1:\\r\\n model = nn.DataParallel(model)\\r\\n \\r\\n params_list = []\\r\\n # train and validate for all epochs\\r\\n for epoch in range(config.EPOCHS):\\r\\n epoch_start_time = time.time()\\r\\n\\r\\n ###----Train--------\\r\\n train_outputs, train_labels, train_loss = engine.train_fn(train_it, model, optimizer, device)\\r\\n train_outputs = torch.Tensor(train_outputs)\\r\\n _, train_predicted = torch.max(train_outputs, dim=1)\\r\\n train_parameters_dict = metrics_func.performance_evaluation_func(train_predicted,train_labels,epoch=str(epoch))\\r\\n # save train paremeters\\r\\n params_list.append(train_parameters_dict)\\r\\n train_f1 = train_parameters_dict['f1_score_macro']\\r\\n train_prec = train_parameters_dict['precision_macro']\\r\\n train_recall = train_parameters_dict['precision_macro']\\r\\n print('\\\\n')\\r\\n print(f\\\" Train Epoch: {epoch}, F1 = {train_f1},precision = {train_prec},recall = {train_recall}\\\")\\r\\n ###------------\\r\\n \\r\\n # validate\\r\\n val_outputs, val_labels, valid_loss = engine.evaluate_fn(valid_it, model, device)\\r\\n val_outputs = torch.Tensor(val_outputs)\\r\\n _, val_predicted = torch.max(val_outputs, dim=1) \\r\\n # calculate evaluation paremeters\\r\\n val_parameters_dict = metrics_func.performance_evaluation_func(val_predicted, val_labels, epoch=str(epoch),flag='val')\\r\\n # save evaluation paremeters\\r\\n params_list.append(val_parameters_dict)\\r\\n \\r\\n val_f1 = val_parameters_dict['f1_score_macro']\\r\\n val_prec = val_parameters_dict['precision_macro']\\r\\n val_recall = val_parameters_dict['recall_macro']\\r\\n print(f\\\"Val Epoch: {epoch},F1 = {val_f1},precision = {val_prec}, recall = {val_recall}\\\")\\r\\n \\r\\n ###-------Test-----------------------\\r\\n test_outputs, test_labels, test_loss = engine.evaluate_fn(test_it, model, device)\\r\\n test_outputs = torch.Tensor(test_outputs)\\r\\n _, test_predicted = torch.max(test_outputs, dim=1) \\r\\n # calculate evaluation paremeters\\r\\n test_parameters_dict = metrics_func.performance_evaluation_func(test_predicted, test_labels, epoch=str(epoch),flag='test')\\r\\n # save evaluation paremeters\\r\\n params_list.append(test_parameters_dict)\\r\\n \\r\\n test_f1 = test_parameters_dict['f1_score_macro']\\r\\n test_prec = test_parameters_dict['precision_macro']\\r\\n test_recall = test_parameters_dict['recall_macro']\\r\\n print(f\\\"test Epoch: {epoch},F1 = {test_f1},precision = {test_prec}, recall = {test_recall}\\\")\\r\\n \\r\\n lr_scheduler = LRScheduler(optimizer)\\r\\n lr_scheduler(valid_loss)\\r\\n \\r\\n \\r\\n # simple early stopping\\r\\n# val_f1 = float(val_f1)\\r\\n #f1 = (float(train_f1) + float(val_f1)) / 2\\r\\n val_loss = float(valid_loss)\\r\\n early_stopping(val_loss, model)\\r\\n if early_stopping.early_stop:\\r\\n print(\\\"Early stopping\\\")\\r\\n break\\r\\n # 获得 early stopping 时的模型参数\\r\\n# model.load_state_dict(torch.load('checkpoint.pt'))\\r\\n\\r\\n# save_model_func(model, epoch, path='outputs')\\r\\n \\r\\n metrics_func.save_parameters_txt(params_list)\",\n \"def get_inference_dataset(dataset_path,debug=False):\\n\\n if not os.path.exists(dataset_path):\\n assert False, \\\"Couldn't find path : '{}'\\\".format(dataset_path)\\n print(\\\"\\\\nprocessing data :'{}'\\\\n\\\".format(dataset_path))\\n\\n path = os.getcwd()\\n os.chdir(dataset_path)\\n\\n dataset = []\\n for file in tqdm(os.listdir('.')):\\n if not file.endswith('features'):\\n continue\\n name = file.replace(\\\".features\\\", \\\"\\\") # removing \\\"features\\\"\\n x = np.loadtxt(name + '.features')\\n np.nan_to_num(x, copy=False)\\n #get labels file\\n if os.path.exists(name + '.test.labels'):\\n labels_file = open(name + '.test.labels').readlines()\\n elif os.path.exists(name + '.labels'):\\n labels_file = open(name + '.labels').readlines()\\n else:\\n continue\\n file_info = (name , float(labels_file[-2].split(' ')[-1]),\\n np.fromstring(labels_file[1].strip(), sep=' ')[:2],\\n float(labels_file[2]))#(file name,window_offset,(onset,offset),vot_type)\\n\\n dataset.append([torch.from_numpy(x).float(), file_info])\\n if debug and len(dataset)>100:\\n break\\n os.chdir(path)\\n\\n return DataLoader(dataset,shuffle=False)\",\n \"def create_train_test(option, transform, params, split=0.2):\\r\\n clip_im_dir = option.clip_im_dir\\r\\n matting_dir = option.matting_dir\\r\\n csv_path = option.csv_path\\r\\n \\r\\n print(\\\"create datasets\\\")\\r\\n \\r\\n \\r\\n data_df = pd.read_csv(csv_path)\\r\\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\\r\\n \\r\\n #separate data in training and test data (20/80)\\r\\n train_df, test_df = train_test_split(data_df, test_size=split)\\r\\n \\r\\n #search right Dataset class\\r\\n package_dir = Path(src.dataset.__file__).resolve().parent\\r\\n\\r\\n for (_, module_name, _) in iter_modules([package_dir]):\\r\\n # print(module_name, self.ComType)\\r\\n if option.dataset.lower() == module_name.lower() :\\r\\n modelModule = importlib.import_module(\\\".\\\"+module_name)\\r\\n break\\r\\n \\r\\n # train data\\r\\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\\r\\n train_loader = DataLoader(training_set, **params)\\r\\n \\r\\n \\r\\n #test data\\r\\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\\r\\n test_loader = DataLoader(testing_set, **params)\\r\\n \\r\\n return train_loader, test_loader\",\n \"def test_correct_dataset_found_by_name(self):\\n dataset_name = 'my_unlikely_dataset_name'\\n dataset = factories.SourceDatasetFactory.create(dataset_name=dataset_name)\\n url = self.get_url()\\n response = self.client.get(url, {'q': dataset_name})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(returned_pks, [dataset.i_id])\",\n \"def test_correct_dataset_found_by_name(self):\\n dataset_name = 'my_unlikely_dataset_name'\\n dataset = factories.SourceDatasetFactory.create(dataset_name=dataset_name)\\n url = self.get_url()\\n response = self.client.get(url, {'q': dataset_name})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(returned_pks, [dataset.i_id])\",\n \"def run(dataset = 1):\\n train_list, test_list = load_list(dataset, False)\\n train_imgs = process_list(train_list)\\n test_imgs = process_list(test_list)\\n with open(os.path.join(WORKING_DIR, 'data', 'train' + str(dataset) + '.txt'), 'w') as f:\\n for img in train_imgs:\\n f.write(img)\\n f.write(' ')\\n if img[-14] == 'F':\\n f.write('1')\\n else:\\n f.write('0')\\n f.write('\\\\n')\\n with open(os.path.join(WORKING_DIR, 'data', 'test' + str(dataset) + '.txt'), 'w') as f:\\n for img in test_imgs:\\n f.write(img)\\n f.write(' ')\\n if img[-14] == 'F':\\n f.write('1')\\n else:\\n f.write('0')\\n f.write('\\\\n')\",\n \"def make_dataset():\\n\\n\\tnumberOfTrials = dataset_params.num_of_samples\\n\\tnumberOfTrials_train = int(numberOfTrials*0.8)\\n\\tnumberOfTrials_test = int(numberOfTrials*0.2)\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"1. Generating Train images ......\\\")\\n\\tprint(\\\"\\\\nTrain image per variation\\\", numberOfTrials_train)\\n\\tmakeDataset(numberOfTrials_train, \\\"train\\\")\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"2. Generating Test images ......\\\")\\n\\tprint(\\\"\\\\nTest image per variation\\\", numberOfTrials_test)\\n\\tmakeDataset(numberOfTrials_test, \\\"test\\\")\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"Done!!!\\\")\",\n \"def load_dataset():\\n\\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \\\"r\\\")\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\n\\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \\\"r\\\")\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\n\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\n \\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\n \\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def getDataset(self, train=True):\\n \\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\") \\n \\n if self.dataset == \\\"ELLIPSE\\\":\\n a = np.array([[0,1.0],[1.0,2.0]]) \\n b = a*0.5 \\n myE = el.ellipse(device, 500, 100, a, b) \\n if train == True:\\n return myE.create_dataset(myE.examples)\\n return myE.create_dataset(myE.valid) \\n \\n if self.dataset == \\\"SWISS\\\": \\n myS = sw.SwissRoll(device, 500, 0.2) \\n if train == True:\\n return myS.create_dataset(myS.examples)\\n return myS.create_dataset(myS.valid)\\n \\n \\n #open file\\n myFile = h5py.File(self.dataString, 'r', self.driver)\\n \\n if train == True: \\n inputString = \\\"train_inputs\\\"\\n labelsString = \\\"train_labels\\\"\\n \\n else:\\n inputString = \\\"test_inputs\\\"\\n labelsString = \\\"test_labels\\\"\\n \\n #get hdf5 datsets\\n features = myFile.get(inputString)\\n labels = myFile.get(labelsString)\\n \\n #convert to tensors\\n features = torch.from_numpy(np.array(features))\\n labels = torch.from_numpy(np.array(labels))\\n \\n #close file to ensure dataset is in memory\\n myFile.close()\\n \\n #conver to correct datatypes\\n features = features.float()\\n \\n if self.conv_sg == False:\\n labels = labels.long() \\n \\n dataset = torch.utils.data.TensorDataset(features, labels)\\n \\n return dataset\",\n \"def switch_to_train_data(self) -> None:\\n if self._train_name not in self._datasets:\\n raise ValueError(\\\"Training data not provided.\\\")\\n self.switch_to_dataset(self._train_name)\",\n \"def create_dataset():\\n ds_train_raw, ds_test_raw = load_raw_datasets()\\n vectorize_layer = create_vectorizer(ds_train_raw)\\n ds_train = ds_train_raw.map(\\n lambda text, label: (vectorize_layer(text), label)\\n ).prefetch(tf.data.experimental.AUTOTUNE)\\n ds_test = ds_test_raw.map(\\n lambda text, label: (vectorize_layer(text), label)\\n ).prefetch(tf.data.experimental.AUTOTUNE)\\n return ds_train, ds_test, vectorize_layer\",\n \"def _createDatasets(self, datasetName):\\r\\n\\r\\n # Set the feature vector dtype\\r\\n if self.featureVectorDType == 'str':\\r\\n dt = h5py.special_dtype(vlen=str)\\r\\n else:\\r\\n dt = self.featureVectorDType\\r\\n\\r\\n\\t\\t# Initialize the datasets\\r\\n logger.debug('Creating dataset `{}`.'.format(datasetName))\\r\\n\\r\\n if self.featureVectorSize > 1:\\r\\n self.datasets[datasetName] = self.db.create_dataset(str(datasetName), (self.estNumSamples, self.featureVectorSize), maxshape=(None, self.featureVectorSize), dtype=dt)\\r\\n else:\\r\\n self.datasets[datasetName] = self.db.create_dataset(str(datasetName), (self.estNumSamples,), maxshape=(None,), dtype=dt)\",\n \"def get_dataset(dataset: str, split: str) -> Dataset:\\n if dataset == \\\"imagenet\\\":\\n return _imagenet(split)\\n elif dataset == \\\"imagenet32\\\":\\n return _imagenet32(split)\\n elif dataset == \\\"cifar10\\\":\\n return _cifar10(split)\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def load_data(opt=\\\"mnist\\\"):\\n if opt == \\\"mnist\\\":\\n train, test = tf.keras.datasets.mnist.load_data()\\n \\n x_train, y_train = train\\n x_test, y_test = test\\n \\n x_train = x_train.reshape(x_train.shape[0], 28 * 28)\\n x_test = x_test.reshape(x_test.shape[0], 28 * 28)\\n \\n y_train = y_train.astype(np.int)\\n y_test = y_test.astype(np.int)\\n for i in range(len(y_train)):\\n y_train[i] = 1 if y_train[i] % 2 == 0 else -1\\n for i in range(len(y_test)):\\n y_test[i] = 1 if y_test[i] % 2 == 0 else -1\\n\\n elif opt == \\\"covertype\\\":\\n df = pd.read_csv(\\\"covtype.data\\\", header=None)\\n x = df.iloc[:, 0:54].values\\n y = df[54].values\\n for i in range(len(y)):\\n y[i] = 1 if y[i] % 2 == 0 else -1\\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\\n \\n else:\\n logging.error(\\\"Unknown dataset!!\\\")\\n\\n logging.info(\\\"train data shape: {}\\\".format(x_train.shape))\\n logging.info(\\\"test data shape: {}\\\".format(x_test.shape))\\n return (x_train, y_train), (x_test, y_test)\",\n \"def create_dataset(project, dataset_name):\\n dataset = dataset_name\\n get_dataset = project.datasets.get(dataset_name=dataset)\\n project.datasets.create(dataset_name=dataset_name)\\n \\n return get_dataset\",\n \"def dataset(request):\\n X, y = make_classification(\\n n_samples=700, n_features=10, n_informative=8, n_redundant=2,\\n n_classes=2, n_clusters_per_class=2, random_state=6483\\n )\\n\\n request.cls.dataset = Dataset(X, y)\",\n \"def prepare_dataset(dataset_name='MNIST', data_path='data', val_size=0.1,\\n task_pairs=[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)],\\n truncate_size=None,\\n train_transform=None,\\n val_transform=None,\\n test_transform=None):\\n if dataset_name == 'MNIST':\\n dataset_class = datasets.MNIST\\n elif dataset_name == 'Fashion-MNIST':\\n dataset_class = datasets.FashionMNIST\\n elif dataset_name == 'KMNIST':\\n dataset_class = datasets.KMNIST\\n elif dataset_name == 'CIFAR10':\\n dataset_class = datasets.CIFAR10\\n elif dataset_name == '_CPU_224': # for imitating 224x224 data\\n tasked_train = _CPUDataset(in_ch=3, height=224)\\n tasked_val = _CPUDataset(in_ch=3, height=224)\\n tasked_test = _CPUDataset(in_ch=3, height=224)\\n return tasked_train, tasked_val, tasked_test\\n else:\\n raise NotImplementedError\\n\\n data_train = dataset_class(root=data_path, train=True,\\n download=True)\\n\\n X, y = data_train.data / 255., data_train.targets\\n if dataset_name == 'CIFAR10':\\n X = torch.FloatTensor(X).permute(0, 3, 1, 2)\\n y = torch.LongTensor(y)\\n\\n X_train, X_val, y_train, y_val = train_test_split(\\n X, y, test_size=val_size, stratify=y, random_state=42)\\n\\n tasked_train = TaskedDataset(X_train, y_train,\\n all_tasks=task_pairs,\\n truncate_size=truncate_size,\\n transform=train_transform)\\n tasked_val = TaskedDataset(X_val, y_val,\\n all_tasks=task_pairs,\\n truncate_size=truncate_size,\\n transform=val_transform)\\n\\n data_test = dataset_class(root=data_path, train=False,\\n download=True)\\n X_test, y_test = data_test.data / 255., data_test.targets\\n if dataset_name == 'CIFAR10':\\n X_test = torch.FloatTensor(X_test).permute(0, 3, 1, 2)\\n y_test = torch.LongTensor(y_test)\\n\\n tasked_test = TaskedDataset(X_test, y_test,\\n all_tasks=task_pairs,\\n truncate_size=truncate_size,\\n transform=test_transform)\\n\\n return tasked_train, tasked_val, tasked_test\",\n \"def load(dataset_name='processed_500maxnode'):\\n # data_dir = os.path.join('../data/modelnet40_ply_hdf5_2048')\\n # assert os.path.exists(data_dir)\\n\\n processed_data_dir = os.path.join(DATA_DIR, dataset_name)\\n if not os.path.exists(processed_data_dir):\\n os.makedirs(processed_data_dir)\\n\\n if len(os.listdir(processed_data_dir)) != 0:\\n\\n # print(\\\"Loading Saved Data from Disk.......\\\")\\n\\n \\\"\\\"\\\" pre-defined location for saving the train and test data\\\"\\\"\\\"\\n train_dir = os.path.join(processed_data_dir, 'train')\\n test_dir = os.path.join(processed_data_dir, 'test')\\n\\n train, max_node = load_back_from_disk(data_dir=train_dir, istrain=True)\\n test, max_node_test = load_back_from_disk(data_dir=test_dir, istrain=False)\\n max_node = max(max_node, max_node_test)\\n\\n else:\\n train, test, max_node = featurize(\\n processed_data_dir,\\n shard_size=16)\\n\\n return train, test, max_node\",\n \"def test_full_dataset_from_file(full_dataset):\\n train_dummy = \\\"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\\\"\\n val_dummy = \\\"malesuada. Integer id magna et ipsum cursus vestibulum. Mauris magna.\\\"\\n\\n assert full_dataset.train[0][0] == train_dummy\\n assert full_dataset.train[0][1] == '6'\\n\\n assert full_dataset.val[0][0] == val_dummy\\n assert full_dataset.val[0][1] == '8'\\n\\n assert full_dataset[0][0] == train_dummy\\n assert full_dataset[100][0] == val_dummy\",\n \"def get_train_test(input_dataset,ylabels):\\n train_size = 0.7\\n test_size = 1-train_size\\n stratified_split = StratifiedShuffleSplit(ylabels,test_size=test_size,n_iter=1,random_state=77)\\n\\n for train_indx,test_indx in stratified_split:\\n train = [input_dataset[i] for i in train_indx]\\n train_y = [ylabels[i] for i in train_indx]\\n \\n test = [input_dataset[i] for i in test_indx]\\n test_y = [ylabels[i] for i in test_indx]\\n return train,test,train_y,test_y\",\n \"def load_data_and_labels(filename, dataset_name,is_train):\\n label_count={}\\n parameter_file = \\\"./parameters.json\\\"\\n params = json.loads(open(parameter_file).read())\\n if dataset_name == 'ag_news' or dataset_name == 'dbpedia' or dataset_name == 'sogou_news' or dataset_name == 'amazon_review_full' or dataset_name == 'amazon_review_polarity' :\\n df = pd.read_csv(filename, names=['label', 'title', 'text'], dtype={'title': object,'text': object})\\n selected = ['label', 'title','text','too_short','to_drop']\\n\\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['too_short']= df[selected[2]].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN)\\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN)\\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n # Map the actual labels to one hot labels\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df[selected[2]].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df[selected[2]].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n \\n elif dataset_name == 'yelp_review_full' or dataset_name == 'yelp_review_polarity':\\n df = pd.read_csv(filename, names=['label','text'], dtype={'text': object})\\n selected = ['label','text','too_short','to_drop']\\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['too_short']= df[selected[1]].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n # Map the actual labels to one hot labels\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df['text'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df['text'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n\\n elif dataset_name == 'yahoo_answers':\\n df = pd.read_csv(filename, names=['label', 'title', 'content','answer'], dtype={'title': object,'answer': object,'content': object})\\n selected = ['label', 'title','content','answer','too_short','to_drop'] \\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['temp'] = df[['content','answer']].apply(lambda x: ' '.join(str(v) for v in x), axis=1)\\n df['too_short']= df['temp'].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df['temp'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df['temp'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n\\n return x_raw, y_raw, df, labels\",\n \"def dataset_by_name(name):\\n return _datasets[name.lower()]\",\n \"def get_dataset(dataset_name, split_type, validation_percent=20,\\n batch_size=None, preprocess_fn=None):\\n\\n if split_type == DatasetSplit.TRAIN:\\n split = \\\"train[{}%:]\\\".format(validation_percent)\\n elif split_type == DatasetSplit.VALID:\\n split = \\\"train[:{}%]\\\".format(validation_percent)\\n elif split_type == DatasetSplit.TEST:\\n split = \\\"test\\\"\\n elif split_type == DatasetSplit.TRAIN_FULL:\\n split = \\\"train\\\"\\n else:\\n raise ValueError(\\\"Unknown split_type {}\\\".format(split_type))\\n\\n ds = tfds.load(name=dataset_name, split=split,\\n as_dataset_kwargs={\\\"shuffle_files\\\": False}\\n ).shuffle(1000, seed=17)\\n\\n if split_type in [DatasetSplit.TRAIN, DatasetSplit.TRAIN_FULL]:\\n ds = ds.repeat()\\n\\n ds = ds.map(preprocess_fn, num_parallel_calls=batch_size)\\n\\n return (ds.batch(\\n batch_size, drop_remainder=True).prefetch(tf.data.experimental.AUTOTUNE))\",\n \"def get_dataset_simple(dataset_name,\\n add_valid_to_vocab=False,\\n add_test_to_vocab=False,\\n to_lower_case=True,\\n tok_fn=word_tokenize,\\n **kwargs):\\n loader = get_loader(dataset_name, **kwargs)\\n return get_simple_splits(loader,\\n add_valid_to_vocab=add_valid_to_vocab,\\n add_test_to_vocab=add_test_to_vocab,\\n tok_fn=tok_fn,\\n to_lower_case=to_lower_case)\",\n \"def dataset_name(self):\\n return self.dataset.name\",\n \"def _create_model_and_data(\\n dataset_name: str, use_synthetic_data: bool\\n) -> Tuple[constants.ModelFnType, constants.FederatedDatasetsType,\\n constants.ProcessFnType, constants.SplitDataFnType, str]:\\n if dataset_name == 'emnist':\\n return emnist.create_model_and_data(\\n num_local_epochs=_TRAIN_EPOCHS.value,\\n train_batch_size=_TRAIN_BATCH_SIZE.value,\\n use_synthetic_data=use_synthetic_data)\\n elif dataset_name == 'stackoverflow':\\n return stackoverflow.create_model_and_data(\\n num_local_epochs=_TRAIN_EPOCHS.value,\\n train_batch_size=_TRAIN_BATCH_SIZE.value,\\n use_synthetic_data=use_synthetic_data)\\n elif dataset_name == 'landmark':\\n return landmark.create_model_and_data(\\n num_local_epochs=_TRAIN_EPOCHS.value,\\n train_batch_size=_TRAIN_BATCH_SIZE.value,\\n use_synthetic_data=use_synthetic_data)\\n elif dataset_name == 'ted_multi':\\n return ted_multi.create_model_and_data(\\n num_local_epochs=_TRAIN_EPOCHS.value,\\n train_batch_size=_TRAIN_BATCH_SIZE.value,\\n use_synthetic_data=use_synthetic_data)\\n raise ValueError(f'Accepted dataset names: {constants.DATASET_NAMES}, but '\\n f'found {dataset_name}. Please provide a valid name.')\",\n \"def load_dataset_train():\\n df_train = load_csv_file(\\\"31_train.csv\\\")\\n df_train_target = load_csv_file(\\\"31_target_train.csv\\\")\\n\\n return df_train.values, df_train_target.values\",\n \"def train(self, dataset): \\n self.random_forest.fit(dataset[:,:-1], dataset[:,-1])\",\n \"def train_and_test(self, data):\\n\\n np.random.shuffle(data)\\n datalist = self.unpack_data(data)\\n\\n logger.info('[*] 75-25 partition of datasets ...')\\n\\n markline1 = math.floor(0.75*(len(datalist['features'])))\\n markline2 = math.floor(0.75*len(datalist['labels']))\\n\\n train_features = datalist['features'][:(markline1)]\\n test_features = datalist['features'][(markline1):]\\n \\n train_labels = datalist['labels'][:(markline2)]\\n test_labels = datalist['labels'][(markline2):]\\n\\n logger.info('[*] Training started with 75% Dataset ...')\\n\\n self.knn_model.fit(train_features, train_labels)\\n\\n logger.info('[*] Testing started with 25% Dataset ...')\\n print('\\\\n/---------------Accuracy----------------/') \\n \\n accuracy = self.knn_model.score(train_features, train_labels)\\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\\n\\n if accuracy < 0.40:\\n logger.warning('[-.-!] Thanks for tryin\\\\' but this machine ain\\\\'t learning.')\\n\\n return True\",\n \"def _process_dataset(all_train_img, all_train_label, all_test_img, all_test_label):\\n # Read all training and test images and set the correct path\\n train_files = tf.io.gfile.listdir(all_train_img)\\n test_files = tf.io.gfile.listdir(all_test_img)\\n all_train_class_path = [os.path.join(all_train_img, f) for f in train_files]\\n all_test_img_path = [os.path.join(all_test_img, f) for f in test_files]\\n # Since Labels start at 1, substract -1 for correct indices with starting '0'\\n label_np_test = read_labels_txt(all_test_label) - 1\\n synsets_np_train = read_labels_mat(all_train_label)\\n\\n all_train_img_path = []\\n label_np_train = []\\n for folder in all_train_class_path:\\n img_class_files = tf.io.gfile.listdir(folder)\\n synset = os.path.basename(os.path.normpath(folder))\\n label_train = synsets_np_train.index(synset)\\n for f in img_class_files:\\n all_train_img_path.append(os.path.join(folder, f))\\n label_np_train.append(label_train)\\n\\n # Create the Datasets for training and test images with corresponding labels\\n path_ds_train = tf.data.Dataset.from_tensor_slices((all_train_img_path, label_np_train))\\n img_label_ds_train = path_ds_train.map(_process_image)\\n path_ds_test = tf.data.Dataset.from_tensor_slices((all_test_img_path, label_np_test))\\n img_label_ds_test = path_ds_test.map(_process_image)\\n\\n print(img_label_ds_train)\\n print(img_label_ds_test)\\n\\n # Check an example image if necessary\\n # example, = img_label_ds_test.take(1)\\n for i in range(5):\\n example, = img_label_ds_train.take(1)\\n image, label = example[0], example[1]\\n plt.figure(i)\\n if image.shape[2] == 1:\\n plt.imshow(tf.squeeze(image), cmap='gray')\\n else:\\n plt.imshow(image/255)\\n print(\\\"Label: {}\\\".format(label.numpy()))\\n plt.show()\\n\\n return img_label_ds_train, img_label_ds_test\",\n \"def get_dataset(self, purpose):\\n if purpose == 'train':\\n return self._get_dataset_from_generator(self._get_train_generator)\\n elif purpose == 'validation':\\n return self._get_dataset_from_generator(self._get_validation_generator)\\n elif purpose == 'test':\\n return self._get_dataset_from_generator(self._get_train_generator)\\n else:\\n return ValueError('Purpose should be either \\\\'train\\\\', \\\\'validation\\\\', or \\\\'test\\\\'')\",\n \"def run(dataset_dir,pic_path):\\n if not tf.gfile.Exists(dataset_dir):\\n tf.gfile.MakeDirs(dataset_dir)\\n\\n training_filename = _get_output_filename(dataset_dir, 'train')\\n testing_filename = _get_output_filename(dataset_dir, 'test')\\n\\n if tf.gfile.Exists(training_filename) and tf.gfile.Exists(testing_filename):\\n print('Dataset files already exist. Exiting without re-creating them.')\\n return\\n\\n class_names = os.listdir(pic_path)\\n labels_to_class_names = dict(zip(class_names,range(len(class_names))))\\n \\n picnames=[]\\n for label in class_names:\\n alabel_path=os.path.join(pic_path,label)\\n names=os.listdir(alabel_path)\\n picnames.extend([os.path.join(alabel_path,name) for name in names])\\n random.shuffle(picnames) \\n \\n train_picnames = picnames[:int(0.7*len(picnames))]\\n test_picnames = picnames[int(0.7*len(picnames)):]\\n # First, process the training data:\\n with tf.python_io.TFRecordWriter(training_filename) as tfrecord_writer:\\n offset = 0\\n for name in train_picnames:\\n offset = _add_to_tfrecord(name, tfrecord_writer, labels_to_class_names, offset)\\n\\n # Next, process the testing data:\\n with tf.python_io.TFRecordWriter(testing_filename) as tfrecord_writer:\\n offset = 0\\n for name in test_picnames:\\n offset = _add_to_tfrecord(name, tfrecord_writer, labels_to_class_names, offset)\\n\\n # Finally, write the labels file:\\n labels_to_class_names = dict(zip(labels_to_class_names.values(),labels_to_class_names.keys())) \\n dataset_utils.write_label_file(labels_to_class_names, dataset_dir)\\n with open(os.path.join(dataset_dir,'info.json'),'w') as f:\\n info=json.dumps({'num_class':len(class_names),'num_sample_train':len(train_picnames),'num_sample_test':len(test_picnames)})\\n f.write(info)\\n\\n print('\\\\nFinished converting the dataset in the {}!'.format(pic_path))\\n print('\\\\nThe tfrecord files,info.json and labels file is located in the {}'.format(dataset_dir))\",\n \"def read_data_sets(data_path, fake_data=False, one_hot=False,\\n validation_size=5000, source_url={},\\n augment=False,\\n percentage_train=100.,\\n unbalance=False, unbalance_dict={\\\"percentage\\\": 20, \\\"label1\\\": 0, \\\"label2\\\": 8},\\n ):\\n\\n class DataSets(object):\\n pass\\n\\n data_sets = DataSets()\\n\\n if fake_data:\\n data_sets.train = DataSet([], [], fake_data=True, one_hot=True)\\n data_sets.validation = DataSet([], [], fake_data=True, one_hot=True)\\n data_sets.test = DataSet([], [], fake_data=True, one_hot=True)\\n return data_sets\\n\\n if not source_url: # empty string check\\n if 'fashion' in data_path:\\n source_url = DEFAULT_SOURCE_URL_FASHION\\n else:\\n source_url = DEFAULT_SOURCE_URL_MNIST\\n\\n if 'fashion' in data_path or 'mnist' in data_path: # mnist or fashion\\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\\\\n load_mnist(data_path, validation_size, source_url, one_hot)\\n reshape = True\\n else:\\n train_images, train_labels, val_images, val_labels, test_images, test_labels = \\\\\\n load_medical_data(data_path)\\n reshape = False\\n\\n # add random permutation to train & validation\\n np.random.seed(42)\\n\\n n_train = train_images.shape[0]\\n perm = np.random.permutation(n_train)\\n train_images = train_images[perm]\\n train_labels = train_labels[perm]\\n\\n n_val = val_images.shape[0]\\n perm = np.random.permutation(n_val)\\n val_images = val_images[perm]\\n val_labels = val_labels[perm]\\n\\n # For experiments with data-augmentation\\n if augment:\\n if 'fashion' in data_path: # rotations +-10 and horizontal flips\\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=True)\\n elif 'mnist' in data_path: # rotations +-10\\n augmented_images, augmented_labels = augment_data(train_images, train_labels, hflip=False)\\n train_images = np.concatenate([train_images, np.expand_dims(augmented_images, 3)])\\n train_labels = np.concatenate([train_labels, augmented_labels])\\n # for the medical datasets, you can use the \\\"augment\\\" argument while doing patch extraction\\n\\n # For experiments with limited amount of data\\n if percentage_train != 100.:\\n train_size = int(0.01*percentage_train*train_images.shape[0])\\n Xtrain_images, Xval_images, ytrain, yval = train_test_split(train_images, train_labels, train_size=train_size)\\n train_images = Xtrain_images\\n train_labels = ytrain\\n\\n # For experiments with class-imbalance distribution\\n if unbalance:\\n n_classes = len(np.unique(np.argmax(train_labels, 1)))\\n reduceto = 0.01*unbalance_dict['percentage']\\n label1 = unbalance_dict['label1']\\n label2 = unbalance_dict['label2']\\n\\n pick_ids = []\\n newsize = 0\\n all_classes = np.arange(0, n_classes)\\n all_classes = np.delete(all_classes, np.where(all_classes == label1)[0])\\n all_classes = np.delete(all_classes, np.where(all_classes == label2)[0])\\n\\n for lab in [label1, label2]:\\n allids = np.where(np.argmax(train_labels, 1) == lab)[0]\\n selectedids = np.random.choice(allids, int(reduceto * allids.shape[0]), replace=False)\\n pick_ids.append(selectedids)\\n newsize += len(selectedids)\\n\\n new_ids = convert_list_to_array(pick_ids, newsize)\\n\\n other_ids = []\\n othersize = 0\\n for lab in all_classes.tolist():\\n selectedids = np.where(np.argmax(train_labels, 1) == lab)[0]\\n other_ids.append(selectedids)\\n othersize += len(selectedids)\\n\\n keep_ids = convert_list_to_array(other_ids, othersize)\\n\\n # new_ids: contains the indices of the reduced (imbalance) classes\\n # keep_ids: contains the indices of the rest (keep the same class distribution)\\n resulting_ids = np.concatenate((new_ids, keep_ids))\\n np.random.shuffle(resulting_ids)\\n\\n train_images = train_images[resulting_ids, ...]\\n train_labels = train_labels[resulting_ids, ...]\\n\\n data_sets.train = DataSet(train_images, train_labels, fake_data=True, one_hot=True, reshape=reshape)\\n data_sets.validation = DataSet(val_images, val_labels, fake_data=True, one_hot=True, reshape=reshape)\\n data_sets.test = DataSet(test_images, test_labels, fake_data=True, one_hot=True, reshape=reshape)\\n\\n return data_sets\",\n \"def read_in_and_split_data(iris_data):\\n iris_data = datasets.load_iris()\\n data = iris_data['data']\\n targets = iris_data['target']\\n train_data, test_data, train_targets, test_targets = train_test_split(data, targets, test_size=0.1) \\n return (train_data, test_data, train_targets, test_targets)\",\n \"def test_data_set_load(data_set):\\n data = data_set()\\n train_data, train_labels, test_data, test_labels = data.load_data()\\n\\n assert len(train_data) > 0\\n assert len(test_data) > 0\\n assert len(train_data) == len(train_labels)\\n assert len(test_data) == len(test_labels)\",\n \"def get_dataset(name, *, tfds_data_dir=None, seed=547):\\n\\n kwargs = {}\\n kwargs['tfds_data_dir'] = tfds_data_dir\\n name_prefix = name\\n\\n if name_prefix not in ['lsun', *SimpleDataset.DATASET_NAMES]:\\n kwargs['seed'] = seed\\n\\n if name_prefix not in DATASETS:\\n raise ValueError(\\\"Dataset %s is not available.\\\" % name)\\n\\n return DATASETS[name_prefix](**kwargs)\",\n \"def train(self, dataset, model_dir):\\n raise NotImplementedError\",\n \"def dtrain(directory):\\n return dataset(directory, 'train-images-idx3-ubyte',\\n 'train-labels-idx1-ubyte')\",\n \"def train(self, dataset = \\\"Amazon\\\", top_words=10000):\\n assert dataset in datasets, 'Dataset should be in that list ' + str(datasets)\\n if dataset == 'Amazon':\\n X_train, y_train = load_dataset('dataset/amazonreviews/data', self.nb_lines_amazon)\\n else:\\n (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)\\n raise Exception('Dead code... This should be retest again')\",\n \"def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\\n distribute_training=False):\\n train_set = np.array(train_set)\\n test_set = np.array(test_set)\\n\\n print(\\\"The shape of training set before dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set before dimension reduction is {0}\\\".format(test_set.shape))\\n print('Use distribute training ? >> {0}'.format(distribute_training))\\n reg = linear_model.BayesianRidge()\\n\\n if dimension_reduce:\\n pca = PCA(n_components=128)\\n train_set = pca.fit_transform(train_set)\\n test_set = pca.fit_transform(test_set)\\n\\n print(\\\"The shape of training set after dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set after dimension reduction is {0}\\\".format(test_set.shape))\\n\\n if not distribute_training:\\n reg.fit(train_set, train_label)\\n else:\\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\\n train_label), da.array(test_label)\\n reg.fit(train_set, train_label)\\n\\n predicted_label = reg.predict(test_set)\\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\\n print('The regression model has been persisted...')\\n\\n mkdirs_if_not_exist('./result')\\n\\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\\n\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/%s.csv' % data_name, index=False)\\n print('The result csv file has been generated...')\",\n \"def datasets(self):\\n return [Dataset.ENSEMBL]\",\n \"def load_raw_dataset(name):\\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\\n\\n os.makedirs('downloads', exist_ok=True)\\n path = os.path.join('downloads', name)\\n path_raw = os.path.join(path, 'raw')\\n\\n if name == 'iris':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'iris.data'), names=['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid', 'species'])\\n\\n elif name == 'wine':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'wine.data'), names=['class',\\n 'alcohol',\\n 'malic_acid',\\n 'ash',\\n 'alkalinity',\\n 'magnesium',\\n 'phenols',\\n 'flavanoids',\\n 'nonflavanoid_phenols',\\n 'proanthocyanins',\\n 'color_intensity',\\n 'hue',\\n 'dilution',\\n 'proline'])\\n\\n elif name == 'titanic':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path_raw)) == 0:\\n kaggle.api.competition_download_files('titanic', path_raw)\\n titanic = pd.read_csv(os.path.join(path_raw, 'train.csv'))\\n titanic_test = pd.read_csv(os.path.join(path_raw, 'test.csv'))\\n return titanic, titanic_test\\n\\n elif name == 'lanl':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path)) == 0:\\n kaggle.api.competition_download_files('LANL-Earthquake-Prediction', path_raw)\\n if not os.path.exists(os.path.join(path_raw, 'test')):\\n zip_ref = zipfile.ZipFile(os.path.join(path_raw, 'test.zip'), 'r')\\n zip_ref.extractall(os.path.join(path_raw, 'test'))\\n zip_ref.close()\\n return pd.read_csv(os.path.join(path_raw, 'train.csv.zip'))\\n\\n elif name == 'MNIST':\\n mnist = torchvision.datasets.MNIST('downloads', train=True, download=True)\\n mnist_test = torchvision.datasets.MNIST('downloads', train=False, download=True)\\n return mnist, mnist_test\\n\\n elif name == 'FashionMNIST':\\n fmnist = torchvision.datasets.FashionMNIST('downloads', train=True, download=True)\\n fmnist_test = torchvision.datasets.FashionMNIST('downloads', train=False, download=True)\\n return fmnist, fmnist_test\",\n \"def load_data_fashion_mnist(batch_size, resize=None): #@save\\n (x_train, y_train), (x_test,y_test) = tf.keras.datasets.fashion_mnist.load_data()\\n x_train,x_test = x_train/255, x_test/255\\n print(y_train.shape)\\n # Divide all numbers by 255 so that all pixel values are between\\n # 0 and 1, add a batch dimension at the last. And cast label to int32\\n train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\\n test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))\\n train_dataset = train_dataset.shuffle(1000).batch(batch_size)\\n test_dataset = test_dataset.batch(batch_size)\\n return train_dataset,test_dataset\",\n \"def load_train_data(batch_size,\\n data_path='',\\n dataset_name='cifar10',\\n n_data=50000,\\n randomize_labels=False):\\n if not data_path:\\n train_dataset = tfds.load(\\n name=dataset_name, split='train', as_supervised=True)\\n else:\\n if 'tiny' in data_path:\\n train_dataset = tfds.load(\\n name=dataset_name, split='train[:6%]', as_supervised=True)\\n elif 'half' in data_path:\\n train_dataset = tfds.load(\\n name=dataset_name, split='train[:50%]', as_supervised=True)\\n else:\\n train_dataset = tfds.load(\\n name=dataset_name, split='train[:25%]', as_supervised=True)\\n\\n if randomize_labels:\\n all_labels = []\\n all_images = []\\n for images, labels in train_dataset:\\n all_labels.extend([labels.numpy()])\\n all_images.append(images.numpy()[np.newaxis, :, :, :])\\n all_images = np.vstack(all_images)\\n np.random.seed(FLAGS.copy)\\n np.random.shuffle(all_labels)\\n train_dataset = tf.data.Dataset.from_tensor_slices(\\n (tf.convert_to_tensor(all_images, dtype=tf.float32),\\n tf.convert_to_tensor(all_labels, dtype=tf.int64)))\\n\\n train_dataset = train_dataset.shuffle(buffer_size=n_data)\\n train_dataset = train_dataset.map(\\n functools.partial(preprocess_data, is_training=True),\\n num_parallel_calls=tf.data.AUTOTUNE)\\n train_dataset = train_dataset.batch(batch_size, drop_remainder=True)\\n train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)\\n return train_dataset\",\n \"def test_train_dataset(self):\\n classifiers, estimates =\\\\\\n ada_boost.train_dataset(self.larger_matrix,\\n self.larger_class_labels,\\n 9)\\n expected = [\\n {'alpha': 0.6931471805599453,\\n 'dim': 0,\\n 'inequal': 'lt',\\n 'threshold': 1.3},\\n {'alpha': 0.9729550745276565,\\n 'dim': 1,\\n 'inequal': 'lt',\\n 'threshold': 1.0},\\n {'alpha': 0.8958797346140273,\\n 'dim': 0,\\n 'inequal': 'lt',\\n 'threshold': 0.90000000000000002}\\n ]\\n self.assertEqual(classifiers, expected)\",\n \"def create_1st_dataset_rtacltest1(driver, dataset_name):\\n assert wait_on_element(driver, 5, '//tr[contains(.,\\\"tank\\\")]//mat-icon[text()=\\\"more_vert\\\"]', 'clickable')\\n driver.find_element_by_xpath('//tr[contains(.,\\\"tank\\\")]//mat-icon[text()=\\\"more_vert\\\"]').click()\\n assert wait_on_element(driver, 4, '//button[normalize-space(text())=\\\"Add Dataset\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[normalize-space(text())=\\\"Add Dataset\\\"]').click() \\n assert wait_on_element(driver, 5, '//h3[text()=\\\"Add Dataset\\\"]')\\n assert wait_on_element(driver, 5, '//input[@ix-auto=\\\"input__Name\\\"]', 'inputable')\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').clear()\\n driver.find_element_by_xpath('//input[@ix-auto=\\\"input__Name\\\"]').send_keys(dataset_name)\\n assert wait_on_element(driver, 5, '//mat-select[@ix-auto=\\\"select__Share Type\\\"]')\\n driver.find_element_by_xpath('//mat-select[@ix-auto=\\\"select__Share Type\\\"]').click()\\n assert wait_on_element(driver, 5, '//mat-option[@ix-auto=\\\"option__Share Type_SMB\\\"]', 'clickable')\\n driver.find_element_by_xpath('//mat-option[@ix-auto=\\\"option__Share Type_SMB\\\"]').click()\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SAVE\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SAVE\\\"]').click()\",\n \"def load_mnist(dataset_name='mnist', **kwargs):\\n dataset_name = dataset_name.strip().lower().replace('minist', 'mnist')\\n\\n if dataset_name.lower() not in ['mnist', 'fashion-mnist']:\\n raise ValueError('Only mnist or fashion-mnist are valid dataset_name.')\\n\\n base = 'http://yann.lecun.com/exdb/mnist/'\\n if dataset_name == 'fashion-mnist':\\n base = 'http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/'\\n\\n dirname = os.path.join(_trident_dir, dataset_name)\\n make_dir_if_need(dirname)\\n\\n \\\"\\\"\\\"Load MNIST data from `path`\\\"\\\"\\\"\\n trainData = None\\n testData = None\\n for kind in ['train', 'test']:\\n labels_file = '{0}-labels-idx1-ubyte.gz'.format( 't10k' if dataset_name in ('mnist', 'fashion-mnist') and kind == 'test' else kind)\\n images_file = '{0}-images-idx3-ubyte.gz'.format( 't10k' if dataset_name in ('mnist', 'fashion-mnist') and kind == 'test' else kind)\\n # if dataset_name == 'emnist' :\\n # labels_file='emnist-balanced-'+labels_file\\n # images_file = 'emnist-balanced-' + images_file\\n\\n is_data_download = download_file(base + labels_file, dirname, labels_file, dataset_name + '_labels_{0}'.format(kind))\\n is_label_download = download_file(base + images_file, dirname, images_file, dataset_name + '_images_{0}'.format(kind))\\n if is_data_download and is_label_download:\\n labels_path = os.path.join(dirname, labels_file)\\n images_path = os.path.join(dirname, images_file)\\n labeldata = None\\n imagedata = None\\n with gzip.open(labels_path, 'rb') as lbpath:\\n labels = np.frombuffer(lbpath.read(), dtype=np.uint8, offset=8)\\n labels = np.squeeze(labels).astype(np.int64)\\n labeldata = LabelDataset(labels.tolist(),object_type=ObjectType.classification_label)\\n\\n with gzip.open(images_path, 'rb') as imgpath:\\n images = np.frombuffer(imgpath.read(), dtype=np.uint8, offset=16)\\n images = np.reshape(images, (len(labels), 784)).astype(dtype=_session.floatx)\\n images = np.reshape(images, (-1, 28, 28))\\n imagedata = ImageDataset(images, object_type=ObjectType.gray)\\n if kind == 'train':\\n trainData = Iterator(data=imagedata, label=labeldata)\\n else:\\n testData = Iterator(data=imagedata, label=labeldata)\\n\\n dataset = DataProvider(dataset_name, traindata=trainData, testdata=testData)\\n dataset.binding_class_names(\\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] if dataset_name == 'mnist' else ['T-shirt/top', 'Trouser', 'Pullover',\\n 'Dress', 'Coat', 'Sandal', 'Shirt',\\n 'Sneaker', 'Bag', 'Ankle boot'],\\n 'en-US')\\n\\n return dataset\\n return None\",\n \"def pre_train_person(self, dataset, **kwargs):\\n \\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7228631","0.70241654","0.70175004","0.70087993","0.6977617","0.6900802","0.68130064","0.6774054","0.67727417","0.67533123","0.673811","0.67380196","0.6732079","0.6708","0.6619651","0.6580174","0.65409255","0.6507022","0.6495979","0.6469288","0.64399636","0.6430534","0.64198136","0.6419272","0.6416908","0.6404549","0.63958627","0.63842446","0.63745505","0.63723415","0.6369405","0.6360896","0.63607216","0.63385123","0.633764","0.6328929","0.63232565","0.63232565","0.63170505","0.6307923","0.6306626","0.6287282","0.6270653","0.6254663","0.62469196","0.6246451","0.6234785","0.6231411","0.6227634","0.6215897","0.6214375","0.6210371","0.62052965","0.6203223","0.6201904","0.61985683","0.61985683","0.6195917","0.6180638","0.6179708","0.6179627","0.6179395","0.6175689","0.617264","0.61643606","0.6160177","0.61552984","0.6154384","0.6154202","0.61435753","0.6137506","0.6116254","0.6111997","0.6106134","0.6105421","0.60960424","0.6092703","0.6087021","0.60828525","0.60823953","0.6081129","0.607478","0.6070845","0.60668796","0.6063693","0.60625696","0.60612506","0.6053987","0.6053173","0.6053117","0.6049725","0.6049355","0.6046537","0.60406405","0.60377705","0.60265386","0.6025807","0.6014338","0.6013667","0.60114014","0.60061955"],"string":"[\n \"0.7228631\",\n \"0.70241654\",\n \"0.70175004\",\n \"0.70087993\",\n \"0.6977617\",\n \"0.6900802\",\n \"0.68130064\",\n \"0.6774054\",\n \"0.67727417\",\n \"0.67533123\",\n \"0.673811\",\n \"0.67380196\",\n \"0.6732079\",\n \"0.6708\",\n \"0.6619651\",\n \"0.6580174\",\n \"0.65409255\",\n \"0.6507022\",\n \"0.6495979\",\n \"0.6469288\",\n \"0.64399636\",\n \"0.6430534\",\n \"0.64198136\",\n \"0.6419272\",\n \"0.6416908\",\n \"0.6404549\",\n \"0.63958627\",\n \"0.63842446\",\n \"0.63745505\",\n \"0.63723415\",\n \"0.6369405\",\n \"0.6360896\",\n \"0.63607216\",\n \"0.63385123\",\n \"0.633764\",\n \"0.6328929\",\n \"0.63232565\",\n \"0.63232565\",\n \"0.63170505\",\n \"0.6307923\",\n \"0.6306626\",\n \"0.6287282\",\n \"0.6270653\",\n \"0.6254663\",\n \"0.62469196\",\n \"0.6246451\",\n \"0.6234785\",\n \"0.6231411\",\n \"0.6227634\",\n \"0.6215897\",\n \"0.6214375\",\n \"0.6210371\",\n \"0.62052965\",\n \"0.6203223\",\n \"0.6201904\",\n \"0.61985683\",\n \"0.61985683\",\n \"0.6195917\",\n \"0.6180638\",\n \"0.6179708\",\n \"0.6179627\",\n \"0.6179395\",\n \"0.6175689\",\n \"0.617264\",\n \"0.61643606\",\n \"0.6160177\",\n \"0.61552984\",\n \"0.6154384\",\n \"0.6154202\",\n \"0.61435753\",\n \"0.6137506\",\n \"0.6116254\",\n \"0.6111997\",\n \"0.6106134\",\n \"0.6105421\",\n \"0.60960424\",\n \"0.6092703\",\n \"0.6087021\",\n \"0.60828525\",\n \"0.60823953\",\n \"0.6081129\",\n \"0.607478\",\n \"0.6070845\",\n \"0.60668796\",\n \"0.6063693\",\n \"0.60625696\",\n \"0.60612506\",\n \"0.6053987\",\n \"0.6053173\",\n \"0.6053117\",\n \"0.6049725\",\n \"0.6049355\",\n \"0.6046537\",\n \"0.60406405\",\n \"0.60377705\",\n \"0.60265386\",\n \"0.6025807\",\n \"0.6014338\",\n \"0.6013667\",\n \"0.60114014\",\n \"0.60061955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":577,"cells":{"query":{"kind":"string","value":"Return the number of dimension of the state space"},"document":{"kind":"string","value":"def getStatesDim(self):\n return 2"},"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 state_space_dimension(cls) -> int:\n return 1","def n_dim(self):\n return self._n_dim","def num_dim(self):\n return len(self._dimensions)","def num_dim(self):\n return len(self._dimensions)","def _get_observation_dimension(self):\n return len(self._get_observation_np())","def dimension(self):\n return self.__N","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def _get_state_sizes(self):\n ds = self.builder.nodes[self.ds_inputs[0]]\n return [[ds.xdim]]","def dimensionality(self):\n return int(self.nDims)","def dim(self) -> int:\n return self._n_dim","def dimension_count(self):\n return self._dimensionCount","def getNumDimensions(self):\n return len(self.di.keys())","def dim(self):\n return len(self._n)","def dim(self):\n return len(self.shape)","def dim(self):\n return len(self.shape)","def n_dims(self):\n return len(self.dimensions)","def dimension(self):\n return 3*self.genus - 3 + self.n","def dim(self) -> int:","def size(self):\n\t\treturn self.dims","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def num_dims(self):\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]","def state_size(self):\n # estimated state, its covariance, and the step number\n return [[self.dim_x], [self.dim_x * self.dim_x], [1]]","def dims(self):\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)","def dim(self) -> int:\n pass","def get_dimension_length(self):\n pass","def _get_ndim(self):\n return len(self.level_shapes[0])","def count_dims(da):\n return len(da.dims)","def dim(self) -> int:\n return self.atoms.shape[:-1]","def state_size(self):\n\t\treturn (\n\t\t\ttf.TensorShape([self.args[\"kb_node_max_len\"], self.args[\"mp_state_width\"]]),\n\t\t)","def state_size(self):\n return [tf.TensorShape([self.dmodel]),tf.TensorShape([self.dmodel]),tf.TensorShape([self.dmodel])]","def dimension_size(self):\n return self._dim","def dim(self):\n return self.ambient_dim() - self.n_equations()","def dimensions():","def dim(self):\n\t\treturn self.D","def get_dimension_number(self) -> int:\n return np.squeeze(self._channel_arrays[0]).ndim","def dim(self):\n return self.__dim__","def __len__(self):\n return self.n_node.shape[0]","def state_size(self):\n raise NotImplementedError(\"Please implement this method\")","def n_dims(self):\n return self.pdm.n_dims","def N(self):\n return self._dimensions","def dimension(self):\n\t\treturn self.d","def dimension(self):\n return self._dim","def getDimension(self):\n return len(self.components)","def dim(self):\n return self._dim","def dimensionality(self):\n if self.vector.shape is ():\n return 0\n if len(self.vector.shape) is 1:\n return 1\n _, dim = self.vector.shape\n return dim","def dim(self):\n return self._d","def xdim(self):\n return len(self._x)","def ndims(x):\n return len(x.get_shape())","def __len__(self) -> int:\n\n return self.layout.gaDims","def dims(x):\n return len(x.shape)","def dim(self):\n return self.m, self.n","def get_in_dim(self) -> int:\n return self.in_dim","def get_input_dim(self) -> int:\n raise NotImplementedError","def ndim(self):\n if self._ndim is None:\n self._ndim = self.get_mesh_dimension()\n\n return self._ndim","def num_dimensions(self):\n if self.__num_dimensions__ == 0:\n # Try to get the number of dimensions from the first point or bounding box\n if len(self.points) > 0:\n self.__num_dimensions__ = len(self.points[0].coordinate)\n elif len(self.bounding_boxes) > 0:\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\n return self.__num_dimensions__","def get_dims(self):\n row_lbl, col_lbl = self.get_idxvals()\n return len(row_lbl), len(col_lbl)","def dimension(self):","def ndim(self):\n return self.initial_value.ndim","def dimension(self):\n return np.prod(np.asarray(self.subsystem_dims))","def ndim(self):\n # type: () -> int\n return len(self.shape)","def outdim(self):\n return len(self.getSensors())","def get_dim(self, name):\n return len(self.root_group.dimensions[name])","def ndim(self):\n return len(self._shape)","def get_num_states(self):\n return self.n_states","def dim(self):\n return (self.n, )","def width(self) -> int:\n return self._obj[self.x_dim].size","def __len__(self):\n i = 0\n for S in self.states():\n i += 1\n return i","def dimensions(self) -> int:\n return pulumi.get(self, \"dimensions\")","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def ndim(self):\n return len(self.shape)","def n_dims(self):\n return self.model.template_instance.n_dims","def ndim(self):\n return self._ndim","def ndim(self):\n return self.__value.ndim","def get_dim(self):\n return self.dim","def get_dim(self):\n return self._dim","def size(self)->int:\n\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])","def get_dimensionality(self) -> int:\n return self.dimensionality","def get_dimensionality(p_state, idx_image=-1, idx_chain=-1):\n return int(_Get_Dimensionality(ctypes.c_void_p(p_state), ctypes.c_int(idx_image), ctypes.c_int(idx_chain)))","def ndim(self):\n return len(self.nvars)","def feature_dim(self):\n raise NotImplementedError","def dimension(self) -> float:\n return self._dimensions","def ndim(self):\n\n self._check_assigned()\n\n if (\n self.lazy\n and self.transformer is not None\n and hasattr(self.transformer, \"get_transformed_shape\")\n ):\n return len(self.transformer.get_transformed_shape(self.values))\n else:\n return self.__array__().ndim","def get_ndim(self):\n return self.ndim","def dim(self):\n if self._classifier is None:\n with self:\n return self._classifier.features_dim\n\n return self._classifier.features_dim","def __len__(self):\n return self.N.shape[0]","def get_state_shape(s):\n c = _concat(batch_size, s)\n c_static = _concat(batch_size, s, static=True)\n size = array_ops.zeros(c, dtype=dtype)\n size.set_shape(c_static)\n return size","def _cell_state_size(self):\n state_sizes = self._cells[0].state_size\n if isinstance(state_sizes, tuple):\n return sum(state_sizes)\n return state_sizes","def dim(self):\n if '_dim' in self.__dict__:\n return self._dim\n\n if len(self._Vrepresentation)==0:\n self._dim = -1\n return self._dim\n\n origin = vector(self._Vrepresentation[0])\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\n self._dim = matrix(v_list).rank()\n return self._dim","def ndim(self):\n return self.X.ndim","def dim(self):\n raise NotImplementedError","def dim(self):\n return self.raw_wires.get_dim();","def dim(self) -> tuple:\n if self.has_tensor(): return self.as_tensor().dim()\n else:\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]","def size(self):\n return self.states.size() * self.n_pop","def _getdim(x):\n \n if np.ndim(x) > 1:\n \n dim = x.shape[-1]\n \n else:\n \n dim = 0\n \n return dim","def size(self) -> tf.Tensor:","def get_feature_space_dimensionality(self):\n return self.nextIdPruned"],"string":"[\n \"def state_space_dimension(cls) -> int:\\n return 1\",\n \"def n_dim(self):\\n return self._n_dim\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def _get_observation_dimension(self):\\n return len(self._get_observation_np())\",\n \"def dimension(self):\\n return self.__N\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def _get_state_sizes(self):\\n ds = self.builder.nodes[self.ds_inputs[0]]\\n return [[ds.xdim]]\",\n \"def dimensionality(self):\\n return int(self.nDims)\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def dim(self):\\n return len(self._n)\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def dim(self):\\n return len(self.shape)\",\n \"def n_dims(self):\\n return len(self.dimensions)\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def dim(self) -> int:\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def num_dims(self):\\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]\",\n \"def state_size(self):\\n # estimated state, its covariance, and the step number\\n return [[self.dim_x], [self.dim_x * self.dim_x], [1]]\",\n \"def dims(self):\\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)\",\n \"def dim(self) -> int:\\n pass\",\n \"def get_dimension_length(self):\\n pass\",\n \"def _get_ndim(self):\\n return len(self.level_shapes[0])\",\n \"def count_dims(da):\\n return len(da.dims)\",\n \"def dim(self) -> int:\\n return self.atoms.shape[:-1]\",\n \"def state_size(self):\\n\\t\\treturn (\\n\\t\\t\\ttf.TensorShape([self.args[\\\"kb_node_max_len\\\"], self.args[\\\"mp_state_width\\\"]]),\\n\\t\\t)\",\n \"def state_size(self):\\n return [tf.TensorShape([self.dmodel]),tf.TensorShape([self.dmodel]),tf.TensorShape([self.dmodel])]\",\n \"def dimension_size(self):\\n return self._dim\",\n \"def dim(self):\\n return self.ambient_dim() - self.n_equations()\",\n \"def dimensions():\",\n \"def dim(self):\\n\\t\\treturn self.D\",\n \"def get_dimension_number(self) -> int:\\n return np.squeeze(self._channel_arrays[0]).ndim\",\n \"def dim(self):\\n return self.__dim__\",\n \"def __len__(self):\\n return self.n_node.shape[0]\",\n \"def state_size(self):\\n raise NotImplementedError(\\\"Please implement this method\\\")\",\n \"def n_dims(self):\\n return self.pdm.n_dims\",\n \"def N(self):\\n return self._dimensions\",\n \"def dimension(self):\\n\\t\\treturn self.d\",\n \"def dimension(self):\\n return self._dim\",\n \"def getDimension(self):\\n return len(self.components)\",\n \"def dim(self):\\n return self._dim\",\n \"def dimensionality(self):\\n if self.vector.shape is ():\\n return 0\\n if len(self.vector.shape) is 1:\\n return 1\\n _, dim = self.vector.shape\\n return dim\",\n \"def dim(self):\\n return self._d\",\n \"def xdim(self):\\n return len(self._x)\",\n \"def ndims(x):\\n return len(x.get_shape())\",\n \"def __len__(self) -> int:\\n\\n return self.layout.gaDims\",\n \"def dims(x):\\n return len(x.shape)\",\n \"def dim(self):\\n return self.m, self.n\",\n \"def get_in_dim(self) -> int:\\n return self.in_dim\",\n \"def get_input_dim(self) -> int:\\n raise NotImplementedError\",\n \"def ndim(self):\\n if self._ndim is None:\\n self._ndim = self.get_mesh_dimension()\\n\\n return self._ndim\",\n \"def num_dimensions(self):\\n if self.__num_dimensions__ == 0:\\n # Try to get the number of dimensions from the first point or bounding box\\n if len(self.points) > 0:\\n self.__num_dimensions__ = len(self.points[0].coordinate)\\n elif len(self.bounding_boxes) > 0:\\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\\n return self.__num_dimensions__\",\n \"def get_dims(self):\\n row_lbl, col_lbl = self.get_idxvals()\\n return len(row_lbl), len(col_lbl)\",\n \"def dimension(self):\",\n \"def ndim(self):\\n return self.initial_value.ndim\",\n \"def dimension(self):\\n return np.prod(np.asarray(self.subsystem_dims))\",\n \"def ndim(self):\\n # type: () -> int\\n return len(self.shape)\",\n \"def outdim(self):\\n return len(self.getSensors())\",\n \"def get_dim(self, name):\\n return len(self.root_group.dimensions[name])\",\n \"def ndim(self):\\n return len(self._shape)\",\n \"def get_num_states(self):\\n return self.n_states\",\n \"def dim(self):\\n return (self.n, )\",\n \"def width(self) -> int:\\n return self._obj[self.x_dim].size\",\n \"def __len__(self):\\n i = 0\\n for S in self.states():\\n i += 1\\n return i\",\n \"def dimensions(self) -> int:\\n return pulumi.get(self, \\\"dimensions\\\")\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def ndim(self):\\n return len(self.shape)\",\n \"def n_dims(self):\\n return self.model.template_instance.n_dims\",\n \"def ndim(self):\\n return self._ndim\",\n \"def ndim(self):\\n return self.__value.ndim\",\n \"def get_dim(self):\\n return self.dim\",\n \"def get_dim(self):\\n return self._dim\",\n \"def size(self)->int:\\n\\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])\",\n \"def get_dimensionality(self) -> int:\\n return self.dimensionality\",\n \"def get_dimensionality(p_state, idx_image=-1, idx_chain=-1):\\n return int(_Get_Dimensionality(ctypes.c_void_p(p_state), ctypes.c_int(idx_image), ctypes.c_int(idx_chain)))\",\n \"def ndim(self):\\n return len(self.nvars)\",\n \"def feature_dim(self):\\n raise NotImplementedError\",\n \"def dimension(self) -> float:\\n return self._dimensions\",\n \"def ndim(self):\\n\\n self._check_assigned()\\n\\n if (\\n self.lazy\\n and self.transformer is not None\\n and hasattr(self.transformer, \\\"get_transformed_shape\\\")\\n ):\\n return len(self.transformer.get_transformed_shape(self.values))\\n else:\\n return self.__array__().ndim\",\n \"def get_ndim(self):\\n return self.ndim\",\n \"def dim(self):\\n if self._classifier is None:\\n with self:\\n return self._classifier.features_dim\\n\\n return self._classifier.features_dim\",\n \"def __len__(self):\\n return self.N.shape[0]\",\n \"def get_state_shape(s):\\n c = _concat(batch_size, s)\\n c_static = _concat(batch_size, s, static=True)\\n size = array_ops.zeros(c, dtype=dtype)\\n size.set_shape(c_static)\\n return size\",\n \"def _cell_state_size(self):\\n state_sizes = self._cells[0].state_size\\n if isinstance(state_sizes, tuple):\\n return sum(state_sizes)\\n return state_sizes\",\n \"def dim(self):\\n if '_dim' in self.__dict__:\\n return self._dim\\n\\n if len(self._Vrepresentation)==0:\\n self._dim = -1\\n return self._dim\\n\\n origin = vector(self._Vrepresentation[0])\\n v_list = [ vector(v)-origin for v in self._Vrepresentation ]\\n self._dim = matrix(v_list).rank()\\n return self._dim\",\n \"def ndim(self):\\n return self.X.ndim\",\n \"def dim(self):\\n raise NotImplementedError\",\n \"def dim(self):\\n return self.raw_wires.get_dim();\",\n \"def dim(self) -> tuple:\\n if self.has_tensor(): return self.as_tensor().dim()\\n else:\\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]\",\n \"def size(self):\\n return self.states.size() * self.n_pop\",\n \"def _getdim(x):\\n \\n if np.ndim(x) > 1:\\n \\n dim = x.shape[-1]\\n \\n else:\\n \\n dim = 0\\n \\n return dim\",\n \"def size(self) -> tf.Tensor:\",\n \"def get_feature_space_dimensionality(self):\\n return self.nextIdPruned\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8514534","0.78174734","0.77158946","0.77158946","0.7706377","0.77037966","0.7664541","0.76440984","0.7634386","0.7625269","0.75904065","0.7558156","0.75198585","0.7480286","0.7480286","0.7450488","0.7439861","0.74317974","0.73826283","0.7376509","0.73712045","0.7370739","0.73465514","0.73365635","0.7335972","0.7334126","0.7321825","0.7308186","0.73076713","0.7290619","0.7282914","0.72461504","0.7243842","0.7237183","0.72207016","0.72107095","0.7208151","0.72081155","0.7201493","0.7191768","0.7183766","0.716048","0.7143834","0.7128026","0.71141374","0.710001","0.709678","0.70957977","0.708807","0.7084486","0.7048741","0.7048713","0.70359087","0.7035587","0.70224994","0.70208913","0.70206594","0.7001931","0.6971935","0.6963771","0.6961245","0.6954344","0.69538075","0.6949346","0.6941698","0.69412374","0.6939988","0.69380224","0.6934311","0.6934311","0.6934311","0.6934311","0.6934311","0.6934311","0.69288534","0.6927563","0.69242656","0.6918362","0.6914071","0.6907923","0.69072217","0.6896279","0.68903255","0.6889704","0.6888225","0.6887559","0.6883262","0.68828845","0.68766767","0.68759376","0.6871423","0.68701273","0.6868932","0.68688583","0.68656844","0.6861184","0.68490976","0.68458575","0.6843749","0.6843482"],"string":"[\n \"0.8514534\",\n \"0.78174734\",\n \"0.77158946\",\n \"0.77158946\",\n \"0.7706377\",\n \"0.77037966\",\n \"0.7664541\",\n \"0.76440984\",\n \"0.7634386\",\n \"0.7625269\",\n \"0.75904065\",\n \"0.7558156\",\n \"0.75198585\",\n \"0.7480286\",\n \"0.7480286\",\n \"0.7450488\",\n \"0.7439861\",\n \"0.74317974\",\n \"0.73826283\",\n \"0.7376509\",\n \"0.73712045\",\n \"0.7370739\",\n \"0.73465514\",\n \"0.73365635\",\n \"0.7335972\",\n \"0.7334126\",\n \"0.7321825\",\n \"0.7308186\",\n \"0.73076713\",\n \"0.7290619\",\n \"0.7282914\",\n \"0.72461504\",\n \"0.7243842\",\n \"0.7237183\",\n \"0.72207016\",\n \"0.72107095\",\n \"0.7208151\",\n \"0.72081155\",\n \"0.7201493\",\n \"0.7191768\",\n \"0.7183766\",\n \"0.716048\",\n \"0.7143834\",\n \"0.7128026\",\n \"0.71141374\",\n \"0.710001\",\n \"0.709678\",\n \"0.70957977\",\n \"0.708807\",\n \"0.7084486\",\n \"0.7048741\",\n \"0.7048713\",\n \"0.70359087\",\n \"0.7035587\",\n \"0.70224994\",\n \"0.70208913\",\n \"0.70206594\",\n \"0.7001931\",\n \"0.6971935\",\n \"0.6963771\",\n \"0.6961245\",\n \"0.6954344\",\n \"0.69538075\",\n \"0.6949346\",\n \"0.6941698\",\n \"0.69412374\",\n \"0.6939988\",\n \"0.69380224\",\n \"0.6934311\",\n \"0.6934311\",\n \"0.6934311\",\n \"0.6934311\",\n \"0.6934311\",\n \"0.6934311\",\n \"0.69288534\",\n \"0.6927563\",\n \"0.69242656\",\n \"0.6918362\",\n \"0.6914071\",\n \"0.6907923\",\n \"0.69072217\",\n \"0.6896279\",\n \"0.68903255\",\n \"0.6889704\",\n \"0.6888225\",\n \"0.6887559\",\n \"0.6883262\",\n \"0.68828845\",\n \"0.68766767\",\n \"0.68759376\",\n \"0.6871423\",\n \"0.68701273\",\n \"0.6868932\",\n \"0.68688583\",\n \"0.68656844\",\n \"0.6861184\",\n \"0.68490976\",\n \"0.68458575\",\n \"0.6843749\",\n \"0.6843482\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76861554"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":578,"cells":{"query":{"kind":"string","value":"Returns the max and min values each dimension can take. These are returned as two tuples, `low` and `high`, where both are a list of as many elements as there is dimension to the state space."},"document":{"kind":"string","value":"def getStatesBounds(self):\n return (0, 0), (self._width - 1, self._height - 1)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def get_minmax(self):\n x_minmax = [np.min(self.grid['x']), np.max(self.grid['x'].max())]\n z_minmax = [np.min(self.grid['z']), np.max(self.grid['z'].max())]\n return x_minmax, z_minmax","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def getMinMax(self,arr):\n # not implemented for Template SED yet\n return arr[\"z\"], arr[\"z\"]","def calculate_min_max_tiles(self):","def getMinMax(self,arr):\n minz=arr['zmg']-arr['sigma_pz']*5\n dmin=self.zcat-5*self.sigmacat\n minz[np.where(minz>dmin)]=dmin\n maxz=arr['zmg']+arr['sigma_pz']*5\n dax=self.zcat+5*self.sigmacat\n maxz[np.where(maxz<dmax)]=dmax\n return dmin,dmax","def range(self):\n lows, highs = [], []\n for graph in self._graphs.values():\n low, high = graph.range()\n lows.append(low)\n highs.append(high)\n return (min(lows), max(highs))","def minMax2(x):\r\n\r\n iMinMax = [0 for i in range(2)]\r\n num = len(x)[0]\r\n\r\n iMin = 0\r\n iMax = 0\r\n\r\n #// Search for minimum and maximum in row 0 - linear values:\r\n min = x[0][iMin]\r\n max = x[0][iMax]\r\n\r\n for i in range(1, num):\r\n\r\n if (x[0][i] < min): \r\n min = x[0][i]\r\n iMin = i\r\n \r\n\r\n if (x[0][i] > max): \r\n max = x[0][i]\r\n iMax = i\r\n \r\n iMinMax[0] = iMin\r\n iMinMax[1] = iMax\r\n\r\n return iMinMax","def min_max(xs):\n return min(xs), max(xs)","def fetchbounds(self):\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\n self.in_end, self.end, self.out_end] \\\n if x is not None]\n return min(pnts), max(pnts)","def limits(self):\n\n\t\treturn [\n\t\t\tmin(self.xvalues),\n\t\t\tmax(self.xvalues),\n\t\t\tmin(self.yvalues),\n\t\t\tmax(self.yvalues)]","def high_and_low(numbers):\n highest = max(numbers)\n lowest = min(numbers)\n return (highest, lowest)","def get_bounds(self):\n x_max = self.data['x'].max()\n y_max = self.data['y'].max()\n z_max = self.data['z'].max()\n print(\"x={}; y={}; z={}\".format(x_max, y_max, z_max))\n return (x_max, y_max, z_max)","def get_min_max(ints):\n current_max = None\n current_min = None\n\n if (len(ints) == 0) or (ints is None):\n return tuple([current_min, current_max])\n\n for i, n in enumerate(ints):\n if i == 0:\n current_max = n\n current_min = n\n else:\n if n > current_max:\n current_max = n\n elif n < current_min:\n current_min = n\n\n return tuple([current_min, current_max])","def high_and_low(numbers):\n highest = max(numbers)\n lowest = min(numbers)\n return (highest,lowest)","def minmax(xs):\n min_val = None\n max_val = None\n for x in xs:\n if min_val is None or x < min_val:\n min_val = x\n if max_val is None or x > max_val:\n max_val = x\n return (min_val, max_val)","def state_limits(self) -> Tuple[torch.Tensor, torch.Tensor]:\n # define upper and lower limits based around the nominal equilibrium input\n upper_limit = torch.ones(self.n_dims)\n upper_limit[TurtleBot2D.X] = 2.0\n upper_limit[TurtleBot2D.Y] = 2.0\n upper_limit[TurtleBot2D.THETA] = 2 * np.pi\n\n lower_limit = -1.0 * upper_limit\n\n return (upper_limit, lower_limit)","def get_minmax(self, stmt, slist):\n minel = maxel = None\n for s in slist:\n if s.keyword == \"min-elements\":\n minel = s.arg\n elif s.keyword == \"max-elements\":\n maxel = s.arg\n if minel is None:\n minst = stmt.search_one(\"min_elements\")\n if minst:\n minel = minst.arg\n else:\n minel = \"0\"\n if maxel is None:\n maxst = stmt.search_one(\"max_elements\")\n if maxst:\n maxel = maxst.arg\n return (minel, maxel)","def _set_min_max_values(self):\n\n p_1, p_2 = self.points[0], self.points[1]\n nb_dim = len(p_1.values)\n self._min_values = []\n self._max_values = []\n for d in range(nb_dim):\n d_min = min(p_1[d], p_2[d])\n d_max = max(p_2[d], p_2[d])\n self._min_values.append(d_min)\n self._max_values.append(d_max)","def get_bounds(self):\n occupied_locations = self.board.keys()\n min_x = min(p[0] for p in occupied_locations)\n max_x = max(p[0] for p in occupied_locations)\n min_y = min(p[1] for p in occupied_locations)\n max_y = max(p[1] for p in occupied_locations)\n return ((min_x, max_x), (min_y, max_y))","def bounds(self):\n\n if self.size == 0:\n lo, hi = np.nan, np.nan\n elif self.is_monotonic:\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\n elif self.dtype is np.datetime64:\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\n else:\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\n\n return lo, hi","def bounds(self):\n return self.min_col, self.min_row, self.max_col, self.max_row","def glGetMinmax( baseFunction, target, reset, format, type, values=None):\r\n if values is None:\r\n width = 2\r\n values = images.images.SetupPixelRead( format, (width,4), type )\r\n arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[\r\n images.images.TYPE_TO_ARRAYTYPE.get(type,type)\r\n ]\r\n baseFunction(\r\n target, reset, format, type,\r\n ctypes.c_void_p( arrayType.dataPointer(values))\r\n )\r\n return values","def get_min_max(ints):\n\n if len(ints) == 0:\n return (None,None)\n min = ints[0]\n max = ints[0]\n for x in range(1,len(ints)):\n if ints[x] > max:\n max=ints[x]\n elif ints[x] < min:\n min = ints[x]\n return (min,max)","def get_physical_bounds(dim):\n dim = basename(dim)\n\n if dim == \"coszen\":\n trunc_low = -1.\n trunc_high = 1.\n\n elif dim == \"energy\":\n trunc_low = 0.\n trunc_high = None\n\n elif dim == \"azimuth\":\n trunc_low = 0.\n trunc_high = 2*np.pi\n\n else:\n raise ValueError(\"No physical bounds for dimension '%s' available.\"%dim)\n\n return trunc_low, trunc_high","def spec_min_max(self):\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\n 2048,2048,2048,2048,2048])\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0])\n return np.vstack((spec_min, spec_max))","def get_min_max(self) -> tuple:\r\n\r\n minimum = float(\"inf\")\r\n maximum = float(\"-inf\")\r\n\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n for name, data in self.trees_data.items():\r\n if self.trees[name][\"point_helper\"] is None:\r\n mapping = self.trees[name][\"mapping\"]\r\n min_x = float(\"inf\")\r\n min_y = float(\"inf\")\r\n min_z = float(\"inf\")\r\n max_x = float(\"-inf\")\r\n max_y = float(\"-inf\")\r\n max_z = float(\"-inf\")\r\n\r\n if mapping[\"x\"] in data:\r\n min_x = min(data[mapping[\"x\"]])\r\n max_x = max(data[mapping[\"x\"]])\r\n\r\n if mapping[\"y\"] in data:\r\n min_y = min(data[mapping[\"y\"]])\r\n max_y = max(data[mapping[\"y\"]])\r\n\r\n if mapping[\"z\"] in data:\r\n min_z = min(data[mapping[\"z\"]])\r\n max_z = max(data[mapping[\"z\"]])\r\n\r\n minimum = min(minimum, min([min_x, min_y, min_z]))\r\n maximum = max(maximum, max([max_x, max_y, max_z]))\r\n\r\n return minimum, maximum","def _get_range(self):\n return tuple((0, m, 1) for m in self.level_shapes[0])","def get_dimensions(self):\r\n x = []\r\n y = []\r\n z = []\r\n for i in self.verts:\r\n x.append(i[0])\r\n y.append(i[1])\r\n z.append(i[2])\r\n\r\n x.append(abs(min(x)))\r\n y.append(abs(min(y)))\r\n z.append(abs(min(z)))\r\n\r\n return max(x), max(y), max(z)","def get_extrema(list):\n max_x = max(list,key=lambda item:item[0])[0]\n max_y = max(list,key=lambda item:item[1])[1]\n min_x = min(list,key=lambda item:item[0])[0]\n min_y = min(list,key=lambda item:item[1])[1]\n return (min_x, max_x, min_y, max_y)","def get_min_max(ints):\n if not ints:\n return None, None\n if len(ints) ==None:\n return None\n min_val = float(\"inf\")\n max_val = -float(\"inf\")\n # for each int in ints if update max_val and min_val accordingly\n for integer in ints:\n if integer > max_val:\n max_val = integer\n\n if integer < min_val:\n min_val = integer\n \n return (min_val, max_val)","def extents(nodes):\n from numpy import min, max\n return ( min(nodes[:,0]), max(nodes[:,0]),\n min(nodes[:,1]), max(nodes[:,1]),\n min(nodes[:,2]), max(nodes[:,2]) )","def bounds(lines):\n min_x = bench_util.Max\n min_y = bench_util.Max\n max_x = bench_util.Min\n max_y = bench_util.Min\n \n for line in lines.itervalues():\n for x, y in line:\n min_x = min(min_x, x)\n min_y = min(min_y, y)\n max_x = max(max_x, x)\n max_y = max(max_y, y)\n \n return ((min_x, min_y), (max_x, max_y))","def find_min_max(data):\n v = [i[1] for i in data]\n extremes = [min(v), max(v)]\n logging.info('Calculated extremes: %s', extremes)\n return extremes","def xminmax ( self ) :\n return self.xvar.minmax()","def min_max(arr, arr_size):\n max_t = arr[0]\n min_t = arr[0]\n for i in range(arr_size):\n if arr[i] > max_t:\n max_t = arr[i]\n if arr[i] < min_t:\n min_t = arr[i]\n return min_t, max_t","def get_min_max(ints):\n if len(ints) <= 0:\n return ()\n min_value = ints[0]\n max_value = ints[0]\n for i in range(len(ints)):\n temp = ints[i]\n if temp <= min_value:\n min_value = temp\n if temp >= max_value:\n max_value = temp\n output = (min_value, max_value)\n# print(\"output: \", output)\n return output\n pass","def getColorRange(self):\n vmax=self.data_matrix.max()\n vmin=self.data_matrix.min()\n\n if vmax * vmin < 0: # ie number range spans +ve and -ve\n vmax = max([vmax, abs(vmin)])\n vmin = -1*vmax\n\n return vmax,vmin","def get_min_max(ints):\n if ints is None or len(ints) == 0:\n return None\n \n min_value = ints[0]\n max_value = ints[0]\n\n for value in ints:\n if value < min_value:\n min_value = value\n\n if value > max_value:\n max_value = value\n\n return (min_value, max_value)","def get_min_max(ints):\r\n if len(ints) == 0:\r\n return None\r\n max = ints[0]\r\n min = ints[0]\r\n\r\n for int in ints:\r\n if int < min:\r\n min = int\r\n if int > max:\r\n max = int\r\n \r\n return min, max","def get_min_max(ints):\n if not ints:\n return\n max = ints[0]\n min = ints[0]\n\n\n for i in ints:\n if i > max:\n max = i\n if i < min:\n min = i\n return (min, max)","def max_in_range(self, x, y, low, high):\r\n data = np.vstack((x,y)) \r\n y_values = data[1][np.logical_and(low < data[0], data[0] < high)]\r\n x_values = data[0][np.logical_and(low < data[0], data[0] < high)]\r\n index_max_y = y_values.argmax()\r\n max_y = y_values[index_max_y]\r\n max_x = x_values[index_max_y]\r\n return max_x, max_y","def input_bounds(self):\n return self._min_input, self._max_input","def minmax(self):\r\n vx = [v[0] for v in self.vl]\r\n vy = [v[1] for v in self.vl]\r\n self.xmax, self.xmin = max(vx), min(vx)\r\n self.ymax, self.ymin = max(vy), min(vy)","def _xywh2min_max(box):\n x, y, w, h = box\n return np.array([x, y, x+w, y+h])","def get_min_max(ints):\n if ints == None or len(ints) == 0:\n return None\n if len(ints) == 1:\n return (ints[0],ints[0])\n \n max = ints[0]\n min = ints[0]\n for i in range(1, len(ints)):\n if ints[i] > max:\n max = ints[i]\n if ints[i] < min:\n min = ints[i]\n return (min,max)","def quickMinMax(self, targetSize=1e6):\n data = self.image\n if targetSize < 2: # keep at least two pixels\n targetSize = 2\n while True:\n h, w = data.shape[:2]\n if h * w <= targetSize: break\n if h > w:\n data = data[::2, ::] # downsample first axis\n else:\n data = data[::, ::2] # downsample second axis\n return self._xp.nanmin(data), self._xp.nanmax(data)","def _value_in_bounds(self, vals):\n return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1]))","def get_features_min_max(self):\n min_max_list = []\n\n # Get each feature's min and max values.\n for feature_name in self.feature_names:\n min = self.data[feature_name].min()\n max = self.data[feature_name].max()\n min_max_list.append([min, max])\n\n # Create dataframe from list of lists in correct format\n min_max_df = pd.DataFrame(min_max_list)\n min_max = min_max_df.T\n min_max.columns = self.feature_names\n min_max.index = ['min', 'max']\n\n return min_max","def return_loose_bounds(maxlum=None):\n return[(None,None), (10**-6, None), (2., 350),\n (None, -10**-6), (None, None)]","def _find_min_and_max_coords(self, block_locations):\n min_x, max_x, min_y, max_y = self.game_size, 0, self.game_size, 0\n for coord in block_locations:\n x = coord[constant.X]\n y = coord[constant.Y]\n if x < min_x:\n min_x = x\n if x > max_x:\n max_x = x\n if y < min_y:\n min_y = y\n if y > max_y:\n max_y = y\n return min_x, max_x, min_y, max_y","def minmax(data):\n smallest = data[0]\n largest = data[0]\n\n for i in range(0,len(data)):\n if data[i] < smallest:\n smallest = data[i]\n elif data[i] > largest:\n largest = data[i]\n\n return(smallest,largest)","def min_max(arr: StaticArray) -> ():\n minimum = arr.get(0) # sets min to first element\n maximum = arr.get(0) # sets max to first element\n # iterate over the elements in the array to check for < or >\n for index in range(arr.size()):\n if arr[index] < minimum: # if element is less than the current min, min = new element\n minimum = arr[index]\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\n maximum = arr[index]\n return minimum, maximum","def get_min_max_tuple(min_max_tuple, value):\n min_v, max_v = min_max_tuple\n\n min_v = smart_min(min_v, value)\n max_v = smart_max(max_v, value)\n\n return (min_v, max_v)","def maxs(self) -> Tensor:\n return self._ranges[:, 1]","def getminmax_tournament(arr, low, high):\n if low == high:\n return arr[low], arr[low]\n\n if abs(low - high) == 1:\n min_num = None\n max_num = None\n if arr[low] > arr[high]:\n max_num = arr[low]\n min_num = arr[high]\n else:\n max_num = arr[high]\n min_num = arr[low]\n return min_num, max_num\n\n else:\n mid = (low + high) // 2\n min_num_1, max_num_1 = getminmax_tournament(arr, low, mid)\n min_num_2, max_num_2 = getminmax_tournament(arr, mid+1, high)\n return min(min_num_1, min_num_2), max(max_num_1, max_num_2)","def min_max(items):\n return min(items), max(items)","def return_parameter_bounds(maximum_luminosity=20):\n return [(maximum_luminosity, maximum_luminosity + 3),\n (3 * 10 ** -4, 8 * 10 ** -3), (2., 350), (-8., -0.2),\n (-400, 400)]","def minmax(self):\n return self._data_lim[self._n_overlay - 1]","def get_min_max(ints):\n print(f\"input arr is {ints}\")\n max=0\n min=len(ints)-1\n for i in range(1,len(ints)):\n if ints[i]>ints[max]:\n temp=ints[i]\n ints[i]=ints[max]\n ints[max]=temp\n if ints[i]<ints[min]:\n temp=ints[i]\n ints[i]=ints[min]\n ints[min]=temp\n #print(f\"max value is {ints[max]}\")\n #print(f\"min value is {ints[min]}\")\n return(ints[min],ints[max])","def bounds(self):\n return self.xmin, self.xmax, self.ymin, self.ymax","def getValues(self):\n return [self.scale_min, self.scale_max]","def view_limits(self, vmin, vmax):\n return vmin, vmax\n # return nonsingular(vmin, vmax)","def get_raw_bounds(self) -> [Vector, Vector]:\n\t\tverts = np.array([v.co for mesh in self._meshes for v in mesh.data.vertices])\n\t\tbbox_min = Vector([*np.min(verts, axis=0)])\n\t\tbbox_max = Vector([*np.max(verts, axis=0)])\n\t\treturn bbox_min, bbox_max","def get_bounds(p_state, idx_image=-1, idx_chain=-1):\n _min = (3*ctypes.c_float)()\n _max = (3*ctypes.c_float)()\n _Get_Bounds(ctypes.c_void_p(p_state), _min, _max,\n ctypes.c_int(idx_image), ctypes.c_int(idx_chain))\n return [_min[i] for i in range(3)], [_max[i] for i in range(3)]","def get_min_max(nums):\n assert(type(nums) == list), \"nums has to be a list\"\n assert(len(nums) > 0), \"get_min_max() arg is an empty sequence\"\n min_ = nums[0]\n max_ = nums[0]\n for n in nums:\n assert(type(n) == int), \"numbers in the list have to be an integer\"\n if n < min_:\n min_ = n\n if n > max_:\n max_ = n\n return (min_, max_)","def find_max_coords(self):\n all_max_bound = []\n all_min_bound = []\n shape_dict = self.shape_dict\n for zone_id in shape_dict:\n zone_shape = shape_dict[zone_id]\n max_bound_zone = zone_shape.max_bound\n min_bound_zone = zone_shape.min_bound\n all_max_bound.append(max_bound_zone)\n all_min_bound.append(min_bound_zone)\n\n map_max_bound, unused_max = Utils.calculate_boundaries(all_max_bound)\n unused_min, map_min_bound = Utils.calculate_boundaries(all_min_bound)\n\n return (map_max_bound, map_min_bound)","def find_mode_range(self):\n\n if (len(self.n) < 1): return -1,-1,-1,-1\n nmin = np.nanmin(self.modes['n'])\n nmax = np.nanmax(self.modes['n'])\n lmin = np.nanmin(self.modes['l'])\n lmax = np.nanmax(self.modes['l'])\n return nmin, nmax, lmin, lmax","def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\n min_max_features = []\n transposed_features = [list(i) for i in zip(*features)]\n for feature in transposed_features:\n min_in_feature = min(feature)\n max_in_feature = max(feature)\n if min_in_feature == max_in_feature:\n min_max_features.append([0 for x in feature])\n else:\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\n return [list(i) for i in zip(*min_max_features)]","def find_minmax(lims, olims):\n\n limzip = zip(list(lims), list(olims), [np.min, np.max])\n return tuple([float(fn([l, ol])) for l, ol, fn in limzip])","def bounds(self) -> tuple[float, float, float, float]:\n transform = self.transform\n a, b, c, d, e, f, _, _, _ = transform\n if b == d == 0:\n xs = (c, c + a * self.width)\n ys = (f, f + e * self.height)\n else: # rotated\n c0x, c0y = c, f\n c1x, c1y = transform * (0, self.height)\n c2x, c2y = transform * (self.width, self.height)\n c3x, c3y = transform * (self.width, 0)\n xs = (c0x, c1x, c2x, c3x)\n ys = (c0y, c1y, c2y, c3y)\n return min(xs), min(ys), max(xs), max(ys)","def find_min_max(x):\n if not x: return None\n if len(x) == 1:\n return x[0], x[0] # the first is min and the second is max\n min_val = x[0]\n max_val = x[0]\n for i in xrange(1, len(x)):\n if x[i] < min_val:\n min_val = x[i]\n elif x[i] > max_val:\n max_val = x[i]","def get_box(self, state, min_x, min_y, max_x, max_y):\n ret_val, min_x.value, min_y.value, max_x.value, max_y.value = self._get_box(state.encode(), min_x.value, min_y.value, max_x.value, max_y.value)\n return ret_val","def bounds(self, resids: NDArray) -> List[Tuple[float, float]]:","def find_max_min(number):\n if max(number) == min(number):\n return [len(number)]\n return [min(number), max(number)]","def get_min_max_x(self, min_x = 1e9, max_x = -1e9, exclude = []): \n \n if self.verbose > 1:\n print(\"MultiLinearSpectra.get_min_max_x()\") \n \n for m in range(len(self.mess)):\n if m not in exclude and self.mess[m][\"class\"] not in exclude:\n min_x, max_x = self.mess[m][\"object\"].get_min_max_x(min_x, max_x)\n \n return min_x, max_x","def getLimits(self):\n lims = [x * self.getSign() + self.getOffset() for x in (self.connection.getChannel(self.chanNamePrefix % 'low_limit').read(), \\\n self.connection.getChannel(self.chanNamePrefix % 'high_limit').read())]\n return (min(lims), max(lims))","def get_minx_maxx(self, normalized=True):\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\n\n for idx, feature_name in enumerate(self.continuous_feature_names):\n max_value = self.train_df[feature_name].max()\n min_value = self.train_df[feature_name].min()\n\n if normalized:\n minx[0][idx] = (self.permitted_range[feature_name]\n [0] - min_value) / (max_value - min_value)\n maxx[0][idx] = (self.permitted_range[feature_name]\n [1] - min_value) / (max_value - min_value)\n else:\n minx[0][idx] = self.permitted_range[feature_name][0]\n maxx[0][idx] = self.permitted_range[feature_name][1]\n return minx, maxx","def compute_bounds(self, space):\n bounds = np.zeros((len(space), 2))\n\n for idx, param in enumerate(space):\n\n if TYPE[param[\"type\"]] is TYPE.FLOAT or \\\n TYPE[param[\"type\"]] is TYPE.INTEGER:\n bounds[idx] = (param[\"min\"], param[\"max\"])\n\n elif TYPE[param[\"type\"]] is TYPE.DISCRETE or \\\n TYPE[param[\"type\"]] is TYPE.DISCRETE:\n bounds[idx] = (0, len(param['values']))\n\n return bounds","def min_max(input):\r\n return tuple(sorted(input)[:1]+sorted(input)[-1:]) # write a line of code to return containing min and max\r\n #tuple(input[:1]+input[-1:]) --------------- it works for the sorted lists\r\n #tuple(sorted(input)[:1]+sorted(input)[-1:]) ---------------it works for any input---slicing lists and concatinating\r\n #tuple(sorted(input))[:1]+tuple(sorted(input))[-1:]----------------it works same as the above----slicing tuples and concatinating them\r","def Extrema(self):\n ymin = np.min(self._corners[:, 1])\n xmin = np.min(self._corners[:, 0])\n ymax = np.max(self._corners[:, 1])\n xmax = np.max(self._corners[:, 0])\n return ymin, xmin, ymax, xmax","def _get_colorbar_limits(self):\n if self.boundaries is not None:\n C = self.boundaries\n if self.extend in [\"min\", \"both\"]:\n C = C[1:]\n\n if self.extend in [\"max\", \"both\"]:\n C = C[:-1]\n return min(C), max(C)\n else:\n return self.get_clim()","def extremePointsTup(cnt):\n\tleftmost = tuple(cnt[cnt[:,:,0].argmin()][0])\n\trightmost = tuple(cnt[cnt[:,:,0].argmax()][0])\n\ttopmost = tuple(cnt[cnt[:,:,1].argmin()][0])\n\tbottommost = tuple(cnt[cnt[:,:,1].argmax()][0])\n\treturn (leftmost, rightmost, topmost, bottommost)","def GetFieldMinMax(fielddef):\n minmax = {'c': (0, 0xff),\n '?': (0, 1),\n 'b': (~0x7f, 0x7f),\n 'B': (0, 0xff),\n 'h': (~0x7fff, 0x7fff),\n 'H': (0, 0xffff),\n 'i': (~0x7fffffff, 0x7fffffff),\n 'I': (0, 0xffffffff),\n 'l': (~0x7fffffff, 0x7fffffff),\n 'L': (0, 0xffffffff),\n 'q': (~0x7fffffffffffffff, 0x7fffffffffffffff),\n 'Q': (0, 0x7fffffffffffffff),\n 'f': (sys.float_info.min, sys.float_info.max),\n 'd': (sys.float_info.min, sys.float_info.max),\n }\n format_ = GetFieldDef(fielddef, fields='format_')\n min_ = 0\n max_ = 0\n\n if format_[-1:] in minmax:\n min_, max_ = minmax[format_[-1:]]\n max_ *= GetFormatCount(format_)\n elif format_[-1:].lower() in ['s','p']:\n # s and p may have a prefix as length\n max_ = GetFormatCount(format_)\n\n return min_,max_","def getminmax_linear_search(arr):\n if len(arr) == 0:\n return None, None\n\n if len(arr) == 1:\n return arr[0], arr[0]\n\n min_num = None\n max_num = None\n if arr[0] > arr[1]:\n max_num = arr[0]\n min_num = arr[1]\n else:\n max_num = arr[1]\n min_num = arr[0]\n\n for idx in range(2, len(arr)):\n if min_num > arr[idx]:\n min_num = arr[idx]\n if max_num < arr[idx]:\n max_num = arr[idx]\n\n return min_num, max_num","def zminmax ( self ) :\n return self.zvar.minmax()","def yield_spectral_range(self) -> Tuple[float, float, float]:\n return [min(self.x), max(self.x), len(self.x)]","def hi_lo(data_series, current_max, current_min):\n \n try:\n highest = numpy.max(data_series)\n except:\n highest = max(data_series)\n \n if highest > current_max:\n new_max = highest\n else:\n new_max = current_max\n \n try: \n lowest = numpy.min(data_series)\n except:\n lowest = min(data_series)\n \n if lowest < current_min:\n new_min = lowest\n else:\n new_min = current_min\n \n return new_max, new_min","def getRange(self) -> Tuple[int, int]:\n return self.validator().bottom(), self.validator().top()","def get_min_max(self):\n\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\n mr[:] = np.max(mr)\n\n mxmin = self.mx - mr\n mxmax = self.mx + mr\n mymin = self.my - mr\n mymax = self.my + mr\n mzmin = self.mz - mr\n mzmax = self.mz + mr\n\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\n\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\n\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\n\n return xmin, xmax, ymin, ymax, zmin, zmax","def getColMinMax(table, col):\n\tvmin = None\n\tvmax = None\n\tfor rec in table:\n\t\tvalue = rec[col]\n\t\tif vmin is None:\n\t\t\tvmin = value\n\t\t\tvmax = value\n\t\telse:\n\t\t\tif value < vmin:\n\t\t\t\tvmin = value\n\t\t\telif value > vmax:\n\t\t\t\tvmax = value\n\treturn (vmin, vmax, vmax - vmin)","def compare_select(self, x: torch.Tensor) -> [torch.Tensor, torch.LongTensor]:\n reshaped_x = x.reshape(-1, self.n_states, 2)\n max_values, absolute_max_ind = torch.max(reshaped_x, 2)\n return max_values, absolute_max_ind","def get_lims(data):\n return data[:, 0].min() - 1, data[:, 0].max() + 1, data[:, 1].min() - 1, data[:, 1].max() + 1","def _get_energy_range(self):\n\n e0_min = self.network.isomers[0].E0\n e0_max = e0_min\n\n for isomer in self.network.isomers[1:]:\n E0 = isomer.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for reactant in self.network.reactants:\n E0 = reactant.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for product in self.network.products:\n E0 = product.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for rxn in self.network.path_reactions:\n E0 = rxn.transition_state.conformer.E0.value_si\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n\n return e0_min, e0_max","def get_bounds(self):\r\n left, bottom, front = 10000, 10000, 10000\r\n right, top, back = -10000, -10000, -10000\r\n for b in self.buf:\r\n for v in b.vertices:\r\n if v[0] < left:\r\n left = v[0]\r\n if v[0] > right:\r\n right = v[0]\r\n if v[1] < bottom:\r\n bottom = v[1]\r\n if v[1] > top:\r\n top = v[1]\r\n if v[2] < front:\r\n front = v[2]\r\n if v[2] > back:\r\n back = v[2]\r\n\r\n return (left, bottom, front, right, top, back)","def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\n\n\n dtype = min_broadcast.dtype\n quant_min = 1 if narrow_range else 0\n quant_max = (2 ** num_bits) - 1\n\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\n\n # caculate each channel max and min difference.\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\n # and min_div_scale = min_broadcast / scale\n if product_is_mini():\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\n else:\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\n\n # zero_point_from_min = quant_min_float - min_broadcast / scale\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\n\n # according to above bool param to select effective value\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\n\n # compute which num is not less than quant_min_float and not large than quant_max_float\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\n # add 0.5 to num which min <= num <= max and then floor them.\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\n if product_is_mini():\n between_min_max_round = topi.cast(between_min_max_round, \"float16\")\n\n between_min_max_round = topi.cast(between_min_max_round, \"float32\")\n\n # calculate the maximum and minimum values of the quantization\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\n\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\n nudged_min = topi.multiply(nudged_min_tmp, scale)\n nudged_max = topi.multiply(nudged_max_tmp, scale)\n res = [nudged_min, nudged_max, scale]\n\n return res","def get_max_min(block_size):\r\n return (int(block_size / 2), int((block_size - 1) / 2))","def get_min_max(ints):\n if len(ints) == 0:\n return None, None\n \n min_e = ints[0]\n max_e = ints[-1]\n for e in ints:\n if isinstance(e, int) == False: # if the list includes non-integer number, do not find min, max \n return None,None\n if e < min_e:\n min_e = e\n if e > max_e:\n max_e = e\n return min_e, max_e","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def range_(self):\n return tuple((e[0], e[-1]) for e in self.edges)"],"string":"[\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def get_minmax(self):\\n x_minmax = [np.min(self.grid['x']), np.max(self.grid['x'].max())]\\n z_minmax = [np.min(self.grid['z']), np.max(self.grid['z'].max())]\\n return x_minmax, z_minmax\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def getMinMax(self,arr):\\n # not implemented for Template SED yet\\n return arr[\\\"z\\\"], arr[\\\"z\\\"]\",\n \"def calculate_min_max_tiles(self):\",\n \"def getMinMax(self,arr):\\n minz=arr['zmg']-arr['sigma_pz']*5\\n dmin=self.zcat-5*self.sigmacat\\n minz[np.where(minz>dmin)]=dmin\\n maxz=arr['zmg']+arr['sigma_pz']*5\\n dax=self.zcat+5*self.sigmacat\\n maxz[np.where(maxz<dmax)]=dmax\\n return dmin,dmax\",\n \"def range(self):\\n lows, highs = [], []\\n for graph in self._graphs.values():\\n low, high = graph.range()\\n lows.append(low)\\n highs.append(high)\\n return (min(lows), max(highs))\",\n \"def minMax2(x):\\r\\n\\r\\n iMinMax = [0 for i in range(2)]\\r\\n num = len(x)[0]\\r\\n\\r\\n iMin = 0\\r\\n iMax = 0\\r\\n\\r\\n #// Search for minimum and maximum in row 0 - linear values:\\r\\n min = x[0][iMin]\\r\\n max = x[0][iMax]\\r\\n\\r\\n for i in range(1, num):\\r\\n\\r\\n if (x[0][i] < min): \\r\\n min = x[0][i]\\r\\n iMin = i\\r\\n \\r\\n\\r\\n if (x[0][i] > max): \\r\\n max = x[0][i]\\r\\n iMax = i\\r\\n \\r\\n iMinMax[0] = iMin\\r\\n iMinMax[1] = iMax\\r\\n\\r\\n return iMinMax\",\n \"def min_max(xs):\\n return min(xs), max(xs)\",\n \"def fetchbounds(self):\\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\\\\n self.in_end, self.end, self.out_end] \\\\\\n if x is not None]\\n return min(pnts), max(pnts)\",\n \"def limits(self):\\n\\n\\t\\treturn [\\n\\t\\t\\tmin(self.xvalues),\\n\\t\\t\\tmax(self.xvalues),\\n\\t\\t\\tmin(self.yvalues),\\n\\t\\t\\tmax(self.yvalues)]\",\n \"def high_and_low(numbers):\\n highest = max(numbers)\\n lowest = min(numbers)\\n return (highest, lowest)\",\n \"def get_bounds(self):\\n x_max = self.data['x'].max()\\n y_max = self.data['y'].max()\\n z_max = self.data['z'].max()\\n print(\\\"x={}; y={}; z={}\\\".format(x_max, y_max, z_max))\\n return (x_max, y_max, z_max)\",\n \"def get_min_max(ints):\\n current_max = None\\n current_min = None\\n\\n if (len(ints) == 0) or (ints is None):\\n return tuple([current_min, current_max])\\n\\n for i, n in enumerate(ints):\\n if i == 0:\\n current_max = n\\n current_min = n\\n else:\\n if n > current_max:\\n current_max = n\\n elif n < current_min:\\n current_min = n\\n\\n return tuple([current_min, current_max])\",\n \"def high_and_low(numbers):\\n highest = max(numbers)\\n lowest = min(numbers)\\n return (highest,lowest)\",\n \"def minmax(xs):\\n min_val = None\\n max_val = None\\n for x in xs:\\n if min_val is None or x < min_val:\\n min_val = x\\n if max_val is None or x > max_val:\\n max_val = x\\n return (min_val, max_val)\",\n \"def state_limits(self) -> Tuple[torch.Tensor, torch.Tensor]:\\n # define upper and lower limits based around the nominal equilibrium input\\n upper_limit = torch.ones(self.n_dims)\\n upper_limit[TurtleBot2D.X] = 2.0\\n upper_limit[TurtleBot2D.Y] = 2.0\\n upper_limit[TurtleBot2D.THETA] = 2 * np.pi\\n\\n lower_limit = -1.0 * upper_limit\\n\\n return (upper_limit, lower_limit)\",\n \"def get_minmax(self, stmt, slist):\\n minel = maxel = None\\n for s in slist:\\n if s.keyword == \\\"min-elements\\\":\\n minel = s.arg\\n elif s.keyword == \\\"max-elements\\\":\\n maxel = s.arg\\n if minel is None:\\n minst = stmt.search_one(\\\"min_elements\\\")\\n if minst:\\n minel = minst.arg\\n else:\\n minel = \\\"0\\\"\\n if maxel is None:\\n maxst = stmt.search_one(\\\"max_elements\\\")\\n if maxst:\\n maxel = maxst.arg\\n return (minel, maxel)\",\n \"def _set_min_max_values(self):\\n\\n p_1, p_2 = self.points[0], self.points[1]\\n nb_dim = len(p_1.values)\\n self._min_values = []\\n self._max_values = []\\n for d in range(nb_dim):\\n d_min = min(p_1[d], p_2[d])\\n d_max = max(p_2[d], p_2[d])\\n self._min_values.append(d_min)\\n self._max_values.append(d_max)\",\n \"def get_bounds(self):\\n occupied_locations = self.board.keys()\\n min_x = min(p[0] for p in occupied_locations)\\n max_x = max(p[0] for p in occupied_locations)\\n min_y = min(p[1] for p in occupied_locations)\\n max_y = max(p[1] for p in occupied_locations)\\n return ((min_x, max_x), (min_y, max_y))\",\n \"def bounds(self):\\n\\n if self.size == 0:\\n lo, hi = np.nan, np.nan\\n elif self.is_monotonic:\\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\\n elif self.dtype is np.datetime64:\\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\\n else:\\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\\n\\n return lo, hi\",\n \"def bounds(self):\\n return self.min_col, self.min_row, self.max_col, self.max_row\",\n \"def glGetMinmax( baseFunction, target, reset, format, type, values=None):\\r\\n if values is None:\\r\\n width = 2\\r\\n values = images.images.SetupPixelRead( format, (width,4), type )\\r\\n arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[\\r\\n images.images.TYPE_TO_ARRAYTYPE.get(type,type)\\r\\n ]\\r\\n baseFunction(\\r\\n target, reset, format, type,\\r\\n ctypes.c_void_p( arrayType.dataPointer(values))\\r\\n )\\r\\n return values\",\n \"def get_min_max(ints):\\n\\n if len(ints) == 0:\\n return (None,None)\\n min = ints[0]\\n max = ints[0]\\n for x in range(1,len(ints)):\\n if ints[x] > max:\\n max=ints[x]\\n elif ints[x] < min:\\n min = ints[x]\\n return (min,max)\",\n \"def get_physical_bounds(dim):\\n dim = basename(dim)\\n\\n if dim == \\\"coszen\\\":\\n trunc_low = -1.\\n trunc_high = 1.\\n\\n elif dim == \\\"energy\\\":\\n trunc_low = 0.\\n trunc_high = None\\n\\n elif dim == \\\"azimuth\\\":\\n trunc_low = 0.\\n trunc_high = 2*np.pi\\n\\n else:\\n raise ValueError(\\\"No physical bounds for dimension '%s' available.\\\"%dim)\\n\\n return trunc_low, trunc_high\",\n \"def spec_min_max(self):\\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\\n 2048,2048,2048,2048,2048])\\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0])\\n return np.vstack((spec_min, spec_max))\",\n \"def get_min_max(self) -> tuple:\\r\\n\\r\\n minimum = float(\\\"inf\\\")\\r\\n maximum = float(\\\"-inf\\\")\\r\\n\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n if self.trees[name][\\\"point_helper\\\"] is None:\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n min_x = float(\\\"inf\\\")\\r\\n min_y = float(\\\"inf\\\")\\r\\n min_z = float(\\\"inf\\\")\\r\\n max_x = float(\\\"-inf\\\")\\r\\n max_y = float(\\\"-inf\\\")\\r\\n max_z = float(\\\"-inf\\\")\\r\\n\\r\\n if mapping[\\\"x\\\"] in data:\\r\\n min_x = min(data[mapping[\\\"x\\\"]])\\r\\n max_x = max(data[mapping[\\\"x\\\"]])\\r\\n\\r\\n if mapping[\\\"y\\\"] in data:\\r\\n min_y = min(data[mapping[\\\"y\\\"]])\\r\\n max_y = max(data[mapping[\\\"y\\\"]])\\r\\n\\r\\n if mapping[\\\"z\\\"] in data:\\r\\n min_z = min(data[mapping[\\\"z\\\"]])\\r\\n max_z = max(data[mapping[\\\"z\\\"]])\\r\\n\\r\\n minimum = min(minimum, min([min_x, min_y, min_z]))\\r\\n maximum = max(maximum, max([max_x, max_y, max_z]))\\r\\n\\r\\n return minimum, maximum\",\n \"def _get_range(self):\\n return tuple((0, m, 1) for m in self.level_shapes[0])\",\n \"def get_dimensions(self):\\r\\n x = []\\r\\n y = []\\r\\n z = []\\r\\n for i in self.verts:\\r\\n x.append(i[0])\\r\\n y.append(i[1])\\r\\n z.append(i[2])\\r\\n\\r\\n x.append(abs(min(x)))\\r\\n y.append(abs(min(y)))\\r\\n z.append(abs(min(z)))\\r\\n\\r\\n return max(x), max(y), max(z)\",\n \"def get_extrema(list):\\n max_x = max(list,key=lambda item:item[0])[0]\\n max_y = max(list,key=lambda item:item[1])[1]\\n min_x = min(list,key=lambda item:item[0])[0]\\n min_y = min(list,key=lambda item:item[1])[1]\\n return (min_x, max_x, min_y, max_y)\",\n \"def get_min_max(ints):\\n if not ints:\\n return None, None\\n if len(ints) ==None:\\n return None\\n min_val = float(\\\"inf\\\")\\n max_val = -float(\\\"inf\\\")\\n # for each int in ints if update max_val and min_val accordingly\\n for integer in ints:\\n if integer > max_val:\\n max_val = integer\\n\\n if integer < min_val:\\n min_val = integer\\n \\n return (min_val, max_val)\",\n \"def extents(nodes):\\n from numpy import min, max\\n return ( min(nodes[:,0]), max(nodes[:,0]),\\n min(nodes[:,1]), max(nodes[:,1]),\\n min(nodes[:,2]), max(nodes[:,2]) )\",\n \"def bounds(lines):\\n min_x = bench_util.Max\\n min_y = bench_util.Max\\n max_x = bench_util.Min\\n max_y = bench_util.Min\\n \\n for line in lines.itervalues():\\n for x, y in line:\\n min_x = min(min_x, x)\\n min_y = min(min_y, y)\\n max_x = max(max_x, x)\\n max_y = max(max_y, y)\\n \\n return ((min_x, min_y), (max_x, max_y))\",\n \"def find_min_max(data):\\n v = [i[1] for i in data]\\n extremes = [min(v), max(v)]\\n logging.info('Calculated extremes: %s', extremes)\\n return extremes\",\n \"def xminmax ( self ) :\\n return self.xvar.minmax()\",\n \"def min_max(arr, arr_size):\\n max_t = arr[0]\\n min_t = arr[0]\\n for i in range(arr_size):\\n if arr[i] > max_t:\\n max_t = arr[i]\\n if arr[i] < min_t:\\n min_t = arr[i]\\n return min_t, max_t\",\n \"def get_min_max(ints):\\n if len(ints) <= 0:\\n return ()\\n min_value = ints[0]\\n max_value = ints[0]\\n for i in range(len(ints)):\\n temp = ints[i]\\n if temp <= min_value:\\n min_value = temp\\n if temp >= max_value:\\n max_value = temp\\n output = (min_value, max_value)\\n# print(\\\"output: \\\", output)\\n return output\\n pass\",\n \"def getColorRange(self):\\n vmax=self.data_matrix.max()\\n vmin=self.data_matrix.min()\\n\\n if vmax * vmin < 0: # ie number range spans +ve and -ve\\n vmax = max([vmax, abs(vmin)])\\n vmin = -1*vmax\\n\\n return vmax,vmin\",\n \"def get_min_max(ints):\\n if ints is None or len(ints) == 0:\\n return None\\n \\n min_value = ints[0]\\n max_value = ints[0]\\n\\n for value in ints:\\n if value < min_value:\\n min_value = value\\n\\n if value > max_value:\\n max_value = value\\n\\n return (min_value, max_value)\",\n \"def get_min_max(ints):\\r\\n if len(ints) == 0:\\r\\n return None\\r\\n max = ints[0]\\r\\n min = ints[0]\\r\\n\\r\\n for int in ints:\\r\\n if int < min:\\r\\n min = int\\r\\n if int > max:\\r\\n max = int\\r\\n \\r\\n return min, max\",\n \"def get_min_max(ints):\\n if not ints:\\n return\\n max = ints[0]\\n min = ints[0]\\n\\n\\n for i in ints:\\n if i > max:\\n max = i\\n if i < min:\\n min = i\\n return (min, max)\",\n \"def max_in_range(self, x, y, low, high):\\r\\n data = np.vstack((x,y)) \\r\\n y_values = data[1][np.logical_and(low < data[0], data[0] < high)]\\r\\n x_values = data[0][np.logical_and(low < data[0], data[0] < high)]\\r\\n index_max_y = y_values.argmax()\\r\\n max_y = y_values[index_max_y]\\r\\n max_x = x_values[index_max_y]\\r\\n return max_x, max_y\",\n \"def input_bounds(self):\\n return self._min_input, self._max_input\",\n \"def minmax(self):\\r\\n vx = [v[0] for v in self.vl]\\r\\n vy = [v[1] for v in self.vl]\\r\\n self.xmax, self.xmin = max(vx), min(vx)\\r\\n self.ymax, self.ymin = max(vy), min(vy)\",\n \"def _xywh2min_max(box):\\n x, y, w, h = box\\n return np.array([x, y, x+w, y+h])\",\n \"def get_min_max(ints):\\n if ints == None or len(ints) == 0:\\n return None\\n if len(ints) == 1:\\n return (ints[0],ints[0])\\n \\n max = ints[0]\\n min = ints[0]\\n for i in range(1, len(ints)):\\n if ints[i] > max:\\n max = ints[i]\\n if ints[i] < min:\\n min = ints[i]\\n return (min,max)\",\n \"def quickMinMax(self, targetSize=1e6):\\n data = self.image\\n if targetSize < 2: # keep at least two pixels\\n targetSize = 2\\n while True:\\n h, w = data.shape[:2]\\n if h * w <= targetSize: break\\n if h > w:\\n data = data[::2, ::] # downsample first axis\\n else:\\n data = data[::, ::2] # downsample second axis\\n return self._xp.nanmin(data), self._xp.nanmax(data)\",\n \"def _value_in_bounds(self, vals):\\n return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1]))\",\n \"def get_features_min_max(self):\\n min_max_list = []\\n\\n # Get each feature's min and max values.\\n for feature_name in self.feature_names:\\n min = self.data[feature_name].min()\\n max = self.data[feature_name].max()\\n min_max_list.append([min, max])\\n\\n # Create dataframe from list of lists in correct format\\n min_max_df = pd.DataFrame(min_max_list)\\n min_max = min_max_df.T\\n min_max.columns = self.feature_names\\n min_max.index = ['min', 'max']\\n\\n return min_max\",\n \"def return_loose_bounds(maxlum=None):\\n return[(None,None), (10**-6, None), (2., 350),\\n (None, -10**-6), (None, None)]\",\n \"def _find_min_and_max_coords(self, block_locations):\\n min_x, max_x, min_y, max_y = self.game_size, 0, self.game_size, 0\\n for coord in block_locations:\\n x = coord[constant.X]\\n y = coord[constant.Y]\\n if x < min_x:\\n min_x = x\\n if x > max_x:\\n max_x = x\\n if y < min_y:\\n min_y = y\\n if y > max_y:\\n max_y = y\\n return min_x, max_x, min_y, max_y\",\n \"def minmax(data):\\n smallest = data[0]\\n largest = data[0]\\n\\n for i in range(0,len(data)):\\n if data[i] < smallest:\\n smallest = data[i]\\n elif data[i] > largest:\\n largest = data[i]\\n\\n return(smallest,largest)\",\n \"def min_max(arr: StaticArray) -> ():\\n minimum = arr.get(0) # sets min to first element\\n maximum = arr.get(0) # sets max to first element\\n # iterate over the elements in the array to check for < or >\\n for index in range(arr.size()):\\n if arr[index] < minimum: # if element is less than the current min, min = new element\\n minimum = arr[index]\\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\\n maximum = arr[index]\\n return minimum, maximum\",\n \"def get_min_max_tuple(min_max_tuple, value):\\n min_v, max_v = min_max_tuple\\n\\n min_v = smart_min(min_v, value)\\n max_v = smart_max(max_v, value)\\n\\n return (min_v, max_v)\",\n \"def maxs(self) -> Tensor:\\n return self._ranges[:, 1]\",\n \"def getminmax_tournament(arr, low, high):\\n if low == high:\\n return arr[low], arr[low]\\n\\n if abs(low - high) == 1:\\n min_num = None\\n max_num = None\\n if arr[low] > arr[high]:\\n max_num = arr[low]\\n min_num = arr[high]\\n else:\\n max_num = arr[high]\\n min_num = arr[low]\\n return min_num, max_num\\n\\n else:\\n mid = (low + high) // 2\\n min_num_1, max_num_1 = getminmax_tournament(arr, low, mid)\\n min_num_2, max_num_2 = getminmax_tournament(arr, mid+1, high)\\n return min(min_num_1, min_num_2), max(max_num_1, max_num_2)\",\n \"def min_max(items):\\n return min(items), max(items)\",\n \"def return_parameter_bounds(maximum_luminosity=20):\\n return [(maximum_luminosity, maximum_luminosity + 3),\\n (3 * 10 ** -4, 8 * 10 ** -3), (2., 350), (-8., -0.2),\\n (-400, 400)]\",\n \"def minmax(self):\\n return self._data_lim[self._n_overlay - 1]\",\n \"def get_min_max(ints):\\n print(f\\\"input arr is {ints}\\\")\\n max=0\\n min=len(ints)-1\\n for i in range(1,len(ints)):\\n if ints[i]>ints[max]:\\n temp=ints[i]\\n ints[i]=ints[max]\\n ints[max]=temp\\n if ints[i]<ints[min]:\\n temp=ints[i]\\n ints[i]=ints[min]\\n ints[min]=temp\\n #print(f\\\"max value is {ints[max]}\\\")\\n #print(f\\\"min value is {ints[min]}\\\")\\n return(ints[min],ints[max])\",\n \"def bounds(self):\\n return self.xmin, self.xmax, self.ymin, self.ymax\",\n \"def getValues(self):\\n return [self.scale_min, self.scale_max]\",\n \"def view_limits(self, vmin, vmax):\\n return vmin, vmax\\n # return nonsingular(vmin, vmax)\",\n \"def get_raw_bounds(self) -> [Vector, Vector]:\\n\\t\\tverts = np.array([v.co for mesh in self._meshes for v in mesh.data.vertices])\\n\\t\\tbbox_min = Vector([*np.min(verts, axis=0)])\\n\\t\\tbbox_max = Vector([*np.max(verts, axis=0)])\\n\\t\\treturn bbox_min, bbox_max\",\n \"def get_bounds(p_state, idx_image=-1, idx_chain=-1):\\n _min = (3*ctypes.c_float)()\\n _max = (3*ctypes.c_float)()\\n _Get_Bounds(ctypes.c_void_p(p_state), _min, _max,\\n ctypes.c_int(idx_image), ctypes.c_int(idx_chain))\\n return [_min[i] for i in range(3)], [_max[i] for i in range(3)]\",\n \"def get_min_max(nums):\\n assert(type(nums) == list), \\\"nums has to be a list\\\"\\n assert(len(nums) > 0), \\\"get_min_max() arg is an empty sequence\\\"\\n min_ = nums[0]\\n max_ = nums[0]\\n for n in nums:\\n assert(type(n) == int), \\\"numbers in the list have to be an integer\\\"\\n if n < min_:\\n min_ = n\\n if n > max_:\\n max_ = n\\n return (min_, max_)\",\n \"def find_max_coords(self):\\n all_max_bound = []\\n all_min_bound = []\\n shape_dict = self.shape_dict\\n for zone_id in shape_dict:\\n zone_shape = shape_dict[zone_id]\\n max_bound_zone = zone_shape.max_bound\\n min_bound_zone = zone_shape.min_bound\\n all_max_bound.append(max_bound_zone)\\n all_min_bound.append(min_bound_zone)\\n\\n map_max_bound, unused_max = Utils.calculate_boundaries(all_max_bound)\\n unused_min, map_min_bound = Utils.calculate_boundaries(all_min_bound)\\n\\n return (map_max_bound, map_min_bound)\",\n \"def find_mode_range(self):\\n\\n if (len(self.n) < 1): return -1,-1,-1,-1\\n nmin = np.nanmin(self.modes['n'])\\n nmax = np.nanmax(self.modes['n'])\\n lmin = np.nanmin(self.modes['l'])\\n lmax = np.nanmax(self.modes['l'])\\n return nmin, nmax, lmin, lmax\",\n \"def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\\n min_max_features = []\\n transposed_features = [list(i) for i in zip(*features)]\\n for feature in transposed_features:\\n min_in_feature = min(feature)\\n max_in_feature = max(feature)\\n if min_in_feature == max_in_feature:\\n min_max_features.append([0 for x in feature])\\n else:\\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\\n return [list(i) for i in zip(*min_max_features)]\",\n \"def find_minmax(lims, olims):\\n\\n limzip = zip(list(lims), list(olims), [np.min, np.max])\\n return tuple([float(fn([l, ol])) for l, ol, fn in limzip])\",\n \"def bounds(self) -> tuple[float, float, float, float]:\\n transform = self.transform\\n a, b, c, d, e, f, _, _, _ = transform\\n if b == d == 0:\\n xs = (c, c + a * self.width)\\n ys = (f, f + e * self.height)\\n else: # rotated\\n c0x, c0y = c, f\\n c1x, c1y = transform * (0, self.height)\\n c2x, c2y = transform * (self.width, self.height)\\n c3x, c3y = transform * (self.width, 0)\\n xs = (c0x, c1x, c2x, c3x)\\n ys = (c0y, c1y, c2y, c3y)\\n return min(xs), min(ys), max(xs), max(ys)\",\n \"def find_min_max(x):\\n if not x: return None\\n if len(x) == 1:\\n return x[0], x[0] # the first is min and the second is max\\n min_val = x[0]\\n max_val = x[0]\\n for i in xrange(1, len(x)):\\n if x[i] < min_val:\\n min_val = x[i]\\n elif x[i] > max_val:\\n max_val = x[i]\",\n \"def get_box(self, state, min_x, min_y, max_x, max_y):\\n ret_val, min_x.value, min_y.value, max_x.value, max_y.value = self._get_box(state.encode(), min_x.value, min_y.value, max_x.value, max_y.value)\\n return ret_val\",\n \"def bounds(self, resids: NDArray) -> List[Tuple[float, float]]:\",\n \"def find_max_min(number):\\n if max(number) == min(number):\\n return [len(number)]\\n return [min(number), max(number)]\",\n \"def get_min_max_x(self, min_x = 1e9, max_x = -1e9, exclude = []): \\n \\n if self.verbose > 1:\\n print(\\\"MultiLinearSpectra.get_min_max_x()\\\") \\n \\n for m in range(len(self.mess)):\\n if m not in exclude and self.mess[m][\\\"class\\\"] not in exclude:\\n min_x, max_x = self.mess[m][\\\"object\\\"].get_min_max_x(min_x, max_x)\\n \\n return min_x, max_x\",\n \"def getLimits(self):\\n lims = [x * self.getSign() + self.getOffset() for x in (self.connection.getChannel(self.chanNamePrefix % 'low_limit').read(), \\\\\\n self.connection.getChannel(self.chanNamePrefix % 'high_limit').read())]\\n return (min(lims), max(lims))\",\n \"def get_minx_maxx(self, normalized=True):\\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\\n\\n for idx, feature_name in enumerate(self.continuous_feature_names):\\n max_value = self.train_df[feature_name].max()\\n min_value = self.train_df[feature_name].min()\\n\\n if normalized:\\n minx[0][idx] = (self.permitted_range[feature_name]\\n [0] - min_value) / (max_value - min_value)\\n maxx[0][idx] = (self.permitted_range[feature_name]\\n [1] - min_value) / (max_value - min_value)\\n else:\\n minx[0][idx] = self.permitted_range[feature_name][0]\\n maxx[0][idx] = self.permitted_range[feature_name][1]\\n return minx, maxx\",\n \"def compute_bounds(self, space):\\n bounds = np.zeros((len(space), 2))\\n\\n for idx, param in enumerate(space):\\n\\n if TYPE[param[\\\"type\\\"]] is TYPE.FLOAT or \\\\\\n TYPE[param[\\\"type\\\"]] is TYPE.INTEGER:\\n bounds[idx] = (param[\\\"min\\\"], param[\\\"max\\\"])\\n\\n elif TYPE[param[\\\"type\\\"]] is TYPE.DISCRETE or \\\\\\n TYPE[param[\\\"type\\\"]] is TYPE.DISCRETE:\\n bounds[idx] = (0, len(param['values']))\\n\\n return bounds\",\n \"def min_max(input):\\r\\n return tuple(sorted(input)[:1]+sorted(input)[-1:]) # write a line of code to return containing min and max\\r\\n #tuple(input[:1]+input[-1:]) --------------- it works for the sorted lists\\r\\n #tuple(sorted(input)[:1]+sorted(input)[-1:]) ---------------it works for any input---slicing lists and concatinating\\r\\n #tuple(sorted(input))[:1]+tuple(sorted(input))[-1:]----------------it works same as the above----slicing tuples and concatinating them\\r\",\n \"def Extrema(self):\\n ymin = np.min(self._corners[:, 1])\\n xmin = np.min(self._corners[:, 0])\\n ymax = np.max(self._corners[:, 1])\\n xmax = np.max(self._corners[:, 0])\\n return ymin, xmin, ymax, xmax\",\n \"def _get_colorbar_limits(self):\\n if self.boundaries is not None:\\n C = self.boundaries\\n if self.extend in [\\\"min\\\", \\\"both\\\"]:\\n C = C[1:]\\n\\n if self.extend in [\\\"max\\\", \\\"both\\\"]:\\n C = C[:-1]\\n return min(C), max(C)\\n else:\\n return self.get_clim()\",\n \"def extremePointsTup(cnt):\\n\\tleftmost = tuple(cnt[cnt[:,:,0].argmin()][0])\\n\\trightmost = tuple(cnt[cnt[:,:,0].argmax()][0])\\n\\ttopmost = tuple(cnt[cnt[:,:,1].argmin()][0])\\n\\tbottommost = tuple(cnt[cnt[:,:,1].argmax()][0])\\n\\treturn (leftmost, rightmost, topmost, bottommost)\",\n \"def GetFieldMinMax(fielddef):\\n minmax = {'c': (0, 0xff),\\n '?': (0, 1),\\n 'b': (~0x7f, 0x7f),\\n 'B': (0, 0xff),\\n 'h': (~0x7fff, 0x7fff),\\n 'H': (0, 0xffff),\\n 'i': (~0x7fffffff, 0x7fffffff),\\n 'I': (0, 0xffffffff),\\n 'l': (~0x7fffffff, 0x7fffffff),\\n 'L': (0, 0xffffffff),\\n 'q': (~0x7fffffffffffffff, 0x7fffffffffffffff),\\n 'Q': (0, 0x7fffffffffffffff),\\n 'f': (sys.float_info.min, sys.float_info.max),\\n 'd': (sys.float_info.min, sys.float_info.max),\\n }\\n format_ = GetFieldDef(fielddef, fields='format_')\\n min_ = 0\\n max_ = 0\\n\\n if format_[-1:] in minmax:\\n min_, max_ = minmax[format_[-1:]]\\n max_ *= GetFormatCount(format_)\\n elif format_[-1:].lower() in ['s','p']:\\n # s and p may have a prefix as length\\n max_ = GetFormatCount(format_)\\n\\n return min_,max_\",\n \"def getminmax_linear_search(arr):\\n if len(arr) == 0:\\n return None, None\\n\\n if len(arr) == 1:\\n return arr[0], arr[0]\\n\\n min_num = None\\n max_num = None\\n if arr[0] > arr[1]:\\n max_num = arr[0]\\n min_num = arr[1]\\n else:\\n max_num = arr[1]\\n min_num = arr[0]\\n\\n for idx in range(2, len(arr)):\\n if min_num > arr[idx]:\\n min_num = arr[idx]\\n if max_num < arr[idx]:\\n max_num = arr[idx]\\n\\n return min_num, max_num\",\n \"def zminmax ( self ) :\\n return self.zvar.minmax()\",\n \"def yield_spectral_range(self) -> Tuple[float, float, float]:\\n return [min(self.x), max(self.x), len(self.x)]\",\n \"def hi_lo(data_series, current_max, current_min):\\n \\n try:\\n highest = numpy.max(data_series)\\n except:\\n highest = max(data_series)\\n \\n if highest > current_max:\\n new_max = highest\\n else:\\n new_max = current_max\\n \\n try: \\n lowest = numpy.min(data_series)\\n except:\\n lowest = min(data_series)\\n \\n if lowest < current_min:\\n new_min = lowest\\n else:\\n new_min = current_min\\n \\n return new_max, new_min\",\n \"def getRange(self) -> Tuple[int, int]:\\n return self.validator().bottom(), self.validator().top()\",\n \"def get_min_max(self):\\n\\n mr = np.sqrt(2 * np.log(1/self.mth)) * self.ms\\n mr[:] = np.max(mr)\\n\\n mxmin = self.mx - mr\\n mxmax = self.mx + mr\\n mymin = self.my - mr\\n mymax = self.my + mr\\n mzmin = self.mz - mr\\n mzmax = self.mz + mr\\n\\n mb_xmin_idx = np.argmin(mxmin[self.ma > 0])\\n mb_xmax_idx = np.argmax(mxmax[self.ma > 0])\\n mb_ymin_idx = np.argmin(mymin[self.ma > 0])\\n mb_ymax_idx = np.argmax(mymax[self.ma > 0])\\n mb_zmin_idx = np.argmin(mzmin[self.ma > 0])\\n mb_zmax_idx = np.argmax(mzmax[self.ma > 0])\\n\\n xmin0 = self.mx[mb_xmin_idx] - mr[mb_xmin_idx]\\n xmax0 = self.mx[mb_xmax_idx] + mr[mb_xmax_idx]\\n ymin0 = self.my[mb_ymin_idx] - mr[mb_ymin_idx]\\n ymax0 = self.my[mb_ymax_idx] + mr[mb_ymax_idx]\\n zmin0 = self.mz[mb_zmin_idx] - mr[mb_zmin_idx]\\n zmax0 = self.mz[mb_zmax_idx] + mr[mb_zmax_idx]\\n\\n xmin = xmin0 - (xmax0 - xmin0) * 0.25\\n xmax = xmax0 + (xmax0 - xmin0) * 0.25\\n ymin = ymin0 - (ymax0 - ymin0) * 0.25\\n ymax = ymax0 + (ymax0 - ymin0) * 0.25\\n zmin = zmin0 - (zmax0 - zmin0) * 0.25\\n zmax = zmax0 + (zmax0 - zmin0) * 0.25\\n\\n return xmin, xmax, ymin, ymax, zmin, zmax\",\n \"def getColMinMax(table, col):\\n\\tvmin = None\\n\\tvmax = None\\n\\tfor rec in table:\\n\\t\\tvalue = rec[col]\\n\\t\\tif vmin is None:\\n\\t\\t\\tvmin = value\\n\\t\\t\\tvmax = value\\n\\t\\telse:\\n\\t\\t\\tif value < vmin:\\n\\t\\t\\t\\tvmin = value\\n\\t\\t\\telif value > vmax:\\n\\t\\t\\t\\tvmax = value\\n\\treturn (vmin, vmax, vmax - vmin)\",\n \"def compare_select(self, x: torch.Tensor) -> [torch.Tensor, torch.LongTensor]:\\n reshaped_x = x.reshape(-1, self.n_states, 2)\\n max_values, absolute_max_ind = torch.max(reshaped_x, 2)\\n return max_values, absolute_max_ind\",\n \"def get_lims(data):\\n return data[:, 0].min() - 1, data[:, 0].max() + 1, data[:, 1].min() - 1, data[:, 1].max() + 1\",\n \"def _get_energy_range(self):\\n\\n e0_min = self.network.isomers[0].E0\\n e0_max = e0_min\\n\\n for isomer in self.network.isomers[1:]:\\n E0 = isomer.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for reactant in self.network.reactants:\\n E0 = reactant.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for product in self.network.products:\\n E0 = product.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for rxn in self.network.path_reactions:\\n E0 = rxn.transition_state.conformer.E0.value_si\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n\\n return e0_min, e0_max\",\n \"def get_bounds(self):\\r\\n left, bottom, front = 10000, 10000, 10000\\r\\n right, top, back = -10000, -10000, -10000\\r\\n for b in self.buf:\\r\\n for v in b.vertices:\\r\\n if v[0] < left:\\r\\n left = v[0]\\r\\n if v[0] > right:\\r\\n right = v[0]\\r\\n if v[1] < bottom:\\r\\n bottom = v[1]\\r\\n if v[1] > top:\\r\\n top = v[1]\\r\\n if v[2] < front:\\r\\n front = v[2]\\r\\n if v[2] > back:\\r\\n back = v[2]\\r\\n\\r\\n return (left, bottom, front, right, top, back)\",\n \"def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\\n\\n\\n dtype = min_broadcast.dtype\\n quant_min = 1 if narrow_range else 0\\n quant_max = (2 ** num_bits) - 1\\n\\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\\n\\n # caculate each channel max and min difference.\\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\\n # and min_div_scale = min_broadcast / scale\\n if product_is_mini():\\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\\n else:\\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\\n\\n # zero_point_from_min = quant_min_float - min_broadcast / scale\\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\\n\\n # according to above bool param to select effective value\\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\\n\\n # compute which num is not less than quant_min_float and not large than quant_max_float\\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\\n # add 0.5 to num which min <= num <= max and then floor them.\\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\\n if product_is_mini():\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float16\\\")\\n\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float32\\\")\\n\\n # calculate the maximum and minimum values of the quantization\\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\\n\\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\\n nudged_min = topi.multiply(nudged_min_tmp, scale)\\n nudged_max = topi.multiply(nudged_max_tmp, scale)\\n res = [nudged_min, nudged_max, scale]\\n\\n return res\",\n \"def get_max_min(block_size):\\r\\n return (int(block_size / 2), int((block_size - 1) / 2))\",\n \"def get_min_max(ints):\\n if len(ints) == 0:\\n return None, None\\n \\n min_e = ints[0]\\n max_e = ints[-1]\\n for e in ints:\\n if isinstance(e, int) == False: # if the list includes non-integer number, do not find min, max \\n return None,None\\n if e < min_e:\\n min_e = e\\n if e > max_e:\\n max_e = e\\n return min_e, max_e\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def range_(self):\\n return tuple((e[0], e[-1]) for e in self.edges)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72885597","0.6820047","0.6709689","0.6641923","0.661468","0.648229","0.64780694","0.6453788","0.64332044","0.6412223","0.6407123","0.63986015","0.63950133","0.63915455","0.6389562","0.63883317","0.6370339","0.63583744","0.6325942","0.629759","0.62925905","0.62804073","0.62690043","0.6263546","0.6241651","0.62414294","0.6240135","0.6239035","0.62382615","0.6236971","0.6222978","0.62102914","0.6204816","0.6203671","0.6198669","0.6191928","0.6191234","0.6190591","0.6182788","0.6174643","0.6171332","0.61711943","0.6160561","0.6158828","0.6157247","0.6144806","0.6143228","0.6142735","0.61409426","0.61353767","0.6134546","0.61343503","0.61335695","0.6129534","0.6114617","0.61081773","0.6097147","0.6096194","0.6095629","0.60932475","0.6084535","0.6075995","0.6067781","0.6066338","0.6048437","0.6034888","0.60329545","0.60235894","0.59961635","0.5992842","0.59924823","0.5973669","0.5957575","0.5947248","0.594655","0.59382915","0.5924997","0.5913877","0.5894166","0.58914983","0.5883603","0.58807325","0.5880488","0.58769315","0.5868057","0.5867279","0.5854983","0.5848413","0.5845814","0.58454543","0.5842041","0.58377486","0.58346266","0.58188796","0.5811431","0.58110946","0.5810921","0.58085555","0.58084714","0.58082694"],"string":"[\n \"0.72885597\",\n \"0.6820047\",\n \"0.6709689\",\n \"0.6641923\",\n \"0.661468\",\n \"0.648229\",\n \"0.64780694\",\n \"0.6453788\",\n \"0.64332044\",\n \"0.6412223\",\n \"0.6407123\",\n \"0.63986015\",\n \"0.63950133\",\n \"0.63915455\",\n \"0.6389562\",\n \"0.63883317\",\n \"0.6370339\",\n \"0.63583744\",\n \"0.6325942\",\n \"0.629759\",\n \"0.62925905\",\n \"0.62804073\",\n \"0.62690043\",\n \"0.6263546\",\n \"0.6241651\",\n \"0.62414294\",\n \"0.6240135\",\n \"0.6239035\",\n \"0.62382615\",\n \"0.6236971\",\n \"0.6222978\",\n \"0.62102914\",\n \"0.6204816\",\n \"0.6203671\",\n \"0.6198669\",\n \"0.6191928\",\n \"0.6191234\",\n \"0.6190591\",\n \"0.6182788\",\n \"0.6174643\",\n \"0.6171332\",\n \"0.61711943\",\n \"0.6160561\",\n \"0.6158828\",\n \"0.6157247\",\n \"0.6144806\",\n \"0.6143228\",\n \"0.6142735\",\n \"0.61409426\",\n \"0.61353767\",\n \"0.6134546\",\n \"0.61343503\",\n \"0.61335695\",\n \"0.6129534\",\n \"0.6114617\",\n \"0.61081773\",\n \"0.6097147\",\n \"0.6096194\",\n \"0.6095629\",\n \"0.60932475\",\n \"0.6084535\",\n \"0.6075995\",\n \"0.6067781\",\n \"0.6066338\",\n \"0.6048437\",\n \"0.6034888\",\n \"0.60329545\",\n \"0.60235894\",\n \"0.59961635\",\n \"0.5992842\",\n \"0.59924823\",\n \"0.5973669\",\n \"0.5957575\",\n \"0.5947248\",\n \"0.594655\",\n \"0.59382915\",\n \"0.5924997\",\n \"0.5913877\",\n \"0.5894166\",\n \"0.58914983\",\n \"0.5883603\",\n \"0.58807325\",\n \"0.5880488\",\n \"0.58769315\",\n \"0.5868057\",\n \"0.5867279\",\n \"0.5854983\",\n \"0.5848413\",\n \"0.5845814\",\n \"0.58454543\",\n \"0.5842041\",\n \"0.58377486\",\n \"0.58346266\",\n \"0.58188796\",\n \"0.5811431\",\n \"0.58110946\",\n \"0.5810921\",\n \"0.58085555\",\n \"0.58084714\",\n \"0.58082694\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58876115"},"document_rank":{"kind":"string","value":"80"}}},{"rowIdx":579,"cells":{"query":{"kind":"string","value":"The agent take the given action and receives back the new state, reward, whether the episode is terminated and some nothingness."},"document":{"kind":"string","value":"def step(self, action):\n x, y = self._move(action, *self._currentPos)\n\n if chr(self._grid[x, y]) == CASE_TYPES.Wall:\n # error - previous state was already a wall\n self._done = True\n self._trajectory.append(self._currentPos)\n return self._currentPos, -1, self._done, {}\n\n reward = {\n CASE_TYPES.Water: self.waterReward,\n CASE_TYPES.Sand: self.sandReward,\n CASE_TYPES.Open: self.stepReward,\n CASE_TYPES.Termination: self.successReward,\n CASE_TYPES.Trap: (\n -(self.maxSteps - len(self._trajectory)) + self.failureReward +\n self.trapReward)\n }[chr(self._grid[x, y])]\n\n # termination state\n if chr(self._grid[x, y]) in [CASE_TYPES.Termination, CASE_TYPES.Trap]:\n self._done = True\n\n self._currentPos = (x, y)\n\n self._trajectory.append(self._currentPos)\n self._nbSteps += 1\n\n if self._nbSteps >= self.maxSteps and not self._done:\n reward += self.failureReward\n\n return self._currentPos, reward, self._done, {}"},"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 agent_step(self, reward, state):\n self.sum_rewards += reward\n self.episode_steps += 1\n\n # Make state an array of shape (1, state_dim) to add a batch dimension and\n # to later match the get_action_values() and get_TD_update() functions\n state = np.array(state)\n\n # Select action\n action = self.policy(state)\n \n # Append new experience to replay buffer\n self.replay_buffer.append(self.last_state, self.last_action, reward, 0, state)\n \n # Perform replay steps:\n if self.replay_buffer.size() > self.replay_buffer.minibatch_size:\n self.network_target.load_state_dict(self.network.state_dict())\n for _ in range(self.num_replay):\n # Get sample experiences from the replay buffer\n experiences = self.replay_buffer.sample() \n self.optimize_network(experiences)\n \n # Update the last state and last action.\n self.last_state = state\n self.last_action = action\n \n return action","def step(self, action):\n\n ob = self.sendCmd(self.url, self.actions_list[action])\n print(\"ob -> {}\".format(ob['obsequium']))\n\n self.obsequium = int(ob[\"obsequium\"])\n self.bonus = int(ob[\"bonus\"])\n\n # we need to check is make sense finish it\n if self.is_game_done:\n raise RuntimeError(\"Episode is done\")\n self.curr_step += 1\n self._take_action(action)\n\n reward = self._get_reward()\n\n # TODO: revisar ob = self._get_state()\n\n return ob, reward, self.is_game_done, {}","def step(self, action):\n assert action in self.infoset.legal_actions\n self.players[self._acting_player_position].set_action(action)\n self._env.step()\n self.infoset = self._game_infoset\n done = False\n reward = 0.0\n if self._game_over:\n done = True\n reward = {\n \"play\": {\n \"landlord\": self._get_reward(\"landlord\"),\n \"landlord_up\": self._get_reward(\"landlord_up\"),\n \"landlord_down\": self._get_reward(\"landlord_down\")\n },\n \"bid\": {\n \"landlord\": self._get_reward_bidding(\"landlord\")*2,\n \"landlord_up\": self._get_reward_bidding(\"landlord_up\"),\n \"landlord_down\": self._get_reward_bidding(\"landlord_down\")\n }\n }\n obs = None\n else:\n obs = get_obs(self.infoset)\n return obs, reward, done, {}","def step(self, action: ActionType) -> EnvResponse:\n action = self.action_space.clip_action_to_space(action)\n if self.action_space and not self.action_space.contains(action):\n raise ValueError(\"The given action does not match the action space definition. \"\n \"Action = {}, action space definition = {}\".format(action, self.action_space))\n\n # store the last agent action done and allow passing None actions to repeat the previously done action\n if action is None:\n action = self.last_action\n self.last_action = action\n if self.visualization_parameters.add_rendered_image_to_env_response:\n current_rendered_image = self.get_rendered_image()\n\n self.current_episode_steps_counter += 1\n if self.phase != RunPhase.UNDEFINED:\n self.total_steps_counter += 1\n\n # act\n self._take_action(action)\n\n # observe\n self._update_state()\n\n if self.is_rendered:\n self.render()\n\n self.total_reward_in_current_episode += self.reward\n\n if self.visualization_parameters.add_rendered_image_to_env_response:\n self.info['image'] = current_rendered_image\n\n self.last_env_response = \\\n EnvResponse(\n reward=self.reward,\n next_state=self.state,\n goal=self.goal,\n game_over=self.done,\n info=self.info\n )\n\n # store observations for video / gif dumping\n if self.should_dump_video_of_the_current_episode(episode_terminated=False) and \\\n (self.visualization_parameters.dump_mp4 or self.visualization_parameters.dump_gifs):\n self.last_episode_images.append(self.get_rendered_image())\n\n return self.last_env_response","def step(self, action):\n \n success = False\n self.curr_step += 1\n self._take_action(action)\n self._take_action(action)\n self._take_action(action)\n\n # initialize reward and get state \n reward = 0.0\n ob = self._get_state()\n\n # give dense rewards \n if not self.sparse_reward:\n reward = self._get_reward()\n\n # bad terminal conditions\n if self.curr_step >= self.max_steps \\\n or self.target_distance >= self.max_distance \\\n or self.mean_radius_sheep >= self.max_radius:\n self.finish = True\n if self.sparse_reward:\n reward = -1.0\n\n # good terminal conditions\n if self.target_distance <= 1.0:\n success = True\n self.finish = True\n if self.sparse_reward:\n reward = 1.0\n\n # update rl parameters\n self.episode_length += 1\n self.episode_reward += reward\n\n # generate info return parameter\n if self.info_mode == 1 and self.finish:\n info = {'r':self.episode_reward, 'l':self.episode_length, \n 's': success}\n else:\n info = {'n':self.num_sheep, 's': success}\n\n return ob, reward, self.finish, info","def step(self, action):\r\n\r\n max_time = len(self.episode) - 1 # the number of states available in the episode , -1 for indexing purpose\r\n state = self.episode[self.t] # state contains LT, ST indicator, closing price\r\n closing_price = state['Close']\r\n transaction_fee = self.transaction_fee\r\n agent = self.agent\r\n reward = 0\r\n \r\n if self.t < max_time-1:\r\n if agent.stock == 0: # if there is no stock position the agent can buy or do nothing\r\n if action == 1: # buy sstock at closing price\r\n agent.stock_position = agent.starting_cash / closing_price * (1 - transaction_fee)\r\n agent.cash = 0\r\n agent.stock = 1\r\n reward = 0\r\n elif action == 0: # no action\r\n reward = 0\r\n else:\r\n reward = -10000\r\n \r\n elif agent.stock == 1: # if there is a stock position the agent can sell or do nothing\r\n if action == 2: # sell stock at closing price\r\n agent.cash = agent.stock_position * closing_price * (1 - transaction_fee)\r\n reward = agent.cash - agent.starting_cash\r\n self.done = True\r\n elif action == 0: # no action\r\n reward = 0\r\n elif action == 1:\r\n reward = -10000\r\n \r\n elif self.t == max_time-1:\r\n if agent.stock == 1:\r\n # stock position is forced to liquidate\r\n agent.cash = agent.stock_position * closing_price * (1 - transaction_fee)\r\n reward = agent.cash - agent.starting_cash\r\n self.done = True\r\n \r\n else:\r\n reward = 0\r\n self.done = True \r\n \r\n next_state = (self.episode[self.t+1]['ST Relative Indicator'], \r\n self.episode[self.t+1]['ST Relative Indicator'],\r\n agent.stock,\r\n self.t+1)\r\n self.t += 1\r\n \r\n return next_state, reward, self.done","def step(self, action):\n # check if suggested action is valid\n valid = self._take_action(action)\n if not valid:\n _, _ = self._simulate()\n response = self.worst_response\n target = 6*60\n else:\n # simulate until a TS response is needed\n response = np.inf\n while response == np.inf:\n response, target = self._simulate()\n if np.isnan(target): # prio 2 or 3 incident: no target exists\n target = response\n\n self.last_action = action if self.action_type == \"tuple\" else self.action_num_to_tuple[action]\n # calculate reward and new state\n self.reward = self._get_reward(response, target, valid=valid)\n self.state, self.is_done = self._extract_state()\n return self.state, self.reward, self.is_done, {\"note\": \"nothing to report\"}","def _step(self, action):\n\n reward = 0.0\n x, y = action\n\n if not Creator.add_edge(self.nxgraph, x+1, y+1):\n reward = 0.0\n # TODO: do we return here?\n raise NotImplementedError\n else:\n reward = 1.0\n new_state = EnvTools.get_state(self.nxgraph)\n EnvTools.calculate_reward(self.state, self.previous_state)\n raise NotImplementedError\n\n\n\n pass","def step(self, action):\n obs = self.gym.get_observations()\n all_actions = self.gym.act(obs)\n all_actions.insert(self.gym.training_agent, action)\n state, reward, terminal, info = self.gym.step(all_actions)\n agent_state = self.featurize(state[self.gym.training_agent])\n\n # agent_state_history = self.make_observation(agent_state, self.step)\n agent_reward = reward[self.gym.training_agent]\n\n # self.step += 1\n return agent_state, agent_reward, terminal, info","def step(self, action):\n\n action[1] = 0 if action[1] < 0 else 1\n\n if not self.moving:\n self.agent_host.sendCommand(\"move 0.5\")\n time.sleep(.2)\n self.moving = True\n\n # Get Action\n command = \"strafe \" + str(action[0])\n if ((action[0] < 0 and self.allow_left) or (action[0] > 0 and self.allow_right)):\n self.agent_host.sendCommand(command)\n time.sleep(.2)\n self.agent_host.sendCommand(\"strafe 0\")\n time.sleep(.1)\n\n if action[1]:\n if self.checkCommand:\n self.jumpsOverDitches += 1\n self.checkCommand = False\n self.agent_host.sendCommand(\"jump 1\")\n time.sleep(.2)\n self.agent_host.sendCommand(\"jump 0\")\n\n # if (command == \"crouch 1\"):\n # self.agent_host.sendCommand(command)\n # time.sleep(.3)\n # self.agent_host.sendCommand(\"crouch 0\")\n # time.sleep(.2)\n\n self.episode_step += 1\n\n # Get Observation\n world_state = self.agent_host.getWorldState()\n for error in world_state.errors:\n print(\"Error:\", error.text)\n self.obs, self.allow_left, self.allow_right, curZPos, curXPos = self.get_observation(world_state)\n if curZPos:\n self.curZPos = curZPos\n if curXPos:\n if self.obs[3 + int(curXPos)]:\n self.checkCommand = True\n self.numDitchesEncountered += 1\n\n # Get Done\n done = not world_state.is_mission_running \n\n # Get Reward\n reward = 0\n for r in world_state.rewards:\n reward += r.getValue()\n self.episode_return += reward\n\n return self.obs, reward, done, dict()","def step(self, action):\n done = self.cur_step >= self.max_steps_per_episode\n\n if done:\n raise RuntimeError(\"Episode is done\")\n\n self.cur_step += 1\n\n # Compute new state based on previous state and action\n new_state = self._take_action(action)\n\n # Compute reward value based on previous state and action\n reward = self._get_reward(action)\n\n # Update current state to new state\n self.cur_state = new_state\n\n # Compute observation from current state\n ob = self._get_obs() # Has to come after new state update\n\n # Update action, observation and reward histories\n self.action_episode_memory[self.cur_episode].append(action)\n self.observation_episode_memory[self.cur_episode].append(ob)\n self.reward_episode_memory[self.cur_episode].append(reward)\n\n # Recompute done since action may have modified it\n done = self.cur_step >= self.max_steps_per_episode\n\n return ob, reward, done, {}","def step(self, action):\r\n reward = self.__execute(action)\r\n self.__totalReward += reward\r\n status = self.__status()\r\n state = self.__observe()\r\n logging.debug(\"action: {:10s} | reward: {: .2f} | status: {}\".format(Action(action).name, reward, status))\r\n return state, reward, status","def _step(self, action):\n if self._episode_ended:\n # The last action ended the episode. Ignore the current action and start a new episode\n return self.reset()\n\n env_action = self.y_train[self.id[self.episode_step]]\n self.episode_step += 1\n\n if action == env_action: # Correct action\n if env_action: # Minority\n reward = 1 # True Positive\n else: # Majority\n reward = self.imb_rate # True Negative\n\n else: # Incorrect action\n if env_action: # Minority\n reward = -1 # False Negative\n self._episode_ended = True # Stop episode when minority class is misclassified\n else: # Majority\n reward = -self.imb_rate # False Positive\n\n if self.episode_step == self.X_len - 1: # If last step in data\n self._episode_ended = True\n\n self._state = self.X_train[self.id[self.episode_step]] # Update state with new datapoint\n\n if self._episode_ended:\n return ts.termination(self._state, reward)\n else:\n return ts.transition(self._state, reward)","def step(self, action):\n self.t += 1\n if self.use_run_time_assurance:\n probe_state, unsafe = self.probe_step(action)\n # switch to safe controller if unsafe\n if unsafe:\n x, x_dot, theta, theta_dot = probe_state\n # go right\n if x <= -self.x_threshold: # go right\n action = 1\n elif x>= self.x_threshold: # go left\n action = 0 \n \n state, reward, done, info = self.env.step(action)\n # Could make a custom reward here if you want\n if self.use_action_masking:\n self.update_avail_actions(state)\n obs = {\n \"action_mask\": self.action_mask,\n \"actual_obs\": state,\n }\n else:\n obs = state\n \n if self.t >= 200: # ------ change if using v1\n done = True\n return obs, reward, done, info","def step(self, action):\n\n \"\"\"\n Here we should convert the action num to movement action, execute the action in the\n simulation and get the observations result of performing that action.\n \"\"\"\n #if self.step_number > 200:\n #self.reset()\n rospy.logdebug(\"START STEP OpenAIROS\")\n\n self.gazebo.unpauseSim()\n self._set_action(action)\n #self._prey_step()\n self.gazebo.pauseSim()\n obs = self._get_obs()\n done = self._is_done(obs)\n info = {}\n reward = self._compute_reward(obs, done)\n \n self.cumulated_episode_reward = self.cumulated_episode_reward+ reward\n self.step_number += 1\n rospy.logdebug(\"END STEP OpenAIROS\")\n\n return obs, reward, done, info","def _single_agent_step(self, action):\n reward = 0.0\n done = False\n self.timestep += 1\n state, player_id = self.game.step(action)\n while not self.game.is_over() and not player_id == self.active_player:\n self.timestep += 1\n action, _ = self.model.agents[player_id].eval_step(\n self._extract_state(state)\n )\n if not self.model.agents[player_id].use_raw:\n action = self._decode_action(action)\n state, player_id = self.game.step(action)\n\n if self.game.is_over():\n reward = self.get_payoffs()[self.active_player]\n done = True\n state = self.reset()\n return state, reward, done\n\n return self._extract_state(state), reward, done","def step(self, action, skiprate=1):\n reward = self.game.make_action(action, skiprate)\n next_state = self.game.get_state()\n game_over = self.game.is_episode_finished()\n return next_state, reward, game_over","def act(self, state):\n # Append the state to the short term memory (ie. History)\n self._history.append(state)\n\n # If policy requires agent to explore, sample random action\n if self._explorer.is_exploring(self._num_actions_taken):\n action = self._explorer(self.nb_actions)\n else:\n # Use the network to output the best action\n env_with_history = self._history.value\n q_values = self._action_value_net.eval(\n # Append batch axis with only one sample to evaluate\n env_with_history.reshape((1,) + env_with_history.shape)\n )\n\n self._episode_q_means.append(np.mean(q_values))\n self._episode_q_stddev.append(np.std(q_values))\n\n # Return the value maximizing the expected reward\n action = q_values.argmax()\n\n # Keep track of interval action counter\n self._num_actions_taken += 1\n return action","def run_one_step(self):\n # Get the current state, action and initialise the reward\n state = copy.copy(self.env.get_state())\n action = self.agent.get_action(state)\n reward = 0.0\n # Check if the environment has reached a terminal state\n if self.env.check_terminal() is False:\n # Save the initial state and action to an 'experience'\n latest_experience = Experience(copy.copy(state), copy.copy(action))\n # Update the environment using the chosne action\n self.env.update(action)\n # Get the reward to attribute to the agent and save to the experience to save\n reward = self.env.get_reward()\n latest_experience.reward = copy.copy(reward)\n # Get the updated state\n state = self.env.get_state()\n if self.env.check_terminal() is False:\n # If the new state isn't terminal, save the next action and the 'done' flag to the experience\n action = self.agent.get_action(state)\n latest_experience.done = False\n else:\n # If the new state is terminal, save a dummy action and the 'done' flag to the experience\n action = 0.0\n latest_experience.done = True\n latest_experience.next_state = copy.copy(state)\n latest_experience.next_action = copy.copy(action)\n # Update the history with the latest experience\n self.agent.update_history(copy.copy(latest_experience))\n # Update the agents policy using a batch of experiences chosen from the history\n self.agent.update_policy_batch(max(1, self.batch_size))\n self.count += 1\n # Update the target network if appropriate\n if self.update_target_rate is not None:\n if self.count % self.update_target_rate == 0:\n self.agent.policy.learner.update_target_network()\n else:\n # If the environment is in a terminal state, record this and perform a policy update\n latest_experience = Experience(copy.copy(state), copy.copy(action))\n latest_experience.reward = 0.0\n latest_experience.next_state = copy.copy(state)\n latest_experience.next_action = 0.0\n latest_experience.done = True\n self.agent.update_history(copy.copy(latest_experience))\n self.agent.update_policy_batch(max(1, self.batch_size))\n self.count = 0\n return reward","def step(self,action):\n observation, reward, done, info = self.env.step(action)\n if info[\"health\"] <= 0 or info[\"enemy_health\"] <= 0:\n self.player_hp = 120\n self.enemy_hp = 120\n reward = 0\n else:\n self.player_hp = info['health']\n self.enemy_hp = info[\"enemy_health\"]\n reward = self.player_hp - self.enemy_hp\n\n\n if info[\"enemy_rounds_won\"] == 2 or info[\"rounds_won\"] == 2:\n self.player_hp = 120\n self.enemy_hp = 120\n reward = 0\n done = True\n\n obs = self.observation(observation)\n if self.current_frame_number == self.frame_skipping:\n self.q.append(obs)\n self.current_frame_number = 0 \n self.current_frame_number += 1\n reward = reward / 120 +1\n return np.array(list(self.q)), reward, done, info","def agent_step(self, reward, observation):\n\n self.step_counter += 1\n return_action = Action()\n\n current_image, raw_image = self.preprocess_observation(observation.intArray)\n\n # if self.step_counter % 100 == 0:\n # plt.imshow(current_image)\n # plt.colorbar()\n # plt.show()\n # time.sleep(0.4)\n\n #TESTING---------------------------\n if raw_image is not None:\n self.episode_images.append(raw_image)\n self.episode_reward += reward\n int_action, max_q = self.choose_action(self.test_data_set, self.testing_epsilon,\n current_image, np.clip(reward, -1, 1))\n if max_q is not None:\n self.epoch_considered_steps += 1\n\n if self.pause > 0:\n time.sleep(self.pause)\n\n # Map it back to ALE's actions\n return_action.intArray = [int_action]\n\n self.last_action = int_action\n self.last_image = current_image\n\n return return_action","def step(self, action):\n assert self.action_space.contains(\n action), \"%r (%s) invalid\" % (action, type(action))\n self.time_step += 1\n reward = float(0)\n self.is_episode_done = False\n\n # For testing code\n current_edge_agg_num = self.time_step\n\n # Rescale the action from [-1, 1] to [1, 2, ... , 9]\n # The action is the number of aggregations on edge servers\n # current_edge_agg_num = int((action + 2) * (action + 2))\n\n logging.info(\"RL Agent: Start time step #%s...\", self.time_step)\n logging.info(\n \"Each edge server will run %s rounds of local aggregation.\",\n current_edge_agg_num)\n\n # Pass the tuned parameter to RL agent\n self.rl_agent.get_tuned_para(current_edge_agg_num, self.time_step)\n\n # Wait for state\n current_loop = asyncio.get_event_loop()\n get_state_task = current_loop.create_task(self.wait_for_state())\n current_loop.run_until_complete(get_state_task)\n #print('State:', self.state)\n\n self.normalize_state()\n #print('Normalized state:', self.state)\n\n reward = self.get_reward()\n info = {}\n\n self.rl_agent.cumulative_reward += reward\n\n # Signal the RL agent to start next time step (next round of FL)\n self.step_done.set()\n\n return np.array([self.state]), reward, self.is_episode_done, info","def step(self, action):\n\n if not self._is_action_legal(action):\n return self.current_state, self.reward_illegal_action, self._is_terminal_state(), None\n else:\n # Change action passed if environment should behave random\n if self.stochastic:\n if not np.random.choice([True, False], 1, p=[self.p, 1 - self.p]):\n action = np.random.choice(self.possible_actions)\n\n # Needed for reward calculation (must be done before updating data structures)\n number_of_shifts = self._get_number_of_shifts(action)\n is_cargo_mandatory = int(self.vehicle_data[2][action] == 1)\n\n slot = self.end_of_lanes[self.current_Lane]\n self.loading_sequence += \"{}. Load Vehicle Type \\t {} \\t in Lane: \\t {} \\t Row: \\t {} \\n\" \\\n .format(self.sequence_no, action, self.current_Lane, slot)\n\n self.end_of_lanes[self.current_Lane] += self.vehicle_data[4][action]\n\n if self.vehicle_data[1][action] == -1 or \\\n self.number_of_vehicles_loaded[action] < self.vehicle_data[1][action]:\n self.number_of_vehicles_loaded[action] += 1\n\n self.loaded_vehicles[self.current_Lane][self.vehicle_Counter[self.current_Lane]] = action\n self.vehicle_Counter[self.current_Lane] += 1\n\n # Update grids\n for i in range(self.vehicle_data[4][action]):\n self.grid.T[self.current_Lane][slot + i] = self.sequence_no\n self.grid_destination.T[self.current_Lane][slot + i] = self.vehicle_data[3][action]\n self.grid_vehicle_type.T[self.current_Lane][slot + i] = self.vehicle_data[0][action]\n\n # Update lowest destination data structure\n if self.vehicle_data[3][action] < self.lowest_destination[self.current_Lane]:\n self.lowest_destination[self.current_Lane] = self.vehicle_data[3][action]\n\n self.sequence_no += 1\n # Update according to lane selection heuristic\n self.current_Lane = self._get_minimal_lanes()[0]\n\n self.possible_actions = self.get_possible_actions_of_state()\n self.current_state = self._get_current_state()\n\n if self._is_terminal_state():\n # Calculate reward for terminal state\n free_spaces = np.sum(self._get_free_capacity()) / np.sum(self.total_capacity)\n mandatory_vehicles_left_to_load = np.sum(self.vehicle_data[1][self.mandatory_cargo_mask]\n - self.number_of_vehicles_loaded[self.mandatory_cargo_mask])\n reward_features = np.array(\n [is_cargo_mandatory, number_of_shifts, free_spaces, mandatory_vehicles_left_to_load])\n reward = np.dot(self.reward_system, reward_features) + self.zeta\n\n return self.current_state, reward, True, {}\n else:\n # Calculate reward\n reward_features = np.array([is_cargo_mandatory, number_of_shifts, 0, 0])\n reward = np.dot(self.reward_system, reward_features) + self.zeta\n\n return self.current_state, reward, False, {}","def step(self, action):\n # if self.current_turn<self.MAX_TURNS-1:\n # self.current_turn += 1\n \n\n self.current_turn += 1\n system_action = self.parseAction(action)\n \n # Used for logging and evaluation\n self.updateMetaState(system_action)\n\n self.processSystemAction(system_action)\n\n reward = self.calculateReward()\n\n user_action = self.user.respond(system_action)\n self.processUserAction(user_action)\n observation = self.generateObservation()\n done = self.isDone()\n if done:\n info = { \"successful\": self.user.goals[\"satisfied\"], \n \"first-appearance\": self.first_appearance, \n \"turn-penalty\": self.current_turn,\n \"sugg-all-penalty\":self.sugg_penalty,\n \"info-all-penalty\": self.info_penalty,\n \"eli-kw-used\": self.eli_kw_observed,\n \"eli-query-used\": self.eli_query_observed,\n }\n else:\n info = {}\n if self.training:\n if done and self.user.goals[\"satisfied\"]: reward+=30\n return observation, reward, done, info","def step(self, action):\n self.t += 1\n state, reward, done, info = self.env.step(action)\n if self.use_action_masking:\n self.update_avail_actions(state)\n obs = {\n \"action_mask\": self.action_mask,\n \"actual_obs\": state,\n }\n else:\n obs = state\n \n if self.t >= 200: # ------ change if using v1\n done = True\n return obs, reward, done, info","def step(self, reward, observation):\n self._last_observation = self._observation\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._store_transition(self._last_observation, self.action, reward, False)\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn)\n self.action = onp.asarray(self.action)\n return self.action","def act(self, action:Action) -> None:\r\n if self.terminated:\r\n raise ValueError # must restart mdp first, as agent already took Terminate action on terminal\r\n\r\n if action == Action.TERMINAL:\r\n self.terminated = True\r\n return\r\n\r\n if uniform(0, 1) < self.failure:\r\n action = action.turn(uniform(0, 1) <= 0.5) # clockwise or counter-clockwise with equal chance for both\r\n print(\"FAIL:\", action)\r\n\r\n dx, dy = action.delta()\r\n x, y = self.agent_x+dx, self.agent_y+dy\r\n\r\n if x < 0 or x >= len(self.fields) or y < 0 or y >= len(self.fields[0]) or self.fields[x][y] == Field.OBSTACLE:\r\n return\r\n\r\n self.agent_x = x\r\n self.agent_y = y","def _step(self, action):\n\n # action is generated from the action_policy (external to the environment)\n if len(action) == 4:\n object_index, new_location, action_means, action_stds = action\n if len(action) == 2:\n \"\"\"\n Action is not generated from a Gaussian distribution\n \"\"\"\n object_index, new_location = action\n action_means = action_stds = None\n \n position = new_location[:2]\n rotation = new_location[2]\n\n prev_transform = self.e.objects[object_index].transform\n\n if len(self.action_storage) > 0:\n last_progress = self.action_storage[-1][4]\n else:\n last_progress = 0\n\n info = {}\n if self.e.act(object_index, Command(position, rotation)):\n # print ('Action accepted')\n cur_transform = self.e.objects[object_index].transform\n # I need to call self.action_storage.append before get_observation_and_progress\n self.action_storage.append( [object_index, prev_transform, cur_transform, None, None, True, action_means, action_stds] )\n observation, progress = self.get_observation_and_progress()\n self.action_storage[-1][3:5] = [observation, progress]\n\n info['action_accepted'] = True\n else:\n \"\"\"\n Action failed\n We can reduce the progress to avoid falling out of the table\n \"\"\"\n if len(self.action_storage) > 0:\n # Just return observation and progress of last action\n _, _, _, observation, progress, _, _, _ = self.action_storage[-1]\n progress -= self.config.failed_action_penalty\n else:\n # First action failed\n observation, _ = self.get_observation_and_progress()\n progress = -self.config.failed_action_penalty\n \n self.action_storage.append( [object_index, prev_transform, prev_transform, observation, progress, False, action_means, action_stds] )\n\n \n info['action_accepted'] = False\n\n # Typical threshold approach\n if progress > self.progress_threshold:\n # Finish action\n done = True\n else:\n done = False\n \n reward = progress - last_progress\n #print ('Progress = %.2f ; reward = %.2f' % (progress, reward))\n\n return (observation, reward, done, info)","def step(self, action):\r\n s = self.get_state()\r\n\r\n elements = np.arange(self.S)\r\n # weights = np.squeeze(self.nextStateProbability[s,action])\r\n weights = self.nextStateProbability[s, action]\r\n nexts = choices(elements, weights, k=1)[0]\r\n\r\n # p = self.nextStateProbability[s,action]\r\n # reward = self.rewardsTable[s,action, nexts][0]\r\n reward = self.rewardsTable[s, action, nexts]\r\n\r\n # fully observable MDP: observation is the actual state\r\n self.currentObservation = nexts\r\n\r\n gameOver = False\r\n if self.currentIteration > np.Inf:\r\n ob = self.reset()\r\n gameOver = True # game ends\r\n else:\r\n ob = self.get_state()\r\n\r\n history = {\"time\": self.currentIteration, \"state_t\": s, \"action_t\": action,\r\n \"reward_tp1\": reward, \"state_tp1\": nexts}\r\n # history version with actions and states, not their indices\r\n # history = {\"time\": self.currentIteration, \"action_t\": self.actionListGivenIndex[action],\r\n # \"reward_tp1\": reward, \"observation_tp1\": self.stateListGivenIndex[self.get_state()]}\r\n self.currentIteration += 1\r\n return ob, reward, gameOver, history","def step(self, action: int):\n assert self.action_space.contains(action)\n loc = action\n if self.done:\n return self._get_obs(), 0, True, None\n\n reward = NO_REWARD\n # update bord\n self.board[loc] = to_code(self.mark)\n\n # check if game has ended\n status = check_game_status(self.board)\n if status >= 0:\n self.done = True\n if status in [1, 2]:\n reward = O_REWARD if self.mark == 'O' else X_REWARD\n\n # update mark\n self.mark = next_mark(self.mark)\n\n return self._get_obs(), reward, self.done, None","def step(self, reward, observation):\n self._last_observation = self._observation\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._store_transition(self._last_observation, self.action, reward, False)\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_quantile_samples,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn,\n self._tau,\n self.optimizer)\n self.action = onp.asarray(self.action)\n return self.action","def execute_action(self, agent, action):\n agent.bump = False\n agent.performance_measure -= 1\n \n if action == 'TurnRight':\n agent.heading = self.turn_heading(agent.heading, -1)\n elif action == 'TurnLeft':\n agent.heading = self.turn_heading(agent.heading, +1)\n elif action == 'Forward':\n self.move_to(agent, vector_add(self.heading_to_vector(agent.heading),\n agent.location))\n elif action == 'Grab':\n if self.some_things_at(agent.location, tclass=Gold):\n try:\n gold = self.list_things_at(agent.location, tclass=Gold)[0]\n agent.has_gold = True\n self.delete_thing(gold)\n except:\n print \"Error: Gold should be here, but couldn't find it!\"\n print 'All things:', self.list_things_at(agent.location)\n print 'Gold?:', self.list_things_at(agent.location, tclass=Gold)\n sys.exit(-1)\n\n elif action == 'Release':\n if agent.location == self.entrance:\n if agent.has_gold:\n agent.performance_measure += 1000\n self.done = True\n elif action == 'Shoot':\n if agent.has_arrow:\n agent.has_arrow = False\n agent.performance_measure -= 10\n self.shoot_arrow(agent)\n elif action == 'Stop':\n self.done = True\n \n print '\\nCurrent Location: ', agent.location\n print 'Heading: ', self.heading_to_str(agent.heading)\n print 'Reminder- Start Location:', self.entrance\n print ''\n print 'Percepts:'","def step(self, action):\n res = self.reward_table.get(self.curr_state, action)\n\n self.curr_state = res['result']\n\n return res","def perform_action(self, action):\n \n assert self.is_valid_action(action)\n \n # Save the action.\n self.action = action\n \n #the slight strategy of the opponent\n if self.reward==rLose :\n observation = self.observation\n else:\n observation = random.choice([oRock,oPaper,oScissor])\n \n #determine the result of the game and get the reward\n if action == aRock:\n if observation == oRock:\n reward= rDraw\n elif observation == oPaper:\n reward= rLose\n elif observation == oScissor:\n reward= rWin\n elif action == aPaper:\n if observation == oRock:\n reward= rWin\n elif observation == oPaper:\n reward= rDraw\n elif observation == oScissor:\n reward= rLose\n elif action == aScissor:\n if observation == oRock:\n reward= rLose\n elif observation == oPaper:\n reward= rWin\n elif observation == oScissor:\n reward= rDraw\n \n \n #Store the observation and reward in the environment.\n self.observation = observation\n \n self.reward = reward\n \n \n return (observation, reward)\n # end def","def step (self, action):\n if self.done == 1:\n print(\"episode done\")\n return [self.state, self.reward, self.done, self.info]\n\n else:\n degree = float(action[0] * HI_ANGLE)\n loc, last_pos = self.state\n\n theta = self.fire.deg_to_rad(degree)\n pos = round(self.fire.calc_dist(theta))\n delta = abs(loc - pos)\n\n self.state[1] = pos\n self.info[\"degree\"] = degree\n self.info[\"theta\"] = round(theta, 3)\n self.info[\"delta\"] = delta\n\n self.render()\n\n if pos <= self.fire.radius:\n # realistically, the launch crew should be dead\n self.reward = -100.0\n elif delta <= self.fire.radius:\n # target hit (within blast radius)\n self.reward = 100.0\n self.done = 1;\n else:\n # reward is the \"nearness\" of the blast destroying the target\n self.reward = round(100.0 * float(abs(loc - delta)) / float(self.fire.range))\n\n return [self.state, self.reward, self.done, self.info]","def step(self, action):\n self.steps += 1\n self.robots[0].setAction(action)\n for i in range(self.num_agents):\n if i != 0 and self.policies[i:i+1]: # self.policies[0] is dummy\n self.robots[i].setAction(self.policies[i](self.robots[i].getObservation()))\n # rewards = [ -1.0 * self.num_foods / self.max_steps for _ in range(self.num_agents) ] # so agent needs to eat foods quickly\n rewards = [ 0.0 for _ in range(self.num_agents) ]\n for i in range(self.BULLET_STEPS):\n p.stepSimulation()\n rewards = [ rewards[i]+self._getReward(self.robots[i]) for i in range(self.num_agents) ]\n self.episode_rewards = [ self.episode_rewards[i]+rewards[i] for i in range(self.num_agents) ]\n obs = self.robots[0].getObservation()\n done = self._isDone()\n info = { 'steps': self.steps }\n if done:\n # TODO\n info['episode'] = { 'r': self.episode_rewards[0], 'l': self.steps, 'r_all': self.episode_rewards }\n # print(self.episode_rewards, self.steps)\n return obs, rewards[0], done, info","def act(self, time, observations, reward):\n return 0","def step(self, actions, agent_id=0):\n self._last_state = self._current_state\n\n # TODO\n # action = actions.discrete_actions[0]-1\n action = actions.argmax()\n\n done = 0\n if self._stage == 0: # is fixation\n if action == 0:\n reward = 0.\n else:\n reward = -1.\n self._current_state = 1\n self._stage = 1\n elif self._stage == 1: # is first stage, use prob_transition\n if action == 1 or action == 2:\n if np.random.random() < self._prob_transition[0][action-1]:\n self._current_state = 2\n else:\n self._current_state = 3\n reward = 0.\n else: # pick a next state at random\n reward = -1.\n self._current_state = np.random.random() < 0.5 and 2 or 3\n self._stage = 2\n else: # is second stage, use prob_reward\n # Given an action (arm pulled), sample reward, return\n if action == 1 or action == 2:\n current_prob_rewards = self._prob_reward[self._current_state-2]\n self._best_reward = self._max_reward*np.max(current_prob_rewards)\n thisProb = current_prob_rewards[action-1]\n if np.random.random() < thisProb:\n # print(\"give reward\")\n reward = self._max_reward\n else:\n reward = 0.0\n else:\n reward = -1.\n\n self._total_reward += reward\n self._best_total_reward += self._best_reward\n self._stage = 0\n self._current_state = 0\n self._trial += 1\n self._since_flipped += 1\n # if more than self._min_stable trials since flipping, certain chance of flipping prob rews\n if (self._since_flipped >= self._min_stable) and (np.random.random() <= self._flip_prob):\n self._randomize()\n self._since_flipped = 0\n\n\n self._last_action = np.zeros(self._num_arms)\n self._last_action[action] = 1\n # conditions to end episode\n if self._step >= self._steps_per_ep-1:\n self._state = READY_TO_END_EPISODE\n done = 1\n\n self._step += 1\n self._prev_reward = reward\n\n obs = self._current_state\n reset = done == 1. or self._step == MAX_FRAMES\n\n # print(np.array([[obs]]).shape)\n\n # print(reward, self._stage)\n return np.array([obs]), reward, done, reset","def step(self, action):\n if self.platform is None:\n raise RuntimeError(\"Call `reset()` before starting to step.\")\n\n if not self.action_space.contains(action):\n raise ValueError(\n \"Given action is not contained in the action space.\")\n\n num_steps = self.frameskip\n\n # ensure episode length is not exceeded due to frameskip\n step_count_after = self.step_count + num_steps\n if step_count_after > self.episode_length:\n excess = step_count_after - self.episode_length\n num_steps = max(1, num_steps - excess)\n\n reward = 0.0\n for _ in range(num_steps):\n self.step_count += 1\n if self.step_count > self.episode_length:\n raise RuntimeError(\"Exceeded number of steps for one episode.\")\n\n # send action to robot\n robot_action = self._gym_action_to_robot_action(action)\n t = self.platform.append_desired_action(robot_action)\n\n # Use observations of step t + 1 to follow what would be expected\n # in a typical gym environment. Note that on the real robot, this\n # will not be possible\n observation = self._create_observation(t + 1)\n\n reward += self.compute_reward(observation, self.info)\n\n is_done = self.step_count == self.episode_length\n\n return observation, reward, is_done, self.info","def step(self, action, decoder_hidden):\r\n\r\n # Check whether episode is over\r\n if (action == EOS_token) or (len(self.predicted_words)>= self.max_length):\r\n self.state = action, decoder_hidden\r\n RL_model_reward = model_evaluation.performance_metrics(\r\n target_sentence=self.target_sentence, pred_sentence=self.pred_sentence(), \r\n similarity_model=self.similarity_model, fluency_model=self.fluency_model, ESIM_model=self.ESIM_model,\r\n logr_model=self.logr_model, std_scaler=self.std_scaler,\r\n similarity_dist=self.similarity_dist, fluency_dist=self.fluency_dist, ESIM_dist=self.ESIM_dist,\r\n vocab_index=vocab_index, metric=self.reward_function)\r\n # Calculate relative reward\r\n self.ep_reward = np.around(RL_model_reward, 3)\r\n self.done = 1\r\n else:\r\n self.state = action, decoder_hidden\r\n \r\n # Add word to pred words\r\n self.predicted_words.append(vocab_index.index2word[action.item()])\r\n \r\n return self.state, self.ep_reward, self.done, None","def step(self, action:list) -> (np.ndarray, float, bool, dict):\n\n\n action[0] = (action[0] + 1)/2 # Done to be compatible with RL algorithms that require symmetric action spaces\n if np.isnan(action).any(): action = np.zeros(action.shape)\n self.main_vessel.step(action)\n\n for vessel in self.moving_obstacles:\n if vessel.index != 0:\n obs = vessel.observe()\n reward = self.rewarder_dict[vessel.index].calculate()\n insight = self.rewarder_dict[vessel.index].insight()\n #print(f'Reward for vessel {vessel.index}: {reward} -- lambda: {insight}')\n obs = np.concatenate([insight,obs])\n action, _states = self.agent.predict(obs, deterministic=True)\n action[0] = (action[0] + 1)/2\n vessel.step(action)\n\n # Testing criteria for ending the episode\n done = self._isdone()\n self._save_latest_step()\n\n # Getting observation vector\n obs = self.observe()\n vessel_data = self.main_vessel.req_latest_data()\n self.collision = vessel_data['collision']\n self.reached_goal = vessel_data['reached_goal']\n self.progress = vessel_data['progress']\n\n # Receiving agent's reward\n reward = self.rewarder.calculate()\n self.last_reward = reward\n #self.cumulative_reward += reward\n\n info = {}\n info['collision'] = self.collision\n info['reached_goal'] = self.reached_goal\n info['progress'] = self.progress\n\n self.t_step += 1\n\n return (obs, reward, done, info)","def step(self, action):\n action = self.randomization.action_randomizer.randomize(\n action, self._random_state\n )\n\n robot_exception = None\n try:\n self._act(action)\n except RobotException as re:\n logger.error(\n f\"Robot raised exception: {str(re)}. This will finish the current episode.\"\n )\n robot_exception = re\n\n if not self.constants.physical:\n # We don't need to do stepping for physical roll out.\n self.mujoco_simulation.step()\n\n self._synchronize_step_time()\n self.t += 1\n\n obs, reward, done, info = self.get_observation(robot_exception=robot_exception)\n obs, reward, done, info = self.step_finalize(obs, reward, done, info)\n return obs, reward, done, info","def _step(self, state, action):\n dealer_hand, player_hand = state[0], state[1]\n\n if action == \"hit\":\n player_hand = self._play_card(player_hand)\n else:\n dealer_hand = self._dealer_step(dealer_hand)\n self._terminate = True\n\n reward = self._get_reward(dealer_hand, player_hand)\n\n if reward != 0:\n self._terminate = True\n\n return [dealer_hand, player_hand], reward","def step(self, action):\n assert self.action_space.contains(action), \"%r (%s) invalid\"%(action, type(action))\n self.microgridPolicy.improveAction(action);\n\n self.microgrid.update();\n\n self.updateState();\n done = self.microgridPolicy.verifyStopConditions();\n reward = self.microgridPolicy.computeReward(done)\n if done: \n if self.steps_beyond_done is None:\n self.steps_beyond_done = 0\n else:\n logger.warn(\"You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.\")\n self.steps_beyond_done += 1\n self.clock.increaseTimeStep();\n return self.state, reward, done, {}","def step(self, action):\n self.timestep += 1\n self.actions = action.ravel()\n\n # Figure out which action was taken\n self.acted = False\n self.eat = False\n self.discard = False\n if action[0] > .5:\n self.eat = True\n self.acted = True\n elif action[1] > .5:\n self.discard = True\n self.acted = True\n\n # Check whether the appropriate action was taken, and assign reward.\n # There is a small punishment for doing nothing.\n self.reward = -.1\n if ((self.eat and self.edible) or\n (self.discard and not self.edible)):\n self.reward = 1.\n elif ((self.eat and not self.edible) or\n (self.discard and self.edible)):\n self.reward = -.9\n\n if self.acted:\n self.grab_fruit()\n\n return self.sensors, self.reward","def run_one_step(self):\n state = copy.copy(self.env.get_state())\n action = self.agent.get_action(state)\n reward = 0.0\n if self.env.check_terminal() is False:\n latest_experience = Experience(copy.copy(state), copy.copy(action))\n self.env.update(action)\n reward = self.env.get_reward()\n latest_experience.reward = copy.copy(reward)\n state = self.env.get_state()\n if self.env.check_terminal() is False:\n action = self.agent.get_action(state)\n latest_experience.done = False\n else:\n action = 0.0\n latest_experience.done = True\n latest_experience.next_state = copy.copy(state)\n latest_experience.next_action = copy.copy(action)\n self.agent.update_history(copy.copy(latest_experience))\n self.count += 1\n # If the latest history has a large enough batch, perform an update\n # CHECK IF THIS IS THE RIGHT METHOD\n if self.count % self.batch_size == 0:\n self.agent.update_policy_ordered(max(1, self.batch_size))\n if self.update_target_rate is not None:\n if self.count % self.update_target_rate == 0:\n self.count = 0\n self.agent.policy.learner.update_target_network()\n else:\n latest_experience = Experience(copy.copy(state), copy.copy(action))\n latest_experience.reward = 0.0\n latest_experience.next_state = copy.copy(state)\n latest_experience.next_action = 0.0\n latest_experience.done = True\n self.agent.update_history(copy.copy(latest_experience))\n # Perform an update on all of the previous experiences that haven't been updated\n if self.count % self.batch_size > 0:\n self.agent.update_policy_ordered((self.count % self.batch_size) + 1)\n self.count = 0\n return reward","def takeAction(self, action):\n return self.env.step(action)","def step(self, agent_action):\n\n done = False\n self.round += 1\n # First check round num, if equal to max then fail\n if self.round == self.max_round:\n done = True\n success = FAIL\n user_response = self._end_response()\n else:\n try:\n success = self.update_state(agent_action)\n if success:\n user_response = self._end_response()\n else:\n agent_intent = agent_action['intent']\n assert agent_intent in self.user_responses, 'Not acceptable agent action'\n user_response = self.user_responses[agent_intent](agent_action)\n except Exception:\n return self._default_response(),-5,False,False\n\n reward = self.reward_function(agent_action, success)\n\n return user_response, reward, done, True if success is 1 else False","def oneActionReward(self, state, action, redTurn):\n\n # TODO this is the main bottleneck for the neural network learning part\n # the only way to speed this up, would be to reduce the number of calls to networks\n # or optimize how the networks are called\n\n # save the original game\n oldGame = self.game\n self.game = state\n self.gameEnv.game = state\n oldCurrent = self.current\n\n # initialize reward for this action\n totalReward = 0\n\n # if the given action is None, then an action must be determined\n if action is None:\n # determine which enemy piece will move\n self.gameEnv.performAction(self.gameNetwork)\n\n # determine the direction that piece will move\n # if there is no valid network input, do not make an action\n netInput = self.toNetInput()\n # find the actual action\n if netInput is not None:\n action = self.internalNetwork.chooseAction(netInput, takeAction=self.canTakeAction)\n else:\n # This shouldn't ever be reached, because if self.toNetInput() returns None,\n # then self.current must be None, which only should happen after\n # self.gameEnv.performAction(self.gameNetwork) is called, but it should\n # only set that if the game is over, so if that first move ended the game\n # then this part of the code should never be reached\n # If this line is reached, then some error has happened\n action = None\n\n piecePos = self.current\n\n # if a move cannot be made, ensure win conditions are checked\n if action is None:\n self.game.checkWinConditions()\n # if an action can be taken, then the game is not over, so make a move\n else:\n # find the modifiers for the action\n modifiers = moveIntToBoolList(action)\n\n # add the reward for the piece moving\n moveR = moveReward(self.game, piecePos, modifiers, redTurn)\n if moveR is not None:\n totalReward += moveR\n # make the move\n self.game.play(piecePos, modifiers)\n\n # if the game ends, add reward for winning\n winReward = endGameReward(self.game.win, redTurn, self.game.moves)\n if winReward is not None:\n totalReward += winReward\n else:\n # if no move reward was found, then there was no valid reward, so set the reward to None\n totalReward = None\n\n # put the game back to it's original state\n self.game = oldGame\n self.gameEnv.game = oldGame\n self.current = oldCurrent\n\n # return the final reward\n return totalReward","def act(self, observation, reward, done):\n if self._not_restarted(observation):\n # not the first action, remember it and update model\n self._remember(self.prev_action, reward, observation, done)\n if len(self.replay_memory) > self.batch_size:\n self._replay()\n\n # determine the next action if not yet done\n action = None\n\n if not done:\n # epsilon greedy\n if random.uniform(0, 1) < self.epsilon_policy.get():\n # exploration: random action\n action = self.action_space.sample()\n action['start_time'] += 1 # non-zero start times\n else:\n # exploitation\n action = self._get_best_action(observation)\n\n self.prev_observation = observation\n self.prev_action = action\n\n return action","def step(self, action):\n (self.state, self.reward, self.terminal, self.truncated,\n self.info) = self.env.step(action)\n\n return self.state, self.reward, self.terminal, self.truncated, self.info","def step(self):\n self.step_n += 1\n self.step_t += 1\n # TODO: directly calling agent.act will by-pass BaseDeepAgent, which\n # checks and assigns 'sess' arugment. So we manually set sess here. But\n # is there a better way to do this?\n self.action = self.agent.act(\n state=self.state, sess=self.agent.sess\n )\n next_state, vec_reward, done, _ = self.env.step(self.action)\n reward, done = func_compile_exp_agent(self.action, vec_reward, done)\n self.total_reward = reward + self.reward_decay * self.total_reward\n info = self.agent.step(\n state=self.state, action=self.action, reward=reward,\n next_state=next_state, episode_done=done\n )\n self.record(info)\n flag_success = True if done and reward > 0.0 else False\n if self.savedir is not None:\n self.steps_saver.save(self.episode_n, self.step_t, self.state, self.action,\n vec_reward, reward, done, self.total_reward, flag_success)\n self.state = next_state\n if done:\n self.step_t = 0\n return done","def _reward(self, action):\n raise NotImplementedError","def step(self, state, reward, training=True):\n last_state, last_action = self.last_state, self.last_action\n last_reward = reward\n state = state\n \n action = self.policy(state, training)\n\n if training:\n self.steps += 1\n print(\"## step:\",self.steps)\n\n if last_state is not None:\n experience = {\n \"state\": last_state,\n \"action\": last_action,\n \"reward\": last_reward,\n \"next_state\": state\n }\n\n self.memory.add(experience)\n #print(\"**memory size:\",self.memory.__len__())\n #else:\n #print(\"&& last_state\",last_state)\n\n if self.steps > self.replay_start_size: #para acumular cierta cantidad de experiences antes de comenzar el entrenamiento\n self.train_network()\n\n if self.steps % self.target_update_freq == 0: #el clon de la red se realiza cada cierta cant de steps\n self.update_target_network()\n\n self.last_state = state\n self.last_action = action\n\n return action","def step(self, action):\n self._robot.send_command(action)\n\n obs = self.get_observation()\n\n reward = self.reward(obs.achieved_goal, self.goal)\n done = self.done(obs.achieved_goal, self.goal)\n next_observation = obs.observation\n return Step(observation=next_observation, reward=reward, done=done)","def step(self, action: CARLAAction, *args: Any, **kwargs: Any) -> Transition:\n observation, reward, done, info = self.env.step(action)\n if observation[\"lane_invasion\"] > 0:\n logging.debug(\"A lane was invaded\")\n done = True\n reward = -1.0\n return observation, reward, done, info","def perform_action(self, action):\r\n t_list = self.get_action_outcomes(self.current_state, action)\r\n new_state = t_list[np.argmax(np.random.multinomial(1, [t[0] for t in t_list]))][1]\r\n # print(len(self.trajectory), ':', self.current_state, '--', action ,'-->', new_state)\r\n self.current_state = new_state\r\n self.trajectory.append(new_state)\r\n return tuple(self.current_state) == tuple(self.end_state)","def step(self, action):\n # Action indicates the position of a datapoint in self.indeces_unknown \n # that we want to sample in unknown_data\n # The index in train_data should be retrieved \n selection_absolute = self.indeces_unknown[action]\n # Label a datapoint: add its index to known samples and removes from unknown\n self.indeces_known = np.concatenate(([self.indeces_known, np.array([selection_absolute])]))\n self.indeces_unknown = np.delete(self.indeces_unknown, action) \n # Train a model with new labeled data\n known_data = self.dataset.train_data[self.indeces_known,:]\n known_labels = self.dataset.train_labels[self.indeces_known]\n known_labels = np.ravel(known_labels)\n self.model.fit(known_data, known_labels)\n # Get a new state \n classifier_state, next_action_state = self._get_state() \n # Update the number of available actions\n self.n_actions = np.size(self.indeces_unknown)\n # Compute the quality of the current classifier\n test_prediction = self.model.predict(self.dataset.test_data)\n new_score = self.quality_method(self.dataset.test_labels, test_prediction)\n self.episode_qualities.append(new_score)\n # Compute the reward\n reward = self._compute_reward()\n # Check if this episode terminated\n done = self._compute_is_terminal() \n return classifier_state, next_action_state, reward, done","def update(self, state, action, nextState, reward):\n util.raiseNotDefined()","def take_action(self, state):\n action = super(SarsaAgent, self).take_action(state)\n if self.learning:\n self.update_q_values(state, self.q_value((state, action)))\n self.prev_state = state\n self.prev_action = action\n self.prev_q_val = self.q_values[self.represent_state(self.prev_state), self.prev_action]\n self.log(\"size of q_values {0}\\nprev state {1}\\nprev action {2}\\nprev q-val {3}\"\n .format(len(self.q_values), self.prev_state, self.prev_action, self.prev_q_val))\n return action","def step(self, action):\n # Implement your step method here\n # return (observation, reward, done, info)\n self._state = self._state + action\n # print('Step state:', self._state)\n x, y = self._state\n reward = - (x ** 2 + y ** 2) ** 0.5\n done = abs(x) < 0.01 and abs(y) < 0.01\n next_observation = np.copy(self._state)\n return Step(observation=next_observation, reward=reward, done=done)","def step(self, action):\n # get the instruction indicated by the action\n instr = self.instrs[action]\n # extend the program\n self.program.inst(instr)\n # run and get some measured bitstrings\n self.bitstrings, info = self._run_program(self.program)\n # compute the avg score of the bitstrings\n reward = self._prob_score(self.bitstrings)\n self.running_episode_reward += reward\n\n info[\"instr\"] = instr\n info[\"reward-nb\"] = reward\n self.current_step += 1\n\n # are we done yet?\n done = False\n if self.current_step >= MAX_PROGRAM_LENGTH:\n done = True\n if reward >= self.reward_threshold:\n reward += MAX_PROGRAM_LENGTH - self.current_step\n done = True\n\n return self.observation, reward, done, info","def step(self, action):\n # print(action)\n distances = self.agent.return_distances(self.agent.corners, self.agent.line_pos)\n\n left = distances[0]\n right = distances[1]\n self.agent.distances.append({\n 'left': left,\n 'right': right\n })\n reward = 0\n if action == 1:\n self.agent.angle -= 90\n if self.agent.angle < 0:\n self.agent.angle = 0\n self.agent.direction_history.append('left')\n self.reset_raycasts(self.agent.angle)\n self.render()\n if left > right:\n reward += 5\n else:\n reward -= 5\n\n elif action == 2:\n self.agent.angle += 90\n if self.agent.angle >= 360:\n self.agent.angle = 0\n\n self.reset_raycasts(self.agent.angle)\n self.render()\n self.agent.direction_history.append('right')\n if left < right:\n reward += 5\n else:\n reward -= 5\n\n elif action == 0:\n self.agent.direction_history.append('forward')\n if self.agent.angle >= 360: self.agent.angle == 0\n if self.agent.angle == 0 or self.agent.angle == 360:\n self.agent.agent_position['y'] -= 10\n self.reset_raycasts(self.agent.angle)\n elif self.agent.angle == 90: \n self.agent.agent_position['x'] += 10\n self.reset_raycasts(self.agent.angle)\n elif self.agent.angle == 180: \n self.agent.agent_position['y'] += 10\n self.reset_raycasts(self.agent.angle)\n elif self.agent.angle == 270:\n self.agent.agent_position['x'] -= 10\n self.reset_raycasts(self.agent.angle)\n \n if left + right >= 50:\n reward += 5\n\n self.render()\n\n elif action == 3:\n self.agent.direction_history.append('reverse')\n if self.agent.angle == 0:\n self.agent.agent_position['y'] += 10\n self.reset_raycasts(self.agent.angle)\n self.render()\n elif self.agent.angle == 90: \n self.agent.agent_position['x'] -= 10\n self.reset_raycasts(self.agent.angle)\n self.render()\n elif self.agent.angle == 180: \n self.agent.agent_position['y'] -= 10\n self.reset_raycasts(self.agent.angle)\n self.render()\n elif self.agent.angle == 270:\n self.agent.agent_position['x'] += 10\n self.reset_raycasts(self.agent.angle)\n self.render()\n \n if left + right <= 50:\n reward += 5\n\n \n else:\n reward -= 5\n\n if \"forward\" not in self.agent.direction_history[len(self.agent.direction_history)-6:len(self.agent.direction_history)-1]:\n reward -= 10\n\n \n info = {}\n if self.agent.check_collision():\n reward -= 10\n self.reset() \n self.agent.rewards.append({\n 'leftDistance': left,\n 'rightDistance': right,\n 'reward': reward,\n })\n self.render()\n print(f\"REWARD: {reward}\")\n # self.render()\n # print(self.agent.direction_history[-1])\n self.agent.rewards.append(reward)\n return np.array([left, right]), reward, False, info","def take_action(self, state):\n if self.epsilon_decay is not None:\n self.epsilon *= self.epsilon_decay\n if random.random() < self.epsilon:\n action = super(BaseQAgent, self).random_next_action(state)\n self.log('exploration move: {0}'.format(str(action)))\n else:\n action = self.greedy_next_action(state)\n self.log('exploitation move: {0}'.format(str(action)))\n return action","def step(self, action):\n if self._backend_agent:\n self._backend_agent._on_gym_step_begin(self, action)\n\n result = self.env.step(action)\n (state, reward, done, info) = result\n self.steps_done_in_episode += 1\n self.steps_done_in_instance += 1\n self.total.steps_done_inc()\n if self.max_steps_per_episode and self.steps_done_in_episode >= self.max_steps_per_episode:\n done = True\n result = (state, reward, done, info)\n if not self.is_episode_done and done:\n self.is_episode_done = True\n self.episodes_done += 1\n self.total.episodes_done_inc()\n\n if self._backend_agent:\n self._backend_agent._on_gym_step_end(self, action, result)\n return result","def step(self, action):\n possible_states, probs = zip(*self.get_next_states(self._current_state, action).items())\n next_state = weighted_choice(possible_states, p=probs)\n reward = self.get_reward(self._current_state, action, next_state)\n is_done = self.is_terminal(next_state)\n self._current_state = next_state\n return next_state, reward, is_done, {}","def begin_episode(self, observation):\n self._reset_state()\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_quantile_samples,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn,\n self._tau,\n self.optimizer)\n self.action = onp.asarray(self.action)\n return self.action","def _act_impl(self, observation, reward,\n done):\n if done:\n raise core.EpisodeDoneError(\"Called act on a done episode.\")\n\n if not self.observation_space.contains(observation):\n raise core.InvalidObservationError(\"Invalid ovservation: %s\" %\n observation)\n if self.params.observation_adjustment_fn:\n observation = self.params.observation_adjustment_fn(\n self.rng, self.beliefs, observation)\n\n features = self.feature_selection_fn(observation)\n self.beliefs = self._update_beliefs(features, self.beliefs)\n action = self._allocate(self._n_resource, self.beliefs)\n\n if not self.action_space.contains(action):\n raise gym.error.InvalidAction(\"Invalid action: %s\" % action)\n\n return action","def step(self, action):\n obs, r, done, info = self.env.step(action)\n obs = self.get_observation(obs)\n return obs, r, self.is_done(), info","def step(self, action):\n state, reward, done, debug_info = self.sample_transition(action)\n self.set_state(state)\n if \"next_state_heuristic\" in debug_info:\n self._current_heuristic = debug_info[\"next_state_heuristic\"]\n return state, reward, done, debug_info","def step(self, action):\n \"\"\" Action is a motion command \"\"\"\n rich_obs, reward, done, info = super(ColoredEgoCostmapRandomAisleTurnEnv, self).step(action)\n obs = self._extract_egocentric_observation(rich_obs)\n return obs, reward, done, info","def step(self, action: nx.Graph):\n # Get the SMILES string associated with this action\n self._state = action\n if self.record_path:\n self._path.append(self._state)\n\n # Update the action space\n self.action_space.update_actions(self._state, self.observation_space)\n self._counter += 1\n\n # Check if we have finished\n # Out of steps or no more moves\n done = len(self.action_space.get_possible_actions()) == 0\n\n # Compute the fingerprints for the state\n return self._state, self.reward(), done, {}","def _step(self, action):\n \n obs, reward, done, info = self.env.step(action)\n\n \n advice=self.generateAdvice()[1]\n\n obs = {\n \"image\": obs,\n \"advice\": advice\n }\n\n\n \n\n\n\n return obs, reward, done, info","def step(self,\n action):\n assert isinstance(action, Actions)\n reward = 0.0\n done = False\n close = self.current_close()\n # if buy a share the state change and you pay the commission (no price slippage)\n if action == Actions.Buy and self.have_position:\n self.have_position = True\n self.open_price = close\n reward -= self.commission_perc\n # if close pay the commission if done = reset_on_close change the done flag(end) and give the reward\n elif action == Actions.Close and self.have_position:\n reward -= self.commission_perc\n done |= self.reset_on_close\n if self.reward_on_close:\n reward += 100.0 * (close - self.open_price) / self.open_price\n self.have_position = False\n self.open_price = 0.0\n # end the process: reward after the last bar movement\n self._offset += 1\n prevision_close = close\n close = self.current_close()\n done |= self._offset >= self._prices.close.shape[0] - 1\n if self.have_position and not self.reward_on_close:\n reward += 100.0 * (close - prevision_close) / prevision_close\n return reward, done","def learn(self, action, reward, is_terminal):\n\n\t\t# Add the experience to the replay memory\n\t\tself.replay_memory.record(self.state_history[:,:,3], action, reward, is_terminal)","def step(self, action: Action) -> Feedback: # type: ignore\n self._action_counter += 1\n step_id = self._action_counter\n\n self._encode_and_send_action(action, step_id)\n\n # Wait (blocking!) for the response envelope from the environment\n in_envelope = self._queue.get(block=True, timeout=None) # type: Envelope\n\n msg = self._decode_percept(in_envelope, step_id)\n\n observation, reward, done, info = self._message_to_percept(msg)\n\n return observation, reward, done, info","def step(self, state, action, reward, next_state, done):\n self.episode_step += 1\n # if early episode termination\n if self.params.max_episode_steps and self.episode_step >= self.params.max_episode_steps:\n done = True\n # track progress\n self.tracker.step(reward)\n # memorize\n self.memory.append((state, action, reward, next_state, 1.0 - done))\n return done","def execute_action(self, agent, action):\n abstract","def take_action(self, state):","def step(self, action: Union[np.ndarray, torch.Tensor]):\n if type(action) == torch.Tensor:\n action = action.squeeze().numpy()\n\n if not type(action) is np.ndarray:\n raise Exception(\"The action must be a Numpy array but is of type %s (value = %s)\" % (type(action), action))\n\n if self.increment_actions and not self.action_space.contains(action):\n action = action.clip(self.action_space.low, self.action_space.high)\n\n # Additionally, we must make sure the value will stay in the range\n # min <= x + action <= max\n if self.increment_actions:\n current_values = self.x[np.array([0, 1, 3, 5])]\n new_flow_values = current_values + action\n else:\n new_flow_values = action\n\n new_flow_values = np.clip(new_flow_values, self.flows_lower_bounds, self.flows_upper_bounds)\n self.update_all_flows(new_flow_values)\n\n if any([x < 0 for x in self.x]):\n pass\n # TODO: should I clip the actions to ensure the flows are always positive?\n # raise Exception(f\"Negative flows! x = {[round(x, 4) for x in self.x]}\")\n\n self.update_fitness()\n\n self.step_number += 1\n\n # reward = self.fitness - self.previous_fitness\n reward = self.fitness\n observation = self.get_observation()\n\n done = (self.step_number == self.total_number_of_episodes)\n info = {}\n return observation, reward, done, info","def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool, dict]:\n next_state, reward, done, info = self.env.step(action)\n return next_state, reward, done, info","def step(self, action: CARLAAction, *args: Any, **kwargs: Any) -> Transition:\n observation, reward, done, info = self.env.step(action)\n if observation[\"collision\"] > 0:\n logging.debug(\"A collision occured\")\n done = True\n reward = -1.0\n return observation, reward, done, info","def step(self, action):\n self.move_step(action) # Move.\n r, d = self.check_goal() # Check the reward and done state, and create\n # new environment.\n s_new= self.render_env() # Render the new environment.\n return s_new, r, d","def observe_reward(self,state,action,statePrime,reward):\n pass","def begin_episode(self, observation):\n self._reset_state()\n self._record_observation(observation)\n\n if not self.eval_mode:\n self._train_step()\n\n self._rng, self.action = select_action(self.network_def,\n self.online_params,\n self.state,\n self._rng,\n self.num_actions,\n self.eval_mode,\n self.epsilon_eval,\n self.epsilon_train,\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_fn)\n self.action = onp.asarray(self.action)\n return self.action","def step(self, action):\n observation, reward, done, _ = self.env.step(action)\n return np.array(observation), reward, done","def env_step(self, action):\n random_prob = np.random.uniform(0, 1)\n if random_prob <= self.stochasticity: # Ignore agent's action and move to one of the 8 neighbours\n # Determine how the agent moves (from -1 to 1 in each direction, but not both 0)\n random_nn = np.random.randint(0, len(self.nn))\n random_y = self.nn[random_nn, 0]\n random_x = self.nn[random_nn, 1]\n\n # Move to one of the nearest neighbours\n self.current_state[0] += random_y\n self.current_state[1] += random_x\n else: # Perform agent's action\n # Update current stated based on the action the agent took\n curr_x = self.current_state[1]\n self.current_state[0] += self.actions[action][0] + self.wind[curr_x]\n self.current_state[1] += self.actions[action][1]\n\n # Check if the agent fell out of the boundaries of the grid world\n y_coord = self.current_state[0]\n x_coord = self.current_state[1]\n\n if y_coord >= self.num_rows: # Agent went too far up\n self.current_state[0] = self.num_rows - 1\n elif y_coord < 0: # Agent went too far down\n self.current_state[0] = 0\n\n if x_coord >= self.num_cols: # Agent went too far right\n self.current_state[1] = self.num_cols - 1\n elif x_coord < 0: # Agent went too far left\n self.current_state[1] = 0\n\n is_terminal = False\n reward = -1.0\n\n # Check if the agent reached a terminal state\n if self.current_state == self.terminal_state:\n is_terminal = True\n reward = 0.0\n\n return reward, self.current_state, is_terminal","def step(self, state, action, reward, done):\n\n self.memory.add(state, action, reward, done)\n if done and self.n_tau % self.update_freq == 0:\n self.n_tau += 1\n return self.update()\n return None","def step(self, action):\n\n previous_state = self.state\n self._make_action(action) \n self.step_simulation()\n self._make_observation() # Update state\n \n ###################\n ### Reward function\n\n body_position = self.agent.get_position('Torso') # x,y,z coordinates of the agent\n r_foot_collision, l_foot_collision = self.state[-2:] # Feet collision indicators [0/1]\n roll, pitch = self.state[12:14] # Roll and pitch of the agent's convex hull\n\n # Staying upright\n posture = 0\n if abs(roll) > abs(previous_state[12]):\n posture -= .1\n else:\n posture += .125\n\n if abs(pitch) > abs(previous_state[13]):\n posture -= .1\n else:\n posture += .125\n \n hull = 0\n if abs(roll) < .125 and abs(pitch) < .125:\n posture += .1\n # Lifting feet while upright\n # collisions = np.count_nonzero(self.state[14::])\n # posture = (2 - collisions) * .\n\n # Hull location\n progress = body_position[0] - self.previous_body_position\n if progress > 0: \n hull = 0.1 + progress * 40\n if hull > .5: hull = .5\n else:\n hull = -0.1 + progress * 40\n if hull < -.5: hull = -.5\n self.previous_body_position = body_position[0]\n\n \"\"\"\n STATE SPACE:\n include:\n 1. Angular velocity of the torso (also normal velocity?) both can be obtained through gyro and accelerometer\n 2. Change to orientation of the torso instead of convex hull\n 3. \n \"\"\"\n\n # Feet distance\n # Use multiplicative reward?\n # Change in feet position along the X axis\n # pos_lfoot = self.agent.get_position('LFoot')[0]\n # pos_rfoot = self.agent.get_position('RFoot')[0]\n # distance_lfoot = (pos_lfoot - self.previous_feet_position[0])\n # distance_rfoot = (pos_rfoot - self.previous_feet_position[1])\n # if self.previous_feet_position[0] != 0:\n # feet_distance = (distance_lfoot + distance_rfoot) * 100\n # else:\n # feet_distance = 0\n\n # self.previous_feet_position = [pos_lfoot, pos_rfoot]\n\n base = 0.05\n reward = base + posture + hull\n # print('hull: {}'.format(hull))\n # print('posture: {}'.cformat(posture))\n\n # End condition\n if (abs(roll) > self.fall_threshold or abs(pitch) > self.fall_threshold):\n reward -= 2\n self.done = True \n\n # print('Posture: {} \\n Hull: {}'.format(posture, hull))\n # print('Total reward: {}'.format(reward))\n\n return self.state, reward, self.done, {}","def step(self, state, action, reward, next_state, done):\n # print(\"agent.step() - state: {}, action: {}, reward: {}, next_state: {}, done: {}\".format(state, action, reward, next_state, done))\n current_reward_val = self.Q[state][action]\n next_step_greedy_action = np.argmax(self.Q[next_state])\n next_step_reward_val = self.Q[next_state][next_step_greedy_action]\n gamma = 0.75 # toto - paramterize\n self.Q[state][action] = self.Q[state][action] + self.alpha * (\n reward + gamma * next_step_reward_val - self.Q[state][action])","def take_one_step(env, policy, state):\n action = sample_action(policy, state)\n new_state, reward, done, _ = env.step(action)\n if (done == True and reward > 0):\n reward = 10.0\n if new_state in hole_states:\n reward = -10.0\n elif not done:\n reward = -1.0\n # print(\"state {0}, new_state {1}, action {2}, reward {3}, done {4}\".format(state, new_state, action, reward, done))\n return action, reward, new_state, done","def step(self, action): # action is nb-cops-sized or 1-sized\n reward = 0\n done = False\n\n action = np.array(action)\n\n def old_pos(set=None):\n if set is None:\n return self.cops_pos if self.is_cops_turn else self.rob_pos\n else:\n if self.is_cops_turn:\n self.cops_pos = action\n else:\n self.rob_pos = action\n\n invalids = []\n\n if self.is_first_turn:\n self.graph.set_cr(action, self.is_cops_turn)\n else:\n edges = self.graph.get_rep()[old_pos(), action]\n invalids = edges != 1\n invalids[action == old_pos()] = False\n invalids = np.where(invalids == True)[0]\n if invalids.shape[0] != 0:\n action[invalids] = old_pos()[invalids] # correct action\n self.graph.set_cr(action, self.is_cops_turn)\n\n old_pos(action)\n if not self.is_cops_turn and self.is_first_turn:\n self.is_first_turn = False\n self.is_cops_turn = not self.is_cops_turn\n if self.rob_pos is not None and self.rob_pos[0] in self.cops_pos:\n print(\"Cops won\")\n done = True\n reward += (1 if self.is_cops_turn else -1) * REWARD_END_WL\n\n reward += (-1 if self.is_cops_turn else +1) * REWARD_STEP_WL\n reward -= len(invalids) * REWARD_INVALID\n\n observation = self.graph.get_attr()\n\n if self.is_cops_turn:\n self.cops_rew += reward\n else:\n self.rob_rew += reward\n\n if not done:\n if self.is_cops_turn and self.cops is not None:\n observation, _, done, _ = self.step(self.cops.act(observation))\n elif not self.is_cops_turn and self.robber is not None:\n observation, _, done, _ = self.step(self.robber.act(observation))\n return observation, reward, done, {}","def rollout(agent, env):\n # run until episode ends\n episode_reward = 0\n done = False\n obs = env.reset()\n while not done:\n action = agent.compute_action(obs)\n obs, reward, done, info = env.step(action)\n episode_reward += reward\n \n return episode_reward","def env_step(self, action):\n if action == 0: # Hit\n\n new_state = deepcopy(self.current_state)\n reward = 0\n terminal = False\n \n new_card = min(self.random.randint(1,14), 10)\n # print('new card:', new_card)\n \n if new_card == 1:\n self.player_ace_count += 1\n new_state['player_sum'] = self.current_state['player_sum'] + 11 \n else:\n new_state['player_sum'] = self.current_state['player_sum'] + new_card\n\n while new_state['player_sum'] > 21 and self.player_ace_count > 0:\n self.player_ace_count -= 1\n new_state['player_sum'] -= 10\n\n new_state['usable_ace'] = int(self.player_ace_count > 0)\n\n if new_state['player_sum'] > 21: # Goes bust\n reward = -1\n terminal = True\n\n elif action == 1: # Stick\n\n new_state = deepcopy(self.current_state)\n terminal = True\n\n if self.current_state['dealer_card'] == 1:\n dealer_ace = 1\n dealer_sum = 11\n else:\n dealer_ace = 0\n dealer_sum = self.current_state['dealer_card']\n\n first_two_cards = True\n while dealer_sum < self.dealer_sticks or first_two_cards:\n first_two_cards = False\n # new_card = self.random.choice(range(1,11), p=self.card_probs)\n new_card = min(self.random.randint(1,14), 10)\n if new_card == 1:\n dealer_sum += 11\n dealer_ace += 1\n else:\n dealer_sum += new_card\n\n while dealer_sum > 21 and dealer_ace > 0:\n dealer_sum -= 10\n dealer_ace -= 1\n dealer_ace = int(dealer_ace > 0)\n # print('dealer:', new_card)\n\n # print('dealer sum:', dealer_sum)\n if dealer_sum > 21:\n reward = 1\n else:\n if new_state['player_sum'] > dealer_sum:\n reward = 1\n elif new_state['player_sum'] < dealer_sum:\n reward = -1\n else:\n reward = 0\n # reward = int(new_state['player_sum'] > dealer_sum) - int(new_state['player_sum'] < dealer_sum)\n\n else:\n raise Exception(\"Invalid action.\")\n\n self.current_state = new_state\n\n self.reward_obs_term = (reward, self.observation(self.current_state), terminal)\n\n return self.reward_obs_term","def reward(self, observation, action, reward):\r\n\r\n if reward > 0 :\r\n print(\"win\") \r\n self.done=1 \r\n self.done_MC=1\r\n\r\n else:\r\n self.done=0\r\n\r\n self.current_state=observation\r\n self.current_action=action\r\n self.current_reward=reward\r\n self.reward_list.append(reward.item())\r\n \r\n self.log_probs.append(self.log_prob)\r\n self.values.append(self.value)\r\n self.rewards.append(self.torch.tensor([self.current_reward], dtype=self.torch.float, device=self.device))\r\n self.masks.append(self.torch.tensor([1-self.done], dtype=self.torch.float, device=self.device))","def state_update(self, last_action, action):\n s_t = self._get_state(last_action)\n r= self._get_reward(last_action,action)\n self._move_user()\n s_t1 = self._get_state(action)\n self.reward = r\n self.s_t = s_t\n self.s_t1 = s_t1","def make_step(self, action_index):\n # Randomly sample action_index if world is stochastic\n if np.random.uniform(0, 1) < self.random_move_probability:\n action_indices = np.arange(self.num_actions, dtype=int)\n action_indices = np.delete(action_indices, action_index)\n action_index = np.random.choice(action_indices, 1)[0]\n\n action = self.actions[action_index]\n\n # Determine new position and check whether the agent hits a wall.\n old_position = self.agent_position\n new_position = self.agent_position\n if action == \"UP\":\n candidate_position = old_position + self.num_cols\n if candidate_position < self.num_fields:\n new_position = candidate_position\n elif action == \"RIGHT\":\n candidate_position = old_position + 1\n if candidate_position % self.num_cols > 0: # The %-operator denotes \"modulo\"-division.\n new_position = candidate_position\n elif action == \"DOWN\":\n candidate_position = old_position - self.num_cols\n if candidate_position >= 0:\n new_position = candidate_position\n elif action == \"LEFT\": # \"LEFT\"\n candidate_position = old_position - 1\n if candidate_position % self.num_cols < self.num_cols - 1:\n new_position = candidate_position\n else:\n raise ValueError('Action was mis-specified!')\n\n # Update the environment state\n self.agent_position = new_position\n \n # Calculate reward\n reward = self.rewards[self.agent_position]\n reward -= 1\n return reward, new_position","def step(self, action, state):\r\n done = False\r\n next_state = json.loads(state)\r\n state_shift = self.action_map[action]\r\n\r\n next_state = np.array(next_state) + np.array(state_shift)\r\n next_state = next_state.tolist()\r\n\r\n reward = self.reward[next_state[0], next_state[1]]\r\n self.reward[next_state[0], next_state[1]] = 0\r\n\r\n next_state = json.dumps(next_state)\r\n\r\n if reward < 0 or reward == 4:\r\n done = True\r\n\r\n return next_state, reward, done","def doAction(self, gameState, action):\n self.lastState = gameState\n self.lastAction = action","def step(self, state, action):\n reward = 0.0\n new_card = self._generate_random_card()\n if action == ACTION_HIT:\n new_player_value = state.player_sum + new_card.get_game_value()\n if new_player_value < 1 or new_player_value > 21:\n return TERMINAL_STATE, -1\n return State(state.dealer_card, new_player_value), 0.0\n current_dealer_value = state.dealer_card.get_game_value()\n # STICK\n current_dealer_value += new_card.get_game_value()\n while current_dealer_value < 17:\n if current_dealer_value < 1:\n return TERMINAL_STATE, 1\n drawn_card = self._generate_random_card()\n current_dealer_value += drawn_card.get_game_value()\n if current_dealer_value > 21:\n return TERMINAL_STATE, 1\n if state.player_sum > current_dealer_value:\n return TERMINAL_STATE, 1\n if state.player_sum == current_dealer_value:\n return TERMINAL_STATE, 0\n return TERMINAL_STATE, -1","def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n next_state, reward, done, _ = self.env.step(action, resize=RESIZE, size = RESIZE_SIZE)\n\n if not self.is_test:\n self.transition += [reward, next_state, done]\n \n # N-step transition\n if self.use_n_step:\n one_step_transition = self.memory_n.store(*self.transition)\n # 1-step transition\n else:\n one_step_transition = self.transition\n\n # add a single step transition\n if one_step_transition:\n self.memory.store(*one_step_transition)\n \n return next_state, reward, done"],"string":"[\n \"def agent_step(self, reward, state):\\n self.sum_rewards += reward\\n self.episode_steps += 1\\n\\n # Make state an array of shape (1, state_dim) to add a batch dimension and\\n # to later match the get_action_values() and get_TD_update() functions\\n state = np.array(state)\\n\\n # Select action\\n action = self.policy(state)\\n \\n # Append new experience to replay buffer\\n self.replay_buffer.append(self.last_state, self.last_action, reward, 0, state)\\n \\n # Perform replay steps:\\n if self.replay_buffer.size() > self.replay_buffer.minibatch_size:\\n self.network_target.load_state_dict(self.network.state_dict())\\n for _ in range(self.num_replay):\\n # Get sample experiences from the replay buffer\\n experiences = self.replay_buffer.sample() \\n self.optimize_network(experiences)\\n \\n # Update the last state and last action.\\n self.last_state = state\\n self.last_action = action\\n \\n return action\",\n \"def step(self, action):\\n\\n ob = self.sendCmd(self.url, self.actions_list[action])\\n print(\\\"ob -> {}\\\".format(ob['obsequium']))\\n\\n self.obsequium = int(ob[\\\"obsequium\\\"])\\n self.bonus = int(ob[\\\"bonus\\\"])\\n\\n # we need to check is make sense finish it\\n if self.is_game_done:\\n raise RuntimeError(\\\"Episode is done\\\")\\n self.curr_step += 1\\n self._take_action(action)\\n\\n reward = self._get_reward()\\n\\n # TODO: revisar ob = self._get_state()\\n\\n return ob, reward, self.is_game_done, {}\",\n \"def step(self, action):\\n assert action in self.infoset.legal_actions\\n self.players[self._acting_player_position].set_action(action)\\n self._env.step()\\n self.infoset = self._game_infoset\\n done = False\\n reward = 0.0\\n if self._game_over:\\n done = True\\n reward = {\\n \\\"play\\\": {\\n \\\"landlord\\\": self._get_reward(\\\"landlord\\\"),\\n \\\"landlord_up\\\": self._get_reward(\\\"landlord_up\\\"),\\n \\\"landlord_down\\\": self._get_reward(\\\"landlord_down\\\")\\n },\\n \\\"bid\\\": {\\n \\\"landlord\\\": self._get_reward_bidding(\\\"landlord\\\")*2,\\n \\\"landlord_up\\\": self._get_reward_bidding(\\\"landlord_up\\\"),\\n \\\"landlord_down\\\": self._get_reward_bidding(\\\"landlord_down\\\")\\n }\\n }\\n obs = None\\n else:\\n obs = get_obs(self.infoset)\\n return obs, reward, done, {}\",\n \"def step(self, action: ActionType) -> EnvResponse:\\n action = self.action_space.clip_action_to_space(action)\\n if self.action_space and not self.action_space.contains(action):\\n raise ValueError(\\\"The given action does not match the action space definition. \\\"\\n \\\"Action = {}, action space definition = {}\\\".format(action, self.action_space))\\n\\n # store the last agent action done and allow passing None actions to repeat the previously done action\\n if action is None:\\n action = self.last_action\\n self.last_action = action\\n if self.visualization_parameters.add_rendered_image_to_env_response:\\n current_rendered_image = self.get_rendered_image()\\n\\n self.current_episode_steps_counter += 1\\n if self.phase != RunPhase.UNDEFINED:\\n self.total_steps_counter += 1\\n\\n # act\\n self._take_action(action)\\n\\n # observe\\n self._update_state()\\n\\n if self.is_rendered:\\n self.render()\\n\\n self.total_reward_in_current_episode += self.reward\\n\\n if self.visualization_parameters.add_rendered_image_to_env_response:\\n self.info['image'] = current_rendered_image\\n\\n self.last_env_response = \\\\\\n EnvResponse(\\n reward=self.reward,\\n next_state=self.state,\\n goal=self.goal,\\n game_over=self.done,\\n info=self.info\\n )\\n\\n # store observations for video / gif dumping\\n if self.should_dump_video_of_the_current_episode(episode_terminated=False) and \\\\\\n (self.visualization_parameters.dump_mp4 or self.visualization_parameters.dump_gifs):\\n self.last_episode_images.append(self.get_rendered_image())\\n\\n return self.last_env_response\",\n \"def step(self, action):\\n \\n success = False\\n self.curr_step += 1\\n self._take_action(action)\\n self._take_action(action)\\n self._take_action(action)\\n\\n # initialize reward and get state \\n reward = 0.0\\n ob = self._get_state()\\n\\n # give dense rewards \\n if not self.sparse_reward:\\n reward = self._get_reward()\\n\\n # bad terminal conditions\\n if self.curr_step >= self.max_steps \\\\\\n or self.target_distance >= self.max_distance \\\\\\n or self.mean_radius_sheep >= self.max_radius:\\n self.finish = True\\n if self.sparse_reward:\\n reward = -1.0\\n\\n # good terminal conditions\\n if self.target_distance <= 1.0:\\n success = True\\n self.finish = True\\n if self.sparse_reward:\\n reward = 1.0\\n\\n # update rl parameters\\n self.episode_length += 1\\n self.episode_reward += reward\\n\\n # generate info return parameter\\n if self.info_mode == 1 and self.finish:\\n info = {'r':self.episode_reward, 'l':self.episode_length, \\n 's': success}\\n else:\\n info = {'n':self.num_sheep, 's': success}\\n\\n return ob, reward, self.finish, info\",\n \"def step(self, action):\\r\\n\\r\\n max_time = len(self.episode) - 1 # the number of states available in the episode , -1 for indexing purpose\\r\\n state = self.episode[self.t] # state contains LT, ST indicator, closing price\\r\\n closing_price = state['Close']\\r\\n transaction_fee = self.transaction_fee\\r\\n agent = self.agent\\r\\n reward = 0\\r\\n \\r\\n if self.t < max_time-1:\\r\\n if agent.stock == 0: # if there is no stock position the agent can buy or do nothing\\r\\n if action == 1: # buy sstock at closing price\\r\\n agent.stock_position = agent.starting_cash / closing_price * (1 - transaction_fee)\\r\\n agent.cash = 0\\r\\n agent.stock = 1\\r\\n reward = 0\\r\\n elif action == 0: # no action\\r\\n reward = 0\\r\\n else:\\r\\n reward = -10000\\r\\n \\r\\n elif agent.stock == 1: # if there is a stock position the agent can sell or do nothing\\r\\n if action == 2: # sell stock at closing price\\r\\n agent.cash = agent.stock_position * closing_price * (1 - transaction_fee)\\r\\n reward = agent.cash - agent.starting_cash\\r\\n self.done = True\\r\\n elif action == 0: # no action\\r\\n reward = 0\\r\\n elif action == 1:\\r\\n reward = -10000\\r\\n \\r\\n elif self.t == max_time-1:\\r\\n if agent.stock == 1:\\r\\n # stock position is forced to liquidate\\r\\n agent.cash = agent.stock_position * closing_price * (1 - transaction_fee)\\r\\n reward = agent.cash - agent.starting_cash\\r\\n self.done = True\\r\\n \\r\\n else:\\r\\n reward = 0\\r\\n self.done = True \\r\\n \\r\\n next_state = (self.episode[self.t+1]['ST Relative Indicator'], \\r\\n self.episode[self.t+1]['ST Relative Indicator'],\\r\\n agent.stock,\\r\\n self.t+1)\\r\\n self.t += 1\\r\\n \\r\\n return next_state, reward, self.done\",\n \"def step(self, action):\\n # check if suggested action is valid\\n valid = self._take_action(action)\\n if not valid:\\n _, _ = self._simulate()\\n response = self.worst_response\\n target = 6*60\\n else:\\n # simulate until a TS response is needed\\n response = np.inf\\n while response == np.inf:\\n response, target = self._simulate()\\n if np.isnan(target): # prio 2 or 3 incident: no target exists\\n target = response\\n\\n self.last_action = action if self.action_type == \\\"tuple\\\" else self.action_num_to_tuple[action]\\n # calculate reward and new state\\n self.reward = self._get_reward(response, target, valid=valid)\\n self.state, self.is_done = self._extract_state()\\n return self.state, self.reward, self.is_done, {\\\"note\\\": \\\"nothing to report\\\"}\",\n \"def _step(self, action):\\n\\n reward = 0.0\\n x, y = action\\n\\n if not Creator.add_edge(self.nxgraph, x+1, y+1):\\n reward = 0.0\\n # TODO: do we return here?\\n raise NotImplementedError\\n else:\\n reward = 1.0\\n new_state = EnvTools.get_state(self.nxgraph)\\n EnvTools.calculate_reward(self.state, self.previous_state)\\n raise NotImplementedError\\n\\n\\n\\n pass\",\n \"def step(self, action):\\n obs = self.gym.get_observations()\\n all_actions = self.gym.act(obs)\\n all_actions.insert(self.gym.training_agent, action)\\n state, reward, terminal, info = self.gym.step(all_actions)\\n agent_state = self.featurize(state[self.gym.training_agent])\\n\\n # agent_state_history = self.make_observation(agent_state, self.step)\\n agent_reward = reward[self.gym.training_agent]\\n\\n # self.step += 1\\n return agent_state, agent_reward, terminal, info\",\n \"def step(self, action):\\n\\n action[1] = 0 if action[1] < 0 else 1\\n\\n if not self.moving:\\n self.agent_host.sendCommand(\\\"move 0.5\\\")\\n time.sleep(.2)\\n self.moving = True\\n\\n # Get Action\\n command = \\\"strafe \\\" + str(action[0])\\n if ((action[0] < 0 and self.allow_left) or (action[0] > 0 and self.allow_right)):\\n self.agent_host.sendCommand(command)\\n time.sleep(.2)\\n self.agent_host.sendCommand(\\\"strafe 0\\\")\\n time.sleep(.1)\\n\\n if action[1]:\\n if self.checkCommand:\\n self.jumpsOverDitches += 1\\n self.checkCommand = False\\n self.agent_host.sendCommand(\\\"jump 1\\\")\\n time.sleep(.2)\\n self.agent_host.sendCommand(\\\"jump 0\\\")\\n\\n # if (command == \\\"crouch 1\\\"):\\n # self.agent_host.sendCommand(command)\\n # time.sleep(.3)\\n # self.agent_host.sendCommand(\\\"crouch 0\\\")\\n # time.sleep(.2)\\n\\n self.episode_step += 1\\n\\n # Get Observation\\n world_state = self.agent_host.getWorldState()\\n for error in world_state.errors:\\n print(\\\"Error:\\\", error.text)\\n self.obs, self.allow_left, self.allow_right, curZPos, curXPos = self.get_observation(world_state)\\n if curZPos:\\n self.curZPos = curZPos\\n if curXPos:\\n if self.obs[3 + int(curXPos)]:\\n self.checkCommand = True\\n self.numDitchesEncountered += 1\\n\\n # Get Done\\n done = not world_state.is_mission_running \\n\\n # Get Reward\\n reward = 0\\n for r in world_state.rewards:\\n reward += r.getValue()\\n self.episode_return += reward\\n\\n return self.obs, reward, done, dict()\",\n \"def step(self, action):\\n done = self.cur_step >= self.max_steps_per_episode\\n\\n if done:\\n raise RuntimeError(\\\"Episode is done\\\")\\n\\n self.cur_step += 1\\n\\n # Compute new state based on previous state and action\\n new_state = self._take_action(action)\\n\\n # Compute reward value based on previous state and action\\n reward = self._get_reward(action)\\n\\n # Update current state to new state\\n self.cur_state = new_state\\n\\n # Compute observation from current state\\n ob = self._get_obs() # Has to come after new state update\\n\\n # Update action, observation and reward histories\\n self.action_episode_memory[self.cur_episode].append(action)\\n self.observation_episode_memory[self.cur_episode].append(ob)\\n self.reward_episode_memory[self.cur_episode].append(reward)\\n\\n # Recompute done since action may have modified it\\n done = self.cur_step >= self.max_steps_per_episode\\n\\n return ob, reward, done, {}\",\n \"def step(self, action):\\r\\n reward = self.__execute(action)\\r\\n self.__totalReward += reward\\r\\n status = self.__status()\\r\\n state = self.__observe()\\r\\n logging.debug(\\\"action: {:10s} | reward: {: .2f} | status: {}\\\".format(Action(action).name, reward, status))\\r\\n return state, reward, status\",\n \"def _step(self, action):\\n if self._episode_ended:\\n # The last action ended the episode. Ignore the current action and start a new episode\\n return self.reset()\\n\\n env_action = self.y_train[self.id[self.episode_step]]\\n self.episode_step += 1\\n\\n if action == env_action: # Correct action\\n if env_action: # Minority\\n reward = 1 # True Positive\\n else: # Majority\\n reward = self.imb_rate # True Negative\\n\\n else: # Incorrect action\\n if env_action: # Minority\\n reward = -1 # False Negative\\n self._episode_ended = True # Stop episode when minority class is misclassified\\n else: # Majority\\n reward = -self.imb_rate # False Positive\\n\\n if self.episode_step == self.X_len - 1: # If last step in data\\n self._episode_ended = True\\n\\n self._state = self.X_train[self.id[self.episode_step]] # Update state with new datapoint\\n\\n if self._episode_ended:\\n return ts.termination(self._state, reward)\\n else:\\n return ts.transition(self._state, reward)\",\n \"def step(self, action):\\n self.t += 1\\n if self.use_run_time_assurance:\\n probe_state, unsafe = self.probe_step(action)\\n # switch to safe controller if unsafe\\n if unsafe:\\n x, x_dot, theta, theta_dot = probe_state\\n # go right\\n if x <= -self.x_threshold: # go right\\n action = 1\\n elif x>= self.x_threshold: # go left\\n action = 0 \\n \\n state, reward, done, info = self.env.step(action)\\n # Could make a custom reward here if you want\\n if self.use_action_masking:\\n self.update_avail_actions(state)\\n obs = {\\n \\\"action_mask\\\": self.action_mask,\\n \\\"actual_obs\\\": state,\\n }\\n else:\\n obs = state\\n \\n if self.t >= 200: # ------ change if using v1\\n done = True\\n return obs, reward, done, info\",\n \"def step(self, action):\\n\\n \\\"\\\"\\\"\\n Here we should convert the action num to movement action, execute the action in the\\n simulation and get the observations result of performing that action.\\n \\\"\\\"\\\"\\n #if self.step_number > 200:\\n #self.reset()\\n rospy.logdebug(\\\"START STEP OpenAIROS\\\")\\n\\n self.gazebo.unpauseSim()\\n self._set_action(action)\\n #self._prey_step()\\n self.gazebo.pauseSim()\\n obs = self._get_obs()\\n done = self._is_done(obs)\\n info = {}\\n reward = self._compute_reward(obs, done)\\n \\n self.cumulated_episode_reward = self.cumulated_episode_reward+ reward\\n self.step_number += 1\\n rospy.logdebug(\\\"END STEP OpenAIROS\\\")\\n\\n return obs, reward, done, info\",\n \"def _single_agent_step(self, action):\\n reward = 0.0\\n done = False\\n self.timestep += 1\\n state, player_id = self.game.step(action)\\n while not self.game.is_over() and not player_id == self.active_player:\\n self.timestep += 1\\n action, _ = self.model.agents[player_id].eval_step(\\n self._extract_state(state)\\n )\\n if not self.model.agents[player_id].use_raw:\\n action = self._decode_action(action)\\n state, player_id = self.game.step(action)\\n\\n if self.game.is_over():\\n reward = self.get_payoffs()[self.active_player]\\n done = True\\n state = self.reset()\\n return state, reward, done\\n\\n return self._extract_state(state), reward, done\",\n \"def step(self, action, skiprate=1):\\n reward = self.game.make_action(action, skiprate)\\n next_state = self.game.get_state()\\n game_over = self.game.is_episode_finished()\\n return next_state, reward, game_over\",\n \"def act(self, state):\\n # Append the state to the short term memory (ie. History)\\n self._history.append(state)\\n\\n # If policy requires agent to explore, sample random action\\n if self._explorer.is_exploring(self._num_actions_taken):\\n action = self._explorer(self.nb_actions)\\n else:\\n # Use the network to output the best action\\n env_with_history = self._history.value\\n q_values = self._action_value_net.eval(\\n # Append batch axis with only one sample to evaluate\\n env_with_history.reshape((1,) + env_with_history.shape)\\n )\\n\\n self._episode_q_means.append(np.mean(q_values))\\n self._episode_q_stddev.append(np.std(q_values))\\n\\n # Return the value maximizing the expected reward\\n action = q_values.argmax()\\n\\n # Keep track of interval action counter\\n self._num_actions_taken += 1\\n return action\",\n \"def run_one_step(self):\\n # Get the current state, action and initialise the reward\\n state = copy.copy(self.env.get_state())\\n action = self.agent.get_action(state)\\n reward = 0.0\\n # Check if the environment has reached a terminal state\\n if self.env.check_terminal() is False:\\n # Save the initial state and action to an 'experience'\\n latest_experience = Experience(copy.copy(state), copy.copy(action))\\n # Update the environment using the chosne action\\n self.env.update(action)\\n # Get the reward to attribute to the agent and save to the experience to save\\n reward = self.env.get_reward()\\n latest_experience.reward = copy.copy(reward)\\n # Get the updated state\\n state = self.env.get_state()\\n if self.env.check_terminal() is False:\\n # If the new state isn't terminal, save the next action and the 'done' flag to the experience\\n action = self.agent.get_action(state)\\n latest_experience.done = False\\n else:\\n # If the new state is terminal, save a dummy action and the 'done' flag to the experience\\n action = 0.0\\n latest_experience.done = True\\n latest_experience.next_state = copy.copy(state)\\n latest_experience.next_action = copy.copy(action)\\n # Update the history with the latest experience\\n self.agent.update_history(copy.copy(latest_experience))\\n # Update the agents policy using a batch of experiences chosen from the history\\n self.agent.update_policy_batch(max(1, self.batch_size))\\n self.count += 1\\n # Update the target network if appropriate\\n if self.update_target_rate is not None:\\n if self.count % self.update_target_rate == 0:\\n self.agent.policy.learner.update_target_network()\\n else:\\n # If the environment is in a terminal state, record this and perform a policy update\\n latest_experience = Experience(copy.copy(state), copy.copy(action))\\n latest_experience.reward = 0.0\\n latest_experience.next_state = copy.copy(state)\\n latest_experience.next_action = 0.0\\n latest_experience.done = True\\n self.agent.update_history(copy.copy(latest_experience))\\n self.agent.update_policy_batch(max(1, self.batch_size))\\n self.count = 0\\n return reward\",\n \"def step(self,action):\\n observation, reward, done, info = self.env.step(action)\\n if info[\\\"health\\\"] <= 0 or info[\\\"enemy_health\\\"] <= 0:\\n self.player_hp = 120\\n self.enemy_hp = 120\\n reward = 0\\n else:\\n self.player_hp = info['health']\\n self.enemy_hp = info[\\\"enemy_health\\\"]\\n reward = self.player_hp - self.enemy_hp\\n\\n\\n if info[\\\"enemy_rounds_won\\\"] == 2 or info[\\\"rounds_won\\\"] == 2:\\n self.player_hp = 120\\n self.enemy_hp = 120\\n reward = 0\\n done = True\\n\\n obs = self.observation(observation)\\n if self.current_frame_number == self.frame_skipping:\\n self.q.append(obs)\\n self.current_frame_number = 0 \\n self.current_frame_number += 1\\n reward = reward / 120 +1\\n return np.array(list(self.q)), reward, done, info\",\n \"def agent_step(self, reward, observation):\\n\\n self.step_counter += 1\\n return_action = Action()\\n\\n current_image, raw_image = self.preprocess_observation(observation.intArray)\\n\\n # if self.step_counter % 100 == 0:\\n # plt.imshow(current_image)\\n # plt.colorbar()\\n # plt.show()\\n # time.sleep(0.4)\\n\\n #TESTING---------------------------\\n if raw_image is not None:\\n self.episode_images.append(raw_image)\\n self.episode_reward += reward\\n int_action, max_q = self.choose_action(self.test_data_set, self.testing_epsilon,\\n current_image, np.clip(reward, -1, 1))\\n if max_q is not None:\\n self.epoch_considered_steps += 1\\n\\n if self.pause > 0:\\n time.sleep(self.pause)\\n\\n # Map it back to ALE's actions\\n return_action.intArray = [int_action]\\n\\n self.last_action = int_action\\n self.last_image = current_image\\n\\n return return_action\",\n \"def step(self, action):\\n assert self.action_space.contains(\\n action), \\\"%r (%s) invalid\\\" % (action, type(action))\\n self.time_step += 1\\n reward = float(0)\\n self.is_episode_done = False\\n\\n # For testing code\\n current_edge_agg_num = self.time_step\\n\\n # Rescale the action from [-1, 1] to [1, 2, ... , 9]\\n # The action is the number of aggregations on edge servers\\n # current_edge_agg_num = int((action + 2) * (action + 2))\\n\\n logging.info(\\\"RL Agent: Start time step #%s...\\\", self.time_step)\\n logging.info(\\n \\\"Each edge server will run %s rounds of local aggregation.\\\",\\n current_edge_agg_num)\\n\\n # Pass the tuned parameter to RL agent\\n self.rl_agent.get_tuned_para(current_edge_agg_num, self.time_step)\\n\\n # Wait for state\\n current_loop = asyncio.get_event_loop()\\n get_state_task = current_loop.create_task(self.wait_for_state())\\n current_loop.run_until_complete(get_state_task)\\n #print('State:', self.state)\\n\\n self.normalize_state()\\n #print('Normalized state:', self.state)\\n\\n reward = self.get_reward()\\n info = {}\\n\\n self.rl_agent.cumulative_reward += reward\\n\\n # Signal the RL agent to start next time step (next round of FL)\\n self.step_done.set()\\n\\n return np.array([self.state]), reward, self.is_episode_done, info\",\n \"def step(self, action):\\n\\n if not self._is_action_legal(action):\\n return self.current_state, self.reward_illegal_action, self._is_terminal_state(), None\\n else:\\n # Change action passed if environment should behave random\\n if self.stochastic:\\n if not np.random.choice([True, False], 1, p=[self.p, 1 - self.p]):\\n action = np.random.choice(self.possible_actions)\\n\\n # Needed for reward calculation (must be done before updating data structures)\\n number_of_shifts = self._get_number_of_shifts(action)\\n is_cargo_mandatory = int(self.vehicle_data[2][action] == 1)\\n\\n slot = self.end_of_lanes[self.current_Lane]\\n self.loading_sequence += \\\"{}. Load Vehicle Type \\\\t {} \\\\t in Lane: \\\\t {} \\\\t Row: \\\\t {} \\\\n\\\" \\\\\\n .format(self.sequence_no, action, self.current_Lane, slot)\\n\\n self.end_of_lanes[self.current_Lane] += self.vehicle_data[4][action]\\n\\n if self.vehicle_data[1][action] == -1 or \\\\\\n self.number_of_vehicles_loaded[action] < self.vehicle_data[1][action]:\\n self.number_of_vehicles_loaded[action] += 1\\n\\n self.loaded_vehicles[self.current_Lane][self.vehicle_Counter[self.current_Lane]] = action\\n self.vehicle_Counter[self.current_Lane] += 1\\n\\n # Update grids\\n for i in range(self.vehicle_data[4][action]):\\n self.grid.T[self.current_Lane][slot + i] = self.sequence_no\\n self.grid_destination.T[self.current_Lane][slot + i] = self.vehicle_data[3][action]\\n self.grid_vehicle_type.T[self.current_Lane][slot + i] = self.vehicle_data[0][action]\\n\\n # Update lowest destination data structure\\n if self.vehicle_data[3][action] < self.lowest_destination[self.current_Lane]:\\n self.lowest_destination[self.current_Lane] = self.vehicle_data[3][action]\\n\\n self.sequence_no += 1\\n # Update according to lane selection heuristic\\n self.current_Lane = self._get_minimal_lanes()[0]\\n\\n self.possible_actions = self.get_possible_actions_of_state()\\n self.current_state = self._get_current_state()\\n\\n if self._is_terminal_state():\\n # Calculate reward for terminal state\\n free_spaces = np.sum(self._get_free_capacity()) / np.sum(self.total_capacity)\\n mandatory_vehicles_left_to_load = np.sum(self.vehicle_data[1][self.mandatory_cargo_mask]\\n - self.number_of_vehicles_loaded[self.mandatory_cargo_mask])\\n reward_features = np.array(\\n [is_cargo_mandatory, number_of_shifts, free_spaces, mandatory_vehicles_left_to_load])\\n reward = np.dot(self.reward_system, reward_features) + self.zeta\\n\\n return self.current_state, reward, True, {}\\n else:\\n # Calculate reward\\n reward_features = np.array([is_cargo_mandatory, number_of_shifts, 0, 0])\\n reward = np.dot(self.reward_system, reward_features) + self.zeta\\n\\n return self.current_state, reward, False, {}\",\n \"def step(self, action):\\n # if self.current_turn<self.MAX_TURNS-1:\\n # self.current_turn += 1\\n \\n\\n self.current_turn += 1\\n system_action = self.parseAction(action)\\n \\n # Used for logging and evaluation\\n self.updateMetaState(system_action)\\n\\n self.processSystemAction(system_action)\\n\\n reward = self.calculateReward()\\n\\n user_action = self.user.respond(system_action)\\n self.processUserAction(user_action)\\n observation = self.generateObservation()\\n done = self.isDone()\\n if done:\\n info = { \\\"successful\\\": self.user.goals[\\\"satisfied\\\"], \\n \\\"first-appearance\\\": self.first_appearance, \\n \\\"turn-penalty\\\": self.current_turn,\\n \\\"sugg-all-penalty\\\":self.sugg_penalty,\\n \\\"info-all-penalty\\\": self.info_penalty,\\n \\\"eli-kw-used\\\": self.eli_kw_observed,\\n \\\"eli-query-used\\\": self.eli_query_observed,\\n }\\n else:\\n info = {}\\n if self.training:\\n if done and self.user.goals[\\\"satisfied\\\"]: reward+=30\\n return observation, reward, done, info\",\n \"def step(self, action):\\n self.t += 1\\n state, reward, done, info = self.env.step(action)\\n if self.use_action_masking:\\n self.update_avail_actions(state)\\n obs = {\\n \\\"action_mask\\\": self.action_mask,\\n \\\"actual_obs\\\": state,\\n }\\n else:\\n obs = state\\n \\n if self.t >= 200: # ------ change if using v1\\n done = True\\n return obs, reward, done, info\",\n \"def step(self, reward, observation):\\n self._last_observation = self._observation\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._store_transition(self._last_observation, self.action, reward, False)\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def act(self, action:Action) -> None:\\r\\n if self.terminated:\\r\\n raise ValueError # must restart mdp first, as agent already took Terminate action on terminal\\r\\n\\r\\n if action == Action.TERMINAL:\\r\\n self.terminated = True\\r\\n return\\r\\n\\r\\n if uniform(0, 1) < self.failure:\\r\\n action = action.turn(uniform(0, 1) <= 0.5) # clockwise or counter-clockwise with equal chance for both\\r\\n print(\\\"FAIL:\\\", action)\\r\\n\\r\\n dx, dy = action.delta()\\r\\n x, y = self.agent_x+dx, self.agent_y+dy\\r\\n\\r\\n if x < 0 or x >= len(self.fields) or y < 0 or y >= len(self.fields[0]) or self.fields[x][y] == Field.OBSTACLE:\\r\\n return\\r\\n\\r\\n self.agent_x = x\\r\\n self.agent_y = y\",\n \"def _step(self, action):\\n\\n # action is generated from the action_policy (external to the environment)\\n if len(action) == 4:\\n object_index, new_location, action_means, action_stds = action\\n if len(action) == 2:\\n \\\"\\\"\\\"\\n Action is not generated from a Gaussian distribution\\n \\\"\\\"\\\"\\n object_index, new_location = action\\n action_means = action_stds = None\\n \\n position = new_location[:2]\\n rotation = new_location[2]\\n\\n prev_transform = self.e.objects[object_index].transform\\n\\n if len(self.action_storage) > 0:\\n last_progress = self.action_storage[-1][4]\\n else:\\n last_progress = 0\\n\\n info = {}\\n if self.e.act(object_index, Command(position, rotation)):\\n # print ('Action accepted')\\n cur_transform = self.e.objects[object_index].transform\\n # I need to call self.action_storage.append before get_observation_and_progress\\n self.action_storage.append( [object_index, prev_transform, cur_transform, None, None, True, action_means, action_stds] )\\n observation, progress = self.get_observation_and_progress()\\n self.action_storage[-1][3:5] = [observation, progress]\\n\\n info['action_accepted'] = True\\n else:\\n \\\"\\\"\\\"\\n Action failed\\n We can reduce the progress to avoid falling out of the table\\n \\\"\\\"\\\"\\n if len(self.action_storage) > 0:\\n # Just return observation and progress of last action\\n _, _, _, observation, progress, _, _, _ = self.action_storage[-1]\\n progress -= self.config.failed_action_penalty\\n else:\\n # First action failed\\n observation, _ = self.get_observation_and_progress()\\n progress = -self.config.failed_action_penalty\\n \\n self.action_storage.append( [object_index, prev_transform, prev_transform, observation, progress, False, action_means, action_stds] )\\n\\n \\n info['action_accepted'] = False\\n\\n # Typical threshold approach\\n if progress > self.progress_threshold:\\n # Finish action\\n done = True\\n else:\\n done = False\\n \\n reward = progress - last_progress\\n #print ('Progress = %.2f ; reward = %.2f' % (progress, reward))\\n\\n return (observation, reward, done, info)\",\n \"def step(self, action):\\r\\n s = self.get_state()\\r\\n\\r\\n elements = np.arange(self.S)\\r\\n # weights = np.squeeze(self.nextStateProbability[s,action])\\r\\n weights = self.nextStateProbability[s, action]\\r\\n nexts = choices(elements, weights, k=1)[0]\\r\\n\\r\\n # p = self.nextStateProbability[s,action]\\r\\n # reward = self.rewardsTable[s,action, nexts][0]\\r\\n reward = self.rewardsTable[s, action, nexts]\\r\\n\\r\\n # fully observable MDP: observation is the actual state\\r\\n self.currentObservation = nexts\\r\\n\\r\\n gameOver = False\\r\\n if self.currentIteration > np.Inf:\\r\\n ob = self.reset()\\r\\n gameOver = True # game ends\\r\\n else:\\r\\n ob = self.get_state()\\r\\n\\r\\n history = {\\\"time\\\": self.currentIteration, \\\"state_t\\\": s, \\\"action_t\\\": action,\\r\\n \\\"reward_tp1\\\": reward, \\\"state_tp1\\\": nexts}\\r\\n # history version with actions and states, not their indices\\r\\n # history = {\\\"time\\\": self.currentIteration, \\\"action_t\\\": self.actionListGivenIndex[action],\\r\\n # \\\"reward_tp1\\\": reward, \\\"observation_tp1\\\": self.stateListGivenIndex[self.get_state()]}\\r\\n self.currentIteration += 1\\r\\n return ob, reward, gameOver, history\",\n \"def step(self, action: int):\\n assert self.action_space.contains(action)\\n loc = action\\n if self.done:\\n return self._get_obs(), 0, True, None\\n\\n reward = NO_REWARD\\n # update bord\\n self.board[loc] = to_code(self.mark)\\n\\n # check if game has ended\\n status = check_game_status(self.board)\\n if status >= 0:\\n self.done = True\\n if status in [1, 2]:\\n reward = O_REWARD if self.mark == 'O' else X_REWARD\\n\\n # update mark\\n self.mark = next_mark(self.mark)\\n\\n return self._get_obs(), reward, self.done, None\",\n \"def step(self, reward, observation):\\n self._last_observation = self._observation\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._store_transition(self._last_observation, self.action, reward, False)\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_quantile_samples,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn,\\n self._tau,\\n self.optimizer)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def execute_action(self, agent, action):\\n agent.bump = False\\n agent.performance_measure -= 1\\n \\n if action == 'TurnRight':\\n agent.heading = self.turn_heading(agent.heading, -1)\\n elif action == 'TurnLeft':\\n agent.heading = self.turn_heading(agent.heading, +1)\\n elif action == 'Forward':\\n self.move_to(agent, vector_add(self.heading_to_vector(agent.heading),\\n agent.location))\\n elif action == 'Grab':\\n if self.some_things_at(agent.location, tclass=Gold):\\n try:\\n gold = self.list_things_at(agent.location, tclass=Gold)[0]\\n agent.has_gold = True\\n self.delete_thing(gold)\\n except:\\n print \\\"Error: Gold should be here, but couldn't find it!\\\"\\n print 'All things:', self.list_things_at(agent.location)\\n print 'Gold?:', self.list_things_at(agent.location, tclass=Gold)\\n sys.exit(-1)\\n\\n elif action == 'Release':\\n if agent.location == self.entrance:\\n if agent.has_gold:\\n agent.performance_measure += 1000\\n self.done = True\\n elif action == 'Shoot':\\n if agent.has_arrow:\\n agent.has_arrow = False\\n agent.performance_measure -= 10\\n self.shoot_arrow(agent)\\n elif action == 'Stop':\\n self.done = True\\n \\n print '\\\\nCurrent Location: ', agent.location\\n print 'Heading: ', self.heading_to_str(agent.heading)\\n print 'Reminder- Start Location:', self.entrance\\n print ''\\n print 'Percepts:'\",\n \"def step(self, action):\\n res = self.reward_table.get(self.curr_state, action)\\n\\n self.curr_state = res['result']\\n\\n return res\",\n \"def perform_action(self, action):\\n \\n assert self.is_valid_action(action)\\n \\n # Save the action.\\n self.action = action\\n \\n #the slight strategy of the opponent\\n if self.reward==rLose :\\n observation = self.observation\\n else:\\n observation = random.choice([oRock,oPaper,oScissor])\\n \\n #determine the result of the game and get the reward\\n if action == aRock:\\n if observation == oRock:\\n reward= rDraw\\n elif observation == oPaper:\\n reward= rLose\\n elif observation == oScissor:\\n reward= rWin\\n elif action == aPaper:\\n if observation == oRock:\\n reward= rWin\\n elif observation == oPaper:\\n reward= rDraw\\n elif observation == oScissor:\\n reward= rLose\\n elif action == aScissor:\\n if observation == oRock:\\n reward= rLose\\n elif observation == oPaper:\\n reward= rWin\\n elif observation == oScissor:\\n reward= rDraw\\n \\n \\n #Store the observation and reward in the environment.\\n self.observation = observation\\n \\n self.reward = reward\\n \\n \\n return (observation, reward)\\n # end def\",\n \"def step (self, action):\\n if self.done == 1:\\n print(\\\"episode done\\\")\\n return [self.state, self.reward, self.done, self.info]\\n\\n else:\\n degree = float(action[0] * HI_ANGLE)\\n loc, last_pos = self.state\\n\\n theta = self.fire.deg_to_rad(degree)\\n pos = round(self.fire.calc_dist(theta))\\n delta = abs(loc - pos)\\n\\n self.state[1] = pos\\n self.info[\\\"degree\\\"] = degree\\n self.info[\\\"theta\\\"] = round(theta, 3)\\n self.info[\\\"delta\\\"] = delta\\n\\n self.render()\\n\\n if pos <= self.fire.radius:\\n # realistically, the launch crew should be dead\\n self.reward = -100.0\\n elif delta <= self.fire.radius:\\n # target hit (within blast radius)\\n self.reward = 100.0\\n self.done = 1;\\n else:\\n # reward is the \\\"nearness\\\" of the blast destroying the target\\n self.reward = round(100.0 * float(abs(loc - delta)) / float(self.fire.range))\\n\\n return [self.state, self.reward, self.done, self.info]\",\n \"def step(self, action):\\n self.steps += 1\\n self.robots[0].setAction(action)\\n for i in range(self.num_agents):\\n if i != 0 and self.policies[i:i+1]: # self.policies[0] is dummy\\n self.robots[i].setAction(self.policies[i](self.robots[i].getObservation()))\\n # rewards = [ -1.0 * self.num_foods / self.max_steps for _ in range(self.num_agents) ] # so agent needs to eat foods quickly\\n rewards = [ 0.0 for _ in range(self.num_agents) ]\\n for i in range(self.BULLET_STEPS):\\n p.stepSimulation()\\n rewards = [ rewards[i]+self._getReward(self.robots[i]) for i in range(self.num_agents) ]\\n self.episode_rewards = [ self.episode_rewards[i]+rewards[i] for i in range(self.num_agents) ]\\n obs = self.robots[0].getObservation()\\n done = self._isDone()\\n info = { 'steps': self.steps }\\n if done:\\n # TODO\\n info['episode'] = { 'r': self.episode_rewards[0], 'l': self.steps, 'r_all': self.episode_rewards }\\n # print(self.episode_rewards, self.steps)\\n return obs, rewards[0], done, info\",\n \"def act(self, time, observations, reward):\\n return 0\",\n \"def step(self, actions, agent_id=0):\\n self._last_state = self._current_state\\n\\n # TODO\\n # action = actions.discrete_actions[0]-1\\n action = actions.argmax()\\n\\n done = 0\\n if self._stage == 0: # is fixation\\n if action == 0:\\n reward = 0.\\n else:\\n reward = -1.\\n self._current_state = 1\\n self._stage = 1\\n elif self._stage == 1: # is first stage, use prob_transition\\n if action == 1 or action == 2:\\n if np.random.random() < self._prob_transition[0][action-1]:\\n self._current_state = 2\\n else:\\n self._current_state = 3\\n reward = 0.\\n else: # pick a next state at random\\n reward = -1.\\n self._current_state = np.random.random() < 0.5 and 2 or 3\\n self._stage = 2\\n else: # is second stage, use prob_reward\\n # Given an action (arm pulled), sample reward, return\\n if action == 1 or action == 2:\\n current_prob_rewards = self._prob_reward[self._current_state-2]\\n self._best_reward = self._max_reward*np.max(current_prob_rewards)\\n thisProb = current_prob_rewards[action-1]\\n if np.random.random() < thisProb:\\n # print(\\\"give reward\\\")\\n reward = self._max_reward\\n else:\\n reward = 0.0\\n else:\\n reward = -1.\\n\\n self._total_reward += reward\\n self._best_total_reward += self._best_reward\\n self._stage = 0\\n self._current_state = 0\\n self._trial += 1\\n self._since_flipped += 1\\n # if more than self._min_stable trials since flipping, certain chance of flipping prob rews\\n if (self._since_flipped >= self._min_stable) and (np.random.random() <= self._flip_prob):\\n self._randomize()\\n self._since_flipped = 0\\n\\n\\n self._last_action = np.zeros(self._num_arms)\\n self._last_action[action] = 1\\n # conditions to end episode\\n if self._step >= self._steps_per_ep-1:\\n self._state = READY_TO_END_EPISODE\\n done = 1\\n\\n self._step += 1\\n self._prev_reward = reward\\n\\n obs = self._current_state\\n reset = done == 1. or self._step == MAX_FRAMES\\n\\n # print(np.array([[obs]]).shape)\\n\\n # print(reward, self._stage)\\n return np.array([obs]), reward, done, reset\",\n \"def step(self, action):\\n if self.platform is None:\\n raise RuntimeError(\\\"Call `reset()` before starting to step.\\\")\\n\\n if not self.action_space.contains(action):\\n raise ValueError(\\n \\\"Given action is not contained in the action space.\\\")\\n\\n num_steps = self.frameskip\\n\\n # ensure episode length is not exceeded due to frameskip\\n step_count_after = self.step_count + num_steps\\n if step_count_after > self.episode_length:\\n excess = step_count_after - self.episode_length\\n num_steps = max(1, num_steps - excess)\\n\\n reward = 0.0\\n for _ in range(num_steps):\\n self.step_count += 1\\n if self.step_count > self.episode_length:\\n raise RuntimeError(\\\"Exceeded number of steps for one episode.\\\")\\n\\n # send action to robot\\n robot_action = self._gym_action_to_robot_action(action)\\n t = self.platform.append_desired_action(robot_action)\\n\\n # Use observations of step t + 1 to follow what would be expected\\n # in a typical gym environment. Note that on the real robot, this\\n # will not be possible\\n observation = self._create_observation(t + 1)\\n\\n reward += self.compute_reward(observation, self.info)\\n\\n is_done = self.step_count == self.episode_length\\n\\n return observation, reward, is_done, self.info\",\n \"def step(self, action, decoder_hidden):\\r\\n\\r\\n # Check whether episode is over\\r\\n if (action == EOS_token) or (len(self.predicted_words)>= self.max_length):\\r\\n self.state = action, decoder_hidden\\r\\n RL_model_reward = model_evaluation.performance_metrics(\\r\\n target_sentence=self.target_sentence, pred_sentence=self.pred_sentence(), \\r\\n similarity_model=self.similarity_model, fluency_model=self.fluency_model, ESIM_model=self.ESIM_model,\\r\\n logr_model=self.logr_model, std_scaler=self.std_scaler,\\r\\n similarity_dist=self.similarity_dist, fluency_dist=self.fluency_dist, ESIM_dist=self.ESIM_dist,\\r\\n vocab_index=vocab_index, metric=self.reward_function)\\r\\n # Calculate relative reward\\r\\n self.ep_reward = np.around(RL_model_reward, 3)\\r\\n self.done = 1\\r\\n else:\\r\\n self.state = action, decoder_hidden\\r\\n \\r\\n # Add word to pred words\\r\\n self.predicted_words.append(vocab_index.index2word[action.item()])\\r\\n \\r\\n return self.state, self.ep_reward, self.done, None\",\n \"def step(self, action:list) -> (np.ndarray, float, bool, dict):\\n\\n\\n action[0] = (action[0] + 1)/2 # Done to be compatible with RL algorithms that require symmetric action spaces\\n if np.isnan(action).any(): action = np.zeros(action.shape)\\n self.main_vessel.step(action)\\n\\n for vessel in self.moving_obstacles:\\n if vessel.index != 0:\\n obs = vessel.observe()\\n reward = self.rewarder_dict[vessel.index].calculate()\\n insight = self.rewarder_dict[vessel.index].insight()\\n #print(f'Reward for vessel {vessel.index}: {reward} -- lambda: {insight}')\\n obs = np.concatenate([insight,obs])\\n action, _states = self.agent.predict(obs, deterministic=True)\\n action[0] = (action[0] + 1)/2\\n vessel.step(action)\\n\\n # Testing criteria for ending the episode\\n done = self._isdone()\\n self._save_latest_step()\\n\\n # Getting observation vector\\n obs = self.observe()\\n vessel_data = self.main_vessel.req_latest_data()\\n self.collision = vessel_data['collision']\\n self.reached_goal = vessel_data['reached_goal']\\n self.progress = vessel_data['progress']\\n\\n # Receiving agent's reward\\n reward = self.rewarder.calculate()\\n self.last_reward = reward\\n #self.cumulative_reward += reward\\n\\n info = {}\\n info['collision'] = self.collision\\n info['reached_goal'] = self.reached_goal\\n info['progress'] = self.progress\\n\\n self.t_step += 1\\n\\n return (obs, reward, done, info)\",\n \"def step(self, action):\\n action = self.randomization.action_randomizer.randomize(\\n action, self._random_state\\n )\\n\\n robot_exception = None\\n try:\\n self._act(action)\\n except RobotException as re:\\n logger.error(\\n f\\\"Robot raised exception: {str(re)}. This will finish the current episode.\\\"\\n )\\n robot_exception = re\\n\\n if not self.constants.physical:\\n # We don't need to do stepping for physical roll out.\\n self.mujoco_simulation.step()\\n\\n self._synchronize_step_time()\\n self.t += 1\\n\\n obs, reward, done, info = self.get_observation(robot_exception=robot_exception)\\n obs, reward, done, info = self.step_finalize(obs, reward, done, info)\\n return obs, reward, done, info\",\n \"def _step(self, state, action):\\n dealer_hand, player_hand = state[0], state[1]\\n\\n if action == \\\"hit\\\":\\n player_hand = self._play_card(player_hand)\\n else:\\n dealer_hand = self._dealer_step(dealer_hand)\\n self._terminate = True\\n\\n reward = self._get_reward(dealer_hand, player_hand)\\n\\n if reward != 0:\\n self._terminate = True\\n\\n return [dealer_hand, player_hand], reward\",\n \"def step(self, action):\\n assert self.action_space.contains(action), \\\"%r (%s) invalid\\\"%(action, type(action))\\n self.microgridPolicy.improveAction(action);\\n\\n self.microgrid.update();\\n\\n self.updateState();\\n done = self.microgridPolicy.verifyStopConditions();\\n reward = self.microgridPolicy.computeReward(done)\\n if done: \\n if self.steps_beyond_done is None:\\n self.steps_beyond_done = 0\\n else:\\n logger.warn(\\\"You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.\\\")\\n self.steps_beyond_done += 1\\n self.clock.increaseTimeStep();\\n return self.state, reward, done, {}\",\n \"def step(self, action):\\n self.timestep += 1\\n self.actions = action.ravel()\\n\\n # Figure out which action was taken\\n self.acted = False\\n self.eat = False\\n self.discard = False\\n if action[0] > .5:\\n self.eat = True\\n self.acted = True\\n elif action[1] > .5:\\n self.discard = True\\n self.acted = True\\n\\n # Check whether the appropriate action was taken, and assign reward.\\n # There is a small punishment for doing nothing.\\n self.reward = -.1\\n if ((self.eat and self.edible) or\\n (self.discard and not self.edible)):\\n self.reward = 1.\\n elif ((self.eat and not self.edible) or\\n (self.discard and self.edible)):\\n self.reward = -.9\\n\\n if self.acted:\\n self.grab_fruit()\\n\\n return self.sensors, self.reward\",\n \"def run_one_step(self):\\n state = copy.copy(self.env.get_state())\\n action = self.agent.get_action(state)\\n reward = 0.0\\n if self.env.check_terminal() is False:\\n latest_experience = Experience(copy.copy(state), copy.copy(action))\\n self.env.update(action)\\n reward = self.env.get_reward()\\n latest_experience.reward = copy.copy(reward)\\n state = self.env.get_state()\\n if self.env.check_terminal() is False:\\n action = self.agent.get_action(state)\\n latest_experience.done = False\\n else:\\n action = 0.0\\n latest_experience.done = True\\n latest_experience.next_state = copy.copy(state)\\n latest_experience.next_action = copy.copy(action)\\n self.agent.update_history(copy.copy(latest_experience))\\n self.count += 1\\n # If the latest history has a large enough batch, perform an update\\n # CHECK IF THIS IS THE RIGHT METHOD\\n if self.count % self.batch_size == 0:\\n self.agent.update_policy_ordered(max(1, self.batch_size))\\n if self.update_target_rate is not None:\\n if self.count % self.update_target_rate == 0:\\n self.count = 0\\n self.agent.policy.learner.update_target_network()\\n else:\\n latest_experience = Experience(copy.copy(state), copy.copy(action))\\n latest_experience.reward = 0.0\\n latest_experience.next_state = copy.copy(state)\\n latest_experience.next_action = 0.0\\n latest_experience.done = True\\n self.agent.update_history(copy.copy(latest_experience))\\n # Perform an update on all of the previous experiences that haven't been updated\\n if self.count % self.batch_size > 0:\\n self.agent.update_policy_ordered((self.count % self.batch_size) + 1)\\n self.count = 0\\n return reward\",\n \"def takeAction(self, action):\\n return self.env.step(action)\",\n \"def step(self, agent_action):\\n\\n done = False\\n self.round += 1\\n # First check round num, if equal to max then fail\\n if self.round == self.max_round:\\n done = True\\n success = FAIL\\n user_response = self._end_response()\\n else:\\n try:\\n success = self.update_state(agent_action)\\n if success:\\n user_response = self._end_response()\\n else:\\n agent_intent = agent_action['intent']\\n assert agent_intent in self.user_responses, 'Not acceptable agent action'\\n user_response = self.user_responses[agent_intent](agent_action)\\n except Exception:\\n return self._default_response(),-5,False,False\\n\\n reward = self.reward_function(agent_action, success)\\n\\n return user_response, reward, done, True if success is 1 else False\",\n \"def oneActionReward(self, state, action, redTurn):\\n\\n # TODO this is the main bottleneck for the neural network learning part\\n # the only way to speed this up, would be to reduce the number of calls to networks\\n # or optimize how the networks are called\\n\\n # save the original game\\n oldGame = self.game\\n self.game = state\\n self.gameEnv.game = state\\n oldCurrent = self.current\\n\\n # initialize reward for this action\\n totalReward = 0\\n\\n # if the given action is None, then an action must be determined\\n if action is None:\\n # determine which enemy piece will move\\n self.gameEnv.performAction(self.gameNetwork)\\n\\n # determine the direction that piece will move\\n # if there is no valid network input, do not make an action\\n netInput = self.toNetInput()\\n # find the actual action\\n if netInput is not None:\\n action = self.internalNetwork.chooseAction(netInput, takeAction=self.canTakeAction)\\n else:\\n # This shouldn't ever be reached, because if self.toNetInput() returns None,\\n # then self.current must be None, which only should happen after\\n # self.gameEnv.performAction(self.gameNetwork) is called, but it should\\n # only set that if the game is over, so if that first move ended the game\\n # then this part of the code should never be reached\\n # If this line is reached, then some error has happened\\n action = None\\n\\n piecePos = self.current\\n\\n # if a move cannot be made, ensure win conditions are checked\\n if action is None:\\n self.game.checkWinConditions()\\n # if an action can be taken, then the game is not over, so make a move\\n else:\\n # find the modifiers for the action\\n modifiers = moveIntToBoolList(action)\\n\\n # add the reward for the piece moving\\n moveR = moveReward(self.game, piecePos, modifiers, redTurn)\\n if moveR is not None:\\n totalReward += moveR\\n # make the move\\n self.game.play(piecePos, modifiers)\\n\\n # if the game ends, add reward for winning\\n winReward = endGameReward(self.game.win, redTurn, self.game.moves)\\n if winReward is not None:\\n totalReward += winReward\\n else:\\n # if no move reward was found, then there was no valid reward, so set the reward to None\\n totalReward = None\\n\\n # put the game back to it's original state\\n self.game = oldGame\\n self.gameEnv.game = oldGame\\n self.current = oldCurrent\\n\\n # return the final reward\\n return totalReward\",\n \"def act(self, observation, reward, done):\\n if self._not_restarted(observation):\\n # not the first action, remember it and update model\\n self._remember(self.prev_action, reward, observation, done)\\n if len(self.replay_memory) > self.batch_size:\\n self._replay()\\n\\n # determine the next action if not yet done\\n action = None\\n\\n if not done:\\n # epsilon greedy\\n if random.uniform(0, 1) < self.epsilon_policy.get():\\n # exploration: random action\\n action = self.action_space.sample()\\n action['start_time'] += 1 # non-zero start times\\n else:\\n # exploitation\\n action = self._get_best_action(observation)\\n\\n self.prev_observation = observation\\n self.prev_action = action\\n\\n return action\",\n \"def step(self, action):\\n (self.state, self.reward, self.terminal, self.truncated,\\n self.info) = self.env.step(action)\\n\\n return self.state, self.reward, self.terminal, self.truncated, self.info\",\n \"def step(self):\\n self.step_n += 1\\n self.step_t += 1\\n # TODO: directly calling agent.act will by-pass BaseDeepAgent, which\\n # checks and assigns 'sess' arugment. So we manually set sess here. But\\n # is there a better way to do this?\\n self.action = self.agent.act(\\n state=self.state, sess=self.agent.sess\\n )\\n next_state, vec_reward, done, _ = self.env.step(self.action)\\n reward, done = func_compile_exp_agent(self.action, vec_reward, done)\\n self.total_reward = reward + self.reward_decay * self.total_reward\\n info = self.agent.step(\\n state=self.state, action=self.action, reward=reward,\\n next_state=next_state, episode_done=done\\n )\\n self.record(info)\\n flag_success = True if done and reward > 0.0 else False\\n if self.savedir is not None:\\n self.steps_saver.save(self.episode_n, self.step_t, self.state, self.action,\\n vec_reward, reward, done, self.total_reward, flag_success)\\n self.state = next_state\\n if done:\\n self.step_t = 0\\n return done\",\n \"def _reward(self, action):\\n raise NotImplementedError\",\n \"def step(self, state, reward, training=True):\\n last_state, last_action = self.last_state, self.last_action\\n last_reward = reward\\n state = state\\n \\n action = self.policy(state, training)\\n\\n if training:\\n self.steps += 1\\n print(\\\"## step:\\\",self.steps)\\n\\n if last_state is not None:\\n experience = {\\n \\\"state\\\": last_state,\\n \\\"action\\\": last_action,\\n \\\"reward\\\": last_reward,\\n \\\"next_state\\\": state\\n }\\n\\n self.memory.add(experience)\\n #print(\\\"**memory size:\\\",self.memory.__len__())\\n #else:\\n #print(\\\"&& last_state\\\",last_state)\\n\\n if self.steps > self.replay_start_size: #para acumular cierta cantidad de experiences antes de comenzar el entrenamiento\\n self.train_network()\\n\\n if self.steps % self.target_update_freq == 0: #el clon de la red se realiza cada cierta cant de steps\\n self.update_target_network()\\n\\n self.last_state = state\\n self.last_action = action\\n\\n return action\",\n \"def step(self, action):\\n self._robot.send_command(action)\\n\\n obs = self.get_observation()\\n\\n reward = self.reward(obs.achieved_goal, self.goal)\\n done = self.done(obs.achieved_goal, self.goal)\\n next_observation = obs.observation\\n return Step(observation=next_observation, reward=reward, done=done)\",\n \"def step(self, action: CARLAAction, *args: Any, **kwargs: Any) -> Transition:\\n observation, reward, done, info = self.env.step(action)\\n if observation[\\\"lane_invasion\\\"] > 0:\\n logging.debug(\\\"A lane was invaded\\\")\\n done = True\\n reward = -1.0\\n return observation, reward, done, info\",\n \"def perform_action(self, action):\\r\\n t_list = self.get_action_outcomes(self.current_state, action)\\r\\n new_state = t_list[np.argmax(np.random.multinomial(1, [t[0] for t in t_list]))][1]\\r\\n # print(len(self.trajectory), ':', self.current_state, '--', action ,'-->', new_state)\\r\\n self.current_state = new_state\\r\\n self.trajectory.append(new_state)\\r\\n return tuple(self.current_state) == tuple(self.end_state)\",\n \"def step(self, action):\\n # Action indicates the position of a datapoint in self.indeces_unknown \\n # that we want to sample in unknown_data\\n # The index in train_data should be retrieved \\n selection_absolute = self.indeces_unknown[action]\\n # Label a datapoint: add its index to known samples and removes from unknown\\n self.indeces_known = np.concatenate(([self.indeces_known, np.array([selection_absolute])]))\\n self.indeces_unknown = np.delete(self.indeces_unknown, action) \\n # Train a model with new labeled data\\n known_data = self.dataset.train_data[self.indeces_known,:]\\n known_labels = self.dataset.train_labels[self.indeces_known]\\n known_labels = np.ravel(known_labels)\\n self.model.fit(known_data, known_labels)\\n # Get a new state \\n classifier_state, next_action_state = self._get_state() \\n # Update the number of available actions\\n self.n_actions = np.size(self.indeces_unknown)\\n # Compute the quality of the current classifier\\n test_prediction = self.model.predict(self.dataset.test_data)\\n new_score = self.quality_method(self.dataset.test_labels, test_prediction)\\n self.episode_qualities.append(new_score)\\n # Compute the reward\\n reward = self._compute_reward()\\n # Check if this episode terminated\\n done = self._compute_is_terminal() \\n return classifier_state, next_action_state, reward, done\",\n \"def update(self, state, action, nextState, reward):\\n util.raiseNotDefined()\",\n \"def take_action(self, state):\\n action = super(SarsaAgent, self).take_action(state)\\n if self.learning:\\n self.update_q_values(state, self.q_value((state, action)))\\n self.prev_state = state\\n self.prev_action = action\\n self.prev_q_val = self.q_values[self.represent_state(self.prev_state), self.prev_action]\\n self.log(\\\"size of q_values {0}\\\\nprev state {1}\\\\nprev action {2}\\\\nprev q-val {3}\\\"\\n .format(len(self.q_values), self.prev_state, self.prev_action, self.prev_q_val))\\n return action\",\n \"def step(self, action):\\n # Implement your step method here\\n # return (observation, reward, done, info)\\n self._state = self._state + action\\n # print('Step state:', self._state)\\n x, y = self._state\\n reward = - (x ** 2 + y ** 2) ** 0.5\\n done = abs(x) < 0.01 and abs(y) < 0.01\\n next_observation = np.copy(self._state)\\n return Step(observation=next_observation, reward=reward, done=done)\",\n \"def step(self, action):\\n # get the instruction indicated by the action\\n instr = self.instrs[action]\\n # extend the program\\n self.program.inst(instr)\\n # run and get some measured bitstrings\\n self.bitstrings, info = self._run_program(self.program)\\n # compute the avg score of the bitstrings\\n reward = self._prob_score(self.bitstrings)\\n self.running_episode_reward += reward\\n\\n info[\\\"instr\\\"] = instr\\n info[\\\"reward-nb\\\"] = reward\\n self.current_step += 1\\n\\n # are we done yet?\\n done = False\\n if self.current_step >= MAX_PROGRAM_LENGTH:\\n done = True\\n if reward >= self.reward_threshold:\\n reward += MAX_PROGRAM_LENGTH - self.current_step\\n done = True\\n\\n return self.observation, reward, done, info\",\n \"def step(self, action):\\n # print(action)\\n distances = self.agent.return_distances(self.agent.corners, self.agent.line_pos)\\n\\n left = distances[0]\\n right = distances[1]\\n self.agent.distances.append({\\n 'left': left,\\n 'right': right\\n })\\n reward = 0\\n if action == 1:\\n self.agent.angle -= 90\\n if self.agent.angle < 0:\\n self.agent.angle = 0\\n self.agent.direction_history.append('left')\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n if left > right:\\n reward += 5\\n else:\\n reward -= 5\\n\\n elif action == 2:\\n self.agent.angle += 90\\n if self.agent.angle >= 360:\\n self.agent.angle = 0\\n\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n self.agent.direction_history.append('right')\\n if left < right:\\n reward += 5\\n else:\\n reward -= 5\\n\\n elif action == 0:\\n self.agent.direction_history.append('forward')\\n if self.agent.angle >= 360: self.agent.angle == 0\\n if self.agent.angle == 0 or self.agent.angle == 360:\\n self.agent.agent_position['y'] -= 10\\n self.reset_raycasts(self.agent.angle)\\n elif self.agent.angle == 90: \\n self.agent.agent_position['x'] += 10\\n self.reset_raycasts(self.agent.angle)\\n elif self.agent.angle == 180: \\n self.agent.agent_position['y'] += 10\\n self.reset_raycasts(self.agent.angle)\\n elif self.agent.angle == 270:\\n self.agent.agent_position['x'] -= 10\\n self.reset_raycasts(self.agent.angle)\\n \\n if left + right >= 50:\\n reward += 5\\n\\n self.render()\\n\\n elif action == 3:\\n self.agent.direction_history.append('reverse')\\n if self.agent.angle == 0:\\n self.agent.agent_position['y'] += 10\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n elif self.agent.angle == 90: \\n self.agent.agent_position['x'] -= 10\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n elif self.agent.angle == 180: \\n self.agent.agent_position['y'] -= 10\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n elif self.agent.angle == 270:\\n self.agent.agent_position['x'] += 10\\n self.reset_raycasts(self.agent.angle)\\n self.render()\\n \\n if left + right <= 50:\\n reward += 5\\n\\n \\n else:\\n reward -= 5\\n\\n if \\\"forward\\\" not in self.agent.direction_history[len(self.agent.direction_history)-6:len(self.agent.direction_history)-1]:\\n reward -= 10\\n\\n \\n info = {}\\n if self.agent.check_collision():\\n reward -= 10\\n self.reset() \\n self.agent.rewards.append({\\n 'leftDistance': left,\\n 'rightDistance': right,\\n 'reward': reward,\\n })\\n self.render()\\n print(f\\\"REWARD: {reward}\\\")\\n # self.render()\\n # print(self.agent.direction_history[-1])\\n self.agent.rewards.append(reward)\\n return np.array([left, right]), reward, False, info\",\n \"def take_action(self, state):\\n if self.epsilon_decay is not None:\\n self.epsilon *= self.epsilon_decay\\n if random.random() < self.epsilon:\\n action = super(BaseQAgent, self).random_next_action(state)\\n self.log('exploration move: {0}'.format(str(action)))\\n else:\\n action = self.greedy_next_action(state)\\n self.log('exploitation move: {0}'.format(str(action)))\\n return action\",\n \"def step(self, action):\\n if self._backend_agent:\\n self._backend_agent._on_gym_step_begin(self, action)\\n\\n result = self.env.step(action)\\n (state, reward, done, info) = result\\n self.steps_done_in_episode += 1\\n self.steps_done_in_instance += 1\\n self.total.steps_done_inc()\\n if self.max_steps_per_episode and self.steps_done_in_episode >= self.max_steps_per_episode:\\n done = True\\n result = (state, reward, done, info)\\n if not self.is_episode_done and done:\\n self.is_episode_done = True\\n self.episodes_done += 1\\n self.total.episodes_done_inc()\\n\\n if self._backend_agent:\\n self._backend_agent._on_gym_step_end(self, action, result)\\n return result\",\n \"def step(self, action):\\n possible_states, probs = zip(*self.get_next_states(self._current_state, action).items())\\n next_state = weighted_choice(possible_states, p=probs)\\n reward = self.get_reward(self._current_state, action, next_state)\\n is_done = self.is_terminal(next_state)\\n self._current_state = next_state\\n return next_state, reward, is_done, {}\",\n \"def begin_episode(self, observation):\\n self._reset_state()\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_quantile_samples,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn,\\n self._tau,\\n self.optimizer)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def _act_impl(self, observation, reward,\\n done):\\n if done:\\n raise core.EpisodeDoneError(\\\"Called act on a done episode.\\\")\\n\\n if not self.observation_space.contains(observation):\\n raise core.InvalidObservationError(\\\"Invalid ovservation: %s\\\" %\\n observation)\\n if self.params.observation_adjustment_fn:\\n observation = self.params.observation_adjustment_fn(\\n self.rng, self.beliefs, observation)\\n\\n features = self.feature_selection_fn(observation)\\n self.beliefs = self._update_beliefs(features, self.beliefs)\\n action = self._allocate(self._n_resource, self.beliefs)\\n\\n if not self.action_space.contains(action):\\n raise gym.error.InvalidAction(\\\"Invalid action: %s\\\" % action)\\n\\n return action\",\n \"def step(self, action):\\n obs, r, done, info = self.env.step(action)\\n obs = self.get_observation(obs)\\n return obs, r, self.is_done(), info\",\n \"def step(self, action):\\n state, reward, done, debug_info = self.sample_transition(action)\\n self.set_state(state)\\n if \\\"next_state_heuristic\\\" in debug_info:\\n self._current_heuristic = debug_info[\\\"next_state_heuristic\\\"]\\n return state, reward, done, debug_info\",\n \"def step(self, action):\\n \\\"\\\"\\\" Action is a motion command \\\"\\\"\\\"\\n rich_obs, reward, done, info = super(ColoredEgoCostmapRandomAisleTurnEnv, self).step(action)\\n obs = self._extract_egocentric_observation(rich_obs)\\n return obs, reward, done, info\",\n \"def step(self, action: nx.Graph):\\n # Get the SMILES string associated with this action\\n self._state = action\\n if self.record_path:\\n self._path.append(self._state)\\n\\n # Update the action space\\n self.action_space.update_actions(self._state, self.observation_space)\\n self._counter += 1\\n\\n # Check if we have finished\\n # Out of steps or no more moves\\n done = len(self.action_space.get_possible_actions()) == 0\\n\\n # Compute the fingerprints for the state\\n return self._state, self.reward(), done, {}\",\n \"def _step(self, action):\\n \\n obs, reward, done, info = self.env.step(action)\\n\\n \\n advice=self.generateAdvice()[1]\\n\\n obs = {\\n \\\"image\\\": obs,\\n \\\"advice\\\": advice\\n }\\n\\n\\n \\n\\n\\n\\n return obs, reward, done, info\",\n \"def step(self,\\n action):\\n assert isinstance(action, Actions)\\n reward = 0.0\\n done = False\\n close = self.current_close()\\n # if buy a share the state change and you pay the commission (no price slippage)\\n if action == Actions.Buy and self.have_position:\\n self.have_position = True\\n self.open_price = close\\n reward -= self.commission_perc\\n # if close pay the commission if done = reset_on_close change the done flag(end) and give the reward\\n elif action == Actions.Close and self.have_position:\\n reward -= self.commission_perc\\n done |= self.reset_on_close\\n if self.reward_on_close:\\n reward += 100.0 * (close - self.open_price) / self.open_price\\n self.have_position = False\\n self.open_price = 0.0\\n # end the process: reward after the last bar movement\\n self._offset += 1\\n prevision_close = close\\n close = self.current_close()\\n done |= self._offset >= self._prices.close.shape[0] - 1\\n if self.have_position and not self.reward_on_close:\\n reward += 100.0 * (close - prevision_close) / prevision_close\\n return reward, done\",\n \"def learn(self, action, reward, is_terminal):\\n\\n\\t\\t# Add the experience to the replay memory\\n\\t\\tself.replay_memory.record(self.state_history[:,:,3], action, reward, is_terminal)\",\n \"def step(self, action: Action) -> Feedback: # type: ignore\\n self._action_counter += 1\\n step_id = self._action_counter\\n\\n self._encode_and_send_action(action, step_id)\\n\\n # Wait (blocking!) for the response envelope from the environment\\n in_envelope = self._queue.get(block=True, timeout=None) # type: Envelope\\n\\n msg = self._decode_percept(in_envelope, step_id)\\n\\n observation, reward, done, info = self._message_to_percept(msg)\\n\\n return observation, reward, done, info\",\n \"def step(self, state, action, reward, next_state, done):\\n self.episode_step += 1\\n # if early episode termination\\n if self.params.max_episode_steps and self.episode_step >= self.params.max_episode_steps:\\n done = True\\n # track progress\\n self.tracker.step(reward)\\n # memorize\\n self.memory.append((state, action, reward, next_state, 1.0 - done))\\n return done\",\n \"def execute_action(self, agent, action):\\n abstract\",\n \"def take_action(self, state):\",\n \"def step(self, action: Union[np.ndarray, torch.Tensor]):\\n if type(action) == torch.Tensor:\\n action = action.squeeze().numpy()\\n\\n if not type(action) is np.ndarray:\\n raise Exception(\\\"The action must be a Numpy array but is of type %s (value = %s)\\\" % (type(action), action))\\n\\n if self.increment_actions and not self.action_space.contains(action):\\n action = action.clip(self.action_space.low, self.action_space.high)\\n\\n # Additionally, we must make sure the value will stay in the range\\n # min <= x + action <= max\\n if self.increment_actions:\\n current_values = self.x[np.array([0, 1, 3, 5])]\\n new_flow_values = current_values + action\\n else:\\n new_flow_values = action\\n\\n new_flow_values = np.clip(new_flow_values, self.flows_lower_bounds, self.flows_upper_bounds)\\n self.update_all_flows(new_flow_values)\\n\\n if any([x < 0 for x in self.x]):\\n pass\\n # TODO: should I clip the actions to ensure the flows are always positive?\\n # raise Exception(f\\\"Negative flows! x = {[round(x, 4) for x in self.x]}\\\")\\n\\n self.update_fitness()\\n\\n self.step_number += 1\\n\\n # reward = self.fitness - self.previous_fitness\\n reward = self.fitness\\n observation = self.get_observation()\\n\\n done = (self.step_number == self.total_number_of_episodes)\\n info = {}\\n return observation, reward, done, info\",\n \"def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool, dict]:\\n next_state, reward, done, info = self.env.step(action)\\n return next_state, reward, done, info\",\n \"def step(self, action: CARLAAction, *args: Any, **kwargs: Any) -> Transition:\\n observation, reward, done, info = self.env.step(action)\\n if observation[\\\"collision\\\"] > 0:\\n logging.debug(\\\"A collision occured\\\")\\n done = True\\n reward = -1.0\\n return observation, reward, done, info\",\n \"def step(self, action):\\n self.move_step(action) # Move.\\n r, d = self.check_goal() # Check the reward and done state, and create\\n # new environment.\\n s_new= self.render_env() # Render the new environment.\\n return s_new, r, d\",\n \"def observe_reward(self,state,action,statePrime,reward):\\n pass\",\n \"def begin_episode(self, observation):\\n self._reset_state()\\n self._record_observation(observation)\\n\\n if not self.eval_mode:\\n self._train_step()\\n\\n self._rng, self.action = select_action(self.network_def,\\n self.online_params,\\n self.state,\\n self._rng,\\n self.num_actions,\\n self.eval_mode,\\n self.epsilon_eval,\\n self.epsilon_train,\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_fn)\\n self.action = onp.asarray(self.action)\\n return self.action\",\n \"def step(self, action):\\n observation, reward, done, _ = self.env.step(action)\\n return np.array(observation), reward, done\",\n \"def env_step(self, action):\\n random_prob = np.random.uniform(0, 1)\\n if random_prob <= self.stochasticity: # Ignore agent's action and move to one of the 8 neighbours\\n # Determine how the agent moves (from -1 to 1 in each direction, but not both 0)\\n random_nn = np.random.randint(0, len(self.nn))\\n random_y = self.nn[random_nn, 0]\\n random_x = self.nn[random_nn, 1]\\n\\n # Move to one of the nearest neighbours\\n self.current_state[0] += random_y\\n self.current_state[1] += random_x\\n else: # Perform agent's action\\n # Update current stated based on the action the agent took\\n curr_x = self.current_state[1]\\n self.current_state[0] += self.actions[action][0] + self.wind[curr_x]\\n self.current_state[1] += self.actions[action][1]\\n\\n # Check if the agent fell out of the boundaries of the grid world\\n y_coord = self.current_state[0]\\n x_coord = self.current_state[1]\\n\\n if y_coord >= self.num_rows: # Agent went too far up\\n self.current_state[0] = self.num_rows - 1\\n elif y_coord < 0: # Agent went too far down\\n self.current_state[0] = 0\\n\\n if x_coord >= self.num_cols: # Agent went too far right\\n self.current_state[1] = self.num_cols - 1\\n elif x_coord < 0: # Agent went too far left\\n self.current_state[1] = 0\\n\\n is_terminal = False\\n reward = -1.0\\n\\n # Check if the agent reached a terminal state\\n if self.current_state == self.terminal_state:\\n is_terminal = True\\n reward = 0.0\\n\\n return reward, self.current_state, is_terminal\",\n \"def step(self, state, action, reward, done):\\n\\n self.memory.add(state, action, reward, done)\\n if done and self.n_tau % self.update_freq == 0:\\n self.n_tau += 1\\n return self.update()\\n return None\",\n \"def step(self, action):\\n\\n previous_state = self.state\\n self._make_action(action) \\n self.step_simulation()\\n self._make_observation() # Update state\\n \\n ###################\\n ### Reward function\\n\\n body_position = self.agent.get_position('Torso') # x,y,z coordinates of the agent\\n r_foot_collision, l_foot_collision = self.state[-2:] # Feet collision indicators [0/1]\\n roll, pitch = self.state[12:14] # Roll and pitch of the agent's convex hull\\n\\n # Staying upright\\n posture = 0\\n if abs(roll) > abs(previous_state[12]):\\n posture -= .1\\n else:\\n posture += .125\\n\\n if abs(pitch) > abs(previous_state[13]):\\n posture -= .1\\n else:\\n posture += .125\\n \\n hull = 0\\n if abs(roll) < .125 and abs(pitch) < .125:\\n posture += .1\\n # Lifting feet while upright\\n # collisions = np.count_nonzero(self.state[14::])\\n # posture = (2 - collisions) * .\\n\\n # Hull location\\n progress = body_position[0] - self.previous_body_position\\n if progress > 0: \\n hull = 0.1 + progress * 40\\n if hull > .5: hull = .5\\n else:\\n hull = -0.1 + progress * 40\\n if hull < -.5: hull = -.5\\n self.previous_body_position = body_position[0]\\n\\n \\\"\\\"\\\"\\n STATE SPACE:\\n include:\\n 1. Angular velocity of the torso (also normal velocity?) both can be obtained through gyro and accelerometer\\n 2. Change to orientation of the torso instead of convex hull\\n 3. \\n \\\"\\\"\\\"\\n\\n # Feet distance\\n # Use multiplicative reward?\\n # Change in feet position along the X axis\\n # pos_lfoot = self.agent.get_position('LFoot')[0]\\n # pos_rfoot = self.agent.get_position('RFoot')[0]\\n # distance_lfoot = (pos_lfoot - self.previous_feet_position[0])\\n # distance_rfoot = (pos_rfoot - self.previous_feet_position[1])\\n # if self.previous_feet_position[0] != 0:\\n # feet_distance = (distance_lfoot + distance_rfoot) * 100\\n # else:\\n # feet_distance = 0\\n\\n # self.previous_feet_position = [pos_lfoot, pos_rfoot]\\n\\n base = 0.05\\n reward = base + posture + hull\\n # print('hull: {}'.format(hull))\\n # print('posture: {}'.cformat(posture))\\n\\n # End condition\\n if (abs(roll) > self.fall_threshold or abs(pitch) > self.fall_threshold):\\n reward -= 2\\n self.done = True \\n\\n # print('Posture: {} \\\\n Hull: {}'.format(posture, hull))\\n # print('Total reward: {}'.format(reward))\\n\\n return self.state, reward, self.done, {}\",\n \"def step(self, state, action, reward, next_state, done):\\n # print(\\\"agent.step() - state: {}, action: {}, reward: {}, next_state: {}, done: {}\\\".format(state, action, reward, next_state, done))\\n current_reward_val = self.Q[state][action]\\n next_step_greedy_action = np.argmax(self.Q[next_state])\\n next_step_reward_val = self.Q[next_state][next_step_greedy_action]\\n gamma = 0.75 # toto - paramterize\\n self.Q[state][action] = self.Q[state][action] + self.alpha * (\\n reward + gamma * next_step_reward_val - self.Q[state][action])\",\n \"def take_one_step(env, policy, state):\\n action = sample_action(policy, state)\\n new_state, reward, done, _ = env.step(action)\\n if (done == True and reward > 0):\\n reward = 10.0\\n if new_state in hole_states:\\n reward = -10.0\\n elif not done:\\n reward = -1.0\\n # print(\\\"state {0}, new_state {1}, action {2}, reward {3}, done {4}\\\".format(state, new_state, action, reward, done))\\n return action, reward, new_state, done\",\n \"def step(self, action): # action is nb-cops-sized or 1-sized\\n reward = 0\\n done = False\\n\\n action = np.array(action)\\n\\n def old_pos(set=None):\\n if set is None:\\n return self.cops_pos if self.is_cops_turn else self.rob_pos\\n else:\\n if self.is_cops_turn:\\n self.cops_pos = action\\n else:\\n self.rob_pos = action\\n\\n invalids = []\\n\\n if self.is_first_turn:\\n self.graph.set_cr(action, self.is_cops_turn)\\n else:\\n edges = self.graph.get_rep()[old_pos(), action]\\n invalids = edges != 1\\n invalids[action == old_pos()] = False\\n invalids = np.where(invalids == True)[0]\\n if invalids.shape[0] != 0:\\n action[invalids] = old_pos()[invalids] # correct action\\n self.graph.set_cr(action, self.is_cops_turn)\\n\\n old_pos(action)\\n if not self.is_cops_turn and self.is_first_turn:\\n self.is_first_turn = False\\n self.is_cops_turn = not self.is_cops_turn\\n if self.rob_pos is not None and self.rob_pos[0] in self.cops_pos:\\n print(\\\"Cops won\\\")\\n done = True\\n reward += (1 if self.is_cops_turn else -1) * REWARD_END_WL\\n\\n reward += (-1 if self.is_cops_turn else +1) * REWARD_STEP_WL\\n reward -= len(invalids) * REWARD_INVALID\\n\\n observation = self.graph.get_attr()\\n\\n if self.is_cops_turn:\\n self.cops_rew += reward\\n else:\\n self.rob_rew += reward\\n\\n if not done:\\n if self.is_cops_turn and self.cops is not None:\\n observation, _, done, _ = self.step(self.cops.act(observation))\\n elif not self.is_cops_turn and self.robber is not None:\\n observation, _, done, _ = self.step(self.robber.act(observation))\\n return observation, reward, done, {}\",\n \"def rollout(agent, env):\\n # run until episode ends\\n episode_reward = 0\\n done = False\\n obs = env.reset()\\n while not done:\\n action = agent.compute_action(obs)\\n obs, reward, done, info = env.step(action)\\n episode_reward += reward\\n \\n return episode_reward\",\n \"def env_step(self, action):\\n if action == 0: # Hit\\n\\n new_state = deepcopy(self.current_state)\\n reward = 0\\n terminal = False\\n \\n new_card = min(self.random.randint(1,14), 10)\\n # print('new card:', new_card)\\n \\n if new_card == 1:\\n self.player_ace_count += 1\\n new_state['player_sum'] = self.current_state['player_sum'] + 11 \\n else:\\n new_state['player_sum'] = self.current_state['player_sum'] + new_card\\n\\n while new_state['player_sum'] > 21 and self.player_ace_count > 0:\\n self.player_ace_count -= 1\\n new_state['player_sum'] -= 10\\n\\n new_state['usable_ace'] = int(self.player_ace_count > 0)\\n\\n if new_state['player_sum'] > 21: # Goes bust\\n reward = -1\\n terminal = True\\n\\n elif action == 1: # Stick\\n\\n new_state = deepcopy(self.current_state)\\n terminal = True\\n\\n if self.current_state['dealer_card'] == 1:\\n dealer_ace = 1\\n dealer_sum = 11\\n else:\\n dealer_ace = 0\\n dealer_sum = self.current_state['dealer_card']\\n\\n first_two_cards = True\\n while dealer_sum < self.dealer_sticks or first_two_cards:\\n first_two_cards = False\\n # new_card = self.random.choice(range(1,11), p=self.card_probs)\\n new_card = min(self.random.randint(1,14), 10)\\n if new_card == 1:\\n dealer_sum += 11\\n dealer_ace += 1\\n else:\\n dealer_sum += new_card\\n\\n while dealer_sum > 21 and dealer_ace > 0:\\n dealer_sum -= 10\\n dealer_ace -= 1\\n dealer_ace = int(dealer_ace > 0)\\n # print('dealer:', new_card)\\n\\n # print('dealer sum:', dealer_sum)\\n if dealer_sum > 21:\\n reward = 1\\n else:\\n if new_state['player_sum'] > dealer_sum:\\n reward = 1\\n elif new_state['player_sum'] < dealer_sum:\\n reward = -1\\n else:\\n reward = 0\\n # reward = int(new_state['player_sum'] > dealer_sum) - int(new_state['player_sum'] < dealer_sum)\\n\\n else:\\n raise Exception(\\\"Invalid action.\\\")\\n\\n self.current_state = new_state\\n\\n self.reward_obs_term = (reward, self.observation(self.current_state), terminal)\\n\\n return self.reward_obs_term\",\n \"def reward(self, observation, action, reward):\\r\\n\\r\\n if reward > 0 :\\r\\n print(\\\"win\\\") \\r\\n self.done=1 \\r\\n self.done_MC=1\\r\\n\\r\\n else:\\r\\n self.done=0\\r\\n\\r\\n self.current_state=observation\\r\\n self.current_action=action\\r\\n self.current_reward=reward\\r\\n self.reward_list.append(reward.item())\\r\\n \\r\\n self.log_probs.append(self.log_prob)\\r\\n self.values.append(self.value)\\r\\n self.rewards.append(self.torch.tensor([self.current_reward], dtype=self.torch.float, device=self.device))\\r\\n self.masks.append(self.torch.tensor([1-self.done], dtype=self.torch.float, device=self.device))\",\n \"def state_update(self, last_action, action):\\n s_t = self._get_state(last_action)\\n r= self._get_reward(last_action,action)\\n self._move_user()\\n s_t1 = self._get_state(action)\\n self.reward = r\\n self.s_t = s_t\\n self.s_t1 = s_t1\",\n \"def make_step(self, action_index):\\n # Randomly sample action_index if world is stochastic\\n if np.random.uniform(0, 1) < self.random_move_probability:\\n action_indices = np.arange(self.num_actions, dtype=int)\\n action_indices = np.delete(action_indices, action_index)\\n action_index = np.random.choice(action_indices, 1)[0]\\n\\n action = self.actions[action_index]\\n\\n # Determine new position and check whether the agent hits a wall.\\n old_position = self.agent_position\\n new_position = self.agent_position\\n if action == \\\"UP\\\":\\n candidate_position = old_position + self.num_cols\\n if candidate_position < self.num_fields:\\n new_position = candidate_position\\n elif action == \\\"RIGHT\\\":\\n candidate_position = old_position + 1\\n if candidate_position % self.num_cols > 0: # The %-operator denotes \\\"modulo\\\"-division.\\n new_position = candidate_position\\n elif action == \\\"DOWN\\\":\\n candidate_position = old_position - self.num_cols\\n if candidate_position >= 0:\\n new_position = candidate_position\\n elif action == \\\"LEFT\\\": # \\\"LEFT\\\"\\n candidate_position = old_position - 1\\n if candidate_position % self.num_cols < self.num_cols - 1:\\n new_position = candidate_position\\n else:\\n raise ValueError('Action was mis-specified!')\\n\\n # Update the environment state\\n self.agent_position = new_position\\n \\n # Calculate reward\\n reward = self.rewards[self.agent_position]\\n reward -= 1\\n return reward, new_position\",\n \"def step(self, action, state):\\r\\n done = False\\r\\n next_state = json.loads(state)\\r\\n state_shift = self.action_map[action]\\r\\n\\r\\n next_state = np.array(next_state) + np.array(state_shift)\\r\\n next_state = next_state.tolist()\\r\\n\\r\\n reward = self.reward[next_state[0], next_state[1]]\\r\\n self.reward[next_state[0], next_state[1]] = 0\\r\\n\\r\\n next_state = json.dumps(next_state)\\r\\n\\r\\n if reward < 0 or reward == 4:\\r\\n done = True\\r\\n\\r\\n return next_state, reward, done\",\n \"def doAction(self, gameState, action):\\n self.lastState = gameState\\n self.lastAction = action\",\n \"def step(self, state, action):\\n reward = 0.0\\n new_card = self._generate_random_card()\\n if action == ACTION_HIT:\\n new_player_value = state.player_sum + new_card.get_game_value()\\n if new_player_value < 1 or new_player_value > 21:\\n return TERMINAL_STATE, -1\\n return State(state.dealer_card, new_player_value), 0.0\\n current_dealer_value = state.dealer_card.get_game_value()\\n # STICK\\n current_dealer_value += new_card.get_game_value()\\n while current_dealer_value < 17:\\n if current_dealer_value < 1:\\n return TERMINAL_STATE, 1\\n drawn_card = self._generate_random_card()\\n current_dealer_value += drawn_card.get_game_value()\\n if current_dealer_value > 21:\\n return TERMINAL_STATE, 1\\n if state.player_sum > current_dealer_value:\\n return TERMINAL_STATE, 1\\n if state.player_sum == current_dealer_value:\\n return TERMINAL_STATE, 0\\n return TERMINAL_STATE, -1\",\n \"def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\\n next_state, reward, done, _ = self.env.step(action, resize=RESIZE, size = RESIZE_SIZE)\\n\\n if not self.is_test:\\n self.transition += [reward, next_state, done]\\n \\n # N-step transition\\n if self.use_n_step:\\n one_step_transition = self.memory_n.store(*self.transition)\\n # 1-step transition\\n else:\\n one_step_transition = self.transition\\n\\n # add a single step transition\\n if one_step_transition:\\n self.memory.store(*one_step_transition)\\n \\n return next_state, reward, done\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77299076","0.7505443","0.7489188","0.7451101","0.7446967","0.7423517","0.7353827","0.73296374","0.732902","0.7246652","0.71973366","0.71956855","0.7170794","0.7170417","0.7162732","0.71451074","0.7140692","0.71406287","0.71278226","0.71219754","0.71109253","0.7090877","0.70869845","0.7085137","0.7063677","0.7054138","0.70449317","0.70366824","0.7033589","0.7025373","0.7006869","0.7001018","0.6990449","0.69802225","0.69578475","0.6956955","0.6933207","0.69265133","0.6925393","0.6921236","0.69206285","0.6916522","0.6915627","0.69097584","0.6894213","0.68863004","0.6885706","0.687405","0.6873803","0.6870774","0.6870652","0.6862348","0.68557715","0.68502146","0.684196","0.683575","0.6832626","0.68091553","0.6806329","0.68055475","0.67869866","0.6778148","0.67703205","0.6751887","0.6743675","0.6734342","0.6728205","0.6722045","0.67154217","0.67139834","0.670993","0.6702935","0.6696547","0.6694851","0.66893286","0.6681997","0.66788584","0.66726816","0.6658906","0.66587865","0.6657755","0.6654369","0.665341","0.66513664","0.66490126","0.6646968","0.66443723","0.6643454","0.6641641","0.6638604","0.6631035","0.6608841","0.6605315","0.6604984","0.66026354","0.6594905","0.6593819","0.6593525","0.65921265","0.6588481","0.6587842"],"string":"[\n \"0.77299076\",\n \"0.7505443\",\n \"0.7489188\",\n \"0.7451101\",\n \"0.7446967\",\n \"0.7423517\",\n \"0.7353827\",\n \"0.73296374\",\n \"0.732902\",\n \"0.7246652\",\n \"0.71973366\",\n \"0.71956855\",\n \"0.7170794\",\n \"0.7170417\",\n \"0.7162732\",\n \"0.71451074\",\n \"0.7140692\",\n \"0.71406287\",\n \"0.71278226\",\n \"0.71219754\",\n \"0.71109253\",\n \"0.7090877\",\n \"0.70869845\",\n \"0.7085137\",\n \"0.7063677\",\n \"0.7054138\",\n \"0.70449317\",\n \"0.70366824\",\n \"0.7033589\",\n \"0.7025373\",\n \"0.7006869\",\n \"0.7001018\",\n \"0.6990449\",\n \"0.69802225\",\n \"0.69578475\",\n \"0.6956955\",\n \"0.6933207\",\n \"0.69265133\",\n \"0.6925393\",\n \"0.6921236\",\n \"0.69206285\",\n \"0.6916522\",\n \"0.6915627\",\n \"0.69097584\",\n \"0.6894213\",\n \"0.68863004\",\n \"0.6885706\",\n \"0.687405\",\n \"0.6873803\",\n \"0.6870774\",\n \"0.6870652\",\n \"0.6862348\",\n \"0.68557715\",\n \"0.68502146\",\n \"0.684196\",\n \"0.683575\",\n \"0.6832626\",\n \"0.68091553\",\n \"0.6806329\",\n \"0.68055475\",\n \"0.67869866\",\n \"0.6778148\",\n \"0.67703205\",\n \"0.6751887\",\n \"0.6743675\",\n \"0.6734342\",\n \"0.6728205\",\n \"0.6722045\",\n \"0.67154217\",\n \"0.67139834\",\n \"0.670993\",\n \"0.6702935\",\n \"0.6696547\",\n \"0.6694851\",\n \"0.66893286\",\n \"0.6681997\",\n \"0.66788584\",\n \"0.66726816\",\n \"0.6658906\",\n \"0.66587865\",\n \"0.6657755\",\n \"0.6654369\",\n \"0.665341\",\n \"0.66513664\",\n \"0.66490126\",\n \"0.6646968\",\n \"0.66443723\",\n \"0.6643454\",\n \"0.6641641\",\n \"0.6638604\",\n \"0.6631035\",\n \"0.6608841\",\n \"0.6605315\",\n \"0.6604984\",\n \"0.66026354\",\n \"0.6594905\",\n \"0.6593819\",\n \"0.6593525\",\n \"0.65921265\",\n \"0.6588481\",\n \"0.6587842\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":580,"cells":{"query":{"kind":"string","value":"Reset the state of the evironment for a new episode `setup` is used to let the reset function know when we're calling it from `setup`. If we don't, the 'random' init scheme should reset to the randomly choosen position instead of picking a new random one."},"document":{"kind":"string","value":"def reset(self, setup=False):\n self._done = False\n self._nbSteps = 0\n\n x = None\n if (self.startPosX == 'random' and setup) or (\n self.startPosX == 'episodeRandom'):\n x = random.randint(0, self._width - 1)\n elif (self.startPosX == 'random' and not setup):\n x = self._initState[0]\n elif self.startPosX == 'center':\n x = self._width - 1\n else:\n x = int(self.startPosX)\n\n y = None\n if (self.startPosX == 'random' and setup) or (\n self.startPosX == 'episodeRandom'):\n y = random.randint(0, self._height - 1)\n elif (self.startPosY == 'random' and not setup):\n y = self._initState[1]\n elif self.startPosX == 'center':\n y = self._height - 1\n else:\n y = int(self.startPosX)\n\n self._currentPos = (x, y)\n self._trajectory = [(x, y)]\n\n return (x, y)"},"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 reset(self):\n\n # initialize gym env variables\n self.finish = False\n self.curr_step = -1\n self.curr_episode += 1\n\n # initialize target position\n self.target = np.random.uniform(-10.0,10.0,size=(2))\n\n # initialize sheep positions\n if self.fixed_reset:\n init_sheep_pose = np.array([75.0, 75.0])\n self.sheep_poses = (np.random.uniform(-50.0, 50.0, \n size=(self.num_sheep,2))) + init_sheep_pose[None,:]\n else:\n init_sheep_pose = np.random.uniform(-self.init_sheep_root, \n self.init_sheep_root, size=(2))\n self.sheep_poses = (np.random.uniform(-self.init_sheep_range, \n self.init_sheep_range, size=(self.num_sheep,2))) \\\n + init_sheep_pose[None,:]\n self.sheep_com = self.sheep_poses.mean(axis=0)\n\n # get the farthest sheep and radius of the sheep\n dist_to_com = np.linalg.norm((self.sheep_poses - self.sheep_com[None,:]), axis=1)\n self.farthest_sheep = self.sheep_poses[np.argmax(dist_to_com),:]\n self.radius_sheep = np.array([np.max(dist_to_com)])\n\n # update distance to target\n self.target_distance = np.linalg.norm(self.target - self.sheep_com)\n\n # initialize values for reward estimation\n self.init_radius_sheep = self.radius_sheep\n self.init_target_distance = self.target_distance\n\n # initialize dog position\n if self.fixed_reset:\n init_dog_pose = np.array([0.0,75.0])\n else:\n init_theta = np.random.uniform(-np.pi,np.pi)\n init_dog_pose = init_sheep_pose + self.init_dog_distance*np.array([np.cos(init_theta), \n np.sin(init_theta)])\n self.dog_pose = init_dog_pose\n\n # initialize inertia\n self.inertia = np.ones((self.num_sheep, 2))\n\n # initialize episode reward and length\n self.episode_reward = 0\n self.episode_length = 0\n\n # get the state, reward, finish, info\n state = self._get_state()\n \n return state","def _hard_reset(self):\n self._reset_specific_envs(np.ones_like(self.episodes_done))\n self._update_other_info()","def _reset(self):\n np.random.shuffle(self.id)\n self.episode_step = 0 # Reset episode step counter at the end of every episode\n self._state = self.X_train[self.id[self.episode_step]]\n self._episode_ended = False\n\n return ts.restart(self._state)","def reset(self):\n self.tracker.reset()\n self.episode += 1\n self.episode_step = 0","def reset(self, **kwargs):\n if self._backend_agent:\n self._backend_agent._on_gym_reset_begin(self, **kwargs)\n\n result = self.env.reset(**kwargs)\n if self.steps_done_in_episode > 0 and not self.is_episode_done:\n self.episodes_done += 1\n self.total.episodes_done_inc()\n self.is_episode_done = False\n self.steps_done_in_episode = 0\n\n if self._backend_agent:\n self._backend_agent._on_gym_reset_end(self, result, **kwargs)\n return result","def reset(self):\n \n if self._config.fix_seed:\n self._init_seed = (self._init_seed + 1) % 2**32 # set_seed requires int\n self.game.set_seed(self._init_seed)\n\n super(ShootEnv, self).reset()\n\n self._killcount = 0.0\n self._ammo = self.game.get_game_variable(GameVariable.AMMO2)\n self._health = self.game.get_game_variable(GameVariable.HEALTH)\n\n return self._get_observation()","def reset(self):\n\n self.curr_episode += 1\n self.curr_step = 0\n\n self.action_episode_memory.append([])\n self.rewards.append([])\n\n self.is_finalized = False\n init_state, init_reward = self._take_action(5 * np.random.randn(self.act_dimension))\n self.initial_conditions.append(init_state)\n return init_state","def specific_reset(self) -> None:\n self.agent.specific_reset() # reset joints\n new_pos = self.agent.init_xyz\n new_pos[:2] = np.random.uniform(-0.01, 0.01, 2)\n self.agent.set_position(new_pos)\n self.old_potential = self.calculate_task_potential()","def reset(self):\n while not self._check_episode_start_condition():\n self._simulate()\n self.state, _ = self._extract_state()\n return self.state","def reset(\n self,\n *,\n seed: int | None = None,\n options: dict[str, Any] | None = None,\n ) -> tuple[np.ndarray, AtariEnvStepMetadata]:\n super().reset(seed=seed, options=options)\n del options\n # Gymnasium's new seeding API seeds on reset.\n # This will cause the console to be recreated\n # and loose all previous state, e.g., statistics, etc.\n seeded_with = None\n if seed is not None:\n seeded_with = self.seed(seed)\n\n self.ale.reset_game()\n obs = self._get_obs()\n\n info = self._get_info()\n if seeded_with is not None:\n info[\"seeds\"] = seeded_with\n return obs, info","def _soft_reset(self):\n self._reset_specific_envs(self.episodes_done)\n self._update_other_info()","def _reset_seeds(self) -> None:\n self._seeds = [None for _ in range(self.num_envs)]","def reset_from_state(self, state):\n\n # initialize gym env variables\n self.finish = False\n self.curr_step = -1\n self.curr_episode += 1\n\n # initialize target position\n self.target = state[4:6]\n\n # initialize sheep com\n self.sheep_com = state[0:2]\n\n # get the farthest sheep and radius of the sheep\n self.farthest_sheep = state[2:4]\n self.radius_sheep = np.array([state[8]])\n\n # update distance to target\n self.target_distance = np.array([state[9]])\n\n # initialize sheep position\n self.sheep_poses = (np.random.uniform(-0.75*self.radius_sheep, \n 0.75*self.radius_sheep, size=(self.num_sheep,2))) \\\n + self.sheep_com[None,:]\n rnd_ind = np.random.choice(self.num_sheep)\n self.sheep_poses[rnd_ind,:] = state[2:4]\n\n # initialize values for reward estimation\n self.init_radius_sheep = self.radius_sheep\n self.init_target_distance = self.target_distance\n\n # initialize dog position\n init_dog_pose = state[6:8]\n self.dog_pose = init_dog_pose\n\n # initialize inertia\n self.inertia = np.ones((self.num_sheep, 2))\n\n # initialize episode reward and length\n self.episode_reward = 0\n self.episode_length = 0\n\n # get the state, reward, finish, info\n state = self._get_state()\n \n return state","def _reset(self):\r\n \r\n airgym.reset()\r\n self.stepN = 0\r\n self.episodeN += 1\r\n \r\n self.allLogs = { 'reward': [0] }\r\n self.allLogs['distance'] = [221]\r\n self.allLogs['action'] = [1]\r\n \r\n print(\"\")\r\n \r\n #self.sensors = airgym.getSensorStates()\r\n \r\n # Initial state\r\n self.state = airgym.getScreenDepthVis()\r\n \r\n \r\n return self.state","def reset(self):\r\n \r\n self.done = False\r\n self.t = 0\r\n self.episode = random.choice(episodes)\r\n\r\n # initiate agent\r\n self.agent = self.create_agent(Agent)\r\n \r\n # initiate state at time zero\r\n self.state = (self.episode[self.t]['ST Relative Indicator'], \r\n self.episode[self.t]['ST Relative Indicator'], \r\n self.agent.stock,\r\n self.t)\r\n \r\n return self.state","def _reset(self): # We are using a virtual function defined in the gym infrastructure.\n self.gazebo.unpauseSim()\n \"\"\"\n why we need to unpauseSim because resetting controllers and for checking the sensors, we need the simulation\n to be running because otherwise we don't have any sensory data and we don't have access to the controller reset\n functions services they won't work and tell you to hit play. => it is very important.\n \"\"\"\n self.controllers_object.reset_controllers()\n self.check_all_sensors_ready()\n self.set_init_pose()\n #initialized robot\n self.gazebo.pauseSim()\n self.gazebo.resetSim()\n self.gazebo.unpauseSim()\n self.controllers_object.reset_controllers()\n self.check_all_sensors_ready()\n self.gazebo.pauseSim()\n self.init_env_variables()\n obs = self._get_obs()\n simplified_obs = self.convert_obs_to_state(obs)\n\n return simplified_obs","def resetEyes(self):\n\n\t\tself.leds.on(\"FaceLeds\")","def resetEyes(self):\n\n\t\tself.leds.on(\"FaceLeds\")","def reset(self):\n self.curr_episode += 1\n self.action_episode_memory.append([])\n self.is_game_done = False\n self.price = 1.00\n self.sendCmd(self.url,\"reset\")\n return self._get_state()","def env_init(self, env_info={}):\n self.dealer_sticks = env_info['dealer_sticks']\n self.random = np.random.RandomState(env_info['seed'])\n self.current_state = None","def _reset_(self):\n print(\"Resetting\")\n\n self._q_target_, x_target = self._pick_random_angles_()\n np.copyto(self._x_target_, x_target)\n if self._target_type == 'position':\n self._target_ = self._x_target_[self._end_effector_indices]\n elif self._target_type == 'angle':\n self._target_ = self._q_target_\n self._action_ = self._rand_obj_.uniform(self._action_low, self._action_high)\n self._cmd_prev_ = np.zeros(len(self._action_low)) # to be used with derivative control of velocity\n if self._reset_type != 'none':\n if self._reset_type == 'random':\n reset_angles, _ = self._pick_random_angles_()\n elif self._reset_type == 'zero':\n reset_angles = self._q_ref[self._joint_indices]\n self._reset_arm(reset_angles)\n\n rand_state_array_type, rand_state_array_size, rand_state_array = utils.get_random_state_array(\n self._rand_obj_.get_state()\n )\n np.copyto(self._shared_rstate_array_, np.frombuffer(rand_state_array, dtype=rand_state_array_type))\n\n print(\"Reset done\")","def reset(self):\n self.tracker.reset()\n self.total_max_q = 0.0\n self.episode_step = 0\n self.episode += 1","def reset(self, gui=False, test_ind=-1):\n # self.gui = gui\n # if gui:\n # # save episode to disk\n # if self._global_frames:\n # make_video_from_rgb_imgs(self._global_frames, self.output_path, f\"episode_global_{self.cur_episode}\")\n\n # for agent_id, frames in self._agent_frames.items():\n # if frames:\n # make_video_from_rgb_imgs(frames, self.output_path, f\"episode_{self.cur_episode}_{agent_id}\")\n\n # # clear frames of previous episode\n # self._global_frames = []\n # self._agent_frames = {agent_id: [] for agent_id in self.agent_tags}\n\n if (self.train_mode):\n seed = self.seed\n elif (test_ind < 0):\n seed = self.seed-1\n else:\n seed = self.test_seeds[test_ind]\n np.random.seed(seed)\n self.seed += 1\n\n self.cur_episode += 1\n self.t = 0 # step counter for each episode\n self.rewards = [0] # to keep track of global rewards\n obs = self.env.reset(done_only=False).cpu().numpy()\n\n # if self.gui:\n # self._global_frames.append(self.env.map_to_colors().astype(np.uint8))\n\n # for agent_id, agent_obs in obs.items():\n # self._agent_frames[agent_id].append(agent_obs.astype(np.uint8))\n\n # obs = list(obs.values())\n obs = self._get_state(obs) # new\n\n return obs","def reset(self):\n # Sample random state from initial state distribution\n self._cur_state = self._sample_state(self._mdp.I)\n self._prev_state = self._cur_state","def reset(self):\n self.observation = None\n self.episode_done = True","def _restart_environment_episode(self, force_environment_reset=False) -> None:\n raise NotImplementedError(\"\")","def reset(self):\n\n # Ending variables\n self.time_idle = 0\n self.time_episode = 0\n self.done_time_idle = False\n self.done_falling = False\n self.done_time_episode = False\n\n # hero variables\n self.last_location = None\n self.last_velocity = 0\n\n # Sensor stack\n self.prev_image_0 = None\n self.prev_image_1 = None\n self.prev_image_2 = None\n\n self.last_heading_deviation = 0","def specific_reset(self) -> None:\n self.old_velocity = 0.\n self.agent.specific_reset()\n max_dist_to_origin = 4.\n min_dist_to_origin = 2\n\n agent_pos = np.random.uniform(-max_dist_to_origin, max_dist_to_origin, 2)\n positioning_done = False\n while not positioning_done:\n agent_pos = np.random.uniform(-max_dist_to_origin,\n max_dist_to_origin, 2)\n if min_dist_to_origin <= np.linalg.norm(agent_pos) <= max_dist_to_origin:\n positioning_done = True\n\n # adjust the height of agent\n agent_pos = np.concatenate((agent_pos[:2], [self.agent.init_xyz[2]]))\n self.agent.set_position(agent_pos)\n\n # set agent orientation in forward run direction\n y = angle2pos(self.agent.get_position(), np.zeros(3)) + np.pi / 2\n y += self.agent.init_rpy[2]\n quaternion = self.bc.getQuaternionFromEuler([0, 0, y])\n self.agent.set_orientation(quaternion)","def seed_random():\n random.seed(0)","def reset(self):\r\n random.seed(1) # Set determanistic play\r\n if self.board is None:\r\n self.setup_board()\r\n self.board.reset()","def reset(self):\n self._reset_next_step = False\n self.step_count = 0\n \n self._state = self.state_initializer()\n self._meta_state = self._meta_state_initializer()\n self.task.reset(self._state, self._meta_state)\n self.physics.reset(self._state)\n self.action_space.reset(self._state)\n for rule in self.game_rules:\n rule.reset(self._state, self._meta_state)\n rule.step(self._state, self._meta_state)\n \n return dm_env.restart(self.observation())","def reset(self):\n p.resetSimulation()\n p.setPhysicsEngineParameter(numSolverIterations=150)\n p.setTimeStep(self._time_step)\n p.setGravity(0, 0, -9.8)\n\n # load plane\n p.loadURDF(os.path.join(pybullet_data.getDataPath(), \"plane.urdf\"), [0, 0, 0])\n # load robot\n self._darwin = DarwinopEnv()\n\n # Let the world run for a bit\n for _ in range(20):\n p.stepSimulation()","def reset(self) -> None:\n self._rng = random.default_rng(self.seed)","def test_env_reset_and_step(self):\n create_env = CreateEnv()\n env = create_env.env\n\n # Assert that the total number of agents matches the sum of the 'n_agents'\n # configuration and the number of planners (1 in this case)\n num_planners = 1\n self.assertEqual(\n len(env.all_agents), create_env.env_config[\"n_agents\"] + num_planners\n )\n\n # Assert that the number of agents created in the world\n # matches the configuration specification\n self.assertEqual(len(env.world.agents), create_env.env_config[\"n_agents\"])\n\n # Assert that the planner's index in the world is 'p'\n self.assertEqual(env.world.planner.idx, \"p\")\n\n obs = env.reset()\n\n # Test whether the observation dictionary keys are created as expected\n self.assertEqual(\n sorted(list(obs.keys())),\n [str(i) for i in range(create_env.env_config[\"n_agents\"])] + [\"p\"],\n )\n\n obs, reward, done, info = env.step({})\n\n # Check that the observation, reward and info keys match\n self.assertEqual(obs.keys(), reward.keys())\n self.assertEqual(obs.keys(), info.keys())\n\n # Assert that __all__ is in done\n assert \"__all__\" in done","def resetEnv(self):\n obs = self.env.reset()\n self.state = torch.tensor(obs, device=self.device, dtype=torch.float).unsqueeze(0)\n return","def reset(self):\n # Initialize the timestep\n self.timestep = 0\n self.state = self.starting_state\n\n if self.from_data:\n self.episode_num += 1\n\n\n return self.starting_state","def init_game():\n raise ValueError(\"init_game is removed. Please use env.reset()\")","def reset(self, blocking=True):\n ret = super(ReacherEnv, self).reset(blocking=blocking)\n self._episode_steps = 0\n return ret","def reinitialize(self, random_state):\n pass","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, **kwargs):\n if self.was_real_done:\n obs = self.env.reset(**kwargs)\n else:\n # no-op step to advance from terminal/lost life state\n obs, _, _, _ = self.env.step(0)\n self.lives = self.env.unwrapped.ale.lives()\n return obs","def reset(self, # type: ignore[override]\n *,\n seed: Optional[int] = None,\n options: Optional[Dict[str, Any]] = None,\n ) -> Tuple[DataNested, InfoType]:\n # Reset the seed if requested\n if seed is not None:\n self._initialize_seed(seed)\n\n # Stop the simulator\n self.simulator.stop()\n\n # Remove external forces, if any\n self.simulator.remove_all_forces()\n\n # Make sure the environment is properly setup\n self._setup()\n\n # Make sure the low-level engine has not changed,\n # otherwise some proxies would be corrupted.\n if self.engine is not self.simulator.engine:\n raise RuntimeError(\n \"Changing unexpectedly the memory address of the low-level \"\n \"jiminy engine is an undefined behavior.\")\n\n # Re-initialize some shared memories.\n # It is necessary because the robot may have changed.\n self.sensors_data = OrderedDict(self.robot.sensors_data)\n\n # Enforce the low-level controller.\n # The robot may have changed, for example it could be randomly\n # generated, which would corrupt the old controller. As a result, it is\n # necessary to either instantiate a new low-level controller and to\n # re-initialize the existing one by calling `controller.initialize`\n # method BEFORE calling `reset` method because doing otherwise would\n # cause a segfault.\n mock_controller = jiminy.ControllerFunctor()\n mock_controller.initialize(self.robot)\n self.simulator.set_controller(mock_controller)\n\n # Reset the simulator.\n # Do NOT remove all forces since it has already been done before, and\n # because it would make it impossible to register forces in `_setup`.\n self.simulator.reset(remove_all_forces=False)\n\n # Reset some internal buffers\n self.num_steps = 0\n self._num_steps_beyond_terminate = None\n\n # Create a new log file\n if self.debug:\n fd, self.log_path = tempfile.mkstemp(suffix=\".data\")\n os.close(fd)\n\n # Extract the observer/controller update period.\n # The controller update period is used by default for the observer if\n # it was not specify by the user in `_setup`.\n engine_options = self.simulator.engine.get_options()\n self.control_dt = float(\n engine_options['stepper']['controllerUpdatePeriod'])\n if self.observe_dt < 0.0:\n self.observe_dt = self.control_dt\n\n # Run the reset hook if any.\n # Note that the reset hook must be called after `_setup` because it\n # expects that the robot is not going to change anymore at this point.\n # Similarly, the observer and controller update periods must be set.\n reset_hook: Optional[Callable[[], JiminyEnvInterface]] = (\n options or {}).get(\"reset_hook\")\n env: JiminyEnvInterface = self\n if reset_hook is not None:\n assert callable(reset_hook)\n env_derived = reset_hook() or self\n assert env_derived.unwrapped is self\n env = env_derived\n self._env_derived = env\n\n # Instantiate the actual controller\n controller = jiminy.ControllerFunctor(env._controller_handle)\n controller.initialize(self.robot)\n self.simulator.set_controller(controller)\n\n # Configure the maximum number of steps\n self.max_steps = int(self.simulation_duration_max // self.step_dt)\n\n # Register user-specified variables to the telemetry\n for header, value in self._registered_variables.values():\n register_variables(controller, header, value)\n\n # Sample the initial state and reset the low-level engine\n qpos, qvel = self._sample_state()\n if not jiminy.is_position_valid(\n self.simulator.pinocchio_model, qpos):\n raise RuntimeError(\n \"The initial state provided by `_sample_state` is \"\n \"inconsistent with the dimension or types of joints of the \"\n \"model.\")\n\n # Start the engine\n self.simulator.start(\n qpos, qvel, None, self.simulator.use_theoretical_model)\n\n # Initialize shared buffers\n self._initialize_buffers()\n\n # Update shared buffers\n self._refresh_buffers()\n\n # Initialize the observation\n env._observer_handle(\n self.stepper_state.t,\n self.system_state.q,\n self.system_state.v,\n self.robot.sensors_data)\n\n # Initialize specialized most-derived observation clipping operator\n self._get_clipped_env_observation = build_clip(\n env.observation, env.observation_space)\n\n # Make sure the state is valid, otherwise there `refresh_observation`\n # and `_initialize_observation_space` are probably inconsistent.\n try:\n obs: ObsT = cast(ObsT, self._get_clipped_env_observation())\n except (TypeError, ValueError) as e:\n raise RuntimeError(\n \"The observation computed by `refresh_observation` is \"\n \"inconsistent with the observation space defined by \"\n \"`_initialize_observation_space` at initialization.\") from e\n\n # Make sure there is no 'nan' value in observation\n for value in tree.flatten(obs):\n if np.isnan(value).any():\n raise RuntimeError(\n f\"'nan' value found in observation ({obs}). Something \"\n \"went wrong with `refresh_observation` method.\")\n\n # The simulation cannot be done before doing a single step.\n if any(self.has_terminated()):\n raise RuntimeError(\n \"The simulation has already terminated at `reset`. Check the \"\n \"implementation of `has_terminated` if overloaded.\")\n\n # Reset cumulative reward\n self.total_reward = 0.0\n\n # Note that the viewer must be reset if available, otherwise it would\n # keep using the old robot model for display, which must be avoided.\n if self.simulator.is_viewer_available:\n self.simulator.viewer._setup(self.robot)\n if self.simulator.viewer.has_gui():\n self.simulator.viewer.refresh()\n\n return obs, deepcopy(self._info)","def reset(self, **kwargs):\r\n if self.was_real_done:\r\n obs = self.env.reset(**kwargs)\r\n else:\r\n # no-op step to advance from terminal/lost life state\r\n obs, _, _, _ = self.env.step(0)\r\n self.lives = self.env.unwrapped.ale.lives()\r\n return obs","def reset(self):\n \n self.steps = 0\n if self.episode == 0:\n self.ins = random.uniform(self.mins.values[:4],self.maxes.values[:4])\n #get the corresponding outputs:\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\n out_temp = self.temp_func(var=self.O_t)\n\n outs = np.array([out_flow,out_frac,out_temp])\n self.starts = np.append(self.ins, outs)\n\n else:\n self.starts = self.state[:7] #previous episode's end state\n\n #get goals from random inputs:\n viable = False\n while viable == False:\n self.ins = random.uniform((self.mins.values[:4]+(self.mins.values[:4]*self.minmaxbuffer)),self.maxes.values[:4]-(self.maxes.values[:4]*self.minmaxbuffer))\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\n out_temp = self.temp_func(var=self.O_t)\n\n outs = np.array([out_flow,out_frac,out_temp])\n \n # Check if viable:\n viable = self.test_viable(outs)\n\n self.goals = outs\n\n # These are your current inputs:\n self.ins = self.starts[:4]\n # State carries the starting points and the goals.\n self.state = np.append(self.starts,self.goals)\n\n #Track episodes and total reward.\n self.episode += 1\n self.tot_rew = 0\n\n return (self.state)","def reset(self):\n error_estop = \"\"\"\\\nE-Stop is ASSERTED. Disengage E-Stop and then reset the robot.\n\"\"\"\n error_nonfatal = \"\"\"Non-fatal Robot Error on reset.\nRobot reset cleared stopped state and robot can be enabled, but a non-fatal\nerror persists. Check diagnostics or rethink.log for more info.\n\"\"\"\n error_env = \"\"\"Failed to reset robot.\nPlease verify that the ROS_IP or ROS_HOSTNAME environment variables are set\nand resolvable. For more information please visit:\nhttp://sdk.rethinkrobotics.com/wiki/RSDK_Shell#Initialize\n\"\"\"\n is_reset = lambda: (self._state.enabled == False and\n self._state.stopped == False and\n self._state.error == False and\n self._state.estop_button == 0 and\n self._state.estop_source == 0)\n pub = rospy.Publisher('robot/set_super_reset', Empty, queue_size=10)\n\n if (self._state.stopped and\n self._state.estop_button == AssemblyState.ESTOP_BUTTON_PRESSED):\n rospy.logfatal(error_estop)\n raise IOError(errno.EREMOTEIO, \"Failed to Reset: E-Stop Engaged\")\n\n rospy.loginfo(\"Resetting robot...\")\n try:\n baxter_dataflow.wait_for(\n test=is_reset,\n timeout=3.0,\n timeout_msg=error_env,\n body=pub.publish\n )\n except OSError as e:\n if e.errno == errno.ETIMEDOUT:\n if self._state.error == True and self._state.stopped == False:\n rospy.logwarn(error_nonfatal)\n return False\n raise","def reset(self):\n # Reset time counter\n self.t = 0\n\n # Reset randomization\n self.randomization.reset()\n\n # Randomize parameters.\n self.parameters = self.randomization.parameter_randomizer.randomize(\n self.parameters, self._random_state\n )\n\n self._reset()\n\n # Randomize simulation. Because sim is recreated in self._reset(),\n # simulation_randomizer.randomize should be called after the _reset.\n self.randomization.simulation_randomizer.randomize(\n self.mujoco_simulation.mj_sim, self._random_state\n )\n\n # reset observer.\n self.observer.reset()\n\n # Reset multi goal tracker for a new episode.\n self.multi_goal_tracker.reset()\n\n # Reset state of goal generation.\n return self.reset_goal_generation(sync_type=SyncType.RESET)","def _initialize_episode(self, agent_type='active'):\n initial_observation = self._environment.reset()\n return self._agent.begin_episode(agent_type, initial_observation)","def reset(self):\n Simulation.reset(self)","def reset_world():\n __switch_ctrl.call(start_controllers=[],\n stop_controllers=[\"hand_position_trajectory_controller\", \"arm_position_trajectory_controller\", \"joint_state_controller\"],\n strictness=SwitchControllerRequest.BEST_EFFORT)\n __pause_physics.call()\n\n joint_names = ['j1', 'j2', 'j3', 'j4', 'j5', 'flange','H1_F1J1', 'H1_F1J2',\n 'H1_F1J3', 'H1_F2J1', 'H1_F2J2', 'H1_F2J3','H1_F3J1', 'H1_F3J2', 'H1_F3J3']\n joint_positions = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] \n\n __set_model.call(model_name=\"denso\",\n urdf_param_name=\"robot_description\",\n joint_names=joint_names,\n joint_positions=joint_positions)\n\n timer = Timer(0.0, __start_ctrl)\n timer.start()\n\n time.sleep(0.1)\n __unpause_physics.call()\n\n #__reset_world.call()\n spawn_extras()","def setup_method(cls):\n seed()","def _reset(self, env_id: np.ndarray) -> None:","def reset():\n _runtime.reset()","def reset(\n self,\n seed: int | None = None,\n options: dict | None = None,\n ) -> None:\n raise NotImplementedError","def setUp(self) -> None:\n self.random = np.random.RandomState(seed=42)","def reset(self):\n if self._draw_new_turn_on_reset:\n turn_params = self._draw_random_turn_params()\n config = AisleTurnEnvParams(turn_params=turn_params, env_params=self._env_params)\n self._env = AisleTurnEnv(config)\n\n return self._env.reset()","def reset(self):\r\n # reset Wheel encoders\r\n self.start_time = time.time()\r\n [left_start, right_start] = self.Roomba.Query(43, 44)\r\n self.Motion.reset(left_start, right_start)\r\n # reset bumper\r\n self.bumper.reset()\r\n\r\n #reset grid world data\r\n self.action=[0.0,0.0]\r\n self.grid_state= [0,0,0]\r\n self.real_state = [0.0, 0.0, 0.0]\r\n self.trans_model = None\r\n pass","def reset(self,\n *,\n seed: Optional[int] = None,\n options: Optional[dict] = None,\n ) -> Tuple[Observation, dict]:\n super().reset(seed=seed, options=options)\n if options and \"config\" in options:\n self.configure(options[\"config\"])\n self.update_metadata()\n self.define_spaces() # First, to set the controlled vehicle class depending on action space\n self.time = self.steps = 0\n self.done = False\n self._reset()\n self.define_spaces() # Second, to link the obs and actions to the vehicles once the scene is created\n obs = self.observation_type.observe()\n info = self._info(obs, action=self.action_space.sample())\n if self.render_mode == 'human':\n self.render()\n return obs, info","def reset(self):\n self.num_steps = 0\n self.world_state = self.action = None","def set_env(self, env):\n\n self.env = env\n self.sim_env = copy.deepcopy(self.env)\n self.sim_env.reset_at_episode_end = False # Avoids expensive re-sampling of jets every time we parse a path\n self.init_episode()","def reset(self, **kwargs):\n\n # on a reset we set the health back to 120\n self.player_hp = 120\n self.enemy_hp = 120\n\n # reset the environment\n \n observation = self.env.reset(**kwargs)\n\n # we restarted inc the number\n self.num_resets += 1\n\n # the observation\n obs = self.observation(observation)\n self.current_frame_number = 0\n \n # fill up the queue\n for i in range(4):\n self.q.append(obs)\n \n return np.array(list(self.q))","def reset(self):\n self.success = False\n self.i = 0\n if self.monitor:\n self.env = gym.wrappers.Monitor(self.env, \"./mountaincar-monitor\", force=True)\n state = self.env.reset()\n state = self.preprocess_state(state)\n state = np.concatenate([state] * self.action_repeat)\n return state","def reset(ctx, with_testdb):\n ctx.invoke(init, with_testdb=with_testdb)\n ctx.invoke(seed)\n\n return None","def reset(ctx, with_testdb):\n ctx.invoke(init, with_testdb=with_testdb)\n ctx.invoke(seed)\n\n return None","def reset(self, observation, target_pos, ground_truth):\n if len(self.episode_starts) == 0 or self.episode_starts[-1] is False:\n self.episode_idx += 1\n\n if self.learn_states and (self.episode_idx + 1) % self.learn_every == 0 and self.n_steps <= self.max_steps:\n print(\"Learning a state representation ...\")\n start_time = time.time()\n ok, self.srl_model_path = self.socket_client.waitForSRLModel(self.state_dim)\n print(\"Took {:.2f}s\".format(time.time() - start_time))\n\n self.episode_step = 0\n self.episode_success = False\n self.episode_folder = \"record_{:03d}\".format(self.episode_idx)\n os.makedirs(\"{}/{}\".format(self.data_folder, self.episode_folder), exist_ok=True)\n\n self.episode_starts.append(True)\n self.target_positions.append(target_pos)\n self.ground_truth_states.append(ground_truth)\n self.saveImage(observation)","def reset(self):\n self.sim.reset()\n # state = np.concatenate([self.sim.pose] * self.action_repeat) \n state = self.sim.pose\n return state","def set_seed(self, seed: int):\n self.rsimulator.set_seed(seed)\n # Maybe call new game here?","def reset(self):\r\n pg.event.clear()\r\n self.stop_powerpellet()\r\n if not self.eaten:\r\n self.dot_counter = 0\r\n self.eaten = False\r\n self.eat_ghost = False\r\n self.reset_energizer_flag()\r\n self.last_dir = self.direction = 'l'\r\n self.count_eaten_ghost = 200\r\n self.pos = list(self.start_pos)[:]\r\n self.global_counter = 0\r\n self.hourglass_counter = 0","def restart(self):\n self.set_random_pos('starting')\n self.set_random_pos('finishing')\n self.game_loop()","def reset():\n Vessel.reset_instances()","def reset(self,new_tgt_pos=None):\n self.sim.reset()\n state = np.concatenate([self.sim.pose] * self.action_repeat) \n if new_tgt_pos is not None:\n self.target_pos = new_tgt_pos \n return state","def reset_env(\n self, key: chex.PRNGKey, params: EnvParams\n ) -> Tuple[chex.Array, EnvState]:\n # Always start with no stock\n # # By defauly, we start on a random weekday\n # Otherwise, with fixed burn-in, would always\n # count return from same weekday\n weekday = jax.lax.cond(\n params.initial_weekday == -1,\n lambda _: jax.random.randint(key, (), 0, 7, dtype=jnp_int),\n lambda _: params.initial_weekday.astype(jnp_int),\n None,\n )\n\n state = EnvState(\n weekday=weekday,\n stock=self.initial_stock,\n step=0,\n )\n return self.get_obs(state), state","def reset(self):\n self.cur_step = 0\n self.cur_episode += 1\n self.cur_state = 0 # Always start with fixed state\n self.action_episode_memory.append([])\n self.observation_episode_memory.append([])\n self.reward_episode_memory.append([])\n obs = self._get_obs()\n return obs","def set_global_seeds(seed):\n \n torch.manual_seed(seed)\n np.random.seed(seed)\n random.seed(seed)","def reset(self):\n self.sim.reset()\n state = np.concatenate([self.sim.pose] * self.action_repeat) \n return state","def reset(self):\n self.sim.reset()\n state = np.concatenate([self.sim.pose] * self.action_repeat) \n return state","def reset(self):\n self.sim.reset()\n state = np.concatenate([self.sim.pose] * self.action_repeat) \n return state","def reset(self, normalized_state, state):\n # self.episode_starts.append(True)\n self.normalized_states.append(normalized_state)\n self.states.append(np.squeeze(state))","def reset_env(\n self, key: chex.PRNGKey, params: EnvParams\n ) -> Tuple[chex.Array, EnvState]:\n # Always start with no stock\n # # By defauly, we start on a random weekday\n # Otherwise, with fixed burn-in, would always\n # count return from same weekday\n weekday = jax.lax.cond(\n params.initial_weekday == -1,\n lambda _: jax.random.randint(key, (), 0, 7, dtype=jnp_int),\n lambda _: params.initial_weekday.astype(jnp_int),\n None,\n )\n\n state = EnvState(\n weekday=weekday,\n stock=jnp.zeros(self.max_useful_life - 1, dtype=jnp_int),\n step=0,\n )\n return self.get_obs(state), state","def reset(self):\n print('call reset()')\n self.cur = 0\n if self.shuffle:\n random.shuffle(self.seq)","def reset(self):\n self.sim.reset()\n self.takeoff = False\n self.success = False\n state = np.concatenate([self.sim.pose] * self.action_repeat)\n return state","def reset(self, x=0.2, y=0.2):\n\n # Reset the environment (start a new episode)\n self.y = y\n self.x = x\n self.theta = 90\n self.theta = math.radians(self.theta)\n self.steps = 0\n self.index = 0\n self.farthest = -1\n self.laps = 0\n\n # add noise to position and theta\n # self.x_noise = self.x + np.random.normal(self.mu, self.sigmaxy, 1)\n # self.y_noise = self.y + np.random.normal(self.mu, self.sigmaxy, 1)\n # self.theta_noise = self.theta + np.random.normal(self.mu,\n # self.sigmaangle, 1)\n\n self._distance_next()\n self._calc_delta_theta()\n\n if self.discrete_input:\n # discretize state for the agent to control\n\n discrete_distance, discrete_delta_theta \\\n = self._discretize_agent_state(self.distance, self.delta_theta)\n\n self.agent_state = np.array([discrete_distance,\n discrete_delta_theta])\n\n else:\n # self.agent_state has to be a matrix to be accepted by keras\n self.agent_state = np.array([self.distance, self.delta_theta])\n\n # Create state (x,y,theta)\n self.state = [self.x, self.y, self.theta]\n\n return self.state, self.agent_state","def episode_init(self):\n self.nsteps = 0\n self.action = None\n self.state = None\n self.reward = None\n self.terminal = None\n self.total_reward = 0.0","def rngreset(seed=0):\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n torch.backends.cudnn.deterministic = True","def reset(self):\n self.noise = [0.] * 6\n self.state = [0.0] * 9\n self.q = [0.0, 0.0, 0.0, 1.0]\n self.terminal = False\n self.steps = 0\n # Return current state and error\n return self.observation, self.error","def reset(self, *args):\n self.state = GameStates.playing\n self.human = evilrps.Player('Human', self.get_player_choice)\n self.ai = evilrps.Player('AI', evilrps.create_ai())\n self.game = evilrps.Game(self.human, self.ai)","def reset_target(scope) -> None:\n if globals.cw_platform == \"CW303\" or globals.cw_platform == \"CWLITEXMEGA\":\n scope.io.pdic = 'low'\n time.sleep(0.1)\n scope.io.pdic = 'high_z' #XMEGA doesn't like pdic driven high\n time.sleep(0.1) #xmega needs more startup time\n else: \n scope.io.nrst = 'low'\n time.sleep(0.05)\n scope.io.nrst = 'high_z'\n time.sleep(0.05)","def reset(self):\n\n logger.info('Removed existing OpenMM engine.')\n self._simulation = None","def reset(self):\n\n self.speed = self.getRandomVelocity()\n self.setX(Configuration.windowWidth / 2)\n self.setY(Configuration.windowHeight / 2)","def reset(self, **kwargs):\n self.env.reset(**kwargs)\n if self.override_num_noops is not None:\n noops = self.override_num_noops\n else:\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101\n assert noops > 0\n obs = None\n for _ in range(noops):\n obs, _, done, _ = self.env.step(self.noop_action)\n if done:\n obs = self.env.reset(**kwargs)\n return obs","def reset(self):\r\n self.x = self.initX\r\n self.y = self.initY\r\n self.dir= self.initDir","def set_global(self):\n random.setstate(self.py)\n np.random.set_state(self.np)\n torch.set_rng_state(self.torch)","def run(self, seed=None):\n if seed is not None:\n random_seed.set_seed(seed)\n self.reset()","def reset(self):\n # self state is velocity, observation is velocity\n # self._state = np.random.uniform(0, self.GOAL_VELOCITY, size=(self.num_cars,))\n # print(\"In reset function\", self.initialized)\n if self.initialized:\n traci.close()\n sumoProcess = subprocess.Popen([self.sumoBinary, \"-c\", self.cfgfn, \"--remote-port\", str(self.PORT)], stdout=sys.stdout, stderr=sys.stderr)\n traci.init(self.PORT)\n traci.simulationStep()\n if not self.initialized:\n self.vehIDs = traci.vehicle.getIDList()\n print(\"ID List in reset\", self.vehIDs)\n self.initialized = True\n self._state = np.array([traci.vehicle.getSpeed(vID) for vID in self.controllable])\n observation = np.copy(self._state)\n return observation","def prepare_for_use(self):\n self._random_state = check_random_state(self.random_state)\n self._offset = self.offset\n self._x_idx = 0","def prepare_for_use(self):\n self._random_state = check_random_state(self.random_state)\n self._offset = self.offset\n self._x_idx = 0","def prepare_for_use(self):\n self._random_state = check_random_state(self.random_state)\n self._offset = self.offset\n self._x_idx = 0"],"string":"[\n \"def reset(self):\\n\\n # initialize gym env variables\\n self.finish = False\\n self.curr_step = -1\\n self.curr_episode += 1\\n\\n # initialize target position\\n self.target = np.random.uniform(-10.0,10.0,size=(2))\\n\\n # initialize sheep positions\\n if self.fixed_reset:\\n init_sheep_pose = np.array([75.0, 75.0])\\n self.sheep_poses = (np.random.uniform(-50.0, 50.0, \\n size=(self.num_sheep,2))) + init_sheep_pose[None,:]\\n else:\\n init_sheep_pose = np.random.uniform(-self.init_sheep_root, \\n self.init_sheep_root, size=(2))\\n self.sheep_poses = (np.random.uniform(-self.init_sheep_range, \\n self.init_sheep_range, size=(self.num_sheep,2))) \\\\\\n + init_sheep_pose[None,:]\\n self.sheep_com = self.sheep_poses.mean(axis=0)\\n\\n # get the farthest sheep and radius of the sheep\\n dist_to_com = np.linalg.norm((self.sheep_poses - self.sheep_com[None,:]), axis=1)\\n self.farthest_sheep = self.sheep_poses[np.argmax(dist_to_com),:]\\n self.radius_sheep = np.array([np.max(dist_to_com)])\\n\\n # update distance to target\\n self.target_distance = np.linalg.norm(self.target - self.sheep_com)\\n\\n # initialize values for reward estimation\\n self.init_radius_sheep = self.radius_sheep\\n self.init_target_distance = self.target_distance\\n\\n # initialize dog position\\n if self.fixed_reset:\\n init_dog_pose = np.array([0.0,75.0])\\n else:\\n init_theta = np.random.uniform(-np.pi,np.pi)\\n init_dog_pose = init_sheep_pose + self.init_dog_distance*np.array([np.cos(init_theta), \\n np.sin(init_theta)])\\n self.dog_pose = init_dog_pose\\n\\n # initialize inertia\\n self.inertia = np.ones((self.num_sheep, 2))\\n\\n # initialize episode reward and length\\n self.episode_reward = 0\\n self.episode_length = 0\\n\\n # get the state, reward, finish, info\\n state = self._get_state()\\n \\n return state\",\n \"def _hard_reset(self):\\n self._reset_specific_envs(np.ones_like(self.episodes_done))\\n self._update_other_info()\",\n \"def _reset(self):\\n np.random.shuffle(self.id)\\n self.episode_step = 0 # Reset episode step counter at the end of every episode\\n self._state = self.X_train[self.id[self.episode_step]]\\n self._episode_ended = False\\n\\n return ts.restart(self._state)\",\n \"def reset(self):\\n self.tracker.reset()\\n self.episode += 1\\n self.episode_step = 0\",\n \"def reset(self, **kwargs):\\n if self._backend_agent:\\n self._backend_agent._on_gym_reset_begin(self, **kwargs)\\n\\n result = self.env.reset(**kwargs)\\n if self.steps_done_in_episode > 0 and not self.is_episode_done:\\n self.episodes_done += 1\\n self.total.episodes_done_inc()\\n self.is_episode_done = False\\n self.steps_done_in_episode = 0\\n\\n if self._backend_agent:\\n self._backend_agent._on_gym_reset_end(self, result, **kwargs)\\n return result\",\n \"def reset(self):\\n \\n if self._config.fix_seed:\\n self._init_seed = (self._init_seed + 1) % 2**32 # set_seed requires int\\n self.game.set_seed(self._init_seed)\\n\\n super(ShootEnv, self).reset()\\n\\n self._killcount = 0.0\\n self._ammo = self.game.get_game_variable(GameVariable.AMMO2)\\n self._health = self.game.get_game_variable(GameVariable.HEALTH)\\n\\n return self._get_observation()\",\n \"def reset(self):\\n\\n self.curr_episode += 1\\n self.curr_step = 0\\n\\n self.action_episode_memory.append([])\\n self.rewards.append([])\\n\\n self.is_finalized = False\\n init_state, init_reward = self._take_action(5 * np.random.randn(self.act_dimension))\\n self.initial_conditions.append(init_state)\\n return init_state\",\n \"def specific_reset(self) -> None:\\n self.agent.specific_reset() # reset joints\\n new_pos = self.agent.init_xyz\\n new_pos[:2] = np.random.uniform(-0.01, 0.01, 2)\\n self.agent.set_position(new_pos)\\n self.old_potential = self.calculate_task_potential()\",\n \"def reset(self):\\n while not self._check_episode_start_condition():\\n self._simulate()\\n self.state, _ = self._extract_state()\\n return self.state\",\n \"def reset(\\n self,\\n *,\\n seed: int | None = None,\\n options: dict[str, Any] | None = None,\\n ) -> tuple[np.ndarray, AtariEnvStepMetadata]:\\n super().reset(seed=seed, options=options)\\n del options\\n # Gymnasium's new seeding API seeds on reset.\\n # This will cause the console to be recreated\\n # and loose all previous state, e.g., statistics, etc.\\n seeded_with = None\\n if seed is not None:\\n seeded_with = self.seed(seed)\\n\\n self.ale.reset_game()\\n obs = self._get_obs()\\n\\n info = self._get_info()\\n if seeded_with is not None:\\n info[\\\"seeds\\\"] = seeded_with\\n return obs, info\",\n \"def _soft_reset(self):\\n self._reset_specific_envs(self.episodes_done)\\n self._update_other_info()\",\n \"def _reset_seeds(self) -> None:\\n self._seeds = [None for _ in range(self.num_envs)]\",\n \"def reset_from_state(self, state):\\n\\n # initialize gym env variables\\n self.finish = False\\n self.curr_step = -1\\n self.curr_episode += 1\\n\\n # initialize target position\\n self.target = state[4:6]\\n\\n # initialize sheep com\\n self.sheep_com = state[0:2]\\n\\n # get the farthest sheep and radius of the sheep\\n self.farthest_sheep = state[2:4]\\n self.radius_sheep = np.array([state[8]])\\n\\n # update distance to target\\n self.target_distance = np.array([state[9]])\\n\\n # initialize sheep position\\n self.sheep_poses = (np.random.uniform(-0.75*self.radius_sheep, \\n 0.75*self.radius_sheep, size=(self.num_sheep,2))) \\\\\\n + self.sheep_com[None,:]\\n rnd_ind = np.random.choice(self.num_sheep)\\n self.sheep_poses[rnd_ind,:] = state[2:4]\\n\\n # initialize values for reward estimation\\n self.init_radius_sheep = self.radius_sheep\\n self.init_target_distance = self.target_distance\\n\\n # initialize dog position\\n init_dog_pose = state[6:8]\\n self.dog_pose = init_dog_pose\\n\\n # initialize inertia\\n self.inertia = np.ones((self.num_sheep, 2))\\n\\n # initialize episode reward and length\\n self.episode_reward = 0\\n self.episode_length = 0\\n\\n # get the state, reward, finish, info\\n state = self._get_state()\\n \\n return state\",\n \"def _reset(self):\\r\\n \\r\\n airgym.reset()\\r\\n self.stepN = 0\\r\\n self.episodeN += 1\\r\\n \\r\\n self.allLogs = { 'reward': [0] }\\r\\n self.allLogs['distance'] = [221]\\r\\n self.allLogs['action'] = [1]\\r\\n \\r\\n print(\\\"\\\")\\r\\n \\r\\n #self.sensors = airgym.getSensorStates()\\r\\n \\r\\n # Initial state\\r\\n self.state = airgym.getScreenDepthVis()\\r\\n \\r\\n \\r\\n return self.state\",\n \"def reset(self):\\r\\n \\r\\n self.done = False\\r\\n self.t = 0\\r\\n self.episode = random.choice(episodes)\\r\\n\\r\\n # initiate agent\\r\\n self.agent = self.create_agent(Agent)\\r\\n \\r\\n # initiate state at time zero\\r\\n self.state = (self.episode[self.t]['ST Relative Indicator'], \\r\\n self.episode[self.t]['ST Relative Indicator'], \\r\\n self.agent.stock,\\r\\n self.t)\\r\\n \\r\\n return self.state\",\n \"def _reset(self): # We are using a virtual function defined in the gym infrastructure.\\n self.gazebo.unpauseSim()\\n \\\"\\\"\\\"\\n why we need to unpauseSim because resetting controllers and for checking the sensors, we need the simulation\\n to be running because otherwise we don't have any sensory data and we don't have access to the controller reset\\n functions services they won't work and tell you to hit play. => it is very important.\\n \\\"\\\"\\\"\\n self.controllers_object.reset_controllers()\\n self.check_all_sensors_ready()\\n self.set_init_pose()\\n #initialized robot\\n self.gazebo.pauseSim()\\n self.gazebo.resetSim()\\n self.gazebo.unpauseSim()\\n self.controllers_object.reset_controllers()\\n self.check_all_sensors_ready()\\n self.gazebo.pauseSim()\\n self.init_env_variables()\\n obs = self._get_obs()\\n simplified_obs = self.convert_obs_to_state(obs)\\n\\n return simplified_obs\",\n \"def resetEyes(self):\\n\\n\\t\\tself.leds.on(\\\"FaceLeds\\\")\",\n \"def resetEyes(self):\\n\\n\\t\\tself.leds.on(\\\"FaceLeds\\\")\",\n \"def reset(self):\\n self.curr_episode += 1\\n self.action_episode_memory.append([])\\n self.is_game_done = False\\n self.price = 1.00\\n self.sendCmd(self.url,\\\"reset\\\")\\n return self._get_state()\",\n \"def env_init(self, env_info={}):\\n self.dealer_sticks = env_info['dealer_sticks']\\n self.random = np.random.RandomState(env_info['seed'])\\n self.current_state = None\",\n \"def _reset_(self):\\n print(\\\"Resetting\\\")\\n\\n self._q_target_, x_target = self._pick_random_angles_()\\n np.copyto(self._x_target_, x_target)\\n if self._target_type == 'position':\\n self._target_ = self._x_target_[self._end_effector_indices]\\n elif self._target_type == 'angle':\\n self._target_ = self._q_target_\\n self._action_ = self._rand_obj_.uniform(self._action_low, self._action_high)\\n self._cmd_prev_ = np.zeros(len(self._action_low)) # to be used with derivative control of velocity\\n if self._reset_type != 'none':\\n if self._reset_type == 'random':\\n reset_angles, _ = self._pick_random_angles_()\\n elif self._reset_type == 'zero':\\n reset_angles = self._q_ref[self._joint_indices]\\n self._reset_arm(reset_angles)\\n\\n rand_state_array_type, rand_state_array_size, rand_state_array = utils.get_random_state_array(\\n self._rand_obj_.get_state()\\n )\\n np.copyto(self._shared_rstate_array_, np.frombuffer(rand_state_array, dtype=rand_state_array_type))\\n\\n print(\\\"Reset done\\\")\",\n \"def reset(self):\\n self.tracker.reset()\\n self.total_max_q = 0.0\\n self.episode_step = 0\\n self.episode += 1\",\n \"def reset(self, gui=False, test_ind=-1):\\n # self.gui = gui\\n # if gui:\\n # # save episode to disk\\n # if self._global_frames:\\n # make_video_from_rgb_imgs(self._global_frames, self.output_path, f\\\"episode_global_{self.cur_episode}\\\")\\n\\n # for agent_id, frames in self._agent_frames.items():\\n # if frames:\\n # make_video_from_rgb_imgs(frames, self.output_path, f\\\"episode_{self.cur_episode}_{agent_id}\\\")\\n\\n # # clear frames of previous episode\\n # self._global_frames = []\\n # self._agent_frames = {agent_id: [] for agent_id in self.agent_tags}\\n\\n if (self.train_mode):\\n seed = self.seed\\n elif (test_ind < 0):\\n seed = self.seed-1\\n else:\\n seed = self.test_seeds[test_ind]\\n np.random.seed(seed)\\n self.seed += 1\\n\\n self.cur_episode += 1\\n self.t = 0 # step counter for each episode\\n self.rewards = [0] # to keep track of global rewards\\n obs = self.env.reset(done_only=False).cpu().numpy()\\n\\n # if self.gui:\\n # self._global_frames.append(self.env.map_to_colors().astype(np.uint8))\\n\\n # for agent_id, agent_obs in obs.items():\\n # self._agent_frames[agent_id].append(agent_obs.astype(np.uint8))\\n\\n # obs = list(obs.values())\\n obs = self._get_state(obs) # new\\n\\n return obs\",\n \"def reset(self):\\n # Sample random state from initial state distribution\\n self._cur_state = self._sample_state(self._mdp.I)\\n self._prev_state = self._cur_state\",\n \"def reset(self):\\n self.observation = None\\n self.episode_done = True\",\n \"def _restart_environment_episode(self, force_environment_reset=False) -> None:\\n raise NotImplementedError(\\\"\\\")\",\n \"def reset(self):\\n\\n # Ending variables\\n self.time_idle = 0\\n self.time_episode = 0\\n self.done_time_idle = False\\n self.done_falling = False\\n self.done_time_episode = False\\n\\n # hero variables\\n self.last_location = None\\n self.last_velocity = 0\\n\\n # Sensor stack\\n self.prev_image_0 = None\\n self.prev_image_1 = None\\n self.prev_image_2 = None\\n\\n self.last_heading_deviation = 0\",\n \"def specific_reset(self) -> None:\\n self.old_velocity = 0.\\n self.agent.specific_reset()\\n max_dist_to_origin = 4.\\n min_dist_to_origin = 2\\n\\n agent_pos = np.random.uniform(-max_dist_to_origin, max_dist_to_origin, 2)\\n positioning_done = False\\n while not positioning_done:\\n agent_pos = np.random.uniform(-max_dist_to_origin,\\n max_dist_to_origin, 2)\\n if min_dist_to_origin <= np.linalg.norm(agent_pos) <= max_dist_to_origin:\\n positioning_done = True\\n\\n # adjust the height of agent\\n agent_pos = np.concatenate((agent_pos[:2], [self.agent.init_xyz[2]]))\\n self.agent.set_position(agent_pos)\\n\\n # set agent orientation in forward run direction\\n y = angle2pos(self.agent.get_position(), np.zeros(3)) + np.pi / 2\\n y += self.agent.init_rpy[2]\\n quaternion = self.bc.getQuaternionFromEuler([0, 0, y])\\n self.agent.set_orientation(quaternion)\",\n \"def seed_random():\\n random.seed(0)\",\n \"def reset(self):\\r\\n random.seed(1) # Set determanistic play\\r\\n if self.board is None:\\r\\n self.setup_board()\\r\\n self.board.reset()\",\n \"def reset(self):\\n self._reset_next_step = False\\n self.step_count = 0\\n \\n self._state = self.state_initializer()\\n self._meta_state = self._meta_state_initializer()\\n self.task.reset(self._state, self._meta_state)\\n self.physics.reset(self._state)\\n self.action_space.reset(self._state)\\n for rule in self.game_rules:\\n rule.reset(self._state, self._meta_state)\\n rule.step(self._state, self._meta_state)\\n \\n return dm_env.restart(self.observation())\",\n \"def reset(self):\\n p.resetSimulation()\\n p.setPhysicsEngineParameter(numSolverIterations=150)\\n p.setTimeStep(self._time_step)\\n p.setGravity(0, 0, -9.8)\\n\\n # load plane\\n p.loadURDF(os.path.join(pybullet_data.getDataPath(), \\\"plane.urdf\\\"), [0, 0, 0])\\n # load robot\\n self._darwin = DarwinopEnv()\\n\\n # Let the world run for a bit\\n for _ in range(20):\\n p.stepSimulation()\",\n \"def reset(self) -> None:\\n self._rng = random.default_rng(self.seed)\",\n \"def test_env_reset_and_step(self):\\n create_env = CreateEnv()\\n env = create_env.env\\n\\n # Assert that the total number of agents matches the sum of the 'n_agents'\\n # configuration and the number of planners (1 in this case)\\n num_planners = 1\\n self.assertEqual(\\n len(env.all_agents), create_env.env_config[\\\"n_agents\\\"] + num_planners\\n )\\n\\n # Assert that the number of agents created in the world\\n # matches the configuration specification\\n self.assertEqual(len(env.world.agents), create_env.env_config[\\\"n_agents\\\"])\\n\\n # Assert that the planner's index in the world is 'p'\\n self.assertEqual(env.world.planner.idx, \\\"p\\\")\\n\\n obs = env.reset()\\n\\n # Test whether the observation dictionary keys are created as expected\\n self.assertEqual(\\n sorted(list(obs.keys())),\\n [str(i) for i in range(create_env.env_config[\\\"n_agents\\\"])] + [\\\"p\\\"],\\n )\\n\\n obs, reward, done, info = env.step({})\\n\\n # Check that the observation, reward and info keys match\\n self.assertEqual(obs.keys(), reward.keys())\\n self.assertEqual(obs.keys(), info.keys())\\n\\n # Assert that __all__ is in done\\n assert \\\"__all__\\\" in done\",\n \"def resetEnv(self):\\n obs = self.env.reset()\\n self.state = torch.tensor(obs, device=self.device, dtype=torch.float).unsqueeze(0)\\n return\",\n \"def reset(self):\\n # Initialize the timestep\\n self.timestep = 0\\n self.state = self.starting_state\\n\\n if self.from_data:\\n self.episode_num += 1\\n\\n\\n return self.starting_state\",\n \"def init_game():\\n raise ValueError(\\\"init_game is removed. Please use env.reset()\\\")\",\n \"def reset(self, blocking=True):\\n ret = super(ReacherEnv, self).reset(blocking=blocking)\\n self._episode_steps = 0\\n return ret\",\n \"def reinitialize(self, random_state):\\n pass\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, **kwargs):\\n if self.was_real_done:\\n obs = self.env.reset(**kwargs)\\n else:\\n # no-op step to advance from terminal/lost life state\\n obs, _, _, _ = self.env.step(0)\\n self.lives = self.env.unwrapped.ale.lives()\\n return obs\",\n \"def reset(self, # type: ignore[override]\\n *,\\n seed: Optional[int] = None,\\n options: Optional[Dict[str, Any]] = None,\\n ) -> Tuple[DataNested, InfoType]:\\n # Reset the seed if requested\\n if seed is not None:\\n self._initialize_seed(seed)\\n\\n # Stop the simulator\\n self.simulator.stop()\\n\\n # Remove external forces, if any\\n self.simulator.remove_all_forces()\\n\\n # Make sure the environment is properly setup\\n self._setup()\\n\\n # Make sure the low-level engine has not changed,\\n # otherwise some proxies would be corrupted.\\n if self.engine is not self.simulator.engine:\\n raise RuntimeError(\\n \\\"Changing unexpectedly the memory address of the low-level \\\"\\n \\\"jiminy engine is an undefined behavior.\\\")\\n\\n # Re-initialize some shared memories.\\n # It is necessary because the robot may have changed.\\n self.sensors_data = OrderedDict(self.robot.sensors_data)\\n\\n # Enforce the low-level controller.\\n # The robot may have changed, for example it could be randomly\\n # generated, which would corrupt the old controller. As a result, it is\\n # necessary to either instantiate a new low-level controller and to\\n # re-initialize the existing one by calling `controller.initialize`\\n # method BEFORE calling `reset` method because doing otherwise would\\n # cause a segfault.\\n mock_controller = jiminy.ControllerFunctor()\\n mock_controller.initialize(self.robot)\\n self.simulator.set_controller(mock_controller)\\n\\n # Reset the simulator.\\n # Do NOT remove all forces since it has already been done before, and\\n # because it would make it impossible to register forces in `_setup`.\\n self.simulator.reset(remove_all_forces=False)\\n\\n # Reset some internal buffers\\n self.num_steps = 0\\n self._num_steps_beyond_terminate = None\\n\\n # Create a new log file\\n if self.debug:\\n fd, self.log_path = tempfile.mkstemp(suffix=\\\".data\\\")\\n os.close(fd)\\n\\n # Extract the observer/controller update period.\\n # The controller update period is used by default for the observer if\\n # it was not specify by the user in `_setup`.\\n engine_options = self.simulator.engine.get_options()\\n self.control_dt = float(\\n engine_options['stepper']['controllerUpdatePeriod'])\\n if self.observe_dt < 0.0:\\n self.observe_dt = self.control_dt\\n\\n # Run the reset hook if any.\\n # Note that the reset hook must be called after `_setup` because it\\n # expects that the robot is not going to change anymore at this point.\\n # Similarly, the observer and controller update periods must be set.\\n reset_hook: Optional[Callable[[], JiminyEnvInterface]] = (\\n options or {}).get(\\\"reset_hook\\\")\\n env: JiminyEnvInterface = self\\n if reset_hook is not None:\\n assert callable(reset_hook)\\n env_derived = reset_hook() or self\\n assert env_derived.unwrapped is self\\n env = env_derived\\n self._env_derived = env\\n\\n # Instantiate the actual controller\\n controller = jiminy.ControllerFunctor(env._controller_handle)\\n controller.initialize(self.robot)\\n self.simulator.set_controller(controller)\\n\\n # Configure the maximum number of steps\\n self.max_steps = int(self.simulation_duration_max // self.step_dt)\\n\\n # Register user-specified variables to the telemetry\\n for header, value in self._registered_variables.values():\\n register_variables(controller, header, value)\\n\\n # Sample the initial state and reset the low-level engine\\n qpos, qvel = self._sample_state()\\n if not jiminy.is_position_valid(\\n self.simulator.pinocchio_model, qpos):\\n raise RuntimeError(\\n \\\"The initial state provided by `_sample_state` is \\\"\\n \\\"inconsistent with the dimension or types of joints of the \\\"\\n \\\"model.\\\")\\n\\n # Start the engine\\n self.simulator.start(\\n qpos, qvel, None, self.simulator.use_theoretical_model)\\n\\n # Initialize shared buffers\\n self._initialize_buffers()\\n\\n # Update shared buffers\\n self._refresh_buffers()\\n\\n # Initialize the observation\\n env._observer_handle(\\n self.stepper_state.t,\\n self.system_state.q,\\n self.system_state.v,\\n self.robot.sensors_data)\\n\\n # Initialize specialized most-derived observation clipping operator\\n self._get_clipped_env_observation = build_clip(\\n env.observation, env.observation_space)\\n\\n # Make sure the state is valid, otherwise there `refresh_observation`\\n # and `_initialize_observation_space` are probably inconsistent.\\n try:\\n obs: ObsT = cast(ObsT, self._get_clipped_env_observation())\\n except (TypeError, ValueError) as e:\\n raise RuntimeError(\\n \\\"The observation computed by `refresh_observation` is \\\"\\n \\\"inconsistent with the observation space defined by \\\"\\n \\\"`_initialize_observation_space` at initialization.\\\") from e\\n\\n # Make sure there is no 'nan' value in observation\\n for value in tree.flatten(obs):\\n if np.isnan(value).any():\\n raise RuntimeError(\\n f\\\"'nan' value found in observation ({obs}). Something \\\"\\n \\\"went wrong with `refresh_observation` method.\\\")\\n\\n # The simulation cannot be done before doing a single step.\\n if any(self.has_terminated()):\\n raise RuntimeError(\\n \\\"The simulation has already terminated at `reset`. Check the \\\"\\n \\\"implementation of `has_terminated` if overloaded.\\\")\\n\\n # Reset cumulative reward\\n self.total_reward = 0.0\\n\\n # Note that the viewer must be reset if available, otherwise it would\\n # keep using the old robot model for display, which must be avoided.\\n if self.simulator.is_viewer_available:\\n self.simulator.viewer._setup(self.robot)\\n if self.simulator.viewer.has_gui():\\n self.simulator.viewer.refresh()\\n\\n return obs, deepcopy(self._info)\",\n \"def reset(self, **kwargs):\\r\\n if self.was_real_done:\\r\\n obs = self.env.reset(**kwargs)\\r\\n else:\\r\\n # no-op step to advance from terminal/lost life state\\r\\n obs, _, _, _ = self.env.step(0)\\r\\n self.lives = self.env.unwrapped.ale.lives()\\r\\n return obs\",\n \"def reset(self):\\n \\n self.steps = 0\\n if self.episode == 0:\\n self.ins = random.uniform(self.mins.values[:4],self.maxes.values[:4])\\n #get the corresponding outputs:\\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\\n out_temp = self.temp_func(var=self.O_t)\\n\\n outs = np.array([out_flow,out_frac,out_temp])\\n self.starts = np.append(self.ins, outs)\\n\\n else:\\n self.starts = self.state[:7] #previous episode's end state\\n\\n #get goals from random inputs:\\n viable = False\\n while viable == False:\\n self.ins = random.uniform((self.mins.values[:4]+(self.mins.values[:4]*self.minmaxbuffer)),self.maxes.values[:4]-(self.maxes.values[:4]*self.minmaxbuffer))\\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\\n out_temp = self.temp_func(var=self.O_t)\\n\\n outs = np.array([out_flow,out_frac,out_temp])\\n \\n # Check if viable:\\n viable = self.test_viable(outs)\\n\\n self.goals = outs\\n\\n # These are your current inputs:\\n self.ins = self.starts[:4]\\n # State carries the starting points and the goals.\\n self.state = np.append(self.starts,self.goals)\\n\\n #Track episodes and total reward.\\n self.episode += 1\\n self.tot_rew = 0\\n\\n return (self.state)\",\n \"def reset(self):\\n error_estop = \\\"\\\"\\\"\\\\\\nE-Stop is ASSERTED. Disengage E-Stop and then reset the robot.\\n\\\"\\\"\\\"\\n error_nonfatal = \\\"\\\"\\\"Non-fatal Robot Error on reset.\\nRobot reset cleared stopped state and robot can be enabled, but a non-fatal\\nerror persists. Check diagnostics or rethink.log for more info.\\n\\\"\\\"\\\"\\n error_env = \\\"\\\"\\\"Failed to reset robot.\\nPlease verify that the ROS_IP or ROS_HOSTNAME environment variables are set\\nand resolvable. For more information please visit:\\nhttp://sdk.rethinkrobotics.com/wiki/RSDK_Shell#Initialize\\n\\\"\\\"\\\"\\n is_reset = lambda: (self._state.enabled == False and\\n self._state.stopped == False and\\n self._state.error == False and\\n self._state.estop_button == 0 and\\n self._state.estop_source == 0)\\n pub = rospy.Publisher('robot/set_super_reset', Empty, queue_size=10)\\n\\n if (self._state.stopped and\\n self._state.estop_button == AssemblyState.ESTOP_BUTTON_PRESSED):\\n rospy.logfatal(error_estop)\\n raise IOError(errno.EREMOTEIO, \\\"Failed to Reset: E-Stop Engaged\\\")\\n\\n rospy.loginfo(\\\"Resetting robot...\\\")\\n try:\\n baxter_dataflow.wait_for(\\n test=is_reset,\\n timeout=3.0,\\n timeout_msg=error_env,\\n body=pub.publish\\n )\\n except OSError as e:\\n if e.errno == errno.ETIMEDOUT:\\n if self._state.error == True and self._state.stopped == False:\\n rospy.logwarn(error_nonfatal)\\n return False\\n raise\",\n \"def reset(self):\\n # Reset time counter\\n self.t = 0\\n\\n # Reset randomization\\n self.randomization.reset()\\n\\n # Randomize parameters.\\n self.parameters = self.randomization.parameter_randomizer.randomize(\\n self.parameters, self._random_state\\n )\\n\\n self._reset()\\n\\n # Randomize simulation. Because sim is recreated in self._reset(),\\n # simulation_randomizer.randomize should be called after the _reset.\\n self.randomization.simulation_randomizer.randomize(\\n self.mujoco_simulation.mj_sim, self._random_state\\n )\\n\\n # reset observer.\\n self.observer.reset()\\n\\n # Reset multi goal tracker for a new episode.\\n self.multi_goal_tracker.reset()\\n\\n # Reset state of goal generation.\\n return self.reset_goal_generation(sync_type=SyncType.RESET)\",\n \"def _initialize_episode(self, agent_type='active'):\\n initial_observation = self._environment.reset()\\n return self._agent.begin_episode(agent_type, initial_observation)\",\n \"def reset(self):\\n Simulation.reset(self)\",\n \"def reset_world():\\n __switch_ctrl.call(start_controllers=[],\\n stop_controllers=[\\\"hand_position_trajectory_controller\\\", \\\"arm_position_trajectory_controller\\\", \\\"joint_state_controller\\\"],\\n strictness=SwitchControllerRequest.BEST_EFFORT)\\n __pause_physics.call()\\n\\n joint_names = ['j1', 'j2', 'j3', 'j4', 'j5', 'flange','H1_F1J1', 'H1_F1J2',\\n 'H1_F1J3', 'H1_F2J1', 'H1_F2J2', 'H1_F2J3','H1_F3J1', 'H1_F3J2', 'H1_F3J3']\\n joint_positions = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] \\n\\n __set_model.call(model_name=\\\"denso\\\",\\n urdf_param_name=\\\"robot_description\\\",\\n joint_names=joint_names,\\n joint_positions=joint_positions)\\n\\n timer = Timer(0.0, __start_ctrl)\\n timer.start()\\n\\n time.sleep(0.1)\\n __unpause_physics.call()\\n\\n #__reset_world.call()\\n spawn_extras()\",\n \"def setup_method(cls):\\n seed()\",\n \"def _reset(self, env_id: np.ndarray) -> None:\",\n \"def reset():\\n _runtime.reset()\",\n \"def reset(\\n self,\\n seed: int | None = None,\\n options: dict | None = None,\\n ) -> None:\\n raise NotImplementedError\",\n \"def setUp(self) -> None:\\n self.random = np.random.RandomState(seed=42)\",\n \"def reset(self):\\n if self._draw_new_turn_on_reset:\\n turn_params = self._draw_random_turn_params()\\n config = AisleTurnEnvParams(turn_params=turn_params, env_params=self._env_params)\\n self._env = AisleTurnEnv(config)\\n\\n return self._env.reset()\",\n \"def reset(self):\\r\\n # reset Wheel encoders\\r\\n self.start_time = time.time()\\r\\n [left_start, right_start] = self.Roomba.Query(43, 44)\\r\\n self.Motion.reset(left_start, right_start)\\r\\n # reset bumper\\r\\n self.bumper.reset()\\r\\n\\r\\n #reset grid world data\\r\\n self.action=[0.0,0.0]\\r\\n self.grid_state= [0,0,0]\\r\\n self.real_state = [0.0, 0.0, 0.0]\\r\\n self.trans_model = None\\r\\n pass\",\n \"def reset(self,\\n *,\\n seed: Optional[int] = None,\\n options: Optional[dict] = None,\\n ) -> Tuple[Observation, dict]:\\n super().reset(seed=seed, options=options)\\n if options and \\\"config\\\" in options:\\n self.configure(options[\\\"config\\\"])\\n self.update_metadata()\\n self.define_spaces() # First, to set the controlled vehicle class depending on action space\\n self.time = self.steps = 0\\n self.done = False\\n self._reset()\\n self.define_spaces() # Second, to link the obs and actions to the vehicles once the scene is created\\n obs = self.observation_type.observe()\\n info = self._info(obs, action=self.action_space.sample())\\n if self.render_mode == 'human':\\n self.render()\\n return obs, info\",\n \"def reset(self):\\n self.num_steps = 0\\n self.world_state = self.action = None\",\n \"def set_env(self, env):\\n\\n self.env = env\\n self.sim_env = copy.deepcopy(self.env)\\n self.sim_env.reset_at_episode_end = False # Avoids expensive re-sampling of jets every time we parse a path\\n self.init_episode()\",\n \"def reset(self, **kwargs):\\n\\n # on a reset we set the health back to 120\\n self.player_hp = 120\\n self.enemy_hp = 120\\n\\n # reset the environment\\n \\n observation = self.env.reset(**kwargs)\\n\\n # we restarted inc the number\\n self.num_resets += 1\\n\\n # the observation\\n obs = self.observation(observation)\\n self.current_frame_number = 0\\n \\n # fill up the queue\\n for i in range(4):\\n self.q.append(obs)\\n \\n return np.array(list(self.q))\",\n \"def reset(self):\\n self.success = False\\n self.i = 0\\n if self.monitor:\\n self.env = gym.wrappers.Monitor(self.env, \\\"./mountaincar-monitor\\\", force=True)\\n state = self.env.reset()\\n state = self.preprocess_state(state)\\n state = np.concatenate([state] * self.action_repeat)\\n return state\",\n \"def reset(ctx, with_testdb):\\n ctx.invoke(init, with_testdb=with_testdb)\\n ctx.invoke(seed)\\n\\n return None\",\n \"def reset(ctx, with_testdb):\\n ctx.invoke(init, with_testdb=with_testdb)\\n ctx.invoke(seed)\\n\\n return None\",\n \"def reset(self, observation, target_pos, ground_truth):\\n if len(self.episode_starts) == 0 or self.episode_starts[-1] is False:\\n self.episode_idx += 1\\n\\n if self.learn_states and (self.episode_idx + 1) % self.learn_every == 0 and self.n_steps <= self.max_steps:\\n print(\\\"Learning a state representation ...\\\")\\n start_time = time.time()\\n ok, self.srl_model_path = self.socket_client.waitForSRLModel(self.state_dim)\\n print(\\\"Took {:.2f}s\\\".format(time.time() - start_time))\\n\\n self.episode_step = 0\\n self.episode_success = False\\n self.episode_folder = \\\"record_{:03d}\\\".format(self.episode_idx)\\n os.makedirs(\\\"{}/{}\\\".format(self.data_folder, self.episode_folder), exist_ok=True)\\n\\n self.episode_starts.append(True)\\n self.target_positions.append(target_pos)\\n self.ground_truth_states.append(ground_truth)\\n self.saveImage(observation)\",\n \"def reset(self):\\n self.sim.reset()\\n # state = np.concatenate([self.sim.pose] * self.action_repeat) \\n state = self.sim.pose\\n return state\",\n \"def set_seed(self, seed: int):\\n self.rsimulator.set_seed(seed)\\n # Maybe call new game here?\",\n \"def reset(self):\\r\\n pg.event.clear()\\r\\n self.stop_powerpellet()\\r\\n if not self.eaten:\\r\\n self.dot_counter = 0\\r\\n self.eaten = False\\r\\n self.eat_ghost = False\\r\\n self.reset_energizer_flag()\\r\\n self.last_dir = self.direction = 'l'\\r\\n self.count_eaten_ghost = 200\\r\\n self.pos = list(self.start_pos)[:]\\r\\n self.global_counter = 0\\r\\n self.hourglass_counter = 0\",\n \"def restart(self):\\n self.set_random_pos('starting')\\n self.set_random_pos('finishing')\\n self.game_loop()\",\n \"def reset():\\n Vessel.reset_instances()\",\n \"def reset(self,new_tgt_pos=None):\\n self.sim.reset()\\n state = np.concatenate([self.sim.pose] * self.action_repeat) \\n if new_tgt_pos is not None:\\n self.target_pos = new_tgt_pos \\n return state\",\n \"def reset_env(\\n self, key: chex.PRNGKey, params: EnvParams\\n ) -> Tuple[chex.Array, EnvState]:\\n # Always start with no stock\\n # # By defauly, we start on a random weekday\\n # Otherwise, with fixed burn-in, would always\\n # count return from same weekday\\n weekday = jax.lax.cond(\\n params.initial_weekday == -1,\\n lambda _: jax.random.randint(key, (), 0, 7, dtype=jnp_int),\\n lambda _: params.initial_weekday.astype(jnp_int),\\n None,\\n )\\n\\n state = EnvState(\\n weekday=weekday,\\n stock=self.initial_stock,\\n step=0,\\n )\\n return self.get_obs(state), state\",\n \"def reset(self):\\n self.cur_step = 0\\n self.cur_episode += 1\\n self.cur_state = 0 # Always start with fixed state\\n self.action_episode_memory.append([])\\n self.observation_episode_memory.append([])\\n self.reward_episode_memory.append([])\\n obs = self._get_obs()\\n return obs\",\n \"def set_global_seeds(seed):\\n \\n torch.manual_seed(seed)\\n np.random.seed(seed)\\n random.seed(seed)\",\n \"def reset(self):\\n self.sim.reset()\\n state = np.concatenate([self.sim.pose] * self.action_repeat) \\n return state\",\n \"def reset(self):\\n self.sim.reset()\\n state = np.concatenate([self.sim.pose] * self.action_repeat) \\n return state\",\n \"def reset(self):\\n self.sim.reset()\\n state = np.concatenate([self.sim.pose] * self.action_repeat) \\n return state\",\n \"def reset(self, normalized_state, state):\\n # self.episode_starts.append(True)\\n self.normalized_states.append(normalized_state)\\n self.states.append(np.squeeze(state))\",\n \"def reset_env(\\n self, key: chex.PRNGKey, params: EnvParams\\n ) -> Tuple[chex.Array, EnvState]:\\n # Always start with no stock\\n # # By defauly, we start on a random weekday\\n # Otherwise, with fixed burn-in, would always\\n # count return from same weekday\\n weekday = jax.lax.cond(\\n params.initial_weekday == -1,\\n lambda _: jax.random.randint(key, (), 0, 7, dtype=jnp_int),\\n lambda _: params.initial_weekday.astype(jnp_int),\\n None,\\n )\\n\\n state = EnvState(\\n weekday=weekday,\\n stock=jnp.zeros(self.max_useful_life - 1, dtype=jnp_int),\\n step=0,\\n )\\n return self.get_obs(state), state\",\n \"def reset(self):\\n print('call reset()')\\n self.cur = 0\\n if self.shuffle:\\n random.shuffle(self.seq)\",\n \"def reset(self):\\n self.sim.reset()\\n self.takeoff = False\\n self.success = False\\n state = np.concatenate([self.sim.pose] * self.action_repeat)\\n return state\",\n \"def reset(self, x=0.2, y=0.2):\\n\\n # Reset the environment (start a new episode)\\n self.y = y\\n self.x = x\\n self.theta = 90\\n self.theta = math.radians(self.theta)\\n self.steps = 0\\n self.index = 0\\n self.farthest = -1\\n self.laps = 0\\n\\n # add noise to position and theta\\n # self.x_noise = self.x + np.random.normal(self.mu, self.sigmaxy, 1)\\n # self.y_noise = self.y + np.random.normal(self.mu, self.sigmaxy, 1)\\n # self.theta_noise = self.theta + np.random.normal(self.mu,\\n # self.sigmaangle, 1)\\n\\n self._distance_next()\\n self._calc_delta_theta()\\n\\n if self.discrete_input:\\n # discretize state for the agent to control\\n\\n discrete_distance, discrete_delta_theta \\\\\\n = self._discretize_agent_state(self.distance, self.delta_theta)\\n\\n self.agent_state = np.array([discrete_distance,\\n discrete_delta_theta])\\n\\n else:\\n # self.agent_state has to be a matrix to be accepted by keras\\n self.agent_state = np.array([self.distance, self.delta_theta])\\n\\n # Create state (x,y,theta)\\n self.state = [self.x, self.y, self.theta]\\n\\n return self.state, self.agent_state\",\n \"def episode_init(self):\\n self.nsteps = 0\\n self.action = None\\n self.state = None\\n self.reward = None\\n self.terminal = None\\n self.total_reward = 0.0\",\n \"def rngreset(seed=0):\\n random.seed(seed)\\n np.random.seed(seed)\\n torch.manual_seed(seed)\\n torch.cuda.manual_seed(seed)\\n torch.backends.cudnn.deterministic = True\",\n \"def reset(self):\\n self.noise = [0.] * 6\\n self.state = [0.0] * 9\\n self.q = [0.0, 0.0, 0.0, 1.0]\\n self.terminal = False\\n self.steps = 0\\n # Return current state and error\\n return self.observation, self.error\",\n \"def reset(self, *args):\\n self.state = GameStates.playing\\n self.human = evilrps.Player('Human', self.get_player_choice)\\n self.ai = evilrps.Player('AI', evilrps.create_ai())\\n self.game = evilrps.Game(self.human, self.ai)\",\n \"def reset_target(scope) -> None:\\n if globals.cw_platform == \\\"CW303\\\" or globals.cw_platform == \\\"CWLITEXMEGA\\\":\\n scope.io.pdic = 'low'\\n time.sleep(0.1)\\n scope.io.pdic = 'high_z' #XMEGA doesn't like pdic driven high\\n time.sleep(0.1) #xmega needs more startup time\\n else: \\n scope.io.nrst = 'low'\\n time.sleep(0.05)\\n scope.io.nrst = 'high_z'\\n time.sleep(0.05)\",\n \"def reset(self):\\n\\n logger.info('Removed existing OpenMM engine.')\\n self._simulation = None\",\n \"def reset(self):\\n\\n self.speed = self.getRandomVelocity()\\n self.setX(Configuration.windowWidth / 2)\\n self.setY(Configuration.windowHeight / 2)\",\n \"def reset(self, **kwargs):\\n self.env.reset(**kwargs)\\n if self.override_num_noops is not None:\\n noops = self.override_num_noops\\n else:\\n noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101\\n assert noops > 0\\n obs = None\\n for _ in range(noops):\\n obs, _, done, _ = self.env.step(self.noop_action)\\n if done:\\n obs = self.env.reset(**kwargs)\\n return obs\",\n \"def reset(self):\\r\\n self.x = self.initX\\r\\n self.y = self.initY\\r\\n self.dir= self.initDir\",\n \"def set_global(self):\\n random.setstate(self.py)\\n np.random.set_state(self.np)\\n torch.set_rng_state(self.torch)\",\n \"def run(self, seed=None):\\n if seed is not None:\\n random_seed.set_seed(seed)\\n self.reset()\",\n \"def reset(self):\\n # self state is velocity, observation is velocity\\n # self._state = np.random.uniform(0, self.GOAL_VELOCITY, size=(self.num_cars,))\\n # print(\\\"In reset function\\\", self.initialized)\\n if self.initialized:\\n traci.close()\\n sumoProcess = subprocess.Popen([self.sumoBinary, \\\"-c\\\", self.cfgfn, \\\"--remote-port\\\", str(self.PORT)], stdout=sys.stdout, stderr=sys.stderr)\\n traci.init(self.PORT)\\n traci.simulationStep()\\n if not self.initialized:\\n self.vehIDs = traci.vehicle.getIDList()\\n print(\\\"ID List in reset\\\", self.vehIDs)\\n self.initialized = True\\n self._state = np.array([traci.vehicle.getSpeed(vID) for vID in self.controllable])\\n observation = np.copy(self._state)\\n return observation\",\n \"def prepare_for_use(self):\\n self._random_state = check_random_state(self.random_state)\\n self._offset = self.offset\\n self._x_idx = 0\",\n \"def prepare_for_use(self):\\n self._random_state = check_random_state(self.random_state)\\n self._offset = self.offset\\n self._x_idx = 0\",\n \"def prepare_for_use(self):\\n self._random_state = check_random_state(self.random_state)\\n self._offset = self.offset\\n self._x_idx = 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66944516","0.6647286","0.65143913","0.6312656","0.6290814","0.62830704","0.6277763","0.62062037","0.61978877","0.6173854","0.61685586","0.61399466","0.613353","0.61265284","0.6108667","0.6104944","0.60824627","0.60824627","0.6075161","0.6065723","0.60425687","0.6032285","0.60291636","0.5983385","0.59776616","0.59693563","0.5967431","0.59631056","0.5941566","0.59100235","0.59031326","0.5889999","0.58571434","0.5834076","0.5827408","0.58233976","0.5819535","0.5818656","0.5816387","0.58091414","0.58091414","0.58091414","0.58091414","0.58091414","0.58091414","0.5802788","0.5790347","0.57829505","0.57786286","0.5775214","0.5759442","0.57378894","0.57274944","0.5725739","0.5724762","0.57218033","0.5715117","0.5706373","0.5705369","0.5670608","0.5656151","0.565257","0.56498444","0.56152123","0.5615158","0.56119424","0.56119424","0.56109786","0.5604719","0.56042117","0.55915916","0.5576077","0.55697566","0.5541169","0.55348796","0.5534629","0.55342895","0.55336565","0.55336565","0.55336565","0.5519929","0.5498642","0.5496687","0.5492959","0.54808027","0.5479382","0.5471577","0.5469426","0.54681575","0.54511786","0.5443704","0.54357016","0.54257953","0.54227257","0.5421158","0.5420466","0.5412168","0.541078","0.541078","0.541078"],"string":"[\n \"0.66944516\",\n \"0.6647286\",\n \"0.65143913\",\n \"0.6312656\",\n \"0.6290814\",\n \"0.62830704\",\n \"0.6277763\",\n \"0.62062037\",\n \"0.61978877\",\n \"0.6173854\",\n \"0.61685586\",\n \"0.61399466\",\n \"0.613353\",\n \"0.61265284\",\n \"0.6108667\",\n \"0.6104944\",\n \"0.60824627\",\n \"0.60824627\",\n \"0.6075161\",\n \"0.6065723\",\n \"0.60425687\",\n \"0.6032285\",\n \"0.60291636\",\n \"0.5983385\",\n \"0.59776616\",\n \"0.59693563\",\n \"0.5967431\",\n \"0.59631056\",\n \"0.5941566\",\n \"0.59100235\",\n \"0.59031326\",\n \"0.5889999\",\n \"0.58571434\",\n \"0.5834076\",\n \"0.5827408\",\n \"0.58233976\",\n \"0.5819535\",\n \"0.5818656\",\n \"0.5816387\",\n \"0.58091414\",\n \"0.58091414\",\n \"0.58091414\",\n \"0.58091414\",\n \"0.58091414\",\n \"0.58091414\",\n \"0.5802788\",\n \"0.5790347\",\n \"0.57829505\",\n \"0.57786286\",\n \"0.5775214\",\n \"0.5759442\",\n \"0.57378894\",\n \"0.57274944\",\n \"0.5725739\",\n \"0.5724762\",\n \"0.57218033\",\n \"0.5715117\",\n \"0.5706373\",\n \"0.5705369\",\n \"0.5670608\",\n \"0.5656151\",\n \"0.565257\",\n \"0.56498444\",\n \"0.56152123\",\n \"0.5615158\",\n \"0.56119424\",\n \"0.56119424\",\n \"0.56109786\",\n \"0.5604719\",\n \"0.56042117\",\n \"0.55915916\",\n \"0.5576077\",\n \"0.55697566\",\n \"0.5541169\",\n \"0.55348796\",\n \"0.5534629\",\n \"0.55342895\",\n \"0.55336565\",\n \"0.55336565\",\n \"0.55336565\",\n \"0.5519929\",\n \"0.5498642\",\n \"0.5496687\",\n \"0.5492959\",\n \"0.54808027\",\n \"0.5479382\",\n \"0.5471577\",\n \"0.5469426\",\n \"0.54681575\",\n \"0.54511786\",\n \"0.5443704\",\n \"0.54357016\",\n \"0.54257953\",\n \"0.54227257\",\n \"0.5421158\",\n \"0.5420466\",\n \"0.5412168\",\n \"0.541078\",\n \"0.541078\",\n \"0.541078\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6798604"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":581,"cells":{"query":{"kind":"string","value":"Render the environment serverside"},"document":{"kind":"string","value":"def render(self, mode=\"human\", close=False):\n if close and self._viewer is None:\n if self._viewer is not None:\n self._viewer.close()\n self._viewer = None\n return\n\n screen_width = 600\n screen_height = 600\n if self._viewer is None:\n from gym.envs.classic_control import rendering\n self._viewer = rendering.Viewer(screen_width, screen_height)\n\n # generate the grid\n xs, self._xstep = np.linspace(\n 0, screen_width, self._width + 1, retstep=True)\n ys, self._ystep = np.linspace(\n 0, screen_height, self._height + 1, retstep=True)\n\n # render the grid\n for x in xrange(self._width):\n for y in xrange(self._height):\n l, r, t, b = (0, self._xstep, self._ystep, 0)\n tile = rendering.FilledPolygon([\n (l, b), (l, t), (r, t), (r, b)])\n tile.add_attr(rendering.Transform(translation=(\n x * self._xstep, y * self._ystep)))\n tile.set_color(*CASE_COLORS[chr(self._grid[x, y])])\n self._viewer.add_geom(tile)\n\n # render starting point\n l, r, t, b = (0, self._xstep, self._ystep, 0)\n tile = rendering.FilledPolygon([\n (l, b), (l, t), (r, t), (r, b)])\n tile.add_attr(rendering.Transform(translation=(\n self._trajectory[0][0] * self._xstep,\n self._trajectory[0][1] * self._ystep)))\n tile.set_color(0, 1.0, 1.0)\n self._viewer.add_geom(tile)\n\n # render grid lines\n for x in xs[1:len(xs) - 1]:\n # not including the first and last one\n line = rendering.Line((x, 0), (x, screen_height))\n self._viewer.add_geom(line)\n for y in ys[1: len(ys) - 1]:\n line = rendering.Line((0, y), (screen_width, y))\n self._viewer.add_geom(line)\n\n agent = rendering.make_circle(\n radius=min(\n screen_width / (self._width + 1) / 3,\n screen_height / (self._height + 1) / 3),\n res=30)\n self._agentTrans = rendering.Transform(translation=(\n self._currentPos[0] * self._xstep + (self._xstep / 2),\n self._currentPos[1] * self._ystep + (self._ystep / 2)))\n agent.add_attr(self._agentTrans)\n self._viewer.add_geom(agent)\n\n self._renderTrajectory()\n\n self._agentTrans.set_translation(\n self._currentPos[0] * self._xstep + (self._xstep / 2),\n self._currentPos[1] * self._ystep + (self._ystep / 2))\n\n self._viewer.render(return_rgb_array=(mode == 'rgb_array'))\n\n if close:\n if self._viewer is not None:\n self._viewer.close()\n self._viewer = None\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 render(self):\n self.env.render()","def render(self):\n self.rendering = True\n self.env.render()","def render(self, mode='human'):\n return self._env.render(mode)","def _serve_environment(self, request):\n return http_util.Respond(\n request,\n {\n 'data_location': self._logdir or self._db_uri,\n 'window_title': self._window_title,\n },\n 'application/json')","def serve(self) -> str:\n return self._render()","def render(self, mode='human'):\n\n if self.RENDER_ENV_ONLY:\n SCREEN_W = 600\n SCREEN_H = 600\n \n if self.viewer is None:\n from gym.envs.classic_control import rendering\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\n\n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=np.array([120, 120, 120])/255.0)\n bezel = 10\n \n self._env_render(self.get_full_state,\n [bezel, bezel], [SCREEN_W-2*bezel, SCREEN_H-2*bezel])\n self._agent_render(self.get_full_state,\n [bezel, bezel], [SCREEN_W-2*bezel, SCREEN_H-2*bezel])\n return self.viewer.render(return_rgb_array = mode=='rgb_array')\n\n if (self.RENDER_INDIV_MEMORY == True and self.INDIV_MEMORY == \"fog\") or (self.RENDER_TEAM_MEMORY == True and self.TEAM_MEMORY == \"fog\"):\n SCREEN_W = 1200\n SCREEN_H = 600\n\n if self.viewer is None:\n from gym.envs.classic_control import rendering\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\n \n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=(0, 0, 0))\n\n self._env_render(self._static_map,\n [7, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\n self._env_render(self.get_obs_blue_render,\n [7+1.49*SCREEN_H//3, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\n self._env_render(self.get_obs_red_render,\n [7+1.49*SCREEN_H//3, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\n self._env_render(self.get_full_state,\n [7, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\n\n # ind blue agent memory rendering\n for num_blue, blue_agent in enumerate(self._team_blue):\n if num_blue < 2:\n blue_agent.INDIV_MEMORY = self.INDIV_MEMORY\n if blue_agent.INDIV_MEMORY == \"fog\" and self.RENDER_INDIV_MEMORY == True:\n self._env_render(blue_agent.get_obs(self),\n [900+num_blue*SCREEN_H//4, 7], [SCREEN_H//4-10, SCREEN_H//4-10])\n else:\n blue_agent.INDIV_MEMORY = self.INDIV_MEMORY\n if blue_agent.INDIV_MEMORY == \"fog\" and self.RENDER_INDIV_MEMORY == True:\n self._env_render(blue_agent.get_obs(self),\n [900+(num_blue-2)*SCREEN_H//4, 7+SCREEN_H//4], [SCREEN_H//4-10, SCREEN_H//4-10])\n\n # ind red agent memory rendering\n for num_red, red_agent in enumerate(self._team_red):\n if num_red < 2:\n red_agent.INDIV_MEMORY = self.INDIV_MEMORY\n if red_agent.INDIV_MEMORY == \"fog\" and self.RENDER_INDIV_MEMORY == True:\n self._env_render(red_agent.get_obs(self),\n [900+num_red*SCREEN_H//4, 7+1.49*SCREEN_H//2], [SCREEN_H//4-10, SCREEN_H//4-10])\n \n else:\n red_agent.INDIV_MEMORY = self.INDIV_MEMORY\n if red_agent.INDIV_MEMORY == \"fog\" and self.RENDER_INDIV_MEMORY == True:\n self._env_render(red_agent.get_obs(self),\n [900+(num_red-2)*SCREEN_H//4, 7+SCREEN_H//2], [SCREEN_H//4-10, SCREEN_H//4-10])\n\n if self.TEAM_MEMORY == \"fog\" and self.RENDER_TEAM_MEMORY == True:\n # blue team memory rendering\n blue_visited = np.copy(self._static_map)\n blue_visited[self.blue_memory] = UNKNOWN\n self._env_render(blue_visited,\n [7+2.98*SCREEN_H//3, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\n\n # red team memory rendering \n red_visited = np.copy(self._static_map)\n red_visited[self.red_memory] = UNKNOWN\n self._env_render(red_visited,\n [7+2.98*SCREEN_H//3, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\n else:\n SCREEN_W = 600\n SCREEN_H = 600\n \n if self.viewer is None:\n from gym.envs.classic_control import rendering\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\n\n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=(0, 0, 0))\n \n self._env_render(self._static_map,\n [5, 10], [SCREEN_W//2-10, SCREEN_H//2-10])\n self._env_render(self.get_obs_blue_render,\n [5+SCREEN_W//2, 10], [SCREEN_W//2-10, SCREEN_H//2-10])\n self._agent_render(self.get_full_state,\n [5+SCREEN_W//2, 10], [SCREEN_W//2-10, SCREEN_H//2-10], self._team_blue)\n self._env_render(self.get_obs_red_render,\n [5+SCREEN_W//2, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\n self._env_render(self.get_full_state,\n [5, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\n self._agent_render(self.get_full_state,\n [5, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\n\n if self.SILENCE_RENDER:\n return self.viewer.get_array()\n else:\n return self.viewer.render(return_rgb_array = mode=='rgb_array')","def serve_vue_app():\n return(render_template('index.html'))","def render(self):\n self.env.render()\n #input(\"Press enter to take a step \")","def display():\n\n #still needs some cleanup on imagry and what the site is about. \n\n return render_template(\"index.html\")","def main():\n return render_template('index.html')","def main():\n return render_template('index.html')","def entry_point():\n return render_template(\"index.html\")","def run():\n return render_template('index.html')","def server(request):\n return render_to_response(\n 'server/index.html', {\n 'user_url': getViewURL(request, idPage),\n 'server_xrds_url': getViewURL(request, idpXrds),\n },\n context_instance=RequestContext(request))","def browser():\n return flask.render_template('browser.html')","def frontend(request: HttpRequest) -> HttpResponse:\n return render(request, \"frontend/base.html\", {})","def render(env_type):\n _setup_env()\n\n # Activate local virtual environment (for render_templates+flask?)\n local('. %s' % env.activate_path)\n\n if not os.path.exists(env.s3cmd_cfg):\n abort(\"Could not find 's3cmd.cfg' repository at '%(s3cmd_cfg)s'.\")\n\n if not env_type in _config['deploy']:\n abort('Could not find \"%s\" in \"deploy\" in config file' % env_type)\n\n if not \"bucket\" in _config['deploy'][env_type]:\n abort('Could not find \"bucket\" in deploy.%s\" in config file' % env_type)\n\n if 'usemin_context' in _config['deploy'][env_type]:\n usemin_context = _config['deploy'][env_type]['usemin_context']\n else:\n usemin_context = None\n\n template_path = join(_config['project_path'], 'website', 'templates')\n deploy_path = join(_config['project_path'], 'build', 'website')\n\n clean(deploy_path)\n\n # Render templates and run usemin\n if 'deploy_context' in _config['deploy'][env_type]:\n deploy_context = _config['deploy'][env_type]['deploy_context']\n else:\n deploy_context = {}\n\n # Sometimes we need this path append to import app from website\n # in render_templates, dunno why:\n sys.path.append(_config['project_path'])\n\n static.render_templates(template_path, deploy_path, deploy_context)\n static.usemin(_config, [deploy_path], usemin_context)\n\n # Copy static files\n static.copy(_config, [{\n \"src\": join(_config['project_path'], 'website', 'static'),\n \"dst\": join(deploy_path, 'static')\n }])\n\n # Additional copy?\n if 'copy' in _config['deploy'][env_type]:\n static.copy(_config, _config['deploy'][env_type]['copy'])","def main():\n return render_template(\"main.html\")","def main():\n return render_template(\"main.html\")","def home(environ):\n return render_template(template_name=\"index.html\", context={})","def main():\r\n return render_template(\"UI.html\")","def render(trin, config, args):\n\n from forge.embyr.twistedserver import Application\n sword = trin.sword.remote(trin, config, args, idx=0)\n env = sword.getEnv.remote()\n Application(env, sword.tick.remote)","def dashboard_render(self,servers):\n THIS_DIR = os.path.dirname(os.path.abspath(__file__))\n j2_env = Environment(loader=FileSystemLoader(THIS_DIR),\n trim_blocks=True)\n new_dashboard = (j2_env.get_template('templating_dashboard.json').render(\n list_templating=self.templating(servers)\n ))\n return (new_dashboard)","def get(self):\n self.render(\"index.html\")","def render_env(self):\n return {\n jinja2.Template(k).render({self.name: self}):\n jinja2.Template(v).render({self.name: self})\n for k, v in self.env.items()\n } if self.env else self.env","def index():\n return render_template('home.jinja2')","def main():\n\n return render_template(\"index.html\", title=\"Home\", heading=\"Dublin Bus\")","def get(self):\n template = Constants.JINJA_ENVIRONMENT.get_template('homepage.html')\n self.response.headers['Content-Type'] = 'text/html'\n self.response.write(template.render())","def get(self):\n self.render(\n \"index.html\",\n )","def index():\n return render_template(\"main.html\")","def get(self):\n # this trick allows us to return the correct image url, even in docker\n global _host\n _host = self.request.host\n _logger.debug(\"setting hostname to {0}\".format(_host))\n env = Environment(loader=FileSystemLoader('templates'))\n template = env.get_template('embed.html')\n script = server_document('http://{0}/bkapp'.format(_host))\n self.set_status(200)\n self.write(template.render(script=script, template=\"Tornado\"))\n self.finish()","def get(self):\n self.render('index.html')\n return","def test():\n\n print \"SERVER IS RUNNING\"\n\n\n return render_template(\"statemap.html\")\n # return render_template(\"testworld.html\")","def index():\n return render_template('main.html')","def index():\n return render_template('main.html')","def index():\n global realsense_enabled\n return render_template('index.html')","def index(self):\n return render_template(\"{0}/index.html\".format(self.__APP_DIR__))","def Home():\n resp = render_template('index.html')\n return resp","def root():\n return render_template('index.html')","def root():\n return render_template('index.html')","def root():\n return render_template('index.html')","def start(response, input={}):\n try: host = socket.gethostname()\n except AttributeError:\n if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST']\n else: host = os.environ['SERVER_NAME']\n template = LazyDict({'version': getversion(), 'host': host, 'color': Config().color or \"#C54848\"})\n if input: template.update(input)\n temp = os.path.join(os.getcwd(), 'templates/console.html')\n outstr = template.render(temp)\n response.out.write(outstr)","def main():\n access_token = get_access_token()\n\n return render_template('index.html', ACCESS_TOKEN=access_token)","def home():\n stocks = preprocess()\n\n return render_template(\"main.html\",stocks=stocks)","def createBasicRenderSetup():\n\n pass","def index():\n with app.app_context():\n return render_template(\"public/index.html\")","def get_root():\r\n return render_template(\"index.html\"), 200","def get(self):\n self.render('view.html')","def front_page():\n vars = dict(request.args)\n vars.setdefault('output', vars.get('format'))\n\n key = vars.get('auth_entity')\n if key:\n vars['entity'] = ndb.Key(urlsafe=key).get()\n if vars['entity']:\n vars.setdefault('site', vars['entity'].site_name().lower())\n\n vars.update({\n silo + '_html': module.Start.button_html(\n f'/{silo}/start_auth',\n image_prefix='/oauth_dropins_static/',\n outer_classes='col-lg-2 col-sm-4 col-xs-6',\n scopes=SCOPE_OVERRIDES.get(silo, ''),\n )\n for silo, module in OAUTHS.items()})\n\n return render_template('index.html', **vars)","def index():\n return render_template('index.html', title='PanOS Bootstrap Utility')","def setupRender():\n prefs = getPreferences()\n\n # Check of the built-in environment maps path can be located.\n # Discontinue if it cannot be found.\n envPath = prefs.path_value\n if not envPath:\n return {'WARNING'}, \"No environment images path defined\"\n\n # Discontinue if there is no output path defined.\n renderPath = outputPath()\n if not renderPath:\n return {'WARNING'}, \"The scene needs to be saved before rendering\"\n\n if prefs.image_value == 'NONE':\n return {'WARNING'}, \"No environment image defined\"\n\n setRenderSettings(os.path.join(renderPath, IMAGE_NAME))\n createCamera()\n createWorld(envPath)\n return renderPath","def hello():\n\n return render_template(\"index.html\")","def run(self) -> None:\n self._render()\n print(self.sio.getvalue())","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():\r\n return render_template('index.html')","def partaj_context(request):\n frontend_context = {\n \"assets\": {\"icons\": static(\"core/icons.svg\")},\n \"crisp_website_id\": settings.CRISP_WEBSITE_ID,\n \"csrftoken\": get_token(request),\n \"environment\": settings.ENVIRONMENT,\n \"url_admin\": reverse(\"admin:index\"),\n \"url_logout\": reverse(\"cas_ng_logout\"),\n }\n\n if settings.SENTRY_DSN:\n frontend_context[\"sentry_dsn\"] = settings.SENTRY_DSN\n\n if request.user.is_authenticated:\n frontend_context[\"token\"] = str(\n Token.objects.get_or_create(user=request.user)[0]\n )\n\n return {\"FRONTEND_CONTEXT\": json.dumps(frontend_context)}","def get(self):\n return render_template(\"index.html\")","def render_home():\r\n\treturn render_template(\"index.html\")","def root():\n return render_template('root.html')","def main_page():\n return render_template(\"index.html\")","def homepage(): \n return render_template('home/index.html',title='Welcome to SYCLIQ')\n #return render_template_string(\"Welcome to SYCLIQ\")","def show_homepage():\n\n return render_template(\"blank-slate.html\")","def index():\n # Render template\n return render_template('index.html')","def index():\n return render_template('index.html')","def get(self):\n self.response.write(view_utils.render('base.html', {}))","def render_scheudle_view(path):\n client_build_dir = 'client/build'\n if path != \"\" and os.path.exists(os.path.join(client_build_dir, path)):\n return flask.send_from_directory(client_build_dir, path)\n else:\n return flask.send_from_directory(client_build_dir, 'index.html')","def renderPage():\n return render_template(\"index.html\")","def index(request):\n return render_to_response(\n # note: this is slightly different than the labs app with \"app/app.html\" rather than the labs/labs.html\n # and we don't pass submodule name. fixme, by changing to new style with name = app_name\n settings.JS_HOME+'app.html',\n {'INDIVO_UI_APP_CSS': settings.INDIVO_UI_SERVER_BASE+'/jmvc/ui/resources/css/ui.css'}\n )","def angular_main_page():\n print(session)\n return render_template(\"/angular_main_page.html\")","def root():\n return flask.render_template('index.html')","def landing():\n return render_template('index.html', token=webview.token)","def landing():\n return render_template('index.html', token=webview.token)","def show(self):\n\t\tself.html += '<head>\\n' + self.head + '</head>\\n<body>\\n' + self.body + '</body>\\n</html>'\n\n\t\treturn self.html","def home():\n return render_template(\"d3_graph.html\")","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'app/index.html',\n {\n 'title':'Aplicacion para transpasar datos del sensor FreeStyle Libre de MongoDB a MySql',\n 'year':datetime.now().year,\n }\n )","def renderHTTP(ctx):","def __call__(self, req, res):\n if not hasattr(res, 'render'):\n res.render = Renderer(res)\n res.locals = {}\n res.render.add_engine(self)","def render(self, mode='human'):\n\n pass","def view_landing_page():\n return render_template(\"index.html\")","def index():\n \n \n return render_template('index.html')","def run_html():\n if __name__ != \"__main__\":\n app.run(debug=True)","def index():\n return render_template('index.html'), 200","def index():\n return render_template('index.html')","def index():\n return render_template('index.html')","def RenderEnv(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def landing_page():\n\n return render_template('index.html')","def index(self):\n\t\treturn render_template('index.html')","def index():\r\n return render_template('index.html')","def index():\r\n return render_template('index.html')","def index():\n\n\treturn(render_template('index.html'))","def index():\n #Getting source\n sources = get_sources()\n print(sources)\n return render_template('index.html', sources = sources)","def render(self, mode='human'):\n pass # no use in this situation","def welcome():\n return render_template(\"NFL.html\")","def index(self):\n return render_template('main/index.html')","def render(self, mode='human'):","def home():\n return render_template('main.html')","def index():\n\n return render_template(\"index.html\"), 200","def index() -> Any:\n return render_template(\"index.html\")","def setup(self):\n print(\"Inside setup\")\n self.fetch_from_db()\n # Don't assign to the function output. Assing it to the function object so that whenever we\n # do some changes to layout, it will reflect without server restarting\n app.layout = self.get_root_layout\n return app.server","def index(self, **kw):\n\n template = self.context\n request = self.request\n\n request.response.setHeader('content-type',\n template.content_type)\n\n return template.render(request, **kw)","def home():\n return render_template(\"index.html\")"],"string":"[\n \"def render(self):\\n self.env.render()\",\n \"def render(self):\\n self.rendering = True\\n self.env.render()\",\n \"def render(self, mode='human'):\\n return self._env.render(mode)\",\n \"def _serve_environment(self, request):\\n return http_util.Respond(\\n request,\\n {\\n 'data_location': self._logdir or self._db_uri,\\n 'window_title': self._window_title,\\n },\\n 'application/json')\",\n \"def serve(self) -> str:\\n return self._render()\",\n \"def render(self, mode='human'):\\n\\n if self.RENDER_ENV_ONLY:\\n SCREEN_W = 600\\n SCREEN_H = 600\\n \\n if self.viewer is None:\\n from gym.envs.classic_control import rendering\\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\\n\\n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=np.array([120, 120, 120])/255.0)\\n bezel = 10\\n \\n self._env_render(self.get_full_state,\\n [bezel, bezel], [SCREEN_W-2*bezel, SCREEN_H-2*bezel])\\n self._agent_render(self.get_full_state,\\n [bezel, bezel], [SCREEN_W-2*bezel, SCREEN_H-2*bezel])\\n return self.viewer.render(return_rgb_array = mode=='rgb_array')\\n\\n if (self.RENDER_INDIV_MEMORY == True and self.INDIV_MEMORY == \\\"fog\\\") or (self.RENDER_TEAM_MEMORY == True and self.TEAM_MEMORY == \\\"fog\\\"):\\n SCREEN_W = 1200\\n SCREEN_H = 600\\n\\n if self.viewer is None:\\n from gym.envs.classic_control import rendering\\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\\n \\n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=(0, 0, 0))\\n\\n self._env_render(self._static_map,\\n [7, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\\n self._env_render(self.get_obs_blue_render,\\n [7+1.49*SCREEN_H//3, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\\n self._env_render(self.get_obs_red_render,\\n [7+1.49*SCREEN_H//3, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\\n self._env_render(self.get_full_state,\\n [7, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\\n\\n # ind blue agent memory rendering\\n for num_blue, blue_agent in enumerate(self._team_blue):\\n if num_blue < 2:\\n blue_agent.INDIV_MEMORY = self.INDIV_MEMORY\\n if blue_agent.INDIV_MEMORY == \\\"fog\\\" and self.RENDER_INDIV_MEMORY == True:\\n self._env_render(blue_agent.get_obs(self),\\n [900+num_blue*SCREEN_H//4, 7], [SCREEN_H//4-10, SCREEN_H//4-10])\\n else:\\n blue_agent.INDIV_MEMORY = self.INDIV_MEMORY\\n if blue_agent.INDIV_MEMORY == \\\"fog\\\" and self.RENDER_INDIV_MEMORY == True:\\n self._env_render(blue_agent.get_obs(self),\\n [900+(num_blue-2)*SCREEN_H//4, 7+SCREEN_H//4], [SCREEN_H//4-10, SCREEN_H//4-10])\\n\\n # ind red agent memory rendering\\n for num_red, red_agent in enumerate(self._team_red):\\n if num_red < 2:\\n red_agent.INDIV_MEMORY = self.INDIV_MEMORY\\n if red_agent.INDIV_MEMORY == \\\"fog\\\" and self.RENDER_INDIV_MEMORY == True:\\n self._env_render(red_agent.get_obs(self),\\n [900+num_red*SCREEN_H//4, 7+1.49*SCREEN_H//2], [SCREEN_H//4-10, SCREEN_H//4-10])\\n \\n else:\\n red_agent.INDIV_MEMORY = self.INDIV_MEMORY\\n if red_agent.INDIV_MEMORY == \\\"fog\\\" and self.RENDER_INDIV_MEMORY == True:\\n self._env_render(red_agent.get_obs(self),\\n [900+(num_red-2)*SCREEN_H//4, 7+SCREEN_H//2], [SCREEN_H//4-10, SCREEN_H//4-10])\\n\\n if self.TEAM_MEMORY == \\\"fog\\\" and self.RENDER_TEAM_MEMORY == True:\\n # blue team memory rendering\\n blue_visited = np.copy(self._static_map)\\n blue_visited[self.blue_memory] = UNKNOWN\\n self._env_render(blue_visited,\\n [7+2.98*SCREEN_H//3, 7], [SCREEN_H//2-10, SCREEN_H//2-10])\\n\\n # red team memory rendering \\n red_visited = np.copy(self._static_map)\\n red_visited[self.red_memory] = UNKNOWN\\n self._env_render(red_visited,\\n [7+2.98*SCREEN_H//3, 7+1.49*SCREEN_H//3], [SCREEN_H//2-10, SCREEN_H//2-10])\\n else:\\n SCREEN_W = 600\\n SCREEN_H = 600\\n \\n if self.viewer is None:\\n from gym.envs.classic_control import rendering\\n self.viewer = rendering.Viewer(SCREEN_W, SCREEN_H)\\n self.viewer.set_bounds(0, SCREEN_W, 0, SCREEN_H)\\n\\n self.viewer.draw_polygon([(0, 0), (SCREEN_W, 0), (SCREEN_W, SCREEN_H), (0, SCREEN_H)], color=(0, 0, 0))\\n \\n self._env_render(self._static_map,\\n [5, 10], [SCREEN_W//2-10, SCREEN_H//2-10])\\n self._env_render(self.get_obs_blue_render,\\n [5+SCREEN_W//2, 10], [SCREEN_W//2-10, SCREEN_H//2-10])\\n self._agent_render(self.get_full_state,\\n [5+SCREEN_W//2, 10], [SCREEN_W//2-10, SCREEN_H//2-10], self._team_blue)\\n self._env_render(self.get_obs_red_render,\\n [5+SCREEN_W//2, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\\n self._env_render(self.get_full_state,\\n [5, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\\n self._agent_render(self.get_full_state,\\n [5, 10+SCREEN_H//2], [SCREEN_W//2-10, SCREEN_H//2-10])\\n\\n if self.SILENCE_RENDER:\\n return self.viewer.get_array()\\n else:\\n return self.viewer.render(return_rgb_array = mode=='rgb_array')\",\n \"def serve_vue_app():\\n return(render_template('index.html'))\",\n \"def render(self):\\n self.env.render()\\n #input(\\\"Press enter to take a step \\\")\",\n \"def display():\\n\\n #still needs some cleanup on imagry and what the site is about. \\n\\n return render_template(\\\"index.html\\\")\",\n \"def main():\\n return render_template('index.html')\",\n \"def main():\\n return render_template('index.html')\",\n \"def entry_point():\\n return render_template(\\\"index.html\\\")\",\n \"def run():\\n return render_template('index.html')\",\n \"def server(request):\\n return render_to_response(\\n 'server/index.html', {\\n 'user_url': getViewURL(request, idPage),\\n 'server_xrds_url': getViewURL(request, idpXrds),\\n },\\n context_instance=RequestContext(request))\",\n \"def browser():\\n return flask.render_template('browser.html')\",\n \"def frontend(request: HttpRequest) -> HttpResponse:\\n return render(request, \\\"frontend/base.html\\\", {})\",\n \"def render(env_type):\\n _setup_env()\\n\\n # Activate local virtual environment (for render_templates+flask?)\\n local('. %s' % env.activate_path)\\n\\n if not os.path.exists(env.s3cmd_cfg):\\n abort(\\\"Could not find 's3cmd.cfg' repository at '%(s3cmd_cfg)s'.\\\")\\n\\n if not env_type in _config['deploy']:\\n abort('Could not find \\\"%s\\\" in \\\"deploy\\\" in config file' % env_type)\\n\\n if not \\\"bucket\\\" in _config['deploy'][env_type]:\\n abort('Could not find \\\"bucket\\\" in deploy.%s\\\" in config file' % env_type)\\n\\n if 'usemin_context' in _config['deploy'][env_type]:\\n usemin_context = _config['deploy'][env_type]['usemin_context']\\n else:\\n usemin_context = None\\n\\n template_path = join(_config['project_path'], 'website', 'templates')\\n deploy_path = join(_config['project_path'], 'build', 'website')\\n\\n clean(deploy_path)\\n\\n # Render templates and run usemin\\n if 'deploy_context' in _config['deploy'][env_type]:\\n deploy_context = _config['deploy'][env_type]['deploy_context']\\n else:\\n deploy_context = {}\\n\\n # Sometimes we need this path append to import app from website\\n # in render_templates, dunno why:\\n sys.path.append(_config['project_path'])\\n\\n static.render_templates(template_path, deploy_path, deploy_context)\\n static.usemin(_config, [deploy_path], usemin_context)\\n\\n # Copy static files\\n static.copy(_config, [{\\n \\\"src\\\": join(_config['project_path'], 'website', 'static'),\\n \\\"dst\\\": join(deploy_path, 'static')\\n }])\\n\\n # Additional copy?\\n if 'copy' in _config['deploy'][env_type]:\\n static.copy(_config, _config['deploy'][env_type]['copy'])\",\n \"def main():\\n return render_template(\\\"main.html\\\")\",\n \"def main():\\n return render_template(\\\"main.html\\\")\",\n \"def home(environ):\\n return render_template(template_name=\\\"index.html\\\", context={})\",\n \"def main():\\r\\n return render_template(\\\"UI.html\\\")\",\n \"def render(trin, config, args):\\n\\n from forge.embyr.twistedserver import Application\\n sword = trin.sword.remote(trin, config, args, idx=0)\\n env = sword.getEnv.remote()\\n Application(env, sword.tick.remote)\",\n \"def dashboard_render(self,servers):\\n THIS_DIR = os.path.dirname(os.path.abspath(__file__))\\n j2_env = Environment(loader=FileSystemLoader(THIS_DIR),\\n trim_blocks=True)\\n new_dashboard = (j2_env.get_template('templating_dashboard.json').render(\\n list_templating=self.templating(servers)\\n ))\\n return (new_dashboard)\",\n \"def get(self):\\n self.render(\\\"index.html\\\")\",\n \"def render_env(self):\\n return {\\n jinja2.Template(k).render({self.name: self}):\\n jinja2.Template(v).render({self.name: self})\\n for k, v in self.env.items()\\n } if self.env else self.env\",\n \"def index():\\n return render_template('home.jinja2')\",\n \"def main():\\n\\n return render_template(\\\"index.html\\\", title=\\\"Home\\\", heading=\\\"Dublin Bus\\\")\",\n \"def get(self):\\n template = Constants.JINJA_ENVIRONMENT.get_template('homepage.html')\\n self.response.headers['Content-Type'] = 'text/html'\\n self.response.write(template.render())\",\n \"def get(self):\\n self.render(\\n \\\"index.html\\\",\\n )\",\n \"def index():\\n return render_template(\\\"main.html\\\")\",\n \"def get(self):\\n # this trick allows us to return the correct image url, even in docker\\n global _host\\n _host = self.request.host\\n _logger.debug(\\\"setting hostname to {0}\\\".format(_host))\\n env = Environment(loader=FileSystemLoader('templates'))\\n template = env.get_template('embed.html')\\n script = server_document('http://{0}/bkapp'.format(_host))\\n self.set_status(200)\\n self.write(template.render(script=script, template=\\\"Tornado\\\"))\\n self.finish()\",\n \"def get(self):\\n self.render('index.html')\\n return\",\n \"def test():\\n\\n print \\\"SERVER IS RUNNING\\\"\\n\\n\\n return render_template(\\\"statemap.html\\\")\\n # return render_template(\\\"testworld.html\\\")\",\n \"def index():\\n return render_template('main.html')\",\n \"def index():\\n return render_template('main.html')\",\n \"def index():\\n global realsense_enabled\\n return render_template('index.html')\",\n \"def index(self):\\n return render_template(\\\"{0}/index.html\\\".format(self.__APP_DIR__))\",\n \"def Home():\\n resp = render_template('index.html')\\n return resp\",\n \"def root():\\n return render_template('index.html')\",\n \"def root():\\n return render_template('index.html')\",\n \"def root():\\n return render_template('index.html')\",\n \"def start(response, input={}):\\n try: host = socket.gethostname()\\n except AttributeError:\\n if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST']\\n else: host = os.environ['SERVER_NAME']\\n template = LazyDict({'version': getversion(), 'host': host, 'color': Config().color or \\\"#C54848\\\"})\\n if input: template.update(input)\\n temp = os.path.join(os.getcwd(), 'templates/console.html')\\n outstr = template.render(temp)\\n response.out.write(outstr)\",\n \"def main():\\n access_token = get_access_token()\\n\\n return render_template('index.html', ACCESS_TOKEN=access_token)\",\n \"def home():\\n stocks = preprocess()\\n\\n return render_template(\\\"main.html\\\",stocks=stocks)\",\n \"def createBasicRenderSetup():\\n\\n pass\",\n \"def index():\\n with app.app_context():\\n return render_template(\\\"public/index.html\\\")\",\n \"def get_root():\\r\\n return render_template(\\\"index.html\\\"), 200\",\n \"def get(self):\\n self.render('view.html')\",\n \"def front_page():\\n vars = dict(request.args)\\n vars.setdefault('output', vars.get('format'))\\n\\n key = vars.get('auth_entity')\\n if key:\\n vars['entity'] = ndb.Key(urlsafe=key).get()\\n if vars['entity']:\\n vars.setdefault('site', vars['entity'].site_name().lower())\\n\\n vars.update({\\n silo + '_html': module.Start.button_html(\\n f'/{silo}/start_auth',\\n image_prefix='/oauth_dropins_static/',\\n outer_classes='col-lg-2 col-sm-4 col-xs-6',\\n scopes=SCOPE_OVERRIDES.get(silo, ''),\\n )\\n for silo, module in OAUTHS.items()})\\n\\n return render_template('index.html', **vars)\",\n \"def index():\\n return render_template('index.html', title='PanOS Bootstrap Utility')\",\n \"def setupRender():\\n prefs = getPreferences()\\n\\n # Check of the built-in environment maps path can be located.\\n # Discontinue if it cannot be found.\\n envPath = prefs.path_value\\n if not envPath:\\n return {'WARNING'}, \\\"No environment images path defined\\\"\\n\\n # Discontinue if there is no output path defined.\\n renderPath = outputPath()\\n if not renderPath:\\n return {'WARNING'}, \\\"The scene needs to be saved before rendering\\\"\\n\\n if prefs.image_value == 'NONE':\\n return {'WARNING'}, \\\"No environment image defined\\\"\\n\\n setRenderSettings(os.path.join(renderPath, IMAGE_NAME))\\n createCamera()\\n createWorld(envPath)\\n return renderPath\",\n \"def hello():\\n\\n return render_template(\\\"index.html\\\")\",\n \"def run(self) -> None:\\n self._render()\\n print(self.sio.getvalue())\",\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():\\r\\n return render_template('index.html')\",\n \"def partaj_context(request):\\n frontend_context = {\\n \\\"assets\\\": {\\\"icons\\\": static(\\\"core/icons.svg\\\")},\\n \\\"crisp_website_id\\\": settings.CRISP_WEBSITE_ID,\\n \\\"csrftoken\\\": get_token(request),\\n \\\"environment\\\": settings.ENVIRONMENT,\\n \\\"url_admin\\\": reverse(\\\"admin:index\\\"),\\n \\\"url_logout\\\": reverse(\\\"cas_ng_logout\\\"),\\n }\\n\\n if settings.SENTRY_DSN:\\n frontend_context[\\\"sentry_dsn\\\"] = settings.SENTRY_DSN\\n\\n if request.user.is_authenticated:\\n frontend_context[\\\"token\\\"] = str(\\n Token.objects.get_or_create(user=request.user)[0]\\n )\\n\\n return {\\\"FRONTEND_CONTEXT\\\": json.dumps(frontend_context)}\",\n \"def get(self):\\n return render_template(\\\"index.html\\\")\",\n \"def render_home():\\r\\n\\treturn render_template(\\\"index.html\\\")\",\n \"def root():\\n return render_template('root.html')\",\n \"def main_page():\\n return render_template(\\\"index.html\\\")\",\n \"def homepage(): \\n return render_template('home/index.html',title='Welcome to SYCLIQ')\\n #return render_template_string(\\\"Welcome to SYCLIQ\\\")\",\n \"def show_homepage():\\n\\n return render_template(\\\"blank-slate.html\\\")\",\n \"def index():\\n # Render template\\n return render_template('index.html')\",\n \"def index():\\n return render_template('index.html')\",\n \"def get(self):\\n self.response.write(view_utils.render('base.html', {}))\",\n \"def render_scheudle_view(path):\\n client_build_dir = 'client/build'\\n if path != \\\"\\\" and os.path.exists(os.path.join(client_build_dir, path)):\\n return flask.send_from_directory(client_build_dir, path)\\n else:\\n return flask.send_from_directory(client_build_dir, 'index.html')\",\n \"def renderPage():\\n return render_template(\\\"index.html\\\")\",\n \"def index(request):\\n return render_to_response(\\n # note: this is slightly different than the labs app with \\\"app/app.html\\\" rather than the labs/labs.html\\n # and we don't pass submodule name. fixme, by changing to new style with name = app_name\\n settings.JS_HOME+'app.html',\\n {'INDIVO_UI_APP_CSS': settings.INDIVO_UI_SERVER_BASE+'/jmvc/ui/resources/css/ui.css'}\\n )\",\n \"def angular_main_page():\\n print(session)\\n return render_template(\\\"/angular_main_page.html\\\")\",\n \"def root():\\n return flask.render_template('index.html')\",\n \"def landing():\\n return render_template('index.html', token=webview.token)\",\n \"def landing():\\n return render_template('index.html', token=webview.token)\",\n \"def show(self):\\n\\t\\tself.html += '<head>\\\\n' + self.head + '</head>\\\\n<body>\\\\n' + self.body + '</body>\\\\n</html>'\\n\\n\\t\\treturn self.html\",\n \"def home():\\n return render_template(\\\"d3_graph.html\\\")\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'app/index.html',\\n {\\n 'title':'Aplicacion para transpasar datos del sensor FreeStyle Libre de MongoDB a MySql',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def renderHTTP(ctx):\",\n \"def __call__(self, req, res):\\n if not hasattr(res, 'render'):\\n res.render = Renderer(res)\\n res.locals = {}\\n res.render.add_engine(self)\",\n \"def render(self, mode='human'):\\n\\n pass\",\n \"def view_landing_page():\\n return render_template(\\\"index.html\\\")\",\n \"def index():\\n \\n \\n return render_template('index.html')\",\n \"def run_html():\\n if __name__ != \\\"__main__\\\":\\n app.run(debug=True)\",\n \"def index():\\n return render_template('index.html'), 200\",\n \"def index():\\n return render_template('index.html')\",\n \"def index():\\n return render_template('index.html')\",\n \"def RenderEnv(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def landing_page():\\n\\n return render_template('index.html')\",\n \"def index(self):\\n\\t\\treturn render_template('index.html')\",\n \"def index():\\r\\n return render_template('index.html')\",\n \"def index():\\r\\n return render_template('index.html')\",\n \"def index():\\n\\n\\treturn(render_template('index.html'))\",\n \"def index():\\n #Getting source\\n sources = get_sources()\\n print(sources)\\n return render_template('index.html', sources = sources)\",\n \"def render(self, mode='human'):\\n pass # no use in this situation\",\n \"def welcome():\\n return render_template(\\\"NFL.html\\\")\",\n \"def index(self):\\n return render_template('main/index.html')\",\n \"def render(self, mode='human'):\",\n \"def home():\\n return render_template('main.html')\",\n \"def index():\\n\\n return render_template(\\\"index.html\\\"), 200\",\n \"def index() -> Any:\\n return render_template(\\\"index.html\\\")\",\n \"def setup(self):\\n print(\\\"Inside setup\\\")\\n self.fetch_from_db()\\n # Don't assign to the function output. Assing it to the function object so that whenever we\\n # do some changes to layout, it will reflect without server restarting\\n app.layout = self.get_root_layout\\n return app.server\",\n \"def index(self, **kw):\\n\\n template = self.context\\n request = self.request\\n\\n request.response.setHeader('content-type',\\n template.content_type)\\n\\n return template.render(request, **kw)\",\n \"def home():\\n return render_template(\\\"index.html\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8079139","0.7380633","0.6701152","0.6639087","0.6605521","0.6443869","0.6436322","0.64339954","0.6354514","0.6319063","0.6319063","0.6318727","0.62650275","0.6256661","0.62470657","0.62287277","0.6225323","0.6188681","0.6188681","0.61411625","0.61068594","0.6104807","0.61025804","0.60988903","0.60519594","0.605076","0.60223687","0.5994819","0.5989986","0.5964126","0.5957838","0.5945889","0.5944655","0.59420615","0.59420615","0.59416944","0.5935708","0.5933474","0.5927994","0.5927994","0.5927994","0.59087896","0.5899255","0.58943367","0.58940905","0.5889614","0.58847076","0.5883214","0.5879425","0.58728373","0.5866742","0.58397454","0.5824557","0.58178014","0.58149904","0.58133686","0.58109725","0.5803976","0.5802057","0.58009887","0.57972354","0.57959616","0.5791541","0.5788467","0.5788101","0.57783103","0.5773926","0.5773059","0.57724565","0.5769796","0.5769735","0.5769735","0.5763292","0.57632613","0.57607055","0.5756857","0.57547396","0.5752402","0.5745306","0.57429206","0.57386535","0.57364124","0.5730737","0.5730737","0.5730135","0.57297814","0.5720903","0.57122034","0.57122034","0.57095206","0.5704845","0.57030207","0.5700497","0.5699913","0.56917065","0.5690366","0.5688967","0.56873983","0.5686322","0.56816626","0.5675159"],"string":"[\n \"0.8079139\",\n \"0.7380633\",\n \"0.6701152\",\n \"0.6639087\",\n \"0.6605521\",\n \"0.6443869\",\n \"0.6436322\",\n \"0.64339954\",\n \"0.6354514\",\n \"0.6319063\",\n \"0.6319063\",\n \"0.6318727\",\n \"0.62650275\",\n \"0.6256661\",\n \"0.62470657\",\n \"0.62287277\",\n \"0.6225323\",\n \"0.6188681\",\n \"0.6188681\",\n \"0.61411625\",\n \"0.61068594\",\n \"0.6104807\",\n \"0.61025804\",\n \"0.60988903\",\n \"0.60519594\",\n \"0.605076\",\n \"0.60223687\",\n \"0.5994819\",\n \"0.5989986\",\n \"0.5964126\",\n \"0.5957838\",\n \"0.5945889\",\n \"0.5944655\",\n \"0.59420615\",\n \"0.59420615\",\n \"0.59416944\",\n \"0.5935708\",\n \"0.5933474\",\n \"0.5927994\",\n \"0.5927994\",\n \"0.5927994\",\n \"0.59087896\",\n \"0.5899255\",\n \"0.58943367\",\n \"0.58940905\",\n \"0.5889614\",\n \"0.58847076\",\n \"0.5883214\",\n \"0.5879425\",\n \"0.58728373\",\n \"0.5866742\",\n \"0.58397454\",\n \"0.5824557\",\n \"0.58178014\",\n \"0.58149904\",\n \"0.58133686\",\n \"0.58109725\",\n \"0.5803976\",\n \"0.5802057\",\n \"0.58009887\",\n \"0.57972354\",\n \"0.57959616\",\n \"0.5791541\",\n \"0.5788467\",\n \"0.5788101\",\n \"0.57783103\",\n \"0.5773926\",\n \"0.5773059\",\n \"0.57724565\",\n \"0.5769796\",\n \"0.5769735\",\n \"0.5769735\",\n \"0.5763292\",\n \"0.57632613\",\n \"0.57607055\",\n \"0.5756857\",\n \"0.57547396\",\n \"0.5752402\",\n \"0.5745306\",\n \"0.57429206\",\n \"0.57386535\",\n \"0.57364124\",\n \"0.5730737\",\n \"0.5730737\",\n \"0.5730135\",\n \"0.57297814\",\n \"0.5720903\",\n \"0.57122034\",\n \"0.57122034\",\n \"0.57095206\",\n \"0.5704845\",\n \"0.57030207\",\n \"0.5700497\",\n \"0.5699913\",\n \"0.56917065\",\n \"0.5690366\",\n \"0.5688967\",\n \"0.56873983\",\n \"0.5686322\",\n \"0.56816626\",\n \"0.5675159\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":582,"cells":{"query":{"kind":"string","value":"Fonction sans argument qui affiche un labyrinthe"},"document":{"kind":"string","value":"def afficher_carte(self):\n print(self)"},"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 simple():","def simple():","def sth():","def saluda1(sujeto):\n print 'Hola '+sujeto+' !!'","def plothub1():\r\n pass","def saluda2(sujeto):\n print 'Hola %s !!' % sujeto","def func():","def getLabel(*args):","def getLabel(*args):","def getLabel(*args):","def getLabel2(*args):","def getLabel2(*args):","def piku():\n pass","def apply():\r\n result = dataSampling(str, \"hhhhhhahhhhhahhahahahahhahahha\", 5)\r\n final_res = dataScreening(result, \"ha\")\r\n print(final_res)","def example_function():","def fn():","def realsense():\n pass","def print_result(label, result):\n print(f\"{label} {result}\\n\")","def g():","def print_result(result, label):\n print(\"\\n\", label)\n print(\"\\n\", result)\n # your code","def mezclar_bolsa(self):","def show_data():","def disp_score():","def show(*args):","def show(*args):","def show(*args):","def show(*args):","def falcon():","def funca(la, lb):\n print(\"la =\", la)\n print(\"lb =\", lb)","def subtractor(a, b): \n print(\"I'm a function. My name is {}\".format(subtractor.__name__))\n print(\"I'm about to subtract {} and {}\\n\\n\".format(a,b))\n return a - b # i output a value by using the return statement","def demo():\n ...","def verteileKarten(anzahlSpieler):\n pass","def result_display(self, arg):\n if self.rc.pprint:\n out = stringify_func(arg)\n\n if '\\n' in out:\n print\n\n print out\n else:\n print repr(arg)","def GetHelix(helix):\r\n pass","def print_out():\n pass","def show_func(self, x):\n\n if (self._flag == 1):\n g = self.modelfun(x, *self._gf)\n elif (self._flag == 2):\n g = self.modelfun1(x, *self._gf)\n elif ((self._flag == 0) & (self._load != '0')):\n pass\n else:\n # pass\n sys.exit(\"Wrong flag in do_fit\")\n\n return g","def sample(self):","def exo2():","def Problem11():\n return 'Ductile Coulomb-Mohr'","def call(self):","def feat():\n pass","def Label(self) -> str:","def calculate_output(self):","def test_transE_display():\n testing_function('transe', display=True)","def show_result():\n print(\"I win!!\")","def lro(self) -> global___Snippet.Lro:","def healthcare():","def exercise_b2_70():\r\n pass","def display_message():","def CL(self):","def firstFunction(self):","def function(self):\n raise NotImplementedError","def substantiate():","def main(_):\n\tlabel_wav()","def disp(self, modulo=None):\r\n raise NotImplementedError('method disp() is not implemented')","def trace(self,p):\n n = self\n c=0 \n while n!=None :\n print (n)\n n = n.pere\n c+=1\n print (\"Nombre d'étapes de la solution:\", c-1)\n return","def feature():\n pass","def showp():\n def show1(i):\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetAz' % (i+1) ,qmax_)\n e=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetEl' % (i+1) ,qmax_)\n return (a,e)\n print ' ant dAz dEl'\n for i in range(6):\n (a,e) = show1(i)\n print ' 00%d %7.3f %7.3f' % (i+1,a,e)","def used_tex_func(val):\n return None","def fn(): # fn definition # help2\r\n print(my_text)","def main():\n printfunc(calc(menu()))","def exercise_b2_69():\r\n pass","def main():\n\n # on affiche la liste des cartes disponibles\n liste_des_cartes = functions.liste_cartes() + functions.liste_sauvegardes()\n functions.afficher_liste(liste_des_cartes)\n\n # selection d'une carte, un retour \"None\" indique une mauvaise saisie\n while True:\n choix = functions.choix_carte(\n input('''Indiquez le numéro de la carte choisie.\n Attention, si vous choisissez une nouvelle partie, la sauvegarde associée\n à la carte concernée sera remplacée. \\n'''), liste_des_cartes)\n if choix is not None:\n break\n\n # la carte est choisie, on peut générer un Labyrinthe\n laby = Labyrinthe(choix)\n # on affiche le tracé du labyrinthe\n print(laby.carte)\n\n # on lance la boucle du jeu\n while True:\n deplacements = input(\"\"\"Dans quelle direction voulez vous aller?\n \"E\" pour aller vers l'est, \"N\" pour aller vers le nord\n \"S\" pour aller vers le sud, \"O\" pour aller vers l'ouest\n Suivi d'un nombre (optionnel) pour le nombre de cases à parcourir\n \"Q\" pour sauvegarder et quitter\n \"\"\")\n # on vérifie que les données entrées par l'utilisateur sont valides\n instructions = functions.instructions_valide(deplacements)\n if instructions is not None:\n\n if instructions == \"quitter\":\n laby.sauvegarder_partie()\n break\n if instructions == \"lettre non valide\":\n print(\"La lettre entrée n'est pas valide \\n\")\n continue\n if instructions == \"non valide\":\n print(\"Les données entrées ne sont pas valides \\n\")\n continue\n else:\n # on vérifie si la partie est toujours active\n partie_en_cours = laby.effectuer_deplacements(instructions)\n if not partie_en_cours:\n # en cas de sortie trouvée, on supprime la sauvegarde\n laby.supprimer_partie()\n print(\"Partie terminée, sauvegarde supprimée\")\n break\n\n # On met en pause le système (Windows)\n os.system(\"pause\")","def dummy_fn(self):\n\t\tpass","def _regr_basic():","def handle_output(self, workunit, label, s):\r\n pass","def handle_output(self, workunit, label, s):\r\n pass","def note():","def ti_func_doc(self, label):\n latex = (\n r'\\begin{split}' + '\\n'\n r'0 = & ti - LHV_\\mathrm{fuel} \\cdot \\left[\\sum_i \\left('\n r'\\dot{m}_{\\mathrm{in,}i}\\cdot x_{\\mathrm{fuel,in,}i}\\right)-'\n r' \\dot{m}_\\mathrm{out,1}\\cdot '\n r'x_{\\mathrm{fuel,out,1}} \\right]\\\\' + '\\n'\n r'& \\forall i \\in \\text{combustion inlets}\\\\' + '\\n'\n r'\\end{split}'\n )\n return generate_latex_eq(self, latex, label)","def view(self):\r\n\t\t\r\n\t\t# add zero term\r\n\t\tt = self\r\n\t\tif t == []:\r\n\t\t\tt = [Te(0)]\r\n\t\t\r\n\t\t# display\r\n\t\tfor i in t:\r\n\t\t\ti.view()\r\n\t\t\t\r\n\t\t# spacer\r\n\t\tprint(' ')\r\n\t\t\t\r\n\t\treturn None","def result(self):","def result(self):","def goToZero():\n #on remet tout à zero\n usr_choice = 0\n fonctions_pfc.x = 0\n fonctions_pfc.y = 0\n fonctions_pfc.result = \"\"\n fonctions_pfc.pc_score = \" SCORE DU PC : \"\n fonctions_pfc.usr_score = \" SCORE DU PC : \"\n #on ré-affiche tous les composants\n display_pack_component()","def spiel(self, *args, **kwargs):\n\t\t\n if kwargs.get('h'):\n print(\"\\nSpiel ( FussballToto, 7 Mannschaften )\\n\")\n print(\"Aufruf t . spiel( /[ tipp ] /[, m ] )\\n\")\n print(\" t Toto-Objekt\")\n print(\" tipp abgegebener Tipp (Liste mit 7 Zahlen aus {0, 1, 2})\")\t\t\t\n print(\" fehlt die Angabe, wird ein zufälliger Tipp angenom-\")\n print(\" men\")\t\t\t\n print(\" m Anzahl Spiele (mit dem gleichen Tipp); Standard=1\\n\")\n print(\"Zusatz z=ja Es wird ein zufälliger Tipp angenommen\")\n print(\" (ein eventuell angegebener Tipp wird nicht beachtet)\")\n print(\" d=ja Bei Angabe von m > 1 Rückgabe einer DatenReihe\")\n print(\" mit der Anzahl Richtige je Spiel\\n\")\t\t\t\n return\t\t\t\n\t \n def zuf_tipp()\t :\n return zuf_zahl((0, 2), 7)\t\t\n\t \n zufall = False\t \n if len(args) not in (0, 1, 2):\n print('zufall: 0 bis 2 Argumente angeben')\n return\n if len(args) == 0:\n m = 1\n zufall = True\t\t\t\n elif len(args) == 1:\n m = args[0]\n if isinstance(m, (int, Integer)):\t\n zufall = True\t\t\t\n elif isinstance(m, (list, tuple)):\n tipp = m\n m = 1\n else:\t\t\t\t\n print('zufall: positive ganze Zahl oder Tipp-Liste angeben')\n elif len(args) == 2:\n tipp, m = args\t\n\n if m <= 0:\n print('zufall: Anzahl der Spiele >= 1 angeben')\n return\t\n\n if kwargs.get('z'):\n zufall = True\n\n if zufall:\n tipp = zuf_tipp()\n\t\t\t\n if len(tipp) != 7 or not all([x in (0,1,2) for x in tipp]):\t\t\t\n print('zufall: Tipp als Liste von 7 Zahlen aus (0,1,2) angeben')\n return\t\t\t\n\t\t\t\n ergebnisse = zuf_tipp()\t\t\t\n\n def dm(x):\n return display(Math(x))\t\t\t\t\n\n print(' ')\n\t\t\t\n if m == 1:\n if not zufall:\t\t\n dm('\\\\text{Tipp}' + '\\\\quad\\\\quad \\,:' + latex(tipp))\n else:\n dm('\\\\text{Tipp}' + '\\\\quad\\\\quad :\\;' + latex(tipp) + '\\;\\;\\\\text{(zufällig)}')\n dm('\\\\text{Ergebnisse :} \\;' + latex(ergebnisse))\t\n erg = 0\t\t\t\n for i, t in enumerate(tipp):\n if t == ergebnisse[i]:\n erg += 1\n if erg == 1:\t\t\t\t\t\n dm(latex(erg) + '\\;\\\\text{Richtiger}')\t\n else:\t\t\t\t\t\n dm(latex(erg) + '\\;\\\\text{Richtige}')\t\n else:\t\t\t\n summen = {}\n dr = []\t\t\t\n for i in range(m):\n erg = zuf_tipp()\n sum = 0\t\t\t\t\n for j, t in enumerate(tipp):\n if t == erg[j]:\n sum += 1\n if kwargs.get('d'):\n dr += [sum]\t\t\t\t\t\t\n try:\t\t\t\t\t\t\n summen[sum] += 1\n except KeyError:\n summen[sum] = 1\n dm(latex(m) + '\\; \\\\text{Spiele}')\n dm('\\\\text{Spielergebnisse (Richtige : Anzahl Spiele, relative Häufigkeit, \\\n \t\t\ttheoretische}') \n dm('\\\\text{Wahrscheinlichkeit)}')\t\t\t\n u = Urne([0, 1, 2], 7, f=anzahl(1), info=False)\t\t\t\n for s in summen:\n sum = summen[s]\t\t\n dm(latex(s) + '\\\\text{ : } \\\\quad' + latex(sum) + '\\\\quad' + \\\n\t\t\t\t latex(format(float(sum/m), '.4f')) + '\\\\quad ' + \\\n\t\t\t\t latex(format(float(u.P(s)), '.4f')) + '=' + latex(u.P(s)))\n print(' ') \n if kwargs.get('d'):\n print('Rückgabe einer DatenReihe (Anzahl Richtige je Spiel)')\t\t\n return DatenReihe(dr)","def display_problem():\n return \"\\nFind the difference between the sum of the squares of the first one hundred natural numbers and the \" \\\n \"square of the sum.\\n\"","def output(self):\r\n self.logic ( )\r\n return self.output","def test(): # TO BE DELETED WHEN PROGRAM COMPLETED\n print('methode test')","def exercise2(self, param1, param2):\n print param1 / param2\n return","def sample(self, x):","def showm():\n def show1(i):\n coeff=[]\n for m in range(5):\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.m%d' % (i+1,m+1) ,qmax_)\n coeff.append(a)\n for o in range(3):\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.o%d' % (i+1,o+1) ,qmax_)\n coeff.append(a)\n return coeff\n print ' ant m1 m2 m3 m4 m5 o1 o2 o3'\n for i in range(6):\n m = show1(i)\n print ' 00%d %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f' % (i+1,m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7])","def nr():\n pass","def subtractor(a,b): \n return a-b # i output a value by using the return statement","def func_case(self):\n test.success(\"\")","def display_message():\n\tprint(\"In this chapter we will be learning how to write functions\")","def describe():","def display4(*args):\n #-------------------- unpack\n twiss_func = args[0]\n cos_like = args[1]\n sin_like = args[2]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\n#-------------------- longitudinal trajectories\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\n\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- beta functions\n splot211=plt.subplot(211)\n splot211.set_title('beta x,y')\n # mapping box\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\n # function plots\n plt.plot(s,bx, label=r\"$\\beta$x [m]\", color='black', linestyle='-')\n plt.plot(s,by, label=r\"$\\beta$y [m]\", color='red', linestyle='-')\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\n vscale=splot211.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\n # zero line\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n\n #-------------------- longitudinal tracks z, dP/P\n # ax_l = left abszisse\n ax_l=plt.subplot(212)\n # ax_l=plt.subplot(10,1,(7,9))\n ax_l.set_title('synchrotron oscillation')\n ax_l.set_ylabel(r\"z [mm]\")\n ax_l.tick_params(axis='y', colors='green')\n ax_l.yaxis.label.set_color('green')\n ax_l.plot(z1,cz,label='C',color='green')\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\n plt.legend(loc='lower left',fontsize='x-small')\n # ax_r = right abszisse\n ax_r = ax_l.twinx()\n ax_r.set_ylabel(r'$\\Delta$p/p [%]')\n ax_r.tick_params(axis='y', colors='red')\n ax_r.yaxis.label.set_color('red')\n ax_r.plot(z2,cdp,label='C',color='red')\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n # lattice elements\n vscale=ax_l.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')","def fn(self):\n return \"Hello\"","def input(self):","def printme(parameters): # create a function called printme using def\n print(parameters) # prints anything that is stored inside parameters\n return","def echo(self, foetus):\n Allele_semblable = 0\n for Allele in range(3):\n if self.allele[Allele] in foetus.allele and self.allele[Allele] != 0.0:\n Allele_semblable = Allele\n if Allele_semblable == 0:\n Allele_Echo = self.allele[Allele_semblable + 1]\n for Alleles_foetus in range(3):\n if foetus.allele[Alleles_foetus] - 1 == Allele_Echo:\n foetus.informatif = 3\n elif Allele_semblable == 1:\n Allele_Echo = self.allele[Allele_semblable - 1]\n for Alleles_foetus in range(3):\n if foetus.allele[Alleles_foetus] - 1 == Allele_Echo:\n foetus.informatif = 3","def default_display_function(feature):\n # n_samples = min(n_samples, feature.shape[0])\n IPython.display.display(widgets.Box(layout=widgets.Layout(height=\"2.5%\")))\n IPython.display.display(feature)\n IPython.display.display(widgets.Box(layout=widgets.Layout(height=\"2.5%\")))","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def preberi_pot(ukazi):","def display(self):\n print(\"{}, {}\".format(self.label, self.params))","def introduction_function(self):\n pass","def printfunc(self):\n zero1=self.Newton(True)\n print \"Using initial porition %0.2f ,%0.2f\" %(self.x_init,self.y_0)\n print \"extremum calculated witn Newton-Rapson: %0.2f ,%0.2f.\"%(zero1[0],zero1[1])\n zero2=self.Newton(False)\n print \"extremum calculated witn Secant: %0.2f ,%0.2f.\" %(zero2[0],zero2[1])\n xlist=np.arange(self.x_0-10,self.x_0+10,0.01)\n ylist=np.arange(self.y_0-10,self.y_0+10,0.01)\n X,Y=np.meshgrid(xlist,ylist)\n Z=self.sfunc(X,Y)\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n \n ax.plot(xlist, ylist, self.sfunc(xlist,ylist), 'g-',label='function $e^{(-(x-%0.2f)^2-(y-%0.2f)^2)}$' %(self.x_0,self.y_0))\n ax.contour(X, Y, Z)# colors = 'k', linestyles = 'solid')\n ax.plot([zero1[0]], [zero1[0]], self.sfunc(zero1[0],zero1[1]),'bo',label='extrema using Newton-Rapson (%0.2f; %0.2f)'%(zero1[0],zero1[1]))\n ax.plot([zero2[0]], [zero2[0]], self.sfunc(zero2[0],zero2[1]),'ro',label='extrema using Seacent (%0.2f; %0.2f)'%(zero2[0],zero2[1]))\n ax.legend()\n plt.show()","def display_results():\n pass","def __call__():"],"string":"[\n \"def simple():\",\n \"def simple():\",\n \"def sth():\",\n \"def saluda1(sujeto):\\n print 'Hola '+sujeto+' !!'\",\n \"def plothub1():\\r\\n pass\",\n \"def saluda2(sujeto):\\n print 'Hola %s !!' % sujeto\",\n \"def func():\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel(*args):\",\n \"def getLabel2(*args):\",\n \"def getLabel2(*args):\",\n \"def piku():\\n pass\",\n \"def apply():\\r\\n result = dataSampling(str, \\\"hhhhhhahhhhhahhahahahahhahahha\\\", 5)\\r\\n final_res = dataScreening(result, \\\"ha\\\")\\r\\n print(final_res)\",\n \"def example_function():\",\n \"def fn():\",\n \"def realsense():\\n pass\",\n \"def print_result(label, result):\\n print(f\\\"{label} {result}\\\\n\\\")\",\n \"def g():\",\n \"def print_result(result, label):\\n print(\\\"\\\\n\\\", label)\\n print(\\\"\\\\n\\\", result)\\n # your code\",\n \"def mezclar_bolsa(self):\",\n \"def show_data():\",\n \"def disp_score():\",\n \"def show(*args):\",\n \"def show(*args):\",\n \"def show(*args):\",\n \"def show(*args):\",\n \"def falcon():\",\n \"def funca(la, lb):\\n print(\\\"la =\\\", la)\\n print(\\\"lb =\\\", lb)\",\n \"def subtractor(a, b): \\n print(\\\"I'm a function. My name is {}\\\".format(subtractor.__name__))\\n print(\\\"I'm about to subtract {} and {}\\\\n\\\\n\\\".format(a,b))\\n return a - b # i output a value by using the return statement\",\n \"def demo():\\n ...\",\n \"def verteileKarten(anzahlSpieler):\\n pass\",\n \"def result_display(self, arg):\\n if self.rc.pprint:\\n out = stringify_func(arg)\\n\\n if '\\\\n' in out:\\n print\\n\\n print out\\n else:\\n print repr(arg)\",\n \"def GetHelix(helix):\\r\\n pass\",\n \"def print_out():\\n pass\",\n \"def show_func(self, x):\\n\\n if (self._flag == 1):\\n g = self.modelfun(x, *self._gf)\\n elif (self._flag == 2):\\n g = self.modelfun1(x, *self._gf)\\n elif ((self._flag == 0) & (self._load != '0')):\\n pass\\n else:\\n # pass\\n sys.exit(\\\"Wrong flag in do_fit\\\")\\n\\n return g\",\n \"def sample(self):\",\n \"def exo2():\",\n \"def Problem11():\\n return 'Ductile Coulomb-Mohr'\",\n \"def call(self):\",\n \"def feat():\\n pass\",\n \"def Label(self) -> str:\",\n \"def calculate_output(self):\",\n \"def test_transE_display():\\n testing_function('transe', display=True)\",\n \"def show_result():\\n print(\\\"I win!!\\\")\",\n \"def lro(self) -> global___Snippet.Lro:\",\n \"def healthcare():\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def display_message():\",\n \"def CL(self):\",\n \"def firstFunction(self):\",\n \"def function(self):\\n raise NotImplementedError\",\n \"def substantiate():\",\n \"def main(_):\\n\\tlabel_wav()\",\n \"def disp(self, modulo=None):\\r\\n raise NotImplementedError('method disp() is not implemented')\",\n \"def trace(self,p):\\n n = self\\n c=0 \\n while n!=None :\\n print (n)\\n n = n.pere\\n c+=1\\n print (\\\"Nombre d'étapes de la solution:\\\", c-1)\\n return\",\n \"def feature():\\n pass\",\n \"def showp():\\n def show1(i):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetAz' % (i+1) ,qmax_)\\n e=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetEl' % (i+1) ,qmax_)\\n return (a,e)\\n print ' ant dAz dEl'\\n for i in range(6):\\n (a,e) = show1(i)\\n print ' 00%d %7.3f %7.3f' % (i+1,a,e)\",\n \"def used_tex_func(val):\\n return None\",\n \"def fn(): # fn definition # help2\\r\\n print(my_text)\",\n \"def main():\\n printfunc(calc(menu()))\",\n \"def exercise_b2_69():\\r\\n pass\",\n \"def main():\\n\\n # on affiche la liste des cartes disponibles\\n liste_des_cartes = functions.liste_cartes() + functions.liste_sauvegardes()\\n functions.afficher_liste(liste_des_cartes)\\n\\n # selection d'une carte, un retour \\\"None\\\" indique une mauvaise saisie\\n while True:\\n choix = functions.choix_carte(\\n input('''Indiquez le numéro de la carte choisie.\\n Attention, si vous choisissez une nouvelle partie, la sauvegarde associée\\n à la carte concernée sera remplacée. \\\\n'''), liste_des_cartes)\\n if choix is not None:\\n break\\n\\n # la carte est choisie, on peut générer un Labyrinthe\\n laby = Labyrinthe(choix)\\n # on affiche le tracé du labyrinthe\\n print(laby.carte)\\n\\n # on lance la boucle du jeu\\n while True:\\n deplacements = input(\\\"\\\"\\\"Dans quelle direction voulez vous aller?\\n \\\"E\\\" pour aller vers l'est, \\\"N\\\" pour aller vers le nord\\n \\\"S\\\" pour aller vers le sud, \\\"O\\\" pour aller vers l'ouest\\n Suivi d'un nombre (optionnel) pour le nombre de cases à parcourir\\n \\\"Q\\\" pour sauvegarder et quitter\\n \\\"\\\"\\\")\\n # on vérifie que les données entrées par l'utilisateur sont valides\\n instructions = functions.instructions_valide(deplacements)\\n if instructions is not None:\\n\\n if instructions == \\\"quitter\\\":\\n laby.sauvegarder_partie()\\n break\\n if instructions == \\\"lettre non valide\\\":\\n print(\\\"La lettre entrée n'est pas valide \\\\n\\\")\\n continue\\n if instructions == \\\"non valide\\\":\\n print(\\\"Les données entrées ne sont pas valides \\\\n\\\")\\n continue\\n else:\\n # on vérifie si la partie est toujours active\\n partie_en_cours = laby.effectuer_deplacements(instructions)\\n if not partie_en_cours:\\n # en cas de sortie trouvée, on supprime la sauvegarde\\n laby.supprimer_partie()\\n print(\\\"Partie terminée, sauvegarde supprimée\\\")\\n break\\n\\n # On met en pause le système (Windows)\\n os.system(\\\"pause\\\")\",\n \"def dummy_fn(self):\\n\\t\\tpass\",\n \"def _regr_basic():\",\n \"def handle_output(self, workunit, label, s):\\r\\n pass\",\n \"def handle_output(self, workunit, label, s):\\r\\n pass\",\n \"def note():\",\n \"def ti_func_doc(self, label):\\n latex = (\\n r'\\\\begin{split}' + '\\\\n'\\n r'0 = & ti - LHV_\\\\mathrm{fuel} \\\\cdot \\\\left[\\\\sum_i \\\\left('\\n r'\\\\dot{m}_{\\\\mathrm{in,}i}\\\\cdot x_{\\\\mathrm{fuel,in,}i}\\\\right)-'\\n r' \\\\dot{m}_\\\\mathrm{out,1}\\\\cdot '\\n r'x_{\\\\mathrm{fuel,out,1}} \\\\right]\\\\\\\\' + '\\\\n'\\n r'& \\\\forall i \\\\in \\\\text{combustion inlets}\\\\\\\\' + '\\\\n'\\n r'\\\\end{split}'\\n )\\n return generate_latex_eq(self, latex, label)\",\n \"def view(self):\\r\\n\\t\\t\\r\\n\\t\\t# add zero term\\r\\n\\t\\tt = self\\r\\n\\t\\tif t == []:\\r\\n\\t\\t\\tt = [Te(0)]\\r\\n\\t\\t\\r\\n\\t\\t# display\\r\\n\\t\\tfor i in t:\\r\\n\\t\\t\\ti.view()\\r\\n\\t\\t\\t\\r\\n\\t\\t# spacer\\r\\n\\t\\tprint(' ')\\r\\n\\t\\t\\t\\r\\n\\t\\treturn None\",\n \"def result(self):\",\n \"def result(self):\",\n \"def goToZero():\\n #on remet tout à zero\\n usr_choice = 0\\n fonctions_pfc.x = 0\\n fonctions_pfc.y = 0\\n fonctions_pfc.result = \\\"\\\"\\n fonctions_pfc.pc_score = \\\" SCORE DU PC : \\\"\\n fonctions_pfc.usr_score = \\\" SCORE DU PC : \\\"\\n #on ré-affiche tous les composants\\n display_pack_component()\",\n \"def spiel(self, *args, **kwargs):\\n\\t\\t\\n if kwargs.get('h'):\\n print(\\\"\\\\nSpiel ( FussballToto, 7 Mannschaften )\\\\n\\\")\\n print(\\\"Aufruf t . spiel( /[ tipp ] /[, m ] )\\\\n\\\")\\n print(\\\" t Toto-Objekt\\\")\\n print(\\\" tipp abgegebener Tipp (Liste mit 7 Zahlen aus {0, 1, 2})\\\")\\t\\t\\t\\n print(\\\" fehlt die Angabe, wird ein zufälliger Tipp angenom-\\\")\\n print(\\\" men\\\")\\t\\t\\t\\n print(\\\" m Anzahl Spiele (mit dem gleichen Tipp); Standard=1\\\\n\\\")\\n print(\\\"Zusatz z=ja Es wird ein zufälliger Tipp angenommen\\\")\\n print(\\\" (ein eventuell angegebener Tipp wird nicht beachtet)\\\")\\n print(\\\" d=ja Bei Angabe von m > 1 Rückgabe einer DatenReihe\\\")\\n print(\\\" mit der Anzahl Richtige je Spiel\\\\n\\\")\\t\\t\\t\\n return\\t\\t\\t\\n\\t \\n def zuf_tipp()\\t :\\n return zuf_zahl((0, 2), 7)\\t\\t\\n\\t \\n zufall = False\\t \\n if len(args) not in (0, 1, 2):\\n print('zufall: 0 bis 2 Argumente angeben')\\n return\\n if len(args) == 0:\\n m = 1\\n zufall = True\\t\\t\\t\\n elif len(args) == 1:\\n m = args[0]\\n if isinstance(m, (int, Integer)):\\t\\n zufall = True\\t\\t\\t\\n elif isinstance(m, (list, tuple)):\\n tipp = m\\n m = 1\\n else:\\t\\t\\t\\t\\n print('zufall: positive ganze Zahl oder Tipp-Liste angeben')\\n elif len(args) == 2:\\n tipp, m = args\\t\\n\\n if m <= 0:\\n print('zufall: Anzahl der Spiele >= 1 angeben')\\n return\\t\\n\\n if kwargs.get('z'):\\n zufall = True\\n\\n if zufall:\\n tipp = zuf_tipp()\\n\\t\\t\\t\\n if len(tipp) != 7 or not all([x in (0,1,2) for x in tipp]):\\t\\t\\t\\n print('zufall: Tipp als Liste von 7 Zahlen aus (0,1,2) angeben')\\n return\\t\\t\\t\\n\\t\\t\\t\\n ergebnisse = zuf_tipp()\\t\\t\\t\\n\\n def dm(x):\\n return display(Math(x))\\t\\t\\t\\t\\n\\n print(' ')\\n\\t\\t\\t\\n if m == 1:\\n if not zufall:\\t\\t\\n dm('\\\\\\\\text{Tipp}' + '\\\\\\\\quad\\\\\\\\quad \\\\,:' + latex(tipp))\\n else:\\n dm('\\\\\\\\text{Tipp}' + '\\\\\\\\quad\\\\\\\\quad :\\\\;' + latex(tipp) + '\\\\;\\\\;\\\\\\\\text{(zufällig)}')\\n dm('\\\\\\\\text{Ergebnisse :} \\\\;' + latex(ergebnisse))\\t\\n erg = 0\\t\\t\\t\\n for i, t in enumerate(tipp):\\n if t == ergebnisse[i]:\\n erg += 1\\n if erg == 1:\\t\\t\\t\\t\\t\\n dm(latex(erg) + '\\\\;\\\\\\\\text{Richtiger}')\\t\\n else:\\t\\t\\t\\t\\t\\n dm(latex(erg) + '\\\\;\\\\\\\\text{Richtige}')\\t\\n else:\\t\\t\\t\\n summen = {}\\n dr = []\\t\\t\\t\\n for i in range(m):\\n erg = zuf_tipp()\\n sum = 0\\t\\t\\t\\t\\n for j, t in enumerate(tipp):\\n if t == erg[j]:\\n sum += 1\\n if kwargs.get('d'):\\n dr += [sum]\\t\\t\\t\\t\\t\\t\\n try:\\t\\t\\t\\t\\t\\t\\n summen[sum] += 1\\n except KeyError:\\n summen[sum] = 1\\n dm(latex(m) + '\\\\; \\\\\\\\text{Spiele}')\\n dm('\\\\\\\\text{Spielergebnisse (Richtige : Anzahl Spiele, relative Häufigkeit, \\\\\\n \\t\\t\\ttheoretische}') \\n dm('\\\\\\\\text{Wahrscheinlichkeit)}')\\t\\t\\t\\n u = Urne([0, 1, 2], 7, f=anzahl(1), info=False)\\t\\t\\t\\n for s in summen:\\n sum = summen[s]\\t\\t\\n dm(latex(s) + '\\\\\\\\text{ : } \\\\\\\\quad' + latex(sum) + '\\\\\\\\quad' + \\\\\\n\\t\\t\\t\\t latex(format(float(sum/m), '.4f')) + '\\\\\\\\quad ' + \\\\\\n\\t\\t\\t\\t latex(format(float(u.P(s)), '.4f')) + '=' + latex(u.P(s)))\\n print(' ') \\n if kwargs.get('d'):\\n print('Rückgabe einer DatenReihe (Anzahl Richtige je Spiel)')\\t\\t\\n return DatenReihe(dr)\",\n \"def display_problem():\\n return \\\"\\\\nFind the difference between the sum of the squares of the first one hundred natural numbers and the \\\" \\\\\\n \\\"square of the sum.\\\\n\\\"\",\n \"def output(self):\\r\\n self.logic ( )\\r\\n return self.output\",\n \"def test(): # TO BE DELETED WHEN PROGRAM COMPLETED\\n print('methode test')\",\n \"def exercise2(self, param1, param2):\\n print param1 / param2\\n return\",\n \"def sample(self, x):\",\n \"def showm():\\n def show1(i):\\n coeff=[]\\n for m in range(5):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.m%d' % (i+1,m+1) ,qmax_)\\n coeff.append(a)\\n for o in range(3):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.o%d' % (i+1,o+1) ,qmax_)\\n coeff.append(a)\\n return coeff\\n print ' ant m1 m2 m3 m4 m5 o1 o2 o3'\\n for i in range(6):\\n m = show1(i)\\n print ' 00%d %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f' % (i+1,m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7])\",\n \"def nr():\\n pass\",\n \"def subtractor(a,b): \\n return a-b # i output a value by using the return statement\",\n \"def func_case(self):\\n test.success(\\\"\\\")\",\n \"def display_message():\\n\\tprint(\\\"In this chapter we will be learning how to write functions\\\")\",\n \"def describe():\",\n \"def display4(*args):\\n #-------------------- unpack\\n twiss_func = args[0]\\n cos_like = args[1]\\n sin_like = args[2]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\\n#-------------------- longitudinal trajectories\\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\\n\\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- beta functions\\n splot211=plt.subplot(211)\\n splot211.set_title('beta x,y')\\n # mapping box\\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\\n # function plots\\n plt.plot(s,bx, label=r\\\"$\\\\beta$x [m]\\\", color='black', linestyle='-')\\n plt.plot(s,by, label=r\\\"$\\\\beta$y [m]\\\", color='red', linestyle='-')\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\\n vscale=splot211.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n # zero line\\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n\\n #-------------------- longitudinal tracks z, dP/P\\n # ax_l = left abszisse\\n ax_l=plt.subplot(212)\\n # ax_l=plt.subplot(10,1,(7,9))\\n ax_l.set_title('synchrotron oscillation')\\n ax_l.set_ylabel(r\\\"z [mm]\\\")\\n ax_l.tick_params(axis='y', colors='green')\\n ax_l.yaxis.label.set_color('green')\\n ax_l.plot(z1,cz,label='C',color='green')\\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\\n plt.legend(loc='lower left',fontsize='x-small')\\n # ax_r = right abszisse\\n ax_r = ax_l.twinx()\\n ax_r.set_ylabel(r'$\\\\Delta$p/p [%]')\\n ax_r.tick_params(axis='y', colors='red')\\n ax_r.yaxis.label.set_color('red')\\n ax_r.plot(z2,cdp,label='C',color='red')\\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n # lattice elements\\n vscale=ax_l.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')\",\n \"def fn(self):\\n return \\\"Hello\\\"\",\n \"def input(self):\",\n \"def printme(parameters): # create a function called printme using def\\n print(parameters) # prints anything that is stored inside parameters\\n return\",\n \"def echo(self, foetus):\\n Allele_semblable = 0\\n for Allele in range(3):\\n if self.allele[Allele] in foetus.allele and self.allele[Allele] != 0.0:\\n Allele_semblable = Allele\\n if Allele_semblable == 0:\\n Allele_Echo = self.allele[Allele_semblable + 1]\\n for Alleles_foetus in range(3):\\n if foetus.allele[Alleles_foetus] - 1 == Allele_Echo:\\n foetus.informatif = 3\\n elif Allele_semblable == 1:\\n Allele_Echo = self.allele[Allele_semblable - 1]\\n for Alleles_foetus in range(3):\\n if foetus.allele[Alleles_foetus] - 1 == Allele_Echo:\\n foetus.informatif = 3\",\n \"def default_display_function(feature):\\n # n_samples = min(n_samples, feature.shape[0])\\n IPython.display.display(widgets.Box(layout=widgets.Layout(height=\\\"2.5%\\\")))\\n IPython.display.display(feature)\\n IPython.display.display(widgets.Box(layout=widgets.Layout(height=\\\"2.5%\\\")))\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def display(self):\\n print(\\\"{}, {}\\\".format(self.label, self.params))\",\n \"def introduction_function(self):\\n pass\",\n \"def printfunc(self):\\n zero1=self.Newton(True)\\n print \\\"Using initial porition %0.2f ,%0.2f\\\" %(self.x_init,self.y_0)\\n print \\\"extremum calculated witn Newton-Rapson: %0.2f ,%0.2f.\\\"%(zero1[0],zero1[1])\\n zero2=self.Newton(False)\\n print \\\"extremum calculated witn Secant: %0.2f ,%0.2f.\\\" %(zero2[0],zero2[1])\\n xlist=np.arange(self.x_0-10,self.x_0+10,0.01)\\n ylist=np.arange(self.y_0-10,self.y_0+10,0.01)\\n X,Y=np.meshgrid(xlist,ylist)\\n Z=self.sfunc(X,Y)\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n \\n ax.plot(xlist, ylist, self.sfunc(xlist,ylist), 'g-',label='function $e^{(-(x-%0.2f)^2-(y-%0.2f)^2)}$' %(self.x_0,self.y_0))\\n ax.contour(X, Y, Z)# colors = 'k', linestyles = 'solid')\\n ax.plot([zero1[0]], [zero1[0]], self.sfunc(zero1[0],zero1[1]),'bo',label='extrema using Newton-Rapson (%0.2f; %0.2f)'%(zero1[0],zero1[1]))\\n ax.plot([zero2[0]], [zero2[0]], self.sfunc(zero2[0],zero2[1]),'ro',label='extrema using Seacent (%0.2f; %0.2f)'%(zero2[0],zero2[1]))\\n ax.legend()\\n plt.show()\",\n \"def display_results():\\n pass\",\n \"def __call__():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63914204","0.63914204","0.5986804","0.59826845","0.59645784","0.5792992","0.5778979","0.5771139","0.5771139","0.5771139","0.57593817","0.57593817","0.57460934","0.5673789","0.5656487","0.5655953","0.56223005","0.5616206","0.560993","0.56080663","0.560432","0.5603471","0.5591425","0.55910933","0.55910933","0.55910933","0.55910933","0.55624384","0.55190325","0.55054754","0.5468469","0.5447353","0.54365796","0.5429421","0.5418774","0.5406786","0.53993124","0.53917307","0.53776854","0.5367113","0.5364031","0.53604114","0.53365034","0.53297204","0.5324961","0.5319152","0.53172207","0.53134525","0.5309881","0.5304874","0.5299356","0.5291189","0.52819794","0.52743906","0.52649033","0.52600974","0.52501875","0.5245689","0.5245638","0.52240884","0.52229345","0.52125","0.52086633","0.5206865","0.51891965","0.518201","0.518201","0.51811594","0.5180423","0.51760614","0.51677775","0.51677775","0.5161713","0.5156817","0.5156572","0.5153086","0.51529914","0.51438123","0.5142331","0.51417357","0.5141168","0.51378894","0.5137704","0.5137194","0.51368064","0.5132928","0.51312023","0.512844","0.5127816","0.51239777","0.51233834","0.5123249","0.5123249","0.5123249","0.5123249","0.5123249","0.51231515","0.5120981","0.5120627","0.5117872","0.5117194"],"string":"[\n \"0.63914204\",\n \"0.63914204\",\n \"0.5986804\",\n \"0.59826845\",\n \"0.59645784\",\n \"0.5792992\",\n \"0.5778979\",\n \"0.5771139\",\n \"0.5771139\",\n \"0.5771139\",\n \"0.57593817\",\n \"0.57593817\",\n \"0.57460934\",\n \"0.5673789\",\n \"0.5656487\",\n \"0.5655953\",\n \"0.56223005\",\n \"0.5616206\",\n \"0.560993\",\n \"0.56080663\",\n \"0.560432\",\n \"0.5603471\",\n \"0.5591425\",\n \"0.55910933\",\n \"0.55910933\",\n \"0.55910933\",\n \"0.55910933\",\n \"0.55624384\",\n \"0.55190325\",\n \"0.55054754\",\n \"0.5468469\",\n \"0.5447353\",\n \"0.54365796\",\n \"0.5429421\",\n \"0.5418774\",\n \"0.5406786\",\n \"0.53993124\",\n \"0.53917307\",\n \"0.53776854\",\n \"0.5367113\",\n \"0.5364031\",\n \"0.53604114\",\n \"0.53365034\",\n \"0.53297204\",\n \"0.5324961\",\n \"0.5319152\",\n \"0.53172207\",\n \"0.53134525\",\n \"0.5309881\",\n \"0.5304874\",\n \"0.5299356\",\n \"0.5291189\",\n \"0.52819794\",\n \"0.52743906\",\n \"0.52649033\",\n \"0.52600974\",\n \"0.52501875\",\n \"0.5245689\",\n \"0.5245638\",\n \"0.52240884\",\n \"0.52229345\",\n \"0.52125\",\n \"0.52086633\",\n \"0.5206865\",\n \"0.51891965\",\n \"0.518201\",\n \"0.518201\",\n \"0.51811594\",\n \"0.5180423\",\n \"0.51760614\",\n \"0.51677775\",\n \"0.51677775\",\n \"0.5161713\",\n \"0.5156817\",\n \"0.5156572\",\n \"0.5153086\",\n \"0.51529914\",\n \"0.51438123\",\n \"0.5142331\",\n \"0.51417357\",\n \"0.5141168\",\n \"0.51378894\",\n \"0.5137704\",\n \"0.5137194\",\n \"0.51368064\",\n \"0.5132928\",\n \"0.51312023\",\n \"0.512844\",\n \"0.5127816\",\n \"0.51239777\",\n \"0.51233834\",\n \"0.5123249\",\n \"0.5123249\",\n \"0.5123249\",\n \"0.5123249\",\n \"0.5123249\",\n \"0.51231515\",\n \"0.5120981\",\n \"0.5120627\",\n \"0.5117872\",\n \"0.5117194\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":583,"cells":{"query":{"kind":"string","value":"do api request, parse error, return response."},"document":{"kind":"string","value":"def get_subtitleinfo(fileFullName):\n sys.stdout.write(\"Requesting subtitle info...\\n\")\n\n #接口获取字幕信息\n response = requests.post(\n \"https://www.shooter.cn/api/subapi.php\",\n verify=False,\n params= {\n 'filehash': ComputeFileHash(fileFullName),\n 'pathinfo': os.path.realpath(fileFullName),\n 'format': 'json',\n 'lang': \"Chn\",\n },\n )\n #未找到字幕处理\n if response.text == u'\\xff':\n sys.stderr.write(\"Subtitle not found.\\n\")\n sys.exit(1)\n return response"},"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":["async def _api_request(self,\n method: str,\n path_url: str,\n params: Dict[str, Any] = {}) -> Dict[str, Any]:\n base_url = f\"https://{global_config_map['gateway_api_host'].value}:\" \\\n f\"{global_config_map['gateway_api_port'].value}\"\n url = f\"{base_url}/{path_url}\"\n client = await self._http_client()\n if method == \"get\":\n if len(params) > 0:\n response = await client.get(url, params=params)\n else:\n response = await client.get(url)\n elif method == \"post\":\n response = await client.post(url, data=params)\n\n parsed_response = json.loads(await response.text())\n if response.status != 200:\n err_msg = \"\"\n if \"error\" in parsed_response:\n err_msg = f\" Message: {parsed_response['error']}\"\n raise IOError(f\"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}\")\n if \"error\" in parsed_response:\n raise Exception(f\"Error: {parsed_response['error']}\")\n\n return parsed_response","def api_call():\n\tresponse = requests.get(URL_API)\n\treturn response","def _api_request(self, endpoint, params=None):\n \n if params:\n response = requests.get(url=f\"{self.api_url}/{endpoint}\", headers={\"Authorization\":self.auth_header},\n params=params)\n else:\n response = requests.get(url=f\"{self.api_url}/{endpoint}\", headers={\"Authorization\":self.auth_header})\n code = response.status_code\n if 200 <= code < 300:\n logging.debug(f\"API call: {self.api_url}/{endpoint} | {code}\")\n encoding = response.encoding\n raw = response.content\n return json.loads(raw.decode(encoding))\n elif code > 500:\n raise APIAuthException\n else:\n logging.error(f\"ERROR: Bad API call: {self.api_url}/{endpoint} | {code}\")","def get_response(request):\n uri = \"api.php\"\n response_body = None\n url = proto + \"://\" + host + \"/\" + api_dir + \"/\" + uri\n logger.debug(\"Enter get_response(url=\" + url + \") with request:\")\n logger.debug(request)\n if proto == \"http\":\n conn = httplib.HTTPConnection(host)\n elif proto == \"https\":\n conn = httplib.HTTPSConnection(host)\n else:\n logger.error(\"Unsupported protocol \" + proto)\n return None\n http_response = \"\"\n try:\n conn.connect()\n logger.debug(\"Sending to \" + host + \":\")\n logger.debug(request)\n data_json = json.dumps(request)\n data_json_enc = data_json\n data_json_enc_urlenc = urllib.urlencode({'data': data_json_enc})\n conn.putrequest('POST', \"/\" + api_dir + \"/\" + uri)\n headers = {'Content-Length': \"%d\" % (len(data_json_enc_urlenc)),\n 'Content-Type': 'application/x-www-form-urlencoded'}\n for k in headers:\n conn.putheader(k, headers[k])\n conn.endheaders()\n conn.send(data_json_enc_urlenc)\n http_response = conn.getresponse()\n if http_response.status == 200:\n response_body = http_response.read()\n logger.debug(\"Response from server: %s\" % response_body)\n if not response_body:\n return None\n url = \"%(proto)s://%(host)s/%(api_dir)s/%(uri)s\" % {\n \"proto\": proto,\n \"host\": host,\n \"api_dir\": api_dir,\n \"uri\": uri\n }\n logger.debug(\"Response from %(url)s : %(resp)s\" % {\n \"url\": url,\n \"resp\": response_body\n })\n else:\n logger.error(\"HTTP error %d %s\" % (http_response.status, http_response.reason))\n except socket.error as err:\n logger.error(\"Exception while making request \" + url)\n logger.error(err)\n logger.error(\"Please check that DNS server is reachable and works\")\n return None\n except exceptions.KeyError as err:\n logger.error(\"Failed to decode response from server %s\" % http_response)\n logger.error(\"Could not find key %s\" % err)\n return None\n finally:\n conn.close()\n return response_body","def __exec_request(self, URL) -> Any:\n headers = {\n \"X-ELS-APIKey\": self.config['apikey'],\n \"Accept\": 'application/json'\n }\n\n request = requests.get(\n URL,\n headers=headers\n )\n self._status_code = request.status_code\n\n if request.status_code == 200:\n return json.loads(request.text, strict=False)\n else:\n return \"failed\"","def _http_get(self, url, params={}):\n if not self.token:\n self.get_token()\n headers = {'Authorization': self.token, 'Accept': 'application/json; indent=4'}\n url = self.server + '/api2' + url\n try:\n r = requests.get(url=url, headers=headers, params=params)\n except requests.exceptions.RequestException as e:\n return check_failed(e)\n # raise ClientHttpError(None, e)\n if r.status_code != 200:\n return check_failed(r.status_code)\n # return ClientHttpError(r.status_code, json.loads(r.text)['error_msg'])\n try:\n data = json.loads(r.text)\n except:\n data = r.text\n # TODO: check data\n return data","def _get_api_request(url):\n req = requests.get(url)\n\n if not req.status_code == 200:\n print(\"Error getting API request:\", url)\n print(\"Status code:\", req.status_code)\n print(\"Error:\", req.text)\n exit(200)\n\n data = None\n try:\n data = req.json()\n except JSONDecodeError:\n print(\"WarcraftLogs did not return proper JSON, it is likely down for maintenance.\")\n print(\"Request response:\", req.text)\n exit(300)\n\n return data","def call_api(self):\n #generate the final call string\n self.generate_call_string();\n #debug\n #print (self.call_url);\n \n #finally make api call\n try: \n #pass; \n self.return_articles= json.loads(urlopen(self.call_url).read());\n #print json.dumps(self.return_articles, indent=4, sort_keys=True)\n except :#elaborate on this later\n print(\"Exception,response did not go through:\");\n e = sys.exc_info()[0]\n print(e);\n raise;\n return;","def call_api_endpoint(url, data):\n try:\n \n req = urllib2.Request(url, data, {'Content-Type': 'application/json'})\n \n f = urllib2.urlopen(req)\n response = f.read()\n f.close()\n return response\n\n \n except urllib2.HTTPError, e:\n if e.code == 400:\n return -1","def _request(self, endpoint: str = \"/api/\", params: object = {}) -> dict:\n ret: dict = {}\n try:\n if not self.api_key:\n ret[\"error\"] = \"API key is empty\"\n raise APIError(ret['error'])\n\n r = requests.get(f\"{self.apibase}{endpoint}\",\n params=params,\n headers=self.headers,\n verify=self.verify_ssl)\n response_data = orjson.loads(r.text)\n except orjson.JSONDecodeError:\n ret[\"error\"] = \"Failed to parse response data to JSON\"\n if self.debug:\n ret[\"error\"] += \"\\nDescription: \" + r.reason\n ret[\"error\"] += \"\\nData: \" + r.text\n except requests.HTTPError:\n ret[\"error\"] = f\"{r.status_code}: {r.reason}\"\n if self.debug:\n ret[\"error\"] += \"\\nDescription: \" + r.reason\n ret[\"error\"] += \"\\nData: \" + r.text\n\n if ret.get('error', None):\n raise APIError(ret['error'])\n check_status_code(request=r, debug=self.debug, ret=ret)\n\n ret = response_data\n return ret","def _api_request(*args, **kwargs):\n response = requests.request(*args, **kwargs)\n return APIResponse(response)","def _do_request(self, url, method='GET', body=None):\n response, content = self.request(url, method=method, body=body, headers=self.headers)\n if int(response['status']) != 200:\n raise GPAPIError(response['status'], 'ERROR IN REQUEST')\n json = simplejson.loads(content)\n return json","def _api_request(self, path, method, data=None, query=None):\n\n url = request_url(\n self.config['secure'],\n self.config['hostname'],\n self.config['port'],\n path,\n query,\n )\n\n try:\n resp = request(\n url,\n method,\n self._headers(),\n data,\n self.config['timeout'],\n )\n\n return Response(\n resp.get('meta', {}),\n # Response info may have 'object' or 'objects' key, depending\n # on whether there are 1 or multiple results.\n resp.get('object', resp.get('objects'))\n )\n except HTTPError as e:\n response = e.read()\n fallback = '{0} {1}'.format(e.code, e.msg)\n\n if isinstance(response, bytes):\n data = response.decode('utf8')\n else:\n data = response\n\n error = json.loads(data).get('error', {})\n message = error.get('message', fallback)\n raise HTTPResponseError(message, status_code=e.code, cause=e)","def http_request(endpoint, data, method='POST'):\n url = BASE_API + endpoint\n data['authkey'] = AUTH_KEY\n\n response = requests.request(method, url=url, data=data, timeout=300, verify=VERIFY)\n if response.status_code == 200:\n try:\n return response.json()\n except Exception as e:\n return_error('Response JSON decoding failed due to {}'.format(str(e)))\n\n else:\n return_error('API Returned, {}:{}'.format(response.status_code, response.reason))","def _request_get(self, url):\n try:\n r = requests.get(url)\n except Exception:\n raise Exception('Cannot connect')\n if (r.status_code != 200):\n raise Exception('%d %s' % (r.status_code, r.text))\n if (not r.text) or (not r.text.strip()):\n raise Exception('Empty answer')\n try:\n response = json.loads(r.text)\n except Exception:\n raise Exception('Cannot parse response')\n return response","def _handle_api_call(self, url):\n response = urlopen(url)\n url_response = response.read()\n json_response = loads(url_response)\n \n if not json_response:\n raise ValueError('Error getting data from the api, no return was given.')\n elif \"Error Message\" in json_response:\n raise ValueError(json_response[\"Error Message\"])\n elif \"Information\" in json_response and self.treat_info_as_error:\n raise ValueError(json_response[\"Information\"])\n \n return json_response","def __make_api_get(self, api_path):\n try:\n self.last_response = urllib2.urlopen(\n self.api_server + api_path, cafile=self.cacert_path)\n json_data = self.last_response.read()\n\n # Check for errors\n except urllib2.HTTPError as err:\n error = \"API HTTP error [%s] - '%s'\" % (err.code, err.read())\n raise EFIgyCliError(error, self.last_response)\n\n except urllib2.URLError as err:\n error = 'Problem calling API at location %s - %s' % (\n self.api_server + api_path, err)\n raise EFIgyCliError(error, self.last_response)\n\n # Decode json response into an object\n try:\n ret = json.loads(json_data)\n except ValueError as err:\n error = \"Problem deserialising data, expecting JSON.\\nError: %s\\nData: %s\" % (\n err, json_data)\n raise EFIgyCliError(error, self.last_response)\n\n # Return JSON deserialised object\n return ret","def __request(self,endpoint):\n apiRequest = requests.get(\"%s/%s\" % (self.baseurl,endpoint), \n auth=requests.auth.HTTPBasicAuth(self.api_id, self.api_secret))\n try:\n json = apiRequest.json()\n return json\n except JSONDecodeError:\n print(\"Failed to download or failed to parse JSON.\")\n print(apiRequest)\n return None","async def request(\r\n self, method: str, url: str, params: dict = None, data: dict = None\r\n ):\r\n async with self._session.request(\r\n method,\r\n url,\r\n params=params,\r\n json=data,\r\n headers={\"Authorization\": \"Bearer \" + self._token},\r\n ) as resp:\r\n if resp.status == 200:\r\n return await resp.json()\r\n if resp.status in (400, 422, 429, 500):\r\n data = None\r\n try:\r\n data = await resp.json()\r\n except Exception: # pylint: disable=broad-except\r\n pass\r\n raise APIResponseError(\r\n resp.request_info,\r\n resp.history,\r\n status=resp.status,\r\n message=resp.reason,\r\n headers=resp.headers,\r\n data=data,\r\n )\r\n resp.raise_for_status()","def _send_in_request(self):\n try:\n req_params = urllib.urlencode(self._params)\n except Exception as ex:\n raise ProxyError('Error signing request string') \n \n try:\n self.logger.debug('Send api request to: %s' % self._api_url)\n self.logger.debug('Request params: %s' % req_params)\n self.logger.debug('Request timeout: %s' % self._timeout)\n if len(self._params) > 0:\n f = urllib2.urlopen(self._api_url, req_params, self._timeout)\n response = f.read()\n self.logger.debug('Response length: %s' % len(response))\n f.close() \n return response\n else:\n return \"{'command':'ping', 'message':'ok'}\" \n except (urllib2.URLError) as ex:\n self._error = json.loads(ex.fp.readline()).values()\n raise ProxyResponseError()\n except (IOError) as ex:\n raise ProxyError(ex)","def api_req(dev, api_call):\r\n import xmltodict\r\n import logging\r\n try:\r\n r = requests.get(dev + ':8060' + api_call, timeout=5)\r\n except Exception as exc:\r\n response = [\"ERR\", exc]\r\n return response[0]\r\n except ConnectionError as connerr:\r\n response = [\"ERR\", connerr]\r\n return response[0]\r\n except TimeoutError as toerr:\r\n response = [\"ERR\", toerr]\r\n return response[0], toerr\r\n r_code = r.status_code\r\n if r_code == 200:\r\n print(\"REQUEST WAS A SUCCESS. DEVICE RETURNED: {} \".format(str(r)))\r\n r2 = r.text\r\n response = xmltodict.parse(r2, xml_attribs=False)\r\n return response\r\n else:\r\n response = \"UnknownERR\"\r\n dev.state(DISABLED)\r\n return msg_box(response)","def _api_request(date: str, api_url: str) -> Dict[str, str]:\n try:\n data = json.loads(urlopen(\n Request(f\"{api_url}?at={quote(date)}\")\n ).read().decode('utf-8'))\n except HTTPError as e:\n data = json.loads(e.file.read().decode('utf-8'))\n if \"message\" in data:\n raise ValidationError(data[\"message\"])\n else:\n raise ValidationError(f\"Service unavailable ({e}\")\n return data","def parse_api(baseurl):\n\t# Make 4 api calls in total\n\tfor call in range(1, 5):\n\t\t# Write an error to file if no response after 4 attempts\n\t\tif call == 4:\n\t\t\twith open('errors.txt', 'a') as file:\n\t\t\t\tfile.write(\"Server is not responding after 4 attempts. Time: {}\\n\".format(\n\t\t\t\t\tdt_to_string(datetime.datetime.now())\n\t\t\t\t))\n\t\t\treturn False\n\t\ttry:\n\t\t\t# download data from api\n\t\t\tresult = urllib.request.urlopen(baseurl).read()\n\t\t\treturn result\n\t\texcept urllib.error.URLError:\n\t\t\t# wait 10 minutes if server is not responding and make another call\n\t\t\tprint(\"Seems like server is not responding. Will try again in 10 minutes...\")\n\t\t\ttime.sleep(660)","def _handle_api_result(self, response, params, tries, wait, ae_retry):\n try:\n res = response.json()\n except ValueError:\n e = \"API query failed: JSON could not be decoded.\"\n raise exceptions.APIError(e)\n\n if \"warnings\" in res:\n for name, value in res[\"warnings\"].items():\n try:\n warning = value[\"warnings\"]\n except KeyError:\n try:\n warning = value[\"*\"]\n except KeyError:\n warning = value\n self._logger.warning(\"API warning: %s: %s\", name, warning)\n\n if self._should_save_cookiejar():\n self._save_cookiejar()\n\n try:\n code = res[\"error\"][\"code\"]\n info = res[\"error\"][\"info\"]\n except (TypeError, KeyError): # If there's no error code/info, return\n if \"query\" in res and \"tokens\" in res[\"query\"]:\n for name, token in res[\"query\"][\"tokens\"].items():\n self._tokens[name.split(\"token\")[0]] = token\n return res\n\n if code == \"maxlag\": # We've been throttled by the server\n if tries >= self._max_retries:\n e = \"Maximum number of retries reached ({0}).\"\n raise exceptions.APIError(e.format(self._max_retries))\n tries += 1\n msg = 'Server says \"{0}\"; retrying in {1} seconds ({2}/{3})'\n self._logger.info(msg.format(info, wait, tries, self._max_retries))\n sleep(wait)\n return self._api_query(params, tries, wait * 2, ae_retry=ae_retry)\n elif code in [\"assertuserfailed\", \"assertbotfailed\"]: # AssertEdit\n if ae_retry and all(self._login_info) and not self._oauth:\n # Try to log in if we got logged out:\n self._login(self._login_info)\n if \"token\" in params: # Fetch a new one; this is invalid now\n params[\"token\"] = self.get_token(params[\"action\"])\n return self._api_query(params, tries, wait, ae_retry=False)\n if not all(self._login_info) and not self._oauth:\n e = \"Assertion failed, and no login info was provided.\"\n elif code == \"assertbotfailed\":\n e = \"Bot assertion failed: we don't have a bot flag!\"\n else:\n e = \"User assertion failed due to an unknown issue. Cookie or OAuth problem?\"\n raise exceptions.PermissionsError(\"AssertEdit: \" + e)\n else: # Some unknown error occurred\n e = 'API query failed: got error \"{0}\"; server says: \"{1}\".'\n error = exceptions.APIError(e.format(code, info))\n error.code, error.info = code, info\n raise error","def __apiRequest(self, url, parms={}):\n authparms = self.__addAuthParms(parms);\n request = self.http.request('GET', url, fields=authparms)\n if request.status != 200:\n raise ApiCommunicationError('Failed to retrieve data from Marvel, HTTP Status {}'.format(request.status))\n else:\n return json.loads( request.data.decode('utf-8') )","def api_call():\n\n json_str = load_input()\n output = {\n 'inputs': json_str,\n 'results': 'cool results'}\n\n return json.dumps(output), 200, {'Content-Type': 'text/plain;charset=utf-8'}","def call(self):\n # if this is a POST request, process data\n if self.data:\n post_json = json.dumps(self.data)\n values = {'json': post_json, 'apikey': API_KEY}\n post = urllib.parse.urlencode(values)\n\n else:\n post = None\n\n req = urllib.request.Request(self.url, post)\n\n try:\n self.response = urllib.request.urlopen(req, timeout=self.timeout)\n\n except (URLError, HTTPError, timeout) as error:\n self.response = error","def api_call(uri, name, method='get', **kwargs):\n # Ensure uri is valid\n if not bool(urlparse.urlparse(uri).netloc):\n print(\"Error: {0} is not a valid url\").format(uri)\n return False\n func = getattr(requests, method)\n args = {}\n for key, value in kwargs.iteritems():\n args[key] = value\n try:\n response = func(uri, **args)\n except requests.exceptions.Timeout:\n print \"The api call to {0} timed out\".format(uri)\n except requests.exceptions.TooManyRedirects:\n print \"The api call to {0} appears incorrect, returned: too many re-directs\".format(uri)\n except requests.exceptions.RequestException as error:\n print \"The api call to {0} failed\\n Error {1}\".format(uri, error)\n sys.exit(1)\n try:\n response_dictionary = response.json()\n except ValueError:\n return response\n #If API call errors out print the error and quit the script\n if response.status_code not in [200, 201]:\n if 'errors' in response_dictionary:\n errors = response_dictionary.pop('errors')\n first_error = errors.pop()\n elif 'error' in response_dictionary:\n first_error = response_dictionary.pop('error')\n else:\n first_error['message'] = \"No error message provided by response\"\n msg = \"{0} returned an error, exiting the script.\\n\".format(name)\n msg += \"Status Code: {0} \\n\".format(response.status_code)\n msg += \"Error: {0}\".format(first_error['message'])\n print msg\n return False\n else:\n return response_dictionary","def perform_request(self,\n request: RequestBase,\n method: str='POST'\n ):\n headers = {\n 'Accept': 'application/json',\n 'User-Agent': self.user_agent()\n }\n if APIAuthentication.use_http_auth:\n headers['Authorization'] = 'Basic {auth}'.format(auth=self.get_auth())\n\n # Lazy loader for api credentials.\n if request.requires_api_token() and ParamValidator.is_empty(request.api_token)\\\n and ParamValidator.not_empty(APIAuthentication.api_token):\n request.api_token = APIAuthentication.api_token\n if request.requires_service_id() and ParamValidator.is_empty(request.service_id)\\\n and ParamValidator.not_empty(APIAuthentication.service_id):\n request.service_id = APIAuthentication.service_id\n\n # Build url\n url = \"{0}/{1}\".format(PAYNL_END_POINT, request.get_url())\n parameters = request.get_parameters()\n if APIAuthentication.use_http_auth and 'token' in parameters:\n del parameters['token']\n\n if self.print_debug:\n print(\"Calling {} using {}\".format(url, method))\n print(\"HTTP Headers: {}\".format(json.dumps(headers)))\n print(\"Params: {}\".format(json.dumps(parameters)))\n\n if method.upper() == 'GET':\n response = requests.get(url, verify=True, headers=headers, params=parameters)\n else:\n response = requests.post(url, verify=True, headers=headers, data=parameters)\n\n if response.status_code not in self.__supported_status_codes:\n response.raise_for_status()\n\n if self.print_debug:\n print(\"Response object: {}\".format(response))\n print(\"Raw response: {}\".format(response.text))\n\n # Now the we have a response, let the request class handle the response.\n request.raw_response = response.text\n\n if self.print_debug:\n print(type(request.response))\n\n if request.response.is_error():\n raise ErrorException(request.response.request)","def _make_request(self, url: str, parameters: dict = None,\n method: str = 'GET', *args, **kwargs):\n response = requests.request(\n method=method,\n url=build_url(\n self.BASE_API_URL, url, parameters\n ),\n headers={\n 'Authorization': 'Bearer {}'.format(self._access_token)\n }, **kwargs\n )\n if response.ok:\n return response.json()\n raise MondoApiException(response.json()['message'])","def _call_api(endpoint, query, data):\n headers = {\"Content-Type\": \"application/json\", }\n response = InnerTube._execute(f\"{endpoint}?{parse.urlencode(query)}\", \"POST\", headers=headers, data=data)\n\n try:\n resp = json.loads(response.read())\n except JSONDecodeError as e:\n log(f\"{__class__.__name__}: Parsing response error: {e}\")\n else:\n return resp","def _doRequest(self, httpClientMethod, *args):\n try:\n resp = httpClientMethod(*args)\n return resp.json()\n except RequestException as e:\n raise checkedError(e)","def call_api(url):\n\n req = requests.get(url)\n return req","def call_api(url):\n\n req = requests.get(url)\n return req","def _process_url(self, url):\n response = requests.get(url, timeout=self.TIMEOUT)\n try:\n ret = response.json()\n except JSONDecodeError:\n self.log.exception(\"JSONDecodeError, response: %r, response.text: %r\", response, response.text)\n ret = {\"error\": \"The api broke.\"}\n return ret","def api_call(url, method, debug, **kwargs):\n resp = None\n attempt = 0\n maxattempts = 3\n req = Request(method.upper(), url, **kwargs)\n\n if debug:\n print(\"DEBUG: Request ({}) {}\".format(method.upper(), url))\n\n while True:\n try:\n attempt += 1\n resp = Session().send(\n Session().prepare_request(req), verify=True)\n resp.raise_for_status()\n break\n except (HTTPError, ConnectionError, Timeout) as ex:\n if attempt >= maxattempts:\n abort(ex.message)\n else:\n time.sleep(1)\n continue\n except RequestException as ex:\n abort(ex.message)\n\n if resp is not None:\n return resp\n else:\n abort(\"Error making API call to URL: \" % url)","def call(self, http_method, api_path, params=None, raw_data=False):\n\n # get function of requests package\n requests_func = getattr(requests, http_method.lower())\n\n # parse parameters\n req_params = {}\n file_params = {}\n\n if params is not None:\n for key, value in six.iteritems(params):\n if isinstance(value, (datetime.date,\n datetime.datetime,\n float,\n int)):\n req_params[key] = six.text_type(value)\n elif isinstance(value, six.string_types):\n req_params[key] = six.text_type(value)\n elif hasattr(value, \"read\"):\n filename = os.path.split(value.name)[1]\n if not _is_string_ascii_encodeable(filename):\n b64_key = key + \"name_b64enc\"\n byte_value = filename.encode(\"utf-8\")\n b64_value = base64.b64encode(byte_value).decode(\"utf-8\")\n\n filename = \"@param=%s\" % b64_key\n req_params[b64_key] = b64_value\n file_params[key] = (filename, value, \"application/octet-stream\")\n else:\n raise VMRayRESTAPIError(\"Parameter \\\"{}\\\" has unknown type \\\"{}\\\"\".format(key, type(value)))\n\n # construct request\n if file_params:\n files = file_params\n else:\n files = None\n\n # we need to adjust some stuff for POST requests\n if http_method.lower() == \"post\":\n req_data = req_params\n req_params = None\n else:\n req_data = None\n\n # do request\n result = requests_func(self.server + api_path,\n data=req_data,\n params=req_params,\n headers={\"Authorization\": \"api_key {}\".format(self.api_key)},\n files=files,\n verify=self.verify_cert,\n stream=raw_data)\n handle_rest_api_result(result)\n\n if raw_data:\n return result.raw\n\n # parse result\n try:\n json_result = result.json()\n except ValueError:\n raise ValueError(\"API returned invalid JSON: {}\".format(result.text))\n\n # if there are no cached elements then return the data\n if \"continuation_id\" not in json_result:\n return json_result.get(\"data\", None)\n\n data = json_result[\"data\"]\n\n # get cached results\n while \"continuation_id\" in json_result:\n # send request to server\n result = requests.get(\"{}/rest/continuation/{}\".format(self.server, json_result[\"continuation_id\"]),\n headers={\"Authorization\": \"api_key {}\".format(self.api_key)},\n verify=self.verify_cert)\n handle_rest_api_result(result)\n\n # parse result\n try:\n json_result = result.json()\n except ValueError:\n raise ValueError(\"API returned invalid JSON: {}\".format(result.text))\n\n data.extend(json_result[\"data\"])\n\n return data","def call_api(self, url, method='GET', headers=None, params=None, data=None):\n r = requests.request(method=method, url=url, headers=headers, params=params, data=data)\n \n self.log.debug(f'Called endpoint {url} with result {r}')\n\n try:\n jayson = json.loads(r.text)\n return jayson\n except:\n self.log.info(f'ERROR! Text of response object: {r.text}')","async def _make_request(self, url: str, params, server_id: str):\n headers = {\n 'X-Response-Control': 'minified',\n 'User-Agent': 'Friendly Red bot'\n }\n\n if server_id in self.config:\n if 'API_TOKEN' in self.config[server_id]:\n headers['X-Auth-Token'] = self.config['API_TOKEN']\n else:\n await self.bot.say(box('Requests made without an authentication token are limited to 100 requests per 24 hours.\\nYou can request a key by registering at http://api.football-data.org and setting it via [p]football tokenset.'))\n\n async with aiohttp.get(url, headers=headers, params=params) as r:\n if r.status == 200:\n data = await r.json()\n return data\n elif r.status == 400:\n await self.bot.say(box('Bad Request [400]:\\nYour request was malformed most likely the value of a Filter was not set according to the Data Type that is expected.'))\n return\n elif r.status == 403:\n await self.bot.say(box('Restricted Resource [403]:\\nYou tried to access a resource that exists, but is not available for you. This can be out of the following reasons:\\n- the resource is only available to authenticated clients\\n- the resource is only available to donating clients\\n- the resource is not available in the API version you are using'))\n return\n elif r.status == 404:\n await self.bot.say(box('Not found [404]\\nYou tried to access a resource that doesn’t exist.'))\n return\n elif r.status == 429:\n await self.bot.say(box('Too many requests [429]\\nYou exceeded your allowed requests per minute/day depending on API version and your user status.\\nSee http://api.football-data.org/docs/v1/index.html#_request_throttling for more information.'))\n await self.bot.say(box('Requests reset in ' + r.headers['X-RequestCounter-Reset'] + ' seconds.'))\n return\n else:\n await self.bot.say(box('Pancake has no idea what you\\'ve done, seriously.'))\n await self.bot.say(box(r.status + '\\n' + r.json()['error']))\n return","def _call(self, method, url, params):\n if not url.startswith('http'):\n url = self.root + url\n headers = self._auth_headers()\n headers['Content-Type'] = 'application/json'\n\n r = self._session.request(method, url,\n headers=headers,\n proxies=self.proxies,\n params=params,\n timeout=self.requests_timeout)\n r.raise_for_status() # Check for error\n return r.json()","def _get_request(url_root,api_key,path,response_type,params, ssl_verify):\n url = _url_builder(url_root,api_key,path,params)\n content = _fetch(url, ssl_verify)\n response = _dispatch(response_type)(content)\n return response","def _do_request(self, url: str):\n\n self.debug.ok('method', self.method)\n\n if self.client.fake_response_path:\n with open(self.client.fake_response_path, 'r') as f:\n return constants.ResponseCode.OK, f.read()\n\n elif self.method == constants.RequestConst.GET:\n response = requests.get(\n url, headers=self._headers(), timeout=self._timeout\n )\n\n self.debug.ok(\n constants.RequestConst.QUERY_PARAMETERS,\n self.parameters[constants.RequestConst.QUERY]\n )\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\n\n return response.status_code, response.text\n\n elif self.method in [\n constants.RequestConst.POST,\n constants.RequestConst.PUT,\n constants.RequestConst.DELETE\n ]:\n if self.method == constants.RequestConst.POST:\n send_request = requests.post\n elif self.method == constants.RequestConst.PUT:\n send_request = requests.put\n elif self.method == constants.RequestConst.DELETE:\n send_request = requests.delete\n\n response = send_request(\n url, json=self.parameters[constants.RequestConst.QUERY],\n headers=self._headers(), timeout=self._timeout\n )\n\n self.debug.ok('payload', self.parameters[\n constants.RequestConst.QUERY\n ])\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\n\n return response.status_code, response.text\n\n else:\n return constants.ResponseCode.NOT_FOUND, {}","def pull(self, url, params=None, data=None, auth=None, method=\"GET\"):\n try:\n __method_name = inspect.currentframe().f_code.co_name\n if method == \"POST\":\n res = self.session.post(\n url=url,\n auth=auth,\n params=params,\n data=data,\n timeout=consts.API_TIMEOUT,\n )\n else:\n res = self.session.get(\n url=url,\n auth=auth,\n params=params,\n data=data,\n timeout=consts.API_TIMEOUT,\n )\n res.raise_for_status()\n if res and res.status_code in [200, 201]:\n self.applogger.debug(\n '{}(method={}) : {} : API call: Response received successfully. url=\"{}\" params=\"{}\"'.format(\n consts.LOGS_STARTS_WITH,\n __method_name,\n self.function_name,\n url,\n params,\n )\n )\n return res.json()\n else:\n self.applogger.error(\n \"{}(method={}) : {} : API call: Unknown status code or empty \"\n 'response: url=\"{}\" status_code=\"{}\" response=\"{}\"'.format(\n consts.LOGS_STARTS_WITH,\n __method_name,\n self.function_name,\n url,\n res.status_code,\n res.text,\n )\n )\n raise Exception(\"Received unknown status code or empty response.\")\n except requests.exceptions.HTTPError as ex:\n if res.status_code == 404:\n self.applogger.debug(\n '{}(method={}) : {} : API call: Got {} Status Code : url=\"{}\"'\n ' response=\"{}\"'.format(\n consts.LOGS_STARTS_WITH,\n __method_name,\n self.function_name,\n url,\n ex.response.status_code,\n ex.response.text,\n )\n )\n return {}\n else:\n self.applogger.error(\n '{}(method={}) : {} : API call: Unsuccessful response: url=\"{}\" status_code=\"{}\"'\n ' response=\"{}\"'.format(\n consts.LOGS_STARTS_WITH,\n __method_name,\n self.function_name,\n url,\n ex.response.status_code,\n ex.response.text,\n )\n )\n raise Exception(\"HTTP Error Occurred while getting response from api.\")\n except Exception as ex:\n self.applogger.error(\n '{}(method={}) : {} : API call: Unexpected error while API call url=\"{}\" error=\"{}\"'.format(\n consts.LOGS_STARTS_WITH,\n __method_name,\n self.function_name,\n url,\n str(ex),\n )\n )\n raise Exception(\"Error Occurred while getting response from api.\")","async def handle_request(self, api_endpoint, api_version):\n code = 400\n data = self.get_post_data()\n request_method = self.request.method.lower()\n if data:\n try:\n # will call process_get or process_post methods for the given API\n res = await getattr(api_endpoint, 'process_' + request_method)(api_version, data)\n code = 200\n except ValidationError as validerr:\n if validerr.absolute_path:\n res = '%s : %s' % (\n validerr.absolute_path.pop(), validerr.message)\n else:\n res = '%s' % validerr.message\n LOGGER.error('ValidationError: %s', res)\n raise tornado.web.HTTPError(reason=res)\n except ValueError as valuerr:\n res = str(valuerr)\n LOGGER.error('ValueError: %s', res)\n raise tornado.web.HTTPError(reason=res)\n except DatabaseError as dberr:\n err_id = dberr.__hash__()\n res = str(dberr.reason)\n LOGGER.error(res)\n LOGGER.info(\"Input data for <%s>: %s\", err_id, data)\n raise dberr\n except Exception as err: # pylint: disable=broad-except\n err_id = err.__hash__()\n res = 'Internal server error <%s>:' \\\n 'please include this error id in bug report.' % err_id\n code = 500\n LOGGER.exception(res)\n LOGGER.info(\"Input data for <%s>: %s\", err_id, data)\n raise tornado.web.HTTPError(reason=res)\n else:\n res = 'Error: malformed input JSON.'\n LOGGER.error(res)\n raise tornado.web.HTTPError(reason=res)\n\n # raise tornado.web.HTTPError(status_code=444, reason='error happened')\n self.set_status(code)\n self.write(res)","def _execApiCall(headers, params, method_name,\r\n domain='ma.gnolia.com',\r\n urlhead='/api/rest/1/'):\r\n \r\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\r\n raise MagnoliaException('Required API Key parameter missing')\r\n conn = httplib.HTTPConnection(domain)\r\n conn.request('POST', urlhead + method_name, params, headers)\r\n return conn.getresponse()","def _parse_response(self, response, all_ops):\n try:\n parsed_response = json.loads(response)\n except Exception, e:\n raise ApiError(e)\n if 'error' in parsed_response: # needed anymore?\n raise ApiError(parsed_response['error'])\n # Return the true API return value.\n return parsed_response","def api():\n try:\n data = json.loads(request.data)\n except:\n return jsonify({\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"Parse error\"}, \"id\": None}), 500\n return jsonify(hwi.jsonrpc(data))","def _request(self, method, url, body=None, headers=None, serialize=True):\n headers = headers or {}\n headers['Accept'] = 'application/json'\n headers['User-Agent'] = 'paxes-httpclient'\n if body and not 'Content-Type' in headers:\n headers['Content-Type'] = 'application/json'\n if self.auth_token:\n headers['X-Auth-Token'] = self.auth_token\n LOG.debug('>> %s %s, %s, %s' % (method, url, headers, body))\n conn = self._create_connection(url)\n if body and serialize:\n body = json.dumps(body)\n conn.request(method, url, body, headers)\n res = conn.getresponse()\n header_list = res.getheaders()\n header_dict = {}\n for ituple in header_list:\n header_dict[ituple[0].lower()] = ituple[1]\n response_info = {\n 'status': res.status,\n 'reason': res.reason,\n 'headers': header_dict,\n 'body': res.read()\n }\n LOG.debug('<< %d %s, %s, %s' % (response_info['status'],\n response_info['reason'],\n response_info['headers'],\n response_info['body']))\n conn.close()\n return response_info","def _http_post(self, url, params={}):\n url = self.server + '/api2' + url\n try:\n r = requests.post(url=url, data=params)\n except requests.exceptions.RequestException as e:\n return check_failed(e)\n # raise ClientHttpError(None, e)\n if r.status_code != 200:\n return check_failed(r.status_code)\n # return ClientHttpError(r.status_code, r.text)\n data = json.loads(r.text)\n # TODO: check data\n return data","def make_request(request_url, request_url_without_api_key):\n response = requests.get(request_url)\n if response.status_code != requests.codes.ok:\n err = \"Check the URL and API details, cannot connect to: `{}`\".format(\n request_url_without_api_key\n )\n logger.error(err)\n raise TaskError(\"Bad response from server: {}\".format(err))\n try:\n packages = response.json()\n except json.JSONDecodeError:\n err = \"Response is OK, but cannot decode JSON from server\"\n logger.error(err)\n raise TaskError(err)\n return packages","def _request(http, project, method, data, base_url, client_info):\n user_agent = client_info.to_user_agent()\n headers = {\n \"Content-Type\": \"application/x-protobuf\",\n \"User-Agent\": user_agent,\n connection_module.CLIENT_INFO_HEADER: user_agent,\n }\n api_url = build_api_url(project, method, base_url)\n\n response = http.request(url=api_url, method=\"POST\", headers=headers, data=data)\n\n if response.status_code != 200:\n error_status = status_pb2.Status.FromString(response.content)\n raise exceptions.from_http_status(\n response.status_code, error_status.message, errors=[error_status]\n )\n\n return response.content","async def _perform_api_request(self, url, **kwargs):\n error = ''\n json = {}\n max_retries = 5\n for retries in range(max_retries):\n async with self._session.get(url, **kwargs) as resp:\n self.request_count += 1\n status = resp.status\n if resp.status == 504:\n error = 'API timeout'\n self.retry_count += 1\n continue\n try:\n resp.raise_for_status()\n except ClientResponseError:\n error = f'{resp.status}: {resp.reason}'\n continue\n try:\n json = await resp.json()\n except ContentTypeError:\n error = 'Unable to decode JSON'\n self.retry_count += 1\n status = 0\n continue\n json['request_datetime'] = datetime.now()\n break\n\n if retries == max_retries - 1 and error:\n logger.warning(error)\n\n return json, status","def __make_api_post(self, api_path, data=None):\n headers = {\n \"Content-type\": \"application/json\",\n \"Accept\": \"application/json\"}\n x = json.dumps(data)\n\n try:\n req = urllib2.Request(self.api_server + api_path, x, headers)\n self.last_response = urllib2.urlopen(req, cafile=self.cacert_path)\n json_data = self.last_response.read()\n\n # Check for errors\n except urllib2.HTTPError as err:\n error = \"API HTTP error [%s] - '%s'\" % (err.code, err)\n raise EFIgyCliError(error, err)\n\n except urllib2.URLError as err:\n error = 'Problem calling API at location %s - %s' % (\n self.api_server + api_path, err)\n raise EFIgyCliError(error, self.last_response)\n\n # Decode json response into an object\n try:\n ret = json.loads(json_data)\n except ValueError as err:\n error = \"Problem deserialising data, expecting JSON.\\nError: %s\\nData: %s\" % (\n err, json_data)\n raise EFIgyCliError(error, self.last_response)\n\n # Return JSON deserialised object\n # print \"DEBUG - %s\"%(ret), type(ret)\n return ret","async def request_api(url):\n\theaders = {\"User-Agent\": f\"Mozilla/5.0 aiotfm/{__version__}\"}\n\n\ttry:\n\t\tasync with aiohttp.ClientSession() as session:\n\t\t\tasync with session.get(url, headers=headers) as resp:\n\t\t\t\treturn await resp.json()\n\texcept aiohttp.ClientError:\n\t\treturn {}","def _make_request(self):\n response = urllib2.urlopen(\n url=self.api_url,\n data=self._get_request_data()\n )\n content = response.read()\n return json.loads(content.decode('utf8'))","def _response(request):\n with urllib.request.urlopen(request) as response:\n status = response.getcode()\n # print(status, response.info(), )\n data = json.loads(\n response.read().decode('utf-8')\n )\n # print(data)\n if status == 200 and data[\"ok\"]:\n return data, status\n elif status == 200 and not data[\"ok\"]:\n raise ValueError('client._response() - Server response is not good ' +\n json.dumps(data))\n else:\n raise ConnectionFault('client._response() - Connection Error: ' +\n str(response.getcode()))","async def send_request(self, url: str, params: dict) -> dict:\n if self.session is None:\n # Create a session if one doesn't exist\n await self.create_session()\n\n async with self.session.get(url, params=params, headers=self.headers) as resp:\n # Make sure that the response of the request\n # returns code 200. Something wrong happened if it doesn't\n if not (300 > resp.status >= 200):\n # Raise an error if the status code isn't 200\n raise ParsingError(f\"Library error parsing request from API: {str(resp.status)}\")\n\n try:\n # We attempt to return the contents\n # of the request in JSON format\n response = await resp.json()\n if resp.status >= 400:\n # This is a validation error from the API\n # Likely has to do with missing/improper params\n missing_params = list()\n for param in response[\"detail\"]:\n missing_params.append(f\"{param['msg']} - {param['loc'][0]}\")\n raise InvalidParams(f\"Impropert params in given request: {missing_params}\")\n # If that fails, simply return the contents of the request\n # without ant kind of formatting (aka just read it)\n except aiohttp.ClientResponseError:\n raise ParsingError(\"Could not return contents from the request\")\n\n # Return the respose from the request, if any\n return response","async def _api_request(self, path: str, method=\"GET\") -> Any:\n params = {\"access_token\": self.token}\n\n attempt = 0\n while attempt <= MAX_REQUEST_ATTEMPT_COUNT:\n attempt += 1\n conn = aiohttp.TCPConnector(ssl=False)\n try:\n async with aiohttp.request(\n method, f\"{self.api_url}/{path}\", params=params, connector=conn\n ) as resp:\n if resp.status >= 400:\n # retry on server errors or request timeout w/ increasing delay\n if resp.status >= 500 or resp.status == 408:\n if attempt < MAX_REQUEST_ATTEMPT_COUNT:\n _LOGGER.debug(\n \"%s request to %s failed with code %d: %s.\"\n \" Retrying...\",\n method,\n path,\n resp.status,\n resp.reason,\n )\n await asyncio.sleep(\n attempt * REQUEST_RETRY_DELAY_INTERVAL\n )\n continue\n\n if resp.status == 401:\n raise InvalidToken()\n else:\n raise RequestError(resp)\n try:\n json = await resp.json()\n if \"error\" in json and json[\"error\"]:\n raise RequestError(resp)\n return json\n except ContentTypeError as e:\n text = await resp.text()\n _LOGGER.warn(\"Unable to parse as JSON: %s\", text)\n raise e\n except (\n ClientConnectionError,\n asyncio.TimeoutError,\n ContentTypeError,\n ) as e:\n # catch connection exceptions to retry w/ increasing delay\n if attempt < MAX_REQUEST_ATTEMPT_COUNT:\n _LOGGER.debug(\n \"%s request to %s failed with %s. Retrying...\",\n method,\n path,\n str(e),\n )\n await asyncio.sleep(attempt * REQUEST_RETRY_DELAY_INTERVAL)\n continue\n else:\n raise e\n finally:\n await conn.close()","def http_request(\n self,\n method: str,\n url_suffix: str,\n json_data=None,\n params=None,\n headers=None,\n ):\n resp = Response()\n try:\n resp = super()._http_request(\n method=method,\n url_suffix=url_suffix,\n json_data=json_data,\n params=params,\n headers=headers,\n resp_type='response',\n timeout=self.request_timeout,\n ok_codes=(200, 201),\n error_handler=self.handle_error_response,\n )\n except MissingSchema:\n raise ValueError(MESSAGES['MISSING_SCHEMA_ERROR'])\n except InvalidSchema:\n raise ValueError(MESSAGES['INVALID_SCHEMA_ERROR'])\n except InvalidURL:\n raise ValueError(MESSAGES['INVALID_API_URL'])\n except DemistoException as e:\n self.handle_demisto_exception(e)\n\n if resp.ok:\n content_type = resp.headers.get('Content-Type', '')\n if content_type == CONTENT_TYPE_JSON:\n # Handle empty response\n if resp.text == '':\n return resp\n else:\n return resp.json()\n elif self.is_supported_context_type(content_type):\n return resp","def request_routine(self, url, request_method, json_data=None):\n response_obj = requests.request(request_method,\n url=url,\n headers=self.header,\n data=json.dumps(json_data),\n verify=self.verify)\n\n LOG.debug('JovianDSS: Response code: %s', response_obj.status_code)\n LOG.debug('JovianDSS: Response data: %s', response_obj.text)\n\n ret = dict()\n ret['code'] = response_obj.status_code\n\n if '{' in response_obj.text and '}' in response_obj.text:\n if \"error\" in response_obj.text:\n ret[\"error\"] = json.loads(response_obj.text)[\"error\"]\n else:\n ret[\"error\"] = None\n if \"data\" in response_obj.text:\n ret[\"data\"] = json.loads(response_obj.text)[\"data\"]\n else:\n ret[\"data\"] = None\n\n return ret","def make_request(self, url):\n try:\n response = requests.get(url)\n if response.status_code != 200:\n return None\n return response.json()\n except requests.ConnectionError:\n return None","def call_api(payload):\n data = requests.get(weatherbit_url, params=payload)\n assert data.status_code == 200, f\"Something wrong. Error details: {data.json()['error']}\"\n assert 'error' not in data.json().keys(), f'Problem: {data.json()}'\n return data.json()","def _request(self, query):\n query_string = self._create_query_string(query)\n\n try:\n response = requests.get(query_string)\n except requests.exceptions.ConnectionError:\n raise EngineConnectionException(self.name, \"Unable to send request, check connectivity.\")\n\n if response.status_code != 200:\n raise EngineConnectionException(self.name, \"\", code=response.status_code)\n\n return self._parse_json_response(query, response)","def http_request(self, method: str, url_suffix: str, params: dict = None, json_data: dict = None, **kwargs):\n response = self._http_request(method, url_suffix, params=params, json_data=json_data, resp_type=\"response\",\n ok_codes=[200, *list(HTTP_ERRORS.keys())], raise_on_status=False, **kwargs)\n if response.status_code == 400 and response.json() and response.json().get('Message'):\n raise DemistoException(\n HTTP_ERRORS[response.status_code].format(\"Message:\" + response.json().get(\"Message\")))\n elif response.status_code in list(HTTP_ERRORS.keys()):\n raise DemistoException(HTTP_ERRORS[response.status_code])\n return response.json()","def _request(self, method, api_url, **kwargs):\n if not self.connected:\n raise Exception(\"'{d}' is not connected for alias '{a}'\"\n .format(d=self.device.name,\n a=self.alias))\n\n # Deal with the dn\n full_url = '{f}{api_url}'.format(f=self.url, api_url=api_url)\n\n if 'data' in kwargs:\n payload = kwargs['data']\n elif 'json' in kwargs:\n payload = kwargs['json']\n else:\n payload = ''\n\n log.info(\"Sending {method} command to '{d}':\"\n \"\\napi_url: {furl}\\nPayload:{payload}\"\n .format(method=method,\n d=self.device.name,\n furl=full_url,\n payload=payload))\n\n headers = {\n 'Dcnm-Token': self.token,\n 'Content-type': 'application/json'\n }\n\n # Send to the device\n response = self.session.request(method=method, url=full_url, headers=headers, **kwargs)\n\n\n # Make sure it was successful\n try:\n response.raise_for_status()\n except Exception:\n raise RequestException(\n \"'{c}' result code has been returned \"\n \"for '{d}'.\\nResponse from server: \"\n \"{r}\".format(d=self.device.name,\n c=response.status_code,\n r=response.text))\n\n # In case the response cannot be decoded into json\n # warn and return the raw text\n\n try:\n output = response.json()\n if isinstance(output, list):\n output = {\"temproot\": output}\n except Exception:\n log.warning('Could not decode json. Returning text!')\n output = response.text\n\n return output","def _request(self, url):\n response = requests.get(url, headers=self.header)\n\n if str(response.status_code).startswith('2'):\n return response\n\n raise Exception(\"URI request returned an error. Error Code \" + str(response.status_code))","def base_request(url_path):\n response = requests.get(settings.URL_API + url_path)\n if response.status_code != 200:\n return response\n else:\n return response.json()","def api_call(endpoint, params, headers):\n\n api_response = get(BASE_URL.format(endpoint=endpoint), params=params,\n headers=headers)\n\n api_response.raise_for_status()\n json_resp = api_response.json()\n\n api_response.close()\n return json_resp","def make_api_call(action, parameters = {}, method = 'get', data = {}):\n headers = {\n 'Content-type': 'application/json',\n 'Accept-Encoding': 'gzip',\n 'Authorization': 'Bearer %s' % ACCESS_TOKEN\n }\n if method == 'get':\n r = s.request(method, API_BASE_URL+action, headers=headers, params=parameters, timeout=30)\n elif method == 'post':\n r = s.request(method, API_BASE_URL+action, headers=headers, data=data, params=parameters, timeout=10)\n else:\n raise ValueError('Method should be get or post.')\n log('API %s call: %s' % (method, r.url) )\n if ((r.status_code == 200 and method == 'get') or (r.status_code == 201 and method == 'post')):\n return r.json()\n else:\n raise ValueError('API error when calling %s : %s' % (r.url, r.content))","def request(self, verb, subpath, data=''):\n if not self.api_key or not self.api_secret:\n raise Exception(\"Vingd authentication credentials undefined.\")\n \n endpoint = urlparse(self.api_endpoint)\n if endpoint.scheme != 'https':\n raise Exception(\"Invalid Vingd endpoint URL (non-https).\")\n \n host = endpoint.netloc.split(':')[0]\n port = 443\n path = urljoin(endpoint.path+'/', subpath)\n \n creds = \"%s:%s\" % (self.api_key, self.api_secret)\n headers = {\n 'Authorization': b'Basic ' + base64.b64encode(creds.encode('ascii')),\n 'User-Agent': self.USER_AGENT\n }\n try:\n conn = httplib.HTTPSConnection(host, port)\n conn.request(verb.upper(), quote(path), data, headers)\n r = conn.getresponse()\n content = r.read().decode('ascii')\n code = r.status\n conn.close()\n except httplib.HTTPException as e:\n raise InternalError('HTTP request failed! (Network error? Installation error?)')\n \n try:\n content = json.loads(content)\n except:\n raise GeneralException(content, 'Non-JSON server response', code)\n \n if 200 <= code <= 299:\n try:\n return content['data']\n except:\n raise InvalidData('Invalid server DATA response format!')\n \n try:\n message = content['message']\n context = content['context']\n except:\n raise InvalidData('Invalid server ERROR response format!')\n \n if code == Codes.BAD_REQUEST:\n raise InvalidData(message, context)\n elif code == Codes.FORBIDDEN:\n raise Forbidden(message, context)\n elif code == Codes.NOT_FOUND:\n raise NotFound(message, context)\n elif code == Codes.INTERNAL_SERVER_ERROR:\n raise InternalError(message, context)\n elif code == Codes.CONFLICT:\n raise GeneralException(message, context)\n \n raise GeneralException(message, context, code)","def _method_call(self, method, **kwargs):\n try:\n connection = httplib.HTTPConnection(self._api_address)\n except:\n raise FantasyDataError('Error: Cannot connect to the FantasyData API')\n\n try:\n method = method.format(format=self._response_format, **kwargs)\n request_url = \"/standard/{format}/{method}?{get_params}\".format(format=self._response_format, method=method,\n get_params=self._get_params)\n connection.request(\"GET\", request_url, \"\", self._headers)\n response = connection.getresponse()\n\n result = json.loads(response.read())\n\n if isinstance(result, dict) and \"statusCode\" in result:\n if (result['statusCode']) == 401:\n raise FantasyDataError('Error: Invalid API key')\n else:\n raise FantasyDataError('Error: Failed to get response')\n\n return result\n # except:\n # pass\n finally:\n connection.close()","def http_call(\n self,\n method,\n url,\n data=None,\n json_data=None,\n headers=None,\n verify=False,\n params=None,\n ):\n if data:\n _response = getattr(self.session, method.lower())(\n url, data=data, headers=headers, params=params, verify=verify\n )\n\n elif json_data:\n _response = getattr(self.session, method.lower())(\n url, json=json_data, headers=headers, params=params, verify=verify\n )\n\n else:\n _response = getattr(self.session, method.lower())(\n url, headers=headers, params=params, verify=verify\n )\n self.api_calls += 1\n\n try:\n _response.raise_for_status()\n except HTTPError:\n raise HTTPError(\n f\"{_response.json()['status']}: {_response.json()['message']}\"\n )\n\n return _response","def _api_call(self, api_call, method=\"GET\", payload=None):\n # type: (str, str, Dict[str, str]) -> requests.Response\n\n headers = {\n \"accept\" : \"application/json\",\n \"Authorization\" : f\"Bearer {self.access_token}\",\n \"x-ibm-client-id\" : self.client_id,\n }\n self.__log.debug(headers)\n api_url = f\"{self.base_url}/{api_call}\"\n\n self.__log.debug(f\"Calling {api_url} with method {method}\")\n if method == \"GET\":\n resp = requests.get(api_url, headers=headers)\n elif method == \"POST\":\n resp = requests.post(api_url, headers=header, data=payload)\n elif method == \"PUT\":\n resp = requests.put(api_url, headers=header, data=payload)\n elif method == \"DELETE\":\n resp = requests.delete(api_url, headers=headers)\n elif method == \"HEAD\":\n resp = requests.head(api_url, headers=headers)\n elif method == \"OPTIONS\":\n resp = requests.options(api_url, headers=headers)\n else:\n raise Exception(f\"The method {method} is unsupported\")\n \n if (resp.ok):\n return resp\n else:\n self.__log.debug(resp.status_code)\n self.__log.debug(resp.text)\n return resp","def request(self, service, data):\n _res = self._request(service, data)\n res = _res.json()[0][0]\n if res[\"success\"] == True:\n return res[\"result\"]\n else:\n err_msg = res[\"errmsg\"]\n raise Exception(\"Request not successful: '{0}'\".format(err_msg))","def send_request(self, request):\n json_results = requests.get(request).json()\n\n status = json_results['status']\n\n if status == const.STATUS_OK:\n return json_results['results']\n\n self.log.warning(self.get_status_code(status))","def request(self, params):\n params[\"public_key\"] = self.__PUBLIC_KEY\n post_data = urllib.parse.urlencode(params)\n hmac_ = hmac.new(self.__SECRET_KEY, post_data.encode(\"utf-8\"), hashlib.sha256).hexdigest()\n\n curl = pycurl.Curl()\n curl.setopt(pycurl.URL, self.__URL)\n curl.setopt(pycurl.HTTPHEADER, ['HMAC: ' + str(hmac_)])\n curl.setopt(pycurl.POST, True)\n curl.setopt(pycurl.POSTFIELDS, post_data)\n curl.setopt(pycurl.CONNECTTIMEOUT, 10)\n curl.setopt(pycurl.TIMEOUT, 5)\n\n buf = io.BytesIO()\n curl.setopt(pycurl.WRITEFUNCTION, buf.write)\n curl.perform()\n\n response = buf.getvalue()\n\n # Uncomment to debug raw JSON response\n # self.__log(\"< \" + response)\n\n http_code = curl.getinfo(pycurl.HTTP_CODE)\n\n curl.close()\n\n result = json.loads(response.decode('utf-8'))\n\n if http_code != 200:\n if result[\"error\"]:\n # 404 with some valid JSON\n self.__log(\"ERROR: HTTP \" + str(http_code) + \": \" + json.dumps(result[\"error\"]))\n else:\n self.__log(\"ERROR: HTTP \" + str(http_code) + \": \" + response)\n else:\n if result is None:\n self.__log(\"ERROR: Unparsable JSON \" + response)\n else:\n if 'error' in result: # || !$result[\"result\"]\n self.__log(\"ERROR: \" + json_encode(result[\"error\"]))\n else:\n result = result[\"result\"]\n\n return result","def _get(self, url: str) -> requests.Response:\n # todo: do some error checking here\n if url.startswith(API_PATH['base']):\n try:\n # logger.debug(f\"RestClient._get(): {url}\") # log in calling function\n response = requests.get(url, auth=self.auth)\n rest_code = response.json()['meta']['code']\n if rest_code not in [200, 201, 204]:\n raise RestException(f\"REST API Error: {rest_code}. {response.content}\")\n except RestException as e:\n logger.error(e)\n return None\n return response\n else:\n raise ValueError(f\"URL is invalid: {url}\")","async def _request(\n self, req_method: str, endpoint: str, extra_query: QueryDict = None, json=True\n ) -> Union[Dict, bytes]:\n if req_method not in (\"GET\", \"POST\"):\n raise APIError(f\"{req_method} not a known request method!\")\n\n url = await self._create_url(endpoint, extra_query=extra_query)\n\n async with aiohttp.ClientSession() as session:\n\n session_methods = {\"GET\": session.get, \"POST\": session.post}\n\n async with session_methods[req_method](url) as resp:\n self.logger.debug(\"got response: %s\", resp)\n\n if resp.status == 200:\n if json:\n data = await resp.json()\n self.logger.debug(\"got json: %s\", data)\n if data[\"subsonic-response\"][\"status\"] == \"failed\":\n raise APIError(\n data[\"subsonic-response\"][\"error\"][\"message\"]\n )\n return data\n\n data = await resp.read()\n return data\n\n raise APIError(f\"got status code {resp.status}!\")","async def _api_call(self, url, payload={}, retry=False):\n timeout = aiohttp.ClientTimeout(total=self.api_timeout)\n try:\n async with self._client_session.get(\n API_URL + url, headers=self.headers, timeout=timeout, data=payload\n ) as resp:\n if not retry and resp.status == 401:\n await self.renew_auth()\n return await self._api_call(url, payload, True)\n\n # 4xx represents unauthenticated\n if resp.status == 401 or resp.status == 403 or resp.status == 404:\n raise SenseAuthenticationException(f\"API Return Code: {resp.status}\")\n\n if resp.status != 200:\n raise SenseAPIException(f\"API Return Code: {resp.status}\")\n\n return await resp.json()\n except asyncio.TimeoutError as ex:\n # timed out\n raise SenseAPITimeoutException(\"API call timed out\") from ex","def _api_call(self, **kwargs):\n params = {\n 'format': 'json',\n }\n params.update(kwargs)\n r = requests.get(self.api_base_url, params=params)\n return r.json()","def execute(self) -> typing.Dict[str, typing.Any]:\n headers = {\n \"User-Agent\": \"{zenora.__name__} {zenora.__version__}\",\n \"Authorization\": f\"{self.token}\",\n }\n if self.headers:\n headers = self.headers\n\n if self.json:\n r = requests.request(\n method=self.method,\n url=self.url,\n headers=headers,\n json=self.json,\n )\n else:\n r = requests.request(\n method=self.method,\n url=self.url,\n headers=headers,\n data=self.form_data,\n )\n\n return raise_error_or_return(r) # type: ignore[return-value]","def __call(method, resource, headers=None, json=None):\n result = requests.request(method, resource, headers=headers, json=json)\n\n if result:\n try:\n return result.json()\n except ValueError:\n pass\n\n _LOGGER.debug(\"Erroneous response (%s)\", result)\n return result","async def request(\n self, method: str, path: Optional[str] = \"\", json: Optional[dict] = None\n ) -> dict:\n LOGGER.debug('Sending \"%s\" \"%s\" to \"%s %s\"', method, json, self.host, path)\n\n url = f\"http://{self.host}:{self.port}/api/{self.api_key}{path}\"\n\n try:\n async with self.session.request(method, url, json=json) as res:\n\n if res.content_type != \"application/json\":\n raise ResponseError(\n \"Invalid content type: {}\".format(res.content_type)\n )\n\n response = await res.json()\n LOGGER.debug(\"HTTP request response: %s\", pformat(response))\n\n _raise_on_error(response)\n\n return response\n\n except client_exceptions.ClientError as err:\n raise RequestError(\n \"Error requesting data from {}: {}\".format(self.host, err)\n ) from None","def _make_request(self):\n try:\n self.response = requests.request(\n method=self.method,\n url=self.url,\n params=self.params,\n data=self.data,\n )\n\n logger.debug(f\"Request URL: {self.response.url}\")\n\n self.response.raise_for_status()\n\n # wrap all `requests` library error and serve as custom application error\n except RequestException as e:\n logger.error(e.__str__(), exc_info=True)\n raise ExternalAPIError(\n \"Error while communication with External API\"\n )","def _do_api_call(\n self,\n endpoint_info: tuple[str, str],\n json: dict[str, Any] | None = None,\n wrap_http_errors: bool = True,\n ):\n method, endpoint = endpoint_info\n\n # TODO: get rid of explicit 'api/' in the endpoint specification\n url = f\"https://{self.host}/{endpoint}\"\n\n aad_headers = self._get_aad_headers()\n headers = {**self.user_agent_header, **aad_headers}\n\n auth: AuthBase\n token = self._get_token()\n if token:\n auth = _TokenAuth(token)\n else:\n self.log.info(\"Using basic auth.\")\n auth = HTTPBasicAuth(self.databricks_conn.login, self.databricks_conn.password)\n\n request_func: Any\n if method == \"GET\":\n request_func = requests.get\n elif method == \"POST\":\n request_func = requests.post\n elif method == \"PATCH\":\n request_func = requests.patch\n elif method == \"DELETE\":\n request_func = requests.delete\n else:\n raise AirflowException(\"Unexpected HTTP Method: \" + method)\n\n try:\n for attempt in self._get_retry_object():\n with attempt:\n response = request_func(\n url,\n json=json if method in (\"POST\", \"PATCH\") else None,\n params=json if method == \"GET\" else None,\n auth=auth,\n headers=headers,\n timeout=self.timeout_seconds,\n )\n response.raise_for_status()\n return response.json()\n except RetryError:\n raise AirflowException(f\"API requests to Databricks failed {self.retry_limit} times. Giving up.\")\n except requests_exceptions.HTTPError as e:\n if wrap_http_errors:\n raise AirflowException(\n f\"Response: {e.response.content}, Status Code: {e.response.status_code}\"\n )\n else:\n raise e","def _do_api_call(self, endpoint_info, json=None):\n method, endpoint = endpoint_info\n if self.fivetran_conn is None:\n self.fivetran_conn = self.get_connection(self.conn_id)\n auth = (self.fivetran_conn.login, self.fivetran_conn.password)\n url = f\"{self.api_protocol}://{self.api_host}/{endpoint}\"\n\n headers = {\n \"User-Agent\": self.api_user_agent\n }\n\n if method == \"GET\":\n request_func = requests.get\n elif method == \"POST\":\n request_func = requests.post\n elif method == \"PATCH\":\n request_func = requests.patch\n headers.update({\"Content-Type\": \"application/json;version=2\"})\n else:\n raise AirflowException(\"Unexpected HTTP Method: \" + method)\n\n attempt_num = 1\n while True:\n try:\n response = request_func(\n url,\n data=json if method in (\"POST\", \"PATCH\") else None,\n params=json if method in (\"GET\") else None,\n auth=auth,\n headers=headers\n )\n response.raise_for_status()\n return response.json()\n except requests_exceptions.RequestException as e:\n if not _retryable_error(e):\n # In this case, the user probably made a mistake.\n # Don't retry.\n raise AirflowException(\n f\"Response: {e.response.content}, \"\n f\"Status Code: {e.response.status_code}\"\n )\n\n self._log_request_error(attempt_num, e)\n\n if attempt_num == self.retry_limit:\n raise AirflowException(\n f\"API request to Fivetran failed {self.retry_limit} times.\"\n \" Giving up.\"\n )\n\n attempt_num += 1\n sleep(self.retry_delay)","def _do_operation(self,\n\t operation, api_path, query_params=None, munchify=True, debug_response=False,\n\t expected_status_codes=range(200, 300), *unused_args, **kwargs):\n\n\t\tif not self._session:\n\t\t\tmsg = u'No session has been created for the API. Have you called create() yet?'\n\t\t\tlog_with_debug_info(logging.ERROR, msg)\n\t\t\traise OperationError(msg)\n\n\t\tresponse = None\n\t\tretdata = None\n\n\t\tendpoint = self._build_endpoint(api_path, params=kwargs, query_params=query_params)\n\n\t\tparams = {u'headers': self._headers, u'verify': self._verify_cert}\n\n\t\tif u'data' in kwargs:\n\t\t\tparams[u'data'] = json.dumps(kwargs[u'data'])\n\n\t\tlog_with_debug_info(logging.DEBUG, u'Call parameters: {0}'.format(params))\n\n\t\t# Call the API endpoint\n\t\tresponse = getattr(self._session, operation)(endpoint, **params)\n\n\t\tlog_with_debug_info(logging.DEBUG, u'Response status: {0} {1}'.format(response.status_code,\n\t\t response.reason))\n\n\t\tif response.status_code not in expected_status_codes:\n\t\t\ttry:\n\t\t\t\tretdata = response.json()\n\t\t\texcept Exception as e:\n\t\t\t\t# Invalid JSON payload.\n\t\t\t\tmsg = (u'HTTP Status Code: [{0}]; API response data for end-point [{1}] does not '\n\t\t\t\t u'appear to be valid JSON. Cause: {2}.')\n\t\t\t\tmsg = msg.format(response.status_code, endpoint, e)\n\t\t\t\tif debug_response:\n\t\t\t\t\tlog_with_debug_info(logging.ERROR, msg + u' Data: [' + str(response.text) + u']')\n\t\t\t\traise InvalidJSONError(msg, resp=response)\n\t\t\tmsg = u'{0} request to RESTful API at [{1}] expected status(s) {2}; failed: {3} {4};'\\\n\t\t\t u' Response: {5}'\n\t\t\tmsg = msg.format(operation.upper(), endpoint, expected_status_codes,\n\t\t\t response.status_code, response.reason, retdata)\n\t\t\tlog_with_debug_info(logging.ERROR, msg)\n\t\t\traise OperationError(msg, resp=response)\n\n\t\ttry:\n\t\t\tif response.status_code in ('204',):\n\t\t\t\t# \"204 No Content\"\n\t\t\t\tretdata = {}\n\t\t\telse:\n\t\t\t\t# Decode the expected JSON\n\t\t\t\tretdata = response.json()\n\t\texcept Exception as e:\n\t\t\t# Invalid JSON payload.\n\t\t\tmsg = (u'HTTP Status Code: [{0}]; API response data for end-point [{1}] does not '\n\t\t\t u'appear to be valid JSON. Cause: {2}.')\n\t\t\tmsg = msg.format(response.status_code, endpoint, e)\n\t\t\tif debug_response:\n\t\t\t\tlog_with_debug_info(logging.ERROR, msg + u' Data: [' + str(response.text) + u']')\n\t\t\traise InvalidJSONError(msg, resp=response)\n\t\tretdata = munch.munchify(retdata) if munchify else retdata\n\t\treturn (retdata[u'response'] if u'response' in retdata else retdata), response","def _api_request(method, path, data = None):\n headers = {}\n\n if method == 'PUT' or method == 'POST':\n headers = {'Content-Type': 'application/json'}\n data = json.dumps(data)\n\n connection = httplib.HTTPSConnection(API_HOST,\n API_PORT,\n key_file = VM_CERTIFICATE,\n cert_file = VM_CERTIFICATE)\n\n connection.request(method, path, data, headers)\n response = connection.getresponse()\n\n if response.status == 404:\n return None\n if response.status == 403:\n return False\n\n if method == 'PUT' or method == 'POST':\n return True\n\n try:\n return json.loads(response.read())\n except:\n print('Response code: %s' % response.status)\n raise","def _call(self, method: str, *url_parts, data=None,\n params=None, stream=None) -> bytes:\n response = self.request(method.upper(),\n self._mk_url(url_parts),\n params=params,\n data=data,\n stream=stream)\n\n if response.status_code not in (200, 201):\n try:\n self._raise_error(response.status_code, response.json())\n except ValueError as e:\n raise APIError(response.status_code,\n self._RESPONSE_NOT_JSON_MSG) from e\n\n return response.content","def make_request(self, url, action, data='', status_code='', parser=None):\n self._url = self.get_api_path(url)\n headers = {\n 'Content-Type': \"application/json\",\n 'Token': self.token,\n\n }\n kwargs = {}\n if headers:\n kwargs.update(headers=headers)\n if data:\n kwargs.update(data=json.dumps(data))\n\n return getattr(self.http, action.lower())(self._url, **kwargs)","def http_request(url, post_params=None, timeout=None, max_response=None, json=False):\n try:\n if post_params:\n response = requests.post(url, data=post_params, timeout=timeout)\n else:\n response = requests.get(url, timeout=timeout)\n except requests.exceptions.RequestException as error:\n raise HttpError(exception=error)\n if response.status_code != 200:\n raise HttpError(\n error_type='status_code',\n message='Error making request: response code {} ({}).'\n .format(response.status_code, response.reason)\n )\n if json:\n try:\n return response.json()\n except json.JSONDecodeError as error:\n raise HttpError(\n exception=error,\n message='Response not valid JSON: {!r}'.format(response.text)\n )\n else:\n return response.text","def makeApiCall(url, endpointParams, type):\r\n\r\n if type == 'POST': # post request\r\n data = requests.post(url, endpointParams)\r\n else: # get request\r\n data = requests.get(url, endpointParams)\r\n\r\n response = dict() # hold response info\r\n response['url'] = url # url we are hitting\r\n response['endpoint_params'] = endpointParams # parameters for the endpoint\r\n response['endpoint_params_pretty'] = json.dumps(endpointParams, indent=4) # pretty print for cli\r\n response['json_data'] = json.loads(data.content) # response data from the api\r\n response['json_data_pretty'] = json.dumps(response['json_data'], indent=4) # pretty print for cli\r\n\r\n return response # get and return content\r","def _do_call(cls, method, url, params={}):\n headers = {\n 'User-Agent': 'py-retain/' + __version__,\n 'content-type': 'application/json'\n }\n try:\n r = cls.request_map[method.lower()]\n except KeyError:\n raise ValueError(\"Unknow HTTP Method\")\n response = r(\n url,\n auth=(cls.app_id, cls.api_key),\n headers=headers,\n data=json.dumps(params),\n timeout=cls.timeout)\n return response.json()","def request(self, method, path, msg=None, json=None, retfmt='bool', errorfatal=True, autoauth=True, verify_ssl=False):\n url = self.admin_url + '/acs/api/v1' + path\n\n if msg:\n self.log.info(msg)\n\n headers = self.default_headers.copy()\n\n if not self.auth_header and autoauth:\n self.set_auth_header()\n\n if self.auth_header:\n headers.update(self.auth_header)\n\n if method == 'get':\n r = requests.get(url, headers=headers, json=json, verify=verify_ssl)\n elif method == 'post':\n r = requests.post(url, headers=headers, json=json, verify=verify_ssl)\n elif method == 'put':\n r = requests.put(url, headers=headers, json=json, verify=verify_ssl)\n elif method == 'delete':\n r = requests.delete(url, headers=headers, json=json, verify=verify_ssl)\n\n if 200 <= r.status_code < 300:\n self.log.debug(\"success\")\n if retfmt == 'json':\n self.log.debug('returning json')\n return r.json()\n elif retfmt == 'request':\n self.log.debug('returning request object')\n return r\n else:\n return True\n else:\n if 'Content-Type' in r.headers and r.headers['Content-Type'] == 'application/json':\n resp = r.json()['code']\n else:\n resp = r.reason\n msg = \"failed: {}\".format(resp)\n self.log.debug(msg)\n if errorfatal:\n raise Exception(msg)\n else:\n if retfmt == 'request':\n self.log.debug('returning request object')\n return r\n else:\n return None","def make_request(self, request, captcha_response=None):\n logger.debug('Prepare API Method request %r', request)\n response = self._send_api_request(request=request,\n captcha_response=captcha_response)\n response.raise_for_status()\n response_or_error = json.loads(response.text)\n logger.debug('response: %s', response_or_error)\n\n if 'error' in response_or_error:\n error_data = response_or_error['error']\n vk_error = VkAPIError(error_data)\n\n if vk_error.is_captcha_needed():\n captcha_key = self.get_captcha_key(vk_error.captcha_img_url)\n if not captcha_key:\n raise vk_error\n\n # Retry http request with captcha info attached\n captcha_response = {\n 'sid': vk_error.captcha_sid,\n 'key': captcha_key,\n }\n return self.make_request(\n request, captcha_response=captcha_response)\n\n elif vk_error.is_access_token_incorrect():\n logger.info(\n 'Authorization failed. Access token will be dropped')\n self._access_token = None\n return self.make_request(request)\n\n else:\n raise vk_error\n elif 'execute_errors' in response_or_error:\n # can take place while running .execute vk method\n # See more: https://vk.com/dev/execute\n raise VkAPIError(response_or_error['execute_errors'][0])\n elif 'response' in response_or_error:\n return response_or_error['response']","def _request(self, url, values=None):\n\n url += \"?{}\".format(urllib.urlencode(values))\n\n request = urllib2.Request(url)\n\n try:\n connection = urllib2.urlopen(request)\n except urllib2.HTTPError, e:\n return {'status': 'Failed', 'message': str(e.reason)}\n except urllib2.URLError, e:\n return {'status': 'Failed', 'message': str(e.reason)}\n except httplib.HTTPException, e:\n return {'status': 'Failed', 'message': str(e.reason)}\n except Exception as exception:\n return {'status': 'Failed', 'message': str(exception)}\n\n response = connection.read()\n connection.close()\n\n\n try:\n result = json.loads(response.decode())\n except ValueError as exception:\n return {'status': 'Failed', 'message': str(exception)}\n\n return result","async def _httpx_request(method: Literal[\"GET\", \"POST\", \"DELETE\"], url: str, payload: dict, response_model: pydantic.BaseModel, private: bool=False):\n # return\n\n if private:\n try:\n keyset = get_keys() # returns a set of tuples (key, secret) \n except EmptyEnv:\n # do not proceed to send a test request in this case\n return\n key, secret = keyset.pop()\n payload[\"timestamp\"] = auth_timestamp()\n payload[\"signature\"] = auth_signature(url, payload, secret=secret)\n headers = auth_headers(key)\n else:\n headers = {}\n\n async with httpx.AsyncClient() as client:\n if private:\n signature = payload.pop(\"signature\")\n payload = sorted([(k, v) for k, v in payload.items()], reverse=False)\n payload.append((\"signature\", signature)) #! needs to always be last param\n if method in [\"POST\", \"DELETE\"]:\n r = await client.request(method, url, data=dict(payload), headers=headers)\n else:\n r = await client.request(method, url, params=payload, headers=headers)\n else:\n r = await client.request(method, url, params=payload)\n \n rjson = r.json()\n print(\"response.json\", rjson)\n\n assert r.status_code == 200, f\"Json Response {rjson} \\nPayload {payload} \\nHeaders {headers} \\nRequest {r.request}\"\n\n # if empty response, return directly without validation\n # (this might be what we expected, so assertion has to take place in the test function not here)\n if not rjson:\n return rjson\n\n # else we validate\n if isinstance(rjson, list) or isinstance(rjson, tuple):\n response_model(rjson)\n else:\n response_model(**rjson)","async def _call_api(\n self, endpoint: str, method: str = \"GET\", data: Optional[dict] = None\n ) -> Optional[ClientResponse]:\n try:\n response = await self._session.request(\n method=method,\n url=f\"{BASE_URL}/{endpoint}\",\n headers={\n \"aftership-api-key\": self._api_key,\n \"Content-Type\": \"application/json\",\n },\n json=data,\n timeout=ClientTimeout(total=self._timeout),\n )\n return await self._handle_response(response)\n\n except asyncio.TimeoutError as exception:\n raise AfterShipCommunicationException(\"Timeout error\") from exception\n\n except (ClientError, gaierror) as exception:\n raise AfterShipCommunicationException(\n f\"Communication error {exception}\"\n ) from exception","def _call_api(self, api_function, kwargs):\n kwargs['_request_timeout'] = self._timeout\n retries = self._retries\n while True:\n try:\n response = api_function(**kwargs)\n # Call was successful (200)\n return self._create_valid_response(response, api_function, kwargs)\n except ApiException as error:\n # If no chance for retries, return the error\n if retries == 0:\n return self._create_error_response(error)\n # If bad request or not found, return the error (it will never work)\n elif error.status in [400, 404]:\n return self._create_error_response(error)\n # If authentication error, reset access token and retry\n elif error.status in [401, 403]:\n self._set_auth_header(refresh=True)\n # If rate limit error, wait the proper time and try again\n elif error.status == 429:\n # If the the minute limit hit, wait that long\n if (int(error.headers.get(Headers.x_ratelimit_remaining_min))\n == int(error.headers.get(Headers.x_ratelimit_min))):\n time.sleep(60)\n # Otherwise it was the second limit and only wait a second\n time.sleep(1)\n # If some internal server error we know nothing about, return\n elif error.status == 500:\n return self._create_error_response(error)\n # If internal server errors that has to do with timeouts, try again\n elif error.status > 500:\n pass\n # If error with the swagger client, raise the error\n else:\n raise PureError(error)\n retries = retries - 1","def _call(self, request_method, endpoint, params=None, data=None):\n response = request_method(\n self._construct_url(endpoint),\n params=params,\n data=data,\n auth=BsdApiAuth(self.api_id, self.api_secret)\n )\n\n if response.status_code == 202 and endpoint != \"get_deferred_results\":\n return self._resolve_deferred_response(response, self.deferred_result_max_attempts)\n else:\n return response","def _request(self, url, **kwargs):\n headers = {'PRIVATE-TOKEN': self.token}\n response = make_request(self.base_url + url, headers=headers, **kwargs)\n logging.info('Requested: {0}'.format(url))\n logging.info('Method: {0}'.format(kwargs.get('method', 'GET')))\n logging.info(response.content)\n return json.loads(response.content)"],"string":"[\n \"async def _api_request(self,\\n method: str,\\n path_url: str,\\n params: Dict[str, Any] = {}) -> Dict[str, Any]:\\n base_url = f\\\"https://{global_config_map['gateway_api_host'].value}:\\\" \\\\\\n f\\\"{global_config_map['gateway_api_port'].value}\\\"\\n url = f\\\"{base_url}/{path_url}\\\"\\n client = await self._http_client()\\n if method == \\\"get\\\":\\n if len(params) > 0:\\n response = await client.get(url, params=params)\\n else:\\n response = await client.get(url)\\n elif method == \\\"post\\\":\\n response = await client.post(url, data=params)\\n\\n parsed_response = json.loads(await response.text())\\n if response.status != 200:\\n err_msg = \\\"\\\"\\n if \\\"error\\\" in parsed_response:\\n err_msg = f\\\" Message: {parsed_response['error']}\\\"\\n raise IOError(f\\\"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}\\\")\\n if \\\"error\\\" in parsed_response:\\n raise Exception(f\\\"Error: {parsed_response['error']}\\\")\\n\\n return parsed_response\",\n \"def api_call():\\n\\tresponse = requests.get(URL_API)\\n\\treturn response\",\n \"def _api_request(self, endpoint, params=None):\\n \\n if params:\\n response = requests.get(url=f\\\"{self.api_url}/{endpoint}\\\", headers={\\\"Authorization\\\":self.auth_header},\\n params=params)\\n else:\\n response = requests.get(url=f\\\"{self.api_url}/{endpoint}\\\", headers={\\\"Authorization\\\":self.auth_header})\\n code = response.status_code\\n if 200 <= code < 300:\\n logging.debug(f\\\"API call: {self.api_url}/{endpoint} | {code}\\\")\\n encoding = response.encoding\\n raw = response.content\\n return json.loads(raw.decode(encoding))\\n elif code > 500:\\n raise APIAuthException\\n else:\\n logging.error(f\\\"ERROR: Bad API call: {self.api_url}/{endpoint} | {code}\\\")\",\n \"def get_response(request):\\n uri = \\\"api.php\\\"\\n response_body = None\\n url = proto + \\\"://\\\" + host + \\\"/\\\" + api_dir + \\\"/\\\" + uri\\n logger.debug(\\\"Enter get_response(url=\\\" + url + \\\") with request:\\\")\\n logger.debug(request)\\n if proto == \\\"http\\\":\\n conn = httplib.HTTPConnection(host)\\n elif proto == \\\"https\\\":\\n conn = httplib.HTTPSConnection(host)\\n else:\\n logger.error(\\\"Unsupported protocol \\\" + proto)\\n return None\\n http_response = \\\"\\\"\\n try:\\n conn.connect()\\n logger.debug(\\\"Sending to \\\" + host + \\\":\\\")\\n logger.debug(request)\\n data_json = json.dumps(request)\\n data_json_enc = data_json\\n data_json_enc_urlenc = urllib.urlencode({'data': data_json_enc})\\n conn.putrequest('POST', \\\"/\\\" + api_dir + \\\"/\\\" + uri)\\n headers = {'Content-Length': \\\"%d\\\" % (len(data_json_enc_urlenc)),\\n 'Content-Type': 'application/x-www-form-urlencoded'}\\n for k in headers:\\n conn.putheader(k, headers[k])\\n conn.endheaders()\\n conn.send(data_json_enc_urlenc)\\n http_response = conn.getresponse()\\n if http_response.status == 200:\\n response_body = http_response.read()\\n logger.debug(\\\"Response from server: %s\\\" % response_body)\\n if not response_body:\\n return None\\n url = \\\"%(proto)s://%(host)s/%(api_dir)s/%(uri)s\\\" % {\\n \\\"proto\\\": proto,\\n \\\"host\\\": host,\\n \\\"api_dir\\\": api_dir,\\n \\\"uri\\\": uri\\n }\\n logger.debug(\\\"Response from %(url)s : %(resp)s\\\" % {\\n \\\"url\\\": url,\\n \\\"resp\\\": response_body\\n })\\n else:\\n logger.error(\\\"HTTP error %d %s\\\" % (http_response.status, http_response.reason))\\n except socket.error as err:\\n logger.error(\\\"Exception while making request \\\" + url)\\n logger.error(err)\\n logger.error(\\\"Please check that DNS server is reachable and works\\\")\\n return None\\n except exceptions.KeyError as err:\\n logger.error(\\\"Failed to decode response from server %s\\\" % http_response)\\n logger.error(\\\"Could not find key %s\\\" % err)\\n return None\\n finally:\\n conn.close()\\n return response_body\",\n \"def __exec_request(self, URL) -> Any:\\n headers = {\\n \\\"X-ELS-APIKey\\\": self.config['apikey'],\\n \\\"Accept\\\": 'application/json'\\n }\\n\\n request = requests.get(\\n URL,\\n headers=headers\\n )\\n self._status_code = request.status_code\\n\\n if request.status_code == 200:\\n return json.loads(request.text, strict=False)\\n else:\\n return \\\"failed\\\"\",\n \"def _http_get(self, url, params={}):\\n if not self.token:\\n self.get_token()\\n headers = {'Authorization': self.token, 'Accept': 'application/json; indent=4'}\\n url = self.server + '/api2' + url\\n try:\\n r = requests.get(url=url, headers=headers, params=params)\\n except requests.exceptions.RequestException as e:\\n return check_failed(e)\\n # raise ClientHttpError(None, e)\\n if r.status_code != 200:\\n return check_failed(r.status_code)\\n # return ClientHttpError(r.status_code, json.loads(r.text)['error_msg'])\\n try:\\n data = json.loads(r.text)\\n except:\\n data = r.text\\n # TODO: check data\\n return data\",\n \"def _get_api_request(url):\\n req = requests.get(url)\\n\\n if not req.status_code == 200:\\n print(\\\"Error getting API request:\\\", url)\\n print(\\\"Status code:\\\", req.status_code)\\n print(\\\"Error:\\\", req.text)\\n exit(200)\\n\\n data = None\\n try:\\n data = req.json()\\n except JSONDecodeError:\\n print(\\\"WarcraftLogs did not return proper JSON, it is likely down for maintenance.\\\")\\n print(\\\"Request response:\\\", req.text)\\n exit(300)\\n\\n return data\",\n \"def call_api(self):\\n #generate the final call string\\n self.generate_call_string();\\n #debug\\n #print (self.call_url);\\n \\n #finally make api call\\n try: \\n #pass; \\n self.return_articles= json.loads(urlopen(self.call_url).read());\\n #print json.dumps(self.return_articles, indent=4, sort_keys=True)\\n except :#elaborate on this later\\n print(\\\"Exception,response did not go through:\\\");\\n e = sys.exc_info()[0]\\n print(e);\\n raise;\\n return;\",\n \"def call_api_endpoint(url, data):\\n try:\\n \\n req = urllib2.Request(url, data, {'Content-Type': 'application/json'})\\n \\n f = urllib2.urlopen(req)\\n response = f.read()\\n f.close()\\n return response\\n\\n \\n except urllib2.HTTPError, e:\\n if e.code == 400:\\n return -1\",\n \"def _request(self, endpoint: str = \\\"/api/\\\", params: object = {}) -> dict:\\n ret: dict = {}\\n try:\\n if not self.api_key:\\n ret[\\\"error\\\"] = \\\"API key is empty\\\"\\n raise APIError(ret['error'])\\n\\n r = requests.get(f\\\"{self.apibase}{endpoint}\\\",\\n params=params,\\n headers=self.headers,\\n verify=self.verify_ssl)\\n response_data = orjson.loads(r.text)\\n except orjson.JSONDecodeError:\\n ret[\\\"error\\\"] = \\\"Failed to parse response data to JSON\\\"\\n if self.debug:\\n ret[\\\"error\\\"] += \\\"\\\\nDescription: \\\" + r.reason\\n ret[\\\"error\\\"] += \\\"\\\\nData: \\\" + r.text\\n except requests.HTTPError:\\n ret[\\\"error\\\"] = f\\\"{r.status_code}: {r.reason}\\\"\\n if self.debug:\\n ret[\\\"error\\\"] += \\\"\\\\nDescription: \\\" + r.reason\\n ret[\\\"error\\\"] += \\\"\\\\nData: \\\" + r.text\\n\\n if ret.get('error', None):\\n raise APIError(ret['error'])\\n check_status_code(request=r, debug=self.debug, ret=ret)\\n\\n ret = response_data\\n return ret\",\n \"def _api_request(*args, **kwargs):\\n response = requests.request(*args, **kwargs)\\n return APIResponse(response)\",\n \"def _do_request(self, url, method='GET', body=None):\\n response, content = self.request(url, method=method, body=body, headers=self.headers)\\n if int(response['status']) != 200:\\n raise GPAPIError(response['status'], 'ERROR IN REQUEST')\\n json = simplejson.loads(content)\\n return json\",\n \"def _api_request(self, path, method, data=None, query=None):\\n\\n url = request_url(\\n self.config['secure'],\\n self.config['hostname'],\\n self.config['port'],\\n path,\\n query,\\n )\\n\\n try:\\n resp = request(\\n url,\\n method,\\n self._headers(),\\n data,\\n self.config['timeout'],\\n )\\n\\n return Response(\\n resp.get('meta', {}),\\n # Response info may have 'object' or 'objects' key, depending\\n # on whether there are 1 or multiple results.\\n resp.get('object', resp.get('objects'))\\n )\\n except HTTPError as e:\\n response = e.read()\\n fallback = '{0} {1}'.format(e.code, e.msg)\\n\\n if isinstance(response, bytes):\\n data = response.decode('utf8')\\n else:\\n data = response\\n\\n error = json.loads(data).get('error', {})\\n message = error.get('message', fallback)\\n raise HTTPResponseError(message, status_code=e.code, cause=e)\",\n \"def http_request(endpoint, data, method='POST'):\\n url = BASE_API + endpoint\\n data['authkey'] = AUTH_KEY\\n\\n response = requests.request(method, url=url, data=data, timeout=300, verify=VERIFY)\\n if response.status_code == 200:\\n try:\\n return response.json()\\n except Exception as e:\\n return_error('Response JSON decoding failed due to {}'.format(str(e)))\\n\\n else:\\n return_error('API Returned, {}:{}'.format(response.status_code, response.reason))\",\n \"def _request_get(self, url):\\n try:\\n r = requests.get(url)\\n except Exception:\\n raise Exception('Cannot connect')\\n if (r.status_code != 200):\\n raise Exception('%d %s' % (r.status_code, r.text))\\n if (not r.text) or (not r.text.strip()):\\n raise Exception('Empty answer')\\n try:\\n response = json.loads(r.text)\\n except Exception:\\n raise Exception('Cannot parse response')\\n return response\",\n \"def _handle_api_call(self, url):\\n response = urlopen(url)\\n url_response = response.read()\\n json_response = loads(url_response)\\n \\n if not json_response:\\n raise ValueError('Error getting data from the api, no return was given.')\\n elif \\\"Error Message\\\" in json_response:\\n raise ValueError(json_response[\\\"Error Message\\\"])\\n elif \\\"Information\\\" in json_response and self.treat_info_as_error:\\n raise ValueError(json_response[\\\"Information\\\"])\\n \\n return json_response\",\n \"def __make_api_get(self, api_path):\\n try:\\n self.last_response = urllib2.urlopen(\\n self.api_server + api_path, cafile=self.cacert_path)\\n json_data = self.last_response.read()\\n\\n # Check for errors\\n except urllib2.HTTPError as err:\\n error = \\\"API HTTP error [%s] - '%s'\\\" % (err.code, err.read())\\n raise EFIgyCliError(error, self.last_response)\\n\\n except urllib2.URLError as err:\\n error = 'Problem calling API at location %s - %s' % (\\n self.api_server + api_path, err)\\n raise EFIgyCliError(error, self.last_response)\\n\\n # Decode json response into an object\\n try:\\n ret = json.loads(json_data)\\n except ValueError as err:\\n error = \\\"Problem deserialising data, expecting JSON.\\\\nError: %s\\\\nData: %s\\\" % (\\n err, json_data)\\n raise EFIgyCliError(error, self.last_response)\\n\\n # Return JSON deserialised object\\n return ret\",\n \"def __request(self,endpoint):\\n apiRequest = requests.get(\\\"%s/%s\\\" % (self.baseurl,endpoint), \\n auth=requests.auth.HTTPBasicAuth(self.api_id, self.api_secret))\\n try:\\n json = apiRequest.json()\\n return json\\n except JSONDecodeError:\\n print(\\\"Failed to download or failed to parse JSON.\\\")\\n print(apiRequest)\\n return None\",\n \"async def request(\\r\\n self, method: str, url: str, params: dict = None, data: dict = None\\r\\n ):\\r\\n async with self._session.request(\\r\\n method,\\r\\n url,\\r\\n params=params,\\r\\n json=data,\\r\\n headers={\\\"Authorization\\\": \\\"Bearer \\\" + self._token},\\r\\n ) as resp:\\r\\n if resp.status == 200:\\r\\n return await resp.json()\\r\\n if resp.status in (400, 422, 429, 500):\\r\\n data = None\\r\\n try:\\r\\n data = await resp.json()\\r\\n except Exception: # pylint: disable=broad-except\\r\\n pass\\r\\n raise APIResponseError(\\r\\n resp.request_info,\\r\\n resp.history,\\r\\n status=resp.status,\\r\\n message=resp.reason,\\r\\n headers=resp.headers,\\r\\n data=data,\\r\\n )\\r\\n resp.raise_for_status()\",\n \"def _send_in_request(self):\\n try:\\n req_params = urllib.urlencode(self._params)\\n except Exception as ex:\\n raise ProxyError('Error signing request string') \\n \\n try:\\n self.logger.debug('Send api request to: %s' % self._api_url)\\n self.logger.debug('Request params: %s' % req_params)\\n self.logger.debug('Request timeout: %s' % self._timeout)\\n if len(self._params) > 0:\\n f = urllib2.urlopen(self._api_url, req_params, self._timeout)\\n response = f.read()\\n self.logger.debug('Response length: %s' % len(response))\\n f.close() \\n return response\\n else:\\n return \\\"{'command':'ping', 'message':'ok'}\\\" \\n except (urllib2.URLError) as ex:\\n self._error = json.loads(ex.fp.readline()).values()\\n raise ProxyResponseError()\\n except (IOError) as ex:\\n raise ProxyError(ex)\",\n \"def api_req(dev, api_call):\\r\\n import xmltodict\\r\\n import logging\\r\\n try:\\r\\n r = requests.get(dev + ':8060' + api_call, timeout=5)\\r\\n except Exception as exc:\\r\\n response = [\\\"ERR\\\", exc]\\r\\n return response[0]\\r\\n except ConnectionError as connerr:\\r\\n response = [\\\"ERR\\\", connerr]\\r\\n return response[0]\\r\\n except TimeoutError as toerr:\\r\\n response = [\\\"ERR\\\", toerr]\\r\\n return response[0], toerr\\r\\n r_code = r.status_code\\r\\n if r_code == 200:\\r\\n print(\\\"REQUEST WAS A SUCCESS. DEVICE RETURNED: {} \\\".format(str(r)))\\r\\n r2 = r.text\\r\\n response = xmltodict.parse(r2, xml_attribs=False)\\r\\n return response\\r\\n else:\\r\\n response = \\\"UnknownERR\\\"\\r\\n dev.state(DISABLED)\\r\\n return msg_box(response)\",\n \"def _api_request(date: str, api_url: str) -> Dict[str, str]:\\n try:\\n data = json.loads(urlopen(\\n Request(f\\\"{api_url}?at={quote(date)}\\\")\\n ).read().decode('utf-8'))\\n except HTTPError as e:\\n data = json.loads(e.file.read().decode('utf-8'))\\n if \\\"message\\\" in data:\\n raise ValidationError(data[\\\"message\\\"])\\n else:\\n raise ValidationError(f\\\"Service unavailable ({e}\\\")\\n return data\",\n \"def parse_api(baseurl):\\n\\t# Make 4 api calls in total\\n\\tfor call in range(1, 5):\\n\\t\\t# Write an error to file if no response after 4 attempts\\n\\t\\tif call == 4:\\n\\t\\t\\twith open('errors.txt', 'a') as file:\\n\\t\\t\\t\\tfile.write(\\\"Server is not responding after 4 attempts. Time: {}\\\\n\\\".format(\\n\\t\\t\\t\\t\\tdt_to_string(datetime.datetime.now())\\n\\t\\t\\t\\t))\\n\\t\\t\\treturn False\\n\\t\\ttry:\\n\\t\\t\\t# download data from api\\n\\t\\t\\tresult = urllib.request.urlopen(baseurl).read()\\n\\t\\t\\treturn result\\n\\t\\texcept urllib.error.URLError:\\n\\t\\t\\t# wait 10 minutes if server is not responding and make another call\\n\\t\\t\\tprint(\\\"Seems like server is not responding. Will try again in 10 minutes...\\\")\\n\\t\\t\\ttime.sleep(660)\",\n \"def _handle_api_result(self, response, params, tries, wait, ae_retry):\\n try:\\n res = response.json()\\n except ValueError:\\n e = \\\"API query failed: JSON could not be decoded.\\\"\\n raise exceptions.APIError(e)\\n\\n if \\\"warnings\\\" in res:\\n for name, value in res[\\\"warnings\\\"].items():\\n try:\\n warning = value[\\\"warnings\\\"]\\n except KeyError:\\n try:\\n warning = value[\\\"*\\\"]\\n except KeyError:\\n warning = value\\n self._logger.warning(\\\"API warning: %s: %s\\\", name, warning)\\n\\n if self._should_save_cookiejar():\\n self._save_cookiejar()\\n\\n try:\\n code = res[\\\"error\\\"][\\\"code\\\"]\\n info = res[\\\"error\\\"][\\\"info\\\"]\\n except (TypeError, KeyError): # If there's no error code/info, return\\n if \\\"query\\\" in res and \\\"tokens\\\" in res[\\\"query\\\"]:\\n for name, token in res[\\\"query\\\"][\\\"tokens\\\"].items():\\n self._tokens[name.split(\\\"token\\\")[0]] = token\\n return res\\n\\n if code == \\\"maxlag\\\": # We've been throttled by the server\\n if tries >= self._max_retries:\\n e = \\\"Maximum number of retries reached ({0}).\\\"\\n raise exceptions.APIError(e.format(self._max_retries))\\n tries += 1\\n msg = 'Server says \\\"{0}\\\"; retrying in {1} seconds ({2}/{3})'\\n self._logger.info(msg.format(info, wait, tries, self._max_retries))\\n sleep(wait)\\n return self._api_query(params, tries, wait * 2, ae_retry=ae_retry)\\n elif code in [\\\"assertuserfailed\\\", \\\"assertbotfailed\\\"]: # AssertEdit\\n if ae_retry and all(self._login_info) and not self._oauth:\\n # Try to log in if we got logged out:\\n self._login(self._login_info)\\n if \\\"token\\\" in params: # Fetch a new one; this is invalid now\\n params[\\\"token\\\"] = self.get_token(params[\\\"action\\\"])\\n return self._api_query(params, tries, wait, ae_retry=False)\\n if not all(self._login_info) and not self._oauth:\\n e = \\\"Assertion failed, and no login info was provided.\\\"\\n elif code == \\\"assertbotfailed\\\":\\n e = \\\"Bot assertion failed: we don't have a bot flag!\\\"\\n else:\\n e = \\\"User assertion failed due to an unknown issue. Cookie or OAuth problem?\\\"\\n raise exceptions.PermissionsError(\\\"AssertEdit: \\\" + e)\\n else: # Some unknown error occurred\\n e = 'API query failed: got error \\\"{0}\\\"; server says: \\\"{1}\\\".'\\n error = exceptions.APIError(e.format(code, info))\\n error.code, error.info = code, info\\n raise error\",\n \"def __apiRequest(self, url, parms={}):\\n authparms = self.__addAuthParms(parms);\\n request = self.http.request('GET', url, fields=authparms)\\n if request.status != 200:\\n raise ApiCommunicationError('Failed to retrieve data from Marvel, HTTP Status {}'.format(request.status))\\n else:\\n return json.loads( request.data.decode('utf-8') )\",\n \"def api_call():\\n\\n json_str = load_input()\\n output = {\\n 'inputs': json_str,\\n 'results': 'cool results'}\\n\\n return json.dumps(output), 200, {'Content-Type': 'text/plain;charset=utf-8'}\",\n \"def call(self):\\n # if this is a POST request, process data\\n if self.data:\\n post_json = json.dumps(self.data)\\n values = {'json': post_json, 'apikey': API_KEY}\\n post = urllib.parse.urlencode(values)\\n\\n else:\\n post = None\\n\\n req = urllib.request.Request(self.url, post)\\n\\n try:\\n self.response = urllib.request.urlopen(req, timeout=self.timeout)\\n\\n except (URLError, HTTPError, timeout) as error:\\n self.response = error\",\n \"def api_call(uri, name, method='get', **kwargs):\\n # Ensure uri is valid\\n if not bool(urlparse.urlparse(uri).netloc):\\n print(\\\"Error: {0} is not a valid url\\\").format(uri)\\n return False\\n func = getattr(requests, method)\\n args = {}\\n for key, value in kwargs.iteritems():\\n args[key] = value\\n try:\\n response = func(uri, **args)\\n except requests.exceptions.Timeout:\\n print \\\"The api call to {0} timed out\\\".format(uri)\\n except requests.exceptions.TooManyRedirects:\\n print \\\"The api call to {0} appears incorrect, returned: too many re-directs\\\".format(uri)\\n except requests.exceptions.RequestException as error:\\n print \\\"The api call to {0} failed\\\\n Error {1}\\\".format(uri, error)\\n sys.exit(1)\\n try:\\n response_dictionary = response.json()\\n except ValueError:\\n return response\\n #If API call errors out print the error and quit the script\\n if response.status_code not in [200, 201]:\\n if 'errors' in response_dictionary:\\n errors = response_dictionary.pop('errors')\\n first_error = errors.pop()\\n elif 'error' in response_dictionary:\\n first_error = response_dictionary.pop('error')\\n else:\\n first_error['message'] = \\\"No error message provided by response\\\"\\n msg = \\\"{0} returned an error, exiting the script.\\\\n\\\".format(name)\\n msg += \\\"Status Code: {0} \\\\n\\\".format(response.status_code)\\n msg += \\\"Error: {0}\\\".format(first_error['message'])\\n print msg\\n return False\\n else:\\n return response_dictionary\",\n \"def perform_request(self,\\n request: RequestBase,\\n method: str='POST'\\n ):\\n headers = {\\n 'Accept': 'application/json',\\n 'User-Agent': self.user_agent()\\n }\\n if APIAuthentication.use_http_auth:\\n headers['Authorization'] = 'Basic {auth}'.format(auth=self.get_auth())\\n\\n # Lazy loader for api credentials.\\n if request.requires_api_token() and ParamValidator.is_empty(request.api_token)\\\\\\n and ParamValidator.not_empty(APIAuthentication.api_token):\\n request.api_token = APIAuthentication.api_token\\n if request.requires_service_id() and ParamValidator.is_empty(request.service_id)\\\\\\n and ParamValidator.not_empty(APIAuthentication.service_id):\\n request.service_id = APIAuthentication.service_id\\n\\n # Build url\\n url = \\\"{0}/{1}\\\".format(PAYNL_END_POINT, request.get_url())\\n parameters = request.get_parameters()\\n if APIAuthentication.use_http_auth and 'token' in parameters:\\n del parameters['token']\\n\\n if self.print_debug:\\n print(\\\"Calling {} using {}\\\".format(url, method))\\n print(\\\"HTTP Headers: {}\\\".format(json.dumps(headers)))\\n print(\\\"Params: {}\\\".format(json.dumps(parameters)))\\n\\n if method.upper() == 'GET':\\n response = requests.get(url, verify=True, headers=headers, params=parameters)\\n else:\\n response = requests.post(url, verify=True, headers=headers, data=parameters)\\n\\n if response.status_code not in self.__supported_status_codes:\\n response.raise_for_status()\\n\\n if self.print_debug:\\n print(\\\"Response object: {}\\\".format(response))\\n print(\\\"Raw response: {}\\\".format(response.text))\\n\\n # Now the we have a response, let the request class handle the response.\\n request.raw_response = response.text\\n\\n if self.print_debug:\\n print(type(request.response))\\n\\n if request.response.is_error():\\n raise ErrorException(request.response.request)\",\n \"def _make_request(self, url: str, parameters: dict = None,\\n method: str = 'GET', *args, **kwargs):\\n response = requests.request(\\n method=method,\\n url=build_url(\\n self.BASE_API_URL, url, parameters\\n ),\\n headers={\\n 'Authorization': 'Bearer {}'.format(self._access_token)\\n }, **kwargs\\n )\\n if response.ok:\\n return response.json()\\n raise MondoApiException(response.json()['message'])\",\n \"def _call_api(endpoint, query, data):\\n headers = {\\\"Content-Type\\\": \\\"application/json\\\", }\\n response = InnerTube._execute(f\\\"{endpoint}?{parse.urlencode(query)}\\\", \\\"POST\\\", headers=headers, data=data)\\n\\n try:\\n resp = json.loads(response.read())\\n except JSONDecodeError as e:\\n log(f\\\"{__class__.__name__}: Parsing response error: {e}\\\")\\n else:\\n return resp\",\n \"def _doRequest(self, httpClientMethod, *args):\\n try:\\n resp = httpClientMethod(*args)\\n return resp.json()\\n except RequestException as e:\\n raise checkedError(e)\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def _process_url(self, url):\\n response = requests.get(url, timeout=self.TIMEOUT)\\n try:\\n ret = response.json()\\n except JSONDecodeError:\\n self.log.exception(\\\"JSONDecodeError, response: %r, response.text: %r\\\", response, response.text)\\n ret = {\\\"error\\\": \\\"The api broke.\\\"}\\n return ret\",\n \"def api_call(url, method, debug, **kwargs):\\n resp = None\\n attempt = 0\\n maxattempts = 3\\n req = Request(method.upper(), url, **kwargs)\\n\\n if debug:\\n print(\\\"DEBUG: Request ({}) {}\\\".format(method.upper(), url))\\n\\n while True:\\n try:\\n attempt += 1\\n resp = Session().send(\\n Session().prepare_request(req), verify=True)\\n resp.raise_for_status()\\n break\\n except (HTTPError, ConnectionError, Timeout) as ex:\\n if attempt >= maxattempts:\\n abort(ex.message)\\n else:\\n time.sleep(1)\\n continue\\n except RequestException as ex:\\n abort(ex.message)\\n\\n if resp is not None:\\n return resp\\n else:\\n abort(\\\"Error making API call to URL: \\\" % url)\",\n \"def call(self, http_method, api_path, params=None, raw_data=False):\\n\\n # get function of requests package\\n requests_func = getattr(requests, http_method.lower())\\n\\n # parse parameters\\n req_params = {}\\n file_params = {}\\n\\n if params is not None:\\n for key, value in six.iteritems(params):\\n if isinstance(value, (datetime.date,\\n datetime.datetime,\\n float,\\n int)):\\n req_params[key] = six.text_type(value)\\n elif isinstance(value, six.string_types):\\n req_params[key] = six.text_type(value)\\n elif hasattr(value, \\\"read\\\"):\\n filename = os.path.split(value.name)[1]\\n if not _is_string_ascii_encodeable(filename):\\n b64_key = key + \\\"name_b64enc\\\"\\n byte_value = filename.encode(\\\"utf-8\\\")\\n b64_value = base64.b64encode(byte_value).decode(\\\"utf-8\\\")\\n\\n filename = \\\"@param=%s\\\" % b64_key\\n req_params[b64_key] = b64_value\\n file_params[key] = (filename, value, \\\"application/octet-stream\\\")\\n else:\\n raise VMRayRESTAPIError(\\\"Parameter \\\\\\\"{}\\\\\\\" has unknown type \\\\\\\"{}\\\\\\\"\\\".format(key, type(value)))\\n\\n # construct request\\n if file_params:\\n files = file_params\\n else:\\n files = None\\n\\n # we need to adjust some stuff for POST requests\\n if http_method.lower() == \\\"post\\\":\\n req_data = req_params\\n req_params = None\\n else:\\n req_data = None\\n\\n # do request\\n result = requests_func(self.server + api_path,\\n data=req_data,\\n params=req_params,\\n headers={\\\"Authorization\\\": \\\"api_key {}\\\".format(self.api_key)},\\n files=files,\\n verify=self.verify_cert,\\n stream=raw_data)\\n handle_rest_api_result(result)\\n\\n if raw_data:\\n return result.raw\\n\\n # parse result\\n try:\\n json_result = result.json()\\n except ValueError:\\n raise ValueError(\\\"API returned invalid JSON: {}\\\".format(result.text))\\n\\n # if there are no cached elements then return the data\\n if \\\"continuation_id\\\" not in json_result:\\n return json_result.get(\\\"data\\\", None)\\n\\n data = json_result[\\\"data\\\"]\\n\\n # get cached results\\n while \\\"continuation_id\\\" in json_result:\\n # send request to server\\n result = requests.get(\\\"{}/rest/continuation/{}\\\".format(self.server, json_result[\\\"continuation_id\\\"]),\\n headers={\\\"Authorization\\\": \\\"api_key {}\\\".format(self.api_key)},\\n verify=self.verify_cert)\\n handle_rest_api_result(result)\\n\\n # parse result\\n try:\\n json_result = result.json()\\n except ValueError:\\n raise ValueError(\\\"API returned invalid JSON: {}\\\".format(result.text))\\n\\n data.extend(json_result[\\\"data\\\"])\\n\\n return data\",\n \"def call_api(self, url, method='GET', headers=None, params=None, data=None):\\n r = requests.request(method=method, url=url, headers=headers, params=params, data=data)\\n \\n self.log.debug(f'Called endpoint {url} with result {r}')\\n\\n try:\\n jayson = json.loads(r.text)\\n return jayson\\n except:\\n self.log.info(f'ERROR! Text of response object: {r.text}')\",\n \"async def _make_request(self, url: str, params, server_id: str):\\n headers = {\\n 'X-Response-Control': 'minified',\\n 'User-Agent': 'Friendly Red bot'\\n }\\n\\n if server_id in self.config:\\n if 'API_TOKEN' in self.config[server_id]:\\n headers['X-Auth-Token'] = self.config['API_TOKEN']\\n else:\\n await self.bot.say(box('Requests made without an authentication token are limited to 100 requests per 24 hours.\\\\nYou can request a key by registering at http://api.football-data.org and setting it via [p]football tokenset.'))\\n\\n async with aiohttp.get(url, headers=headers, params=params) as r:\\n if r.status == 200:\\n data = await r.json()\\n return data\\n elif r.status == 400:\\n await self.bot.say(box('Bad Request [400]:\\\\nYour request was malformed most likely the value of a Filter was not set according to the Data Type that is expected.'))\\n return\\n elif r.status == 403:\\n await self.bot.say(box('Restricted Resource [403]:\\\\nYou tried to access a resource that exists, but is not available for you. This can be out of the following reasons:\\\\n- the resource is only available to authenticated clients\\\\n- the resource is only available to donating clients\\\\n- the resource is not available in the API version you are using'))\\n return\\n elif r.status == 404:\\n await self.bot.say(box('Not found [404]\\\\nYou tried to access a resource that doesn’t exist.'))\\n return\\n elif r.status == 429:\\n await self.bot.say(box('Too many requests [429]\\\\nYou exceeded your allowed requests per minute/day depending on API version and your user status.\\\\nSee http://api.football-data.org/docs/v1/index.html#_request_throttling for more information.'))\\n await self.bot.say(box('Requests reset in ' + r.headers['X-RequestCounter-Reset'] + ' seconds.'))\\n return\\n else:\\n await self.bot.say(box('Pancake has no idea what you\\\\'ve done, seriously.'))\\n await self.bot.say(box(r.status + '\\\\n' + r.json()['error']))\\n return\",\n \"def _call(self, method, url, params):\\n if not url.startswith('http'):\\n url = self.root + url\\n headers = self._auth_headers()\\n headers['Content-Type'] = 'application/json'\\n\\n r = self._session.request(method, url,\\n headers=headers,\\n proxies=self.proxies,\\n params=params,\\n timeout=self.requests_timeout)\\n r.raise_for_status() # Check for error\\n return r.json()\",\n \"def _get_request(url_root,api_key,path,response_type,params, ssl_verify):\\n url = _url_builder(url_root,api_key,path,params)\\n content = _fetch(url, ssl_verify)\\n response = _dispatch(response_type)(content)\\n return response\",\n \"def _do_request(self, url: str):\\n\\n self.debug.ok('method', self.method)\\n\\n if self.client.fake_response_path:\\n with open(self.client.fake_response_path, 'r') as f:\\n return constants.ResponseCode.OK, f.read()\\n\\n elif self.method == constants.RequestConst.GET:\\n response = requests.get(\\n url, headers=self._headers(), timeout=self._timeout\\n )\\n\\n self.debug.ok(\\n constants.RequestConst.QUERY_PARAMETERS,\\n self.parameters[constants.RequestConst.QUERY]\\n )\\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\\n\\n return response.status_code, response.text\\n\\n elif self.method in [\\n constants.RequestConst.POST,\\n constants.RequestConst.PUT,\\n constants.RequestConst.DELETE\\n ]:\\n if self.method == constants.RequestConst.POST:\\n send_request = requests.post\\n elif self.method == constants.RequestConst.PUT:\\n send_request = requests.put\\n elif self.method == constants.RequestConst.DELETE:\\n send_request = requests.delete\\n\\n response = send_request(\\n url, json=self.parameters[constants.RequestConst.QUERY],\\n headers=self._headers(), timeout=self._timeout\\n )\\n\\n self.debug.ok('payload', self.parameters[\\n constants.RequestConst.QUERY\\n ])\\n self.debug.ok(constants.ResponseConst.RESPONSE_OBJECT, response)\\n\\n return response.status_code, response.text\\n\\n else:\\n return constants.ResponseCode.NOT_FOUND, {}\",\n \"def pull(self, url, params=None, data=None, auth=None, method=\\\"GET\\\"):\\n try:\\n __method_name = inspect.currentframe().f_code.co_name\\n if method == \\\"POST\\\":\\n res = self.session.post(\\n url=url,\\n auth=auth,\\n params=params,\\n data=data,\\n timeout=consts.API_TIMEOUT,\\n )\\n else:\\n res = self.session.get(\\n url=url,\\n auth=auth,\\n params=params,\\n data=data,\\n timeout=consts.API_TIMEOUT,\\n )\\n res.raise_for_status()\\n if res and res.status_code in [200, 201]:\\n self.applogger.debug(\\n '{}(method={}) : {} : API call: Response received successfully. url=\\\"{}\\\" params=\\\"{}\\\"'.format(\\n consts.LOGS_STARTS_WITH,\\n __method_name,\\n self.function_name,\\n url,\\n params,\\n )\\n )\\n return res.json()\\n else:\\n self.applogger.error(\\n \\\"{}(method={}) : {} : API call: Unknown status code or empty \\\"\\n 'response: url=\\\"{}\\\" status_code=\\\"{}\\\" response=\\\"{}\\\"'.format(\\n consts.LOGS_STARTS_WITH,\\n __method_name,\\n self.function_name,\\n url,\\n res.status_code,\\n res.text,\\n )\\n )\\n raise Exception(\\\"Received unknown status code or empty response.\\\")\\n except requests.exceptions.HTTPError as ex:\\n if res.status_code == 404:\\n self.applogger.debug(\\n '{}(method={}) : {} : API call: Got {} Status Code : url=\\\"{}\\\"'\\n ' response=\\\"{}\\\"'.format(\\n consts.LOGS_STARTS_WITH,\\n __method_name,\\n self.function_name,\\n url,\\n ex.response.status_code,\\n ex.response.text,\\n )\\n )\\n return {}\\n else:\\n self.applogger.error(\\n '{}(method={}) : {} : API call: Unsuccessful response: url=\\\"{}\\\" status_code=\\\"{}\\\"'\\n ' response=\\\"{}\\\"'.format(\\n consts.LOGS_STARTS_WITH,\\n __method_name,\\n self.function_name,\\n url,\\n ex.response.status_code,\\n ex.response.text,\\n )\\n )\\n raise Exception(\\\"HTTP Error Occurred while getting response from api.\\\")\\n except Exception as ex:\\n self.applogger.error(\\n '{}(method={}) : {} : API call: Unexpected error while API call url=\\\"{}\\\" error=\\\"{}\\\"'.format(\\n consts.LOGS_STARTS_WITH,\\n __method_name,\\n self.function_name,\\n url,\\n str(ex),\\n )\\n )\\n raise Exception(\\\"Error Occurred while getting response from api.\\\")\",\n \"async def handle_request(self, api_endpoint, api_version):\\n code = 400\\n data = self.get_post_data()\\n request_method = self.request.method.lower()\\n if data:\\n try:\\n # will call process_get or process_post methods for the given API\\n res = await getattr(api_endpoint, 'process_' + request_method)(api_version, data)\\n code = 200\\n except ValidationError as validerr:\\n if validerr.absolute_path:\\n res = '%s : %s' % (\\n validerr.absolute_path.pop(), validerr.message)\\n else:\\n res = '%s' % validerr.message\\n LOGGER.error('ValidationError: %s', res)\\n raise tornado.web.HTTPError(reason=res)\\n except ValueError as valuerr:\\n res = str(valuerr)\\n LOGGER.error('ValueError: %s', res)\\n raise tornado.web.HTTPError(reason=res)\\n except DatabaseError as dberr:\\n err_id = dberr.__hash__()\\n res = str(dberr.reason)\\n LOGGER.error(res)\\n LOGGER.info(\\\"Input data for <%s>: %s\\\", err_id, data)\\n raise dberr\\n except Exception as err: # pylint: disable=broad-except\\n err_id = err.__hash__()\\n res = 'Internal server error <%s>:' \\\\\\n 'please include this error id in bug report.' % err_id\\n code = 500\\n LOGGER.exception(res)\\n LOGGER.info(\\\"Input data for <%s>: %s\\\", err_id, data)\\n raise tornado.web.HTTPError(reason=res)\\n else:\\n res = 'Error: malformed input JSON.'\\n LOGGER.error(res)\\n raise tornado.web.HTTPError(reason=res)\\n\\n # raise tornado.web.HTTPError(status_code=444, reason='error happened')\\n self.set_status(code)\\n self.write(res)\",\n \"def _execApiCall(headers, params, method_name,\\r\\n domain='ma.gnolia.com',\\r\\n urlhead='/api/rest/1/'):\\r\\n \\r\\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\\r\\n raise MagnoliaException('Required API Key parameter missing')\\r\\n conn = httplib.HTTPConnection(domain)\\r\\n conn.request('POST', urlhead + method_name, params, headers)\\r\\n return conn.getresponse()\",\n \"def _parse_response(self, response, all_ops):\\n try:\\n parsed_response = json.loads(response)\\n except Exception, e:\\n raise ApiError(e)\\n if 'error' in parsed_response: # needed anymore?\\n raise ApiError(parsed_response['error'])\\n # Return the true API return value.\\n return parsed_response\",\n \"def api():\\n try:\\n data = json.loads(request.data)\\n except:\\n return jsonify({\\\"jsonrpc\\\": \\\"2.0\\\", \\\"error\\\": {\\\"code\\\": -32700, \\\"message\\\": \\\"Parse error\\\"}, \\\"id\\\": None}), 500\\n return jsonify(hwi.jsonrpc(data))\",\n \"def _request(self, method, url, body=None, headers=None, serialize=True):\\n headers = headers or {}\\n headers['Accept'] = 'application/json'\\n headers['User-Agent'] = 'paxes-httpclient'\\n if body and not 'Content-Type' in headers:\\n headers['Content-Type'] = 'application/json'\\n if self.auth_token:\\n headers['X-Auth-Token'] = self.auth_token\\n LOG.debug('>> %s %s, %s, %s' % (method, url, headers, body))\\n conn = self._create_connection(url)\\n if body and serialize:\\n body = json.dumps(body)\\n conn.request(method, url, body, headers)\\n res = conn.getresponse()\\n header_list = res.getheaders()\\n header_dict = {}\\n for ituple in header_list:\\n header_dict[ituple[0].lower()] = ituple[1]\\n response_info = {\\n 'status': res.status,\\n 'reason': res.reason,\\n 'headers': header_dict,\\n 'body': res.read()\\n }\\n LOG.debug('<< %d %s, %s, %s' % (response_info['status'],\\n response_info['reason'],\\n response_info['headers'],\\n response_info['body']))\\n conn.close()\\n return response_info\",\n \"def _http_post(self, url, params={}):\\n url = self.server + '/api2' + url\\n try:\\n r = requests.post(url=url, data=params)\\n except requests.exceptions.RequestException as e:\\n return check_failed(e)\\n # raise ClientHttpError(None, e)\\n if r.status_code != 200:\\n return check_failed(r.status_code)\\n # return ClientHttpError(r.status_code, r.text)\\n data = json.loads(r.text)\\n # TODO: check data\\n return data\",\n \"def make_request(request_url, request_url_without_api_key):\\n response = requests.get(request_url)\\n if response.status_code != requests.codes.ok:\\n err = \\\"Check the URL and API details, cannot connect to: `{}`\\\".format(\\n request_url_without_api_key\\n )\\n logger.error(err)\\n raise TaskError(\\\"Bad response from server: {}\\\".format(err))\\n try:\\n packages = response.json()\\n except json.JSONDecodeError:\\n err = \\\"Response is OK, but cannot decode JSON from server\\\"\\n logger.error(err)\\n raise TaskError(err)\\n return packages\",\n \"def _request(http, project, method, data, base_url, client_info):\\n user_agent = client_info.to_user_agent()\\n headers = {\\n \\\"Content-Type\\\": \\\"application/x-protobuf\\\",\\n \\\"User-Agent\\\": user_agent,\\n connection_module.CLIENT_INFO_HEADER: user_agent,\\n }\\n api_url = build_api_url(project, method, base_url)\\n\\n response = http.request(url=api_url, method=\\\"POST\\\", headers=headers, data=data)\\n\\n if response.status_code != 200:\\n error_status = status_pb2.Status.FromString(response.content)\\n raise exceptions.from_http_status(\\n response.status_code, error_status.message, errors=[error_status]\\n )\\n\\n return response.content\",\n \"async def _perform_api_request(self, url, **kwargs):\\n error = ''\\n json = {}\\n max_retries = 5\\n for retries in range(max_retries):\\n async with self._session.get(url, **kwargs) as resp:\\n self.request_count += 1\\n status = resp.status\\n if resp.status == 504:\\n error = 'API timeout'\\n self.retry_count += 1\\n continue\\n try:\\n resp.raise_for_status()\\n except ClientResponseError:\\n error = f'{resp.status}: {resp.reason}'\\n continue\\n try:\\n json = await resp.json()\\n except ContentTypeError:\\n error = 'Unable to decode JSON'\\n self.retry_count += 1\\n status = 0\\n continue\\n json['request_datetime'] = datetime.now()\\n break\\n\\n if retries == max_retries - 1 and error:\\n logger.warning(error)\\n\\n return json, status\",\n \"def __make_api_post(self, api_path, data=None):\\n headers = {\\n \\\"Content-type\\\": \\\"application/json\\\",\\n \\\"Accept\\\": \\\"application/json\\\"}\\n x = json.dumps(data)\\n\\n try:\\n req = urllib2.Request(self.api_server + api_path, x, headers)\\n self.last_response = urllib2.urlopen(req, cafile=self.cacert_path)\\n json_data = self.last_response.read()\\n\\n # Check for errors\\n except urllib2.HTTPError as err:\\n error = \\\"API HTTP error [%s] - '%s'\\\" % (err.code, err)\\n raise EFIgyCliError(error, err)\\n\\n except urllib2.URLError as err:\\n error = 'Problem calling API at location %s - %s' % (\\n self.api_server + api_path, err)\\n raise EFIgyCliError(error, self.last_response)\\n\\n # Decode json response into an object\\n try:\\n ret = json.loads(json_data)\\n except ValueError as err:\\n error = \\\"Problem deserialising data, expecting JSON.\\\\nError: %s\\\\nData: %s\\\" % (\\n err, json_data)\\n raise EFIgyCliError(error, self.last_response)\\n\\n # Return JSON deserialised object\\n # print \\\"DEBUG - %s\\\"%(ret), type(ret)\\n return ret\",\n \"async def request_api(url):\\n\\theaders = {\\\"User-Agent\\\": f\\\"Mozilla/5.0 aiotfm/{__version__}\\\"}\\n\\n\\ttry:\\n\\t\\tasync with aiohttp.ClientSession() as session:\\n\\t\\t\\tasync with session.get(url, headers=headers) as resp:\\n\\t\\t\\t\\treturn await resp.json()\\n\\texcept aiohttp.ClientError:\\n\\t\\treturn {}\",\n \"def _make_request(self):\\n response = urllib2.urlopen(\\n url=self.api_url,\\n data=self._get_request_data()\\n )\\n content = response.read()\\n return json.loads(content.decode('utf8'))\",\n \"def _response(request):\\n with urllib.request.urlopen(request) as response:\\n status = response.getcode()\\n # print(status, response.info(), )\\n data = json.loads(\\n response.read().decode('utf-8')\\n )\\n # print(data)\\n if status == 200 and data[\\\"ok\\\"]:\\n return data, status\\n elif status == 200 and not data[\\\"ok\\\"]:\\n raise ValueError('client._response() - Server response is not good ' +\\n json.dumps(data))\\n else:\\n raise ConnectionFault('client._response() - Connection Error: ' +\\n str(response.getcode()))\",\n \"async def send_request(self, url: str, params: dict) -> dict:\\n if self.session is None:\\n # Create a session if one doesn't exist\\n await self.create_session()\\n\\n async with self.session.get(url, params=params, headers=self.headers) as resp:\\n # Make sure that the response of the request\\n # returns code 200. Something wrong happened if it doesn't\\n if not (300 > resp.status >= 200):\\n # Raise an error if the status code isn't 200\\n raise ParsingError(f\\\"Library error parsing request from API: {str(resp.status)}\\\")\\n\\n try:\\n # We attempt to return the contents\\n # of the request in JSON format\\n response = await resp.json()\\n if resp.status >= 400:\\n # This is a validation error from the API\\n # Likely has to do with missing/improper params\\n missing_params = list()\\n for param in response[\\\"detail\\\"]:\\n missing_params.append(f\\\"{param['msg']} - {param['loc'][0]}\\\")\\n raise InvalidParams(f\\\"Impropert params in given request: {missing_params}\\\")\\n # If that fails, simply return the contents of the request\\n # without ant kind of formatting (aka just read it)\\n except aiohttp.ClientResponseError:\\n raise ParsingError(\\\"Could not return contents from the request\\\")\\n\\n # Return the respose from the request, if any\\n return response\",\n \"async def _api_request(self, path: str, method=\\\"GET\\\") -> Any:\\n params = {\\\"access_token\\\": self.token}\\n\\n attempt = 0\\n while attempt <= MAX_REQUEST_ATTEMPT_COUNT:\\n attempt += 1\\n conn = aiohttp.TCPConnector(ssl=False)\\n try:\\n async with aiohttp.request(\\n method, f\\\"{self.api_url}/{path}\\\", params=params, connector=conn\\n ) as resp:\\n if resp.status >= 400:\\n # retry on server errors or request timeout w/ increasing delay\\n if resp.status >= 500 or resp.status == 408:\\n if attempt < MAX_REQUEST_ATTEMPT_COUNT:\\n _LOGGER.debug(\\n \\\"%s request to %s failed with code %d: %s.\\\"\\n \\\" Retrying...\\\",\\n method,\\n path,\\n resp.status,\\n resp.reason,\\n )\\n await asyncio.sleep(\\n attempt * REQUEST_RETRY_DELAY_INTERVAL\\n )\\n continue\\n\\n if resp.status == 401:\\n raise InvalidToken()\\n else:\\n raise RequestError(resp)\\n try:\\n json = await resp.json()\\n if \\\"error\\\" in json and json[\\\"error\\\"]:\\n raise RequestError(resp)\\n return json\\n except ContentTypeError as e:\\n text = await resp.text()\\n _LOGGER.warn(\\\"Unable to parse as JSON: %s\\\", text)\\n raise e\\n except (\\n ClientConnectionError,\\n asyncio.TimeoutError,\\n ContentTypeError,\\n ) as e:\\n # catch connection exceptions to retry w/ increasing delay\\n if attempt < MAX_REQUEST_ATTEMPT_COUNT:\\n _LOGGER.debug(\\n \\\"%s request to %s failed with %s. Retrying...\\\",\\n method,\\n path,\\n str(e),\\n )\\n await asyncio.sleep(attempt * REQUEST_RETRY_DELAY_INTERVAL)\\n continue\\n else:\\n raise e\\n finally:\\n await conn.close()\",\n \"def http_request(\\n self,\\n method: str,\\n url_suffix: str,\\n json_data=None,\\n params=None,\\n headers=None,\\n ):\\n resp = Response()\\n try:\\n resp = super()._http_request(\\n method=method,\\n url_suffix=url_suffix,\\n json_data=json_data,\\n params=params,\\n headers=headers,\\n resp_type='response',\\n timeout=self.request_timeout,\\n ok_codes=(200, 201),\\n error_handler=self.handle_error_response,\\n )\\n except MissingSchema:\\n raise ValueError(MESSAGES['MISSING_SCHEMA_ERROR'])\\n except InvalidSchema:\\n raise ValueError(MESSAGES['INVALID_SCHEMA_ERROR'])\\n except InvalidURL:\\n raise ValueError(MESSAGES['INVALID_API_URL'])\\n except DemistoException as e:\\n self.handle_demisto_exception(e)\\n\\n if resp.ok:\\n content_type = resp.headers.get('Content-Type', '')\\n if content_type == CONTENT_TYPE_JSON:\\n # Handle empty response\\n if resp.text == '':\\n return resp\\n else:\\n return resp.json()\\n elif self.is_supported_context_type(content_type):\\n return resp\",\n \"def request_routine(self, url, request_method, json_data=None):\\n response_obj = requests.request(request_method,\\n url=url,\\n headers=self.header,\\n data=json.dumps(json_data),\\n verify=self.verify)\\n\\n LOG.debug('JovianDSS: Response code: %s', response_obj.status_code)\\n LOG.debug('JovianDSS: Response data: %s', response_obj.text)\\n\\n ret = dict()\\n ret['code'] = response_obj.status_code\\n\\n if '{' in response_obj.text and '}' in response_obj.text:\\n if \\\"error\\\" in response_obj.text:\\n ret[\\\"error\\\"] = json.loads(response_obj.text)[\\\"error\\\"]\\n else:\\n ret[\\\"error\\\"] = None\\n if \\\"data\\\" in response_obj.text:\\n ret[\\\"data\\\"] = json.loads(response_obj.text)[\\\"data\\\"]\\n else:\\n ret[\\\"data\\\"] = None\\n\\n return ret\",\n \"def make_request(self, url):\\n try:\\n response = requests.get(url)\\n if response.status_code != 200:\\n return None\\n return response.json()\\n except requests.ConnectionError:\\n return None\",\n \"def call_api(payload):\\n data = requests.get(weatherbit_url, params=payload)\\n assert data.status_code == 200, f\\\"Something wrong. Error details: {data.json()['error']}\\\"\\n assert 'error' not in data.json().keys(), f'Problem: {data.json()}'\\n return data.json()\",\n \"def _request(self, query):\\n query_string = self._create_query_string(query)\\n\\n try:\\n response = requests.get(query_string)\\n except requests.exceptions.ConnectionError:\\n raise EngineConnectionException(self.name, \\\"Unable to send request, check connectivity.\\\")\\n\\n if response.status_code != 200:\\n raise EngineConnectionException(self.name, \\\"\\\", code=response.status_code)\\n\\n return self._parse_json_response(query, response)\",\n \"def http_request(self, method: str, url_suffix: str, params: dict = None, json_data: dict = None, **kwargs):\\n response = self._http_request(method, url_suffix, params=params, json_data=json_data, resp_type=\\\"response\\\",\\n ok_codes=[200, *list(HTTP_ERRORS.keys())], raise_on_status=False, **kwargs)\\n if response.status_code == 400 and response.json() and response.json().get('Message'):\\n raise DemistoException(\\n HTTP_ERRORS[response.status_code].format(\\\"Message:\\\" + response.json().get(\\\"Message\\\")))\\n elif response.status_code in list(HTTP_ERRORS.keys()):\\n raise DemistoException(HTTP_ERRORS[response.status_code])\\n return response.json()\",\n \"def _request(self, method, api_url, **kwargs):\\n if not self.connected:\\n raise Exception(\\\"'{d}' is not connected for alias '{a}'\\\"\\n .format(d=self.device.name,\\n a=self.alias))\\n\\n # Deal with the dn\\n full_url = '{f}{api_url}'.format(f=self.url, api_url=api_url)\\n\\n if 'data' in kwargs:\\n payload = kwargs['data']\\n elif 'json' in kwargs:\\n payload = kwargs['json']\\n else:\\n payload = ''\\n\\n log.info(\\\"Sending {method} command to '{d}':\\\"\\n \\\"\\\\napi_url: {furl}\\\\nPayload:{payload}\\\"\\n .format(method=method,\\n d=self.device.name,\\n furl=full_url,\\n payload=payload))\\n\\n headers = {\\n 'Dcnm-Token': self.token,\\n 'Content-type': 'application/json'\\n }\\n\\n # Send to the device\\n response = self.session.request(method=method, url=full_url, headers=headers, **kwargs)\\n\\n\\n # Make sure it was successful\\n try:\\n response.raise_for_status()\\n except Exception:\\n raise RequestException(\\n \\\"'{c}' result code has been returned \\\"\\n \\\"for '{d}'.\\\\nResponse from server: \\\"\\n \\\"{r}\\\".format(d=self.device.name,\\n c=response.status_code,\\n r=response.text))\\n\\n # In case the response cannot be decoded into json\\n # warn and return the raw text\\n\\n try:\\n output = response.json()\\n if isinstance(output, list):\\n output = {\\\"temproot\\\": output}\\n except Exception:\\n log.warning('Could not decode json. Returning text!')\\n output = response.text\\n\\n return output\",\n \"def _request(self, url):\\n response = requests.get(url, headers=self.header)\\n\\n if str(response.status_code).startswith('2'):\\n return response\\n\\n raise Exception(\\\"URI request returned an error. Error Code \\\" + str(response.status_code))\",\n \"def base_request(url_path):\\n response = requests.get(settings.URL_API + url_path)\\n if response.status_code != 200:\\n return response\\n else:\\n return response.json()\",\n \"def api_call(endpoint, params, headers):\\n\\n api_response = get(BASE_URL.format(endpoint=endpoint), params=params,\\n headers=headers)\\n\\n api_response.raise_for_status()\\n json_resp = api_response.json()\\n\\n api_response.close()\\n return json_resp\",\n \"def make_api_call(action, parameters = {}, method = 'get', data = {}):\\n headers = {\\n 'Content-type': 'application/json',\\n 'Accept-Encoding': 'gzip',\\n 'Authorization': 'Bearer %s' % ACCESS_TOKEN\\n }\\n if method == 'get':\\n r = s.request(method, API_BASE_URL+action, headers=headers, params=parameters, timeout=30)\\n elif method == 'post':\\n r = s.request(method, API_BASE_URL+action, headers=headers, data=data, params=parameters, timeout=10)\\n else:\\n raise ValueError('Method should be get or post.')\\n log('API %s call: %s' % (method, r.url) )\\n if ((r.status_code == 200 and method == 'get') or (r.status_code == 201 and method == 'post')):\\n return r.json()\\n else:\\n raise ValueError('API error when calling %s : %s' % (r.url, r.content))\",\n \"def request(self, verb, subpath, data=''):\\n if not self.api_key or not self.api_secret:\\n raise Exception(\\\"Vingd authentication credentials undefined.\\\")\\n \\n endpoint = urlparse(self.api_endpoint)\\n if endpoint.scheme != 'https':\\n raise Exception(\\\"Invalid Vingd endpoint URL (non-https).\\\")\\n \\n host = endpoint.netloc.split(':')[0]\\n port = 443\\n path = urljoin(endpoint.path+'/', subpath)\\n \\n creds = \\\"%s:%s\\\" % (self.api_key, self.api_secret)\\n headers = {\\n 'Authorization': b'Basic ' + base64.b64encode(creds.encode('ascii')),\\n 'User-Agent': self.USER_AGENT\\n }\\n try:\\n conn = httplib.HTTPSConnection(host, port)\\n conn.request(verb.upper(), quote(path), data, headers)\\n r = conn.getresponse()\\n content = r.read().decode('ascii')\\n code = r.status\\n conn.close()\\n except httplib.HTTPException as e:\\n raise InternalError('HTTP request failed! (Network error? Installation error?)')\\n \\n try:\\n content = json.loads(content)\\n except:\\n raise GeneralException(content, 'Non-JSON server response', code)\\n \\n if 200 <= code <= 299:\\n try:\\n return content['data']\\n except:\\n raise InvalidData('Invalid server DATA response format!')\\n \\n try:\\n message = content['message']\\n context = content['context']\\n except:\\n raise InvalidData('Invalid server ERROR response format!')\\n \\n if code == Codes.BAD_REQUEST:\\n raise InvalidData(message, context)\\n elif code == Codes.FORBIDDEN:\\n raise Forbidden(message, context)\\n elif code == Codes.NOT_FOUND:\\n raise NotFound(message, context)\\n elif code == Codes.INTERNAL_SERVER_ERROR:\\n raise InternalError(message, context)\\n elif code == Codes.CONFLICT:\\n raise GeneralException(message, context)\\n \\n raise GeneralException(message, context, code)\",\n \"def _method_call(self, method, **kwargs):\\n try:\\n connection = httplib.HTTPConnection(self._api_address)\\n except:\\n raise FantasyDataError('Error: Cannot connect to the FantasyData API')\\n\\n try:\\n method = method.format(format=self._response_format, **kwargs)\\n request_url = \\\"/standard/{format}/{method}?{get_params}\\\".format(format=self._response_format, method=method,\\n get_params=self._get_params)\\n connection.request(\\\"GET\\\", request_url, \\\"\\\", self._headers)\\n response = connection.getresponse()\\n\\n result = json.loads(response.read())\\n\\n if isinstance(result, dict) and \\\"statusCode\\\" in result:\\n if (result['statusCode']) == 401:\\n raise FantasyDataError('Error: Invalid API key')\\n else:\\n raise FantasyDataError('Error: Failed to get response')\\n\\n return result\\n # except:\\n # pass\\n finally:\\n connection.close()\",\n \"def http_call(\\n self,\\n method,\\n url,\\n data=None,\\n json_data=None,\\n headers=None,\\n verify=False,\\n params=None,\\n ):\\n if data:\\n _response = getattr(self.session, method.lower())(\\n url, data=data, headers=headers, params=params, verify=verify\\n )\\n\\n elif json_data:\\n _response = getattr(self.session, method.lower())(\\n url, json=json_data, headers=headers, params=params, verify=verify\\n )\\n\\n else:\\n _response = getattr(self.session, method.lower())(\\n url, headers=headers, params=params, verify=verify\\n )\\n self.api_calls += 1\\n\\n try:\\n _response.raise_for_status()\\n except HTTPError:\\n raise HTTPError(\\n f\\\"{_response.json()['status']}: {_response.json()['message']}\\\"\\n )\\n\\n return _response\",\n \"def _api_call(self, api_call, method=\\\"GET\\\", payload=None):\\n # type: (str, str, Dict[str, str]) -> requests.Response\\n\\n headers = {\\n \\\"accept\\\" : \\\"application/json\\\",\\n \\\"Authorization\\\" : f\\\"Bearer {self.access_token}\\\",\\n \\\"x-ibm-client-id\\\" : self.client_id,\\n }\\n self.__log.debug(headers)\\n api_url = f\\\"{self.base_url}/{api_call}\\\"\\n\\n self.__log.debug(f\\\"Calling {api_url} with method {method}\\\")\\n if method == \\\"GET\\\":\\n resp = requests.get(api_url, headers=headers)\\n elif method == \\\"POST\\\":\\n resp = requests.post(api_url, headers=header, data=payload)\\n elif method == \\\"PUT\\\":\\n resp = requests.put(api_url, headers=header, data=payload)\\n elif method == \\\"DELETE\\\":\\n resp = requests.delete(api_url, headers=headers)\\n elif method == \\\"HEAD\\\":\\n resp = requests.head(api_url, headers=headers)\\n elif method == \\\"OPTIONS\\\":\\n resp = requests.options(api_url, headers=headers)\\n else:\\n raise Exception(f\\\"The method {method} is unsupported\\\")\\n \\n if (resp.ok):\\n return resp\\n else:\\n self.__log.debug(resp.status_code)\\n self.__log.debug(resp.text)\\n return resp\",\n \"def request(self, service, data):\\n _res = self._request(service, data)\\n res = _res.json()[0][0]\\n if res[\\\"success\\\"] == True:\\n return res[\\\"result\\\"]\\n else:\\n err_msg = res[\\\"errmsg\\\"]\\n raise Exception(\\\"Request not successful: '{0}'\\\".format(err_msg))\",\n \"def send_request(self, request):\\n json_results = requests.get(request).json()\\n\\n status = json_results['status']\\n\\n if status == const.STATUS_OK:\\n return json_results['results']\\n\\n self.log.warning(self.get_status_code(status))\",\n \"def request(self, params):\\n params[\\\"public_key\\\"] = self.__PUBLIC_KEY\\n post_data = urllib.parse.urlencode(params)\\n hmac_ = hmac.new(self.__SECRET_KEY, post_data.encode(\\\"utf-8\\\"), hashlib.sha256).hexdigest()\\n\\n curl = pycurl.Curl()\\n curl.setopt(pycurl.URL, self.__URL)\\n curl.setopt(pycurl.HTTPHEADER, ['HMAC: ' + str(hmac_)])\\n curl.setopt(pycurl.POST, True)\\n curl.setopt(pycurl.POSTFIELDS, post_data)\\n curl.setopt(pycurl.CONNECTTIMEOUT, 10)\\n curl.setopt(pycurl.TIMEOUT, 5)\\n\\n buf = io.BytesIO()\\n curl.setopt(pycurl.WRITEFUNCTION, buf.write)\\n curl.perform()\\n\\n response = buf.getvalue()\\n\\n # Uncomment to debug raw JSON response\\n # self.__log(\\\"< \\\" + response)\\n\\n http_code = curl.getinfo(pycurl.HTTP_CODE)\\n\\n curl.close()\\n\\n result = json.loads(response.decode('utf-8'))\\n\\n if http_code != 200:\\n if result[\\\"error\\\"]:\\n # 404 with some valid JSON\\n self.__log(\\\"ERROR: HTTP \\\" + str(http_code) + \\\": \\\" + json.dumps(result[\\\"error\\\"]))\\n else:\\n self.__log(\\\"ERROR: HTTP \\\" + str(http_code) + \\\": \\\" + response)\\n else:\\n if result is None:\\n self.__log(\\\"ERROR: Unparsable JSON \\\" + response)\\n else:\\n if 'error' in result: # || !$result[\\\"result\\\"]\\n self.__log(\\\"ERROR: \\\" + json_encode(result[\\\"error\\\"]))\\n else:\\n result = result[\\\"result\\\"]\\n\\n return result\",\n \"def _get(self, url: str) -> requests.Response:\\n # todo: do some error checking here\\n if url.startswith(API_PATH['base']):\\n try:\\n # logger.debug(f\\\"RestClient._get(): {url}\\\") # log in calling function\\n response = requests.get(url, auth=self.auth)\\n rest_code = response.json()['meta']['code']\\n if rest_code not in [200, 201, 204]:\\n raise RestException(f\\\"REST API Error: {rest_code}. {response.content}\\\")\\n except RestException as e:\\n logger.error(e)\\n return None\\n return response\\n else:\\n raise ValueError(f\\\"URL is invalid: {url}\\\")\",\n \"async def _request(\\n self, req_method: str, endpoint: str, extra_query: QueryDict = None, json=True\\n ) -> Union[Dict, bytes]:\\n if req_method not in (\\\"GET\\\", \\\"POST\\\"):\\n raise APIError(f\\\"{req_method} not a known request method!\\\")\\n\\n url = await self._create_url(endpoint, extra_query=extra_query)\\n\\n async with aiohttp.ClientSession() as session:\\n\\n session_methods = {\\\"GET\\\": session.get, \\\"POST\\\": session.post}\\n\\n async with session_methods[req_method](url) as resp:\\n self.logger.debug(\\\"got response: %s\\\", resp)\\n\\n if resp.status == 200:\\n if json:\\n data = await resp.json()\\n self.logger.debug(\\\"got json: %s\\\", data)\\n if data[\\\"subsonic-response\\\"][\\\"status\\\"] == \\\"failed\\\":\\n raise APIError(\\n data[\\\"subsonic-response\\\"][\\\"error\\\"][\\\"message\\\"]\\n )\\n return data\\n\\n data = await resp.read()\\n return data\\n\\n raise APIError(f\\\"got status code {resp.status}!\\\")\",\n \"async def _api_call(self, url, payload={}, retry=False):\\n timeout = aiohttp.ClientTimeout(total=self.api_timeout)\\n try:\\n async with self._client_session.get(\\n API_URL + url, headers=self.headers, timeout=timeout, data=payload\\n ) as resp:\\n if not retry and resp.status == 401:\\n await self.renew_auth()\\n return await self._api_call(url, payload, True)\\n\\n # 4xx represents unauthenticated\\n if resp.status == 401 or resp.status == 403 or resp.status == 404:\\n raise SenseAuthenticationException(f\\\"API Return Code: {resp.status}\\\")\\n\\n if resp.status != 200:\\n raise SenseAPIException(f\\\"API Return Code: {resp.status}\\\")\\n\\n return await resp.json()\\n except asyncio.TimeoutError as ex:\\n # timed out\\n raise SenseAPITimeoutException(\\\"API call timed out\\\") from ex\",\n \"def _api_call(self, **kwargs):\\n params = {\\n 'format': 'json',\\n }\\n params.update(kwargs)\\n r = requests.get(self.api_base_url, params=params)\\n return r.json()\",\n \"def execute(self) -> typing.Dict[str, typing.Any]:\\n headers = {\\n \\\"User-Agent\\\": \\\"{zenora.__name__} {zenora.__version__}\\\",\\n \\\"Authorization\\\": f\\\"{self.token}\\\",\\n }\\n if self.headers:\\n headers = self.headers\\n\\n if self.json:\\n r = requests.request(\\n method=self.method,\\n url=self.url,\\n headers=headers,\\n json=self.json,\\n )\\n else:\\n r = requests.request(\\n method=self.method,\\n url=self.url,\\n headers=headers,\\n data=self.form_data,\\n )\\n\\n return raise_error_or_return(r) # type: ignore[return-value]\",\n \"def __call(method, resource, headers=None, json=None):\\n result = requests.request(method, resource, headers=headers, json=json)\\n\\n if result:\\n try:\\n return result.json()\\n except ValueError:\\n pass\\n\\n _LOGGER.debug(\\\"Erroneous response (%s)\\\", result)\\n return result\",\n \"async def request(\\n self, method: str, path: Optional[str] = \\\"\\\", json: Optional[dict] = None\\n ) -> dict:\\n LOGGER.debug('Sending \\\"%s\\\" \\\"%s\\\" to \\\"%s %s\\\"', method, json, self.host, path)\\n\\n url = f\\\"http://{self.host}:{self.port}/api/{self.api_key}{path}\\\"\\n\\n try:\\n async with self.session.request(method, url, json=json) as res:\\n\\n if res.content_type != \\\"application/json\\\":\\n raise ResponseError(\\n \\\"Invalid content type: {}\\\".format(res.content_type)\\n )\\n\\n response = await res.json()\\n LOGGER.debug(\\\"HTTP request response: %s\\\", pformat(response))\\n\\n _raise_on_error(response)\\n\\n return response\\n\\n except client_exceptions.ClientError as err:\\n raise RequestError(\\n \\\"Error requesting data from {}: {}\\\".format(self.host, err)\\n ) from None\",\n \"def _make_request(self):\\n try:\\n self.response = requests.request(\\n method=self.method,\\n url=self.url,\\n params=self.params,\\n data=self.data,\\n )\\n\\n logger.debug(f\\\"Request URL: {self.response.url}\\\")\\n\\n self.response.raise_for_status()\\n\\n # wrap all `requests` library error and serve as custom application error\\n except RequestException as e:\\n logger.error(e.__str__(), exc_info=True)\\n raise ExternalAPIError(\\n \\\"Error while communication with External API\\\"\\n )\",\n \"def _do_api_call(\\n self,\\n endpoint_info: tuple[str, str],\\n json: dict[str, Any] | None = None,\\n wrap_http_errors: bool = True,\\n ):\\n method, endpoint = endpoint_info\\n\\n # TODO: get rid of explicit 'api/' in the endpoint specification\\n url = f\\\"https://{self.host}/{endpoint}\\\"\\n\\n aad_headers = self._get_aad_headers()\\n headers = {**self.user_agent_header, **aad_headers}\\n\\n auth: AuthBase\\n token = self._get_token()\\n if token:\\n auth = _TokenAuth(token)\\n else:\\n self.log.info(\\\"Using basic auth.\\\")\\n auth = HTTPBasicAuth(self.databricks_conn.login, self.databricks_conn.password)\\n\\n request_func: Any\\n if method == \\\"GET\\\":\\n request_func = requests.get\\n elif method == \\\"POST\\\":\\n request_func = requests.post\\n elif method == \\\"PATCH\\\":\\n request_func = requests.patch\\n elif method == \\\"DELETE\\\":\\n request_func = requests.delete\\n else:\\n raise AirflowException(\\\"Unexpected HTTP Method: \\\" + method)\\n\\n try:\\n for attempt in self._get_retry_object():\\n with attempt:\\n response = request_func(\\n url,\\n json=json if method in (\\\"POST\\\", \\\"PATCH\\\") else None,\\n params=json if method == \\\"GET\\\" else None,\\n auth=auth,\\n headers=headers,\\n timeout=self.timeout_seconds,\\n )\\n response.raise_for_status()\\n return response.json()\\n except RetryError:\\n raise AirflowException(f\\\"API requests to Databricks failed {self.retry_limit} times. Giving up.\\\")\\n except requests_exceptions.HTTPError as e:\\n if wrap_http_errors:\\n raise AirflowException(\\n f\\\"Response: {e.response.content}, Status Code: {e.response.status_code}\\\"\\n )\\n else:\\n raise e\",\n \"def _do_api_call(self, endpoint_info, json=None):\\n method, endpoint = endpoint_info\\n if self.fivetran_conn is None:\\n self.fivetran_conn = self.get_connection(self.conn_id)\\n auth = (self.fivetran_conn.login, self.fivetran_conn.password)\\n url = f\\\"{self.api_protocol}://{self.api_host}/{endpoint}\\\"\\n\\n headers = {\\n \\\"User-Agent\\\": self.api_user_agent\\n }\\n\\n if method == \\\"GET\\\":\\n request_func = requests.get\\n elif method == \\\"POST\\\":\\n request_func = requests.post\\n elif method == \\\"PATCH\\\":\\n request_func = requests.patch\\n headers.update({\\\"Content-Type\\\": \\\"application/json;version=2\\\"})\\n else:\\n raise AirflowException(\\\"Unexpected HTTP Method: \\\" + method)\\n\\n attempt_num = 1\\n while True:\\n try:\\n response = request_func(\\n url,\\n data=json if method in (\\\"POST\\\", \\\"PATCH\\\") else None,\\n params=json if method in (\\\"GET\\\") else None,\\n auth=auth,\\n headers=headers\\n )\\n response.raise_for_status()\\n return response.json()\\n except requests_exceptions.RequestException as e:\\n if not _retryable_error(e):\\n # In this case, the user probably made a mistake.\\n # Don't retry.\\n raise AirflowException(\\n f\\\"Response: {e.response.content}, \\\"\\n f\\\"Status Code: {e.response.status_code}\\\"\\n )\\n\\n self._log_request_error(attempt_num, e)\\n\\n if attempt_num == self.retry_limit:\\n raise AirflowException(\\n f\\\"API request to Fivetran failed {self.retry_limit} times.\\\"\\n \\\" Giving up.\\\"\\n )\\n\\n attempt_num += 1\\n sleep(self.retry_delay)\",\n \"def _do_operation(self,\\n\\t operation, api_path, query_params=None, munchify=True, debug_response=False,\\n\\t expected_status_codes=range(200, 300), *unused_args, **kwargs):\\n\\n\\t\\tif not self._session:\\n\\t\\t\\tmsg = u'No session has been created for the API. Have you called create() yet?'\\n\\t\\t\\tlog_with_debug_info(logging.ERROR, msg)\\n\\t\\t\\traise OperationError(msg)\\n\\n\\t\\tresponse = None\\n\\t\\tretdata = None\\n\\n\\t\\tendpoint = self._build_endpoint(api_path, params=kwargs, query_params=query_params)\\n\\n\\t\\tparams = {u'headers': self._headers, u'verify': self._verify_cert}\\n\\n\\t\\tif u'data' in kwargs:\\n\\t\\t\\tparams[u'data'] = json.dumps(kwargs[u'data'])\\n\\n\\t\\tlog_with_debug_info(logging.DEBUG, u'Call parameters: {0}'.format(params))\\n\\n\\t\\t# Call the API endpoint\\n\\t\\tresponse = getattr(self._session, operation)(endpoint, **params)\\n\\n\\t\\tlog_with_debug_info(logging.DEBUG, u'Response status: {0} {1}'.format(response.status_code,\\n\\t\\t response.reason))\\n\\n\\t\\tif response.status_code not in expected_status_codes:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tretdata = response.json()\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\t# Invalid JSON payload.\\n\\t\\t\\t\\tmsg = (u'HTTP Status Code: [{0}]; API response data for end-point [{1}] does not '\\n\\t\\t\\t\\t u'appear to be valid JSON. Cause: {2}.')\\n\\t\\t\\t\\tmsg = msg.format(response.status_code, endpoint, e)\\n\\t\\t\\t\\tif debug_response:\\n\\t\\t\\t\\t\\tlog_with_debug_info(logging.ERROR, msg + u' Data: [' + str(response.text) + u']')\\n\\t\\t\\t\\traise InvalidJSONError(msg, resp=response)\\n\\t\\t\\tmsg = u'{0} request to RESTful API at [{1}] expected status(s) {2}; failed: {3} {4};'\\\\\\n\\t\\t\\t u' Response: {5}'\\n\\t\\t\\tmsg = msg.format(operation.upper(), endpoint, expected_status_codes,\\n\\t\\t\\t response.status_code, response.reason, retdata)\\n\\t\\t\\tlog_with_debug_info(logging.ERROR, msg)\\n\\t\\t\\traise OperationError(msg, resp=response)\\n\\n\\t\\ttry:\\n\\t\\t\\tif response.status_code in ('204',):\\n\\t\\t\\t\\t# \\\"204 No Content\\\"\\n\\t\\t\\t\\tretdata = {}\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# Decode the expected JSON\\n\\t\\t\\t\\tretdata = response.json()\\n\\t\\texcept Exception as e:\\n\\t\\t\\t# Invalid JSON payload.\\n\\t\\t\\tmsg = (u'HTTP Status Code: [{0}]; API response data for end-point [{1}] does not '\\n\\t\\t\\t u'appear to be valid JSON. Cause: {2}.')\\n\\t\\t\\tmsg = msg.format(response.status_code, endpoint, e)\\n\\t\\t\\tif debug_response:\\n\\t\\t\\t\\tlog_with_debug_info(logging.ERROR, msg + u' Data: [' + str(response.text) + u']')\\n\\t\\t\\traise InvalidJSONError(msg, resp=response)\\n\\t\\tretdata = munch.munchify(retdata) if munchify else retdata\\n\\t\\treturn (retdata[u'response'] if u'response' in retdata else retdata), response\",\n \"def _api_request(method, path, data = None):\\n headers = {}\\n\\n if method == 'PUT' or method == 'POST':\\n headers = {'Content-Type': 'application/json'}\\n data = json.dumps(data)\\n\\n connection = httplib.HTTPSConnection(API_HOST,\\n API_PORT,\\n key_file = VM_CERTIFICATE,\\n cert_file = VM_CERTIFICATE)\\n\\n connection.request(method, path, data, headers)\\n response = connection.getresponse()\\n\\n if response.status == 404:\\n return None\\n if response.status == 403:\\n return False\\n\\n if method == 'PUT' or method == 'POST':\\n return True\\n\\n try:\\n return json.loads(response.read())\\n except:\\n print('Response code: %s' % response.status)\\n raise\",\n \"def _call(self, method: str, *url_parts, data=None,\\n params=None, stream=None) -> bytes:\\n response = self.request(method.upper(),\\n self._mk_url(url_parts),\\n params=params,\\n data=data,\\n stream=stream)\\n\\n if response.status_code not in (200, 201):\\n try:\\n self._raise_error(response.status_code, response.json())\\n except ValueError as e:\\n raise APIError(response.status_code,\\n self._RESPONSE_NOT_JSON_MSG) from e\\n\\n return response.content\",\n \"def make_request(self, url, action, data='', status_code='', parser=None):\\n self._url = self.get_api_path(url)\\n headers = {\\n 'Content-Type': \\\"application/json\\\",\\n 'Token': self.token,\\n\\n }\\n kwargs = {}\\n if headers:\\n kwargs.update(headers=headers)\\n if data:\\n kwargs.update(data=json.dumps(data))\\n\\n return getattr(self.http, action.lower())(self._url, **kwargs)\",\n \"def http_request(url, post_params=None, timeout=None, max_response=None, json=False):\\n try:\\n if post_params:\\n response = requests.post(url, data=post_params, timeout=timeout)\\n else:\\n response = requests.get(url, timeout=timeout)\\n except requests.exceptions.RequestException as error:\\n raise HttpError(exception=error)\\n if response.status_code != 200:\\n raise HttpError(\\n error_type='status_code',\\n message='Error making request: response code {} ({}).'\\n .format(response.status_code, response.reason)\\n )\\n if json:\\n try:\\n return response.json()\\n except json.JSONDecodeError as error:\\n raise HttpError(\\n exception=error,\\n message='Response not valid JSON: {!r}'.format(response.text)\\n )\\n else:\\n return response.text\",\n \"def makeApiCall(url, endpointParams, type):\\r\\n\\r\\n if type == 'POST': # post request\\r\\n data = requests.post(url, endpointParams)\\r\\n else: # get request\\r\\n data = requests.get(url, endpointParams)\\r\\n\\r\\n response = dict() # hold response info\\r\\n response['url'] = url # url we are hitting\\r\\n response['endpoint_params'] = endpointParams # parameters for the endpoint\\r\\n response['endpoint_params_pretty'] = json.dumps(endpointParams, indent=4) # pretty print for cli\\r\\n response['json_data'] = json.loads(data.content) # response data from the api\\r\\n response['json_data_pretty'] = json.dumps(response['json_data'], indent=4) # pretty print for cli\\r\\n\\r\\n return response # get and return content\\r\",\n \"def _do_call(cls, method, url, params={}):\\n headers = {\\n 'User-Agent': 'py-retain/' + __version__,\\n 'content-type': 'application/json'\\n }\\n try:\\n r = cls.request_map[method.lower()]\\n except KeyError:\\n raise ValueError(\\\"Unknow HTTP Method\\\")\\n response = r(\\n url,\\n auth=(cls.app_id, cls.api_key),\\n headers=headers,\\n data=json.dumps(params),\\n timeout=cls.timeout)\\n return response.json()\",\n \"def request(self, method, path, msg=None, json=None, retfmt='bool', errorfatal=True, autoauth=True, verify_ssl=False):\\n url = self.admin_url + '/acs/api/v1' + path\\n\\n if msg:\\n self.log.info(msg)\\n\\n headers = self.default_headers.copy()\\n\\n if not self.auth_header and autoauth:\\n self.set_auth_header()\\n\\n if self.auth_header:\\n headers.update(self.auth_header)\\n\\n if method == 'get':\\n r = requests.get(url, headers=headers, json=json, verify=verify_ssl)\\n elif method == 'post':\\n r = requests.post(url, headers=headers, json=json, verify=verify_ssl)\\n elif method == 'put':\\n r = requests.put(url, headers=headers, json=json, verify=verify_ssl)\\n elif method == 'delete':\\n r = requests.delete(url, headers=headers, json=json, verify=verify_ssl)\\n\\n if 200 <= r.status_code < 300:\\n self.log.debug(\\\"success\\\")\\n if retfmt == 'json':\\n self.log.debug('returning json')\\n return r.json()\\n elif retfmt == 'request':\\n self.log.debug('returning request object')\\n return r\\n else:\\n return True\\n else:\\n if 'Content-Type' in r.headers and r.headers['Content-Type'] == 'application/json':\\n resp = r.json()['code']\\n else:\\n resp = r.reason\\n msg = \\\"failed: {}\\\".format(resp)\\n self.log.debug(msg)\\n if errorfatal:\\n raise Exception(msg)\\n else:\\n if retfmt == 'request':\\n self.log.debug('returning request object')\\n return r\\n else:\\n return None\",\n \"def make_request(self, request, captcha_response=None):\\n logger.debug('Prepare API Method request %r', request)\\n response = self._send_api_request(request=request,\\n captcha_response=captcha_response)\\n response.raise_for_status()\\n response_or_error = json.loads(response.text)\\n logger.debug('response: %s', response_or_error)\\n\\n if 'error' in response_or_error:\\n error_data = response_or_error['error']\\n vk_error = VkAPIError(error_data)\\n\\n if vk_error.is_captcha_needed():\\n captcha_key = self.get_captcha_key(vk_error.captcha_img_url)\\n if not captcha_key:\\n raise vk_error\\n\\n # Retry http request with captcha info attached\\n captcha_response = {\\n 'sid': vk_error.captcha_sid,\\n 'key': captcha_key,\\n }\\n return self.make_request(\\n request, captcha_response=captcha_response)\\n\\n elif vk_error.is_access_token_incorrect():\\n logger.info(\\n 'Authorization failed. Access token will be dropped')\\n self._access_token = None\\n return self.make_request(request)\\n\\n else:\\n raise vk_error\\n elif 'execute_errors' in response_or_error:\\n # can take place while running .execute vk method\\n # See more: https://vk.com/dev/execute\\n raise VkAPIError(response_or_error['execute_errors'][0])\\n elif 'response' in response_or_error:\\n return response_or_error['response']\",\n \"def _request(self, url, values=None):\\n\\n url += \\\"?{}\\\".format(urllib.urlencode(values))\\n\\n request = urllib2.Request(url)\\n\\n try:\\n connection = urllib2.urlopen(request)\\n except urllib2.HTTPError, e:\\n return {'status': 'Failed', 'message': str(e.reason)}\\n except urllib2.URLError, e:\\n return {'status': 'Failed', 'message': str(e.reason)}\\n except httplib.HTTPException, e:\\n return {'status': 'Failed', 'message': str(e.reason)}\\n except Exception as exception:\\n return {'status': 'Failed', 'message': str(exception)}\\n\\n response = connection.read()\\n connection.close()\\n\\n\\n try:\\n result = json.loads(response.decode())\\n except ValueError as exception:\\n return {'status': 'Failed', 'message': str(exception)}\\n\\n return result\",\n \"async def _httpx_request(method: Literal[\\\"GET\\\", \\\"POST\\\", \\\"DELETE\\\"], url: str, payload: dict, response_model: pydantic.BaseModel, private: bool=False):\\n # return\\n\\n if private:\\n try:\\n keyset = get_keys() # returns a set of tuples (key, secret) \\n except EmptyEnv:\\n # do not proceed to send a test request in this case\\n return\\n key, secret = keyset.pop()\\n payload[\\\"timestamp\\\"] = auth_timestamp()\\n payload[\\\"signature\\\"] = auth_signature(url, payload, secret=secret)\\n headers = auth_headers(key)\\n else:\\n headers = {}\\n\\n async with httpx.AsyncClient() as client:\\n if private:\\n signature = payload.pop(\\\"signature\\\")\\n payload = sorted([(k, v) for k, v in payload.items()], reverse=False)\\n payload.append((\\\"signature\\\", signature)) #! needs to always be last param\\n if method in [\\\"POST\\\", \\\"DELETE\\\"]:\\n r = await client.request(method, url, data=dict(payload), headers=headers)\\n else:\\n r = await client.request(method, url, params=payload, headers=headers)\\n else:\\n r = await client.request(method, url, params=payload)\\n \\n rjson = r.json()\\n print(\\\"response.json\\\", rjson)\\n\\n assert r.status_code == 200, f\\\"Json Response {rjson} \\\\nPayload {payload} \\\\nHeaders {headers} \\\\nRequest {r.request}\\\"\\n\\n # if empty response, return directly without validation\\n # (this might be what we expected, so assertion has to take place in the test function not here)\\n if not rjson:\\n return rjson\\n\\n # else we validate\\n if isinstance(rjson, list) or isinstance(rjson, tuple):\\n response_model(rjson)\\n else:\\n response_model(**rjson)\",\n \"async def _call_api(\\n self, endpoint: str, method: str = \\\"GET\\\", data: Optional[dict] = None\\n ) -> Optional[ClientResponse]:\\n try:\\n response = await self._session.request(\\n method=method,\\n url=f\\\"{BASE_URL}/{endpoint}\\\",\\n headers={\\n \\\"aftership-api-key\\\": self._api_key,\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n },\\n json=data,\\n timeout=ClientTimeout(total=self._timeout),\\n )\\n return await self._handle_response(response)\\n\\n except asyncio.TimeoutError as exception:\\n raise AfterShipCommunicationException(\\\"Timeout error\\\") from exception\\n\\n except (ClientError, gaierror) as exception:\\n raise AfterShipCommunicationException(\\n f\\\"Communication error {exception}\\\"\\n ) from exception\",\n \"def _call_api(self, api_function, kwargs):\\n kwargs['_request_timeout'] = self._timeout\\n retries = self._retries\\n while True:\\n try:\\n response = api_function(**kwargs)\\n # Call was successful (200)\\n return self._create_valid_response(response, api_function, kwargs)\\n except ApiException as error:\\n # If no chance for retries, return the error\\n if retries == 0:\\n return self._create_error_response(error)\\n # If bad request or not found, return the error (it will never work)\\n elif error.status in [400, 404]:\\n return self._create_error_response(error)\\n # If authentication error, reset access token and retry\\n elif error.status in [401, 403]:\\n self._set_auth_header(refresh=True)\\n # If rate limit error, wait the proper time and try again\\n elif error.status == 429:\\n # If the the minute limit hit, wait that long\\n if (int(error.headers.get(Headers.x_ratelimit_remaining_min))\\n == int(error.headers.get(Headers.x_ratelimit_min))):\\n time.sleep(60)\\n # Otherwise it was the second limit and only wait a second\\n time.sleep(1)\\n # If some internal server error we know nothing about, return\\n elif error.status == 500:\\n return self._create_error_response(error)\\n # If internal server errors that has to do with timeouts, try again\\n elif error.status > 500:\\n pass\\n # If error with the swagger client, raise the error\\n else:\\n raise PureError(error)\\n retries = retries - 1\",\n \"def _call(self, request_method, endpoint, params=None, data=None):\\n response = request_method(\\n self._construct_url(endpoint),\\n params=params,\\n data=data,\\n auth=BsdApiAuth(self.api_id, self.api_secret)\\n )\\n\\n if response.status_code == 202 and endpoint != \\\"get_deferred_results\\\":\\n return self._resolve_deferred_response(response, self.deferred_result_max_attempts)\\n else:\\n return response\",\n \"def _request(self, url, **kwargs):\\n headers = {'PRIVATE-TOKEN': self.token}\\n response = make_request(self.base_url + url, headers=headers, **kwargs)\\n logging.info('Requested: {0}'.format(url))\\n logging.info('Method: {0}'.format(kwargs.get('method', 'GET')))\\n logging.info(response.content)\\n return json.loads(response.content)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6998465","0.697629","0.6958306","0.68044615","0.67445","0.673964","0.67353","0.67159045","0.6714112","0.6700891","0.6693908","0.66411114","0.6610895","0.6592531","0.65848005","0.6565488","0.65573376","0.6525482","0.64771914","0.6451753","0.6419186","0.6418593","0.63855463","0.6362626","0.6345507","0.63184345","0.63043714","0.62958246","0.62918055","0.62906134","0.62864435","0.62850064","0.6279468","0.6279468","0.6277813","0.6261688","0.6256282","0.6243914","0.62056494","0.6205348","0.6196219","0.6189344","0.6188848","0.6182817","0.61755407","0.6174989","0.6172594","0.6166166","0.6156797","0.6156074","0.6155242","0.6146402","0.6141418","0.61367166","0.6135424","0.6134019","0.6130558","0.61191744","0.611643","0.6110306","0.6102733","0.609839","0.60884124","0.6085871","0.60742205","0.6063546","0.6060491","0.6056238","0.6054171","0.60472053","0.60405785","0.6038251","0.6032271","0.60318375","0.6017209","0.6014929","0.6012561","0.60053366","0.6005092","0.60013676","0.5996974","0.5986768","0.59858346","0.59836286","0.59808016","0.59690297","0.5953665","0.59217393","0.59149665","0.59087443","0.5904626","0.58992016","0.5897545","0.5886306","0.58862835","0.58861613","0.5879825","0.58760065","0.587209","0.5871229","0.587087"],"string":"[\n \"0.6998465\",\n \"0.697629\",\n \"0.6958306\",\n \"0.68044615\",\n \"0.67445\",\n \"0.673964\",\n \"0.67353\",\n \"0.67159045\",\n \"0.6714112\",\n \"0.6700891\",\n \"0.6693908\",\n \"0.66411114\",\n \"0.6610895\",\n \"0.6592531\",\n \"0.65848005\",\n \"0.6565488\",\n \"0.65573376\",\n \"0.6525482\",\n \"0.64771914\",\n \"0.6451753\",\n \"0.6419186\",\n \"0.6418593\",\n \"0.63855463\",\n \"0.6362626\",\n \"0.6345507\",\n \"0.63184345\",\n \"0.63043714\",\n \"0.62958246\",\n \"0.62918055\",\n \"0.62906134\",\n \"0.62864435\",\n \"0.62850064\",\n \"0.6279468\",\n \"0.6279468\",\n \"0.6277813\",\n \"0.6261688\",\n \"0.6256282\",\n \"0.6243914\",\n \"0.62056494\",\n \"0.6205348\",\n \"0.6196219\",\n \"0.6189344\",\n \"0.6188848\",\n \"0.6182817\",\n \"0.61755407\",\n \"0.6174989\",\n \"0.6172594\",\n \"0.6166166\",\n \"0.6156797\",\n \"0.6156074\",\n \"0.6155242\",\n \"0.6146402\",\n \"0.6141418\",\n \"0.61367166\",\n \"0.6135424\",\n \"0.6134019\",\n \"0.6130558\",\n \"0.61191744\",\n \"0.611643\",\n \"0.6110306\",\n \"0.6102733\",\n \"0.609839\",\n \"0.60884124\",\n \"0.6085871\",\n \"0.60742205\",\n \"0.6063546\",\n \"0.6060491\",\n \"0.6056238\",\n \"0.6054171\",\n \"0.60472053\",\n \"0.60405785\",\n \"0.6038251\",\n \"0.6032271\",\n \"0.60318375\",\n \"0.6017209\",\n \"0.6014929\",\n \"0.6012561\",\n \"0.60053366\",\n \"0.6005092\",\n \"0.60013676\",\n \"0.5996974\",\n \"0.5986768\",\n \"0.59858346\",\n \"0.59836286\",\n \"0.59808016\",\n \"0.59690297\",\n \"0.5953665\",\n \"0.59217393\",\n \"0.59149665\",\n \"0.59087443\",\n \"0.5904626\",\n \"0.58992016\",\n \"0.5897545\",\n \"0.5886306\",\n \"0.58862835\",\n \"0.58861613\",\n \"0.5879825\",\n \"0.58760065\",\n \"0.587209\",\n \"0.5871229\",\n \"0.587087\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":584,"cells":{"query":{"kind":"string","value":"Returns Home Assistant base url without '/api' or trailing slash"},"document":{"kind":"string","value":"def get_url(self, url):\n if not url:\n raise ValueError('Property \"url\" is missing in config')\n\n return url.replace(\"/api\", \"\").rstrip(\"/\")"},"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 api_url(url_base):\n return f\"{url_base}/api/v2\"","def get_api_url() -> str:\n\n site = pywikibot.Site()\n url = site.protocol() + \"://\" + site.hostname() + site.apipath()\n return url","def api_url(self) -> httpx.URL:\n return self._client.base_url","def get_api_url() -> str:\n\n\tsite = pywikibot.Site()\n\turl = site.protocol() + \"://\" + site.hostname() + site.apipath()\n\treturn url","def get_api_url():\n return \"https://api.basespace.illumina.com/v1pre3\"","def get_home_url():\n url = base_url + _HOME\n return url","def base_url(self):\n return \"http://{0}:{1}/app\".format(self.host, self.port)","def base_url(self):\n return 'http://%s/api.php?token=%s&path_info=' % \\\n (self.ac_url, self.api_key)","def api_endpoint(self, url):\n if urlparse(url).scheme in [\"http\", \"https\"]:\n return url # url is already complete\n return urljoin(f\"{RESOURCE}/{API_VERSION}/\", url.lstrip(\"/\"))","def _get_api_url(self):\n return \"%s/%s/\" % (settings.API_URL, settings.API_VERSION)","def _base_url(self):\n # URL Protocol\n proto = 'https' if self._ssl else 'http'\n\n # Device port number\n if self._port is None:\n port = 8080 if self._ssl else 8008\n else:\n port = self._port\n \n return f'{proto}://{self._address}:{port}/api/v1'","def api_base_url(self):\n\n\t\treturn self._api_base_url","def get_base_url(self):\n try:\n return self.get_metadata()['api_endpoint']\n except requests.exceptions.RequestException:\n raise","def api_url(self):\n return self.get_api_url()","def base_url():\n return json.loads('{\"message\": \"Try with /data\", \"success\": false}')","def api_url(self, endpoint):\n\n return '{}/{}'.format(self.api_root, endpoint)","def clean_url(app_server, base_path) -> str:\n if app_server.endswith('/'):\n base_url = f\"{app_server[:-1]}{base_path}\"\n else:\n base_url = f\"{app_server}/{base_path}\"\n return base_url","def get_api_url(self, query_, api):\n api_url = \"%s%s%s\" % (api, query_, self.api_key)\n\n return api_url","def getRootURL():","def get_short_url_base():","def _construct_url(self, endpoint):\n return self.base_url + self.api_path + endpoint.strip('/')","def getHome(self):\n # host = getHostWithPort(url)\n # ui = UrlInfo(url)\n # host = url[ui.getHostHead():ui.getHostTail()]\n host = self.url[self.host_head:self.host_tail]\n return \"http://\" + host + \"/\"","def test_home_url_with_no_appid(self):\n gae_req = AppEngineRequest(url=\"/\")\n\n url = gae_req.build_url()\n\n self.assertEqual(url, \"http://localhost/\")","def home():\n return (\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 _get_api_url_for (self, component):\n if self.api_data['API_ROOT'].find(self.api_data['API_BASE_URL']) > -1:\n return self.api_data['API_ROOT'] + '/' + self.api_data['BUILD_IDENTIFIER'] + self.urls[component]\n else:\n return self.api_data['API_ROOT'] + self.api_data['API_BASE_URL'] + '/' + self.api_data['BUILD_IDENTIFIER'] + self.urls[component]","def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])","def build_url(app, request):\n return '%s%s' % (app.url_root, request.path[1:])","def _get_base_url(self):\n return '/{}/'.format(self.name.replace('__', '/'))","def _get_url(self, *args):\n if self._baseUrl not in args:\n args.insert(0, self._baseUrl)\n args = filter(lambda item: item is not None, args)\n return \"/\".join(args)","def api_base_url(self):\n\n return self._api_base_url","def BASE_URL():\n BASE_URL = \"http://api.zippopotam.us/\"\n return BASE_URL","def url_base():\n return \"https://dev-yourOrg.us.auth0.com\"","def app_url(self):\n return self.request.host_url","def base_url(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"base_url\")","def base_url_path(self):\n path = urlsplit(self.base_url())[2]\n if path.endswith(\"/\"):\n path = path[:-1]\n return path","def url (self):\n return Links.createURL('/')","def _get_base_url(self):\n return 'https://'+self.get_address_and_port_string()","def api_url(self):\n return self._api_url","async def _api_url(self) -> URL:\n return await self._gitlab_api_url(\"\")","def get_base_url(self):\n return self.base_url","def api_endpoint(self) -> str:\n return pulumi.get(self, \"api_endpoint\")","def api_path(self, path=\"\"):\n return \"https://{domain}/{path}\".format(\n domain=self.setting(\"DOMAIN\"), path=path\n )","def Url(self) -> str:","def fix_apiroot(root):\n if '://' in root:\n return root\n if ('/' not in root) or ('.' not in root.split('/')[0]):\n root = \"www.pennapps.com/\" + root\n return \"http://%s\" % root","def public_rest_url(path_url: str, domain: str = CONSTANTS.DEFAULT_DOMAIN) -> str:\n return CONSTANTS.FTX_BASE_URL + path_url","def base_url(self) -> URL:\n return (\n URL(self.url)\n if self.url is not None\n else URL.build(\n scheme=f\"http{'s' if self.ssl else ''}\",\n host=self.hostname or self.ipaddress,\n port=str(self.port) if self.port else None,\n path=self.base_api_path or \"\",\n )\n )","def get_url():\n config = configparser.RawConfigParser()\n config.read(\"speech.cfg\")\n region = config.get('auth', 'region')\n host = REGION_MAP[region]\n return (\n f\"wss://{host}/speech-to-text/api/v1/recognize\"\n \"?model=en-US_BroadbandModel&x-watson-learning-opt-out=true\"\n )","def url(self):\n url = os.environ.get('PATH_INFO')\\\n or os.environ.get('REQUEST_URI')\n return url if url else ''","def apiurl(self):\n return self._apiurl","def base_url(self):\n return self._get_base_url()","def getAPI(self):\n return self.api_url","async def _landing_url(self, responses: SourceResponses) -> URL:\n return URL(f\"{await self._api_url()}/CxWebClient\")","def full_url(resource):\r\n # if (url/resource == '127.0.0.1':)\r\n if resource == '/' or resource == ' ':\r\n url = \"{0}{1}\".format(ROOT_DIRECTORY, URL_TEST)\r\n # else (if url/resource == 'Specific resource')\r\n else:\r\n url = \"{0}{1}\".format(ROOT_DIRECTORY, str(resource).replace('/', '\\\\'))\r\n print(f'the client request = {url}')\r\n return url","def _get_api_endpoint():\n try:\n return get_service_endpoint(\"apiext\").strip(\"/\")\n except:\n log.warn(\n \"Could not find valid apiext endpoint for links so will use policy engine endpoint instead\"\n )\n try:\n return get_service_endpoint(\"policy_engine\").strip(\"/\")\n except:\n log.warn(\n \"No policy engine endpoint found either, using default but invalid url\"\n )\n return \"http://<valid endpoint not found>\"","def getBaseURL():\n return getQualifiedURL(getScriptname())","def url_root():\n return \"OK\"","def get_endpoint_url(endpoint):\n return urljoin(api_url_base(), endpoint)","def get_api_path(self):\n return self._get_api_base() + '/' + self._get_resource_suffix()","def sentera_api_url(self, path):\n return \"{}{}\".format(self.config[\"sentera_api_url\"], path)","def root_url(self) -> str:\n return self.root_hartree.har.root_url","def api_url(self, command: str) -> str:\n base_url = self.base_url\n path = \"/\".join(x for x in f\"{base_url.path}/api/v2\".split(\"/\") if x != \"\")\n return URL.build(\n scheme=base_url.scheme,\n host=base_url.host,\n port=base_url.port,\n path=f\"/{path}\",\n query={\"apikey\": self.api_token, \"cmd\": command},\n ).human_repr()","def base_url(self) -> str:\n return self._base_url","def base_url(self):\n return \"https://api.byte-stack.net\" if self.use_sandbox \\\n else \"https://api.ovo.id\"","def url(vmanage_host,vmanage_port,api):\r\n \"\"\" function to get the url provide api endpoint \"\"\"\r\n \r\n return f\"https://{vmanage_host}:{vmanage_port}{api}\"","async def _landing_url(self, responses: SourceResponses) -> URL:\n return URL((await responses[0].json())[\"url\"] if responses else \"https://trello.com\")","def form_api_path(self, request_host: RequestHost, api_path_prefix: str, endpoint: str) -> str:\n api_url = self.base_url(request_host)\n\n if api_path_prefix:\n api_url += api_path_prefix\n\n return f\"{api_url}{endpoint}\"","def _url_full(self):\n return self._url_base + \"/sharing/rest\"","def join_api_url(api_base_url, api_path):\n if api_base_url.endswith('/'):\n api_base_url = api_base_url[:-1]\n if api_path.startswith('/'):\n api_path = api_path[1:]\n\n return api_base_url + '/' + api_path","def home():\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/preciptation<br/>\"\n f\"/api/v1.0/Stations\"\n )","def _build_url(self):\n url = BASE_URL.format(self._host, self._port)\n _LOGGER.debug(\"TOON fetch URL: %s\", url)\n return url","def api_endpoint():\n return 'localhost'","def _parsing_url(self, base_url):\n url2 = f\"{self.location}?apikey={self.api_key}&details=true\"\n absolute_url = urljoin(base_url, url2)\n return absolute_url","def Home():\n return(\n f\"Hawaii Climate 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\"and<br/>\"\n f\"/api/v1.0/<start>/<end>\"\n )","def base_url(self) -> str | None:\n return self._base_url","def getBuildbotURL():","def getHomePage(self):\n return self.home_url","def home():\n return (\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><br/>\"\n )","def basic_url(self):\n return self.base_name + '.cloudlabs.rc.ucl.ac.uk'","def get_base_url(self):\n return urlparse.urljoin(self.domain, self.root_path)","def base_url(self):\n return self._base_url","def url(self) -> str:\n return pulumi.get(self, \"url\")","def url(self) -> str:\n return pulumi.get(self, \"url\")","def Home():\n return (\n f\"Welcome to the Climate App<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><br/>\"\n )","def getBaseUrl(self):\n return self.url","def _get_URL_base(self, request, step):\n index = request.path.find(step.slug)\n\n return request.path[:index]","def get_full_url(self):\n full_url = home_page + self.source_link\n return full_url","def get_url(self, *args):\n try:\n url = '/'.join((self.base_url, ) + args)\n except TypeError:\n url = '/'.join((self.base_url, ) + args[0])\n return url.rstrip('/')","def url_base(self):\n return 'http://%s:%d/' % (self.host, self.port)","def GetBaseURL(self):\n base_url = self.server_base_url\n if base_url is None:\n base_url = 'http://%s:%s' % self.server_address[:2]\n\n return base_url","def url(self) -> str:\n return f\"{self._get_base_url()}{self.path_extension}\"","def get_api_url(settings: Settings) -> str:\n return _get_control(settings) \\\n .get('provider', {}).get('arguments', {}) \\\n .get('api_url', '')","def get_url():\n if os.environ['SERVER_PORT'] == '80':\n scheme = 'http://'\n else:\n scheme = 'https://'\n host = os.environ['SERVER_NAME']\n script_name = urllib.quote(os.environ.get('SCRIPT_NAME', ''))\n path_info = urllib.quote(os.environ.get('PATH_INFO', ''))\n qs = os.environ.get('QUERY_STRING', '')\n if qs:\n qs = '?' + qs\n return scheme + host + script_name + path_info + qs","def home():\n return (\n f\"These are the 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 ></br>\"\n )","def url(self, api_name):\n return \"https://%s/api/%s/%s/\" % (self.host, self.api_version, api_name)","def getCompleteUrl(urlPath: str) -> str:\n return os.path.join(BASE_URL, urlPath) if urlPath else BASE_URL","def get_api_url(self):\n\n url = 'https://api.{}/repos/{}/{}/git/'.format(HOST_GITHUB, \\\n self.repo, self.product)\n return url","def weather_api_url(self, path):\n return \"{}{}\".format(self.config[\"weather_api_url\"], path)","def get_base_uri(self, server=Server.DEFAULT):\r\n parameters = {\r\n \"base_url\": {'value': self.base_url, 'encode': False},\r\n }\r\n\r\n return APIHelper.append_url_with_template_parameters(\r\n self.environments[self.environment][server], parameters\r\n )","def get_full_url(self, part_url):\n return BASE_URL + part_url","def home():\n return (\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\"\n )"],"string":"[\n \"def api_url(url_base):\\n return f\\\"{url_base}/api/v2\\\"\",\n \"def get_api_url() -> str:\\n\\n site = pywikibot.Site()\\n url = site.protocol() + \\\"://\\\" + site.hostname() + site.apipath()\\n return url\",\n \"def api_url(self) -> httpx.URL:\\n return self._client.base_url\",\n \"def get_api_url() -> str:\\n\\n\\tsite = pywikibot.Site()\\n\\turl = site.protocol() + \\\"://\\\" + site.hostname() + site.apipath()\\n\\treturn url\",\n \"def get_api_url():\\n return \\\"https://api.basespace.illumina.com/v1pre3\\\"\",\n \"def get_home_url():\\n url = base_url + _HOME\\n return url\",\n \"def base_url(self):\\n return \\\"http://{0}:{1}/app\\\".format(self.host, self.port)\",\n \"def base_url(self):\\n return 'http://%s/api.php?token=%s&path_info=' % \\\\\\n (self.ac_url, self.api_key)\",\n \"def api_endpoint(self, url):\\n if urlparse(url).scheme in [\\\"http\\\", \\\"https\\\"]:\\n return url # url is already complete\\n return urljoin(f\\\"{RESOURCE}/{API_VERSION}/\\\", url.lstrip(\\\"/\\\"))\",\n \"def _get_api_url(self):\\n return \\\"%s/%s/\\\" % (settings.API_URL, settings.API_VERSION)\",\n \"def _base_url(self):\\n # URL Protocol\\n proto = 'https' if self._ssl else 'http'\\n\\n # Device port number\\n if self._port is None:\\n port = 8080 if self._ssl else 8008\\n else:\\n port = self._port\\n \\n return f'{proto}://{self._address}:{port}/api/v1'\",\n \"def api_base_url(self):\\n\\n\\t\\treturn self._api_base_url\",\n \"def get_base_url(self):\\n try:\\n return self.get_metadata()['api_endpoint']\\n except requests.exceptions.RequestException:\\n raise\",\n \"def api_url(self):\\n return self.get_api_url()\",\n \"def base_url():\\n return json.loads('{\\\"message\\\": \\\"Try with /data\\\", \\\"success\\\": false}')\",\n \"def api_url(self, endpoint):\\n\\n return '{}/{}'.format(self.api_root, endpoint)\",\n \"def clean_url(app_server, base_path) -> str:\\n if app_server.endswith('/'):\\n base_url = f\\\"{app_server[:-1]}{base_path}\\\"\\n else:\\n base_url = f\\\"{app_server}/{base_path}\\\"\\n return base_url\",\n \"def get_api_url(self, query_, api):\\n api_url = \\\"%s%s%s\\\" % (api, query_, self.api_key)\\n\\n return api_url\",\n \"def getRootURL():\",\n \"def get_short_url_base():\",\n \"def _construct_url(self, endpoint):\\n return self.base_url + self.api_path + endpoint.strip('/')\",\n \"def getHome(self):\\n # host = getHostWithPort(url)\\n # ui = UrlInfo(url)\\n # host = url[ui.getHostHead():ui.getHostTail()]\\n host = self.url[self.host_head:self.host_tail]\\n return \\\"http://\\\" + host + \\\"/\\\"\",\n \"def test_home_url_with_no_appid(self):\\n gae_req = AppEngineRequest(url=\\\"/\\\")\\n\\n url = gae_req.build_url()\\n\\n self.assertEqual(url, \\\"http://localhost/\\\")\",\n \"def home():\\n return (\\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 )\",\n \"def _get_api_url_for (self, component):\\n if self.api_data['API_ROOT'].find(self.api_data['API_BASE_URL']) > -1:\\n return self.api_data['API_ROOT'] + '/' + self.api_data['BUILD_IDENTIFIER'] + self.urls[component]\\n else:\\n return self.api_data['API_ROOT'] + self.api_data['API_BASE_URL'] + '/' + self.api_data['BUILD_IDENTIFIER'] + self.urls[component]\",\n \"def build_url(app, request):\\n return '%s%s' % (app.url_root, request.path[1:])\",\n \"def build_url(app, request):\\n return '%s%s' % (app.url_root, request.path[1:])\",\n \"def _get_base_url(self):\\n return '/{}/'.format(self.name.replace('__', '/'))\",\n \"def _get_url(self, *args):\\n if self._baseUrl not in args:\\n args.insert(0, self._baseUrl)\\n args = filter(lambda item: item is not None, args)\\n return \\\"/\\\".join(args)\",\n \"def api_base_url(self):\\n\\n return self._api_base_url\",\n \"def BASE_URL():\\n BASE_URL = \\\"http://api.zippopotam.us/\\\"\\n return BASE_URL\",\n \"def url_base():\\n return \\\"https://dev-yourOrg.us.auth0.com\\\"\",\n \"def app_url(self):\\n return self.request.host_url\",\n \"def base_url(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"base_url\\\")\",\n \"def base_url_path(self):\\n path = urlsplit(self.base_url())[2]\\n if path.endswith(\\\"/\\\"):\\n path = path[:-1]\\n return path\",\n \"def url (self):\\n return Links.createURL('/')\",\n \"def _get_base_url(self):\\n return 'https://'+self.get_address_and_port_string()\",\n \"def api_url(self):\\n return self._api_url\",\n \"async def _api_url(self) -> URL:\\n return await self._gitlab_api_url(\\\"\\\")\",\n \"def get_base_url(self):\\n return self.base_url\",\n \"def api_endpoint(self) -> str:\\n return pulumi.get(self, \\\"api_endpoint\\\")\",\n \"def api_path(self, path=\\\"\\\"):\\n return \\\"https://{domain}/{path}\\\".format(\\n domain=self.setting(\\\"DOMAIN\\\"), path=path\\n )\",\n \"def Url(self) -> str:\",\n \"def fix_apiroot(root):\\n if '://' in root:\\n return root\\n if ('/' not in root) or ('.' not in root.split('/')[0]):\\n root = \\\"www.pennapps.com/\\\" + root\\n return \\\"http://%s\\\" % root\",\n \"def public_rest_url(path_url: str, domain: str = CONSTANTS.DEFAULT_DOMAIN) -> str:\\n return CONSTANTS.FTX_BASE_URL + path_url\",\n \"def base_url(self) -> URL:\\n return (\\n URL(self.url)\\n if self.url is not None\\n else URL.build(\\n scheme=f\\\"http{'s' if self.ssl else ''}\\\",\\n host=self.hostname or self.ipaddress,\\n port=str(self.port) if self.port else None,\\n path=self.base_api_path or \\\"\\\",\\n )\\n )\",\n \"def get_url():\\n config = configparser.RawConfigParser()\\n config.read(\\\"speech.cfg\\\")\\n region = config.get('auth', 'region')\\n host = REGION_MAP[region]\\n return (\\n f\\\"wss://{host}/speech-to-text/api/v1/recognize\\\"\\n \\\"?model=en-US_BroadbandModel&x-watson-learning-opt-out=true\\\"\\n )\",\n \"def url(self):\\n url = os.environ.get('PATH_INFO')\\\\\\n or os.environ.get('REQUEST_URI')\\n return url if url else ''\",\n \"def apiurl(self):\\n return self._apiurl\",\n \"def base_url(self):\\n return self._get_base_url()\",\n \"def getAPI(self):\\n return self.api_url\",\n \"async def _landing_url(self, responses: SourceResponses) -> URL:\\n return URL(f\\\"{await self._api_url()}/CxWebClient\\\")\",\n \"def full_url(resource):\\r\\n # if (url/resource == '127.0.0.1':)\\r\\n if resource == '/' or resource == ' ':\\r\\n url = \\\"{0}{1}\\\".format(ROOT_DIRECTORY, URL_TEST)\\r\\n # else (if url/resource == 'Specific resource')\\r\\n else:\\r\\n url = \\\"{0}{1}\\\".format(ROOT_DIRECTORY, str(resource).replace('/', '\\\\\\\\'))\\r\\n print(f'the client request = {url}')\\r\\n return url\",\n \"def _get_api_endpoint():\\n try:\\n return get_service_endpoint(\\\"apiext\\\").strip(\\\"/\\\")\\n except:\\n log.warn(\\n \\\"Could not find valid apiext endpoint for links so will use policy engine endpoint instead\\\"\\n )\\n try:\\n return get_service_endpoint(\\\"policy_engine\\\").strip(\\\"/\\\")\\n except:\\n log.warn(\\n \\\"No policy engine endpoint found either, using default but invalid url\\\"\\n )\\n return \\\"http://<valid endpoint not found>\\\"\",\n \"def getBaseURL():\\n return getQualifiedURL(getScriptname())\",\n \"def url_root():\\n return \\\"OK\\\"\",\n \"def get_endpoint_url(endpoint):\\n return urljoin(api_url_base(), endpoint)\",\n \"def get_api_path(self):\\n return self._get_api_base() + '/' + self._get_resource_suffix()\",\n \"def sentera_api_url(self, path):\\n return \\\"{}{}\\\".format(self.config[\\\"sentera_api_url\\\"], path)\",\n \"def root_url(self) -> str:\\n return self.root_hartree.har.root_url\",\n \"def api_url(self, command: str) -> str:\\n base_url = self.base_url\\n path = \\\"/\\\".join(x for x in f\\\"{base_url.path}/api/v2\\\".split(\\\"/\\\") if x != \\\"\\\")\\n return URL.build(\\n scheme=base_url.scheme,\\n host=base_url.host,\\n port=base_url.port,\\n path=f\\\"/{path}\\\",\\n query={\\\"apikey\\\": self.api_token, \\\"cmd\\\": command},\\n ).human_repr()\",\n \"def base_url(self) -> str:\\n return self._base_url\",\n \"def base_url(self):\\n return \\\"https://api.byte-stack.net\\\" if self.use_sandbox \\\\\\n else \\\"https://api.ovo.id\\\"\",\n \"def url(vmanage_host,vmanage_port,api):\\r\\n \\\"\\\"\\\" function to get the url provide api endpoint \\\"\\\"\\\"\\r\\n \\r\\n return f\\\"https://{vmanage_host}:{vmanage_port}{api}\\\"\",\n \"async def _landing_url(self, responses: SourceResponses) -> URL:\\n return URL((await responses[0].json())[\\\"url\\\"] if responses else \\\"https://trello.com\\\")\",\n \"def form_api_path(self, request_host: RequestHost, api_path_prefix: str, endpoint: str) -> str:\\n api_url = self.base_url(request_host)\\n\\n if api_path_prefix:\\n api_url += api_path_prefix\\n\\n return f\\\"{api_url}{endpoint}\\\"\",\n \"def _url_full(self):\\n return self._url_base + \\\"/sharing/rest\\\"\",\n \"def join_api_url(api_base_url, api_path):\\n if api_base_url.endswith('/'):\\n api_base_url = api_base_url[:-1]\\n if api_path.startswith('/'):\\n api_path = api_path[1:]\\n\\n return api_base_url + '/' + api_path\",\n \"def home():\\n return (\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/preciptation<br/>\\\"\\n f\\\"/api/v1.0/Stations\\\"\\n )\",\n \"def _build_url(self):\\n url = BASE_URL.format(self._host, self._port)\\n _LOGGER.debug(\\\"TOON fetch URL: %s\\\", url)\\n return url\",\n \"def api_endpoint():\\n return 'localhost'\",\n \"def _parsing_url(self, base_url):\\n url2 = f\\\"{self.location}?apikey={self.api_key}&details=true\\\"\\n absolute_url = urljoin(base_url, url2)\\n return absolute_url\",\n \"def Home():\\n return(\\n f\\\"Hawaii Climate 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\\\"and<br/>\\\"\\n f\\\"/api/v1.0/<start>/<end>\\\"\\n )\",\n \"def base_url(self) -> str | None:\\n return self._base_url\",\n \"def getBuildbotURL():\",\n \"def getHomePage(self):\\n return self.home_url\",\n \"def home():\\n return (\\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><br/>\\\"\\n )\",\n \"def basic_url(self):\\n return self.base_name + '.cloudlabs.rc.ucl.ac.uk'\",\n \"def get_base_url(self):\\n return urlparse.urljoin(self.domain, self.root_path)\",\n \"def base_url(self):\\n return self._base_url\",\n \"def url(self) -> str:\\n return pulumi.get(self, \\\"url\\\")\",\n \"def url(self) -> str:\\n return pulumi.get(self, \\\"url\\\")\",\n \"def Home():\\n return (\\n f\\\"Welcome to the Climate App<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><br/>\\\"\\n )\",\n \"def getBaseUrl(self):\\n return self.url\",\n \"def _get_URL_base(self, request, step):\\n index = request.path.find(step.slug)\\n\\n return request.path[:index]\",\n \"def get_full_url(self):\\n full_url = home_page + self.source_link\\n return full_url\",\n \"def get_url(self, *args):\\n try:\\n url = '/'.join((self.base_url, ) + args)\\n except TypeError:\\n url = '/'.join((self.base_url, ) + args[0])\\n return url.rstrip('/')\",\n \"def url_base(self):\\n return 'http://%s:%d/' % (self.host, self.port)\",\n \"def GetBaseURL(self):\\n base_url = self.server_base_url\\n if base_url is None:\\n base_url = 'http://%s:%s' % self.server_address[:2]\\n\\n return base_url\",\n \"def url(self) -> str:\\n return f\\\"{self._get_base_url()}{self.path_extension}\\\"\",\n \"def get_api_url(settings: Settings) -> str:\\n return _get_control(settings) \\\\\\n .get('provider', {}).get('arguments', {}) \\\\\\n .get('api_url', '')\",\n \"def get_url():\\n if os.environ['SERVER_PORT'] == '80':\\n scheme = 'http://'\\n else:\\n scheme = 'https://'\\n host = os.environ['SERVER_NAME']\\n script_name = urllib.quote(os.environ.get('SCRIPT_NAME', ''))\\n path_info = urllib.quote(os.environ.get('PATH_INFO', ''))\\n qs = os.environ.get('QUERY_STRING', '')\\n if qs:\\n qs = '?' + qs\\n return scheme + host + script_name + path_info + qs\",\n \"def home():\\n return (\\n f\\\"These are the 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 ></br>\\\"\\n )\",\n \"def url(self, api_name):\\n return \\\"https://%s/api/%s/%s/\\\" % (self.host, self.api_version, api_name)\",\n \"def getCompleteUrl(urlPath: str) -> str:\\n return os.path.join(BASE_URL, urlPath) if urlPath else BASE_URL\",\n \"def get_api_url(self):\\n\\n url = 'https://api.{}/repos/{}/{}/git/'.format(HOST_GITHUB, \\\\\\n self.repo, self.product)\\n return url\",\n \"def weather_api_url(self, path):\\n return \\\"{}{}\\\".format(self.config[\\\"weather_api_url\\\"], path)\",\n \"def get_base_uri(self, server=Server.DEFAULT):\\r\\n parameters = {\\r\\n \\\"base_url\\\": {'value': self.base_url, 'encode': False},\\r\\n }\\r\\n\\r\\n return APIHelper.append_url_with_template_parameters(\\r\\n self.environments[self.environment][server], parameters\\r\\n )\",\n \"def get_full_url(self, part_url):\\n return BASE_URL + part_url\",\n \"def home():\\n return (\\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\\\"\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70845884","0.69659054","0.69256717","0.69165707","0.6896292","0.68960935","0.6873356","0.68278384","0.6792706","0.67290175","0.6711364","0.6674965","0.6651999","0.6650969","0.66333526","0.65721595","0.65439534","0.653448","0.6530355","0.6518613","0.651151","0.6469318","0.6435553","0.6401837","0.63991725","0.6398251","0.6398251","0.63979685","0.63936293","0.63881576","0.63869977","0.6376707","0.6363991","0.63498807","0.63283956","0.63164514","0.63038296","0.62814426","0.62730175","0.6261802","0.6256061","0.625495","0.6223046","0.62212276","0.6220565","0.62032825","0.6197107","0.6196266","0.61933154","0.6172197","0.616827","0.6163223","0.6156613","0.6152854","0.61525714","0.6150149","0.6134586","0.6124526","0.6120455","0.61047935","0.6101056","0.60986894","0.6097556","0.60919434","0.6083459","0.60740846","0.6067206","0.60528684","0.6025407","0.6020927","0.6015083","0.60111135","0.6006659","0.59971017","0.5981449","0.5972066","0.5969562","0.5965292","0.5962938","0.5959671","0.595301","0.595301","0.5940082","0.59338266","0.5932683","0.59312797","0.5930683","0.592773","0.592682","0.5926238","0.59261197","0.59246904","0.592321","0.5916355","0.59138465","0.5898959","0.5888477","0.58751816","0.5870684","0.5870364"],"string":"[\n \"0.70845884\",\n \"0.69659054\",\n \"0.69256717\",\n \"0.69165707\",\n \"0.6896292\",\n \"0.68960935\",\n \"0.6873356\",\n \"0.68278384\",\n \"0.6792706\",\n \"0.67290175\",\n \"0.6711364\",\n \"0.6674965\",\n \"0.6651999\",\n \"0.6650969\",\n \"0.66333526\",\n \"0.65721595\",\n \"0.65439534\",\n \"0.653448\",\n \"0.6530355\",\n \"0.6518613\",\n \"0.651151\",\n \"0.6469318\",\n \"0.6435553\",\n \"0.6401837\",\n \"0.63991725\",\n \"0.6398251\",\n \"0.6398251\",\n \"0.63979685\",\n \"0.63936293\",\n \"0.63881576\",\n \"0.63869977\",\n \"0.6376707\",\n \"0.6363991\",\n \"0.63498807\",\n \"0.63283956\",\n \"0.63164514\",\n \"0.63038296\",\n \"0.62814426\",\n \"0.62730175\",\n \"0.6261802\",\n \"0.6256061\",\n \"0.625495\",\n \"0.6223046\",\n \"0.62212276\",\n \"0.6220565\",\n \"0.62032825\",\n \"0.6197107\",\n \"0.6196266\",\n \"0.61933154\",\n \"0.6172197\",\n \"0.616827\",\n \"0.6163223\",\n \"0.6156613\",\n \"0.6152854\",\n \"0.61525714\",\n \"0.6150149\",\n \"0.6134586\",\n \"0.6124526\",\n \"0.6120455\",\n \"0.61047935\",\n \"0.6101056\",\n \"0.60986894\",\n \"0.6097556\",\n \"0.60919434\",\n \"0.6083459\",\n \"0.60740846\",\n \"0.6067206\",\n \"0.60528684\",\n \"0.6025407\",\n \"0.6020927\",\n \"0.6015083\",\n \"0.60111135\",\n \"0.6006659\",\n \"0.59971017\",\n \"0.5981449\",\n \"0.5972066\",\n \"0.5969562\",\n \"0.5965292\",\n \"0.5962938\",\n \"0.5959671\",\n \"0.595301\",\n \"0.595301\",\n \"0.5940082\",\n \"0.59338266\",\n \"0.5932683\",\n \"0.59312797\",\n \"0.5930683\",\n \"0.592773\",\n \"0.592682\",\n \"0.5926238\",\n \"0.59261197\",\n \"0.59246904\",\n \"0.592321\",\n \"0.5916355\",\n \"0.59138465\",\n \"0.5898959\",\n \"0.5888477\",\n \"0.58751816\",\n \"0.5870684\",\n \"0.5870364\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6285166"},"document_rank":{"kind":"string","value":"37"}}},{"rowIdx":585,"cells":{"query":{"kind":"string","value":"Make sure the netcdf cc data handler operates correctly"},"document":{"kind":"string","value":"def test_data_handling_nc_cc():\n\n input_files = [os.path.join(TEST_DATA_DIR, 'ua_test.nc'),\n os.path.join(TEST_DATA_DIR, 'va_test.nc'),\n os.path.join(TEST_DATA_DIR, 'orog_test.nc'),\n os.path.join(TEST_DATA_DIR, 'zg_test.nc')]\n\n with xr.open_mfdataset(input_files) as fh:\n min_lat = np.min(fh.lat.values)\n min_lon = np.min(fh.lon.values)\n target = (min_lat, min_lon)\n plevel = fh.plev[-1]\n ua = np.transpose(fh['ua'][:, -1, ...].values, (1, 2, 0))\n va = np.transpose(fh['va'][:, -1, ...].values, (1, 2, 0))\n\n handler = DataHandlerNCforCC(input_files, features=['U_100m', 'V_100m'],\n target=target, shape=(20, 20),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n assert handler.data.shape == (20, 20, 20, 2)\n\n handler = DataHandlerNCforCC(input_files,\n features=[f'U_{int(plevel)}pa',\n f'V_{int(plevel)}pa'],\n target=target, shape=(20, 20),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n if handler.invert_lat:\n handler.data = handler.data[::-1]\n assert handler.data.shape == (20, 20, 20, 2)\n assert np.allclose(ua, handler.data[..., 0])\n assert np.allclose(va, handler.data[..., 1])"},"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 _check_data(self):\n # ================ CHECK DATA / CONNECT / SELECT ================\n N = self.xyz.shape[0]\n # Chech array :\n if (self.connect.shape != (N, N)) or not isinstance(self.connect,\n np.ndarray):\n raise ValueError(\"c_connect must be an array of \"\n \"shape \" + str((N, N)))\n if self.select is None:\n self.select = np.ones_like(self.connect)\n if (self.select.shape != (N, N) or not isinstance(self.select,\n np.ndarray)):\n raise ValueError(\"c_select must be an array of \"\n \"shape \" + str((N, N)))\n # Mask c_connect :\n try:\n self.connect.mask\n except:\n self.connect = np.ma.masked_array(self.connect, mask=True)\n self.connect.mask[self.select.nonzero()] = False\n # Use specific color values :\n if (self.colval is not None) and isinstance(self.colval, dict):\n mask = np.ones_like(self.connect.mask)\n for k, v in zip(self.colval.keys(), self.colval.values()):\n mask[self.connect.data == k] = False\n self.colval[k] = color2vb(v)\n self.connect.mask = mask\n\n # ================ CHECK COLOR ================\n # Check colorby :\n if self.colorby not in ['count', 'strength', 'density']:\n raise ValueError(\"The c_colorby parameter must be 'count', \"\n \"'strength' or 'density'\")\n # Test dynamic :\n if (self.dynamic is not None) and not isinstance(self.dynamic, tuple):\n raise ValueError(\"c_dynamic bust be a tuple\")\n\n # ================ NON-ZERO INDICES ================\n # Find where there is non-masked connections :\n self._nnz_x, self._nnz_y = np.where(~self.connect.mask)\n self._indices = np.c_[self._nnz_x, self._nnz_y].flatten()\n self._Nindices = np.arange(len(self._indices))\n # Build position array :\n self.a_position = np.zeros((2*len(self._nnz_x), 3), dtype=np.float32)\n self.a_position[self._Nindices, :] = self.xyz[self._indices, :]","def test_solar_cc():\n\n features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']\n input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]\n nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')\n\n with xr.open_mfdataset(input_files) as fh:\n min_lat = np.min(fh.lat.values)\n min_lon = np.min(fh.lon.values) - 360\n target = (min_lat, min_lon)\n shape = (len(fh.lat.values), len(fh.lon.values))\n\n with pytest.raises(AssertionError):\n handler = DataHandlerNCforCC(input_files, features=features,\n target=target, shape=shape,\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n handler = DataHandlerNCforCC(input_files, features=features,\n nsrdb_source_fp=nsrdb_source_fp,\n target=target, shape=shape,\n temporal_slice=slice(0, 1),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n cs_ratio = handler.data[..., 0]\n ghi = handler.data[..., 1]\n cs_ghi = handler.data[..., 2]\n cs_ratio_truth = ghi / cs_ghi\n\n assert cs_ratio.max() < 1\n assert cs_ratio.min() > 0\n assert (ghi < cs_ghi).all()\n assert np.allclose(cs_ratio, cs_ratio_truth)\n\n with Resource(nsrdb_source_fp) as res:\n meta = res.meta\n tree = KDTree(meta[['latitude', 'longitude']])\n cs_ghi_true = res['clearsky_ghi']\n\n # check a few sites against NSRDB source file\n for i in range(4):\n for j in range(4):\n test_coord = handler.lat_lon[i, j]\n _, inn = tree.query(test_coord)\n\n assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j])","def test_ccds(self):\n #TODO write ccds tests","def __init__(self, datafile):\r\n super(type(self), self).__init__()\r\n self.data = None\r\n log.info(\"Trying to read netcdf \"+datafile)\r\n try:\r\n # We have to uncompress the file to a temporary file\r\n # This will be deleted on __del__ cleanup\r\n datafile = super(type(self), self).uncompressTempFile(datafile)\r\n self.data = Scientific.IO.NetCDF.NetCDFFile(datafile, \"r\")\r\n except BaseException as e:\r\n log.error(\"Couldn't read netcdf data from file \"+datafile)\r\n log.error(\"Exception {0}\".format(e))","def read_netcdf(self,filename):","def sanity_check_step(self):\n\n incs = [\"netcdf.h\"]\n libs = [\"libnetcdf.so\", \"libnetcdf.a\"]\n # since v4.2, the non-C libraries have been split off in seperate extensions_step\n # see netCDF-Fortran and netCDF-C++\n if LooseVersion(self.version) < LooseVersion(\"4.2\"):\n incs += [\"netcdf%s\" % x for x in [\"cpp.h\", \".hh\", \".inc\", \".mod\"]] + \\\n [\"ncvalues.h\", \"typesizes.mod\"]\n libs += [\"libnetcdf_c++.so\", \"libnetcdff.so\",\n \"libnetcdf_c++.a\", \"libnetcdff.a\"]\n\n custom_paths = {\n 'files': [\"bin/nc%s\" % x for x in [\"-config\", \"copy\", \"dump\",\n \"gen\", \"gen3\"]] +\n [\"lib/%s\" % x for x in libs] +\n [\"include/%s\" % x for x in incs],\n 'dirs': []\n }\n\n super(EB_netCDF, self).sanity_check_step(custom_paths=custom_paths)","def __init__(self):\n self.datasets = [\"ISCCP\",\"ISCCP_raw\",\"PATMOSX\",\"PATMOSX_raw\"]\n f = cdms.open(\"OBS/clt_ISCCP_corrected_198301-200912.nc\")\n fp = cdms.open(\"OBS/clt_PATMOSX_corrected_198301-200912.nc\")\n \n f_old = cdms.open(\"OBS/clt_ISCCP_198307-200806.nc\")\n fp_old = cdms.open(\"OBS/clt_PATMOSX_198200-200912.nc\")\n\n fgpcp = cdms.open(\"OBS/GPCP.precip.mon.mean.nc\")\n fcmap = cdms.open(\"OBS/CMAP.std.precip.mon.mean.nc\")\n \n \n self.ISCCP = f(\"clt\",time=('1984-1-1','2009-12-31'))\n self.ISCCP = MV.masked_where(np.isnan(self.ISCCP),self.ISCCP)\n cdutil.setTimeBoundsMonthly(self.ISCCP)\n\n self.PATMOSX = fp(\"clt\",time=('1984-1-1','2009-12-31'))\n self.PATMOSX = MV.masked_where(np.isnan(self.PATMOSX),self.PATMOSX)\n cdutil.setTimeBoundsMonthly(self.PATMOSX)\n\n self.ISCCP_raw = f_old(\"clt\",time=('1984-1-1','2008-6-31'))\n self.ISCCP_raw = MV.masked_where(np.isnan(self.ISCCP_raw),self.ISCCP_raw)\n cdutil.setTimeBoundsMonthly(self.ISCCP_raw)\n\n self.PATMOSX_raw = fp_old(\"clt\",time=('1982-1-1','2009-12-31'))\n self.PATMOSX_raw = MV.masked_where(np.isnan(self.PATMOSX_raw),self.PATMOSX_raw)\n cdutil.setTimeBoundsMonthly(self.PATMOSX_raw)\n\n self.GPCP = cdutil.averager(fgpcp(\"precip\",time=('1979-1-1','2014-12-31'),latitude=(-90,90)),axis='x')\n cdutil.setTimeBoundsMonthly(self.GPCP)\n self.CMAP = cdutil.averager(fcmap(\"precip\",time=('1979-1-1','2014-12-31'),latitude=(-90,90)),axis='x')\n self.CMAP.setAxis(0,self.GPCP.getTime())\n cdutil.setTimeBoundsMonthly(self.CMAP)","def have_cdc() -> bool:","def __init__(self, datafile):\r\n super(type(self), self).__init__()\r\n log.info(\"Trying to read netcdf \"+datafile)\r\n try:\r\n # We have to uncompress the file to a temporary file\r\n # This will be deleted on __del__ cleanup\r\n datafile = \\\r\n netcdf_reader.netcdfReader.uncompressTempFile(self, datafile) \r\n self.data = arcpy.NetCDFFileProperties(datafile)\r\n except BaseException as e:\r\n log.error(\"Couldn't read netcdf data from file \"+datafile)\r\n log.error(\"Exception {0}\".format(e))\r\n \r\n def __del__(self):\r\n # Close our file before calling superclass, since superclass might delete it\r\n if self.data:\r\n self.data.close()\r\n super(type(self), self).__del__()","def write_netcdf(file,xc,xc_bnd,yc,yc_bnd,times,hydrographs,fractions,loc,Flist,velocity,diffusion,NODATA,verbose):\n \n f = Dataset(file,'w', format='NETCDF4')\n\n # set dimensions\n time = f.createDimension('time', None)\n x = f.createDimension('x',xc.shape[1])\n y = f.createDimension('y',xc.shape[0])\n nv4 = f.createDimension('nv4',4)\n\n # initialize variables\n time = f.createVariable('time','f8',('time',))\n xcs = f.createVariable('xc','f8',('y','x',))\n ycs = f.createVariable('yc','f8',('y','x',))\n xc_bnds = f.createVariable('xc_bnds','f8',('y','x','nv4',))\n yc_bnds = f.createVariable('yc_bnds','f8',('y','x','nv4',))\n fraction = f.createVariable('fraction','f8',('y','x',),fill_value=NODATA)\n UHS = f.createVariable('unit_hydrograph','f8',('time','y','x',),fill_value=NODATA)\n\n # write attributes for netcdf\n f.description = 'Aggregated UH_S and Fraction Vars for full RASM domain'\n f.history = 'Created: {}\\n'.format(tm.ctime(tm.time()))\n f.history += ' '.join(sys.argv) + '\\n'\n f.source = sys.argv[0] # prints the name of script used\n f.velocity = velocity\n f.diffusion = diffusion\n f.outlet_lon = loc[0]\n f.outlet_lat = loc[1]\n f.includes = str(len(Flist))+' files'\n\n ycs.long_name = 'latitude of grid cell center'\n ycs.standard_name = 'latitude'\n ycs.units = 'degrees_north'\n ycs._CoordinateAxisType = 'Lat'\n ycs.bounds = 'yc_bnds'\n\n xcs.long_name = 'longitude of grid cell center'\n xcs.standard_name = 'longitude'\n xcs.units = 'degrees_east'\n xcs._CoordinateAxisType = 'Lon'\n xcs.bounds = 'xc_bnds'\n\n time.standard_name = 'time'\n time.units = 'seconds'\n time.description = 'Seconds since initial impulse'\n time.calendar = 'proleptic_gregorian'\n\n UHS.units = 'unitless'\n UHS.description = 'unit hydrograph for each grid cell with respect to basin outlet location'\n \n fraction.units = 'unitless'\n fraction.description = 'fraction of grid cell contributing to guage location'\n\n # write data to variables initialized above\n time[:]= times\n xcs[:,:] = xc\n ycs[:,:] = yc\n xc_bnds[:,:,:] = xc_bnd\n yc_bnds[:,:,:] = yc_bnd\n UHS[:,:,:] = hydrographs\n fraction[:,:]= fractions\n f.close()\n\n return","def inputs_netCDF(ID, fname, data):\n\n from netCDF4 import Dataset #, date2num, num2date\n from datetime import datetime\n\n print('**** creating SpaFHy input netCDF4 file: ' + fname + ' ****')\n \n # create dataset & dimensions\n ncf = Dataset(fname, 'w')\n ncf.description = 'SpatialData from : ' + str(ID)\n ncf.history = 'created ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n ncf.source = 'SpaFHy v.1.0 inputs'\n \n dlat, dlon = np.shape(data['cmask'])\n\n ncf.createDimension('dlon', int(dlon))\n ncf.createDimension('dlat', int(dlat))\n ncf.createDimension('scalar', 1)\n\n # create variables \n # call as createVariable(varname,type,(dimensions))\n cellsize = ncf.createVariable('cellsize', 'f4', ('scalar',))\n cellsize.units = 'm'\n lat = ncf.createVariable('lat', 'f4', ('dlat',))\n lat.units = 'ETRS-TM35FIN'\n lon = ncf.createVariable('lon', 'f4', ('dlon',))\n lon.units = 'ETRS-TM35FIN'\n\n cellsize[0] = data['cellsize']\n lon[:] = data['lon0']\n lat[:] = data['lat0']\n \n # required inputs\n cmask = ncf.createVariable('cmask', 'i4', ('dlat','dlon',))\n cmask.units = 'integer inside catchment, Nan outside'\n LAI_conif = ncf.createVariable('LAI_conif', 'f4', ('dlat','dlon',))\n LAI_conif.units = 'conifer LAI (m2m-2)'\n LAI_decid = ncf.createVariable('LAI_decid', 'f4', ('dlat','dlon',))\n LAI_decid.units = 'deciduous annual max LAI (m2m-2)' \n hc = ncf.createVariable('hc', 'f4', ('dlat','dlon',))\n hc.units = 'canopy height m' \n cf = ncf.createVariable('cf', 'f4', ('dlat','dlon',))\n cf.units = 'canopy closure (-)' \n \n soilclass = ncf.createVariable('soilclass', 'i4', ('dlat','dlon',))\n soilclass.units = 'soil class (1 - 5)'\n \n flowacc = ncf.createVariable('flowacc', 'f4', ('dlat','dlon',))\n flowacc.units = 'flow accumualtion area m2'\n slope = ncf.createVariable('slope', 'f4', ('dlat','dlon',))\n slope.units = 'local slope (deg)' \n \n for k in ['LAI_conif', 'LAI_decid', 'hc', 'cf', 'soilclass', 'flowacc', 'slope']:\n ncf[k][:,:] = data[k]\n \n print('**** done ****')","def _initialize_output(self, time_len, id_len):\r\n\r\n log('Initializing new file %s' % self.cf_compliant_file, 'INFO')\r\n \r\n self.cf_nc = Dataset(self.cf_compliant_file, 'w', format='NETCDF3_CLASSIC')\r\n \r\n # Create global attributes\r\n log(' globals', 'DEBUG', self.print_debug)\r\n self.cf_nc.featureType = 'timeSeries'\r\n self.cf_nc.Metadata_Conventions = 'Unidata Dataset Discovery v1.0'\r\n self.cf_nc.Conventions = 'CF-1.6'\r\n self.cf_nc.cdm_data_type = 'Station'\r\n self.cf_nc.nodc_template_version = (\r\n 'NODC_NetCDF_TimeSeries_Orthogonal_Template_v1.1')\r\n self.cf_nc.standard_name_vocabulary = ('NetCDF Climate and Forecast (CF) ' +\r\n 'Metadata Convention Standard Name ' +\r\n 'Table v28')\r\n self.cf_nc.title = 'RAPID Result'\r\n self.cf_nc.summary = (\"Results of RAPID river routing simulation. Each river \" +\r\n \"reach (i.e., feature) is represented by a point \" +\r\n \"feature at its midpoint, and is identified by the \" +\r\n \"reach's unique NHDPlus COMID identifier.\")\r\n self.cf_nc.time_coverage_resolution = 'point'\r\n self.cf_nc.geospatial_lat_min = 0.0\r\n self.cf_nc.geospatial_lat_max = 0.0\r\n self.cf_nc.geospatial_lat_units = 'degrees_north'\r\n self.cf_nc.geospatial_lat_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_lon_min = 0.0\r\n self.cf_nc.geospatial_lon_max = 0.0\r\n self.cf_nc.geospatial_lon_units = 'degrees_east'\r\n self.cf_nc.geospatial_lon_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_vertical_min = 0.0\r\n self.cf_nc.geospatial_vertical_max = 0.0\r\n self.cf_nc.geospatial_vertical_units = 'm'\r\n self.cf_nc.geospatial_vertical_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_vertical_positive = 'up'\r\n self.cf_nc.project = self.project_name\r\n self.cf_nc.processing_level = 'Raw simulation result'\r\n self.cf_nc.keywords_vocabulary = ('NASA/Global Change Master Directory ' +\r\n '(GCMD) Earth Science Keywords. Version ' +\r\n '8.0.0.0.0')\r\n self.cf_nc.keywords = 'DISCHARGE/FLOW'\r\n self.cf_nc.comment = 'Result time step(s) (seconds): ' + str(self.time_step_array)\r\n \r\n timestamp = datetime.utcnow().isoformat() + 'Z'\r\n self.cf_nc.date_created = timestamp\r\n self.cf_nc.history = (timestamp + '; added time, lat, lon, z, crs variables; ' +\r\n 'added metadata to conform to NODC_NetCDF_TimeSeries_' +\r\n 'Orthogonal_Template_v1.1')\r\n \r\n # Create dimensions\r\n log(' dimming', 'DEBUG', self.print_debug)\r\n self.cf_nc.createDimension('time', time_len)\r\n self.cf_nc.createDimension(self.output_id_dim_name, id_len)\r\n \r\n # Create variables\r\n log(' timeSeries_var', 'DEBUG', self.print_debug)\r\n timeSeries_var = self.cf_nc.createVariable(self.output_id_dim_name, 'i4', \r\n (self.output_id_dim_name,))\r\n timeSeries_var.long_name = (\r\n 'Unique NHDPlus COMID identifier for each river reach feature')\r\n timeSeries_var.cf_role = 'timeseries_id'\r\n \r\n log(' time_var', 'DEBUG', self.print_debug)\r\n time_var = self.cf_nc.createVariable('time', 'i4', ('time',))\r\n time_var.long_name = 'time'\r\n time_var.standard_name = 'time'\r\n time_var.units = 'seconds since 1970-01-01 00:00:00 0:00'\r\n time_var.axis = 'T'\r\n \r\n #only add if user adds\r\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\r\n log(' lat_var', 'DEBUG', self.print_debug)\r\n lat_var = self.cf_nc.createVariable('lat', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n lat_var.long_name = 'latitude'\r\n lat_var.standard_name = 'latitude'\r\n lat_var.units = 'degrees_north'\r\n lat_var.axis = 'Y'\r\n \r\n log(' lon_var', 'DEBUG', self.print_debug)\r\n lon_var = self.cf_nc.createVariable('lon', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n lon_var.long_name = 'longitude'\r\n lon_var.standard_name = 'longitude'\r\n lon_var.units = 'degrees_east'\r\n lon_var.axis = 'X'\r\n \r\n log(' z_var', 'DEBUG', self.print_debug)\r\n z_var = self.cf_nc.createVariable('z', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n z_var.long_name = ('Elevation referenced to the North American ' +\r\n 'Vertical Datum of 1988 (NAVD88)')\r\n z_var.standard_name = 'surface_altitude'\r\n z_var.units = 'm'\r\n z_var.axis = 'Z'\r\n z_var.positive = 'up'\r\n \r\n log(' crs_var', 'DEBUG', self.print_debug)\r\n crs_var = self.cf_nc.createVariable('crs', 'i4')\r\n crs_var.grid_mapping_name = 'latitude_longitude'\r\n crs_var.epsg_code = 'EPSG:4326' # WGS 84\r\n crs_var.semi_major_axis = 6378137.0\r\n crs_var.inverse_flattening = 298.257223563","def save_ecco_dataset_to_netcdf(ecco_ds,\n output_dir,\n dataset_name = 'by_variable',\n time_method = 'by_record',\n output_array_precision = np.float32,\n output_freq_code=None):\n\n\n # Create a name of the files if not specified\n # ---------------------------------------------\n if dataset_name =='by_variable':\n # concat all data variables together into a single string\n dataset_name = '_'.join(list(ecco_ds.data_vars))\n\n\n # force load coordinate values in case they are in dask array\n # -----------------------------------------------------------\n for coord in ecco_ds.coords:\n ecco_ds[coord].load()\n\n\n # Define fill values for NaN\n # ---------------------------------------------\n if output_array_precision == np.float32:\n netcdf_fill_value = nc4.default_fillvals['f4']\n\n elif output_array_precision == np.float64:\n netcdf_fill_value = nc4.default_fillvals['f8']\n\n\n # Create NetCDF encoding directives\n # ---------------------------------------------\n print('\\n... creating variable encodings')\n # ... data variable encoding directives\n dv_encoding = dict()\n for dv in ecco_ds.data_vars:\n dv_encoding[dv] = {'zlib':True, \\\n 'complevel':5,\\\n 'shuffle':True,\\\n '_FillValue':netcdf_fill_value}\n\n # ... coordinate encoding directives\n print('\\n... creating coordinate encodings')\n coord_encoding = dict()\n for coord in ecco_ds.coords:\n # set default no fill value for coordinate\n if output_array_precision == np.float32:\n coord_encoding[coord] = {'_FillValue':None, 'dtype':'float32'}\n elif output_array_precision == np.float64:\n coord_encoding[coord] = {'_FillValue':None, 'dtype':'float64'}\n\n # force 64 bit ints to be 32 bit ints\n if (ecco_ds[coord].values.dtype == np.int32) or \\\n (ecco_ds[coord].values.dtype == np.int64) :\n coord_encoding[coord]['dtype'] ='int32'\n\n # fix encoding of time\n if coord == 'time' or coord == 'time_bnds':\n coord_encoding[coord]['dtype'] ='int32'\n\n if 'units' in ecco_ds[coord].attrs:\n # apply units as encoding for time\n coord_encoding[coord]['units'] = ecco_ds[coord].attrs['units']\n # delete from the attributes list\n del ecco_ds[coord].attrs['units']\n\n elif coord == 'time_step':\n coord_encoding[coord]['dtype'] ='int32'\n\n # ... combined data variable and coordinate encoding directives\n encoding = {**dv_encoding, **coord_encoding}\n\n\n # Create directory for output files\n # ---------------------------------------------\n filepath = output_dir / dataset_name\n\n if not filepath.exists():\n filepath.mkdir(parents=True, exist_ok=True)\n\n\n # Determine output freqency code.\n # ---------------------------------------------\n # user can specify directory or it can be found if the dataset\n # has the 'time_coverage_resolution' global attribute\n if output_freq_code == None:\n if 'time_coverage_resolution' in ecco_ds.attrs:\n\n print('dataset time averaging from metadata')\n time_coverage_resolution = ecco_ds.attrs['time_coverage_resolution']\n if time_coverage_resolution == 'P1M':\n output_freq_code='AVG_MON'\n elif time_coverage_resolution == 'P1D':\n output_freq_code='AVG_DAY'\n elif time_coverage_resolution == 'P0S':\n output_freq_code='SNAP'\n else:\n print('output_freq_code not defined and not available in dataset metadata')\n print('... using full record time in filename')\n\n\n # Write records to disk as NetCDF\n # ---------------------------------------------\n # one file per time level\n\n if time_method == 'by_record':\n for time_i, rec_time in enumerate(ecco_ds.time):\n\n cur_ds = ecco_ds.isel(time=time_i)\n\n # cast data variables to desired precision (if necessary)\n #for data_var in cur_ds.data_vars:\n # if cur_ds[data_var].values.dtype != output_array_precision:\n # cur_ds[data_var].values = cur_ds[data_var].astype(output_array_precision)\n\n time_date_info =\\\n make_date_str_from_dt64(cur_ds.time.values, output_freq_code)\n\n # sort comments alphabetically\n print('\\n... sorting global attributes')\n cur_ds.attrs = sort_attrs(cur_ds.attrs)\n\n # add one final comment (PODAAC request)\n cur_ds.attrs[\"coordinates_comment\"] = \\\n \"Note: the global 'coordinates' attribute descibes auxillary coordinates.\"\n\n fname = dataset_name + '_' + time_date_info['short'] +\\\n '_' + time_date_info['ppp_tttt'] + '.nc'\n\n print(fname)\n print(cur_ds)\n netcdf_output_filename = filepath / fname\n\n # SAVE\n print('\\n... saving to netcdf ', netcdf_output_filename)\n cur_ds.to_netcdf(netcdf_output_filename, encoding=encoding)\n cur_ds.close()\n\n # one file per year\n elif time_method == 'by_year':\n unique_years = np.unique(ecco_ds.time.dt.year)\n print(unique_years)\n\n for year in unique_years:\n # pull out only records for this year\n cur_ds = ecco_ds.sel(time=slice(str(year), str(year)))\n\n first_time = cur_ds.time.values[0]\n last_time = cur_ds.time.values[-1]\n\n first_time_date_info =\\\n make_date_str_from_dt64(first_time, output_freq_code)\n\n last_time_date_info =\\\n make_date_str_from_dt64(last_time, output_freq_code)\n\n # sort comments alphabetically\n print('\\n... sorting global attributes')\n cur_ds.attrs = sort_attrs(cur_ds.attrs)\n\n # add one final comment (PODAAC request)\n cur_ds.attrs[\"coordinates_comment\"] = \\\n \"Note: the global 'coordinates' attribute descibes auxillary coordinates.\"\n\n fname = dataset_name + '_' +\\\n first_time_date_info['short'] + '_' +\\\n last_time_date_info['short'] + '_' +\\\n first_time_date_info['ppp_tttt']+ '.nc'\n\n print(fname)\n print(cur_ds)\n netcdf_output_filename = filepath / fname\n\n # SAVE\n print('\\n... saving to netcdf ', netcdf_output_filename)\n cur_ds.to_netcdf(netcdf_output_filename, encoding=encoding)\n cur_ds.close()","def runTest(self):\n ncfile = netCDF4.Dataset(URL)\n assert varname in ncfile.variables.keys()\n var = ncfile.variables[varname]\n assert var.shape == varshape\n data = var[:]\n assert_array_almost_equal(data.min(),varmin)\n assert_array_almost_equal(data.max(),varmax)\n ncfile.close()\n # test https support (linked curl lib must built with openssl support)\n ncfile = netCDF4.Dataset(URL_https)\n assert(ncfile['sst'].long_name=='Sea Surface Temperature') \n ncfile.close()","def _write_nc(self, FN, data):\n n_points = data['counts'][0] * data['counts'][1] * data['counts'][2]\n from netCDF4 import Dataset\n grid_nc = Dataset(FN, 'w', format='NETCDF4')\n grid_nc.createDimension('one', 1)\n grid_nc.createDimension('n_cartesian', 3)\n grid_nc.createDimension('n_points', n_points)\n grid_nc.createVariable('origin', 'f8', ('one', 'n_cartesian'))\n grid_nc.createVariable('counts', 'i8', ('one', 'n_cartesian'))\n grid_nc.createVariable('spacing', 'f8', ('one', 'n_cartesian'))\n grid_nc.createVariable('vals', 'f8', ('one', 'n_points'), zlib=True)\n for key in data.keys():\n grid_nc.variables[key][:] = data[key]\n grid_nc.close()","def runTest(self):\n nc = Dataset(self.file)\n data = nc['vl'][-1]\n # check max error of compression\n err = np.abs(data - self.data)\n assert(err.max() < nc['vl'].scale_factor)\n # turn off auto-scaling\n nc.set_auto_maskandscale(False)\n data = nc['vl'][-1]\n assert(data[-1] == np.around(self.data[-1]/nc['vl'].scale_factor))\n nc.close()","def execute(self, in_nc, in_weight_table, out_nc, grid_name, conversion_flag, in_time_interval=\"6hr\"): # modified this line CJB 20190218\r\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\r\n # and upstream correction of the cdo grid conversion units attribute.\r\n\r\n # Validate the netcdf dataset\r\n vars_oi_index = self.dataValidation(in_nc)\r\n \r\n \"\"\"get conversion factor the flag is used to differentiate forecasts converted \r\n to netCDF from GRIB and the original netCDF. They both use the same weight tables\r\n but the original netCDF is in mm whereas the stock GRIB forecasts are in meters.\r\n Set the conversion_flag in the run.py configuration file.\r\n \"\"\"\r\n if conversion_flag: # Line Added CJB 20190218\r\n conversion_factor = 1.0 #Line Modified CJB 20190218\r\n elif grid_name == 'ecmwf_t1279' or grid_name == 'ecmwf_tco639': # Line Modified CJB 20190218\r\n #if grid_name == 'ecmwf_HRES_F' or grid_name == 'ecmwf_ENS_F': # Line Added/Modified CJB 20190108\r\n #new grids in mm instead of m\r\n conversion_factor = 0.001\r\n else: #set the conversion factor to 1 for everything else (data is in m but legacy installations do not have a flag) Line Added CJB 20190218\r\n conversion_factor = 1.0 # Line Added CJB 20190218\r\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\r\n # and upstream correction of the cdo grid conversion units attribute.\r\n # identify if the input netcdf data is the High Resolution data with three different time intervals\r\n id_data = self.dataIdentify(in_nc)\r\n if id_data is None:\r\n raise Exception(self.errorMessages[3])\r\n\r\n ''' Read the netcdf dataset'''\r\n data_in_nc = NET.Dataset(in_nc)\r\n time = data_in_nc.variables['time'][:]\r\n\r\n # Check the size of time variable in the netcdf data\r\n if len(time) == 0: # *** MJS This change seems like it is too loose an error trap; should it account for instances when nc file time var is != in length with id_data lenght?\r\n raise Exception(self.errorMessages[3])\r\n #if len(time) != self.length_time[id_data]:\r\n # raise Exception(self.errorMessages[3])\r\n\r\n ''' Read the weight table '''\r\n print(\"Reading the weight table...\", in_weight_table)\r\n dict_list = {self.header_wt[0]:[], self.header_wt[1]:[], self.header_wt[2]:[],\r\n self.header_wt[3]:[], self.header_wt[4]:[]}\r\n\r\n with open(in_weight_table, \"r\") as csvfile:\r\n reader = csv.reader(csvfile)\r\n count = 0\r\n for row in reader:\r\n if count == 0:\r\n #check number of columns in the weight table\r\n if len(row) < len(self.header_wt):\r\n raise Exception(self.errorMessages[4])\r\n #check header\r\n if row[1:len(self.header_wt)] != self.header_wt[1:]:\r\n raise Exception(self.errorMessages[5])\r\n count += 1\r\n else:\r\n for i in range(len(self.header_wt)):\r\n dict_list[self.header_wt[i]].append(row[i])\r\n count += 1\r\n\r\n ''' Calculate water inflows\r\n as a reminder, the first 91 time steps are T=0 to T=90 and are 1-hourly for HRES\r\n\t\t the next 18 time steps for HRES are T=93 to T=144 at 3-hourly\r\n then the final 16 time steps are T=150 to T=240 at 6-hourly for a total of 125 records\r\n\t\t\tFor ENS, the first 49 time steps are T=0 to T=144 at 3-hourly\r\n\t\t\tthe final 35 time steps are T=150 to T=360 at 6-hourly for a total of 84 records\r\n '''\r\n\t\t\t\r\n print(\"Calculating water inflows...\")\r\n\t\t\r\n ''' \r\n added the next section CJB 20180122 \r\n '''\r\n\r\n\t\t# Get the overall number of time steps\r\n size_time = self.getTimeSize(in_nc) #CJB 20180122\r\n # Determine the size of time steps in each group (1-hourly, 3-hourly, and/or 6-hourly)\r\n if id_data == \"HRES1\": # T <= 90 \r\n time_size = (size_time - 1)\r\n elif id_data == \"HRES13\": # 93 <= T <= 144\r\n if in_time_interval == \"1hr\":\r\n time_size = self.length_time_opt[\"HighRes-1hr\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"HighRes-1hr\"] - 1)\r\n elif id_data == \"HRES136\": # 150 <= T <= 240\r\n if in_time_interval == \"1hr\":\r\n time_size = self.length_time_opt[\"HighRes-1hr\"]\r\n elif in_time_interval == \"3hr\": # MJS Doesn't seem to be a case used currently, but added just in case later need.\r\n time_size = self.length_time_opt[\"HighRes-3hr-sub\"] # MJS This is HRES136, i.e., if for some reason in ecmwf_rapid_multi a 3 hr is asked for for this case, it should still have the 3hr_sub number of times\r\n elif in_time_interval == \"3hr_subset\":\r\n time_size = self.length_time_opt[\"HighRes-3hr-Sub\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"HighRes-1hr\"] - self.length_time_opt[\"HighRes-3hr-Sub\"] - 1)\r\n elif id_data == \"ENS3\": # T <= 144\r\n time_size = (size_time - 1)\r\n elif id_data == \"ENS36\": # 150 <= T <= 360\r\n if in_time_interval == \"3hr_subset\":\r\n time_size = self.length_time_opt[\"LowResFull-3hr-Sub\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"LowResFull-3hr-Sub\"] - 1)\r\n else: # id_data == \"ENS6\": # T <= 360 but all 6-hourly\r\n time_size = (size_time - 1)\r\n #else: # something is wrong and need to throw an error message - likely a corrupt forecast file\r\n # raise Exception(self.errorMessages[3])\r\n #''' end of added section CJB 20180122 \r\n #'''\r\n\r\n #if id_data == \"LowRes\":\r\n # size_time = self.length_time_opt[\"LowRes-6hr\"]\r\n #elif id_data == \"Low3HrRes\":\r\n # size_time = self.length_time_opt[\"LowRes-3hr\"]\r\n #elif id_data == \"LowResFull\":\r\n # if in_time_interval == \"3hr_subset\":\r\n # size_time = self.length_time_opt[\"LowResFull-3hr-Sub\"]\r\n # elif in_time_interval == \"6hr_subset\":\r\n # size_time = self.length_time_opt[\"LowResFull-6hr-Sub\"]\r\n # else:\r\n # size_time = self.length_time_opt[\"LowRes-6hr\"]\r\n #else: #HighRes\r\n # if in_time_interval == \"1hr\":\r\n # size_time = self.length_time_opt[\"HighRes-1hr\"]\r\n # elif in_time_interval == \"3hr\":\r\n # size_time = self.length_time_opt[\"HighRes-3hr\"]\r\n # elif in_time_interval == \"3hr_subset\":\r\n # size_time = self.length_time_opt[\"HighRes-3hr-Sub\"]\r\n # elif in_time_interval == \"6hr_subset\":\r\n # size_time = self.length_time_opt[\"HighRes-6hr-Sub\"]\r\n # else:\r\n # size_time = self.length_time_opt[\"HighRes-6hr\"]\r\n\r\n size_streamID = len(set(dict_list[self.header_wt[0]]))\r\n\r\n # Create output inflow netcdf data\r\n # data_out_nc = NET.Dataset(out_nc, \"w\") # by default format = \"NETCDF4\"\r\n data_out_nc = NET.Dataset(out_nc, \"w\", format = \"NETCDF3_CLASSIC\")\r\n #dim_Time = data_out_nc.createDimension('Time', size_time)\r\n dim_Time = data_out_nc.createDimension('Time', time_size)\r\n dim_RiverID = data_out_nc.createDimension('rivid', size_streamID)\r\n var_m3_riv = data_out_nc.createVariable('m3_riv', 'f4', \r\n ('Time', 'rivid'),\r\n fill_value=0)\r\n \r\n #data_temp = NUM.empty(shape = [size_time, size_streamID])\r\n data_temp = NUM.empty(shape = [time_size, size_streamID])\r\n\r\n lon_ind_all = [int(i) for i in dict_list[self.header_wt[2]]]\r\n lat_ind_all = [int(j) for j in dict_list[self.header_wt[3]]]\r\n\r\n # Obtain a subset of runoff data based on the indices in the weight table\r\n min_lon_ind_all = min(lon_ind_all)\r\n max_lon_ind_all = max(lon_ind_all)\r\n min_lat_ind_all = min(lat_ind_all)\r\n max_lat_ind_all = max(lat_ind_all)\r\n\r\n # self.vars_oi[vars_oi_index][3] = RO; get that variable's 3D structure (time, lat_index, lon_index) ready to reshape into 2D (time, lat_index x lon_index)\r\n data_subset_all = data_in_nc.variables[self.vars_oi[vars_oi_index][3]][:, min_lat_ind_all:max_lat_ind_all+1, min_lon_ind_all:max_lon_ind_all+1]\r\n len_time_subset_all = data_subset_all.shape[0]\r\n len_lat_subset_all = data_subset_all.shape[1]\r\n len_lon_subset_all = data_subset_all.shape[2]\r\n data_subset_all = data_subset_all.reshape(len_time_subset_all, (len_lat_subset_all * len_lon_subset_all))\r\n\r\n # compute new indices based on the data_subset_all\r\n index_new = []\r\n for r in range(0,count-1):\r\n ind_lat_orig = lat_ind_all[r]\r\n ind_lon_orig = lon_ind_all[r]\r\n index_new.append((ind_lat_orig - min_lat_ind_all)*len_lon_subset_all + (ind_lon_orig - min_lon_ind_all))\r\n\r\n # obtain a new subset of data\r\n data_subset_new = data_subset_all[:,index_new]*conversion_factor\r\n\r\n # start compute inflow\r\n pointer = 0\r\n for s in range(0, size_streamID):\r\n npoints = int(dict_list[self.header_wt[4]][pointer])\r\n # Check if all npoints points correspond to the same streamID\r\n if len(set(dict_list[self.header_wt[0]][pointer : (pointer + npoints)])) != 1:\r\n print(\"ROW INDEX {0}\".format(pointer))\r\n print(\"RIVID {0}\".format(dict_list[self.header_wt[0]][pointer]))\r\n raise Exception(self.errorMessages[2])\r\n\r\n area_sqm_npoints = [float(k) for k in dict_list[self.header_wt[1]][pointer : (pointer + npoints)]]\r\n area_sqm_npoints = NUM.array(area_sqm_npoints)\r\n area_sqm_npoints = area_sqm_npoints.reshape(1, npoints)\r\n data_goal = data_subset_new[:, pointer:(pointer + npoints)]\r\n \r\n \r\n #remove noise from data\r\n data_goal[data_goal<=0.00001] = 0\r\n\r\n ''' IMPORTANT NOTE: runoff variable in ECMWF dataset is cumulative instead of incremental through time\r\n '''\r\n # For data with Low Resolution, there's only one time interval 6 hrs\r\n if id_data == \"ENS6\": # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints\r\n elif id_data == \"ENS3\": # there's only one time interval 3 hrs # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\r\n elif id_data == \"HRES1\": # there's only one time interval 1 hrs # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\t\r\n #For data with the full version of Low Resolution, from Hour 0 to 144 (the first 49 time points) are of 3 hr time interval,\r\n # then from Hour 144 to 360 (36 time points) are of 6 hour time interval\r\n elif id_data == \"ENS36\": # Line Added/Modified CJB 20190108\r\n if in_time_interval == \"3hr_subset\":\r\n #use only the 3hr time interval\r\n ro_stream = NUM.subtract(data_goal[1:49,], data_goal[:48,]) * area_sqm_npoints\r\n elif in_time_interval == \"6hr_subset\":\r\n #use only the 6hr time interval\r\n ro_stream = NUM.subtract(data_goal[49:,], data_goal[48:-1,]) * area_sqm_npoints\r\n else: #\"LowRes-6hr\"\r\n ######################################################\r\n # MJS Always assume this case will have a full ECMWF 240\r\n # hour forecast to work with. It's actually never re-\r\n # quested by ecmwf_rapid_multiprocess anyhow.\r\n ######################################################\r\n #convert all to 6hr\r\n # calculate time series of 6 hr data from 3 hr data\r\n ro_6hr_a = NUM.subtract(data_goal[2:49:2,], data_goal[:48:2,])\r\n # get the time series of 6 hr data\r\n ro_6hr_b = NUM.subtract(data_goal[49:,], data_goal[48:-1,])\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b]) * area_sqm_npoints\r\n #For data with High Resolution, from Hour 0 to 90 (the first 91 time points) are of 1 hr time interval,\r\n # then from Hour 90 to 144 (18 time points) are of 3 hour time interval, and from Hour 144 to 240 (16 time points)\r\n # are of 6 hour time interval\r\n ##########################################################\r\n # MJS The following should handle id_data = HRES13 and HRES136\r\n ##########################################################\r\n else:\r\n if in_time_interval == \"1hr\":\r\n #ro_stream = NUM.subtract(data_goal[1:91,],data_goal[:90,]) * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:1+time_size,],data_goal[:time_size,]) * area_sqm_npoints # Line Added/Modified CJB, MJS 20190108\r\n elif in_time_interval == \"3hr\": # MJS HRES 3hr not currently used\r\n # calculate time series of 3 hr data from 1 hr data\r\n ro_3hr_a = NUM.subtract(data_goal[3:91:3,],data_goal[:88:3,])\r\n # get the time series of 3 hr data\r\n #ro_3hr_b = NUM.subtract(data_goal[91:109,], data_goal[90:108,])\r\n ro_3hr_b = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) # MJS modified again; seems no case for this, but just in case later... Line Added/Modified CJB 20190108\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_3hr_a, ro_3hr_b]) * area_sqm_npoints\r\n elif in_time_interval == \"3hr_subset\":\r\n #use only the 3hr time interval\r\n #ro_stream = NUM.subtract(data_goal[91:109,], data_goal[90:108,]) * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) * area_sqm_npoints # MJS modified again; needs to handle HRES13 that might not have complete 3hr set... Line Added/Modified CJB 20190108\r\n elif in_time_interval == \"6hr_subset\":\r\n #use only the 6hr time interval\r\n ro_stream = NUM.subtract(data_goal[109:,], data_goal[108:-1,]) * area_sqm_npoints\r\n ######################################################\r\n # MJS Always assume this case will have a full ECMWF 240 \r\n # hour forecast to work with. It's actually never re-\r\n # quested by ecmwf_rapid_multiprocess anyhow.\r\n ######################################################\r\n else: # in_time_interval == \"6hr\"\r\n #arcpy.AddMessage(\"6hr\")\r\n # calculate time series of 6 hr data from 1 hr data\r\n ro_6hr_a = NUM.subtract(data_goal[6:91:6,], data_goal[:85:6,])\r\n # calculate time series of 6 hr data from 3 hr data\r\n ro_6hr_b = NUM.subtract(data_goal[92:109:2,], data_goal[90:107:2,])\r\n # get the time series of 6 hr data\r\n ro_6hr_c = NUM.subtract(data_goal[109:,], data_goal[108:-1,])\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b, ro_6hr_c]) * area_sqm_npoints\r\n \r\n #remove negative values\r\n ro_stream[ro_stream<0] = 0\r\n data_temp[:,s] = ro_stream.sum(axis = 1)\r\n\r\n pointer += npoints\r\n\r\n\r\n '''Write inflow data'''\r\n print(\"Writing inflow data...\")\r\n var_m3_riv[:] = data_temp\r\n # close the input and output netcdf datasets\r\n data_in_nc.close()\r\n data_out_nc.close()","def check_netcdf_file():\n # check the model file and extract necessary information\n # must be in the argument list\n if NETCDF_FILE_NAME is None:\n print('[ERROR] the netCDF model file name is required', flush=True)\n usage_csv()\n sys.exit(1)\n\n # user may provide full path\n elif os.path.isfile(NETCDF_FILE_NAME):\n model_file_name = NETCDF_FILE_NAME\n base_file_name, ext = os.path.splitext(model_file_name)\n\n # user may place it under the data directory\n elif os.path.isfile(os.path.join(DATA_DIR, NETCDF_FILE_NAME)):\n model_file_name = os.path.join(DATA_DIR, NETCDF_FILE_NAME)\n base_file_name, ext = os.path.splitext(model_file_name)\n\n # could not find the file\n else:\n print('[ERROR] could not find the netCDF model file {}'.format(NETCDF_FILE_NAME), flush=True)\n usage_csv()\n sys.exit(1)\n\n return model_file_name, base_file_name","def F_read_S5P_nc(self,fn,data_fields,data_fields_l2g=[]):\n from netCDF4 import Dataset\n ncid = Dataset(fn,'r')\n outp = {}\n for i in range(len(data_fields)):\n tmp = ncid[data_fields[i]]\n tmpdtype = tmp.dtype\n if not data_fields_l2g:\n varname = tmp.name\n else:\n varname = data_fields_l2g[i]\n if tmpdtype is \"str\":\n outp[varname] = tmp[:]\n else:\n outp[varname] = np.squeeze(tmp[:])\n ## scale factor already applied?! so confusing\n# try:\n# outp[varname] = outp[varname]*tmp.scale_factor\n# if tmp.scale_factor != 1:\n# print(varname+' has a scale_factor of '+'%s'%tmp.scale_factor)\n# except Exception:\n# #print(e)\n# print(varname+' has no scale_factor!')\n if 'time_utc' in outp.keys():\n UTC_matlab_datenum = np.zeros((len(outp['time_utc']),1),dtype=np.float64)\n for i in range(len(outp['time_utc'])):\n tmp = datetime.datetime.strptime(outp['time_utc'][i],'%Y-%m-%dT%H:%M:%S.%fZ')\n UTC_matlab_datenum[i] = (tmp.toordinal()\\\n +tmp.hour/24.\\\n +tmp.minute/1440.\\\n +tmp.second/86400.\\\n +tmp.microsecond/86400/1000000+366.)\n outp['UTC_matlab_datenum'] = np.tile(UTC_matlab_datenum,(1,outp['latc'].shape[1]))\n else: # hcho l2 does not have time_utc\n # the delta_time field of hcho fills all across track position, but ch4 is one per scanline\n if len(outp['delta_time'].shape) == 1:\n outp['delta_time'] = np.tile(outp['delta_time'][...,None],(1,outp['latc'].shape[1]))\n outp['UTC_matlab_datenum'] = (outp['time']+outp['delta_time']/1000.)/86400.+734139.\n \n outp['across_track_position'] = np.tile(np.arange(1.,outp['latc'].shape[1]+1),\\\n (outp['latc'].shape[0],1)).astype(np.int16)\n return outp","def verify_netcdf(extents_dir, out_ncfile):\n netcdf_old=out_ncfile #'/g/data/fk4/wofs/water_f7q/extents/149_-036/LS_WATER_149_-036_1987-05-22T23-08-20.154_2014-03-28T23-47-03.171.nc'\n\n tiles = [make_tileinfo(filename) for filename in glob(os.path.join(extents_dir, '*.tif'))]\n tiles.sort(key=lambda t: t.datetime)\n\n with netCDF4.Dataset(netcdf_old) as nco:\n for i in range(0,len(tiles)):\n print nco['time'][i]\n print tiles[i]\n with rasterio.open(tiles[i].filename) as tile_data:\n print \"Any difference? \" \n print numpy.sum(nco['Data'][:,:,i])\n print numpy.sum(tile_data.read(1))\n\n print type(nco['Data'][:,:,i]), type(tile_data.read(1))\n print nco['Data'][:,:,i].shape, tile_data.read(1).shape\n \n print numpy.sum(nco['Data'][:,:,i] - tile_data.read(1)[:,:])\n #print tile_data.read(1)[0:100,0:100] \n\n #print (nco['Data'][:,:,i] == tile_data.read(1)).all()","def is_valid_netcdf_file(nc_data):\n fname = Path(nc_data.filepath()).name\n \n start_str = fname.split(\"_\")[3][1:-1]\n start_fname = dt.datetime.strptime(\n start_str + \" UTC\",\n \"%Y%j%H%M%S %Z\",\n )\n start_fname = start_fname.replace(tzinfo=dt.timezone.utc)\n end_str = fname.split(\"_\")[4][1:-1]\n end_fname = dt.datetime.strptime(end_str + \" UTC\", \"%Y%j%H%M%S %Z\")\n end_fname = end_fname.replace(tzinfo=dt.timezone.utc)\n \n avg_fname = start_fname + (end_fname - start_fname) / 2\n \n vtime = get_valid_time(nc_data)\n if vtime is None:\n return False\n \n diff = (avg_fname - vtime).total_seconds()\n \n if diff > 60:\n return False\n \n return True","def write_netcdf(ncinfo):\r\n\t# ========== Create new netcdf ==========\r\n\tNAME=nc.netcdf_file(ncinfo.fname,'w')\r\n\t\r\n\t# ========== Set up the Dimensions ==========\r\n\tNAME.createDimension('time', None) #Question: Shouldn't time be unlimited?\r\n\t# NAME.createDimension('lev',11)\r\n\tNAME.createDimension('lat',ncinfo.lat)\r\n\tNAME.createDimension('lon',ncinfo.lon)\r\n\t\r\n\t# ========== Setup the Variables ==========\r\n\ttime=NAME.createVariable('time',np.float64,('time',))\r\n\t# lev=NAME.createVariable('lev',np.int32,('lev',))\r\n\tlat=NAME.createVariable('lat',np.float64,('lat',))\r\n\tlon=NAME.createVariable('lon',np.float64,('lon',))\r\n\t# VAR=NAME.createVariable(str(VAR),np.float64,('time','lev','lat','lon'),)\r\n\tVAR=NAME.createVariable(ncinfo.var_name,np.float64,('time','lat','lon'),)\r\n\t# setting the missing value is super important for the file to be cdo readable\r\n\tsetattr(VAR,'missing_value',ncinfo.fill)\r\n\tsetattr(VAR, 'standard_name', ncinfo.var_lname) \r\n\t\r\n\t# ========== Set the units ==========\r\n\ttime.units= 'day as %Y%m%d'\r\n\t# lev.units = '-'\r\n\tlat.units = 'degrees_north'\r\n\tlon.units = 'degrees_east'\r\n\tVAR.units = ncinfo.units\r\n\r\n\t# ========== Add data ==========\r\n\t\r\n\t# creates time vector using the date_range function\r\n\t# time[:]=[t for t in date_range('20110101.5','20111231.5')] \r\n\t# lev[:]=PFT_vector\r\n\tlat[:] = ncinfo.latitudes\r\n\tlon[:] = ncinfo.longitudes\r\n\t# THis is a Bodge for singe variable data\r\n\tVAR[:] = ncinfo.data\r\n\r\n\t#Add global attributes\r\n\tNAME.description = ncinfo.description\r\n\tNAME.history = ncinfo.history\r\n\r\n\t# WHATS MISSING\r\n\t# metadata a whole bunch of metadata\r\n\t# the standard_name and long_name of the variables\r\n\r\n\t# ========== Close the netcdf ==========\r\n\tNAME.close()","def cl_file(tmp_path):\n nc_path = os.path.join(tmp_path, 'cesm2_waccm_cl.nc')\n dataset = Dataset(nc_path, mode='w')\n dataset.createDimension('lev', size=2)\n dataset.createDimension('bnds', size=2)\n\n # Dimensional variables\n dataset.createVariable('lev', np.float64, dimensions=('lev',))\n dataset.createVariable('lev_bnds', np.float64, dimensions=('lev', 'bnds'))\n dataset.variables['lev'][:] = [1.0, 2.0]\n dataset.variables['lev'].bounds = 'lev_bnds'\n dataset.variables['lev'].units = '1'\n dataset.variables['lev_bnds'][:] = [[0.5, 1.5], [1.5, 3.0]]\n dataset.variables['lev_bnds'].standard_name = (\n 'atmosphere_hybrid_sigma_pressure_coordinate')\n dataset.variables['lev_bnds'].units = '1'\n dataset.variables['lev_bnds'].formula_terms = (\n 'p0: p0 a: a_bnds b: b_bnds ps: ps')\n\n # Coordinates for derivation of pressure coordinate\n dataset.createVariable('a', np.float64, dimensions=('lev',))\n dataset.createVariable('a_bnds', np.float64, dimensions=('lev', 'bnds'))\n dataset.createVariable('b', np.float64, dimensions=('lev',))\n dataset.createVariable('b_bnds', np.float64, dimensions=('lev', 'bnds'))\n dataset.variables['a'][:] = [1.0, 2.0]\n dataset.variables['a'].bounds = 'a_bnds'\n dataset.variables['a_bnds'][:] = [[1.5, 0.0], [3.0, 1.5]]\n dataset.variables['b'][:] = [0.0, 1.0]\n dataset.variables['b'].bounds = 'b_bnds'\n dataset.variables['b_bnds'][:] = [[0.5, -1.0], [2.0, 0.5]]\n\n dataset.close()\n return nc_path","def repair_netcdf(fname):\n\n\t# ========== Set the path and the file name ==========\n\t# fname = \"%s_%s_%s_r1i1p1_%s_1950_2050_%s_regrid.nc\" %(var, model, sen, units, sen)\n\tfout = \"%s_setgrid\" % (fname)\n\n\t\n\t# ========== Create a list of files to cleanup ==========\n\tcleanup = []\n\n\t# ========== Check if the file exists ==========\n\tif not os.path.isfile(fname+\".nc\"):\n\t\t# check if the file exists with a different name\n\t\traise IOError(\"WARNING: The file %s cannot be found\"% fname)\n\n\t\n\t# ========== Read longitude from NC file ==========\n\tfh = Dataset(fname+\".nc\", mode='r')\n\ttry:\n\t\tlon = fh.variables['longitude'][:]\n\texcept:\n\t\ttry:\n\t\t\tlon = fh.variables['lon'][:]\n\t\texcept:\n\t\t\tlon = fh.variables['easting'][:] #easting\n\n\n\n\n\t# ========== Create a new grid ==========\n\t# Save the current grid\n\tsubp.call(\"cdo griddes %s.nc > %sGriddes\" % (fname, fname), shell=True)\n\t# add the griddes to the cleanup \n\tcleanup.append(\"%sGriddes\" % fname)\n\n\t# open the current grid\n\tgfile = open(\"%sGriddes\" % fname, \"r\") \n\t# Split the lines of the grid file\n\tginfo = gfile.read().splitlines()\n\t\n\t#Some models have no lat/lon bounds, skip in this case and copy\n\t#\"regrid\" file as \"setgrid\"\n\tif not (any([n.startswith(\"xbounds\") for n in ginfo]) and \n\t\t any([n.startswith(\"ybounds\") for n in ginfo])):\n\t\tsubp.call(\"cp %s.nc %s.nc\" % (fname, fout), shell=True)\n\t\tcleanup.append(\"%s.nc\" % fname)\n\t\treturn cleanup\t\n\t\n\t# Check and see if the start is known\n\tif (\n\t\tany([n.startswith(\"xfirst\") for n in ginfo])\n\t\t) and (\n\t\tany([n.startswith(\"xinc\") for n in ginfo])\n\t\t):\n\t\taddxdet = False\n\t\t# Set the lines to be removed\n\t\tbadel = [\"xvals\", \"yvals\", \" \", \"xbounds\", \"ybounds\"]\n\telse:\n\t\taddxdet = True\n\t\t# Set the lines to be removed\n\t\tbadel = [\"xvals\", \"yvals\", \" \", \"xbounds\", \"ybounds\", \"xfirst\", \"xinc\"]\n\n\t# Create list to hold the new grid details\n\tnew_grid = []\n\n\tfor ginf in ginfo:\n\t\ttest = []\n\t\tfor be in badel:\n\t\t\tif ginf.startswith(be):\n\t\t\t\ttest.append(False)\n\t\t\telif ginf == \"#\":\n\t\t\t\ttest.append(False)\n\t\t\telse:\n\t\t\t\ttest.append(True)\n\t\t\n\t\tif all(test):\n\t\t\tnew_grid.append(ginf)\n\t# Add the additional x variables\n\tif addxdet:\n\t\t# work out the model from the fname\n\t\tmodel = fname.split(\"/\")[-2]\n\t\tnew_grid.append('xfirst = -180')\n\t\tnew_grid.append('xinc = %s' % str(\n\t\t\tfloat(lon) ))\n\t\n\n\t# Check the y values, if they are missing use the ones in the original grid file\n\tif not (any([n.startswith(\"yfirst\") for n in ginfo])):\n\t\t# print (\"Seting the y bounds\")\n\t\tvals = []\n\t\tfor glov in range(0,len(ginfo)):\n\t\t\tif ginfo[glov].startswith(\"yvals\"):\n\t\t\t\tvals.append(glov)\n\t\t\telif ginfo[glov].startswith(\"ybounds\"):\n\t\t\t\tvals.append(glov)\n\t\tif len (vals) == 2:\n\t\t\tfor yv in ginfo[vals[0]:vals[1]]:\n\t\t\t\tnew_grid.append(yv)\n\n\t\telse:\n\t\t\tprint(\"\\n\")\n\t\t\traise IndexError(\"Bounding is incorrect\")\n\n\t# Save the grid out\n\tnewgrid = save_grid(fname, new_grid)\n\tcleanup.append(newgrid)\n\n\t# ========== Set the new grid file ==========\n\t# Save the current grid\n\tsubp.call(\"cdo setgrid,%sGridFix %s.nc %s.nc\" % (fname, fname, fout), shell=True)\n\t\n\tif not os.path.isfile(\"%s.nc\" % fout):\n\t\traise IOError(\"The output file was not created, going interactive\")\n\t\n\t# ========== return the files to be removed ==========\n\tcleanup.append(\"%s.nc\" % fname)\n\treturn cleanup","def testCC(self):\n self.assertEqual(\n self.cc,\n self.ccr.cc\n )\n\n self.assertEqual(\n None,\n self.ccr_bad.cc\n )","def _validate_raw_nc(self):\r\n\r\n self.raw_nc_list = []\r\n total_time_len = 1 #add one for the first flow value RAPID\r\n #does not include\r\n id_len_list = []\r\n for rapid_output_file in self.rapid_output_file_list:\r\n qout_nc = RAPIDDataset(rapid_output_file)\r\n id_len_list.append(qout_nc.size_river_id)\r\n total_time_len += qout_nc.size_time\r\n self.raw_nc_list.append(qout_nc)\r\n \r\n #make sure river id lists are the same\r\n for id_len_undex in range(1, len(id_len_list)):\r\n if id_len_list[id_len_undex] != id_len_list[0]:\r\n raise Exception(\"ERROR: River ID size is different in one of the files ...\")\r\n \r\n for raw_nc_index in range(1, len(self.raw_nc_list)):\r\n if not (self.raw_nc_list[raw_nc_index].get_river_id_array() == self.raw_nc_list[0].get_river_id_array()).all():\r\n raise Exception(\"ERROR: River IDs are different in files ...\")\r\n\r\n return id_len_list[0], total_time_len","def processData(self,data):\n #print 'I GOT DATA',data,[0],data[1]\n # Check for valid data (not null or empty string)\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0])\n if data:\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0]),_RobotCommunicator.WALL_HEADER==data[0]\n\n # Check header and assign data appropriately\n # TODO: Check length of data for validity\n #print 'Header',data[0]\n if data[0] == _RobotCommunicator.POSE_HEADER:\n self.pose = unpack(_RobotCommunicator.POSE_FORMAT,data[1:])\n elif data[0] == _RobotCommunicator.SENSOR_HEADER:\n\n #for i in range(1, len(data)-1, 2):\n index= unpack('B',data[1])\n value = unpack('?',data[2])\n # Update old values or create new sensor-value pair\n self.sensors[index[0]] = value[0]\n #print 'in csharp: ',[index,value]\n\n elif data[0] == _RobotCommunicator.WAYPOINT_HEADER:\n self.waypoints = [] # Clear old waypoints\n for i in range(1, len(data)-16, 16):\n x,y = unpack(_RobotCommunicator.WAYPOINT_FORMAT,\n data[i:i+15])\n self.waypoints.append((x,y))\n elif data[0] == _RobotCommunicator.DIRECTION_HEADER:\n self.direction = unpack(_RobotCommunicator.DIRECTION_FORMAT,\n data[1:])\n elif data[0] == _RobotCommunicator.ACTUATOR_HEADER:\n self.actuators = [] # Clear old actuator commands for i in range(1, len(data)-1):\n self.actuators.append(unpack(\n _RobotCommunicator.ACTUATOR_FORMAT,data[i]))\n elif data[0] == _RobotCommunicator.WALL_HEADER:\n self.walls = {} # Clear old wall entries\n index = unpack('B', data[1])\n x1,y1,x2,y2 = unpack(_RobotCommunicator.WALL_FORMAT,data[2:34])\n self.walls = (x1,y1,x2,y2)\n #print '**************Coordinates***************',(x1,y1,x2,y2)\n print '****self.walls*********',self.walls\n elif data[0] == _RobotCommunicator.OBS_HEADER:\n index = unpack('B', data[1])\n add,x1,y1 = unpack(_RobotCommunicator.OBS_FORMAT,data[2:26])\n #print '***********self.obs*************'+','.join(map(str,[add,x1,y1]))\n self.obs = [add,x1,round(y1,2)]\n if add == 1:\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\n a.shift(x1,y1)\n self.obsPoly += a\n self.receiveObs = True\n #print \"add obstacle:\" + str(x1) + \",\"+ str(y1)\n elif add == 4:\n if x1 == 0:\n self.STOP = True\n else:\n self.STOP = False\n else:\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\n a.shift(x1,y1)\n self.obsPoly -= a\n self.receiveObs = True\n #print \"del obstacle:\"+ str(x1) + \",\"+ str(y1)\n\n\n else:\n print \"Unexpected or corrupted data packet received.\"","def Save2Nc(self):\r\n\r\n frameNumber = self.spinBox_FrameNum.value()\r\n\r\n segmentNumber = self.spinBox_SegmentNum.value()\r\n\r\n exposeTime = self.spinBox_ExpTime.value()\r\n width = self.spinBox_Width.value()\r\n xshift = self.spinBox_XShift.value()\r\n hight = self.spinBox_Hight.value()\r\n yshift = self.spinBox_Yshift.value()\r\n\r\n print(\"frameNumber, segmentNumber, width, high is: \", frameNumber, segmentNumber, width, hight)\r\n app = ReadData(noteObj = self.textBrowser_SetMeasureInf, frameNumber=frameNumber, segmentFrame=segmentNumber, width=width, hight=hight)\r\n self.multiFrameData = app.ImageData()\r\n\r\n options = QFileDialog.Options()\r\n options |= QFileDialog.DontUseNativeDialog\r\n # it just provides the name of file that you want to write into\r\n fileName, _= QFileDialog.getSaveFileName(self,\"QFileDialog.getSaveFileName()\",\"\",\"All Files (*);;NC Files (*.nc)\", options=options)\r\n \r\n if fileName:\r\n print(fileName)\r\n\r\n self.multiFrameData.to_netcdf(fileName + '.nc')\r\n self.textBrowser_SetMeasureInf.setTextColor(QtCore.Qt.green)\r\n self.textBrowser_SetMeasureInf.append(\"the data has saved as .nc file! \")","def check_Data(self):\r\n \r\n if self._target_data is None:\r\n self.processData()","def test_noDuplicateCTCPDispatch(self):\n\n def testCTCP(user, channel, data):\n self.called += 1\n\n self.called = 0\n self.client.ctcpQuery_TESTTHIS = testCTCP\n\n self.client.irc_PRIVMSG(\n \"foo!bar@baz.quux\",\n [\"#chan\", \"{X}TESTTHIS{X}foo{X}TESTTHIS{X}\".format(X=irc.X_DELIM)],\n )\n self.assertEqualBufferValue(self.file.getvalue(), \"\")\n self.assertEqual(self.called, 1)","def test_set_circulationdata_errors(self):\n provider = AlwaysSuccessfulCollectionCoverageProvider(\n self._default_collection\n )\n identifier = self._identifier()\n\n # No data.\n failure = provider._set_circulationdata(identifier, None)\n assert (\"Did not receive circulationdata from input source\" ==\n failure.exception)\n\n # No identifier in CirculationData.\n empty = CirculationData(provider.data_source, primary_identifier=None)\n failure = provider._set_circulationdata(identifier, empty)\n assert (\"Identifier did not match CirculationData's primary identifier.\" ==\n failure.exception)\n\n # Mismatched identifier in CirculationData.\n wrong = CirculationData(provider.data_source,\n primary_identifier=self._identifier())\n failure = provider._set_circulationdata(identifier, empty)\n assert (\"Identifier did not match CirculationData's primary identifier.\" ==\n failure.exception)\n\n # Here, the data is okay, but the ReplacementPolicy is\n # going to cause an error the first time we try to use it.\n correct = CirculationData(provider.data_source,\n identifier)\n provider.replacement_policy = object()\n failure = provider._set_circulationdata(identifier, correct)\n assert isinstance(failure, CoverageFailure)\n\n # Verify that the general error handling works whether or not\n # the provider is associated with a Collection.\n provider.collection_id = None\n failure = provider._set_circulationdata(identifier, correct)\n assert isinstance(failure, CoverageFailure)","def cdf_to_nc(cdf_filename):\n\n # Load raw .cdf data\n ds = xr.load_dataset(cdf_filename)\n\n # create burst num variable\n ds = burst_num(ds)\n\n # Clip data to in/out water times or via good_ens\n ds = utils.clip_ds(ds)\n\n # Trim data when instrument is out of water during a deployment and extra bins if good_bins specified\n if \"bins\" in ds:\n ds = trim_alt(ds)\n else:\n ds = trim_alt(ds, data_vars=[\"Altitude_m\", \"AmplitudeFS\", \"Temperature_C\"])\n\n # calculate bin height for profiling echologger (i.e. type == ea)\n if \"bins\" in ds:\n ds = calc_bin_height(ds)\n\n # calculate corrected altitude (distance to bed/b_range) with adjusted sound speed\n ds = calc_cor_brange(ds)\n\n # calculate corrected bin height (on NAVD88 datum) with adjusted sound speed\n if \"bins\" in ds:\n ds = calc_cor_bin_height(ds)\n\n ds = calc_seabed_elev(ds)\n\n # if \"bins\" in ds:\n # ds = utils.create_z_bindist(ds) #create z for profile\n # else:\n ds = utils.create_z(ds)\n\n # swap bin dim with bin_height\n ds = ds_swap_dims(ds) # swap vert dim to z\n\n # rename variables\n ds = ds_rename_vars(ds)\n\n # drop some vars after renaming\n for k in [\n \"bins\",\n \"ping\",\n \"ping_num_in_series\",\n \"Altitude_m\",\n \"Battery_mV\",\n ]:\n if k in ds:\n ds = ds.drop_vars(k)\n\n # add lat/lons as coordinates\n ds = utils.ds_add_lat_lon(ds)\n\n # add attributes to each variable\n ds = ds_add_attrs(ds)\n\n # add metadata to global atts\n ds = utils.add_start_stop_time(ds)\n ds = utils.add_delta_t(ds)\n\n # Write to .nc file\n print(\"Writing cleaned/trimmed burst data and averaged burst data to .nc file\")\n nc_filename = ds.attrs[\"filename\"] + \"b-cal.nc\"\n\n ds.to_netcdf(\n nc_filename, unlimited_dims=[\"time\"], encoding={\"time\": {\"dtype\": \"i4\"}}\n )\n print(\"Done writing netCDF file\", nc_filename)\n\n # Average busrt and write to -a.nc file\n ds = average_burst(ds)\n\n for var in ds.data_vars:\n # do any diff trimming first\n ds = qaqc.trim_min_diff(ds, var)\n ds = qaqc.trim_min_diff_pct(ds, var)\n ds = qaqc.trim_max_diff(ds, var)\n ds = qaqc.trim_max_diff_pct(ds, var)\n ds = qaqc.trim_med_diff(ds, var)\n ds = qaqc.trim_med_diff_pct(ds, var)\n ds = qaqc.trim_maxabs_diff_2d(ds, var)\n ds = qaqc.trim_maxabs_diff(ds, var)\n # then do other trimming\n ds = qaqc.trim_bad_ens(ds, var)\n ds = qaqc.trim_min(ds, var)\n ds = qaqc.trim_max(ds, var)\n ds = aqdutils.trim_single_bins(ds, var)\n ds = qaqc.trim_fliers(ds, var)\n\n # after check for masking vars by others\n for var in ds.data_vars:\n ds = qaqc.trim_mask(ds, var)\n\n # assign min/max\n ds = utils.add_min_max(ds)\n\n ds = utils.ds_coord_no_fillvalue(ds)\n\n nc_filename = ds.attrs[\"filename\"] + \"-a.nc\"\n\n # ds['time']=ds['time'].astype('datetime64[s]')\n ds.to_netcdf(\n nc_filename, unlimited_dims=[\"time\"], encoding={\"time\": {\"dtype\": \"i4\"}}\n )\n\n utils.check_compliance(nc_filename, conventions=ds.attrs[\"Conventions\"])\n\n print(\"Done writing burst averaged netCDF file\", nc_filename)\n\n return ds","def testCCHalt(self):\n cdl_convert.config.HALT_ON_ERROR = True\n\n def getCC():\n self.ccr_bad.cc\n\n self.assertRaises(\n ValueError,\n getCC\n )","def load_data():\n\t\t# load the data\n\t\tDATPATH = \"../data/\"\n\t\t#fnino = DATPATH + \"nino3.csv\" # 1871-2000\n\t\tfnino = DATPATH + \"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\" # 1871-2016\n\t\t#fnino = DATPATH + \"nino34.long.data\"\n\t\t#nc_data_nino3 = netCDF4.Dataset(fnino)\n\t\t#nino3_load = nc_data_nino3.variables['tas'][:]\n\t\t#dnino = nino3_load.flatten()\n\n\t\tdnino = np.genfromtxt(fnino, delimiter=\",\", dtype=float).flatten()\n\t\t#fismr = DATPATH + \"ismr.csv\" # 1871-2000\n\t\t#fismr = DATPATH + \"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\" # 1871-2016\n\t\tfismr = DATPATH + \"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\" # 1871-2016\n\t\tdismr = np.genfromtxt(fismr, delimiter=\",\", dtype=float).flatten()\n\t\t#fvolc = DATPATH + \"robock.txt\" # 1871-2000\n\t\tfvolc = DATPATH + \"sigl.txt\" # 1871-2016\n\t\tdvolc = np.genfromtxt(fvolc, delimiter=\",\", dtype=float).flatten()\n\n\t\tfvolc_source = DATPATH + \"volc_source_850_1850.csv\" # 1871-2016\n\t\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\",\", dtype=float).flatten()\n\t\t# simple check for data consistency\n\t\tassert dnino.shape == dismr.shape, \"Data sets are unequal!\"\n\t\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \"Data sets are unequal\"\n\t\treturn dnino, dismr, dvolc, dvolc_source","def createNCDF(self):\n\n rootgrp = Dataset(self.filename_out, 'w', format=self.format, clobber=True)\n\n # Create dimensions.\n if 'dimensions' in self.input_dict:\n for k, v in self.input_dict['dimensions'].items():\n rootgrp.createDimension(k, v)\n else:\n if not self.Quiet:\n print('No netCDF created:')\n print(' No dimension key found (!! has to be \\\"dimensions\\\"!!!)')\n return()\n\n # Create global attributes.\n if 'global attributes' in self.input_dict:\n for k, v in self.input_dict['global attributes'].items():\n rootgrp.setncattr(k, v)\n else:\n if not self.Quiet:\n print(' No global attribute key found (!! has to be \\\"global attributes\\\"!!!)')\n\n # Create variables.\n for k, v in self.input_dict['variables'].items():\n dims = self.input_dict['variables'][k]['dimensions']\n data = v['data']\n # Create correct data type if provided\n if 'data_type' in self.input_dict['variables'][k]:\n data_type = self.input_dict['variables'][k]['data_type']\n else:\n data_type = 'f4'\n # Check whether we've been given a fill value.\n if 'fill_value' in self.input_dict['variables'][k]:\n fill_value = self.input_dict['variables'][k]['fill_value']\n else:\n fill_value = None\n # Create ncdf variable\n if not self.Quiet:\n print(' Creating variable: {} {} {}'.format(k, data_type, dims))\n var = rootgrp.createVariable(k, data_type, dims, fill_value=fill_value)\n if len(dims) > np.ndim(data):\n # If number of dimensions given to netCDF is greater than the\n # number of dimension of the data, then fill the netCDF\n # variable accordingly.\n if 'time' in dims:\n # Check for presence of time dimension (which can be\n # unlimited variable: defined by None).\n try:\n var[:] = data\n except IndexError:\n raise(IndexError(('Supplied data shape {} does not match the specified'\n ' dimensions {}, for variable \\'{}\\'.'.format(data.shape, var.shape, k))))\n else:\n if not self.Quiet:\n print('Problem in the number of dimensions')\n else:\n try:\n var[:] = data\n except IndexError:\n raise(IndexError(('Supplied data shape {} does not match the specified'\n ' dimensions {}, for variable \\'{}\\'.'.format(data.shape, var.shape, k))))\n\n # Create attributes for variables\n if 'attributes' in self.input_dict['variables'][k]:\n for ka, va in self.input_dict['variables'][k]['attributes'].items():\n var.setncattr(ka, va)\n\n rootgrp.close()","def test_save_as_netcdf(self):\n target_dims = self.target.dimensions\n expected_target_dims = [(u'MMAXZ', 4), \n (u'NMAXZ', 4), \n (u'MMAX', 4), \n (u'NMAX', 4), \n (u'KMAX', 2), \n (u'KMAX1', 3), \n (u'time', 2)\n ]\n target_vars = self.target.variables\n expected_target_vars = [u'XZ',\n u'YZ',\n u'XCOR',\n u'YCOR',\n u'grid',\n u'U1',\n u'FAKE_U1',\n u'V1',\n u'W',\n u'FAKE_W',\n u'time',\n u'latitude',\n u'longitude',\n u'grid_latitude',\n u'grid_longitude'\n ]\n target_grid_vars = self.target.grid_variables\n expected_target_grid_vars = [u'U1',\n u'FAKE_U1',\n u'V1',\n u'W',\n u'FAKE_W'\n ]\n target_face_coordinates = self.target.face_coordinates\n expected_target_face_coordinates = (u'XZ', u'YZ')\n self.assertIsInstance(self.target, SGrid2D)\n self.assertEqual(len(target_dims), len(expected_target_dims))\n self.assertEqual(set(target_dims), set(expected_target_dims))\n self.assertEqual(len(target_vars), len(expected_target_vars))\n self.assertEqual(set(target_vars), set(expected_target_vars))\n self.assertEqual(len(target_grid_vars), len(expected_target_grid_vars))\n self.assertEqual(set(target_grid_vars), set(expected_target_grid_vars))\n self.assertEqual(target_face_coordinates, expected_target_face_coordinates)","def prepare_val_coco_data(args):\n image_dir, annotation_file = args.val_coco_image_dir, args.val_coco_annotation_file\n\n coco = COCO(annotation_file)\n\n img_ids = list(coco.imgToAnns.keys())\n img_files = []\n img_heights = []\n img_widths = []\n\n for img_id in img_ids:\n img_files.append(os.path.join(image_dir, coco.imgs[img_id]['file_name']))\n img_heights.append(coco.imgs[img_id]['height']) \n img_widths.append(coco.imgs[img_id]['width']) \n\n print(\"Building the validation dataset...\")\n dataset = DataSet(img_ids, img_files, img_heights, img_widths)\n print(\"Dataset built.\")\n return coco, dataset","def initialize_data(self , station = '', datasets = {} ):\n \n self.datasets = datasets\n self.datasets_keys = datasets.keys()\n self.station = station\n \n data = {} # container for the data of each dataset\n source_configuration = {} # container for the source_configuration of each dataset\n \n\n \n \"\"\" Looping over the datasets \"\"\"\n logging.info('*** Reading and Initializing the data from the netCDF files ')\n \n \n for k,v in datasets.items() :\n logging.info(' Initialising the dataset: *** %s ' , k )\n data[k] = {} \n data['cdm_tables'] = {} \n \n ### alternative with xarray \n #ds = xr.load_dataset(v) \n #observations_table = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \n \n ### alternative with netCDF4\n #ds = nc.Dataset(v) \n #data[k]['dateindex'] = ds.variables['dateindex'][0,:] # storing the dateindex \n \n ###for h5py but cant extract date time units !!!\n ds = h5py.File(v , driver=\"core\" ) \n data[k]['df'] = ds # storing the entire file \n try: \n data[k]['source_file'] = ds['source_configuration']['source_file'][0]\n except:\n data[k]['source_file'] = str(v) # temp fix \n \n #data[k]['product_code'] = ds['source_configuration']['product_code'][0] \n #data[k]['recordtimestamp'] = ds['recordtimestamp'].value\n #data[k]['recordindex'] = ds['recordindex'].value \n #ds.close() \n logging.debug('Reading the file with h5py ')\n \n \n # add here appending datasets for the case of ncar_w and ncar_t \n \n \n self.data = data\n self.make_dataframe()\n ds.close()\n \n \"\"\" Reading the header_table, station_configuration, source_configuration \"\"\"\n for k,v in datasets.items() : \n \n #d = xr.open_dataset(v , engine = 'h5netcdf' ) \n #data[k]['recordtimestamp'] = d['recordtimestamp'].values\n #data[k]['recordindex'] = d['recordindex'].values \n \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'station_configuration') \n data[k]['station_configuration'] = d.to_dataframe() \n #data[k]['station_configuration'] = d ### USELESS ? \n logging.debug('Done with %s station_configuration' , str(k) )\n \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'header_table') \n logging.debug('Loading the header_table') \n if 'header_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\n self.attributes['header_table'] = {}\n for var in d.variables:\n self.attributes['header_table'][var] = {}\n self.attributes['header_table'][var]['description'] = d[var].description\n self.attributes['header_table'][var]['external_table'] = d[var].external_table \n data[k]['header_table'] = d.to_dataframe() \n logging.debug('Done with %s ' , k )\n \n logging.info(\"*** Loading the observations_table (might take time) %s\" , k ) \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \n \n if 'observations_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\n self.attributes['observations_table'] = {}\n for var in d.variables:\n self.attributes['observations_table'][var] = {}\n self.attributes['observations_table'][var]['description'] = d[var].description\n self.attributes['observations_table'][var]['external_table'] = d[var].external_table\n \n \n logging.info(\"*** Loading the source configuration %s\" , k ) \n try: \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'source_configuration')\n d = d.isel(hdrlen=[0])\n data[k]['source_configuration'] = d.to_dataframe() ### USELESS ? \n logging.debug('Done with %s source_configuration' , k )\n except: \n data[k]['source_configuration']= pd.DataFrame(np.array( [ [ self.data[k]['source_file'] ] ] ) , columns=['source_file'] ) \n \n if k == 'era5_1': # reading the whole era5_1 feedback (including reanalysis)\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'era5fb') \n data[k]['era5fb'] = d.to_dataframe() \n logging.debug('Done with %s era5 feedback ', k )\n \n \"\"\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \"\"\" \n if list(datasets.keys()).index(k) == 0 :\n for t in [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type']: \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = t) \n #data['cdm_tables'][t] = d.to_dataframe() ### USELESS ?\n data['cdm_tables'][t] = d \n \n d.close() \n ds.close()\n\n \"\"\" Reading the name of the original source file \"\"\"\n source_configuration[k] = {} \n source_configuration[k]['source_file'] = [ c for c in v.split('/') if '.nc' in c][0]\n\n \n \"\"\" Storing the station configurations \"\"\" \n self.source_configuration = source_configuration \n \n \"\"\" Making all date_times \"\"\" \n self.make_all_datetime()\n \n \n \"\"\" feedback columns \"\"\"\n if 'era5_1' in list (self.data.keys() ):\n self.fb_columns = list(self.data['era5_1']['era5fb'].columns ) \n else:\n self.fb_columns = ['empty']","def createncfile(dz_id,t,x,z):\n db = labdb.LabDB()\n #create the directory in which to store the nc file\n sql = \"\"\"INSERT into dn2t (dz_id) VALUES (%d)\"\"\" % (dz_id) \n db.execute(sql)\n sql = \"\"\"SELECT LAST_INSERT_ID()\"\"\" \n rows = db.execute(sql)\n dn2t_id = rows[0][0]\n dn2t_path = \"/Volumes/HD4/dn2t/%d\" % dn2t_id \n os.mkdir(dn2t_path)\n\n dn2t_filename = os.path.join(dn2t_path,\"dn2t.nc\")\n print(\"d(N2)/dt filename : \",dn2t_filename)\n\n\n # Declare the nc file for the first time\n nc = netCDF4.Dataset(dn2t_filename,'w',format = 'NETCDF4')\n row_dim = nc.createDimension('row',964)\n col_dim = nc.createDimension('column',1292)\n lenT=t.shape[0] #lenT is the length of the dn2t file.Its 1 element shorter in time axis than deltaN2\n print(\"time axis length\",lenT) # debug info\n t_dim = nc.createDimension('time',lenT)\n\n # Dimensions are also variable\n ROW = nc.createVariable('row',numpy.float32,('row'))\n print(list(nc.dimensions.keys()), ROW.shape,ROW.dtype)\n COLUMN = nc.createVariable('column',numpy.float32,('column'))\n print(list(nc.dimensions.keys()) , COLUMN.shape, COLUMN.dtype)\n TIME = nc.createVariable('time',numpy.float32,('time'))\n print(list(nc.dimensions.keys()) ,TIME.shape, TIME.dtype)\n\n # declare the 3D data variable \n dn2t = nc.createVariable('dn2t_array',numpy.float32,('time','row','column'))\n print(list(nc.dimensions.keys()) ,dn2t.shape,dn2t.dtype)\n\n # assign the values\n TIME[:] = t\n ROW[:] = z\n COLUMN[:] = x\n\n nc.close()\n db.commit()\n return dn2t_id,dn2t_filename","def decomptcperrlessdata(self) :\n\t\ttry :\n\t\t\treturn self._decomptcperrlessdata\n\t\texcept Exception as e:\n\t\t\traise e","def create_netcdf(self):\n\n # NetCDF file and global attributes\n file_name = self.output_dir / f\"{author.replace(' ', '_').lower()}_{self.sos_file.split('_')[0]}.nc\"\n ds = Dataset(file_name, 'w')\n ds.author = self.author\n ds.contact = self.email\n ds.sos_file = self.sos_file\n ds.production_date = datetime.now().strftime('%d-%b-%Y %H:%M:%S')\n\n # Groups\n for source in self.priors_dict.keys():\n # Check if the group has data\n if self.priors_dict[source]:\n # Create groups for each prior and populate with data\n for prior, data in self.priors_dict[source].items():\n # Group\n g = ds.createGroup(f\"{source}_{prior}\")\n\n # Attribute\n g.run_type = data[\"run_type\"]\n\n # Dimensions\n if \"reach_ids\" in data.keys(): \n self.create_dimensions(source, g, num_reaches=len(data[\"reach_ids\"]))\n else:\n self.create_dimensions(source, g, num_nodes=len(data[\"node_ids\"]))\n\n # Variables\n self.create_variables(source, prior, data, g)\n\n # Close dataset file\n ds.close()","def _check_data(data):\n if not (data.dtype == _np.float32 and data.flags.c_contiguous):\n raise ValueError('supplied data must be float32 and C contiguous')\n if data.ndim == 2:\n num_frames, channels = data.shape\n elif data.ndim == 1:\n num_frames, channels = data.size, 1\n else:\n raise ValueError('rank > 2 not supported')\n return num_frames, channels","def to_netcdf(self, outfile):","def test_cl_fix_data(cl_cube):\n fix = Cl(None)\n out_cube = fix.fix_data(cl_cube)\n assert out_cube.data == [100.0]","def test_simple(self):\n with self.subTest(\"from np array\"):\n data = np.random.rand(10, 4)\n mask = np.ones((10, 4))\n channels = [\"a\", \"b\", \"c\", \"d\"]\n fcs.FCSData((data, mask), channels=channels)","def data_fetch_netcdf(self):\n self.client = boto3.client('s3', aws_access_key_id=self.creds_data['key_id'],\n aws_secret_access_key=self.creds_data['key_access'])\n year = self.month_year[0]\n month = self.month_year[1]\n # change output folder to desired location from TRMM website\n # folder structure to partitioned the data year_month\n output_temp = self.output_folder + year + '_' + month\n url_data = \"http://trmm.atmos.washington.edu/{}interp_data/{}/{}\".format(self.output_folder, year, month)\n print(url_data)\n start_time_year_month = time.time()\n r = requests.get(url_data, auth=self.auth_data)\n # check if url exists then extract netcdf links to download and upload to s3.\n if r.status_code == 200:\n soup = BeautifulSoup(r.text, features='lxml')\n for link in soup.findAll('a'):\n link_url = link.get('href')\n write_path = os.path.join(output_temp, link_url)\n if link_url.endswith('.nc4'):\n file_url = url_data + '/' + link_url\n r = requests.get(file_url, auth=self.auth_data, stream=True)\n if r.status_code == 200:\n self.client.put_object(Body=r.content, Bucket='himatdata', Key='Trmm/' + write_path)\n logging.info(\"Done with Year Month: %s\", month_year)\n print(\"--- %s seconds ---\" % (time.time() - start_time_year_month))\n\n else:\n print('No data/authentication for'.format(month_year))","def test_cl_fix_file(mock_get_filepath, cl_file, tmp_path):\n mock_get_filepath.return_value = os.path.join(tmp_path,\n 'fixed_cesm2_waccm_cl.nc')\n fix = Cl(None)\n fixed_file = fix.fix_file(cl_file, tmp_path)\n mock_get_filepath.assert_called_once_with(tmp_path, cl_file)\n fixed_dataset = Dataset(fixed_file, mode='r')\n assert fixed_dataset.variables['lev'].standard_name == (\n 'atmosphere_hybrid_sigma_pressure_coordinate')\n assert fixed_dataset.variables['lev'].formula_terms == (\n 'p0: p0 a: a b: b ps: ps')\n assert fixed_dataset.variables['lev'].units == '1'\n np.testing.assert_allclose(fixed_dataset.variables['a'][:], [1.0, 2.0])\n np.testing.assert_allclose(fixed_dataset.variables['b'][:], [0.0, 1.0])\n np.testing.assert_allclose(fixed_dataset.variables['a_bnds'][:],\n [[0.0, 1.5], [1.5, 3.0]])\n np.testing.assert_allclose(fixed_dataset.variables['b_bnds'][:],\n [[-1.0, 0.5], [0.5, 2.0]])","def test_recv(self):\n # Required to get useful test names\n super(TestCisPandasInput_local, self).test_recv()","def prepare_test_data():\n # Dictionary in which to store data\n data_dict = {}\n # Load data01.nc Dataset\n data01 = xr.open_dataset(os.path.dirname(__file__)+'/data/data01.nc',\n decode_times=False, autoclose=True)\n data_dict['data01'] = data01.copy()\n # Extract two *DataArrays* - to test functions with DataArrays\n da_ts = data01['TS'].copy()\n da_precl = data01['PRECL'].copy()\n data_dict['da_ts'] = da_ts.copy()\n data_dict['da_precl'] = da_precl.copy()\n # Dataset with *shifted* longitudes\n ds_shift_lon = climapy.xr_shift_lon(data01.copy())\n data_dict['ds_shift_lon'] = ds_shift_lon.copy()\n # Datasets with *reversed* lon/lat coordinates and data\n ds_rev_lon = data01.copy()\n ds_rev_lon['lon'].values = ds_rev_lon['lon'].values[::-1]\n for var_name in ['TS', 'PRECL']: # array order: time, lat, lon\n ds_rev_lon[var_name].values = ds_rev_lon[var_name].values[:, :, ::-1]\n ds_rev_lat = data01.copy()\n ds_rev_lat['lat'].values = ds_rev_lat['lat'].values[::-1]\n for var_name in ['TS', 'PRECL']:\n ds_rev_lat[var_name].values = ds_rev_lat[var_name].values[:, ::-1, :]\n ds_rev_both = data01.copy()\n ds_rev_both['lat'].values = ds_rev_both['lat'].values[::-1]\n ds_rev_both['lon'].values = ds_rev_both['lon'].values[::-1]\n for var_name in ['TS', 'PRECL']:\n ds_rev_both[var_name].values = ds_rev_both[var_name].values[:, ::-1, ::-1]\n data_dict['ds_rev_lon'] = ds_rev_lon.copy()\n data_dict['ds_rev_lat'] = ds_rev_lat.copy()\n data_dict['ds_rev_both'] = ds_rev_both.copy()\n # Dataset with *transposed* lon/lat coords\n ds_transposed = data01.copy()\n ds_transposed = ds_transposed.transpose()\n data_dict['ds_transposed'] = ds_transposed.copy()\n # Dataset with *renamed* longitude and latitude coords\n ds_renamed = data01.copy()\n ds_renamed = ds_renamed.rename({'lon': 'longitude', 'lat': 'latitude'})\n data_dict['ds_renamed'] = ds_renamed.copy()\n # Datasets with slightly *irregular* lon/lat coords, yet still monotonic\n nx, ny = data01['lon'].size, data01['lat'].size\n lon_irr = (data01['lon'].values +\n np_rand.uniform(low=-0.5, high=0.5, size=nx)) # add small amount of noise\n lon_irr[[0, -1]] = data01['lon'].values[[0, -1]] # keep end values unchanged\n lat_irr = (data01['lat'].values +\n np_rand.uniform(low=-0.5, high=0.5, size=ny))\n lat_irr[[0, -1]] = data01['lat'].values[[0, -1]]\n ds_irr_lon = data01.copy()\n ds_irr_lon['lon'].values = lon_irr.copy()\n ds_irr_lat = data01.copy()\n ds_irr_lat['lat'].values = lat_irr.copy()\n ds_irr_both = data01.copy()\n ds_irr_both['lon'].values = lon_irr.copy()\n ds_irr_both['lat'].values = lat_irr.copy()\n data_dict['ds_irr_lon'] = ds_irr_lon.copy()\n data_dict['ds_irr_lat'] = ds_irr_lat.copy()\n data_dict['ds_irr_both'] = ds_irr_both.copy()\n # Dataset with *strange* lon/lat coords - very irregular and not monotonic\n lon_strange = (data01['lon'].values +\n np_rand.uniform(low=-10, high=10, size=nx)) # add large amount of noise\n lon_strange[[0, -1]] = data01['lon'].values[[0, -1]] # keep end values unchanged\n lat_strange = (data01['lat'].values + np_rand.uniform(low=-10, high=10, size=ny))\n lat_strange[[0, -1]] = data01['lat'].values[[0, -1]] # keep end values unchanged\n ds_strange = data01.copy()\n ds_strange['lon'].values = lon_strange.copy()\n ds_strange['lat'].values = lat_strange.copy()\n data_dict['ds_strange'] = ds_strange.copy()\n # Return dictionary of data\n return data_dict","def prep(self, deleteraw=False):\n print\n print 'Filtering rawdata to data as masked array...'\n# using 0 as flag\n# self.data = n.ma.masked_array(self.rawdata[:self.nints,:, self.chans,:], self.rawdata[:self.nints,:, self.chans,:] == 0j)\n# using standard flags\n self.data = n.ma.masked_array(self.rawdata[:self.nints,:, self.chans,:], self.flags[:self.nints,:, self.chans,:] == 0) # mask of True for flagged data (flags=0 in tpipe, which is flags=False in Miriad and flags=True in MS)\n self.dataph = (self.data.mean(axis=3).mean(axis=1)).real #dataph is summed and detected to form TP beam at phase center, multi-pol\n self.min = self.dataph.min()\n self.max = self.dataph.max()\n print 'Shape of data:'\n print self.data.shape\n print 'Dataph min, max:'\n print self.min, self.max\n\n if deleteraw:\n del self.rawdata\n del self.flags\n\n self.freq = self.freq_orig[self.chans]\n\n # set up ur tracks (lol)\n self.dmtrack0 = {}\n self.twidths = {}\n self.delay = {}\n for dmbin in xrange(len(self.dmarr)):\n self.dmtrack0[dmbin] = self.dmtrack(self.dmarr[dmbin],0) # track crosses high-freq channel in first integration\n (trackt, trackc) = self.dmtrack0[dmbin]\n if len(trackc)<len(self.chans):\n print 'Computed track for DM=%.1f is too long for the observation; only %d channels are computed' % (self.dmarr[dmbin],len(trackc))\n continue\n \n# old way\n# self.twidths[dmbin] = [len(n.where(trackc == (chan-self.chans[0]))[0]) for chan in self.chans] # width of track for each unflagged channel\n# self.delay[dmbin] = [n.int(trackt[n.where(trackc == (chan-self.chans[0]))[0][0]]) for chan in self.chans] # integration delay for each unflagged channel of a given dm.\n# new way\n\n self.twidths[dmbin] = [len(n.where(n.array(trackc) == chan)[0]) for chan in range(len(self.chans))] # width of track for each unflagged channel\n self.delay[dmbin] = [n.int(trackt[n.where(n.array(trackc) == chan)[0][0]]) for chan in range(len(self.chans))] # integration delay for each unflagged channel of a given dm.\n\n\n print 'Track width in time: '\n for dmbin in self.twidths:\n print 'DM=%.1f, max(twidth)=%d. Iteration could step by %d/2.' % (self.dmarr[dmbin], max(self.twidths[dmbin]), max(self.twidths[dmbin]))","def has_data(self):\n if len(self.channels) > 0:\n return True\n return False","def setUp(self):\n\n serial_times = {295: '1971-07-31T01:24:11.754',\n 296: '1971-07-31T01:24:36.970',\n 297: '1971-07-31T01:25:02.243',\n 298: '1971-07-31T01:25:27.457',\n 299: '1971-07-31T01:25:52.669',\n 300: '1971-07-31T01:26:17.923'}\n self.serials = ['APOLLO15/METRIC/{}'.format(i) for i in serial_times.values()]\n\n\n x = list(range(5))\n y = list(range(5))\n pid = [0,0,1,1,1]\n idx = pid\n serials = [self.serials[0], self.serials[1], self.serials[2],\n self.serials[2], self.serials[3]]\n\n\n columns = ['x', 'y', 'idx', 'pid', 'nid']\n self.data_length = 5\n\n data = [x,y, idx, pid, serials]\n\n self.creation_time = strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())\n cnet = C(data, index=columns).T\n\n io_controlnetwork.to_isis('test.net', cnet, mode='wb', targetname='Moon')\n\n self.header_message_size = 85\n self.point_start_byte = 65621","def do_grid_check(self,):\n self.ydim, self.xdim = self.data_fcst.shape \n if self.data_obs.shape != (self.ydim,self.xdim):\n raise FormatError(\"Obs and forecast data not same size.\")\n return","def __init__(self, out_dir = 'output' ):\n \n self.data = {} # will contain the data for each different dataset \n self.datasets = '' # will contain the input datasets (original dictionary)\n self.datasets_keys = '' # will contain the input datasets names only (i.e. keys of the datasets dictionary)\n self.datasets_all = ['igra2' , 'era5_1' , 'ncar_w' , 'ncar_t', 'bufr' , 'era5_1759' , 'era5_1761' , 'era5_3188'] # all possibly available datasets \n #self.observation_ids_merged = { 'igra2':1 , 'ncar_t':2 , 'ncar_w':2, 'bufr':3, 'era5_1':4 , 'era5_1759' :5 , 'era5_1761':6 , 'era5_3188' :7} # values used to convert original record_id to the merged record_id, see method merge_all_data \n \n self.observation_ids_merged = { 'igra2':1 , 'ncar':2, 'bufr':3, 'era5_1':4 , 'era5_1759' :5 , 'era5_1761':6 , 'era5_3188' :7} # values used to convert original record_id to the merged record_id, see method merge_all_data \n \n self.unique_dates = {} \n self.attributes = {} # will keep the original attributes from the CDM tables, read from the netCDF files \n self.out_dir = out_dir","def MyDataChangedCallback(self, inRefcon):\r\n pass","def output_netcdf(forecast,proj_dict,grid_dict,start_hour,end_hour,\n stride,size,run_date,target_dataset,smoothing,config):\n for d,date in enumerate(run_date):\n date_outpath = config.forecast_out_path+'20{0}/netcdf/'.format(\n date)\n \n if not os.path.exists(date_outpath):\n os.makedirs(date_outpath)\n \n map_data = make_proj_grids(proj_dict,grid_dict)\n lons = map_data[\"lon\"]\n lats = map_data[\"lat\"]\n \n filtered_forecast = gaussian_filter(forecast[d],smoothing,mode='constant')\n \n filename = date_outpath + \"{0}_{6}_Hail_{1}_Cali_NMEP_{2}mm_{3}_Hours_{4}-{5}.nc\".format(\n config.ensemble_name,\n target_dataset,\n size,\n date,\n start_hour,end_hour,config.forecast_model_names)\n\n \n out_file = Dataset(filename, \"w\")\n out_file.createDimension(\"x\", filtered_forecast.shape[0])\n out_file.createDimension(\"y\", filtered_forecast.shape[1])\n out_file.createVariable(\"Longitude\", \"f4\", (\"x\", \"y\"))\n out_file.createVariable(\"Latitude\", \"f4\",(\"x\", \"y\"))\n out_file.createVariable(\"Data\", \"f4\", (\"x\", \"y\"))\n out_file.variables[\"Longitude\"][:,:] = lons\n out_file.variables[\"Latitude\"][:,:] = lats\n out_file.variables[\"Data\"][:,:] = filtered_forecast\n out_file.projection = proj_dict[\"proj\"]\n out_file.lon_0 = proj_dict[\"lon_0\"]\n out_file.lat_0 = proj_dict[\"lat_0\"]\n out_file.lat_1 = proj_dict[\"lat_1\"]\n out_file.lat_2 = proj_dict[\"lat_2\"]\n out_file.close()\n \n print(\"Writing to \" + filename)\n return","def _handleRequestCableCheckParameters(self, data):\r\n print(\"\\\"Request Cable Check Parameters\\\" received\")\r\n message = self.whitebeet.v2gParseRequestCableCheckParameters(data)\r\n if 'dc' in message:\r\n print(\"SOC: {}%\".format(message['dc']['soc']))\r\n try:\r\n self.whitebeet.v2gSetDcCableCheckParameters(0, 1)\r\n except Warning as e:\r\n print(\"Warning: {}\".format(e))\r\n except ConnectionError as e:\r\n print(\"ConnectionError: {}\".format(e))","def read(self, data=''):\n if not self.nc.io.closed():\n self.nc.io.read_bytes(MAX_CONTROL_LINE_SIZE, callback=self.read, streaming_callback=self.parse, partial=True)","def create_netcdf(self, netcdf_file, cols, rows, doy_range, do_zlib=True):\n\n # least_significant_digit for createVariable(...)\n lsd=None\n\n # create a new netCDF file\n rootgrp = nc.Dataset(netcdf_file, \"w\")\n rootgrp.description = \"NBAR reflectance and BB albedo\"\n\n # Create groups for NBAR reflectance and BB albedo\n refl_grp = rootgrp.createGroup(\"reflectance\")\n refl_grp.description = \"Normalized at nadir (NBAR) reflectance\"\n albedo_grp = rootgrp.createGroup(\"albedo\")\n albedo_grp.description = \"Broad band (BB) albedo\"\n\n # Create dimensions for reflectance data. I.e. time series of reflectance\n # are determined by x, y and a day since 2000\n x = rootgrp.createDimension(\"x\", cols)\n y = rootgrp.createDimension(\"y\", rows)\n day = rootgrp.createDimension(\"day\", doy_range.shape[0])\n band = rootgrp.createDimension(\"band\", 7)\n str_dim = rootgrp.createDimension(\"str_dim\", 10)\n\n # We can set zlib=True for compression as an argument\n # of the createVariable function\n date_str = rootgrp.createVariable(\"date_str\", \"S1\", (\"day\", \"str_dim\"), zlib=do_zlib, least_significant_digit=lsd)\n date_str.units = \"string representation of date: yyyy.mm.dd\"\n # date = rootgrp.createVariable(\"julday\", \"i\")\n date = rootgrp.createVariable(\"julday\", \"i\", \"day\", zlib=do_zlib, least_significant_digit=lsd)\n date.units = \"Julian day\"\n\n # Create variables of NBAR reflectance: 7 MODIS bands\n for i in range(1, 8):\n refl = refl_grp.createVariable(\"refl_b%d\" % i, \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n refl.units = \"surface bidirectional reflectance, band %d\" % i\n\n # reflectance uncertainty\n refl_sd = refl_grp.createVariable(\"refl_b%d_sd\" % i, \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n refl_sd.units = \"uncertainty of surface bidirectional reflectance, band %d\" % i\n \n y_fwd = refl_grp.createVariable(\"y_fwd\", \"f4\", (\"day\", \"band\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n\n y_orig = refl_grp.createVariable(\"y_orig\", \"f4\", (\"day\", \"band\", \"x\", \"y\"), zlib=do_zlib, \\\n least_significant_digit=lsd)\n \n albedo_vis = albedo_grp.createVariable(\"albedo_vis\", \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_vis.units = \"broad band albedo\"\n albedo_nir = albedo_grp.createVariable(\"albedo_nir\", \"f4\", ( \"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_nir.units = \"broad band albedo\"\n albedo_swir = albedo_grp.createVariable(\"albedo_swir\", \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_swir.units = \"broad band albedo\"\n\n # albedo uncertainty\n albedo_vis_sd = albedo_grp.createVariable(\"albedo_vis_sd\", \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_vis_sd.units = \"albedo standard deviation\"\n albedo_nir_sd = albedo_grp.createVariable(\"albedo_nir_sd\", \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_nir_sd.units = \"albedo standard deviation\"\n albedo_swir_sd = albedo_grp.createVariable(\"albedo_swir_sd\", \"f4\", (\"day\", \"x\", \"y\"), zlib=do_zlib,\\\n least_significant_digit=lsd)\n albedo_swir_sd.units = \"albedo standard deviation\"\n\n # latitude and longitude arrays\n lat = rootgrp.createVariable('lat', \"f4\", (\"x\", \"y\"), zlib=do_zlib)\n lat.units = \"latitude\"\n lon = rootgrp.createVariable('lon', \"f4\", (\"x\", \"y\"), zlib=do_zlib)\n lon.units = \"longitude\"\n\n # save geo information and projection\n # nchar_proj = len(proj_str)\n # nchar_geo = len(geo_str)\n rootgrp.createDimension('nchar_proj', 400)\n rootgrp.createDimension('nchar_geo', 100)\n rootgrp.createVariable('proj', 'S1', ('nchar_proj'))\n rootgrp.createVariable('geo_transform', 'S1', 'nchar_geo')\n\n # proj_char = nc.stringtochar(np.array([proj_str], 'S%d' % nchar_proj))\n # geo_char = nc.stringtochar(np.array([geo_str], 'S%d' % nchar_geo))\n # rootgrp.variables['proj'][:] = proj_char\n # rootgrp.variables['geo_transform'][:] = geo_char\n\n return rootgrp","def dataIdentify(self, in_nc):\r\n data_nc = NET.Dataset(in_nc)\r\n time = data_nc.variables['time'][:]\r\n diff = NUM.unique(NUM.diff(time))\r\n data_nc.close()\r\n #time_interval_highres = NUM.array([1.0,3.0,6.0],dtype=float)\r\n #time_interval_lowres_full = NUM.array([3.0, 6.0],dtype=float)\r\n #time_interval_lowres = NUM.array([6.0],dtype=float)\r\n #time_interval_lowres_3Hr = NUM.array([3.0],dtype=float)\r\n\t\t\r\n time_interval_HRES1 = NUM.array([1.0],dtype=float) # Line Added/Modified CJB 20190108\r\n time_interval_HRES13 = NUM.array([1.0,3.0],dtype=float) # Line Added/Modified CJB 20190108\r\n time_interval_HRES136 = NUM.array([1.0,3.0,6.0],dtype=float) # Line Added/Modified CJB 20190108\r\n time_interval_ENS3 = NUM.array([3.0],dtype=float) # Line Added/Modified CJB 20190108\r\n time_interval_ENS36 = NUM.array([3.0,6.0],dtype=float) # Line Added/Modified CJB 20190108\r\n time_interval_ENS6 = NUM.array([6.0],dtype=float) # Line Added/Modified CJB 20190108\r\n\r\n\r\n #print \"SDR - diff:\", diff, time_interval_highres, time_interval_lowres_full, time_interval_lowres\r\n #if NUM.array_equal(diff, time_interval_highres):\r\n # return \"HighRes\"\r\n #elif NUM.array_equal(diff, time_interval_lowres_full):\r\n # return \"LowResFull\"\r\n #elif NUM.array_equal(diff, time_interval_lowres):\r\n # return \"LowRes\"\r\n #elif NUM.array_equal(diff, time_interval_lowres_3Hr):\r\n # return \"Low3HrRes\"\r\n #else:\r\n # return None\r\n\t\t\t\r\n if NUM.array_equal(diff, time_interval_HRES1): # Line Added/Modified CJB 20190108\r\n return \"HRES1\" # Line Added/Modified CJB 20190108\r\n elif NUM.array_equal(diff, time_interval_HRES13): # Line Added/Modified CJB 20190108\r\n return \"HRES13\" # Line Added/Modified CJB 20190108\r\n elif NUM.array_equal(diff, time_interval_HRES136): # Line Added/Modified CJB 20190108\r\n return \"HRES136\" # Line Added/Modified CJB 20190108\r\n elif NUM.array_equal(diff, time_interval_ENS3): # Line Added/Modified CJB 20190108\r\n return \"ENS3\" # Line Added/Modified CJB 20190108\r\n elif NUM.array_equal(diff, time_interval_ENS36): # Line Added/Modified CJB 20190108\r\n return \"ENS36\" # Line Added/Modified CJB 20190108\r\n elif NUM.array_equal(diff, time_interval_ENS6): # Line Added/Modified MJS, CJB 20190108\r\n return \"ENS6\" # Line Added/Modified CJB 20190108\r\n else: # Line Added/Modified CJB 20190108\r\n return None # Line Added/Modified CJB 20190108\r","def writeNetCDFData(out_nc, hrus, dr_time, hru_type, remapped_data, var_meta, var_attrs, var_encodings, remap_idx):\n\n dataset = xr.Dataset()\n\n for varname, meta in var_meta.items():\n foo = xr.DataArray(remapped_data[varname][:, remap_idx],\n dims=['time', 'basinID'],\n name=varname)\n\n foo.encoding = var_encodings[varname]\n foo.attrs = var_attrs[varname]\n\n dataset[varname] = foo\n\n # HRU ID variables\n dataset['basinID'] = xr.DataArray(hrus[remap_idx], dims=['basinID'])\n dataset['basinID'].encoding = {'dtype': hru_type, '_FillValue': None}\n dataset['basinID'].attrs = {'long_name': 'Basin ID'}\n\n dataset[TIME_DIM_NAME] = dr_time\n\n dataset.to_netcdf(out_nc, unlimited_dims='time')","def write_netcdf(file, lons, lats, times, hydrographs, fractions, loc, grid_id,\n inds, Flist, velocity, diffusion, fill_value, verbose):\n f = Dataset(file,'w', format='NETCDF4')\n\n # set dimensions\n time = f.createDimension('time', None)\n lon = f.createDimension('lon', (len(lons)))\n lat = f.createDimension('lat', (len(lats)))\n\n # initialize variables\n time = f.createVariable('time','f8',('time',))\n lon = f.createVariable('lon','f8',('lon',))\n lat = f.createVariable('lat','f8',('lat',))\n fraction = f.createVariable('fraction','f8',('lat','lon',),fill_value=fill_value)\n UHS = f.createVariable('unit_hydrograph','f8',('time','lat','lon',),fill_value=fill_value)\n\n # write attributes for netcdf\n f.description = 'Aggregated UH_S and Fraction Vars'\n f.history = 'Created: {}\\n'.format(tm.ctime(tm.time()))\n f.history += ' '.join(sys.argv) + '\\n'\n f.source = sys.argv[0] # prints the name of script used\n f.velocity = velocity\n f.diffusion = diffusion\n f.outlet_id = str(grid_id.astype(np.int64))\n f.outlet_y= str(inds[0].astype(np.int64))\n f.outlet_x = str(inds[1].astype(np.int64)) # this is change is a cdo work around. Othewise cdo removes the attribute. \n f.outlet_lat = loc[0]\n f.outlet_lon = loc[1]\n f.includes = ', '.join(Flist)\n\n lat.long_name = 'latitude coordinate'\n lat.standard_name = 'latitude'\n lat.units = 'degrees_north'\n\n lon.long_name = 'longitude coordinate'\n lon.standard_name = 'longitude'\n lon.units = 'degrees_east'\n\n time.units = 'seconds since 0001-1-1 0:0:0'\n time.calendar = 'noleap'\n time.longname = 'time'\n time.type_prefered = 'float'\n time.description = 'Seconds since initial impulse'\n\n UHS.units = 'unitless'\n UHS.description = 'unit hydrograph for each grid cell with respect to downstream grid location'\n \n fraction.units = 'unitless'\n fraction.description = 'fraction of grid cell contributing to guage location'\n\n # write data to variables initialized above\n time[:]= times\n lon[:] = lons\n lat[:] = lats\n UHS[:,:,:] = hydrographs\n fraction[:,:]= fractions\n f.close()","def data_cb(self, handle, value):\n \n self.x, self.y, self.z, self.temp = unpack('fffB', value)\n print(f\"xyz: {self.x}, {self.y}, {self.z}\")\n self.send()","def data_sample(CI, CC, thermal, calibration, health, driver_monitor, gps_location,\n poller, cal_status, cal_perc, overtemp, free_space, low_battery,\n driver_status, geofence, state, mismatch_counter, params):\n\n # Update carstate from CAN and create events\n CS = CI.update(CC)\n events = list(CS.events)\n enabled = isEnabled(state)\n\n # Receive from sockets\n td = None\n cal = None\n hh = None\n dm = None\n gps = None\n\n for socket, event in poller.poll(0):\n if socket is thermal:\n td = messaging.recv_one(socket)\n elif socket is calibration:\n cal = messaging.recv_one(socket)\n elif socket is health:\n hh = messaging.recv_one(socket)\n elif socket is driver_monitor:\n dm = messaging.recv_one(socket)\n elif socket is gps_location:\n gps = messaging.recv_one(socket)\n\n if td is not None:\n overtemp = td.thermal.thermalStatus >= ThermalStatus.red\n free_space = td.thermal.freeSpace < 0.15 # under 15% of space free no enable allowed\n low_battery = td.thermal.batteryPercent < 1 # at zero percent battery, OP should not be allowed\n\n # Create events for battery, temperature and disk space\n if low_battery:\n events.append(create_event('lowBattery', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n if overtemp:\n events.append(create_event('overheat', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n if free_space:\n events.append(create_event('outOfSpace', [ET.NO_ENTRY]))\n\n # Handle calibration\n if cal is not None:\n cal_status = cal.liveCalibration.calStatus\n cal_perc = cal.liveCalibration.calPerc\n\n if cal_status != Calibration.CALIBRATED:\n if cal_status == Calibration.UNCALIBRATED:\n events.append(create_event('calibrationIncomplete', [ET.NO_ENTRY, ET.SOFT_DISABLE, ET.PERMANENT]))\n else:\n events.append(create_event('calibrationInvalid', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n\n # When the panda and controlsd do not agree on controls_allowed\n # we want to disengage openpilot. However the status from the panda goes through\n # another socket than the CAN messages, therefore one can arrive earlier than the other.\n # Therefore we allow a mismatch for two samples, then we trigger the disengagement.\n if not enabled:\n mismatch_counter = 0\n\n if hh is not None:\n controls_allowed = hh.health.controlsAllowed\n if not controls_allowed and enabled:\n mismatch_counter += 1\n if mismatch_counter >= 2:\n events.append(create_event('controlsMismatch', [ET.IMMEDIATE_DISABLE]))\n\n # Driver monitoring\n if dm is not None:\n driver_status.get_pose(dm.driverMonitoring, params)\n\n # Geofence\n if geofence is not None and gps is not None:\n geofence.update_geofence_status(gps.gpsLocationExternal, params)\n if geofence is not None and not geofence.in_geofence:\n events.append(create_event('geofence', [ET.NO_ENTRY, ET.WARNING]))\n\n return CS, events, cal_status, cal_perc, overtemp, free_space, low_battery, mismatch_counter","def __log_data_handler(self, event, sender, data):\n pos_x = -data.mvo.pos_x\n pos_y = -data.mvo.pos_y\n pos_z = -data.mvo.pos_z\n # First time we have meaningful values, we store them as reference\n if abs(pos_x) + abs(pos_y) + abs(pos_z) > 0.07:\n if self.ref_pos_x == -1:\n self.ref_pos_x = pos_x\n self.ref_pos_y = pos_y\n self.ref_pos_z = pos_z\n else:\n self.pos_x = pos_x - self.ref_pos_x\n self.pos_y = pos_y - self.ref_pos_y\n self.pos_z = pos_z - self.ref_pos_z\n\n qx = data.imu.q1\n qy = data.imu.q2\n qz = data.imu.q3\n qw = data.imu.q0\n\n degree = 0.01745\n siny = 2 * (qw * qz + qx * qy)\n cosy = 1 - 2 * (qy * qy + qz * qz)\n self.yaw = int(atan2(siny, cosy) / degree)\n\n if self.write_header:\n self.log_file.write(f\"{data.format_cvs_header()}\\n\")\n self.write_header = False\n self.log_file.write(f\"{data.format_cvs()}\\n\")","def _handle_MonitorData (self, event, packet, reverse):\n pass","def XPLMDataChanged_f(inRefcon):","def hmVerifyMsgCRCOK(destination, protocol, source, expectedFunction, expectedLength, datal) :\r\n badresponse = 0\r\n if protocol == constants.HMV3_ID:\r\n checksum = datal[len(datal)-2:]\r\n rxmsg = datal[:len(datal)-2]\r\n crc = crc16() # Initialises the CRC\r\n expectedchecksum = crc.run(rxmsg)\r\n if expectedchecksum == checksum:\r\n print(\"CRC is correct\")\r\n else:\r\n print(\"CRC is INCORRECT\")\r\n s = \"Incorrect CRC: %s Expected: %s \\n\" % (datal, expectedchecksum)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n # Check the response\r\n dest_addr = datal[0]\r\n frame_len_l = datal[1]\r\n frame_len_h = datal[2]\r\n frame_len = (frame_len_h << 8) | frame_len_l\r\n source_addr = datal[3]\r\n func_code = datal[4]\r\n\r\n\r\n\r\n if (dest_addr != 129 and dest_addr != 160):\r\n print(\"dest_addr is ILLEGAL\")\r\n s = \"%s : Controller %s : Illegal Dest Addr: %s\\n\" % (localtime, loop, dest_addr)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (dest_addr != destination):\r\n print(\"dest_addr is INCORRECT\")\r\n s = \"%s : Controller %s : Incorrect Dest Addr: %s\\n\" % (localtime, loop, dest_addr)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (source_addr < 1 or source_addr > 32):\r\n print(\"source_addr is ILLEGAL\")\r\n s = \"%s : Controller %s : Illegal Src Addr: %s\\n\" % (localtime, loop, source_addr)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (source_addr != source):\r\n print(\"source addr is INCORRECT\")\r\n s = \"%s : Controller %s : Incorrect Src Addr: %s\\n\" % (localtime, loop, source_addr)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (func_code != constants.FUNC_WRITE and func_code != constants.FUNC_READ):\r\n print(\"Func Code is UNKNWON\")\r\n s = \"%s : Controller %s : Unknown Func Code: %s\\n\" % (localtime, loop, func_code)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (func_code != expectedFunction):\r\n print(\"Func Code is UNEXPECTED\")\r\n s = \"%s : Controller %s : Unexpected Func Code: %s\\n\" % (localtime, loop, func_code)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (func_code == constants.FUNC_WRITE and frame_len != 7):\r\n # Reply to Write is always 7 long\r\n print(\"response length is INCORRECT\")\r\n s = \"%s : Controller %s : Incorrect length: %s\\n\" % (localtime, loop, frame_len)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n if (len(datal) != frame_len):\r\n print(\"response length MISMATCHES header\")\r\n s = \"%s : Controller %s : Mismatch length: %s %s\\n\" % (localtime, loop, len(datal), frame_len)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\r\n \"\"\"if (func_code == constants.FUNC_READ and expectedLength !=len(datal) ):\r\n # Read response length is wrong\r\n print(\"response length not EXPECTED value\")\r\n print(len(datal))\r\n print(datal)\r\n s = \"%s : Controller %s : Incorrect length: %s\\n\" % (localtime, loop, frame_len)\r\n sys.stderr.write(s)\r\n badresponse += 1\r\n\"\"\"\r\n if (badresponse == 0):\r\n return True\r\n else:\r\n return False\r\n\r\n else:\r\n assert 0, \"Un-supported protocol found %s\" % protocol","def test_scp_handler_return_dataset_no_status(self):\n def handle(event):\n return Dataset()\n\n handlers = [(evt.EVT_C_ECHO, handle)]\n\n self.ae = ae = AE()\n ae.add_supported_context(VerificationSOPClass)\n ae.add_requested_context(VerificationSOPClass)\n scp = ae.start_server(('', 11112), block=False, evt_handlers=handlers)\n\n assoc = ae.associate('localhost', 11112)\n assert assoc.is_established\n rsp = assoc.send_c_echo()\n assert rsp.Status == 0x0000\n assoc.release()\n assert assoc.is_released\n\n scp.shutdown()","def get_data(datauri): \n print(datauri)\n nc = netCDF4.Dataset(datauri)\n time = nc.variables['JULD']\n depth = nc.variables['PRES']\n\n checkdepth = 0\n findepth = np.zeros(time.shape[0])\n for i in range (0, depth.shape[0]):\n maxdepth = np.amax(depth[i])\n findepth[i] = maxdepth\n if (maxdepth > checkdepth):\n dd=i\n checkdepth = maxdepth\n maxdepth = findepth[dd]\n \n temperature = nc.variables['TEMP'][dd] \n tempadj=nc.variables['TEMP_ADJUSTED'][dd]\n depthnew = nc.variables['PRES'][dd] \n depthadj = nc.variables['PRES_ADJUSTED'][dd] \n\n latitude = nc.variables['LATITUDE'][dd]\n longitude = nc.variables['LONGITUDE'][dd]\n\n lonm=nc.variables['LONGITUDE'][dd].mask\n latm=nc.variables['LATITUDE'][dd].mask\n timm=nc.variables['JULD'][dd].mask\n\n if (lonm == True or latm == True):\n longitude=-999.9\n latitude=-999.9\n\n\n out = {}\n out['latitude'] = nc.variables.pop('LATITUDE')[dd]\n out['longitude'] = nc.variables.pop('LONGITUDE')[dd]\n out['temperature'] = nc.variables.pop('TEMP')[dd]\n out['temperatureadj'] = nc.variables.pop('TEMP_ADJUSTED')[dd]\n out['salinity'] = nc.variables.pop('PSAL')[dd]\n out['salinityadj'] = nc.variables.pop('PSAL_ADJUSTED')[dd]\n out['depth'] = nc.variables.pop('PRES')[dd]\n out['depthadj'] = nc.variables.pop('PRES_ADJUSTED')[dd]\n \n return out","def _async_process_data(self):\n raise NotImplementedError","def test_check_cds_14(self):\n self.cds1.orientation = \"f\"\n import_genome.check_cds(self.cds1, self.eval_flags)\n count = count_status(self.cds1, \"error\")\n self.assertEqual(count, 1)","def before_dataobj_create(self, dataobj):","def __init__(self, points_control, cf_file, year, site_data=None,\n output_request=('lcoe_fcr',), out_fpath=None,\n append=False, mem_util_lim=0.4):\n\n super().__init__(points_control, output_request, site_data=site_data,\n out_fpath=out_fpath, mem_util_lim=mem_util_lim)\n\n self._cf_file = cf_file\n self._year = year\n self._run_attrs['cf_file'] = cf_file\n self._run_attrs['sam_module'] = self._sam_module.MODULE\n\n # initialize output file or append econ data to gen file\n if append:\n self._out_fpath = self._cf_file\n else:\n self._init_fpath()\n\n mode = 'a' if append else 'w'\n self._init_h5(mode=mode)\n self._init_out_arrays()","def prepare_train_coco_data(args):\n image_dir, annotation_file, data_dir = args.train_coco_image_dir, args.train_coco_annotation_file, args.train_coco_data_dir\n batch_size = args.batch_size\n basic_model = args.basic_model\n num_roi = args.num_roi\n\n coco = COCO(annotation_file)\n\n img_ids = list(coco.imgToAnns.keys())\n img_files = []\n img_heights = []\n img_widths = []\n anchor_files = []\n gt_classes = []\n gt_bboxes = []\n\n for img_id in img_ids:\n img_files.append(os.path.join(image_dir, coco.imgs[img_id]['file_name'])) \n img_heights.append(coco.imgs[img_id]['height']) \n img_widths.append(coco.imgs[img_id]['width']) \n anchor_files.append(os.path.join(data_dir, os.path.splitext(coco.imgs[img_id]['file_name'])[0]+'_'+basic_model+'_anchor.npz')) \n\n classes = [] \n bboxes = [] \n for ann in coco.imgToAnns[img_id]: \n classes.append(coco_category_to_class[ann['category_id']]) \n bboxes.append([ann['bbox'][1], ann['bbox'][0], ann['bbox'][3]+1, ann['bbox'][2]+1]) \n\n gt_classes.append(classes) \n gt_bboxes.append(bboxes) \n \n print(\"Building the training dataset...\")\n dataset = DataSet(img_ids, img_files, img_heights, img_widths, batch_size, anchor_files, gt_classes, gt_bboxes, True, True)\n print(\"Dataset built.\")\n return coco, dataset","def test_check_cds_15(self):\n self.cds1.locus_tag = \"\"\n import_genome.check_cds(self.cds1, self.eval_flags)\n count = count_status(self.cds1, \"error\", \"warning\")\n self.assertEqual(count, 2)","def test_check_cds_6(self):\n import_genome.check_cds(self.cds1, self.eval_flags)\n count = count_status(self.cds1, \"error\")\n self.assertEqual(count, 0)","def receiveCallback(self, socket, stateMask):\n # read the PDU header\n pduHeader = self.recv(EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE)\n if pduHeader == None:\n # failure handling was done automatically by derived logic\n return\n # consistency check\n pduHeaderLen = len(pduHeader)\n if pduHeaderLen != EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE:\n LOG_ERROR(\"Read of PDU header failed: invalid size: \" + str(pduHeaderLen), \"EDEN\")\n self.disconnectFromServer()\n return\n pdu = EGSE.EDENPDU.PDU(pduHeader)\n # read the data field for the PDU\n dataFieldLength = pdu.dataFieldLength\n if dataFieldLength > 0:\n dataField = self.recv(dataFieldLength)\n if dataField == None:\n # failure handling was done automatically by derived logic\n return\n # consistency check\n remainingSizeRead = len(dataField)\n if remainingSizeRead != dataFieldLength:\n LOG_ERROR(\"Read of remaining PDU failed: invalid remaining size: \" + str(remainingSizeRead), \"EDEN\")\n self.disconnectFromServer()\n return\n pdu.setDataField(dataField)\n # dispatch depending on pduType and subType\n try:\n if pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC_A:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\n # (TC_A,SPACE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TC_A,SPACE)\", \"EDEN\")\n self.notifyTc_aSpace(pdu.field2, pdu.field3)\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\n # (TC_A,SCOE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TC_A,SCOE)\", \"EDEN\")\n self.notifyTc_aScoe(pdu.field2, pdu.field3)\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType), \"EDEN\")\n LOG(\"PDU = \" + str(pdu), \"EDEN\")\n self.disconnectFromServer()\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC_E:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\n # (TC_E,SPACE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TC_E,SPACE)\", \"EDEN\")\n tc_eSpacePDU = EGSE.EDENPDU.TC_Espace(pdu.buffer)\n self.notifyTc_eSpace(tc_eSpacePDU.getCCSDSpacket())\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\n # (TC_E,SCOE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TC_E,SCOE)\", \"EDEN\")\n tc_eScoePDU = EGSE.EDENPDU.TC_Escoe(pdu.buffer)\n self.notifyTc_eScoe(tc_eScoePDU.getCCSDSpacket())\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType), \"EDEN\")\n LOG(\"PDU = \" + str(pdu))\n self.disconnectFromServer()\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TM:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\n # (TM,SPACE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TM,SPACE)\", \"EDEN\")\n tmSpacePDU = EGSE.EDENPDU.TMspace(pdu.buffer)\n self.notifyTmSpace(tmSpacePDU.getCCSDSpacket())\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\n # (TM,SCOE)\n LOG_INFO(\"EDEN.Client.receiveCallback(TM,SCOE)\", \"EDEN\")\n tmScoePDU = EGSE.EDENPDU.TMscoe(pdu.buffer)\n self.notifyTmScoe(tmScoePDU.getCCSDSpacket())\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType), \"EDEN\")\n LOG(\"PDU = \" + str(pdu), \"EDEN\")\n self.disconnectFromServer()\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_CMD:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_ANSW:\n # (CMD,ANSW)\n LOG_INFO(\"EDEN.Client.receiveCallback(CMD,ANSW)\", \"EDEN\")\n self.notifyCmdAnsw(pdu.getDataField().tostring())\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType), \"EDEN\")\n LOG(\"PDU = \" + str(pdu), \"EDEN\")\n self.disconnectFromServer()\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid pduType: \" + str(pdu.pduType), \"EDEN\")\n LOG(\"PDU = \" + str(pdu), \"EDEN\")\n self.disconnectFromServer()\n except Exception as ex:\n LOG_ERROR(\"Processing of received PDU failed: \" + str(ex), \"EDEN\")\n self.disconnectFromServer()","def ncwrt_retrieval_config( retr_setup, outname=None ):\n\n #-- set name of file to be generated\n act_outname = outname if outname!=None else 'retrconfig.nc'\n msg = \"Start writing configuration file ***{}***...\".format(act_outname)\n FileLogger.info(msg)\n\n\n #-- compression settings\n zlev = retr_setup.zlev\n use_zlib = retr_setup.use_zlib\n\n #--\n schedule_dct = retr_setup.schedule_dct\n statevector = retr_setup.prstate\n #-- turn list into array\n sim_typ = np.array(schedule_dct['sim_typ'], dtype=np.int32)\n timepts = schedule_dct['date_utc']\n nstvar,npts = statevector.shape\n #-- overpass geometries SZA,SAA,VZA,VAA\n ivgeom = np.empty((npts,4), dtype=np.float64)\n ivgeom[:,0] = schedule_dct['sza']\n ivgeom[:,1] = schedule_dct['saa']\n ivgeom[:,2] = schedule_dct['vza']\n ivgeom[:,3] = schedule_dct['vaa']\n\n #-- temporal settings, create time-values (time-since)\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\n time_values = nc4.date2num(timepts, time_unit)\n\n #-- ensure directory exists\n mkdirp_smart(os.path.dirname(act_outname))\n\n #-- open file pointer\n ncfp = nc4.Dataset(act_outname, 'w')\n #-- add dimensions\n d1 = ncfp.createDimension('npoints',npts)\n d2 = ncfp.createDimension('ngeo',4)\n\n #-- time-value\n ncvar = ncfp.createVariable( 'time', statevector.dtype, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('standard_name','time')\n ncvar.setncattr('long_name','time')\n ncvar.setncattr('units', time_unit)\n ncvar[:] = time_values[:]\n\n #-- simulation type\n ncvar = ncfp.createVariable( 'sim_typ', sim_typ.dtype, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar[:] = sim_typ[:]\n ncvar.setncattr('long_name','simulation_type')\n ncvar.setncattr('comment', 'integer value which is to be bit-interpreted')\n ncvar.setncattr('nobits_set', 'time-point with other state')\n ncvar.setncattr('bit0_is_set', 'time-point for S1 simulation')\n ncvar.setncattr('bit1_is_set', 'time-point for S2 simulation')\n ncvar.setncattr('bit2_is_set', 'time-point for S1A simulation')\n ncvar.setncattr('bit3_is_set', 'time-point for S1B simulation')\n ncvar.setncattr('bit4_is_set', 'time-point for S2A simulation')\n ncvar.setncattr('bit5_is_set', 'time-point for S2B simulation')\n \n #-- illumination-view geometry\n ncvar = ncfp.createVariable( 'ivgeom', ivgeom.dtype, ('npoints','ngeo'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('sza','igeo: 0')\n ncvar.setncattr('saa','igeo: 1')\n ncvar.setncattr('vza','igeo: 2')\n ncvar.setncattr('vaa','igeo: 3')\n ncvar[:,:] = ivgeom[:,:]\n \n #-- global attributes\n ncfp.setncattr('creator_name',\"The Inversion Lab, Hamburg, Germany\")\n ncfp.setncattr('creator_email', \"Michael.Vossbeck(at)Inversion-Lab.com\")\n ncfp.setncattr('netcdf_libversion',\"{}\".format(nc4.__netcdf4libversion__))\n ncfp.setncattr('date_created',\"{}\".format(dt.datetime.utcnow().isoformat()))\n ncfp.setncattr('time_coverage_start',time_coverage_start)\n ncfp.setncattr('time_coverage_end',time_coverage_end)\n\n #-- close file pointer\n ncfp.close()\n\n # logging\n msg = \"...writing ***{}*** DONE\".format(act_outname)\n FileLogger.info(msg)","def check_condor(self):\n\n self.cluster=self.info['mw_run']['1']\n self.norm_with_cross=self.info['mw_run']['4']\n self.condor_req=self.info['mw_run']['11']\n\n #type is automaticaly updated now\n #self.cluster=int(condor)\n #if norm_with_cross==\"F\":\n # self.norm_with_cross=0\n #else:\n # self.norm_with_cross=1","def receiveCallback(self, socket, stateMask):\n # read the PDU header\n pduHeader = self.recv(EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE)\n if pduHeader == None:\n # failure handling was done automatically by derived logic\n return\n # consistency check\n pduHeaderLen = len(pduHeader)\n if pduHeaderLen != EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE:\n LOG_ERROR(\"Read of PDU header failed: invalid size: \" + str(pduHeaderLen))\n self.disconnectClient()\n return\n pdu = EGSE.EDENPDU.PDU(pduHeader)\n # read the data field for the PDU\n dataFieldLength = pdu.dataFieldLength\n if dataFieldLength > 0:\n dataField = self.recv(dataFieldLength)\n if dataField == None:\n # failure handling was done automatically by derived logic\n return\n # consistency check\n remainingSizeRead = len(dataField)\n if remainingSizeRead != dataFieldLength:\n LOG_ERROR(\"Read of remaining PDU failed: invalid remaining size: \" + str(remainingSizeRead))\n self.disconnectClient()\n return\n pdu.setDataField(dataField)\n # dispatch depending on pduType and subType\n try:\n if pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\n # (TC,SPACE)\n LOG_INFO(\"EDEN.Server.receiveCallback(TC,SPACE)\")\n tcSpacePDU = EGSE.EDENPDU.TCspace(pdu.buffer)\n if self.notifyTcSpace(tcSpacePDU.getCCSDSpacket()):\n # forwarding OK\n self.sendTc_eSpace(tcSpacePDU, 0)\n self.sendTc_aSpace(0, tcSpacePDU.tcIdentificationWord)\n else:\n # forwarding failed\n self.sendTc_eSpace(tcSpacePDU, 1)\n self.sendTc_aSpace(1, tcSpacePDU.tcIdentificationWord)\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\n # (TC,SCOE)\n LOG_INFO(\"EDEN.Server.receiveCallback(TC,SCOE)\")\n tcScoePDU = EGSE.EDENPDU.TCscoe(pdu.buffer)\n if self.notifyTcScoe(tcScoePDU.getCCSDSpacket()):\n # forwarding OK\n self.sendTc_eScoe(tcScoePDU, 0)\n self.sendTc_aScoe(0, tcScoePDU.tcIdentificationWord)\n else:\n # forwarding failed\n self.sendTc_eScoe(tcScoePDU, 1)\n self.sendTc_aScoe(1, tcScoePDU.tcIdentificationWord)\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType))\n LOG(\"PDU = \" + str(pdu))\n self.disconnectClient()\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_CMD:\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_EXEC:\n # (CMD,EXEC)\n LOG_INFO(\"EDEN.Server.receiveCallback(CMD,EXEC)\")\n self.notifyCmdExec(pdu.getDataField().tostring())\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid subType: \" + str(pdu.subType))\n LOG(\"PDU = \" + str(pdu))\n self.disconnectClient()\n else:\n LOG_ERROR(\"Read of PDU header failed: invalid pduType: \" + str(pdu.pduType))\n LOG(\"PDU = \" + str(pdu))\n self.disconnectClient()\n except Exception as ex:\n LOG_ERROR(\"Processing of received PDU failed: \" + str(ex))\n self.disconnectClient()","def on_ctcp(self, raw_msg, source, msg, **kwargs):","def test_scp_callback_return_dataset_no_status(self):\n self.scp = DummyVerificationSCP()\n self.scp.status = Dataset()\n self.scp.start()\n\n ae = AE()\n ae.add_requested_context(VerificationSOPClass)\n assoc = ae.associate('localhost', 11112)\n assert assoc.is_established\n rsp = assoc.send_c_echo()\n assert rsp.Status == 0x0000\n assoc.release()\n self.scp.stop()","def check_config(self):\n assert 'AUTO' in self.config\n assert 'LAT' in self.config\n assert 'LON' in self.config\n assert 'ALL_CHANNELS' in self.config\n for key in self.extract_servo_channels():\n assert 'STATUS' in self.config[key]\n self.config[key]['STATUS'] = float(self.config[key]['STATUS'])\n assert 0.0 <= self.config[key]['STATUS'] <= 1.0\n\n if not 'SUNRISE_BUFFER' in self.config[key]:\n self.config[key]['SUNRISE_BUFFER'] = 0\n if not 'SUNSET_BUFFER' in self.config[key]:\n self.config[key]['SUNSET_BUFFER'] = 0","def check_cdfIntegrity(self, step):\n # Selecting bins automatically:\n x_max = self.onpower_train.max().values[0]\n x_min = 0\n step = 1\n x_onpower = np.arange(x_min, x_max, step).reshape(-1, 1)\n\n x_max = 0\n x_min = self.offpower_train.min().values[0]\n step = 1\n x_offpower = np.arange(x_min, x_max, step).reshape(-1, 1)\n\n x_max = self.duration_train.max().values[0]\n x_min = 0\n step = 1\n x_duration = np.arange(x_min, x_max, step).reshape(-1, 1)\n\n # Evaluating score for:\n # Onpower\n y_onpower = self.__pdf2(self.onpower, x_onpower)\n print(\"Onpower cdf: \" + str(y_onpower.sum()))\n\n # Offpower\n y_offpower = self.__pdf2(self.offpower, x_offpower)\n print(\"Offpower cdf: \" + str(y_offpower.sum()))\n\n # duration\n y_duration = self.__pdf2(self.duration, x_duration)\n print(\"Duration cdf: \" + str(y_duration.sum()))\n\n # Plots:\n # fig1 = plt.figure()\n # ax1 = fig1.add_subplot(311)\n # ax2 = fig1.add_subplot(312)\n # ax3 = fig1.add_subplot(313)\n\n # ax1.plot(x_onpower, y_onpower)\n # ax1.set_title(\"PDF CDF: Onpower\")\n # ax1.set_ylabel(\"density\")\n # ax1.set_xlabel(\"Watts\")\n\n # ax2.plot(x_offpower, y_offpower)\n # ax2.set_title(\" PDF CDF: Offpower\")\n # ax2.set_ylabel(\"denisty\")\n # ax2.set_xlabel(\"Watts\")\n\n # ax3.plot(x_duration, y_duration)\n # ax3.set_title(\"PDF CDF: Duration\")\n # ax3.set_ylabel(\"density\")\n # ax3.set_xlabel(\"Seconds\")","def testCC(self):\n self.assertEqual(\n self.cc,\n self.cd.cc\n )","def validateChanBin(self):\n\n casalog.origin(\"ParallelDataHelper\")\n \n retval = True\n \n # Get the parameter name, which depends on the task calling this class\n parname = self.getChanAvgParamName()\n casalog.post('Channel average parameter is called %s'%parname,'DEBUG1')\n if parname == None:\n retval = False\n \n elif self.__args.has_key(parname):\n fblist = self.__args[parname]\n if isinstance(fblist,list): \n \n if fblist.__len__() > 1:\n if self.__spwList == None: \n msTool = mstool()\n msTool.open(self.__args['vis'])\n spwsel = self.__args['spw'] \n msTool.msselect({'spw':spwsel})\n ddInfo = msTool.getspectralwindowinfo()\n self.__spwList = [info['SpectralWindowId'] for info in ddInfo.values()]\n msTool.close()\n \n if self.__spwList.__len__() != fblist.__len__():\n retval = False\n raise ValueError, 'Number of %s is different from the number of spw' %parname \n \n\n return retval","def test_check_cds_12(self):\n self.cds1.stop = -1\n import_genome.check_cds(self.cds1, self.eval_flags)\n count = count_status(self.cds1, \"error\")\n self.assertEqual(count, 1)","def test_check_cds_16(self):\n self.cds1.locus_tag = \"ABCXYZ\"\n import_genome.check_cds(self.cds1, self.eval_flags)\n count = count_status(self.cds1, \"error\", \"warning\")\n self.assertEqual(count, 1)","def data_received(self, data):\n pass","def dataValidation(self, in_nc):\r\n vars_oi_index = None\r\n data_nc = NET.Dataset(in_nc)\r\n dims = list(data_nc.dimensions)\r\n if dims not in self.dims_oi:\r\n raise Exception(self.errorMessages[1])\r\n\r\n vars = list(data_nc.variables)\r\n\r\n if vars == self.vars_oi[0]:\r\n vars_oi_index = 0\r\n elif vars == self.vars_oi[1]:\r\n vars_oi_index = 1\r\n elif vars == self.vars_oi[2]: # Line Added/Modified CJB 20190108\r\n vars_oi_index = 2 # Line Added/Modified CJB 20190108\r\n else: \r\n raise Exception(self.errorMessages[2])\r\n\r\n return vars_oi_index","def read_mmclx_save_nc(mmclx_filename, nc_filename):\n\n # Open .mmclx file\n mmclx = xr.open_dataset(mmclx_filename)\n\n # Create .nc file with necessary variables\n ncfile = mmclx[\n [\n \"Ze\",\n \"VEL\",\n \"LDR\",\n \"RHO\",\n \"DPS\",\n \"NyquistVelocity\",\n \"nave\",\n \"nfft\",\n \"prf\",\n \"zrg\",\n \"drg\",\n ]\n ]\n # Invert order of dimensions\n ncfile = ncfile.transpose()\n\n # Convert + change attributes of time dimension\n ncfile[\"time\"] = (\n \"time\",\n pd.to_datetime(ncfile.time.values, unit=\"s\"),\n {\"long_name\": \"Time in epoch reference\", \"standard_name\": \"time\"},\n )\n # Change attributes of range dimension\n ncfile[\"range\"] = ncfile.range.assign_attrs(\n {\n \"long_name\": \"Range from antenna to the centre of each range gate\",\n \"standard_name\": \"range\",\n }\n )\n\n # Create additional instrument parameters\n ncfile[\"pulse_width\"] = float(\n ncfile.hrd[\n (ncfile.hrd.find(\"\\nPULSE_WIDTH:\") + 15) : ncfile.hrd.find(\n \"\\nRX_PULSEWIDTH:\"\n )\n ]\n )\n ncfile[\"pulse_width\"] = ncfile.pulse_width.assign_attrs(\n {\n \"long_name\": \"Pulse Width\",\n \"units\": \"s\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"hrd['PULSE_WIDTH']\",\n }\n )\n ncfile[\"prt\"] = 2e-4\n ncfile[\"prt\"] = ncfile.prt.assign_attrs(\n {\n \"long_name\": \"Pulse repetition time\",\n \"units\": \"s\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"\",\n }\n )\n ncfile[\"frequency\"] = 35e9\n ncfile[\"frequency\"] = ncfile.frequency.assign_attrs(\n {\n \"long_name\": \"Radiation Frequency\",\n \"units\": \"s^-1\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"\",\n }\n )\n ncfile[\"latitude\"] = float(ncfile.Latitude[:-1])\n ncfile[\"latitude\"] = ncfile.latitude.assign_attrs(\n {\n \"long_name\": \"Latitude\",\n \"units\": \"degrees_north\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"Latitude\",\n }\n )\n ncfile[\"longitude\"] = float(ncfile.Longitude[:-1])\n ncfile[\"longitude\"] = ncfile.longitude.assign_attrs(\n {\n \"long_name\": \"Longitude\",\n \"units\": \"degrees_east\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"Longitude\",\n }\n )\n ncfile[\"altitude\"] = float(ncfile.Altitude[:-1])\n ncfile[\"altitude\"] = ncfile.altitude.assign_attrs(\n {\n \"long_name\": \"Altitude\",\n \"units\": \"m\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"Altitude\",\n }\n )\n\n # Change names of variables\n ncfile = ncfile.rename_vars(\n {\n \"Ze\": \"filtered_reflectivity\",\n \"VEL\": \"filtered_velocity\",\n \"LDR\": \"filtered_linear_depolarization_ratio\",\n \"RHO\": \"cross_correlation_ratio\",\n \"DPS\": \"differential_phase\",\n \"NyquistVelocity\": \"nyquist_velocity\",\n \"nave\": \"n_samples\",\n \"nfft\": \"n_fft\",\n \"zrg\": \"n_range_gates\",\n \"drg\": \"range_resolution\",\n }\n )\n\n # Convert dBZ variables to dBZ\n ncfile.filtered_reflectivity.values = 10 * np.log10(\n ncfile.filtered_reflectivity.values\n )\n ncfile.filtered_linear_depolarization_ratio.values = 10 * np.log10(\n ncfile.filtered_linear_depolarization_ratio.values\n )\n\n # Change attributes of variables\n ncfile[\"filtered_reflectivity\"] = ncfile.filtered_reflectivity.assign_attrs(\n {\n \"units\": \"dBZ\",\n \"valid_range\": ncfile.filtered_reflectivity.attrs.pop(\"yrange\"),\n \"standard_name\": \"Ze\",\n \"long_name\": \"Filtered Equivalent Reflectivity Factor\",\n }\n )\n ncfile[\"filtered_velocity\"] = ncfile.filtered_velocity.assign_attrs(\n {\n \"units\": \"m * s^-1\",\n \"valid_range\": ncfile.filtered_velocity.attrs.pop(\"yrange\"),\n \"standard_name\": \"VEL\",\n \"long_name\": \"Filtered Mean Doppler Velocity\",\n }\n )\n ncfile[\n \"filtered_linear_depolarization_ratio\"\n ] = ncfile.filtered_linear_depolarization_ratio.assign_attrs(\n {\n \"units\": \"dB\",\n \"valid_range\": ncfile.filtered_linear_depolarization_ratio.attrs.pop(\n \"yrange\"\n ),\n \"standard_name\": \"LDR\",\n \"long_name\": \"Filtered Linear De-Polarization Ratio\",\n }\n )\n ncfile[\n \"cross_correlation_ratio\"\n ] = ncfile.cross_correlation_ratio.assign_attrs(\n {\n \"units\": \"unitless\",\n \"valid_range\": ncfile.cross_correlation_ratio.attrs.pop(\"yrange\"),\n \"standard_name\": \"RHO\",\n \"long_name\": \"Co-Cross Correlation Ratio\",\n }\n )\n ncfile[\"differential_phase\"] = ncfile.differential_phase.assign_attrs(\n {\n \"units\": \"degrees\",\n \"valid_range\": ncfile.differential_phase.attrs.pop(\"yrange\"),\n \"standard_name\": \"DPS\",\n \"long_name\": \"Differential Phase\",\n }\n )\n ncfile[\"nyquist_velocity\"] = ncfile.nyquist_velocity.assign_attrs(\n {\n \"units\": \"m * s^-1\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"NyquistVelocity\",\n \"long_name\": \"Nyquist Velocity\",\n }\n )\n ncfile[\"n_samples\"] = ncfile.n_samples.assign_attrs(\n {\n \"units\": \"unitless\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"nave\",\n \"long_name\": \"Number of spectral averages used to compute moments\",\n }\n )\n ncfile[\"n_fft\"] = ncfile.n_fft.assign_attrs(\n {\n \"units\": \"unitless\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"nfft\",\n \"long_name\": \"Number of FFT points\",\n }\n )\n ncfile[\"prf\"] = ncfile.prf.assign_attrs(\n {\n \"units\": \"Hz\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"prf\",\n \"long_name\": \"Pulse Repetition Frequency\",\n }\n )\n ncfile[\"n_range_gates\"] = ncfile.n_range_gates.assign_attrs(\n {\n \"units\": \"unitless\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"zrg\",\n \"long_name\": \"Number of range gates\",\n }\n )\n ncfile[\"range_resolution\"] = ncfile.range_resolution.assign_attrs(\n {\n \"units\": \"m\",\n \"meta_group\": \"instrument_parameters\",\n \"standard_name\": \"drg\",\n \"long_name\": \"Range resolution\",\n }\n )\n\n # Remove unnecessary attributes of variables\n for var in ncfile.variables:\n for attr in [\"axis\", \"db\", \"unit\"]:\n if attr in ncfile[var].attrs.keys():\n del ncfile[var].attrs[attr]\n\n # Remove unnecessary global attributes\n for attr in [\"Altitude\", \"Latitude\", \"Longitude\", \"ppar\", \"hrd\"]:\n del ncfile.attrs[attr]\n\n # Reorder variables\n ncfile = ncfile[\n [\n \"filtered_reflectivity\",\n \"filtered_velocity\",\n \"filtered_linear_depolarization_ratio\",\n \"cross_correlation_ratio\",\n \"differential_phase\",\n \"nyquist_velocity\",\n \"n_fft\",\n \"prf\",\n \"prt\",\n \"n_range_gates\",\n \"range_resolution\",\n \"n_samples\",\n \"pulse_width\",\n \"frequency\",\n \"latitude\",\n \"longitude\",\n \"altitude\",\n ]\n ]\n\n # Save .nc file\n ncfile.to_netcdf(\n nc_filename,\n unlimited_dims=\"time\",\n encoding={\"time\": {\"units\": \"seconds since 1970-01-01 00:00:00\"}},\n )","def test_netCDF_sample_dimension_groups(self):\n c = cfdm.Count()\n\n c.nc_set_sample_dimension(\"ncvar\")\n\n with self.assertRaises(ValueError):\n c.nc_set_sample_dimension_groups([\"/forecast\"])\n\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n\n attrs = c.nc_clear_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n\n c.nc_set_sample_dimension_groups([\"forecast\", \"model\"])\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertEqual(attrs, (\"forecast\", \"model\"))\n self.assertEqual(c.nc_get_sample_dimension(), \"/forecast/model/ncvar\")\n\n attrs = c.nc_clear_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertEqual(attrs, (\"forecast\", \"model\"))\n\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n self.assertEqual(c.nc_get_sample_dimension(), \"ncvar\")\n\n c.nc_set_sample_dimension(\"ncvar\")\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertEqual(attrs, ())\n\n c.nc_set_sample_dimension(\"/ncvar\")\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n\n c.nc_set_sample_dimension(\"/forecast/model/ncvar\")\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertEqual(attrs, (\"forecast\", \"model\"))\n\n c.nc_del_sample_dimension()\n attrs = c.nc_sample_dimension_groups()\n self.assertIsInstance(attrs, tuple)\n self.assertFalse(attrs)\n\n with self.assertRaises(ValueError):\n c.nc_set_sample_dimension_groups([\"forecast\", \"model\"])","def has_fcc(self):\n raise NotImplementedError","def check_data(self):\n super().check_data()\n\n for session_index, session_data in enumerate(self._data_to_analyse):\n if session_data.DATA_FORMAT != \"PyMEICA\":\n self.invalid_data_help = f\"Non PyMEICA format compatibility not yet implemented: \" \\\n f\"{session_data.DATA_FORMAT}\"\n return False\n\n return True","def _handleRequestCableCheckStatus(self, data):\r\n print(\"\\\"Request Cable Check Status\\\" received\")\r\n self.whitebeet.v2gParseRequestCableCheckStatus(data)\r\n try:\r\n self.whitebeet.v2gSetDcCableCheckStatus(True)\r\n except Warning as e:\r\n print(\"Warning: {}\".format(e))\r\n except ConnectionError as e:\r\n print(\"ConnectionError: {}\".format(e))","def write_to_netCDF(nc_filename, data,\n ncformat='NETCDF4_CLASSIC',\n all_variables=False,\n verbose=True):\n ncfile = Dataset(nc_filename,'w', format=ncformat, clobber=True)\n for dd,dim in enumerate(data['dims']):\n ncfile.createDimension(data['dimname'][dd],dim)\n for vv,varname in enumerate(data['varn']):\n if all_variables:\n newvar = ncfile.createVariable(varname,\n data['vardtype'][vv],\n data['vardims'][vv])\n newvar[:] = data['data'][vv]\n newvar.units = data['units'][vv]\n else:\n if varname in core_variables:\n newvar = ncfile.createVariable(varname,\n data['vardtype'][vv],\n data['vardims'][vv],\n fill_value=data['fillValue'])\n newvar[:] = data['data'][vv]\n if verbose:\n print(varname)\n print(newvar[newvar == np.nan])\n newvar[newvar == np.nan] = data['fillValue']\n newvar.units = data['units'][vv]\n ncfile.createDimension('nchars',19)\n newvar[:] = data['time']\n ncfile.description = data['description']\n ncfile.station = data['station']\n ncfile.sensor = data['sensor']\n ncfile.latitude = data['latitude']\n ncfile.longitude = data['longitude']\n ncfile.altitude = data['altitude']\n ncfile.createdon = datetime.now().strftime(standard_datetime_fmt)\n ncfile.createdby = data['author']\n ncfile.close()","def test_cds_invalid_coordinates(self):\n for i in (-10, -1, 6, 100):\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))","def test_cds_invalid_coordinates(self):\n for i in (-10, -1, 6, 100):\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))","def test_cds_invalid_coordinates(self):\n for i in (-10, -1, 4, 100):\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))"],"string":"[\n \"def _check_data(self):\\n # ================ CHECK DATA / CONNECT / SELECT ================\\n N = self.xyz.shape[0]\\n # Chech array :\\n if (self.connect.shape != (N, N)) or not isinstance(self.connect,\\n np.ndarray):\\n raise ValueError(\\\"c_connect must be an array of \\\"\\n \\\"shape \\\" + str((N, N)))\\n if self.select is None:\\n self.select = np.ones_like(self.connect)\\n if (self.select.shape != (N, N) or not isinstance(self.select,\\n np.ndarray)):\\n raise ValueError(\\\"c_select must be an array of \\\"\\n \\\"shape \\\" + str((N, N)))\\n # Mask c_connect :\\n try:\\n self.connect.mask\\n except:\\n self.connect = np.ma.masked_array(self.connect, mask=True)\\n self.connect.mask[self.select.nonzero()] = False\\n # Use specific color values :\\n if (self.colval is not None) and isinstance(self.colval, dict):\\n mask = np.ones_like(self.connect.mask)\\n for k, v in zip(self.colval.keys(), self.colval.values()):\\n mask[self.connect.data == k] = False\\n self.colval[k] = color2vb(v)\\n self.connect.mask = mask\\n\\n # ================ CHECK COLOR ================\\n # Check colorby :\\n if self.colorby not in ['count', 'strength', 'density']:\\n raise ValueError(\\\"The c_colorby parameter must be 'count', \\\"\\n \\\"'strength' or 'density'\\\")\\n # Test dynamic :\\n if (self.dynamic is not None) and not isinstance(self.dynamic, tuple):\\n raise ValueError(\\\"c_dynamic bust be a tuple\\\")\\n\\n # ================ NON-ZERO INDICES ================\\n # Find where there is non-masked connections :\\n self._nnz_x, self._nnz_y = np.where(~self.connect.mask)\\n self._indices = np.c_[self._nnz_x, self._nnz_y].flatten()\\n self._Nindices = np.arange(len(self._indices))\\n # Build position array :\\n self.a_position = np.zeros((2*len(self._nnz_x), 3), dtype=np.float32)\\n self.a_position[self._Nindices, :] = self.xyz[self._indices, :]\",\n \"def test_solar_cc():\\n\\n features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']\\n input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]\\n nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')\\n\\n with xr.open_mfdataset(input_files) as fh:\\n min_lat = np.min(fh.lat.values)\\n min_lon = np.min(fh.lon.values) - 360\\n target = (min_lat, min_lon)\\n shape = (len(fh.lat.values), len(fh.lon.values))\\n\\n with pytest.raises(AssertionError):\\n handler = DataHandlerNCforCC(input_files, features=features,\\n target=target, shape=shape,\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n\\n handler = DataHandlerNCforCC(input_files, features=features,\\n nsrdb_source_fp=nsrdb_source_fp,\\n target=target, shape=shape,\\n temporal_slice=slice(0, 1),\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n\\n cs_ratio = handler.data[..., 0]\\n ghi = handler.data[..., 1]\\n cs_ghi = handler.data[..., 2]\\n cs_ratio_truth = ghi / cs_ghi\\n\\n assert cs_ratio.max() < 1\\n assert cs_ratio.min() > 0\\n assert (ghi < cs_ghi).all()\\n assert np.allclose(cs_ratio, cs_ratio_truth)\\n\\n with Resource(nsrdb_source_fp) as res:\\n meta = res.meta\\n tree = KDTree(meta[['latitude', 'longitude']])\\n cs_ghi_true = res['clearsky_ghi']\\n\\n # check a few sites against NSRDB source file\\n for i in range(4):\\n for j in range(4):\\n test_coord = handler.lat_lon[i, j]\\n _, inn = tree.query(test_coord)\\n\\n assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j])\",\n \"def test_ccds(self):\\n #TODO write ccds tests\",\n \"def __init__(self, datafile):\\r\\n super(type(self), self).__init__()\\r\\n self.data = None\\r\\n log.info(\\\"Trying to read netcdf \\\"+datafile)\\r\\n try:\\r\\n # We have to uncompress the file to a temporary file\\r\\n # This will be deleted on __del__ cleanup\\r\\n datafile = super(type(self), self).uncompressTempFile(datafile)\\r\\n self.data = Scientific.IO.NetCDF.NetCDFFile(datafile, \\\"r\\\")\\r\\n except BaseException as e:\\r\\n log.error(\\\"Couldn't read netcdf data from file \\\"+datafile)\\r\\n log.error(\\\"Exception {0}\\\".format(e))\",\n \"def read_netcdf(self,filename):\",\n \"def sanity_check_step(self):\\n\\n incs = [\\\"netcdf.h\\\"]\\n libs = [\\\"libnetcdf.so\\\", \\\"libnetcdf.a\\\"]\\n # since v4.2, the non-C libraries have been split off in seperate extensions_step\\n # see netCDF-Fortran and netCDF-C++\\n if LooseVersion(self.version) < LooseVersion(\\\"4.2\\\"):\\n incs += [\\\"netcdf%s\\\" % x for x in [\\\"cpp.h\\\", \\\".hh\\\", \\\".inc\\\", \\\".mod\\\"]] + \\\\\\n [\\\"ncvalues.h\\\", \\\"typesizes.mod\\\"]\\n libs += [\\\"libnetcdf_c++.so\\\", \\\"libnetcdff.so\\\",\\n \\\"libnetcdf_c++.a\\\", \\\"libnetcdff.a\\\"]\\n\\n custom_paths = {\\n 'files': [\\\"bin/nc%s\\\" % x for x in [\\\"-config\\\", \\\"copy\\\", \\\"dump\\\",\\n \\\"gen\\\", \\\"gen3\\\"]] +\\n [\\\"lib/%s\\\" % x for x in libs] +\\n [\\\"include/%s\\\" % x for x in incs],\\n 'dirs': []\\n }\\n\\n super(EB_netCDF, self).sanity_check_step(custom_paths=custom_paths)\",\n \"def __init__(self):\\n self.datasets = [\\\"ISCCP\\\",\\\"ISCCP_raw\\\",\\\"PATMOSX\\\",\\\"PATMOSX_raw\\\"]\\n f = cdms.open(\\\"OBS/clt_ISCCP_corrected_198301-200912.nc\\\")\\n fp = cdms.open(\\\"OBS/clt_PATMOSX_corrected_198301-200912.nc\\\")\\n \\n f_old = cdms.open(\\\"OBS/clt_ISCCP_198307-200806.nc\\\")\\n fp_old = cdms.open(\\\"OBS/clt_PATMOSX_198200-200912.nc\\\")\\n\\n fgpcp = cdms.open(\\\"OBS/GPCP.precip.mon.mean.nc\\\")\\n fcmap = cdms.open(\\\"OBS/CMAP.std.precip.mon.mean.nc\\\")\\n \\n \\n self.ISCCP = f(\\\"clt\\\",time=('1984-1-1','2009-12-31'))\\n self.ISCCP = MV.masked_where(np.isnan(self.ISCCP),self.ISCCP)\\n cdutil.setTimeBoundsMonthly(self.ISCCP)\\n\\n self.PATMOSX = fp(\\\"clt\\\",time=('1984-1-1','2009-12-31'))\\n self.PATMOSX = MV.masked_where(np.isnan(self.PATMOSX),self.PATMOSX)\\n cdutil.setTimeBoundsMonthly(self.PATMOSX)\\n\\n self.ISCCP_raw = f_old(\\\"clt\\\",time=('1984-1-1','2008-6-31'))\\n self.ISCCP_raw = MV.masked_where(np.isnan(self.ISCCP_raw),self.ISCCP_raw)\\n cdutil.setTimeBoundsMonthly(self.ISCCP_raw)\\n\\n self.PATMOSX_raw = fp_old(\\\"clt\\\",time=('1982-1-1','2009-12-31'))\\n self.PATMOSX_raw = MV.masked_where(np.isnan(self.PATMOSX_raw),self.PATMOSX_raw)\\n cdutil.setTimeBoundsMonthly(self.PATMOSX_raw)\\n\\n self.GPCP = cdutil.averager(fgpcp(\\\"precip\\\",time=('1979-1-1','2014-12-31'),latitude=(-90,90)),axis='x')\\n cdutil.setTimeBoundsMonthly(self.GPCP)\\n self.CMAP = cdutil.averager(fcmap(\\\"precip\\\",time=('1979-1-1','2014-12-31'),latitude=(-90,90)),axis='x')\\n self.CMAP.setAxis(0,self.GPCP.getTime())\\n cdutil.setTimeBoundsMonthly(self.CMAP)\",\n \"def have_cdc() -> bool:\",\n \"def __init__(self, datafile):\\r\\n super(type(self), self).__init__()\\r\\n log.info(\\\"Trying to read netcdf \\\"+datafile)\\r\\n try:\\r\\n # We have to uncompress the file to a temporary file\\r\\n # This will be deleted on __del__ cleanup\\r\\n datafile = \\\\\\r\\n netcdf_reader.netcdfReader.uncompressTempFile(self, datafile) \\r\\n self.data = arcpy.NetCDFFileProperties(datafile)\\r\\n except BaseException as e:\\r\\n log.error(\\\"Couldn't read netcdf data from file \\\"+datafile)\\r\\n log.error(\\\"Exception {0}\\\".format(e))\\r\\n \\r\\n def __del__(self):\\r\\n # Close our file before calling superclass, since superclass might delete it\\r\\n if self.data:\\r\\n self.data.close()\\r\\n super(type(self), self).__del__()\",\n \"def write_netcdf(file,xc,xc_bnd,yc,yc_bnd,times,hydrographs,fractions,loc,Flist,velocity,diffusion,NODATA,verbose):\\n \\n f = Dataset(file,'w', format='NETCDF4')\\n\\n # set dimensions\\n time = f.createDimension('time', None)\\n x = f.createDimension('x',xc.shape[1])\\n y = f.createDimension('y',xc.shape[0])\\n nv4 = f.createDimension('nv4',4)\\n\\n # initialize variables\\n time = f.createVariable('time','f8',('time',))\\n xcs = f.createVariable('xc','f8',('y','x',))\\n ycs = f.createVariable('yc','f8',('y','x',))\\n xc_bnds = f.createVariable('xc_bnds','f8',('y','x','nv4',))\\n yc_bnds = f.createVariable('yc_bnds','f8',('y','x','nv4',))\\n fraction = f.createVariable('fraction','f8',('y','x',),fill_value=NODATA)\\n UHS = f.createVariable('unit_hydrograph','f8',('time','y','x',),fill_value=NODATA)\\n\\n # write attributes for netcdf\\n f.description = 'Aggregated UH_S and Fraction Vars for full RASM domain'\\n f.history = 'Created: {}\\\\n'.format(tm.ctime(tm.time()))\\n f.history += ' '.join(sys.argv) + '\\\\n'\\n f.source = sys.argv[0] # prints the name of script used\\n f.velocity = velocity\\n f.diffusion = diffusion\\n f.outlet_lon = loc[0]\\n f.outlet_lat = loc[1]\\n f.includes = str(len(Flist))+' files'\\n\\n ycs.long_name = 'latitude of grid cell center'\\n ycs.standard_name = 'latitude'\\n ycs.units = 'degrees_north'\\n ycs._CoordinateAxisType = 'Lat'\\n ycs.bounds = 'yc_bnds'\\n\\n xcs.long_name = 'longitude of grid cell center'\\n xcs.standard_name = 'longitude'\\n xcs.units = 'degrees_east'\\n xcs._CoordinateAxisType = 'Lon'\\n xcs.bounds = 'xc_bnds'\\n\\n time.standard_name = 'time'\\n time.units = 'seconds'\\n time.description = 'Seconds since initial impulse'\\n time.calendar = 'proleptic_gregorian'\\n\\n UHS.units = 'unitless'\\n UHS.description = 'unit hydrograph for each grid cell with respect to basin outlet location'\\n \\n fraction.units = 'unitless'\\n fraction.description = 'fraction of grid cell contributing to guage location'\\n\\n # write data to variables initialized above\\n time[:]= times\\n xcs[:,:] = xc\\n ycs[:,:] = yc\\n xc_bnds[:,:,:] = xc_bnd\\n yc_bnds[:,:,:] = yc_bnd\\n UHS[:,:,:] = hydrographs\\n fraction[:,:]= fractions\\n f.close()\\n\\n return\",\n \"def inputs_netCDF(ID, fname, data):\\n\\n from netCDF4 import Dataset #, date2num, num2date\\n from datetime import datetime\\n\\n print('**** creating SpaFHy input netCDF4 file: ' + fname + ' ****')\\n \\n # create dataset & dimensions\\n ncf = Dataset(fname, 'w')\\n ncf.description = 'SpatialData from : ' + str(ID)\\n ncf.history = 'created ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\n ncf.source = 'SpaFHy v.1.0 inputs'\\n \\n dlat, dlon = np.shape(data['cmask'])\\n\\n ncf.createDimension('dlon', int(dlon))\\n ncf.createDimension('dlat', int(dlat))\\n ncf.createDimension('scalar', 1)\\n\\n # create variables \\n # call as createVariable(varname,type,(dimensions))\\n cellsize = ncf.createVariable('cellsize', 'f4', ('scalar',))\\n cellsize.units = 'm'\\n lat = ncf.createVariable('lat', 'f4', ('dlat',))\\n lat.units = 'ETRS-TM35FIN'\\n lon = ncf.createVariable('lon', 'f4', ('dlon',))\\n lon.units = 'ETRS-TM35FIN'\\n\\n cellsize[0] = data['cellsize']\\n lon[:] = data['lon0']\\n lat[:] = data['lat0']\\n \\n # required inputs\\n cmask = ncf.createVariable('cmask', 'i4', ('dlat','dlon',))\\n cmask.units = 'integer inside catchment, Nan outside'\\n LAI_conif = ncf.createVariable('LAI_conif', 'f4', ('dlat','dlon',))\\n LAI_conif.units = 'conifer LAI (m2m-2)'\\n LAI_decid = ncf.createVariable('LAI_decid', 'f4', ('dlat','dlon',))\\n LAI_decid.units = 'deciduous annual max LAI (m2m-2)' \\n hc = ncf.createVariable('hc', 'f4', ('dlat','dlon',))\\n hc.units = 'canopy height m' \\n cf = ncf.createVariable('cf', 'f4', ('dlat','dlon',))\\n cf.units = 'canopy closure (-)' \\n \\n soilclass = ncf.createVariable('soilclass', 'i4', ('dlat','dlon',))\\n soilclass.units = 'soil class (1 - 5)'\\n \\n flowacc = ncf.createVariable('flowacc', 'f4', ('dlat','dlon',))\\n flowacc.units = 'flow accumualtion area m2'\\n slope = ncf.createVariable('slope', 'f4', ('dlat','dlon',))\\n slope.units = 'local slope (deg)' \\n \\n for k in ['LAI_conif', 'LAI_decid', 'hc', 'cf', 'soilclass', 'flowacc', 'slope']:\\n ncf[k][:,:] = data[k]\\n \\n print('**** done ****')\",\n \"def _initialize_output(self, time_len, id_len):\\r\\n\\r\\n log('Initializing new file %s' % self.cf_compliant_file, 'INFO')\\r\\n \\r\\n self.cf_nc = Dataset(self.cf_compliant_file, 'w', format='NETCDF3_CLASSIC')\\r\\n \\r\\n # Create global attributes\\r\\n log(' globals', 'DEBUG', self.print_debug)\\r\\n self.cf_nc.featureType = 'timeSeries'\\r\\n self.cf_nc.Metadata_Conventions = 'Unidata Dataset Discovery v1.0'\\r\\n self.cf_nc.Conventions = 'CF-1.6'\\r\\n self.cf_nc.cdm_data_type = 'Station'\\r\\n self.cf_nc.nodc_template_version = (\\r\\n 'NODC_NetCDF_TimeSeries_Orthogonal_Template_v1.1')\\r\\n self.cf_nc.standard_name_vocabulary = ('NetCDF Climate and Forecast (CF) ' +\\r\\n 'Metadata Convention Standard Name ' +\\r\\n 'Table v28')\\r\\n self.cf_nc.title = 'RAPID Result'\\r\\n self.cf_nc.summary = (\\\"Results of RAPID river routing simulation. Each river \\\" +\\r\\n \\\"reach (i.e., feature) is represented by a point \\\" +\\r\\n \\\"feature at its midpoint, and is identified by the \\\" +\\r\\n \\\"reach's unique NHDPlus COMID identifier.\\\")\\r\\n self.cf_nc.time_coverage_resolution = 'point'\\r\\n self.cf_nc.geospatial_lat_min = 0.0\\r\\n self.cf_nc.geospatial_lat_max = 0.0\\r\\n self.cf_nc.geospatial_lat_units = 'degrees_north'\\r\\n self.cf_nc.geospatial_lat_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_lon_min = 0.0\\r\\n self.cf_nc.geospatial_lon_max = 0.0\\r\\n self.cf_nc.geospatial_lon_units = 'degrees_east'\\r\\n self.cf_nc.geospatial_lon_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_vertical_min = 0.0\\r\\n self.cf_nc.geospatial_vertical_max = 0.0\\r\\n self.cf_nc.geospatial_vertical_units = 'm'\\r\\n self.cf_nc.geospatial_vertical_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_vertical_positive = 'up'\\r\\n self.cf_nc.project = self.project_name\\r\\n self.cf_nc.processing_level = 'Raw simulation result'\\r\\n self.cf_nc.keywords_vocabulary = ('NASA/Global Change Master Directory ' +\\r\\n '(GCMD) Earth Science Keywords. Version ' +\\r\\n '8.0.0.0.0')\\r\\n self.cf_nc.keywords = 'DISCHARGE/FLOW'\\r\\n self.cf_nc.comment = 'Result time step(s) (seconds): ' + str(self.time_step_array)\\r\\n \\r\\n timestamp = datetime.utcnow().isoformat() + 'Z'\\r\\n self.cf_nc.date_created = timestamp\\r\\n self.cf_nc.history = (timestamp + '; added time, lat, lon, z, crs variables; ' +\\r\\n 'added metadata to conform to NODC_NetCDF_TimeSeries_' +\\r\\n 'Orthogonal_Template_v1.1')\\r\\n \\r\\n # Create dimensions\\r\\n log(' dimming', 'DEBUG', self.print_debug)\\r\\n self.cf_nc.createDimension('time', time_len)\\r\\n self.cf_nc.createDimension(self.output_id_dim_name, id_len)\\r\\n \\r\\n # Create variables\\r\\n log(' timeSeries_var', 'DEBUG', self.print_debug)\\r\\n timeSeries_var = self.cf_nc.createVariable(self.output_id_dim_name, 'i4', \\r\\n (self.output_id_dim_name,))\\r\\n timeSeries_var.long_name = (\\r\\n 'Unique NHDPlus COMID identifier for each river reach feature')\\r\\n timeSeries_var.cf_role = 'timeseries_id'\\r\\n \\r\\n log(' time_var', 'DEBUG', self.print_debug)\\r\\n time_var = self.cf_nc.createVariable('time', 'i4', ('time',))\\r\\n time_var.long_name = 'time'\\r\\n time_var.standard_name = 'time'\\r\\n time_var.units = 'seconds since 1970-01-01 00:00:00 0:00'\\r\\n time_var.axis = 'T'\\r\\n \\r\\n #only add if user adds\\r\\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\\r\\n log(' lat_var', 'DEBUG', self.print_debug)\\r\\n lat_var = self.cf_nc.createVariable('lat', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n lat_var.long_name = 'latitude'\\r\\n lat_var.standard_name = 'latitude'\\r\\n lat_var.units = 'degrees_north'\\r\\n lat_var.axis = 'Y'\\r\\n \\r\\n log(' lon_var', 'DEBUG', self.print_debug)\\r\\n lon_var = self.cf_nc.createVariable('lon', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n lon_var.long_name = 'longitude'\\r\\n lon_var.standard_name = 'longitude'\\r\\n lon_var.units = 'degrees_east'\\r\\n lon_var.axis = 'X'\\r\\n \\r\\n log(' z_var', 'DEBUG', self.print_debug)\\r\\n z_var = self.cf_nc.createVariable('z', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n z_var.long_name = ('Elevation referenced to the North American ' +\\r\\n 'Vertical Datum of 1988 (NAVD88)')\\r\\n z_var.standard_name = 'surface_altitude'\\r\\n z_var.units = 'm'\\r\\n z_var.axis = 'Z'\\r\\n z_var.positive = 'up'\\r\\n \\r\\n log(' crs_var', 'DEBUG', self.print_debug)\\r\\n crs_var = self.cf_nc.createVariable('crs', 'i4')\\r\\n crs_var.grid_mapping_name = 'latitude_longitude'\\r\\n crs_var.epsg_code = 'EPSG:4326' # WGS 84\\r\\n crs_var.semi_major_axis = 6378137.0\\r\\n crs_var.inverse_flattening = 298.257223563\",\n \"def save_ecco_dataset_to_netcdf(ecco_ds,\\n output_dir,\\n dataset_name = 'by_variable',\\n time_method = 'by_record',\\n output_array_precision = np.float32,\\n output_freq_code=None):\\n\\n\\n # Create a name of the files if not specified\\n # ---------------------------------------------\\n if dataset_name =='by_variable':\\n # concat all data variables together into a single string\\n dataset_name = '_'.join(list(ecco_ds.data_vars))\\n\\n\\n # force load coordinate values in case they are in dask array\\n # -----------------------------------------------------------\\n for coord in ecco_ds.coords:\\n ecco_ds[coord].load()\\n\\n\\n # Define fill values for NaN\\n # ---------------------------------------------\\n if output_array_precision == np.float32:\\n netcdf_fill_value = nc4.default_fillvals['f4']\\n\\n elif output_array_precision == np.float64:\\n netcdf_fill_value = nc4.default_fillvals['f8']\\n\\n\\n # Create NetCDF encoding directives\\n # ---------------------------------------------\\n print('\\\\n... creating variable encodings')\\n # ... data variable encoding directives\\n dv_encoding = dict()\\n for dv in ecco_ds.data_vars:\\n dv_encoding[dv] = {'zlib':True, \\\\\\n 'complevel':5,\\\\\\n 'shuffle':True,\\\\\\n '_FillValue':netcdf_fill_value}\\n\\n # ... coordinate encoding directives\\n print('\\\\n... creating coordinate encodings')\\n coord_encoding = dict()\\n for coord in ecco_ds.coords:\\n # set default no fill value for coordinate\\n if output_array_precision == np.float32:\\n coord_encoding[coord] = {'_FillValue':None, 'dtype':'float32'}\\n elif output_array_precision == np.float64:\\n coord_encoding[coord] = {'_FillValue':None, 'dtype':'float64'}\\n\\n # force 64 bit ints to be 32 bit ints\\n if (ecco_ds[coord].values.dtype == np.int32) or \\\\\\n (ecco_ds[coord].values.dtype == np.int64) :\\n coord_encoding[coord]['dtype'] ='int32'\\n\\n # fix encoding of time\\n if coord == 'time' or coord == 'time_bnds':\\n coord_encoding[coord]['dtype'] ='int32'\\n\\n if 'units' in ecco_ds[coord].attrs:\\n # apply units as encoding for time\\n coord_encoding[coord]['units'] = ecco_ds[coord].attrs['units']\\n # delete from the attributes list\\n del ecco_ds[coord].attrs['units']\\n\\n elif coord == 'time_step':\\n coord_encoding[coord]['dtype'] ='int32'\\n\\n # ... combined data variable and coordinate encoding directives\\n encoding = {**dv_encoding, **coord_encoding}\\n\\n\\n # Create directory for output files\\n # ---------------------------------------------\\n filepath = output_dir / dataset_name\\n\\n if not filepath.exists():\\n filepath.mkdir(parents=True, exist_ok=True)\\n\\n\\n # Determine output freqency code.\\n # ---------------------------------------------\\n # user can specify directory or it can be found if the dataset\\n # has the 'time_coverage_resolution' global attribute\\n if output_freq_code == None:\\n if 'time_coverage_resolution' in ecco_ds.attrs:\\n\\n print('dataset time averaging from metadata')\\n time_coverage_resolution = ecco_ds.attrs['time_coverage_resolution']\\n if time_coverage_resolution == 'P1M':\\n output_freq_code='AVG_MON'\\n elif time_coverage_resolution == 'P1D':\\n output_freq_code='AVG_DAY'\\n elif time_coverage_resolution == 'P0S':\\n output_freq_code='SNAP'\\n else:\\n print('output_freq_code not defined and not available in dataset metadata')\\n print('... using full record time in filename')\\n\\n\\n # Write records to disk as NetCDF\\n # ---------------------------------------------\\n # one file per time level\\n\\n if time_method == 'by_record':\\n for time_i, rec_time in enumerate(ecco_ds.time):\\n\\n cur_ds = ecco_ds.isel(time=time_i)\\n\\n # cast data variables to desired precision (if necessary)\\n #for data_var in cur_ds.data_vars:\\n # if cur_ds[data_var].values.dtype != output_array_precision:\\n # cur_ds[data_var].values = cur_ds[data_var].astype(output_array_precision)\\n\\n time_date_info =\\\\\\n make_date_str_from_dt64(cur_ds.time.values, output_freq_code)\\n\\n # sort comments alphabetically\\n print('\\\\n... sorting global attributes')\\n cur_ds.attrs = sort_attrs(cur_ds.attrs)\\n\\n # add one final comment (PODAAC request)\\n cur_ds.attrs[\\\"coordinates_comment\\\"] = \\\\\\n \\\"Note: the global 'coordinates' attribute descibes auxillary coordinates.\\\"\\n\\n fname = dataset_name + '_' + time_date_info['short'] +\\\\\\n '_' + time_date_info['ppp_tttt'] + '.nc'\\n\\n print(fname)\\n print(cur_ds)\\n netcdf_output_filename = filepath / fname\\n\\n # SAVE\\n print('\\\\n... saving to netcdf ', netcdf_output_filename)\\n cur_ds.to_netcdf(netcdf_output_filename, encoding=encoding)\\n cur_ds.close()\\n\\n # one file per year\\n elif time_method == 'by_year':\\n unique_years = np.unique(ecco_ds.time.dt.year)\\n print(unique_years)\\n\\n for year in unique_years:\\n # pull out only records for this year\\n cur_ds = ecco_ds.sel(time=slice(str(year), str(year)))\\n\\n first_time = cur_ds.time.values[0]\\n last_time = cur_ds.time.values[-1]\\n\\n first_time_date_info =\\\\\\n make_date_str_from_dt64(first_time, output_freq_code)\\n\\n last_time_date_info =\\\\\\n make_date_str_from_dt64(last_time, output_freq_code)\\n\\n # sort comments alphabetically\\n print('\\\\n... sorting global attributes')\\n cur_ds.attrs = sort_attrs(cur_ds.attrs)\\n\\n # add one final comment (PODAAC request)\\n cur_ds.attrs[\\\"coordinates_comment\\\"] = \\\\\\n \\\"Note: the global 'coordinates' attribute descibes auxillary coordinates.\\\"\\n\\n fname = dataset_name + '_' +\\\\\\n first_time_date_info['short'] + '_' +\\\\\\n last_time_date_info['short'] + '_' +\\\\\\n first_time_date_info['ppp_tttt']+ '.nc'\\n\\n print(fname)\\n print(cur_ds)\\n netcdf_output_filename = filepath / fname\\n\\n # SAVE\\n print('\\\\n... saving to netcdf ', netcdf_output_filename)\\n cur_ds.to_netcdf(netcdf_output_filename, encoding=encoding)\\n cur_ds.close()\",\n \"def runTest(self):\\n ncfile = netCDF4.Dataset(URL)\\n assert varname in ncfile.variables.keys()\\n var = ncfile.variables[varname]\\n assert var.shape == varshape\\n data = var[:]\\n assert_array_almost_equal(data.min(),varmin)\\n assert_array_almost_equal(data.max(),varmax)\\n ncfile.close()\\n # test https support (linked curl lib must built with openssl support)\\n ncfile = netCDF4.Dataset(URL_https)\\n assert(ncfile['sst'].long_name=='Sea Surface Temperature') \\n ncfile.close()\",\n \"def _write_nc(self, FN, data):\\n n_points = data['counts'][0] * data['counts'][1] * data['counts'][2]\\n from netCDF4 import Dataset\\n grid_nc = Dataset(FN, 'w', format='NETCDF4')\\n grid_nc.createDimension('one', 1)\\n grid_nc.createDimension('n_cartesian', 3)\\n grid_nc.createDimension('n_points', n_points)\\n grid_nc.createVariable('origin', 'f8', ('one', 'n_cartesian'))\\n grid_nc.createVariable('counts', 'i8', ('one', 'n_cartesian'))\\n grid_nc.createVariable('spacing', 'f8', ('one', 'n_cartesian'))\\n grid_nc.createVariable('vals', 'f8', ('one', 'n_points'), zlib=True)\\n for key in data.keys():\\n grid_nc.variables[key][:] = data[key]\\n grid_nc.close()\",\n \"def runTest(self):\\n nc = Dataset(self.file)\\n data = nc['vl'][-1]\\n # check max error of compression\\n err = np.abs(data - self.data)\\n assert(err.max() < nc['vl'].scale_factor)\\n # turn off auto-scaling\\n nc.set_auto_maskandscale(False)\\n data = nc['vl'][-1]\\n assert(data[-1] == np.around(self.data[-1]/nc['vl'].scale_factor))\\n nc.close()\",\n \"def execute(self, in_nc, in_weight_table, out_nc, grid_name, conversion_flag, in_time_interval=\\\"6hr\\\"): # modified this line CJB 20190218\\r\\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\\r\\n # and upstream correction of the cdo grid conversion units attribute.\\r\\n\\r\\n # Validate the netcdf dataset\\r\\n vars_oi_index = self.dataValidation(in_nc)\\r\\n \\r\\n \\\"\\\"\\\"get conversion factor the flag is used to differentiate forecasts converted \\r\\n to netCDF from GRIB and the original netCDF. They both use the same weight tables\\r\\n but the original netCDF is in mm whereas the stock GRIB forecasts are in meters.\\r\\n Set the conversion_flag in the run.py configuration file.\\r\\n \\\"\\\"\\\"\\r\\n if conversion_flag: # Line Added CJB 20190218\\r\\n conversion_factor = 1.0 #Line Modified CJB 20190218\\r\\n elif grid_name == 'ecmwf_t1279' or grid_name == 'ecmwf_tco639': # Line Modified CJB 20190218\\r\\n #if grid_name == 'ecmwf_HRES_F' or grid_name == 'ecmwf_ENS_F': # Line Added/Modified CJB 20190108\\r\\n #new grids in mm instead of m\\r\\n conversion_factor = 0.001\\r\\n else: #set the conversion factor to 1 for everything else (data is in m but legacy installations do not have a flag) Line Added CJB 20190218\\r\\n conversion_factor = 1.0 # Line Added CJB 20190218\\r\\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\\r\\n # and upstream correction of the cdo grid conversion units attribute.\\r\\n # identify if the input netcdf data is the High Resolution data with three different time intervals\\r\\n id_data = self.dataIdentify(in_nc)\\r\\n if id_data is None:\\r\\n raise Exception(self.errorMessages[3])\\r\\n\\r\\n ''' Read the netcdf dataset'''\\r\\n data_in_nc = NET.Dataset(in_nc)\\r\\n time = data_in_nc.variables['time'][:]\\r\\n\\r\\n # Check the size of time variable in the netcdf data\\r\\n if len(time) == 0: # *** MJS This change seems like it is too loose an error trap; should it account for instances when nc file time var is != in length with id_data lenght?\\r\\n raise Exception(self.errorMessages[3])\\r\\n #if len(time) != self.length_time[id_data]:\\r\\n # raise Exception(self.errorMessages[3])\\r\\n\\r\\n ''' Read the weight table '''\\r\\n print(\\\"Reading the weight table...\\\", in_weight_table)\\r\\n dict_list = {self.header_wt[0]:[], self.header_wt[1]:[], self.header_wt[2]:[],\\r\\n self.header_wt[3]:[], self.header_wt[4]:[]}\\r\\n\\r\\n with open(in_weight_table, \\\"r\\\") as csvfile:\\r\\n reader = csv.reader(csvfile)\\r\\n count = 0\\r\\n for row in reader:\\r\\n if count == 0:\\r\\n #check number of columns in the weight table\\r\\n if len(row) < len(self.header_wt):\\r\\n raise Exception(self.errorMessages[4])\\r\\n #check header\\r\\n if row[1:len(self.header_wt)] != self.header_wt[1:]:\\r\\n raise Exception(self.errorMessages[5])\\r\\n count += 1\\r\\n else:\\r\\n for i in range(len(self.header_wt)):\\r\\n dict_list[self.header_wt[i]].append(row[i])\\r\\n count += 1\\r\\n\\r\\n ''' Calculate water inflows\\r\\n as a reminder, the first 91 time steps are T=0 to T=90 and are 1-hourly for HRES\\r\\n\\t\\t the next 18 time steps for HRES are T=93 to T=144 at 3-hourly\\r\\n then the final 16 time steps are T=150 to T=240 at 6-hourly for a total of 125 records\\r\\n\\t\\t\\tFor ENS, the first 49 time steps are T=0 to T=144 at 3-hourly\\r\\n\\t\\t\\tthe final 35 time steps are T=150 to T=360 at 6-hourly for a total of 84 records\\r\\n '''\\r\\n\\t\\t\\t\\r\\n print(\\\"Calculating water inflows...\\\")\\r\\n\\t\\t\\r\\n ''' \\r\\n added the next section CJB 20180122 \\r\\n '''\\r\\n\\r\\n\\t\\t# Get the overall number of time steps\\r\\n size_time = self.getTimeSize(in_nc) #CJB 20180122\\r\\n # Determine the size of time steps in each group (1-hourly, 3-hourly, and/or 6-hourly)\\r\\n if id_data == \\\"HRES1\\\": # T <= 90 \\r\\n time_size = (size_time - 1)\\r\\n elif id_data == \\\"HRES13\\\": # 93 <= T <= 144\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"HighRes-1hr\\\"] - 1)\\r\\n elif id_data == \\\"HRES136\\\": # 150 <= T <= 240\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n elif in_time_interval == \\\"3hr\\\": # MJS Doesn't seem to be a case used currently, but added just in case later need.\\r\\n time_size = self.length_time_opt[\\\"HighRes-3hr-sub\\\"] # MJS This is HRES136, i.e., if for some reason in ecmwf_rapid_multi a 3 hr is asked for for this case, it should still have the 3hr_sub number of times\\r\\n elif in_time_interval == \\\"3hr_subset\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-3hr-Sub\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"HighRes-1hr\\\"] - self.length_time_opt[\\\"HighRes-3hr-Sub\\\"] - 1)\\r\\n elif id_data == \\\"ENS3\\\": # T <= 144\\r\\n time_size = (size_time - 1)\\r\\n elif id_data == \\\"ENS36\\\": # 150 <= T <= 360\\r\\n if in_time_interval == \\\"3hr_subset\\\":\\r\\n time_size = self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"] - 1)\\r\\n else: # id_data == \\\"ENS6\\\": # T <= 360 but all 6-hourly\\r\\n time_size = (size_time - 1)\\r\\n #else: # something is wrong and need to throw an error message - likely a corrupt forecast file\\r\\n # raise Exception(self.errorMessages[3])\\r\\n #''' end of added section CJB 20180122 \\r\\n #'''\\r\\n\\r\\n #if id_data == \\\"LowRes\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowRes-6hr\\\"]\\r\\n #elif id_data == \\\"Low3HrRes\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowRes-3hr\\\"]\\r\\n #elif id_data == \\\"LowResFull\\\":\\r\\n # if in_time_interval == \\\"3hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"]\\r\\n # elif in_time_interval == \\\"6hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowResFull-6hr-Sub\\\"]\\r\\n # else:\\r\\n # size_time = self.length_time_opt[\\\"LowRes-6hr\\\"]\\r\\n #else: #HighRes\\r\\n # if in_time_interval == \\\"1hr\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n # elif in_time_interval == \\\"3hr\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-3hr\\\"]\\r\\n # elif in_time_interval == \\\"3hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-3hr-Sub\\\"]\\r\\n # elif in_time_interval == \\\"6hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-6hr-Sub\\\"]\\r\\n # else:\\r\\n # size_time = self.length_time_opt[\\\"HighRes-6hr\\\"]\\r\\n\\r\\n size_streamID = len(set(dict_list[self.header_wt[0]]))\\r\\n\\r\\n # Create output inflow netcdf data\\r\\n # data_out_nc = NET.Dataset(out_nc, \\\"w\\\") # by default format = \\\"NETCDF4\\\"\\r\\n data_out_nc = NET.Dataset(out_nc, \\\"w\\\", format = \\\"NETCDF3_CLASSIC\\\")\\r\\n #dim_Time = data_out_nc.createDimension('Time', size_time)\\r\\n dim_Time = data_out_nc.createDimension('Time', time_size)\\r\\n dim_RiverID = data_out_nc.createDimension('rivid', size_streamID)\\r\\n var_m3_riv = data_out_nc.createVariable('m3_riv', 'f4', \\r\\n ('Time', 'rivid'),\\r\\n fill_value=0)\\r\\n \\r\\n #data_temp = NUM.empty(shape = [size_time, size_streamID])\\r\\n data_temp = NUM.empty(shape = [time_size, size_streamID])\\r\\n\\r\\n lon_ind_all = [int(i) for i in dict_list[self.header_wt[2]]]\\r\\n lat_ind_all = [int(j) for j in dict_list[self.header_wt[3]]]\\r\\n\\r\\n # Obtain a subset of runoff data based on the indices in the weight table\\r\\n min_lon_ind_all = min(lon_ind_all)\\r\\n max_lon_ind_all = max(lon_ind_all)\\r\\n min_lat_ind_all = min(lat_ind_all)\\r\\n max_lat_ind_all = max(lat_ind_all)\\r\\n\\r\\n # self.vars_oi[vars_oi_index][3] = RO; get that variable's 3D structure (time, lat_index, lon_index) ready to reshape into 2D (time, lat_index x lon_index)\\r\\n data_subset_all = data_in_nc.variables[self.vars_oi[vars_oi_index][3]][:, min_lat_ind_all:max_lat_ind_all+1, min_lon_ind_all:max_lon_ind_all+1]\\r\\n len_time_subset_all = data_subset_all.shape[0]\\r\\n len_lat_subset_all = data_subset_all.shape[1]\\r\\n len_lon_subset_all = data_subset_all.shape[2]\\r\\n data_subset_all = data_subset_all.reshape(len_time_subset_all, (len_lat_subset_all * len_lon_subset_all))\\r\\n\\r\\n # compute new indices based on the data_subset_all\\r\\n index_new = []\\r\\n for r in range(0,count-1):\\r\\n ind_lat_orig = lat_ind_all[r]\\r\\n ind_lon_orig = lon_ind_all[r]\\r\\n index_new.append((ind_lat_orig - min_lat_ind_all)*len_lon_subset_all + (ind_lon_orig - min_lon_ind_all))\\r\\n\\r\\n # obtain a new subset of data\\r\\n data_subset_new = data_subset_all[:,index_new]*conversion_factor\\r\\n\\r\\n # start compute inflow\\r\\n pointer = 0\\r\\n for s in range(0, size_streamID):\\r\\n npoints = int(dict_list[self.header_wt[4]][pointer])\\r\\n # Check if all npoints points correspond to the same streamID\\r\\n if len(set(dict_list[self.header_wt[0]][pointer : (pointer + npoints)])) != 1:\\r\\n print(\\\"ROW INDEX {0}\\\".format(pointer))\\r\\n print(\\\"RIVID {0}\\\".format(dict_list[self.header_wt[0]][pointer]))\\r\\n raise Exception(self.errorMessages[2])\\r\\n\\r\\n area_sqm_npoints = [float(k) for k in dict_list[self.header_wt[1]][pointer : (pointer + npoints)]]\\r\\n area_sqm_npoints = NUM.array(area_sqm_npoints)\\r\\n area_sqm_npoints = area_sqm_npoints.reshape(1, npoints)\\r\\n data_goal = data_subset_new[:, pointer:(pointer + npoints)]\\r\\n \\r\\n \\r\\n #remove noise from data\\r\\n data_goal[data_goal<=0.00001] = 0\\r\\n\\r\\n ''' IMPORTANT NOTE: runoff variable in ECMWF dataset is cumulative instead of incremental through time\\r\\n '''\\r\\n # For data with Low Resolution, there's only one time interval 6 hrs\\r\\n if id_data == \\\"ENS6\\\": # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints\\r\\n elif id_data == \\\"ENS3\\\": # there's only one time interval 3 hrs # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\\r\\n elif id_data == \\\"HRES1\\\": # there's only one time interval 1 hrs # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\\t\\r\\n #For data with the full version of Low Resolution, from Hour 0 to 144 (the first 49 time points) are of 3 hr time interval,\\r\\n # then from Hour 144 to 360 (36 time points) are of 6 hour time interval\\r\\n elif id_data == \\\"ENS36\\\": # Line Added/Modified CJB 20190108\\r\\n if in_time_interval == \\\"3hr_subset\\\":\\r\\n #use only the 3hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[1:49,], data_goal[:48,]) * area_sqm_npoints\\r\\n elif in_time_interval == \\\"6hr_subset\\\":\\r\\n #use only the 6hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[49:,], data_goal[48:-1,]) * area_sqm_npoints\\r\\n else: #\\\"LowRes-6hr\\\"\\r\\n ######################################################\\r\\n # MJS Always assume this case will have a full ECMWF 240\\r\\n # hour forecast to work with. It's actually never re-\\r\\n # quested by ecmwf_rapid_multiprocess anyhow.\\r\\n ######################################################\\r\\n #convert all to 6hr\\r\\n # calculate time series of 6 hr data from 3 hr data\\r\\n ro_6hr_a = NUM.subtract(data_goal[2:49:2,], data_goal[:48:2,])\\r\\n # get the time series of 6 hr data\\r\\n ro_6hr_b = NUM.subtract(data_goal[49:,], data_goal[48:-1,])\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b]) * area_sqm_npoints\\r\\n #For data with High Resolution, from Hour 0 to 90 (the first 91 time points) are of 1 hr time interval,\\r\\n # then from Hour 90 to 144 (18 time points) are of 3 hour time interval, and from Hour 144 to 240 (16 time points)\\r\\n # are of 6 hour time interval\\r\\n ##########################################################\\r\\n # MJS The following should handle id_data = HRES13 and HRES136\\r\\n ##########################################################\\r\\n else:\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n #ro_stream = NUM.subtract(data_goal[1:91,],data_goal[:90,]) * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:1+time_size,],data_goal[:time_size,]) * area_sqm_npoints # Line Added/Modified CJB, MJS 20190108\\r\\n elif in_time_interval == \\\"3hr\\\": # MJS HRES 3hr not currently used\\r\\n # calculate time series of 3 hr data from 1 hr data\\r\\n ro_3hr_a = NUM.subtract(data_goal[3:91:3,],data_goal[:88:3,])\\r\\n # get the time series of 3 hr data\\r\\n #ro_3hr_b = NUM.subtract(data_goal[91:109,], data_goal[90:108,])\\r\\n ro_3hr_b = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) # MJS modified again; seems no case for this, but just in case later... Line Added/Modified CJB 20190108\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_3hr_a, ro_3hr_b]) * area_sqm_npoints\\r\\n elif in_time_interval == \\\"3hr_subset\\\":\\r\\n #use only the 3hr time interval\\r\\n #ro_stream = NUM.subtract(data_goal[91:109,], data_goal[90:108,]) * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) * area_sqm_npoints # MJS modified again; needs to handle HRES13 that might not have complete 3hr set... Line Added/Modified CJB 20190108\\r\\n elif in_time_interval == \\\"6hr_subset\\\":\\r\\n #use only the 6hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[109:,], data_goal[108:-1,]) * area_sqm_npoints\\r\\n ######################################################\\r\\n # MJS Always assume this case will have a full ECMWF 240 \\r\\n # hour forecast to work with. It's actually never re-\\r\\n # quested by ecmwf_rapid_multiprocess anyhow.\\r\\n ######################################################\\r\\n else: # in_time_interval == \\\"6hr\\\"\\r\\n #arcpy.AddMessage(\\\"6hr\\\")\\r\\n # calculate time series of 6 hr data from 1 hr data\\r\\n ro_6hr_a = NUM.subtract(data_goal[6:91:6,], data_goal[:85:6,])\\r\\n # calculate time series of 6 hr data from 3 hr data\\r\\n ro_6hr_b = NUM.subtract(data_goal[92:109:2,], data_goal[90:107:2,])\\r\\n # get the time series of 6 hr data\\r\\n ro_6hr_c = NUM.subtract(data_goal[109:,], data_goal[108:-1,])\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b, ro_6hr_c]) * area_sqm_npoints\\r\\n \\r\\n #remove negative values\\r\\n ro_stream[ro_stream<0] = 0\\r\\n data_temp[:,s] = ro_stream.sum(axis = 1)\\r\\n\\r\\n pointer += npoints\\r\\n\\r\\n\\r\\n '''Write inflow data'''\\r\\n print(\\\"Writing inflow data...\\\")\\r\\n var_m3_riv[:] = data_temp\\r\\n # close the input and output netcdf datasets\\r\\n data_in_nc.close()\\r\\n data_out_nc.close()\",\n \"def check_netcdf_file():\\n # check the model file and extract necessary information\\n # must be in the argument list\\n if NETCDF_FILE_NAME is None:\\n print('[ERROR] the netCDF model file name is required', flush=True)\\n usage_csv()\\n sys.exit(1)\\n\\n # user may provide full path\\n elif os.path.isfile(NETCDF_FILE_NAME):\\n model_file_name = NETCDF_FILE_NAME\\n base_file_name, ext = os.path.splitext(model_file_name)\\n\\n # user may place it under the data directory\\n elif os.path.isfile(os.path.join(DATA_DIR, NETCDF_FILE_NAME)):\\n model_file_name = os.path.join(DATA_DIR, NETCDF_FILE_NAME)\\n base_file_name, ext = os.path.splitext(model_file_name)\\n\\n # could not find the file\\n else:\\n print('[ERROR] could not find the netCDF model file {}'.format(NETCDF_FILE_NAME), flush=True)\\n usage_csv()\\n sys.exit(1)\\n\\n return model_file_name, base_file_name\",\n \"def F_read_S5P_nc(self,fn,data_fields,data_fields_l2g=[]):\\n from netCDF4 import Dataset\\n ncid = Dataset(fn,'r')\\n outp = {}\\n for i in range(len(data_fields)):\\n tmp = ncid[data_fields[i]]\\n tmpdtype = tmp.dtype\\n if not data_fields_l2g:\\n varname = tmp.name\\n else:\\n varname = data_fields_l2g[i]\\n if tmpdtype is \\\"str\\\":\\n outp[varname] = tmp[:]\\n else:\\n outp[varname] = np.squeeze(tmp[:])\\n ## scale factor already applied?! so confusing\\n# try:\\n# outp[varname] = outp[varname]*tmp.scale_factor\\n# if tmp.scale_factor != 1:\\n# print(varname+' has a scale_factor of '+'%s'%tmp.scale_factor)\\n# except Exception:\\n# #print(e)\\n# print(varname+' has no scale_factor!')\\n if 'time_utc' in outp.keys():\\n UTC_matlab_datenum = np.zeros((len(outp['time_utc']),1),dtype=np.float64)\\n for i in range(len(outp['time_utc'])):\\n tmp = datetime.datetime.strptime(outp['time_utc'][i],'%Y-%m-%dT%H:%M:%S.%fZ')\\n UTC_matlab_datenum[i] = (tmp.toordinal()\\\\\\n +tmp.hour/24.\\\\\\n +tmp.minute/1440.\\\\\\n +tmp.second/86400.\\\\\\n +tmp.microsecond/86400/1000000+366.)\\n outp['UTC_matlab_datenum'] = np.tile(UTC_matlab_datenum,(1,outp['latc'].shape[1]))\\n else: # hcho l2 does not have time_utc\\n # the delta_time field of hcho fills all across track position, but ch4 is one per scanline\\n if len(outp['delta_time'].shape) == 1:\\n outp['delta_time'] = np.tile(outp['delta_time'][...,None],(1,outp['latc'].shape[1]))\\n outp['UTC_matlab_datenum'] = (outp['time']+outp['delta_time']/1000.)/86400.+734139.\\n \\n outp['across_track_position'] = np.tile(np.arange(1.,outp['latc'].shape[1]+1),\\\\\\n (outp['latc'].shape[0],1)).astype(np.int16)\\n return outp\",\n \"def verify_netcdf(extents_dir, out_ncfile):\\n netcdf_old=out_ncfile #'/g/data/fk4/wofs/water_f7q/extents/149_-036/LS_WATER_149_-036_1987-05-22T23-08-20.154_2014-03-28T23-47-03.171.nc'\\n\\n tiles = [make_tileinfo(filename) for filename in glob(os.path.join(extents_dir, '*.tif'))]\\n tiles.sort(key=lambda t: t.datetime)\\n\\n with netCDF4.Dataset(netcdf_old) as nco:\\n for i in range(0,len(tiles)):\\n print nco['time'][i]\\n print tiles[i]\\n with rasterio.open(tiles[i].filename) as tile_data:\\n print \\\"Any difference? \\\" \\n print numpy.sum(nco['Data'][:,:,i])\\n print numpy.sum(tile_data.read(1))\\n\\n print type(nco['Data'][:,:,i]), type(tile_data.read(1))\\n print nco['Data'][:,:,i].shape, tile_data.read(1).shape\\n \\n print numpy.sum(nco['Data'][:,:,i] - tile_data.read(1)[:,:])\\n #print tile_data.read(1)[0:100,0:100] \\n\\n #print (nco['Data'][:,:,i] == tile_data.read(1)).all()\",\n \"def is_valid_netcdf_file(nc_data):\\n fname = Path(nc_data.filepath()).name\\n \\n start_str = fname.split(\\\"_\\\")[3][1:-1]\\n start_fname = dt.datetime.strptime(\\n start_str + \\\" UTC\\\",\\n \\\"%Y%j%H%M%S %Z\\\",\\n )\\n start_fname = start_fname.replace(tzinfo=dt.timezone.utc)\\n end_str = fname.split(\\\"_\\\")[4][1:-1]\\n end_fname = dt.datetime.strptime(end_str + \\\" UTC\\\", \\\"%Y%j%H%M%S %Z\\\")\\n end_fname = end_fname.replace(tzinfo=dt.timezone.utc)\\n \\n avg_fname = start_fname + (end_fname - start_fname) / 2\\n \\n vtime = get_valid_time(nc_data)\\n if vtime is None:\\n return False\\n \\n diff = (avg_fname - vtime).total_seconds()\\n \\n if diff > 60:\\n return False\\n \\n return True\",\n \"def write_netcdf(ncinfo):\\r\\n\\t# ========== Create new netcdf ==========\\r\\n\\tNAME=nc.netcdf_file(ncinfo.fname,'w')\\r\\n\\t\\r\\n\\t# ========== Set up the Dimensions ==========\\r\\n\\tNAME.createDimension('time', None) #Question: Shouldn't time be unlimited?\\r\\n\\t# NAME.createDimension('lev',11)\\r\\n\\tNAME.createDimension('lat',ncinfo.lat)\\r\\n\\tNAME.createDimension('lon',ncinfo.lon)\\r\\n\\t\\r\\n\\t# ========== Setup the Variables ==========\\r\\n\\ttime=NAME.createVariable('time',np.float64,('time',))\\r\\n\\t# lev=NAME.createVariable('lev',np.int32,('lev',))\\r\\n\\tlat=NAME.createVariable('lat',np.float64,('lat',))\\r\\n\\tlon=NAME.createVariable('lon',np.float64,('lon',))\\r\\n\\t# VAR=NAME.createVariable(str(VAR),np.float64,('time','lev','lat','lon'),)\\r\\n\\tVAR=NAME.createVariable(ncinfo.var_name,np.float64,('time','lat','lon'),)\\r\\n\\t# setting the missing value is super important for the file to be cdo readable\\r\\n\\tsetattr(VAR,'missing_value',ncinfo.fill)\\r\\n\\tsetattr(VAR, 'standard_name', ncinfo.var_lname) \\r\\n\\t\\r\\n\\t# ========== Set the units ==========\\r\\n\\ttime.units= 'day as %Y%m%d'\\r\\n\\t# lev.units = '-'\\r\\n\\tlat.units = 'degrees_north'\\r\\n\\tlon.units = 'degrees_east'\\r\\n\\tVAR.units = ncinfo.units\\r\\n\\r\\n\\t# ========== Add data ==========\\r\\n\\t\\r\\n\\t# creates time vector using the date_range function\\r\\n\\t# time[:]=[t for t in date_range('20110101.5','20111231.5')] \\r\\n\\t# lev[:]=PFT_vector\\r\\n\\tlat[:] = ncinfo.latitudes\\r\\n\\tlon[:] = ncinfo.longitudes\\r\\n\\t# THis is a Bodge for singe variable data\\r\\n\\tVAR[:] = ncinfo.data\\r\\n\\r\\n\\t#Add global attributes\\r\\n\\tNAME.description = ncinfo.description\\r\\n\\tNAME.history = ncinfo.history\\r\\n\\r\\n\\t# WHATS MISSING\\r\\n\\t# metadata a whole bunch of metadata\\r\\n\\t# the standard_name and long_name of the variables\\r\\n\\r\\n\\t# ========== Close the netcdf ==========\\r\\n\\tNAME.close()\",\n \"def cl_file(tmp_path):\\n nc_path = os.path.join(tmp_path, 'cesm2_waccm_cl.nc')\\n dataset = Dataset(nc_path, mode='w')\\n dataset.createDimension('lev', size=2)\\n dataset.createDimension('bnds', size=2)\\n\\n # Dimensional variables\\n dataset.createVariable('lev', np.float64, dimensions=('lev',))\\n dataset.createVariable('lev_bnds', np.float64, dimensions=('lev', 'bnds'))\\n dataset.variables['lev'][:] = [1.0, 2.0]\\n dataset.variables['lev'].bounds = 'lev_bnds'\\n dataset.variables['lev'].units = '1'\\n dataset.variables['lev_bnds'][:] = [[0.5, 1.5], [1.5, 3.0]]\\n dataset.variables['lev_bnds'].standard_name = (\\n 'atmosphere_hybrid_sigma_pressure_coordinate')\\n dataset.variables['lev_bnds'].units = '1'\\n dataset.variables['lev_bnds'].formula_terms = (\\n 'p0: p0 a: a_bnds b: b_bnds ps: ps')\\n\\n # Coordinates for derivation of pressure coordinate\\n dataset.createVariable('a', np.float64, dimensions=('lev',))\\n dataset.createVariable('a_bnds', np.float64, dimensions=('lev', 'bnds'))\\n dataset.createVariable('b', np.float64, dimensions=('lev',))\\n dataset.createVariable('b_bnds', np.float64, dimensions=('lev', 'bnds'))\\n dataset.variables['a'][:] = [1.0, 2.0]\\n dataset.variables['a'].bounds = 'a_bnds'\\n dataset.variables['a_bnds'][:] = [[1.5, 0.0], [3.0, 1.5]]\\n dataset.variables['b'][:] = [0.0, 1.0]\\n dataset.variables['b'].bounds = 'b_bnds'\\n dataset.variables['b_bnds'][:] = [[0.5, -1.0], [2.0, 0.5]]\\n\\n dataset.close()\\n return nc_path\",\n \"def repair_netcdf(fname):\\n\\n\\t# ========== Set the path and the file name ==========\\n\\t# fname = \\\"%s_%s_%s_r1i1p1_%s_1950_2050_%s_regrid.nc\\\" %(var, model, sen, units, sen)\\n\\tfout = \\\"%s_setgrid\\\" % (fname)\\n\\n\\t\\n\\t# ========== Create a list of files to cleanup ==========\\n\\tcleanup = []\\n\\n\\t# ========== Check if the file exists ==========\\n\\tif not os.path.isfile(fname+\\\".nc\\\"):\\n\\t\\t# check if the file exists with a different name\\n\\t\\traise IOError(\\\"WARNING: The file %s cannot be found\\\"% fname)\\n\\n\\t\\n\\t# ========== Read longitude from NC file ==========\\n\\tfh = Dataset(fname+\\\".nc\\\", mode='r')\\n\\ttry:\\n\\t\\tlon = fh.variables['longitude'][:]\\n\\texcept:\\n\\t\\ttry:\\n\\t\\t\\tlon = fh.variables['lon'][:]\\n\\t\\texcept:\\n\\t\\t\\tlon = fh.variables['easting'][:] #easting\\n\\n\\n\\n\\n\\t# ========== Create a new grid ==========\\n\\t# Save the current grid\\n\\tsubp.call(\\\"cdo griddes %s.nc > %sGriddes\\\" % (fname, fname), shell=True)\\n\\t# add the griddes to the cleanup \\n\\tcleanup.append(\\\"%sGriddes\\\" % fname)\\n\\n\\t# open the current grid\\n\\tgfile = open(\\\"%sGriddes\\\" % fname, \\\"r\\\") \\n\\t# Split the lines of the grid file\\n\\tginfo = gfile.read().splitlines()\\n\\t\\n\\t#Some models have no lat/lon bounds, skip in this case and copy\\n\\t#\\\"regrid\\\" file as \\\"setgrid\\\"\\n\\tif not (any([n.startswith(\\\"xbounds\\\") for n in ginfo]) and \\n\\t\\t any([n.startswith(\\\"ybounds\\\") for n in ginfo])):\\n\\t\\tsubp.call(\\\"cp %s.nc %s.nc\\\" % (fname, fout), shell=True)\\n\\t\\tcleanup.append(\\\"%s.nc\\\" % fname)\\n\\t\\treturn cleanup\\t\\n\\t\\n\\t# Check and see if the start is known\\n\\tif (\\n\\t\\tany([n.startswith(\\\"xfirst\\\") for n in ginfo])\\n\\t\\t) and (\\n\\t\\tany([n.startswith(\\\"xinc\\\") for n in ginfo])\\n\\t\\t):\\n\\t\\taddxdet = False\\n\\t\\t# Set the lines to be removed\\n\\t\\tbadel = [\\\"xvals\\\", \\\"yvals\\\", \\\" \\\", \\\"xbounds\\\", \\\"ybounds\\\"]\\n\\telse:\\n\\t\\taddxdet = True\\n\\t\\t# Set the lines to be removed\\n\\t\\tbadel = [\\\"xvals\\\", \\\"yvals\\\", \\\" \\\", \\\"xbounds\\\", \\\"ybounds\\\", \\\"xfirst\\\", \\\"xinc\\\"]\\n\\n\\t# Create list to hold the new grid details\\n\\tnew_grid = []\\n\\n\\tfor ginf in ginfo:\\n\\t\\ttest = []\\n\\t\\tfor be in badel:\\n\\t\\t\\tif ginf.startswith(be):\\n\\t\\t\\t\\ttest.append(False)\\n\\t\\t\\telif ginf == \\\"#\\\":\\n\\t\\t\\t\\ttest.append(False)\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttest.append(True)\\n\\t\\t\\n\\t\\tif all(test):\\n\\t\\t\\tnew_grid.append(ginf)\\n\\t# Add the additional x variables\\n\\tif addxdet:\\n\\t\\t# work out the model from the fname\\n\\t\\tmodel = fname.split(\\\"/\\\")[-2]\\n\\t\\tnew_grid.append('xfirst = -180')\\n\\t\\tnew_grid.append('xinc = %s' % str(\\n\\t\\t\\tfloat(lon) ))\\n\\t\\n\\n\\t# Check the y values, if they are missing use the ones in the original grid file\\n\\tif not (any([n.startswith(\\\"yfirst\\\") for n in ginfo])):\\n\\t\\t# print (\\\"Seting the y bounds\\\")\\n\\t\\tvals = []\\n\\t\\tfor glov in range(0,len(ginfo)):\\n\\t\\t\\tif ginfo[glov].startswith(\\\"yvals\\\"):\\n\\t\\t\\t\\tvals.append(glov)\\n\\t\\t\\telif ginfo[glov].startswith(\\\"ybounds\\\"):\\n\\t\\t\\t\\tvals.append(glov)\\n\\t\\tif len (vals) == 2:\\n\\t\\t\\tfor yv in ginfo[vals[0]:vals[1]]:\\n\\t\\t\\t\\tnew_grid.append(yv)\\n\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"\\\\n\\\")\\n\\t\\t\\traise IndexError(\\\"Bounding is incorrect\\\")\\n\\n\\t# Save the grid out\\n\\tnewgrid = save_grid(fname, new_grid)\\n\\tcleanup.append(newgrid)\\n\\n\\t# ========== Set the new grid file ==========\\n\\t# Save the current grid\\n\\tsubp.call(\\\"cdo setgrid,%sGridFix %s.nc %s.nc\\\" % (fname, fname, fout), shell=True)\\n\\t\\n\\tif not os.path.isfile(\\\"%s.nc\\\" % fout):\\n\\t\\traise IOError(\\\"The output file was not created, going interactive\\\")\\n\\t\\n\\t# ========== return the files to be removed ==========\\n\\tcleanup.append(\\\"%s.nc\\\" % fname)\\n\\treturn cleanup\",\n \"def testCC(self):\\n self.assertEqual(\\n self.cc,\\n self.ccr.cc\\n )\\n\\n self.assertEqual(\\n None,\\n self.ccr_bad.cc\\n )\",\n \"def _validate_raw_nc(self):\\r\\n\\r\\n self.raw_nc_list = []\\r\\n total_time_len = 1 #add one for the first flow value RAPID\\r\\n #does not include\\r\\n id_len_list = []\\r\\n for rapid_output_file in self.rapid_output_file_list:\\r\\n qout_nc = RAPIDDataset(rapid_output_file)\\r\\n id_len_list.append(qout_nc.size_river_id)\\r\\n total_time_len += qout_nc.size_time\\r\\n self.raw_nc_list.append(qout_nc)\\r\\n \\r\\n #make sure river id lists are the same\\r\\n for id_len_undex in range(1, len(id_len_list)):\\r\\n if id_len_list[id_len_undex] != id_len_list[0]:\\r\\n raise Exception(\\\"ERROR: River ID size is different in one of the files ...\\\")\\r\\n \\r\\n for raw_nc_index in range(1, len(self.raw_nc_list)):\\r\\n if not (self.raw_nc_list[raw_nc_index].get_river_id_array() == self.raw_nc_list[0].get_river_id_array()).all():\\r\\n raise Exception(\\\"ERROR: River IDs are different in files ...\\\")\\r\\n\\r\\n return id_len_list[0], total_time_len\",\n \"def processData(self,data):\\n #print 'I GOT DATA',data,[0],data[1]\\n # Check for valid data (not null or empty string)\\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0])\\n if data:\\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0]),_RobotCommunicator.WALL_HEADER==data[0]\\n\\n # Check header and assign data appropriately\\n # TODO: Check length of data for validity\\n #print 'Header',data[0]\\n if data[0] == _RobotCommunicator.POSE_HEADER:\\n self.pose = unpack(_RobotCommunicator.POSE_FORMAT,data[1:])\\n elif data[0] == _RobotCommunicator.SENSOR_HEADER:\\n\\n #for i in range(1, len(data)-1, 2):\\n index= unpack('B',data[1])\\n value = unpack('?',data[2])\\n # Update old values or create new sensor-value pair\\n self.sensors[index[0]] = value[0]\\n #print 'in csharp: ',[index,value]\\n\\n elif data[0] == _RobotCommunicator.WAYPOINT_HEADER:\\n self.waypoints = [] # Clear old waypoints\\n for i in range(1, len(data)-16, 16):\\n x,y = unpack(_RobotCommunicator.WAYPOINT_FORMAT,\\n data[i:i+15])\\n self.waypoints.append((x,y))\\n elif data[0] == _RobotCommunicator.DIRECTION_HEADER:\\n self.direction = unpack(_RobotCommunicator.DIRECTION_FORMAT,\\n data[1:])\\n elif data[0] == _RobotCommunicator.ACTUATOR_HEADER:\\n self.actuators = [] # Clear old actuator commands for i in range(1, len(data)-1):\\n self.actuators.append(unpack(\\n _RobotCommunicator.ACTUATOR_FORMAT,data[i]))\\n elif data[0] == _RobotCommunicator.WALL_HEADER:\\n self.walls = {} # Clear old wall entries\\n index = unpack('B', data[1])\\n x1,y1,x2,y2 = unpack(_RobotCommunicator.WALL_FORMAT,data[2:34])\\n self.walls = (x1,y1,x2,y2)\\n #print '**************Coordinates***************',(x1,y1,x2,y2)\\n print '****self.walls*********',self.walls\\n elif data[0] == _RobotCommunicator.OBS_HEADER:\\n index = unpack('B', data[1])\\n add,x1,y1 = unpack(_RobotCommunicator.OBS_FORMAT,data[2:26])\\n #print '***********self.obs*************'+','.join(map(str,[add,x1,y1]))\\n self.obs = [add,x1,round(y1,2)]\\n if add == 1:\\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\\n a.shift(x1,y1)\\n self.obsPoly += a\\n self.receiveObs = True\\n #print \\\"add obstacle:\\\" + str(x1) + \\\",\\\"+ str(y1)\\n elif add == 4:\\n if x1 == 0:\\n self.STOP = True\\n else:\\n self.STOP = False\\n else:\\n a = PolyShapes.Rectangle(self.resolX,self.resolY)\\n a.shift(x1,y1)\\n self.obsPoly -= a\\n self.receiveObs = True\\n #print \\\"del obstacle:\\\"+ str(x1) + \\\",\\\"+ str(y1)\\n\\n\\n else:\\n print \\\"Unexpected or corrupted data packet received.\\\"\",\n \"def Save2Nc(self):\\r\\n\\r\\n frameNumber = self.spinBox_FrameNum.value()\\r\\n\\r\\n segmentNumber = self.spinBox_SegmentNum.value()\\r\\n\\r\\n exposeTime = self.spinBox_ExpTime.value()\\r\\n width = self.spinBox_Width.value()\\r\\n xshift = self.spinBox_XShift.value()\\r\\n hight = self.spinBox_Hight.value()\\r\\n yshift = self.spinBox_Yshift.value()\\r\\n\\r\\n print(\\\"frameNumber, segmentNumber, width, high is: \\\", frameNumber, segmentNumber, width, hight)\\r\\n app = ReadData(noteObj = self.textBrowser_SetMeasureInf, frameNumber=frameNumber, segmentFrame=segmentNumber, width=width, hight=hight)\\r\\n self.multiFrameData = app.ImageData()\\r\\n\\r\\n options = QFileDialog.Options()\\r\\n options |= QFileDialog.DontUseNativeDialog\\r\\n # it just provides the name of file that you want to write into\\r\\n fileName, _= QFileDialog.getSaveFileName(self,\\\"QFileDialog.getSaveFileName()\\\",\\\"\\\",\\\"All Files (*);;NC Files (*.nc)\\\", options=options)\\r\\n \\r\\n if fileName:\\r\\n print(fileName)\\r\\n\\r\\n self.multiFrameData.to_netcdf(fileName + '.nc')\\r\\n self.textBrowser_SetMeasureInf.setTextColor(QtCore.Qt.green)\\r\\n self.textBrowser_SetMeasureInf.append(\\\"the data has saved as .nc file! \\\")\",\n \"def check_Data(self):\\r\\n \\r\\n if self._target_data is None:\\r\\n self.processData()\",\n \"def test_noDuplicateCTCPDispatch(self):\\n\\n def testCTCP(user, channel, data):\\n self.called += 1\\n\\n self.called = 0\\n self.client.ctcpQuery_TESTTHIS = testCTCP\\n\\n self.client.irc_PRIVMSG(\\n \\\"foo!bar@baz.quux\\\",\\n [\\\"#chan\\\", \\\"{X}TESTTHIS{X}foo{X}TESTTHIS{X}\\\".format(X=irc.X_DELIM)],\\n )\\n self.assertEqualBufferValue(self.file.getvalue(), \\\"\\\")\\n self.assertEqual(self.called, 1)\",\n \"def test_set_circulationdata_errors(self):\\n provider = AlwaysSuccessfulCollectionCoverageProvider(\\n self._default_collection\\n )\\n identifier = self._identifier()\\n\\n # No data.\\n failure = provider._set_circulationdata(identifier, None)\\n assert (\\\"Did not receive circulationdata from input source\\\" ==\\n failure.exception)\\n\\n # No identifier in CirculationData.\\n empty = CirculationData(provider.data_source, primary_identifier=None)\\n failure = provider._set_circulationdata(identifier, empty)\\n assert (\\\"Identifier did not match CirculationData's primary identifier.\\\" ==\\n failure.exception)\\n\\n # Mismatched identifier in CirculationData.\\n wrong = CirculationData(provider.data_source,\\n primary_identifier=self._identifier())\\n failure = provider._set_circulationdata(identifier, empty)\\n assert (\\\"Identifier did not match CirculationData's primary identifier.\\\" ==\\n failure.exception)\\n\\n # Here, the data is okay, but the ReplacementPolicy is\\n # going to cause an error the first time we try to use it.\\n correct = CirculationData(provider.data_source,\\n identifier)\\n provider.replacement_policy = object()\\n failure = provider._set_circulationdata(identifier, correct)\\n assert isinstance(failure, CoverageFailure)\\n\\n # Verify that the general error handling works whether or not\\n # the provider is associated with a Collection.\\n provider.collection_id = None\\n failure = provider._set_circulationdata(identifier, correct)\\n assert isinstance(failure, CoverageFailure)\",\n \"def cdf_to_nc(cdf_filename):\\n\\n # Load raw .cdf data\\n ds = xr.load_dataset(cdf_filename)\\n\\n # create burst num variable\\n ds = burst_num(ds)\\n\\n # Clip data to in/out water times or via good_ens\\n ds = utils.clip_ds(ds)\\n\\n # Trim data when instrument is out of water during a deployment and extra bins if good_bins specified\\n if \\\"bins\\\" in ds:\\n ds = trim_alt(ds)\\n else:\\n ds = trim_alt(ds, data_vars=[\\\"Altitude_m\\\", \\\"AmplitudeFS\\\", \\\"Temperature_C\\\"])\\n\\n # calculate bin height for profiling echologger (i.e. type == ea)\\n if \\\"bins\\\" in ds:\\n ds = calc_bin_height(ds)\\n\\n # calculate corrected altitude (distance to bed/b_range) with adjusted sound speed\\n ds = calc_cor_brange(ds)\\n\\n # calculate corrected bin height (on NAVD88 datum) with adjusted sound speed\\n if \\\"bins\\\" in ds:\\n ds = calc_cor_bin_height(ds)\\n\\n ds = calc_seabed_elev(ds)\\n\\n # if \\\"bins\\\" in ds:\\n # ds = utils.create_z_bindist(ds) #create z for profile\\n # else:\\n ds = utils.create_z(ds)\\n\\n # swap bin dim with bin_height\\n ds = ds_swap_dims(ds) # swap vert dim to z\\n\\n # rename variables\\n ds = ds_rename_vars(ds)\\n\\n # drop some vars after renaming\\n for k in [\\n \\\"bins\\\",\\n \\\"ping\\\",\\n \\\"ping_num_in_series\\\",\\n \\\"Altitude_m\\\",\\n \\\"Battery_mV\\\",\\n ]:\\n if k in ds:\\n ds = ds.drop_vars(k)\\n\\n # add lat/lons as coordinates\\n ds = utils.ds_add_lat_lon(ds)\\n\\n # add attributes to each variable\\n ds = ds_add_attrs(ds)\\n\\n # add metadata to global atts\\n ds = utils.add_start_stop_time(ds)\\n ds = utils.add_delta_t(ds)\\n\\n # Write to .nc file\\n print(\\\"Writing cleaned/trimmed burst data and averaged burst data to .nc file\\\")\\n nc_filename = ds.attrs[\\\"filename\\\"] + \\\"b-cal.nc\\\"\\n\\n ds.to_netcdf(\\n nc_filename, unlimited_dims=[\\\"time\\\"], encoding={\\\"time\\\": {\\\"dtype\\\": \\\"i4\\\"}}\\n )\\n print(\\\"Done writing netCDF file\\\", nc_filename)\\n\\n # Average busrt and write to -a.nc file\\n ds = average_burst(ds)\\n\\n for var in ds.data_vars:\\n # do any diff trimming first\\n ds = qaqc.trim_min_diff(ds, var)\\n ds = qaqc.trim_min_diff_pct(ds, var)\\n ds = qaqc.trim_max_diff(ds, var)\\n ds = qaqc.trim_max_diff_pct(ds, var)\\n ds = qaqc.trim_med_diff(ds, var)\\n ds = qaqc.trim_med_diff_pct(ds, var)\\n ds = qaqc.trim_maxabs_diff_2d(ds, var)\\n ds = qaqc.trim_maxabs_diff(ds, var)\\n # then do other trimming\\n ds = qaqc.trim_bad_ens(ds, var)\\n ds = qaqc.trim_min(ds, var)\\n ds = qaqc.trim_max(ds, var)\\n ds = aqdutils.trim_single_bins(ds, var)\\n ds = qaqc.trim_fliers(ds, var)\\n\\n # after check for masking vars by others\\n for var in ds.data_vars:\\n ds = qaqc.trim_mask(ds, var)\\n\\n # assign min/max\\n ds = utils.add_min_max(ds)\\n\\n ds = utils.ds_coord_no_fillvalue(ds)\\n\\n nc_filename = ds.attrs[\\\"filename\\\"] + \\\"-a.nc\\\"\\n\\n # ds['time']=ds['time'].astype('datetime64[s]')\\n ds.to_netcdf(\\n nc_filename, unlimited_dims=[\\\"time\\\"], encoding={\\\"time\\\": {\\\"dtype\\\": \\\"i4\\\"}}\\n )\\n\\n utils.check_compliance(nc_filename, conventions=ds.attrs[\\\"Conventions\\\"])\\n\\n print(\\\"Done writing burst averaged netCDF file\\\", nc_filename)\\n\\n return ds\",\n \"def testCCHalt(self):\\n cdl_convert.config.HALT_ON_ERROR = True\\n\\n def getCC():\\n self.ccr_bad.cc\\n\\n self.assertRaises(\\n ValueError,\\n getCC\\n )\",\n \"def load_data():\\n\\t\\t# load the data\\n\\t\\tDATPATH = \\\"../data/\\\"\\n\\t\\t#fnino = DATPATH + \\\"nino3.csv\\\" # 1871-2000\\n\\t\\tfnino = DATPATH + \\\"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\\\" # 1871-2016\\n\\t\\t#fnino = DATPATH + \\\"nino34.long.data\\\"\\n\\t\\t#nc_data_nino3 = netCDF4.Dataset(fnino)\\n\\t\\t#nino3_load = nc_data_nino3.variables['tas'][:]\\n\\t\\t#dnino = nino3_load.flatten()\\n\\n\\t\\tdnino = np.genfromtxt(fnino, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fismr = DATPATH + \\\"ismr.csv\\\" # 1871-2000\\n\\t\\t#fismr = DATPATH + \\\"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\\\" # 1871-2016\\n\\t\\tfismr = DATPATH + \\\"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\\\" # 1871-2016\\n\\t\\tdismr = np.genfromtxt(fismr, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fvolc = DATPATH + \\\"robock.txt\\\" # 1871-2000\\n\\t\\tfvolc = DATPATH + \\\"sigl.txt\\\" # 1871-2016\\n\\t\\tdvolc = np.genfromtxt(fvolc, delimiter=\\\",\\\", dtype=float).flatten()\\n\\n\\t\\tfvolc_source = DATPATH + \\\"volc_source_850_1850.csv\\\" # 1871-2016\\n\\t\\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t# simple check for data consistency\\n\\t\\tassert dnino.shape == dismr.shape, \\\"Data sets are unequal!\\\"\\n\\t\\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \\\"Data sets are unequal\\\"\\n\\t\\treturn dnino, dismr, dvolc, dvolc_source\",\n \"def createNCDF(self):\\n\\n rootgrp = Dataset(self.filename_out, 'w', format=self.format, clobber=True)\\n\\n # Create dimensions.\\n if 'dimensions' in self.input_dict:\\n for k, v in self.input_dict['dimensions'].items():\\n rootgrp.createDimension(k, v)\\n else:\\n if not self.Quiet:\\n print('No netCDF created:')\\n print(' No dimension key found (!! has to be \\\\\\\"dimensions\\\\\\\"!!!)')\\n return()\\n\\n # Create global attributes.\\n if 'global attributes' in self.input_dict:\\n for k, v in self.input_dict['global attributes'].items():\\n rootgrp.setncattr(k, v)\\n else:\\n if not self.Quiet:\\n print(' No global attribute key found (!! has to be \\\\\\\"global attributes\\\\\\\"!!!)')\\n\\n # Create variables.\\n for k, v in self.input_dict['variables'].items():\\n dims = self.input_dict['variables'][k]['dimensions']\\n data = v['data']\\n # Create correct data type if provided\\n if 'data_type' in self.input_dict['variables'][k]:\\n data_type = self.input_dict['variables'][k]['data_type']\\n else:\\n data_type = 'f4'\\n # Check whether we've been given a fill value.\\n if 'fill_value' in self.input_dict['variables'][k]:\\n fill_value = self.input_dict['variables'][k]['fill_value']\\n else:\\n fill_value = None\\n # Create ncdf variable\\n if not self.Quiet:\\n print(' Creating variable: {} {} {}'.format(k, data_type, dims))\\n var = rootgrp.createVariable(k, data_type, dims, fill_value=fill_value)\\n if len(dims) > np.ndim(data):\\n # If number of dimensions given to netCDF is greater than the\\n # number of dimension of the data, then fill the netCDF\\n # variable accordingly.\\n if 'time' in dims:\\n # Check for presence of time dimension (which can be\\n # unlimited variable: defined by None).\\n try:\\n var[:] = data\\n except IndexError:\\n raise(IndexError(('Supplied data shape {} does not match the specified'\\n ' dimensions {}, for variable \\\\'{}\\\\'.'.format(data.shape, var.shape, k))))\\n else:\\n if not self.Quiet:\\n print('Problem in the number of dimensions')\\n else:\\n try:\\n var[:] = data\\n except IndexError:\\n raise(IndexError(('Supplied data shape {} does not match the specified'\\n ' dimensions {}, for variable \\\\'{}\\\\'.'.format(data.shape, var.shape, k))))\\n\\n # Create attributes for variables\\n if 'attributes' in self.input_dict['variables'][k]:\\n for ka, va in self.input_dict['variables'][k]['attributes'].items():\\n var.setncattr(ka, va)\\n\\n rootgrp.close()\",\n \"def test_save_as_netcdf(self):\\n target_dims = self.target.dimensions\\n expected_target_dims = [(u'MMAXZ', 4), \\n (u'NMAXZ', 4), \\n (u'MMAX', 4), \\n (u'NMAX', 4), \\n (u'KMAX', 2), \\n (u'KMAX1', 3), \\n (u'time', 2)\\n ]\\n target_vars = self.target.variables\\n expected_target_vars = [u'XZ',\\n u'YZ',\\n u'XCOR',\\n u'YCOR',\\n u'grid',\\n u'U1',\\n u'FAKE_U1',\\n u'V1',\\n u'W',\\n u'FAKE_W',\\n u'time',\\n u'latitude',\\n u'longitude',\\n u'grid_latitude',\\n u'grid_longitude'\\n ]\\n target_grid_vars = self.target.grid_variables\\n expected_target_grid_vars = [u'U1',\\n u'FAKE_U1',\\n u'V1',\\n u'W',\\n u'FAKE_W'\\n ]\\n target_face_coordinates = self.target.face_coordinates\\n expected_target_face_coordinates = (u'XZ', u'YZ')\\n self.assertIsInstance(self.target, SGrid2D)\\n self.assertEqual(len(target_dims), len(expected_target_dims))\\n self.assertEqual(set(target_dims), set(expected_target_dims))\\n self.assertEqual(len(target_vars), len(expected_target_vars))\\n self.assertEqual(set(target_vars), set(expected_target_vars))\\n self.assertEqual(len(target_grid_vars), len(expected_target_grid_vars))\\n self.assertEqual(set(target_grid_vars), set(expected_target_grid_vars))\\n self.assertEqual(target_face_coordinates, expected_target_face_coordinates)\",\n \"def prepare_val_coco_data(args):\\n image_dir, annotation_file = args.val_coco_image_dir, args.val_coco_annotation_file\\n\\n coco = COCO(annotation_file)\\n\\n img_ids = list(coco.imgToAnns.keys())\\n img_files = []\\n img_heights = []\\n img_widths = []\\n\\n for img_id in img_ids:\\n img_files.append(os.path.join(image_dir, coco.imgs[img_id]['file_name']))\\n img_heights.append(coco.imgs[img_id]['height']) \\n img_widths.append(coco.imgs[img_id]['width']) \\n\\n print(\\\"Building the validation dataset...\\\")\\n dataset = DataSet(img_ids, img_files, img_heights, img_widths)\\n print(\\\"Dataset built.\\\")\\n return coco, dataset\",\n \"def initialize_data(self , station = '', datasets = {} ):\\n \\n self.datasets = datasets\\n self.datasets_keys = datasets.keys()\\n self.station = station\\n \\n data = {} # container for the data of each dataset\\n source_configuration = {} # container for the source_configuration of each dataset\\n \\n\\n \\n \\\"\\\"\\\" Looping over the datasets \\\"\\\"\\\"\\n logging.info('*** Reading and Initializing the data from the netCDF files ')\\n \\n \\n for k,v in datasets.items() :\\n logging.info(' Initialising the dataset: *** %s ' , k )\\n data[k] = {} \\n data['cdm_tables'] = {} \\n \\n ### alternative with xarray \\n #ds = xr.load_dataset(v) \\n #observations_table = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n ### alternative with netCDF4\\n #ds = nc.Dataset(v) \\n #data[k]['dateindex'] = ds.variables['dateindex'][0,:] # storing the dateindex \\n \\n ###for h5py but cant extract date time units !!!\\n ds = h5py.File(v , driver=\\\"core\\\" ) \\n data[k]['df'] = ds # storing the entire file \\n try: \\n data[k]['source_file'] = ds['source_configuration']['source_file'][0]\\n except:\\n data[k]['source_file'] = str(v) # temp fix \\n \\n #data[k]['product_code'] = ds['source_configuration']['product_code'][0] \\n #data[k]['recordtimestamp'] = ds['recordtimestamp'].value\\n #data[k]['recordindex'] = ds['recordindex'].value \\n #ds.close() \\n logging.debug('Reading the file with h5py ')\\n \\n \\n # add here appending datasets for the case of ncar_w and ncar_t \\n \\n \\n self.data = data\\n self.make_dataframe()\\n ds.close()\\n \\n \\\"\\\"\\\" Reading the header_table, station_configuration, source_configuration \\\"\\\"\\\"\\n for k,v in datasets.items() : \\n \\n #d = xr.open_dataset(v , engine = 'h5netcdf' ) \\n #data[k]['recordtimestamp'] = d['recordtimestamp'].values\\n #data[k]['recordindex'] = d['recordindex'].values \\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'station_configuration') \\n data[k]['station_configuration'] = d.to_dataframe() \\n #data[k]['station_configuration'] = d ### USELESS ? \\n logging.debug('Done with %s station_configuration' , str(k) )\\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'header_table') \\n logging.debug('Loading the header_table') \\n if 'header_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['header_table'] = {}\\n for var in d.variables:\\n self.attributes['header_table'][var] = {}\\n self.attributes['header_table'][var]['description'] = d[var].description\\n self.attributes['header_table'][var]['external_table'] = d[var].external_table \\n data[k]['header_table'] = d.to_dataframe() \\n logging.debug('Done with %s ' , k )\\n \\n logging.info(\\\"*** Loading the observations_table (might take time) %s\\\" , k ) \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n if 'observations_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['observations_table'] = {}\\n for var in d.variables:\\n self.attributes['observations_table'][var] = {}\\n self.attributes['observations_table'][var]['description'] = d[var].description\\n self.attributes['observations_table'][var]['external_table'] = d[var].external_table\\n \\n \\n logging.info(\\\"*** Loading the source configuration %s\\\" , k ) \\n try: \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'source_configuration')\\n d = d.isel(hdrlen=[0])\\n data[k]['source_configuration'] = d.to_dataframe() ### USELESS ? \\n logging.debug('Done with %s source_configuration' , k )\\n except: \\n data[k]['source_configuration']= pd.DataFrame(np.array( [ [ self.data[k]['source_file'] ] ] ) , columns=['source_file'] ) \\n \\n if k == 'era5_1': # reading the whole era5_1 feedback (including reanalysis)\\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'era5fb') \\n data[k]['era5fb'] = d.to_dataframe() \\n logging.debug('Done with %s era5 feedback ', k )\\n \\n \\\"\\\"\\\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \\\"\\\"\\\" \\n if list(datasets.keys()).index(k) == 0 :\\n for t in [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type']: \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = t) \\n #data['cdm_tables'][t] = d.to_dataframe() ### USELESS ?\\n data['cdm_tables'][t] = d \\n \\n d.close() \\n ds.close()\\n\\n \\\"\\\"\\\" Reading the name of the original source file \\\"\\\"\\\"\\n source_configuration[k] = {} \\n source_configuration[k]['source_file'] = [ c for c in v.split('/') if '.nc' in c][0]\\n\\n \\n \\\"\\\"\\\" Storing the station configurations \\\"\\\"\\\" \\n self.source_configuration = source_configuration \\n \\n \\\"\\\"\\\" Making all date_times \\\"\\\"\\\" \\n self.make_all_datetime()\\n \\n \\n \\\"\\\"\\\" feedback columns \\\"\\\"\\\"\\n if 'era5_1' in list (self.data.keys() ):\\n self.fb_columns = list(self.data['era5_1']['era5fb'].columns ) \\n else:\\n self.fb_columns = ['empty']\",\n \"def createncfile(dz_id,t,x,z):\\n db = labdb.LabDB()\\n #create the directory in which to store the nc file\\n sql = \\\"\\\"\\\"INSERT into dn2t (dz_id) VALUES (%d)\\\"\\\"\\\" % (dz_id) \\n db.execute(sql)\\n sql = \\\"\\\"\\\"SELECT LAST_INSERT_ID()\\\"\\\"\\\" \\n rows = db.execute(sql)\\n dn2t_id = rows[0][0]\\n dn2t_path = \\\"/Volumes/HD4/dn2t/%d\\\" % dn2t_id \\n os.mkdir(dn2t_path)\\n\\n dn2t_filename = os.path.join(dn2t_path,\\\"dn2t.nc\\\")\\n print(\\\"d(N2)/dt filename : \\\",dn2t_filename)\\n\\n\\n # Declare the nc file for the first time\\n nc = netCDF4.Dataset(dn2t_filename,'w',format = 'NETCDF4')\\n row_dim = nc.createDimension('row',964)\\n col_dim = nc.createDimension('column',1292)\\n lenT=t.shape[0] #lenT is the length of the dn2t file.Its 1 element shorter in time axis than deltaN2\\n print(\\\"time axis length\\\",lenT) # debug info\\n t_dim = nc.createDimension('time',lenT)\\n\\n # Dimensions are also variable\\n ROW = nc.createVariable('row',numpy.float32,('row'))\\n print(list(nc.dimensions.keys()), ROW.shape,ROW.dtype)\\n COLUMN = nc.createVariable('column',numpy.float32,('column'))\\n print(list(nc.dimensions.keys()) , COLUMN.shape, COLUMN.dtype)\\n TIME = nc.createVariable('time',numpy.float32,('time'))\\n print(list(nc.dimensions.keys()) ,TIME.shape, TIME.dtype)\\n\\n # declare the 3D data variable \\n dn2t = nc.createVariable('dn2t_array',numpy.float32,('time','row','column'))\\n print(list(nc.dimensions.keys()) ,dn2t.shape,dn2t.dtype)\\n\\n # assign the values\\n TIME[:] = t\\n ROW[:] = z\\n COLUMN[:] = x\\n\\n nc.close()\\n db.commit()\\n return dn2t_id,dn2t_filename\",\n \"def decomptcperrlessdata(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._decomptcperrlessdata\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def create_netcdf(self):\\n\\n # NetCDF file and global attributes\\n file_name = self.output_dir / f\\\"{author.replace(' ', '_').lower()}_{self.sos_file.split('_')[0]}.nc\\\"\\n ds = Dataset(file_name, 'w')\\n ds.author = self.author\\n ds.contact = self.email\\n ds.sos_file = self.sos_file\\n ds.production_date = datetime.now().strftime('%d-%b-%Y %H:%M:%S')\\n\\n # Groups\\n for source in self.priors_dict.keys():\\n # Check if the group has data\\n if self.priors_dict[source]:\\n # Create groups for each prior and populate with data\\n for prior, data in self.priors_dict[source].items():\\n # Group\\n g = ds.createGroup(f\\\"{source}_{prior}\\\")\\n\\n # Attribute\\n g.run_type = data[\\\"run_type\\\"]\\n\\n # Dimensions\\n if \\\"reach_ids\\\" in data.keys(): \\n self.create_dimensions(source, g, num_reaches=len(data[\\\"reach_ids\\\"]))\\n else:\\n self.create_dimensions(source, g, num_nodes=len(data[\\\"node_ids\\\"]))\\n\\n # Variables\\n self.create_variables(source, prior, data, g)\\n\\n # Close dataset file\\n ds.close()\",\n \"def _check_data(data):\\n if not (data.dtype == _np.float32 and data.flags.c_contiguous):\\n raise ValueError('supplied data must be float32 and C contiguous')\\n if data.ndim == 2:\\n num_frames, channels = data.shape\\n elif data.ndim == 1:\\n num_frames, channels = data.size, 1\\n else:\\n raise ValueError('rank > 2 not supported')\\n return num_frames, channels\",\n \"def to_netcdf(self, outfile):\",\n \"def test_cl_fix_data(cl_cube):\\n fix = Cl(None)\\n out_cube = fix.fix_data(cl_cube)\\n assert out_cube.data == [100.0]\",\n \"def test_simple(self):\\n with self.subTest(\\\"from np array\\\"):\\n data = np.random.rand(10, 4)\\n mask = np.ones((10, 4))\\n channels = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n fcs.FCSData((data, mask), channels=channels)\",\n \"def data_fetch_netcdf(self):\\n self.client = boto3.client('s3', aws_access_key_id=self.creds_data['key_id'],\\n aws_secret_access_key=self.creds_data['key_access'])\\n year = self.month_year[0]\\n month = self.month_year[1]\\n # change output folder to desired location from TRMM website\\n # folder structure to partitioned the data year_month\\n output_temp = self.output_folder + year + '_' + month\\n url_data = \\\"http://trmm.atmos.washington.edu/{}interp_data/{}/{}\\\".format(self.output_folder, year, month)\\n print(url_data)\\n start_time_year_month = time.time()\\n r = requests.get(url_data, auth=self.auth_data)\\n # check if url exists then extract netcdf links to download and upload to s3.\\n if r.status_code == 200:\\n soup = BeautifulSoup(r.text, features='lxml')\\n for link in soup.findAll('a'):\\n link_url = link.get('href')\\n write_path = os.path.join(output_temp, link_url)\\n if link_url.endswith('.nc4'):\\n file_url = url_data + '/' + link_url\\n r = requests.get(file_url, auth=self.auth_data, stream=True)\\n if r.status_code == 200:\\n self.client.put_object(Body=r.content, Bucket='himatdata', Key='Trmm/' + write_path)\\n logging.info(\\\"Done with Year Month: %s\\\", month_year)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time_year_month))\\n\\n else:\\n print('No data/authentication for'.format(month_year))\",\n \"def test_cl_fix_file(mock_get_filepath, cl_file, tmp_path):\\n mock_get_filepath.return_value = os.path.join(tmp_path,\\n 'fixed_cesm2_waccm_cl.nc')\\n fix = Cl(None)\\n fixed_file = fix.fix_file(cl_file, tmp_path)\\n mock_get_filepath.assert_called_once_with(tmp_path, cl_file)\\n fixed_dataset = Dataset(fixed_file, mode='r')\\n assert fixed_dataset.variables['lev'].standard_name == (\\n 'atmosphere_hybrid_sigma_pressure_coordinate')\\n assert fixed_dataset.variables['lev'].formula_terms == (\\n 'p0: p0 a: a b: b ps: ps')\\n assert fixed_dataset.variables['lev'].units == '1'\\n np.testing.assert_allclose(fixed_dataset.variables['a'][:], [1.0, 2.0])\\n np.testing.assert_allclose(fixed_dataset.variables['b'][:], [0.0, 1.0])\\n np.testing.assert_allclose(fixed_dataset.variables['a_bnds'][:],\\n [[0.0, 1.5], [1.5, 3.0]])\\n np.testing.assert_allclose(fixed_dataset.variables['b_bnds'][:],\\n [[-1.0, 0.5], [0.5, 2.0]])\",\n \"def test_recv(self):\\n # Required to get useful test names\\n super(TestCisPandasInput_local, self).test_recv()\",\n \"def prepare_test_data():\\n # Dictionary in which to store data\\n data_dict = {}\\n # Load data01.nc Dataset\\n data01 = xr.open_dataset(os.path.dirname(__file__)+'/data/data01.nc',\\n decode_times=False, autoclose=True)\\n data_dict['data01'] = data01.copy()\\n # Extract two *DataArrays* - to test functions with DataArrays\\n da_ts = data01['TS'].copy()\\n da_precl = data01['PRECL'].copy()\\n data_dict['da_ts'] = da_ts.copy()\\n data_dict['da_precl'] = da_precl.copy()\\n # Dataset with *shifted* longitudes\\n ds_shift_lon = climapy.xr_shift_lon(data01.copy())\\n data_dict['ds_shift_lon'] = ds_shift_lon.copy()\\n # Datasets with *reversed* lon/lat coordinates and data\\n ds_rev_lon = data01.copy()\\n ds_rev_lon['lon'].values = ds_rev_lon['lon'].values[::-1]\\n for var_name in ['TS', 'PRECL']: # array order: time, lat, lon\\n ds_rev_lon[var_name].values = ds_rev_lon[var_name].values[:, :, ::-1]\\n ds_rev_lat = data01.copy()\\n ds_rev_lat['lat'].values = ds_rev_lat['lat'].values[::-1]\\n for var_name in ['TS', 'PRECL']:\\n ds_rev_lat[var_name].values = ds_rev_lat[var_name].values[:, ::-1, :]\\n ds_rev_both = data01.copy()\\n ds_rev_both['lat'].values = ds_rev_both['lat'].values[::-1]\\n ds_rev_both['lon'].values = ds_rev_both['lon'].values[::-1]\\n for var_name in ['TS', 'PRECL']:\\n ds_rev_both[var_name].values = ds_rev_both[var_name].values[:, ::-1, ::-1]\\n data_dict['ds_rev_lon'] = ds_rev_lon.copy()\\n data_dict['ds_rev_lat'] = ds_rev_lat.copy()\\n data_dict['ds_rev_both'] = ds_rev_both.copy()\\n # Dataset with *transposed* lon/lat coords\\n ds_transposed = data01.copy()\\n ds_transposed = ds_transposed.transpose()\\n data_dict['ds_transposed'] = ds_transposed.copy()\\n # Dataset with *renamed* longitude and latitude coords\\n ds_renamed = data01.copy()\\n ds_renamed = ds_renamed.rename({'lon': 'longitude', 'lat': 'latitude'})\\n data_dict['ds_renamed'] = ds_renamed.copy()\\n # Datasets with slightly *irregular* lon/lat coords, yet still monotonic\\n nx, ny = data01['lon'].size, data01['lat'].size\\n lon_irr = (data01['lon'].values +\\n np_rand.uniform(low=-0.5, high=0.5, size=nx)) # add small amount of noise\\n lon_irr[[0, -1]] = data01['lon'].values[[0, -1]] # keep end values unchanged\\n lat_irr = (data01['lat'].values +\\n np_rand.uniform(low=-0.5, high=0.5, size=ny))\\n lat_irr[[0, -1]] = data01['lat'].values[[0, -1]]\\n ds_irr_lon = data01.copy()\\n ds_irr_lon['lon'].values = lon_irr.copy()\\n ds_irr_lat = data01.copy()\\n ds_irr_lat['lat'].values = lat_irr.copy()\\n ds_irr_both = data01.copy()\\n ds_irr_both['lon'].values = lon_irr.copy()\\n ds_irr_both['lat'].values = lat_irr.copy()\\n data_dict['ds_irr_lon'] = ds_irr_lon.copy()\\n data_dict['ds_irr_lat'] = ds_irr_lat.copy()\\n data_dict['ds_irr_both'] = ds_irr_both.copy()\\n # Dataset with *strange* lon/lat coords - very irregular and not monotonic\\n lon_strange = (data01['lon'].values +\\n np_rand.uniform(low=-10, high=10, size=nx)) # add large amount of noise\\n lon_strange[[0, -1]] = data01['lon'].values[[0, -1]] # keep end values unchanged\\n lat_strange = (data01['lat'].values + np_rand.uniform(low=-10, high=10, size=ny))\\n lat_strange[[0, -1]] = data01['lat'].values[[0, -1]] # keep end values unchanged\\n ds_strange = data01.copy()\\n ds_strange['lon'].values = lon_strange.copy()\\n ds_strange['lat'].values = lat_strange.copy()\\n data_dict['ds_strange'] = ds_strange.copy()\\n # Return dictionary of data\\n return data_dict\",\n \"def prep(self, deleteraw=False):\\n print\\n print 'Filtering rawdata to data as masked array...'\\n# using 0 as flag\\n# self.data = n.ma.masked_array(self.rawdata[:self.nints,:, self.chans,:], self.rawdata[:self.nints,:, self.chans,:] == 0j)\\n# using standard flags\\n self.data = n.ma.masked_array(self.rawdata[:self.nints,:, self.chans,:], self.flags[:self.nints,:, self.chans,:] == 0) # mask of True for flagged data (flags=0 in tpipe, which is flags=False in Miriad and flags=True in MS)\\n self.dataph = (self.data.mean(axis=3).mean(axis=1)).real #dataph is summed and detected to form TP beam at phase center, multi-pol\\n self.min = self.dataph.min()\\n self.max = self.dataph.max()\\n print 'Shape of data:'\\n print self.data.shape\\n print 'Dataph min, max:'\\n print self.min, self.max\\n\\n if deleteraw:\\n del self.rawdata\\n del self.flags\\n\\n self.freq = self.freq_orig[self.chans]\\n\\n # set up ur tracks (lol)\\n self.dmtrack0 = {}\\n self.twidths = {}\\n self.delay = {}\\n for dmbin in xrange(len(self.dmarr)):\\n self.dmtrack0[dmbin] = self.dmtrack(self.dmarr[dmbin],0) # track crosses high-freq channel in first integration\\n (trackt, trackc) = self.dmtrack0[dmbin]\\n if len(trackc)<len(self.chans):\\n print 'Computed track for DM=%.1f is too long for the observation; only %d channels are computed' % (self.dmarr[dmbin],len(trackc))\\n continue\\n \\n# old way\\n# self.twidths[dmbin] = [len(n.where(trackc == (chan-self.chans[0]))[0]) for chan in self.chans] # width of track for each unflagged channel\\n# self.delay[dmbin] = [n.int(trackt[n.where(trackc == (chan-self.chans[0]))[0][0]]) for chan in self.chans] # integration delay for each unflagged channel of a given dm.\\n# new way\\n\\n self.twidths[dmbin] = [len(n.where(n.array(trackc) == chan)[0]) for chan in range(len(self.chans))] # width of track for each unflagged channel\\n self.delay[dmbin] = [n.int(trackt[n.where(n.array(trackc) == chan)[0][0]]) for chan in range(len(self.chans))] # integration delay for each unflagged channel of a given dm.\\n\\n\\n print 'Track width in time: '\\n for dmbin in self.twidths:\\n print 'DM=%.1f, max(twidth)=%d. Iteration could step by %d/2.' % (self.dmarr[dmbin], max(self.twidths[dmbin]), max(self.twidths[dmbin]))\",\n \"def has_data(self):\\n if len(self.channels) > 0:\\n return True\\n return False\",\n \"def setUp(self):\\n\\n serial_times = {295: '1971-07-31T01:24:11.754',\\n 296: '1971-07-31T01:24:36.970',\\n 297: '1971-07-31T01:25:02.243',\\n 298: '1971-07-31T01:25:27.457',\\n 299: '1971-07-31T01:25:52.669',\\n 300: '1971-07-31T01:26:17.923'}\\n self.serials = ['APOLLO15/METRIC/{}'.format(i) for i in serial_times.values()]\\n\\n\\n x = list(range(5))\\n y = list(range(5))\\n pid = [0,0,1,1,1]\\n idx = pid\\n serials = [self.serials[0], self.serials[1], self.serials[2],\\n self.serials[2], self.serials[3]]\\n\\n\\n columns = ['x', 'y', 'idx', 'pid', 'nid']\\n self.data_length = 5\\n\\n data = [x,y, idx, pid, serials]\\n\\n self.creation_time = strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())\\n cnet = C(data, index=columns).T\\n\\n io_controlnetwork.to_isis('test.net', cnet, mode='wb', targetname='Moon')\\n\\n self.header_message_size = 85\\n self.point_start_byte = 65621\",\n \"def do_grid_check(self,):\\n self.ydim, self.xdim = self.data_fcst.shape \\n if self.data_obs.shape != (self.ydim,self.xdim):\\n raise FormatError(\\\"Obs and forecast data not same size.\\\")\\n return\",\n \"def __init__(self, out_dir = 'output' ):\\n \\n self.data = {} # will contain the data for each different dataset \\n self.datasets = '' # will contain the input datasets (original dictionary)\\n self.datasets_keys = '' # will contain the input datasets names only (i.e. keys of the datasets dictionary)\\n self.datasets_all = ['igra2' , 'era5_1' , 'ncar_w' , 'ncar_t', 'bufr' , 'era5_1759' , 'era5_1761' , 'era5_3188'] # all possibly available datasets \\n #self.observation_ids_merged = { 'igra2':1 , 'ncar_t':2 , 'ncar_w':2, 'bufr':3, 'era5_1':4 , 'era5_1759' :5 , 'era5_1761':6 , 'era5_3188' :7} # values used to convert original record_id to the merged record_id, see method merge_all_data \\n \\n self.observation_ids_merged = { 'igra2':1 , 'ncar':2, 'bufr':3, 'era5_1':4 , 'era5_1759' :5 , 'era5_1761':6 , 'era5_3188' :7} # values used to convert original record_id to the merged record_id, see method merge_all_data \\n \\n self.unique_dates = {} \\n self.attributes = {} # will keep the original attributes from the CDM tables, read from the netCDF files \\n self.out_dir = out_dir\",\n \"def MyDataChangedCallback(self, inRefcon):\\r\\n pass\",\n \"def output_netcdf(forecast,proj_dict,grid_dict,start_hour,end_hour,\\n stride,size,run_date,target_dataset,smoothing,config):\\n for d,date in enumerate(run_date):\\n date_outpath = config.forecast_out_path+'20{0}/netcdf/'.format(\\n date)\\n \\n if not os.path.exists(date_outpath):\\n os.makedirs(date_outpath)\\n \\n map_data = make_proj_grids(proj_dict,grid_dict)\\n lons = map_data[\\\"lon\\\"]\\n lats = map_data[\\\"lat\\\"]\\n \\n filtered_forecast = gaussian_filter(forecast[d],smoothing,mode='constant')\\n \\n filename = date_outpath + \\\"{0}_{6}_Hail_{1}_Cali_NMEP_{2}mm_{3}_Hours_{4}-{5}.nc\\\".format(\\n config.ensemble_name,\\n target_dataset,\\n size,\\n date,\\n start_hour,end_hour,config.forecast_model_names)\\n\\n \\n out_file = Dataset(filename, \\\"w\\\")\\n out_file.createDimension(\\\"x\\\", filtered_forecast.shape[0])\\n out_file.createDimension(\\\"y\\\", filtered_forecast.shape[1])\\n out_file.createVariable(\\\"Longitude\\\", \\\"f4\\\", (\\\"x\\\", \\\"y\\\"))\\n out_file.createVariable(\\\"Latitude\\\", \\\"f4\\\",(\\\"x\\\", \\\"y\\\"))\\n out_file.createVariable(\\\"Data\\\", \\\"f4\\\", (\\\"x\\\", \\\"y\\\"))\\n out_file.variables[\\\"Longitude\\\"][:,:] = lons\\n out_file.variables[\\\"Latitude\\\"][:,:] = lats\\n out_file.variables[\\\"Data\\\"][:,:] = filtered_forecast\\n out_file.projection = proj_dict[\\\"proj\\\"]\\n out_file.lon_0 = proj_dict[\\\"lon_0\\\"]\\n out_file.lat_0 = proj_dict[\\\"lat_0\\\"]\\n out_file.lat_1 = proj_dict[\\\"lat_1\\\"]\\n out_file.lat_2 = proj_dict[\\\"lat_2\\\"]\\n out_file.close()\\n \\n print(\\\"Writing to \\\" + filename)\\n return\",\n \"def _handleRequestCableCheckParameters(self, data):\\r\\n print(\\\"\\\\\\\"Request Cable Check Parameters\\\\\\\" received\\\")\\r\\n message = self.whitebeet.v2gParseRequestCableCheckParameters(data)\\r\\n if 'dc' in message:\\r\\n print(\\\"SOC: {}%\\\".format(message['dc']['soc']))\\r\\n try:\\r\\n self.whitebeet.v2gSetDcCableCheckParameters(0, 1)\\r\\n except Warning as e:\\r\\n print(\\\"Warning: {}\\\".format(e))\\r\\n except ConnectionError as e:\\r\\n print(\\\"ConnectionError: {}\\\".format(e))\",\n \"def read(self, data=''):\\n if not self.nc.io.closed():\\n self.nc.io.read_bytes(MAX_CONTROL_LINE_SIZE, callback=self.read, streaming_callback=self.parse, partial=True)\",\n \"def create_netcdf(self, netcdf_file, cols, rows, doy_range, do_zlib=True):\\n\\n # least_significant_digit for createVariable(...)\\n lsd=None\\n\\n # create a new netCDF file\\n rootgrp = nc.Dataset(netcdf_file, \\\"w\\\")\\n rootgrp.description = \\\"NBAR reflectance and BB albedo\\\"\\n\\n # Create groups for NBAR reflectance and BB albedo\\n refl_grp = rootgrp.createGroup(\\\"reflectance\\\")\\n refl_grp.description = \\\"Normalized at nadir (NBAR) reflectance\\\"\\n albedo_grp = rootgrp.createGroup(\\\"albedo\\\")\\n albedo_grp.description = \\\"Broad band (BB) albedo\\\"\\n\\n # Create dimensions for reflectance data. I.e. time series of reflectance\\n # are determined by x, y and a day since 2000\\n x = rootgrp.createDimension(\\\"x\\\", cols)\\n y = rootgrp.createDimension(\\\"y\\\", rows)\\n day = rootgrp.createDimension(\\\"day\\\", doy_range.shape[0])\\n band = rootgrp.createDimension(\\\"band\\\", 7)\\n str_dim = rootgrp.createDimension(\\\"str_dim\\\", 10)\\n\\n # We can set zlib=True for compression as an argument\\n # of the createVariable function\\n date_str = rootgrp.createVariable(\\\"date_str\\\", \\\"S1\\\", (\\\"day\\\", \\\"str_dim\\\"), zlib=do_zlib, least_significant_digit=lsd)\\n date_str.units = \\\"string representation of date: yyyy.mm.dd\\\"\\n # date = rootgrp.createVariable(\\\"julday\\\", \\\"i\\\")\\n date = rootgrp.createVariable(\\\"julday\\\", \\\"i\\\", \\\"day\\\", zlib=do_zlib, least_significant_digit=lsd)\\n date.units = \\\"Julian day\\\"\\n\\n # Create variables of NBAR reflectance: 7 MODIS bands\\n for i in range(1, 8):\\n refl = refl_grp.createVariable(\\\"refl_b%d\\\" % i, \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n refl.units = \\\"surface bidirectional reflectance, band %d\\\" % i\\n\\n # reflectance uncertainty\\n refl_sd = refl_grp.createVariable(\\\"refl_b%d_sd\\\" % i, \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n refl_sd.units = \\\"uncertainty of surface bidirectional reflectance, band %d\\\" % i\\n \\n y_fwd = refl_grp.createVariable(\\\"y_fwd\\\", \\\"f4\\\", (\\\"day\\\", \\\"band\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n\\n y_orig = refl_grp.createVariable(\\\"y_orig\\\", \\\"f4\\\", (\\\"day\\\", \\\"band\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib, \\\\\\n least_significant_digit=lsd)\\n \\n albedo_vis = albedo_grp.createVariable(\\\"albedo_vis\\\", \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_vis.units = \\\"broad band albedo\\\"\\n albedo_nir = albedo_grp.createVariable(\\\"albedo_nir\\\", \\\"f4\\\", ( \\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_nir.units = \\\"broad band albedo\\\"\\n albedo_swir = albedo_grp.createVariable(\\\"albedo_swir\\\", \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_swir.units = \\\"broad band albedo\\\"\\n\\n # albedo uncertainty\\n albedo_vis_sd = albedo_grp.createVariable(\\\"albedo_vis_sd\\\", \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_vis_sd.units = \\\"albedo standard deviation\\\"\\n albedo_nir_sd = albedo_grp.createVariable(\\\"albedo_nir_sd\\\", \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_nir_sd.units = \\\"albedo standard deviation\\\"\\n albedo_swir_sd = albedo_grp.createVariable(\\\"albedo_swir_sd\\\", \\\"f4\\\", (\\\"day\\\", \\\"x\\\", \\\"y\\\"), zlib=do_zlib,\\\\\\n least_significant_digit=lsd)\\n albedo_swir_sd.units = \\\"albedo standard deviation\\\"\\n\\n # latitude and longitude arrays\\n lat = rootgrp.createVariable('lat', \\\"f4\\\", (\\\"x\\\", \\\"y\\\"), zlib=do_zlib)\\n lat.units = \\\"latitude\\\"\\n lon = rootgrp.createVariable('lon', \\\"f4\\\", (\\\"x\\\", \\\"y\\\"), zlib=do_zlib)\\n lon.units = \\\"longitude\\\"\\n\\n # save geo information and projection\\n # nchar_proj = len(proj_str)\\n # nchar_geo = len(geo_str)\\n rootgrp.createDimension('nchar_proj', 400)\\n rootgrp.createDimension('nchar_geo', 100)\\n rootgrp.createVariable('proj', 'S1', ('nchar_proj'))\\n rootgrp.createVariable('geo_transform', 'S1', 'nchar_geo')\\n\\n # proj_char = nc.stringtochar(np.array([proj_str], 'S%d' % nchar_proj))\\n # geo_char = nc.stringtochar(np.array([geo_str], 'S%d' % nchar_geo))\\n # rootgrp.variables['proj'][:] = proj_char\\n # rootgrp.variables['geo_transform'][:] = geo_char\\n\\n return rootgrp\",\n \"def dataIdentify(self, in_nc):\\r\\n data_nc = NET.Dataset(in_nc)\\r\\n time = data_nc.variables['time'][:]\\r\\n diff = NUM.unique(NUM.diff(time))\\r\\n data_nc.close()\\r\\n #time_interval_highres = NUM.array([1.0,3.0,6.0],dtype=float)\\r\\n #time_interval_lowres_full = NUM.array([3.0, 6.0],dtype=float)\\r\\n #time_interval_lowres = NUM.array([6.0],dtype=float)\\r\\n #time_interval_lowres_3Hr = NUM.array([3.0],dtype=float)\\r\\n\\t\\t\\r\\n time_interval_HRES1 = NUM.array([1.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n time_interval_HRES13 = NUM.array([1.0,3.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n time_interval_HRES136 = NUM.array([1.0,3.0,6.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n time_interval_ENS3 = NUM.array([3.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n time_interval_ENS36 = NUM.array([3.0,6.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n time_interval_ENS6 = NUM.array([6.0],dtype=float) # Line Added/Modified CJB 20190108\\r\\n\\r\\n\\r\\n #print \\\"SDR - diff:\\\", diff, time_interval_highres, time_interval_lowres_full, time_interval_lowres\\r\\n #if NUM.array_equal(diff, time_interval_highres):\\r\\n # return \\\"HighRes\\\"\\r\\n #elif NUM.array_equal(diff, time_interval_lowres_full):\\r\\n # return \\\"LowResFull\\\"\\r\\n #elif NUM.array_equal(diff, time_interval_lowres):\\r\\n # return \\\"LowRes\\\"\\r\\n #elif NUM.array_equal(diff, time_interval_lowres_3Hr):\\r\\n # return \\\"Low3HrRes\\\"\\r\\n #else:\\r\\n # return None\\r\\n\\t\\t\\t\\r\\n if NUM.array_equal(diff, time_interval_HRES1): # Line Added/Modified CJB 20190108\\r\\n return \\\"HRES1\\\" # Line Added/Modified CJB 20190108\\r\\n elif NUM.array_equal(diff, time_interval_HRES13): # Line Added/Modified CJB 20190108\\r\\n return \\\"HRES13\\\" # Line Added/Modified CJB 20190108\\r\\n elif NUM.array_equal(diff, time_interval_HRES136): # Line Added/Modified CJB 20190108\\r\\n return \\\"HRES136\\\" # Line Added/Modified CJB 20190108\\r\\n elif NUM.array_equal(diff, time_interval_ENS3): # Line Added/Modified CJB 20190108\\r\\n return \\\"ENS3\\\" # Line Added/Modified CJB 20190108\\r\\n elif NUM.array_equal(diff, time_interval_ENS36): # Line Added/Modified CJB 20190108\\r\\n return \\\"ENS36\\\" # Line Added/Modified CJB 20190108\\r\\n elif NUM.array_equal(diff, time_interval_ENS6): # Line Added/Modified MJS, CJB 20190108\\r\\n return \\\"ENS6\\\" # Line Added/Modified CJB 20190108\\r\\n else: # Line Added/Modified CJB 20190108\\r\\n return None # Line Added/Modified CJB 20190108\\r\",\n \"def writeNetCDFData(out_nc, hrus, dr_time, hru_type, remapped_data, var_meta, var_attrs, var_encodings, remap_idx):\\n\\n dataset = xr.Dataset()\\n\\n for varname, meta in var_meta.items():\\n foo = xr.DataArray(remapped_data[varname][:, remap_idx],\\n dims=['time', 'basinID'],\\n name=varname)\\n\\n foo.encoding = var_encodings[varname]\\n foo.attrs = var_attrs[varname]\\n\\n dataset[varname] = foo\\n\\n # HRU ID variables\\n dataset['basinID'] = xr.DataArray(hrus[remap_idx], dims=['basinID'])\\n dataset['basinID'].encoding = {'dtype': hru_type, '_FillValue': None}\\n dataset['basinID'].attrs = {'long_name': 'Basin ID'}\\n\\n dataset[TIME_DIM_NAME] = dr_time\\n\\n dataset.to_netcdf(out_nc, unlimited_dims='time')\",\n \"def write_netcdf(file, lons, lats, times, hydrographs, fractions, loc, grid_id,\\n inds, Flist, velocity, diffusion, fill_value, verbose):\\n f = Dataset(file,'w', format='NETCDF4')\\n\\n # set dimensions\\n time = f.createDimension('time', None)\\n lon = f.createDimension('lon', (len(lons)))\\n lat = f.createDimension('lat', (len(lats)))\\n\\n # initialize variables\\n time = f.createVariable('time','f8',('time',))\\n lon = f.createVariable('lon','f8',('lon',))\\n lat = f.createVariable('lat','f8',('lat',))\\n fraction = f.createVariable('fraction','f8',('lat','lon',),fill_value=fill_value)\\n UHS = f.createVariable('unit_hydrograph','f8',('time','lat','lon',),fill_value=fill_value)\\n\\n # write attributes for netcdf\\n f.description = 'Aggregated UH_S and Fraction Vars'\\n f.history = 'Created: {}\\\\n'.format(tm.ctime(tm.time()))\\n f.history += ' '.join(sys.argv) + '\\\\n'\\n f.source = sys.argv[0] # prints the name of script used\\n f.velocity = velocity\\n f.diffusion = diffusion\\n f.outlet_id = str(grid_id.astype(np.int64))\\n f.outlet_y= str(inds[0].astype(np.int64))\\n f.outlet_x = str(inds[1].astype(np.int64)) # this is change is a cdo work around. Othewise cdo removes the attribute. \\n f.outlet_lat = loc[0]\\n f.outlet_lon = loc[1]\\n f.includes = ', '.join(Flist)\\n\\n lat.long_name = 'latitude coordinate'\\n lat.standard_name = 'latitude'\\n lat.units = 'degrees_north'\\n\\n lon.long_name = 'longitude coordinate'\\n lon.standard_name = 'longitude'\\n lon.units = 'degrees_east'\\n\\n time.units = 'seconds since 0001-1-1 0:0:0'\\n time.calendar = 'noleap'\\n time.longname = 'time'\\n time.type_prefered = 'float'\\n time.description = 'Seconds since initial impulse'\\n\\n UHS.units = 'unitless'\\n UHS.description = 'unit hydrograph for each grid cell with respect to downstream grid location'\\n \\n fraction.units = 'unitless'\\n fraction.description = 'fraction of grid cell contributing to guage location'\\n\\n # write data to variables initialized above\\n time[:]= times\\n lon[:] = lons\\n lat[:] = lats\\n UHS[:,:,:] = hydrographs\\n fraction[:,:]= fractions\\n f.close()\",\n \"def data_cb(self, handle, value):\\n \\n self.x, self.y, self.z, self.temp = unpack('fffB', value)\\n print(f\\\"xyz: {self.x}, {self.y}, {self.z}\\\")\\n self.send()\",\n \"def data_sample(CI, CC, thermal, calibration, health, driver_monitor, gps_location,\\n poller, cal_status, cal_perc, overtemp, free_space, low_battery,\\n driver_status, geofence, state, mismatch_counter, params):\\n\\n # Update carstate from CAN and create events\\n CS = CI.update(CC)\\n events = list(CS.events)\\n enabled = isEnabled(state)\\n\\n # Receive from sockets\\n td = None\\n cal = None\\n hh = None\\n dm = None\\n gps = None\\n\\n for socket, event in poller.poll(0):\\n if socket is thermal:\\n td = messaging.recv_one(socket)\\n elif socket is calibration:\\n cal = messaging.recv_one(socket)\\n elif socket is health:\\n hh = messaging.recv_one(socket)\\n elif socket is driver_monitor:\\n dm = messaging.recv_one(socket)\\n elif socket is gps_location:\\n gps = messaging.recv_one(socket)\\n\\n if td is not None:\\n overtemp = td.thermal.thermalStatus >= ThermalStatus.red\\n free_space = td.thermal.freeSpace < 0.15 # under 15% of space free no enable allowed\\n low_battery = td.thermal.batteryPercent < 1 # at zero percent battery, OP should not be allowed\\n\\n # Create events for battery, temperature and disk space\\n if low_battery:\\n events.append(create_event('lowBattery', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n if overtemp:\\n events.append(create_event('overheat', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n if free_space:\\n events.append(create_event('outOfSpace', [ET.NO_ENTRY]))\\n\\n # Handle calibration\\n if cal is not None:\\n cal_status = cal.liveCalibration.calStatus\\n cal_perc = cal.liveCalibration.calPerc\\n\\n if cal_status != Calibration.CALIBRATED:\\n if cal_status == Calibration.UNCALIBRATED:\\n events.append(create_event('calibrationIncomplete', [ET.NO_ENTRY, ET.SOFT_DISABLE, ET.PERMANENT]))\\n else:\\n events.append(create_event('calibrationInvalid', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n\\n # When the panda and controlsd do not agree on controls_allowed\\n # we want to disengage openpilot. However the status from the panda goes through\\n # another socket than the CAN messages, therefore one can arrive earlier than the other.\\n # Therefore we allow a mismatch for two samples, then we trigger the disengagement.\\n if not enabled:\\n mismatch_counter = 0\\n\\n if hh is not None:\\n controls_allowed = hh.health.controlsAllowed\\n if not controls_allowed and enabled:\\n mismatch_counter += 1\\n if mismatch_counter >= 2:\\n events.append(create_event('controlsMismatch', [ET.IMMEDIATE_DISABLE]))\\n\\n # Driver monitoring\\n if dm is not None:\\n driver_status.get_pose(dm.driverMonitoring, params)\\n\\n # Geofence\\n if geofence is not None and gps is not None:\\n geofence.update_geofence_status(gps.gpsLocationExternal, params)\\n if geofence is not None and not geofence.in_geofence:\\n events.append(create_event('geofence', [ET.NO_ENTRY, ET.WARNING]))\\n\\n return CS, events, cal_status, cal_perc, overtemp, free_space, low_battery, mismatch_counter\",\n \"def __log_data_handler(self, event, sender, data):\\n pos_x = -data.mvo.pos_x\\n pos_y = -data.mvo.pos_y\\n pos_z = -data.mvo.pos_z\\n # First time we have meaningful values, we store them as reference\\n if abs(pos_x) + abs(pos_y) + abs(pos_z) > 0.07:\\n if self.ref_pos_x == -1:\\n self.ref_pos_x = pos_x\\n self.ref_pos_y = pos_y\\n self.ref_pos_z = pos_z\\n else:\\n self.pos_x = pos_x - self.ref_pos_x\\n self.pos_y = pos_y - self.ref_pos_y\\n self.pos_z = pos_z - self.ref_pos_z\\n\\n qx = data.imu.q1\\n qy = data.imu.q2\\n qz = data.imu.q3\\n qw = data.imu.q0\\n\\n degree = 0.01745\\n siny = 2 * (qw * qz + qx * qy)\\n cosy = 1 - 2 * (qy * qy + qz * qz)\\n self.yaw = int(atan2(siny, cosy) / degree)\\n\\n if self.write_header:\\n self.log_file.write(f\\\"{data.format_cvs_header()}\\\\n\\\")\\n self.write_header = False\\n self.log_file.write(f\\\"{data.format_cvs()}\\\\n\\\")\",\n \"def _handle_MonitorData (self, event, packet, reverse):\\n pass\",\n \"def XPLMDataChanged_f(inRefcon):\",\n \"def hmVerifyMsgCRCOK(destination, protocol, source, expectedFunction, expectedLength, datal) :\\r\\n badresponse = 0\\r\\n if protocol == constants.HMV3_ID:\\r\\n checksum = datal[len(datal)-2:]\\r\\n rxmsg = datal[:len(datal)-2]\\r\\n crc = crc16() # Initialises the CRC\\r\\n expectedchecksum = crc.run(rxmsg)\\r\\n if expectedchecksum == checksum:\\r\\n print(\\\"CRC is correct\\\")\\r\\n else:\\r\\n print(\\\"CRC is INCORRECT\\\")\\r\\n s = \\\"Incorrect CRC: %s Expected: %s \\\\n\\\" % (datal, expectedchecksum)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n # Check the response\\r\\n dest_addr = datal[0]\\r\\n frame_len_l = datal[1]\\r\\n frame_len_h = datal[2]\\r\\n frame_len = (frame_len_h << 8) | frame_len_l\\r\\n source_addr = datal[3]\\r\\n func_code = datal[4]\\r\\n\\r\\n\\r\\n\\r\\n if (dest_addr != 129 and dest_addr != 160):\\r\\n print(\\\"dest_addr is ILLEGAL\\\")\\r\\n s = \\\"%s : Controller %s : Illegal Dest Addr: %s\\\\n\\\" % (localtime, loop, dest_addr)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (dest_addr != destination):\\r\\n print(\\\"dest_addr is INCORRECT\\\")\\r\\n s = \\\"%s : Controller %s : Incorrect Dest Addr: %s\\\\n\\\" % (localtime, loop, dest_addr)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (source_addr < 1 or source_addr > 32):\\r\\n print(\\\"source_addr is ILLEGAL\\\")\\r\\n s = \\\"%s : Controller %s : Illegal Src Addr: %s\\\\n\\\" % (localtime, loop, source_addr)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (source_addr != source):\\r\\n print(\\\"source addr is INCORRECT\\\")\\r\\n s = \\\"%s : Controller %s : Incorrect Src Addr: %s\\\\n\\\" % (localtime, loop, source_addr)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (func_code != constants.FUNC_WRITE and func_code != constants.FUNC_READ):\\r\\n print(\\\"Func Code is UNKNWON\\\")\\r\\n s = \\\"%s : Controller %s : Unknown Func Code: %s\\\\n\\\" % (localtime, loop, func_code)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (func_code != expectedFunction):\\r\\n print(\\\"Func Code is UNEXPECTED\\\")\\r\\n s = \\\"%s : Controller %s : Unexpected Func Code: %s\\\\n\\\" % (localtime, loop, func_code)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (func_code == constants.FUNC_WRITE and frame_len != 7):\\r\\n # Reply to Write is always 7 long\\r\\n print(\\\"response length is INCORRECT\\\")\\r\\n s = \\\"%s : Controller %s : Incorrect length: %s\\\\n\\\" % (localtime, loop, frame_len)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n if (len(datal) != frame_len):\\r\\n print(\\\"response length MISMATCHES header\\\")\\r\\n s = \\\"%s : Controller %s : Mismatch length: %s %s\\\\n\\\" % (localtime, loop, len(datal), frame_len)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\r\\n \\\"\\\"\\\"if (func_code == constants.FUNC_READ and expectedLength !=len(datal) ):\\r\\n # Read response length is wrong\\r\\n print(\\\"response length not EXPECTED value\\\")\\r\\n print(len(datal))\\r\\n print(datal)\\r\\n s = \\\"%s : Controller %s : Incorrect length: %s\\\\n\\\" % (localtime, loop, frame_len)\\r\\n sys.stderr.write(s)\\r\\n badresponse += 1\\r\\n\\\"\\\"\\\"\\r\\n if (badresponse == 0):\\r\\n return True\\r\\n else:\\r\\n return False\\r\\n\\r\\n else:\\r\\n assert 0, \\\"Un-supported protocol found %s\\\" % protocol\",\n \"def test_scp_handler_return_dataset_no_status(self):\\n def handle(event):\\n return Dataset()\\n\\n handlers = [(evt.EVT_C_ECHO, handle)]\\n\\n self.ae = ae = AE()\\n ae.add_supported_context(VerificationSOPClass)\\n ae.add_requested_context(VerificationSOPClass)\\n scp = ae.start_server(('', 11112), block=False, evt_handlers=handlers)\\n\\n assoc = ae.associate('localhost', 11112)\\n assert assoc.is_established\\n rsp = assoc.send_c_echo()\\n assert rsp.Status == 0x0000\\n assoc.release()\\n assert assoc.is_released\\n\\n scp.shutdown()\",\n \"def get_data(datauri): \\n print(datauri)\\n nc = netCDF4.Dataset(datauri)\\n time = nc.variables['JULD']\\n depth = nc.variables['PRES']\\n\\n checkdepth = 0\\n findepth = np.zeros(time.shape[0])\\n for i in range (0, depth.shape[0]):\\n maxdepth = np.amax(depth[i])\\n findepth[i] = maxdepth\\n if (maxdepth > checkdepth):\\n dd=i\\n checkdepth = maxdepth\\n maxdepth = findepth[dd]\\n \\n temperature = nc.variables['TEMP'][dd] \\n tempadj=nc.variables['TEMP_ADJUSTED'][dd]\\n depthnew = nc.variables['PRES'][dd] \\n depthadj = nc.variables['PRES_ADJUSTED'][dd] \\n\\n latitude = nc.variables['LATITUDE'][dd]\\n longitude = nc.variables['LONGITUDE'][dd]\\n\\n lonm=nc.variables['LONGITUDE'][dd].mask\\n latm=nc.variables['LATITUDE'][dd].mask\\n timm=nc.variables['JULD'][dd].mask\\n\\n if (lonm == True or latm == True):\\n longitude=-999.9\\n latitude=-999.9\\n\\n\\n out = {}\\n out['latitude'] = nc.variables.pop('LATITUDE')[dd]\\n out['longitude'] = nc.variables.pop('LONGITUDE')[dd]\\n out['temperature'] = nc.variables.pop('TEMP')[dd]\\n out['temperatureadj'] = nc.variables.pop('TEMP_ADJUSTED')[dd]\\n out['salinity'] = nc.variables.pop('PSAL')[dd]\\n out['salinityadj'] = nc.variables.pop('PSAL_ADJUSTED')[dd]\\n out['depth'] = nc.variables.pop('PRES')[dd]\\n out['depthadj'] = nc.variables.pop('PRES_ADJUSTED')[dd]\\n \\n return out\",\n \"def _async_process_data(self):\\n raise NotImplementedError\",\n \"def test_check_cds_14(self):\\n self.cds1.orientation = \\\"f\\\"\\n import_genome.check_cds(self.cds1, self.eval_flags)\\n count = count_status(self.cds1, \\\"error\\\")\\n self.assertEqual(count, 1)\",\n \"def before_dataobj_create(self, dataobj):\",\n \"def __init__(self, points_control, cf_file, year, site_data=None,\\n output_request=('lcoe_fcr',), out_fpath=None,\\n append=False, mem_util_lim=0.4):\\n\\n super().__init__(points_control, output_request, site_data=site_data,\\n out_fpath=out_fpath, mem_util_lim=mem_util_lim)\\n\\n self._cf_file = cf_file\\n self._year = year\\n self._run_attrs['cf_file'] = cf_file\\n self._run_attrs['sam_module'] = self._sam_module.MODULE\\n\\n # initialize output file or append econ data to gen file\\n if append:\\n self._out_fpath = self._cf_file\\n else:\\n self._init_fpath()\\n\\n mode = 'a' if append else 'w'\\n self._init_h5(mode=mode)\\n self._init_out_arrays()\",\n \"def prepare_train_coco_data(args):\\n image_dir, annotation_file, data_dir = args.train_coco_image_dir, args.train_coco_annotation_file, args.train_coco_data_dir\\n batch_size = args.batch_size\\n basic_model = args.basic_model\\n num_roi = args.num_roi\\n\\n coco = COCO(annotation_file)\\n\\n img_ids = list(coco.imgToAnns.keys())\\n img_files = []\\n img_heights = []\\n img_widths = []\\n anchor_files = []\\n gt_classes = []\\n gt_bboxes = []\\n\\n for img_id in img_ids:\\n img_files.append(os.path.join(image_dir, coco.imgs[img_id]['file_name'])) \\n img_heights.append(coco.imgs[img_id]['height']) \\n img_widths.append(coco.imgs[img_id]['width']) \\n anchor_files.append(os.path.join(data_dir, os.path.splitext(coco.imgs[img_id]['file_name'])[0]+'_'+basic_model+'_anchor.npz')) \\n\\n classes = [] \\n bboxes = [] \\n for ann in coco.imgToAnns[img_id]: \\n classes.append(coco_category_to_class[ann['category_id']]) \\n bboxes.append([ann['bbox'][1], ann['bbox'][0], ann['bbox'][3]+1, ann['bbox'][2]+1]) \\n\\n gt_classes.append(classes) \\n gt_bboxes.append(bboxes) \\n \\n print(\\\"Building the training dataset...\\\")\\n dataset = DataSet(img_ids, img_files, img_heights, img_widths, batch_size, anchor_files, gt_classes, gt_bboxes, True, True)\\n print(\\\"Dataset built.\\\")\\n return coco, dataset\",\n \"def test_check_cds_15(self):\\n self.cds1.locus_tag = \\\"\\\"\\n import_genome.check_cds(self.cds1, self.eval_flags)\\n count = count_status(self.cds1, \\\"error\\\", \\\"warning\\\")\\n self.assertEqual(count, 2)\",\n \"def test_check_cds_6(self):\\n import_genome.check_cds(self.cds1, self.eval_flags)\\n count = count_status(self.cds1, \\\"error\\\")\\n self.assertEqual(count, 0)\",\n \"def receiveCallback(self, socket, stateMask):\\n # read the PDU header\\n pduHeader = self.recv(EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE)\\n if pduHeader == None:\\n # failure handling was done automatically by derived logic\\n return\\n # consistency check\\n pduHeaderLen = len(pduHeader)\\n if pduHeaderLen != EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid size: \\\" + str(pduHeaderLen), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n return\\n pdu = EGSE.EDENPDU.PDU(pduHeader)\\n # read the data field for the PDU\\n dataFieldLength = pdu.dataFieldLength\\n if dataFieldLength > 0:\\n dataField = self.recv(dataFieldLength)\\n if dataField == None:\\n # failure handling was done automatically by derived logic\\n return\\n # consistency check\\n remainingSizeRead = len(dataField)\\n if remainingSizeRead != dataFieldLength:\\n LOG_ERROR(\\\"Read of remaining PDU failed: invalid remaining size: \\\" + str(remainingSizeRead), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n return\\n pdu.setDataField(dataField)\\n # dispatch depending on pduType and subType\\n try:\\n if pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC_A:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\\n # (TC_A,SPACE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TC_A,SPACE)\\\", \\\"EDEN\\\")\\n self.notifyTc_aSpace(pdu.field2, pdu.field3)\\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\\n # (TC_A,SCOE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TC_A,SCOE)\\\", \\\"EDEN\\\")\\n self.notifyTc_aScoe(pdu.field2, pdu.field3)\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType), \\\"EDEN\\\")\\n LOG(\\\"PDU = \\\" + str(pdu), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC_E:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\\n # (TC_E,SPACE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TC_E,SPACE)\\\", \\\"EDEN\\\")\\n tc_eSpacePDU = EGSE.EDENPDU.TC_Espace(pdu.buffer)\\n self.notifyTc_eSpace(tc_eSpacePDU.getCCSDSpacket())\\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\\n # (TC_E,SCOE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TC_E,SCOE)\\\", \\\"EDEN\\\")\\n tc_eScoePDU = EGSE.EDENPDU.TC_Escoe(pdu.buffer)\\n self.notifyTc_eScoe(tc_eScoePDU.getCCSDSpacket())\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType), \\\"EDEN\\\")\\n LOG(\\\"PDU = \\\" + str(pdu))\\n self.disconnectFromServer()\\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TM:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\\n # (TM,SPACE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TM,SPACE)\\\", \\\"EDEN\\\")\\n tmSpacePDU = EGSE.EDENPDU.TMspace(pdu.buffer)\\n self.notifyTmSpace(tmSpacePDU.getCCSDSpacket())\\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\\n # (TM,SCOE)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(TM,SCOE)\\\", \\\"EDEN\\\")\\n tmScoePDU = EGSE.EDENPDU.TMscoe(pdu.buffer)\\n self.notifyTmScoe(tmScoePDU.getCCSDSpacket())\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType), \\\"EDEN\\\")\\n LOG(\\\"PDU = \\\" + str(pdu), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_CMD:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_ANSW:\\n # (CMD,ANSW)\\n LOG_INFO(\\\"EDEN.Client.receiveCallback(CMD,ANSW)\\\", \\\"EDEN\\\")\\n self.notifyCmdAnsw(pdu.getDataField().tostring())\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType), \\\"EDEN\\\")\\n LOG(\\\"PDU = \\\" + str(pdu), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid pduType: \\\" + str(pdu.pduType), \\\"EDEN\\\")\\n LOG(\\\"PDU = \\\" + str(pdu), \\\"EDEN\\\")\\n self.disconnectFromServer()\\n except Exception as ex:\\n LOG_ERROR(\\\"Processing of received PDU failed: \\\" + str(ex), \\\"EDEN\\\")\\n self.disconnectFromServer()\",\n \"def ncwrt_retrieval_config( retr_setup, outname=None ):\\n\\n #-- set name of file to be generated\\n act_outname = outname if outname!=None else 'retrconfig.nc'\\n msg = \\\"Start writing configuration file ***{}***...\\\".format(act_outname)\\n FileLogger.info(msg)\\n\\n\\n #-- compression settings\\n zlev = retr_setup.zlev\\n use_zlib = retr_setup.use_zlib\\n\\n #--\\n schedule_dct = retr_setup.schedule_dct\\n statevector = retr_setup.prstate\\n #-- turn list into array\\n sim_typ = np.array(schedule_dct['sim_typ'], dtype=np.int32)\\n timepts = schedule_dct['date_utc']\\n nstvar,npts = statevector.shape\\n #-- overpass geometries SZA,SAA,VZA,VAA\\n ivgeom = np.empty((npts,4), dtype=np.float64)\\n ivgeom[:,0] = schedule_dct['sza']\\n ivgeom[:,1] = schedule_dct['saa']\\n ivgeom[:,2] = schedule_dct['vza']\\n ivgeom[:,3] = schedule_dct['vaa']\\n\\n #-- temporal settings, create time-values (time-since)\\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\\n time_values = nc4.date2num(timepts, time_unit)\\n\\n #-- ensure directory exists\\n mkdirp_smart(os.path.dirname(act_outname))\\n\\n #-- open file pointer\\n ncfp = nc4.Dataset(act_outname, 'w')\\n #-- add dimensions\\n d1 = ncfp.createDimension('npoints',npts)\\n d2 = ncfp.createDimension('ngeo',4)\\n\\n #-- time-value\\n ncvar = ncfp.createVariable( 'time', statevector.dtype, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('standard_name','time')\\n ncvar.setncattr('long_name','time')\\n ncvar.setncattr('units', time_unit)\\n ncvar[:] = time_values[:]\\n\\n #-- simulation type\\n ncvar = ncfp.createVariable( 'sim_typ', sim_typ.dtype, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar[:] = sim_typ[:]\\n ncvar.setncattr('long_name','simulation_type')\\n ncvar.setncattr('comment', 'integer value which is to be bit-interpreted')\\n ncvar.setncattr('nobits_set', 'time-point with other state')\\n ncvar.setncattr('bit0_is_set', 'time-point for S1 simulation')\\n ncvar.setncattr('bit1_is_set', 'time-point for S2 simulation')\\n ncvar.setncattr('bit2_is_set', 'time-point for S1A simulation')\\n ncvar.setncattr('bit3_is_set', 'time-point for S1B simulation')\\n ncvar.setncattr('bit4_is_set', 'time-point for S2A simulation')\\n ncvar.setncattr('bit5_is_set', 'time-point for S2B simulation')\\n \\n #-- illumination-view geometry\\n ncvar = ncfp.createVariable( 'ivgeom', ivgeom.dtype, ('npoints','ngeo'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('sza','igeo: 0')\\n ncvar.setncattr('saa','igeo: 1')\\n ncvar.setncattr('vza','igeo: 2')\\n ncvar.setncattr('vaa','igeo: 3')\\n ncvar[:,:] = ivgeom[:,:]\\n \\n #-- global attributes\\n ncfp.setncattr('creator_name',\\\"The Inversion Lab, Hamburg, Germany\\\")\\n ncfp.setncattr('creator_email', \\\"Michael.Vossbeck(at)Inversion-Lab.com\\\")\\n ncfp.setncattr('netcdf_libversion',\\\"{}\\\".format(nc4.__netcdf4libversion__))\\n ncfp.setncattr('date_created',\\\"{}\\\".format(dt.datetime.utcnow().isoformat()))\\n ncfp.setncattr('time_coverage_start',time_coverage_start)\\n ncfp.setncattr('time_coverage_end',time_coverage_end)\\n\\n #-- close file pointer\\n ncfp.close()\\n\\n # logging\\n msg = \\\"...writing ***{}*** DONE\\\".format(act_outname)\\n FileLogger.info(msg)\",\n \"def check_condor(self):\\n\\n self.cluster=self.info['mw_run']['1']\\n self.norm_with_cross=self.info['mw_run']['4']\\n self.condor_req=self.info['mw_run']['11']\\n\\n #type is automaticaly updated now\\n #self.cluster=int(condor)\\n #if norm_with_cross==\\\"F\\\":\\n # self.norm_with_cross=0\\n #else:\\n # self.norm_with_cross=1\",\n \"def receiveCallback(self, socket, stateMask):\\n # read the PDU header\\n pduHeader = self.recv(EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE)\\n if pduHeader == None:\\n # failure handling was done automatically by derived logic\\n return\\n # consistency check\\n pduHeaderLen = len(pduHeader)\\n if pduHeaderLen != EGSE.EDENPDU.PDU_HEADER_BYTE_SIZE:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid size: \\\" + str(pduHeaderLen))\\n self.disconnectClient()\\n return\\n pdu = EGSE.EDENPDU.PDU(pduHeader)\\n # read the data field for the PDU\\n dataFieldLength = pdu.dataFieldLength\\n if dataFieldLength > 0:\\n dataField = self.recv(dataFieldLength)\\n if dataField == None:\\n # failure handling was done automatically by derived logic\\n return\\n # consistency check\\n remainingSizeRead = len(dataField)\\n if remainingSizeRead != dataFieldLength:\\n LOG_ERROR(\\\"Read of remaining PDU failed: invalid remaining size: \\\" + str(remainingSizeRead))\\n self.disconnectClient()\\n return\\n pdu.setDataField(dataField)\\n # dispatch depending on pduType and subType\\n try:\\n if pdu.pduType == EGSE.EDENPDU.PDU_TYPE_TC:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_SPACE:\\n # (TC,SPACE)\\n LOG_INFO(\\\"EDEN.Server.receiveCallback(TC,SPACE)\\\")\\n tcSpacePDU = EGSE.EDENPDU.TCspace(pdu.buffer)\\n if self.notifyTcSpace(tcSpacePDU.getCCSDSpacket()):\\n # forwarding OK\\n self.sendTc_eSpace(tcSpacePDU, 0)\\n self.sendTc_aSpace(0, tcSpacePDU.tcIdentificationWord)\\n else:\\n # forwarding failed\\n self.sendTc_eSpace(tcSpacePDU, 1)\\n self.sendTc_aSpace(1, tcSpacePDU.tcIdentificationWord)\\n elif pdu.subType == EGSE.EDENPDU.SUB_TYPE_SCOE:\\n # (TC,SCOE)\\n LOG_INFO(\\\"EDEN.Server.receiveCallback(TC,SCOE)\\\")\\n tcScoePDU = EGSE.EDENPDU.TCscoe(pdu.buffer)\\n if self.notifyTcScoe(tcScoePDU.getCCSDSpacket()):\\n # forwarding OK\\n self.sendTc_eScoe(tcScoePDU, 0)\\n self.sendTc_aScoe(0, tcScoePDU.tcIdentificationWord)\\n else:\\n # forwarding failed\\n self.sendTc_eScoe(tcScoePDU, 1)\\n self.sendTc_aScoe(1, tcScoePDU.tcIdentificationWord)\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType))\\n LOG(\\\"PDU = \\\" + str(pdu))\\n self.disconnectClient()\\n elif pdu.pduType == EGSE.EDENPDU.PDU_TYPE_CMD:\\n if pdu.subType == EGSE.EDENPDU.SUB_TYPE_EXEC:\\n # (CMD,EXEC)\\n LOG_INFO(\\\"EDEN.Server.receiveCallback(CMD,EXEC)\\\")\\n self.notifyCmdExec(pdu.getDataField().tostring())\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid subType: \\\" + str(pdu.subType))\\n LOG(\\\"PDU = \\\" + str(pdu))\\n self.disconnectClient()\\n else:\\n LOG_ERROR(\\\"Read of PDU header failed: invalid pduType: \\\" + str(pdu.pduType))\\n LOG(\\\"PDU = \\\" + str(pdu))\\n self.disconnectClient()\\n except Exception as ex:\\n LOG_ERROR(\\\"Processing of received PDU failed: \\\" + str(ex))\\n self.disconnectClient()\",\n \"def on_ctcp(self, raw_msg, source, msg, **kwargs):\",\n \"def test_scp_callback_return_dataset_no_status(self):\\n self.scp = DummyVerificationSCP()\\n self.scp.status = Dataset()\\n self.scp.start()\\n\\n ae = AE()\\n ae.add_requested_context(VerificationSOPClass)\\n assoc = ae.associate('localhost', 11112)\\n assert assoc.is_established\\n rsp = assoc.send_c_echo()\\n assert rsp.Status == 0x0000\\n assoc.release()\\n self.scp.stop()\",\n \"def check_config(self):\\n assert 'AUTO' in self.config\\n assert 'LAT' in self.config\\n assert 'LON' in self.config\\n assert 'ALL_CHANNELS' in self.config\\n for key in self.extract_servo_channels():\\n assert 'STATUS' in self.config[key]\\n self.config[key]['STATUS'] = float(self.config[key]['STATUS'])\\n assert 0.0 <= self.config[key]['STATUS'] <= 1.0\\n\\n if not 'SUNRISE_BUFFER' in self.config[key]:\\n self.config[key]['SUNRISE_BUFFER'] = 0\\n if not 'SUNSET_BUFFER' in self.config[key]:\\n self.config[key]['SUNSET_BUFFER'] = 0\",\n \"def check_cdfIntegrity(self, step):\\n # Selecting bins automatically:\\n x_max = self.onpower_train.max().values[0]\\n x_min = 0\\n step = 1\\n x_onpower = np.arange(x_min, x_max, step).reshape(-1, 1)\\n\\n x_max = 0\\n x_min = self.offpower_train.min().values[0]\\n step = 1\\n x_offpower = np.arange(x_min, x_max, step).reshape(-1, 1)\\n\\n x_max = self.duration_train.max().values[0]\\n x_min = 0\\n step = 1\\n x_duration = np.arange(x_min, x_max, step).reshape(-1, 1)\\n\\n # Evaluating score for:\\n # Onpower\\n y_onpower = self.__pdf2(self.onpower, x_onpower)\\n print(\\\"Onpower cdf: \\\" + str(y_onpower.sum()))\\n\\n # Offpower\\n y_offpower = self.__pdf2(self.offpower, x_offpower)\\n print(\\\"Offpower cdf: \\\" + str(y_offpower.sum()))\\n\\n # duration\\n y_duration = self.__pdf2(self.duration, x_duration)\\n print(\\\"Duration cdf: \\\" + str(y_duration.sum()))\\n\\n # Plots:\\n # fig1 = plt.figure()\\n # ax1 = fig1.add_subplot(311)\\n # ax2 = fig1.add_subplot(312)\\n # ax3 = fig1.add_subplot(313)\\n\\n # ax1.plot(x_onpower, y_onpower)\\n # ax1.set_title(\\\"PDF CDF: Onpower\\\")\\n # ax1.set_ylabel(\\\"density\\\")\\n # ax1.set_xlabel(\\\"Watts\\\")\\n\\n # ax2.plot(x_offpower, y_offpower)\\n # ax2.set_title(\\\" PDF CDF: Offpower\\\")\\n # ax2.set_ylabel(\\\"denisty\\\")\\n # ax2.set_xlabel(\\\"Watts\\\")\\n\\n # ax3.plot(x_duration, y_duration)\\n # ax3.set_title(\\\"PDF CDF: Duration\\\")\\n # ax3.set_ylabel(\\\"density\\\")\\n # ax3.set_xlabel(\\\"Seconds\\\")\",\n \"def testCC(self):\\n self.assertEqual(\\n self.cc,\\n self.cd.cc\\n )\",\n \"def validateChanBin(self):\\n\\n casalog.origin(\\\"ParallelDataHelper\\\")\\n \\n retval = True\\n \\n # Get the parameter name, which depends on the task calling this class\\n parname = self.getChanAvgParamName()\\n casalog.post('Channel average parameter is called %s'%parname,'DEBUG1')\\n if parname == None:\\n retval = False\\n \\n elif self.__args.has_key(parname):\\n fblist = self.__args[parname]\\n if isinstance(fblist,list): \\n \\n if fblist.__len__() > 1:\\n if self.__spwList == None: \\n msTool = mstool()\\n msTool.open(self.__args['vis'])\\n spwsel = self.__args['spw'] \\n msTool.msselect({'spw':spwsel})\\n ddInfo = msTool.getspectralwindowinfo()\\n self.__spwList = [info['SpectralWindowId'] for info in ddInfo.values()]\\n msTool.close()\\n \\n if self.__spwList.__len__() != fblist.__len__():\\n retval = False\\n raise ValueError, 'Number of %s is different from the number of spw' %parname \\n \\n\\n return retval\",\n \"def test_check_cds_12(self):\\n self.cds1.stop = -1\\n import_genome.check_cds(self.cds1, self.eval_flags)\\n count = count_status(self.cds1, \\\"error\\\")\\n self.assertEqual(count, 1)\",\n \"def test_check_cds_16(self):\\n self.cds1.locus_tag = \\\"ABCXYZ\\\"\\n import_genome.check_cds(self.cds1, self.eval_flags)\\n count = count_status(self.cds1, \\\"error\\\", \\\"warning\\\")\\n self.assertEqual(count, 1)\",\n \"def data_received(self, data):\\n pass\",\n \"def dataValidation(self, in_nc):\\r\\n vars_oi_index = None\\r\\n data_nc = NET.Dataset(in_nc)\\r\\n dims = list(data_nc.dimensions)\\r\\n if dims not in self.dims_oi:\\r\\n raise Exception(self.errorMessages[1])\\r\\n\\r\\n vars = list(data_nc.variables)\\r\\n\\r\\n if vars == self.vars_oi[0]:\\r\\n vars_oi_index = 0\\r\\n elif vars == self.vars_oi[1]:\\r\\n vars_oi_index = 1\\r\\n elif vars == self.vars_oi[2]: # Line Added/Modified CJB 20190108\\r\\n vars_oi_index = 2 # Line Added/Modified CJB 20190108\\r\\n else: \\r\\n raise Exception(self.errorMessages[2])\\r\\n\\r\\n return vars_oi_index\",\n \"def read_mmclx_save_nc(mmclx_filename, nc_filename):\\n\\n # Open .mmclx file\\n mmclx = xr.open_dataset(mmclx_filename)\\n\\n # Create .nc file with necessary variables\\n ncfile = mmclx[\\n [\\n \\\"Ze\\\",\\n \\\"VEL\\\",\\n \\\"LDR\\\",\\n \\\"RHO\\\",\\n \\\"DPS\\\",\\n \\\"NyquistVelocity\\\",\\n \\\"nave\\\",\\n \\\"nfft\\\",\\n \\\"prf\\\",\\n \\\"zrg\\\",\\n \\\"drg\\\",\\n ]\\n ]\\n # Invert order of dimensions\\n ncfile = ncfile.transpose()\\n\\n # Convert + change attributes of time dimension\\n ncfile[\\\"time\\\"] = (\\n \\\"time\\\",\\n pd.to_datetime(ncfile.time.values, unit=\\\"s\\\"),\\n {\\\"long_name\\\": \\\"Time in epoch reference\\\", \\\"standard_name\\\": \\\"time\\\"},\\n )\\n # Change attributes of range dimension\\n ncfile[\\\"range\\\"] = ncfile.range.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Range from antenna to the centre of each range gate\\\",\\n \\\"standard_name\\\": \\\"range\\\",\\n }\\n )\\n\\n # Create additional instrument parameters\\n ncfile[\\\"pulse_width\\\"] = float(\\n ncfile.hrd[\\n (ncfile.hrd.find(\\\"\\\\nPULSE_WIDTH:\\\") + 15) : ncfile.hrd.find(\\n \\\"\\\\nRX_PULSEWIDTH:\\\"\\n )\\n ]\\n )\\n ncfile[\\\"pulse_width\\\"] = ncfile.pulse_width.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Pulse Width\\\",\\n \\\"units\\\": \\\"s\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"hrd['PULSE_WIDTH']\\\",\\n }\\n )\\n ncfile[\\\"prt\\\"] = 2e-4\\n ncfile[\\\"prt\\\"] = ncfile.prt.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Pulse repetition time\\\",\\n \\\"units\\\": \\\"s\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"\\\",\\n }\\n )\\n ncfile[\\\"frequency\\\"] = 35e9\\n ncfile[\\\"frequency\\\"] = ncfile.frequency.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Radiation Frequency\\\",\\n \\\"units\\\": \\\"s^-1\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"\\\",\\n }\\n )\\n ncfile[\\\"latitude\\\"] = float(ncfile.Latitude[:-1])\\n ncfile[\\\"latitude\\\"] = ncfile.latitude.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Latitude\\\",\\n \\\"units\\\": \\\"degrees_north\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"Latitude\\\",\\n }\\n )\\n ncfile[\\\"longitude\\\"] = float(ncfile.Longitude[:-1])\\n ncfile[\\\"longitude\\\"] = ncfile.longitude.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Longitude\\\",\\n \\\"units\\\": \\\"degrees_east\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"Longitude\\\",\\n }\\n )\\n ncfile[\\\"altitude\\\"] = float(ncfile.Altitude[:-1])\\n ncfile[\\\"altitude\\\"] = ncfile.altitude.assign_attrs(\\n {\\n \\\"long_name\\\": \\\"Altitude\\\",\\n \\\"units\\\": \\\"m\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"Altitude\\\",\\n }\\n )\\n\\n # Change names of variables\\n ncfile = ncfile.rename_vars(\\n {\\n \\\"Ze\\\": \\\"filtered_reflectivity\\\",\\n \\\"VEL\\\": \\\"filtered_velocity\\\",\\n \\\"LDR\\\": \\\"filtered_linear_depolarization_ratio\\\",\\n \\\"RHO\\\": \\\"cross_correlation_ratio\\\",\\n \\\"DPS\\\": \\\"differential_phase\\\",\\n \\\"NyquistVelocity\\\": \\\"nyquist_velocity\\\",\\n \\\"nave\\\": \\\"n_samples\\\",\\n \\\"nfft\\\": \\\"n_fft\\\",\\n \\\"zrg\\\": \\\"n_range_gates\\\",\\n \\\"drg\\\": \\\"range_resolution\\\",\\n }\\n )\\n\\n # Convert dBZ variables to dBZ\\n ncfile.filtered_reflectivity.values = 10 * np.log10(\\n ncfile.filtered_reflectivity.values\\n )\\n ncfile.filtered_linear_depolarization_ratio.values = 10 * np.log10(\\n ncfile.filtered_linear_depolarization_ratio.values\\n )\\n\\n # Change attributes of variables\\n ncfile[\\\"filtered_reflectivity\\\"] = ncfile.filtered_reflectivity.assign_attrs(\\n {\\n \\\"units\\\": \\\"dBZ\\\",\\n \\\"valid_range\\\": ncfile.filtered_reflectivity.attrs.pop(\\\"yrange\\\"),\\n \\\"standard_name\\\": \\\"Ze\\\",\\n \\\"long_name\\\": \\\"Filtered Equivalent Reflectivity Factor\\\",\\n }\\n )\\n ncfile[\\\"filtered_velocity\\\"] = ncfile.filtered_velocity.assign_attrs(\\n {\\n \\\"units\\\": \\\"m * s^-1\\\",\\n \\\"valid_range\\\": ncfile.filtered_velocity.attrs.pop(\\\"yrange\\\"),\\n \\\"standard_name\\\": \\\"VEL\\\",\\n \\\"long_name\\\": \\\"Filtered Mean Doppler Velocity\\\",\\n }\\n )\\n ncfile[\\n \\\"filtered_linear_depolarization_ratio\\\"\\n ] = ncfile.filtered_linear_depolarization_ratio.assign_attrs(\\n {\\n \\\"units\\\": \\\"dB\\\",\\n \\\"valid_range\\\": ncfile.filtered_linear_depolarization_ratio.attrs.pop(\\n \\\"yrange\\\"\\n ),\\n \\\"standard_name\\\": \\\"LDR\\\",\\n \\\"long_name\\\": \\\"Filtered Linear De-Polarization Ratio\\\",\\n }\\n )\\n ncfile[\\n \\\"cross_correlation_ratio\\\"\\n ] = ncfile.cross_correlation_ratio.assign_attrs(\\n {\\n \\\"units\\\": \\\"unitless\\\",\\n \\\"valid_range\\\": ncfile.cross_correlation_ratio.attrs.pop(\\\"yrange\\\"),\\n \\\"standard_name\\\": \\\"RHO\\\",\\n \\\"long_name\\\": \\\"Co-Cross Correlation Ratio\\\",\\n }\\n )\\n ncfile[\\\"differential_phase\\\"] = ncfile.differential_phase.assign_attrs(\\n {\\n \\\"units\\\": \\\"degrees\\\",\\n \\\"valid_range\\\": ncfile.differential_phase.attrs.pop(\\\"yrange\\\"),\\n \\\"standard_name\\\": \\\"DPS\\\",\\n \\\"long_name\\\": \\\"Differential Phase\\\",\\n }\\n )\\n ncfile[\\\"nyquist_velocity\\\"] = ncfile.nyquist_velocity.assign_attrs(\\n {\\n \\\"units\\\": \\\"m * s^-1\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"NyquistVelocity\\\",\\n \\\"long_name\\\": \\\"Nyquist Velocity\\\",\\n }\\n )\\n ncfile[\\\"n_samples\\\"] = ncfile.n_samples.assign_attrs(\\n {\\n \\\"units\\\": \\\"unitless\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"nave\\\",\\n \\\"long_name\\\": \\\"Number of spectral averages used to compute moments\\\",\\n }\\n )\\n ncfile[\\\"n_fft\\\"] = ncfile.n_fft.assign_attrs(\\n {\\n \\\"units\\\": \\\"unitless\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"nfft\\\",\\n \\\"long_name\\\": \\\"Number of FFT points\\\",\\n }\\n )\\n ncfile[\\\"prf\\\"] = ncfile.prf.assign_attrs(\\n {\\n \\\"units\\\": \\\"Hz\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"prf\\\",\\n \\\"long_name\\\": \\\"Pulse Repetition Frequency\\\",\\n }\\n )\\n ncfile[\\\"n_range_gates\\\"] = ncfile.n_range_gates.assign_attrs(\\n {\\n \\\"units\\\": \\\"unitless\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"zrg\\\",\\n \\\"long_name\\\": \\\"Number of range gates\\\",\\n }\\n )\\n ncfile[\\\"range_resolution\\\"] = ncfile.range_resolution.assign_attrs(\\n {\\n \\\"units\\\": \\\"m\\\",\\n \\\"meta_group\\\": \\\"instrument_parameters\\\",\\n \\\"standard_name\\\": \\\"drg\\\",\\n \\\"long_name\\\": \\\"Range resolution\\\",\\n }\\n )\\n\\n # Remove unnecessary attributes of variables\\n for var in ncfile.variables:\\n for attr in [\\\"axis\\\", \\\"db\\\", \\\"unit\\\"]:\\n if attr in ncfile[var].attrs.keys():\\n del ncfile[var].attrs[attr]\\n\\n # Remove unnecessary global attributes\\n for attr in [\\\"Altitude\\\", \\\"Latitude\\\", \\\"Longitude\\\", \\\"ppar\\\", \\\"hrd\\\"]:\\n del ncfile.attrs[attr]\\n\\n # Reorder variables\\n ncfile = ncfile[\\n [\\n \\\"filtered_reflectivity\\\",\\n \\\"filtered_velocity\\\",\\n \\\"filtered_linear_depolarization_ratio\\\",\\n \\\"cross_correlation_ratio\\\",\\n \\\"differential_phase\\\",\\n \\\"nyquist_velocity\\\",\\n \\\"n_fft\\\",\\n \\\"prf\\\",\\n \\\"prt\\\",\\n \\\"n_range_gates\\\",\\n \\\"range_resolution\\\",\\n \\\"n_samples\\\",\\n \\\"pulse_width\\\",\\n \\\"frequency\\\",\\n \\\"latitude\\\",\\n \\\"longitude\\\",\\n \\\"altitude\\\",\\n ]\\n ]\\n\\n # Save .nc file\\n ncfile.to_netcdf(\\n nc_filename,\\n unlimited_dims=\\\"time\\\",\\n encoding={\\\"time\\\": {\\\"units\\\": \\\"seconds since 1970-01-01 00:00:00\\\"}},\\n )\",\n \"def test_netCDF_sample_dimension_groups(self):\\n c = cfdm.Count()\\n\\n c.nc_set_sample_dimension(\\\"ncvar\\\")\\n\\n with self.assertRaises(ValueError):\\n c.nc_set_sample_dimension_groups([\\\"/forecast\\\"])\\n\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n\\n attrs = c.nc_clear_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n\\n c.nc_set_sample_dimension_groups([\\\"forecast\\\", \\\"model\\\"])\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertEqual(attrs, (\\\"forecast\\\", \\\"model\\\"))\\n self.assertEqual(c.nc_get_sample_dimension(), \\\"/forecast/model/ncvar\\\")\\n\\n attrs = c.nc_clear_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertEqual(attrs, (\\\"forecast\\\", \\\"model\\\"))\\n\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n self.assertEqual(c.nc_get_sample_dimension(), \\\"ncvar\\\")\\n\\n c.nc_set_sample_dimension(\\\"ncvar\\\")\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertEqual(attrs, ())\\n\\n c.nc_set_sample_dimension(\\\"/ncvar\\\")\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n\\n c.nc_set_sample_dimension(\\\"/forecast/model/ncvar\\\")\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertEqual(attrs, (\\\"forecast\\\", \\\"model\\\"))\\n\\n c.nc_del_sample_dimension()\\n attrs = c.nc_sample_dimension_groups()\\n self.assertIsInstance(attrs, tuple)\\n self.assertFalse(attrs)\\n\\n with self.assertRaises(ValueError):\\n c.nc_set_sample_dimension_groups([\\\"forecast\\\", \\\"model\\\"])\",\n \"def has_fcc(self):\\n raise NotImplementedError\",\n \"def check_data(self):\\n super().check_data()\\n\\n for session_index, session_data in enumerate(self._data_to_analyse):\\n if session_data.DATA_FORMAT != \\\"PyMEICA\\\":\\n self.invalid_data_help = f\\\"Non PyMEICA format compatibility not yet implemented: \\\" \\\\\\n f\\\"{session_data.DATA_FORMAT}\\\"\\n return False\\n\\n return True\",\n \"def _handleRequestCableCheckStatus(self, data):\\r\\n print(\\\"\\\\\\\"Request Cable Check Status\\\\\\\" received\\\")\\r\\n self.whitebeet.v2gParseRequestCableCheckStatus(data)\\r\\n try:\\r\\n self.whitebeet.v2gSetDcCableCheckStatus(True)\\r\\n except Warning as e:\\r\\n print(\\\"Warning: {}\\\".format(e))\\r\\n except ConnectionError as e:\\r\\n print(\\\"ConnectionError: {}\\\".format(e))\",\n \"def write_to_netCDF(nc_filename, data,\\n ncformat='NETCDF4_CLASSIC',\\n all_variables=False,\\n verbose=True):\\n ncfile = Dataset(nc_filename,'w', format=ncformat, clobber=True)\\n for dd,dim in enumerate(data['dims']):\\n ncfile.createDimension(data['dimname'][dd],dim)\\n for vv,varname in enumerate(data['varn']):\\n if all_variables:\\n newvar = ncfile.createVariable(varname,\\n data['vardtype'][vv],\\n data['vardims'][vv])\\n newvar[:] = data['data'][vv]\\n newvar.units = data['units'][vv]\\n else:\\n if varname in core_variables:\\n newvar = ncfile.createVariable(varname,\\n data['vardtype'][vv],\\n data['vardims'][vv],\\n fill_value=data['fillValue'])\\n newvar[:] = data['data'][vv]\\n if verbose:\\n print(varname)\\n print(newvar[newvar == np.nan])\\n newvar[newvar == np.nan] = data['fillValue']\\n newvar.units = data['units'][vv]\\n ncfile.createDimension('nchars',19)\\n newvar[:] = data['time']\\n ncfile.description = data['description']\\n ncfile.station = data['station']\\n ncfile.sensor = data['sensor']\\n ncfile.latitude = data['latitude']\\n ncfile.longitude = data['longitude']\\n ncfile.altitude = data['altitude']\\n ncfile.createdon = datetime.now().strftime(standard_datetime_fmt)\\n ncfile.createdby = data['author']\\n ncfile.close()\",\n \"def test_cds_invalid_coordinates(self):\\n for i in (-10, -1, 6, 100):\\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))\",\n \"def test_cds_invalid_coordinates(self):\\n for i in (-10, -1, 6, 100):\\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))\",\n \"def test_cds_invalid_coordinates(self):\\n for i in (-10, -1, 4, 100):\\n self.assertIsNone(self.t.cds_coordinate_to_chromosome(i))\\n self.assertIsNone(self.t.cds_coordinate_to_transcript(i))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60441834","0.5924442","0.5870361","0.56942517","0.5658238","0.56382203","0.5624735","0.5600587","0.5563595","0.55417067","0.54565823","0.5366081","0.5311197","0.53014123","0.5301123","0.52937174","0.5290408","0.5289225","0.52625626","0.52489024","0.5247772","0.5214412","0.52054906","0.518749","0.51700234","0.5149499","0.5134563","0.5132516","0.5125593","0.51050097","0.51018405","0.50990194","0.50936776","0.50895715","0.5049416","0.5046888","0.49993777","0.49949896","0.49900338","0.4978755","0.49786028","0.49715045","0.49519196","0.4944707","0.49330285","0.49240318","0.49134305","0.49129245","0.49103725","0.4908793","0.4900931","0.48922437","0.48884425","0.48783892","0.48675838","0.48479193","0.48439354","0.48334563","0.48333347","0.48311105","0.48261854","0.47944984","0.47905108","0.4789384","0.4787438","0.47730207","0.47663775","0.4765562","0.47643885","0.47638428","0.4762133","0.4758218","0.4745037","0.47180137","0.47176406","0.47173542","0.47163585","0.47104806","0.4694007","0.46923023","0.46894476","0.46883446","0.4680177","0.4679541","0.46788797","0.46760118","0.46724916","0.4670996","0.46707004","0.46670395","0.4664908","0.46644863","0.46635747","0.46634686","0.4659963","0.465784","0.46468505","0.46445024","0.46445024","0.46430936"],"string":"[\n \"0.60441834\",\n \"0.5924442\",\n \"0.5870361\",\n \"0.56942517\",\n \"0.5658238\",\n \"0.56382203\",\n \"0.5624735\",\n \"0.5600587\",\n \"0.5563595\",\n \"0.55417067\",\n \"0.54565823\",\n \"0.5366081\",\n \"0.5311197\",\n \"0.53014123\",\n \"0.5301123\",\n \"0.52937174\",\n \"0.5290408\",\n \"0.5289225\",\n \"0.52625626\",\n \"0.52489024\",\n \"0.5247772\",\n \"0.5214412\",\n \"0.52054906\",\n \"0.518749\",\n \"0.51700234\",\n \"0.5149499\",\n \"0.5134563\",\n \"0.5132516\",\n \"0.5125593\",\n \"0.51050097\",\n \"0.51018405\",\n \"0.50990194\",\n \"0.50936776\",\n \"0.50895715\",\n \"0.5049416\",\n \"0.5046888\",\n \"0.49993777\",\n \"0.49949896\",\n \"0.49900338\",\n \"0.4978755\",\n \"0.49786028\",\n \"0.49715045\",\n \"0.49519196\",\n \"0.4944707\",\n \"0.49330285\",\n \"0.49240318\",\n \"0.49134305\",\n \"0.49129245\",\n \"0.49103725\",\n \"0.4908793\",\n \"0.4900931\",\n \"0.48922437\",\n \"0.48884425\",\n \"0.48783892\",\n \"0.48675838\",\n \"0.48479193\",\n \"0.48439354\",\n \"0.48334563\",\n \"0.48333347\",\n \"0.48311105\",\n \"0.48261854\",\n \"0.47944984\",\n \"0.47905108\",\n \"0.4789384\",\n \"0.4787438\",\n \"0.47730207\",\n \"0.47663775\",\n \"0.4765562\",\n \"0.47643885\",\n \"0.47638428\",\n \"0.4762133\",\n \"0.4758218\",\n \"0.4745037\",\n \"0.47180137\",\n \"0.47176406\",\n \"0.47173542\",\n \"0.47163585\",\n \"0.47104806\",\n \"0.4694007\",\n \"0.46923023\",\n \"0.46894476\",\n \"0.46883446\",\n \"0.4680177\",\n \"0.4679541\",\n \"0.46788797\",\n \"0.46760118\",\n \"0.46724916\",\n \"0.4670996\",\n \"0.46707004\",\n \"0.46670395\",\n \"0.4664908\",\n \"0.46644863\",\n \"0.46635747\",\n \"0.46634686\",\n \"0.4659963\",\n \"0.465784\",\n \"0.46468505\",\n \"0.46445024\",\n \"0.46445024\",\n \"0.46430936\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74189216"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":586,"cells":{"query":{"kind":"string","value":"Test solar data handling from CC data file with clearsky ratio calculated using clearsky ratio from NSRDB h5 file."},"document":{"kind":"string","value":"def test_solar_cc():\n\n features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']\n input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]\n nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')\n\n with xr.open_mfdataset(input_files) as fh:\n min_lat = np.min(fh.lat.values)\n min_lon = np.min(fh.lon.values) - 360\n target = (min_lat, min_lon)\n shape = (len(fh.lat.values), len(fh.lon.values))\n\n with pytest.raises(AssertionError):\n handler = DataHandlerNCforCC(input_files, features=features,\n target=target, shape=shape,\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n handler = DataHandlerNCforCC(input_files, features=features,\n nsrdb_source_fp=nsrdb_source_fp,\n target=target, shape=shape,\n temporal_slice=slice(0, 1),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n cs_ratio = handler.data[..., 0]\n ghi = handler.data[..., 1]\n cs_ghi = handler.data[..., 2]\n cs_ratio_truth = ghi / cs_ghi\n\n assert cs_ratio.max() < 1\n assert cs_ratio.min() > 0\n assert (ghi < cs_ghi).all()\n assert np.allclose(cs_ratio, cs_ratio_truth)\n\n with Resource(nsrdb_source_fp) as res:\n meta = res.meta\n tree = KDTree(meta[['latitude', 'longitude']])\n cs_ghi_true = res['clearsky_ghi']\n\n # check a few sites against NSRDB source file\n for i in range(4):\n for j in range(4):\n test_coord = handler.lat_lon[i, j]\n _, inn = tree.query(test_coord)\n\n assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j])"},"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 regexham = r'\\s+\\((\\d+,\\s*\\d+)\\)\\s+([\\-+]?\\d+\\.\\d+[eEdD]?[\\-+]?\\d+)' #to extract the Hamiltonian.\n root = '.'\n #fname = 'output_files/'\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\n #print ciffci.calc_overlap(cifdoci)\n #print e.get_groundstate('00000000000011|00000000000011') \n\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\n\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\n count = 0\n for det in detlist:\n for det2 in detlist:\n #+ because the eigenvectors have already a different phasefactor of 1.\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \" col: \" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \n count += 1\n print 'There were ' , count , ' different elements'","def load_data():\n\t\t# load the data\n\t\tDATPATH = \"../data/\"\n\t\t#fnino = DATPATH + \"nino3.csv\" # 1871-2000\n\t\tfnino = DATPATH + \"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\" # 1871-2016\n\t\t#fnino = DATPATH + \"nino34.long.data\"\n\t\t#nc_data_nino3 = netCDF4.Dataset(fnino)\n\t\t#nino3_load = nc_data_nino3.variables['tas'][:]\n\t\t#dnino = nino3_load.flatten()\n\n\t\tdnino = np.genfromtxt(fnino, delimiter=\",\", dtype=float).flatten()\n\t\t#fismr = DATPATH + \"ismr.csv\" # 1871-2000\n\t\t#fismr = DATPATH + \"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\" # 1871-2016\n\t\tfismr = DATPATH + \"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\" # 1871-2016\n\t\tdismr = np.genfromtxt(fismr, delimiter=\",\", dtype=float).flatten()\n\t\t#fvolc = DATPATH + \"robock.txt\" # 1871-2000\n\t\tfvolc = DATPATH + \"sigl.txt\" # 1871-2016\n\t\tdvolc = np.genfromtxt(fvolc, delimiter=\",\", dtype=float).flatten()\n\n\t\tfvolc_source = DATPATH + \"volc_source_850_1850.csv\" # 1871-2016\n\t\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\",\", dtype=float).flatten()\n\t\t# simple check for data consistency\n\t\tassert dnino.shape == dismr.shape, \"Data sets are unequal!\"\n\t\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \"Data sets are unequal\"\n\t\treturn dnino, dismr, dvolc, dvolc_source","def runTest(self):\n ncfile = netCDF4.Dataset(URL)\n assert varname in ncfile.variables.keys()\n var = ncfile.variables[varname]\n assert var.shape == varshape\n data = var[:]\n assert_array_almost_equal(data.min(),varmin)\n assert_array_almost_equal(data.max(),varmax)\n ncfile.close()\n # test https support (linked curl lib must built with openssl support)\n ncfile = netCDF4.Dataset(URL_https)\n assert(ncfile['sst'].long_name=='Sea Surface Temperature') \n ncfile.close()","def runTest(self):\n nc = Dataset(self.file)\n data = nc['vl'][-1]\n # check max error of compression\n err = np.abs(data - self.data)\n assert(err.max() < nc['vl'].scale_factor)\n # turn off auto-scaling\n nc.set_auto_maskandscale(False)\n data = nc['vl'][-1]\n assert(data[-1] == np.around(self.data[-1]/nc['vl'].scale_factor))\n nc.close()","def nc_to_hdf5_mudis(dataset, config):\n np.warnings.filterwarnings('ignore')\n\n date = datetime.datetime.strptime(dataset.recorddate,\n '%d.%m.%Y') # read date from dateset\n date_name = datetime.datetime.strftime(date,\n '%Y%m%d') # convert date to YYYYMMDD format\n config['date'] = date_name\n\n # Create the directory to save the results\n path = config['str_dir'] + '/radiance/{}/data/'.format(config['date'])\n os.makedirs(os.path.dirname(path), exist_ok=True)\n\n # Read time of the file (correct time)\n time = datetime.datetime.strptime(dataset.recordtime, '%H:%M:%S.')\n time = datetime.datetime.time(time)\n\n # convert time to datetime format\n datetime_name = datetime.datetime.combine(date, time)\n new_name = datetime.datetime.strftime(datetime_name, '%Y%m%d_%H%M%S')\n\n # radiance = dataset.variables['data'][:].reshape(113, 1281)\n # wavelength_axis = dataset.variables['xAxis'][:]\n\n # Create a file in the disk\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(\n config['date'], new_name), 'w') as datos:\n\n if not list(datos.items()):\n # Create two datasets(use only one time)\n datos.create_dataset('/data',\n data=dataset['data'][:].reshape(113, 1281),\n dtype='f4')\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\n else:\n del datos['data']\n # del datos['skymap']\n print('data deleted and corrected')\n datos.create_dataset('/data', data=data, dtype='f4')\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\n\n # Add attributes to datasets\n datos['data'].attrs['time'] = str(time)\n datos['data'].attrs['Exposure'] = dataset.exposuretime\n datos['data'].attrs['NumAver'] = dataset.AVERAGED\n datos['data'].attrs['CCDTemp'] = dataset.detectortemperature\n datos['data'].attrs['NumSingMes'] = dataset.noofaccumulations\n # datos['data'].attrs['ElectrTemp'] = dataset.\n datos['data'].attrs['Latitude'] = '52.39N'\n datos['data'].attrs['Longitude'] = '9.7E'\n datos['data'].attrs['Altitude'] = '65 AMSL'\n\n chn = np.arange(1, 114)\n datos.create_dataset('/channel', data=chn, dtype=np.float32)\n datos.create_dataset('/wavelength', data=dataset['xAxis'][:])\n\n datos['data'].dims.create_scale(datos['channel'], 'channel')\n datos['data'].dims[0].attach_scale(datos['channel'])\n datos['data'].dims[0].label = 'channel'\n datos['data'].dims[1].label = 'wavelength'\n\n # datos['skymap'].dims[0].label = 'channel'\n # datos['skymap'].dims[1].label = 'Azimuth, Zenith'\n\n datos.close()","def extract_hrc_data(obsid, data_dir):\n#\n#--- extract fits data\n#\n line = 'operation=retrieve\\n'\n line = line + 'dataset=flight\\n'\n line = line + 'level=1\\n'\n line = line + 'detector=hrc\\n'\n line = line + 'obsid=' + str(obsid) + '\\n'\n line = line + 'go\\n'\n\n with open('zline', 'w') as fo:\n fo.write(line)\n\n cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > zout'\n os.system(cmd)\n#\n#--- create directories and move the data into them\n#\n cmd = 'mkdir primary secondary'\n os.system(cmd)\n \n cmd = 'mv *dtf1*fits* *fov*fits* ./primary/.'\n os.system(cmd)\n\n cmd = 'mv *bpix1*fits* *evt1*fits* *msk1*fits* *mtl1*fits* \\\n *std_dtfstat1.fits* *std_flt1.fits* ./secondary/.'\n os.system(cmd)\n\n line = 'operation=retrieve\\n'\n line = line + 'dataset=flight\\n'\n line = line + 'level=1\\n'\n line = line + 'detector=pcad\\n'\n line = line + 'subdetector=aca\\n'\n line = line + 'obsid=' + str(obsid) + '\\n'\n line = line + 'go\\n'\n\n with open('zline', 'w') as fo:\n fo.write(line)\n\n cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > zout'\n os.system(cmd)\n cmd = 'mv *asol*fits* ./primary/.'\n os.system(cmd)\n\n cmd = 'rm -rf *fits* zline zout'\n os.system(cmd)\n\n hdir = data_dir + '/' + str(obsid)\n if os.path.isdir(hdir):\n cmd = 'rm -rf ' + hdir + '/*'\n os.system(cmd)\n else:\n cmd = 'mkdir ' + hdir \n os.system(cmd)\n\n cmd = 'chmod 774 primary/* secondary/*'\n os.system(cmd)\n\n#\n#--- check whether there are duplicated fits files extracted; if so, remove older ones\n#\n h_list = ['dtf1', 'fov1', 'asol1']\n sdir = 'primary'\n remove_duplicate(h_list, sdir)\n\n h_list = ['bpix1', 'evt1', 'msk1', 'mtl1', 'std_dtfstat1', 'std_flt1']\n sdir = 'secondary'\n remove_duplicate(h_list, sdir)\n\n cmd = 'mv primary secondary ' + hdir + '/.'\n os.system(cmd)\n\n cmd = 'rm -rf ' + hdir + '/analysis/* ' \n os.system(cmd)\n\n return check_data_exist(hdir)","def main_bf_MISR(h5f, output_folder, SPATIAL_RESOLUTION=0.5, VZA_MAX=18, CAMERA='AN'):\n\n # =============================================================================\n # 1. Initialization\n # calculate constant parameters\n # initialize output arrays and output hdf5 file\n # check the number of CERES granules \n # =============================================================================\n\n print(\"-------MISR----->\", h5f)\n print(\"-------FID------<>\", h5f.fid)\n print(\"---->\", type(h5f))\n if type(h5f.fid) is str:\n output_nc_name = h5f.fid.split('/')[-1].replace('TERRA_BF_L1B', 'CLIMARBLE')\n else:\n output_nc_name = h5f.fid.name. \\\n decode(\"utf-8\").split('/')[-1]. \\\n replace('TERRA_BF_L1B', 'CLIMARBLE')\n\n output_nc_name = output_nc_name.replace('.h5', '.nc')\n\n # \n NUM_POINTS = 1 / SPATIAL_RESOLUTION\n NUM_LATS = int(180 / SPATIAL_RESOLUTION)\n NUM_LONS = int(360 / SPATIAL_RESOLUTION)\n\n LAT_EDGES = np.arange(-90.0, 90.0001, SPATIAL_RESOLUTION)\n LON_EDGES = np.arange(-180.0, 180.0001, SPATIAL_RESOLUTION)\n\n # \n orbit_radiance_sum = np.zeros((NUM_LATS, NUM_LONS, 4))\n orbit_radiance_num = np.zeros((NUM_LATS, NUM_LONS, 4))\n orbit_nc_out = os.path.join(output_folder, output_nc_name)\n\n\n # =============================================================================\n # 2. Main processing\n # Loop through each CERES granule and sort radiances into the corresponding lat/lon bins\n # When encounters an asceding granule, script will move to the next granule\n # =============================================================================\n\n # USE MODIS granules to match first and last time of the descending node\n MISR_blocks = get_descending(h5f, 'MISR.{}'.format(CAMERA))\n if MISR_blocks[0] == 0:\n print(\">> IOError( no available MODIS granule in orbit {} )\".format(bf_file))\n return\n\n # LOAD lat/lon here\n lat = h5f['MISR/Geolocation/GeoLatitude'][:]\n lon = h5f['MISR/Geolocation/GeoLongitude'][:]\n\n # LOAD radiance here\n MISR_bands = ['Blue', 'Green', 'Red', 'NIR']\n rads_all = []\n for iband in MISR_bands:\n rads_all.append(h5f['MISR/{}/Data_Fields/{}_Radiance'.format(CAMERA, iband)][:])\n\n # SPECIFY data dimension to interpolate SZA/VZA\n rad_shape = (128, 512)\n \n\n # LOOP through MISR blocks (starts from 0)\n for iblk in MISR_blocks:\n\n # INTERPOLATE sza and vza (this part can be replaced by a more accurate function)\n raw_sza = h5f['MISR/Solar_Geometry/SolarZenith'][iblk]\n raw_vza = h5f['MISR/{}/Sensor_Geometry/{}Zenith'.format(CAMERA, ''.join(c.lower() if i==1 else c for i,c in enumerate(CAMERA)))][iblk]\n np.place(raw_sza, raw_sza<0, np.nan)\n np.place(raw_vza, raw_vza<0, np.nan)\n blk_sza = resize(raw_sza, rad_shape)\n blk_vza = resize(raw_vza, rad_shape)\n\n\n # SELECT lat/lon\n idx_geometry = np.where((blk_sza<89.0) & (blk_vza<VZA_MAX))\n select_lat = lat[iblk][idx_geometry]\n select_lon = lon[iblk][idx_geometry]\n\n\n # SELECT spectral radiances here\n # Aggregate 275-m res data to 1.1-km when necessary\n # Separate band by band to allow one (or more) band(s) failure\n for iband, band_name in enumerate(MISR_bands, start=0):\n blk_rad = rads_all[iband][iblk]\n # blk_rad = h5f['MISR/{}/Data_Fields/{}_Radiance'.format(CAMERA, band_name)][iblk]\n\n if blk_rad.shape == (512, 2048): \n # 275-m res band\n np.place(blk_rad, blk_rad<0, np.nan)\n fnl_blk_rad = np.nanmean(np.reshape(blk_rad, (blk_rad.shape[0]//4, 4, blk_rad.shape[1]//4,4)), axis=(1,3))\n else:\n fnl_blk_rad = blk_rad\n\n\n select_rad = np.nan_to_num(fnl_blk_rad[idx_geometry])\n fnl_idx = np.where((select_rad>0)&(select_rad<1000))[0]\n\n fnl_lat = select_lat[fnl_idx] * -1\n fnl_lon = select_lon[fnl_idx]\n fnl_rad = select_rad[fnl_idx]\n\n try:\n rad_sum, binedges, bin_numbers = binned_statistic_dd((fnl_lat, fnl_lon), fnl_rad, bins=[LAT_EDGES, LON_EDGES], statistic='sum')\n rad_cnt, binedges, bin_numbers = binned_statistic_dd((fnl_lat, fnl_lon), fnl_rad, bins=[LAT_EDGES, LON_EDGES], statistic='count')\n\n orbit_radiance_sum[:, :, iband] += rad_sum\n orbit_radiance_num[:, :, iband] += rad_cnt\n except ValueError:\n continue\n\n # =============================================================================\n # 3. Save results\n # =============================================================================\n orbit_radiance_num = np.array(orbit_radiance_num, dtype='int16')\n\n coords_lats = np.linspace(90-SPATIAL_RESOLUTION/2, -90+SPATIAL_RESOLUTION/2, NUM_LATS)\n coords_lons = np.linspace(-180+SPATIAL_RESOLUTION/2, 180-SPATIAL_RESOLUTION/2, NUM_LONS)\n\n xr_rad_sum = xr.DataArray(orbit_radiance_sum, coords=[('latitude', coords_lats), ('longitude', coords_lons), ('misr_channel', range(4))])\n xr_rad_num = xr.DataArray(orbit_radiance_num, coords=[('latitude', coords_lats), ('longitude', coords_lons), ('misr_channel', range(4))])\n xr_rad_sum.encoding['_FillValue'] = 0\n xr_rad_num.encoding['_FillValue'] = 0\n xr_rad_sum.name = 'MISR spec rad sum'\n xr_rad_num.name = 'MISR spec rad num'\n xr_rad_sum.to_netcdf(orbit_nc_out, 'a')\n xr_rad_num.to_netcdf(orbit_nc_out, 'a')\n return orbit_nc_out","def test_CFCalculation_hdf_files():\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\n\n expected_results = [\n CFCoefficient(l=2, m=0, spin_up=-571.68845386399, spin_down=-558.2336974657351, unit='K', convention='Stevens'),\n CFCoefficient(l=4,\n m=0,\n spin_up=-34.982539807305045,\n spin_down=-21.850435868549834,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=6, m=0, spin_up=3.8503494779930776, spin_down=2.168215129491561, unit='K',\n convention='Stevens'),\n CFCoefficient(l=6,\n m=-6,\n spin_up=110.50156137060345,\n spin_down=85.58558990378205,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=6, m=6, spin_up=110.50156137060345, spin_down=85.58558990378205, unit='K', convention='Stevens')\n ]\n\n cf = CFCalculation()\n cf.readPot('files/cf_calculation/CFdata.hdf')\n cf.readCDN('files/cf_calculation/CFdata.hdf')\n results = cf.performIntegration()\n\n assert results == expected_results","def read_test_data_file(self, filename):\n if not os.path.isfile(filename):\n raise Error(\"Test data file does not exist or problem with file: \" + filename)\n txt = open(filename, 'r').readlines()\n search_params = {}\n for curlinenum, curline in enumerate(txt):\n if curline.startswith('#END'): # end of search parameters\n break\n search_params[curline.split('=')[0].replace('#', '').strip()] = {\n 'value': curline.split('=')[1].split('/', 1)[0].strip(),\n 'comment': curline.split('/', 1)[1].strip()}\n while not txt[curlinenum].startswith('#1'):\n curlinenum += 1\n hdrline1 = txt[curlinenum]\n while not txt[curlinenum].startswith('#2'):\n curlinenum += 1\n hdrline2 = txt[curlinenum]\n headers1 = [a.strip() for a in hdrline1[2:].split('|')]\n headers2 = [a.strip() for a in hdrline2[2:].split('|')]\n headers = [headers1[i] + ' ' + headers2[i] for i in range(len(headers1))][:-1]\n headers = [a.replace(' mag', 'mag') for a in headers]\n split_at = [a.start() for a in re.finditer('\\|', hdrline1)][:-1]\n split_row = lambda row: [row[i:j].replace('\\n', '') for i, j in zip([0] + split_at, split_at + [None])]\n data = [split_row(row) for row in txt[curlinenum + 2:]]\n df = DataFrame(data, columns=headers)\n df.index = df['id id'].apply(lambda x: x.strip())\n df.index.name = 'NOMAD id'\n columns_to_drop = ['id id']\n df['RAJ2000'] = (df['RA hh mm ss'].apply(lambda x: float(x.split()[0])) +\n df['RA hh mm ss'].apply(lambda x: float(x.split()[1])) / 60. +\n df['RA hh mm ss'].apply(lambda x: float(x.split()[2])) / 3600.) * 15.\n columns_to_drop.append('RA hh mm ss')\n dec_sign = lambda x: -1.0 if x.strip()[0] == '-' else 1.0\n df['DEJ2000'] = (df['DEC dd mm ss'].apply(dec_sign) *\n (df['DEC dd mm ss'].apply(lambda x: float(x.split()[0].replace('+', '').replace('-', ''))) +\n df['DEC dd mm ss'].apply(lambda x: float(x.split()[1])) / 60. +\n df['DEC dd mm ss'].apply(lambda x: float(x.split()[2])) / 3600.))\n columns_to_drop.append('DEC dd mm ss')\n columns_to_drop.append('ExtractID id')\n df = df.drop(columns_to_drop, axis=1)\n for column in df: # check first in each column for ability to convert to integer, then float, then leave alone\n if df[column].dtype == object and column != 'Flags hex':\n if df[column][0].strip().lstrip('-').lstrip('+').isdigit():\n df[column] = df[column].apply(np.int)\n elif df[column][0].strip().lstrip('-').lstrip('+').replace('.', '0').isdigit():\n df[column] = df[column].apply(np.float)\n return search_params, df","def spectra_analysis(file_name, sky_file_name): \n\n # read file name and select out the id that we are dealing with\n curr_file_name = file_name.split('.')\n curr_file_name = curr_file_name[0].split('/')\n stk_f_n = curr_file_name[-1]\n cube_id = int(re.search(r'\\d+', stk_f_n).group())\n\n # read catalogue and obtain the HST redshift estimate\n #catalogue = np.load(\"data/matched_catalogue.npy\")\n catalogue = np.load(\"data/low_redshift_catalogue.npy\")\n cat_loc = np.where(catalogue[:,0] == cube_id)[0]\n cube_info = catalogue[cat_loc][0]\n \n hst_redshift = cube_info[7]\n\n # spectra and sky noise data\n spectra_data = spectrum_creator(file_name)\n wl_soln = wavelength_solution(file_name)\n sn_data = sky_noise(sky_file_name)\n\n galaxy_data = spectra_data['galaxy']\n\n # removing baseline from data\n base = peakutils.baseline(galaxy_data, 3)\n gd_mc = galaxy_data - base\n\n # scaling sky-noise to be similar to spectra data\n gd_max = np.amax(galaxy_data)\n sn_data_max = np.amax(sn_data)\n sn_scale = gd_max / sn_data_max\n\n sn_data = sn_data * sn_scale\n\n # spectra lines\n sl = {\n 'emis': {\n '[OII]': '3727',\n 'CaK': '3933',\n 'CaH': '3968',\n 'Hdelta': '4101', \n }, \n 'abs': {'K': '3934.777',\n }\n } \n\n # we can use the redshift from the HST catalogue to define the region to search for\n # the doublet in\n\n # lower and upper bound on wavelength range\n lower_lambda = (1+hst_redshift)*3600\n upper_lambda = (1+hst_redshift)*3850\n\n # x-axis data\n data_h_range = np.linspace(wl_soln['begin'], wl_soln['end'], wl_soln['steps'])\n mask = (lower_lambda < data_h_range) & (data_h_range < upper_lambda) \n\n lambda_data = data_h_range[mask]\n flux_data = gd_mc[mask] \n \n # Finding peaks with PeakUtils\n pu_peaks = peakutils.indexes(flux_data, thres=600, thres_abs=True)\n pu_peaks_x = peakutils.interpolate(lambda_data, flux_data, pu_peaks)\n\n pu_peaks_x = np.sort(pu_peaks_x)\n pu_peaks_x = pu_peaks_x[lower_lambda < pu_peaks_x]\n pu_peaks_x = pu_peaks_x[pu_peaks_x < upper_lambda]\n \n data_dir = 'cube_results/' + stk_f_n\n if not os.path.exists(data_dir):\n os.mkdir(data_dir)\n\n peaks_file = open(data_dir + '/' + stk_f_n + '_peaks.txt', 'w')\n peaks_file.write(\"Peaks found on \" + str(datetime.datetime.now()) + \"\\n\\n\")\n\n peaks_file.write(\"Number Wavelength \\n\")\n for i_peak in range(len(pu_peaks_x)):\n curr_peak = pu_peaks_x[i_peak]\n peaks_file.write(str(i_peak) + \" \" + str(curr_peak) + \"\\n\")\n\n # manually selecting which peak is the [OII] peak - given in wavelength\n if (pu_peaks_x.size != 0):\n otwo_wav = float(pu_peaks_x[0]) \n otwo_acc = float(sl['emis']['[OII]'])\n\n redshift = (otwo_wav / otwo_acc) - 1\n else:\n # accepting HST redshift if cannot find peak\n redshift = hst_redshift\n\n return {'gd_shifted': gd_mc, 'sky_noise': sn_data, 'spectra': sl, 'redshift': \n redshift, 'pu_peaks': pu_peaks_x}","def F_read_S5P_nc(self,fn,data_fields,data_fields_l2g=[]):\n from netCDF4 import Dataset\n ncid = Dataset(fn,'r')\n outp = {}\n for i in range(len(data_fields)):\n tmp = ncid[data_fields[i]]\n tmpdtype = tmp.dtype\n if not data_fields_l2g:\n varname = tmp.name\n else:\n varname = data_fields_l2g[i]\n if tmpdtype is \"str\":\n outp[varname] = tmp[:]\n else:\n outp[varname] = np.squeeze(tmp[:])\n ## scale factor already applied?! so confusing\n# try:\n# outp[varname] = outp[varname]*tmp.scale_factor\n# if tmp.scale_factor != 1:\n# print(varname+' has a scale_factor of '+'%s'%tmp.scale_factor)\n# except Exception:\n# #print(e)\n# print(varname+' has no scale_factor!')\n if 'time_utc' in outp.keys():\n UTC_matlab_datenum = np.zeros((len(outp['time_utc']),1),dtype=np.float64)\n for i in range(len(outp['time_utc'])):\n tmp = datetime.datetime.strptime(outp['time_utc'][i],'%Y-%m-%dT%H:%M:%S.%fZ')\n UTC_matlab_datenum[i] = (tmp.toordinal()\\\n +tmp.hour/24.\\\n +tmp.minute/1440.\\\n +tmp.second/86400.\\\n +tmp.microsecond/86400/1000000+366.)\n outp['UTC_matlab_datenum'] = np.tile(UTC_matlab_datenum,(1,outp['latc'].shape[1]))\n else: # hcho l2 does not have time_utc\n # the delta_time field of hcho fills all across track position, but ch4 is one per scanline\n if len(outp['delta_time'].shape) == 1:\n outp['delta_time'] = np.tile(outp['delta_time'][...,None],(1,outp['latc'].shape[1]))\n outp['UTC_matlab_datenum'] = (outp['time']+outp['delta_time']/1000.)/86400.+734139.\n \n outp['across_track_position'] = np.tile(np.arange(1.,outp['latc'].shape[1]+1),\\\n (outp['latc'].shape[0],1)).astype(np.int16)\n return outp","def test_cl_fix_file(mock_get_filepath, cl_file, tmp_path):\n mock_get_filepath.return_value = os.path.join(tmp_path,\n 'fixed_cesm2_waccm_cl.nc')\n fix = Cl(None)\n fixed_file = fix.fix_file(cl_file, tmp_path)\n mock_get_filepath.assert_called_once_with(tmp_path, cl_file)\n fixed_dataset = Dataset(fixed_file, mode='r')\n assert fixed_dataset.variables['lev'].standard_name == (\n 'atmosphere_hybrid_sigma_pressure_coordinate')\n assert fixed_dataset.variables['lev'].formula_terms == (\n 'p0: p0 a: a b: b ps: ps')\n assert fixed_dataset.variables['lev'].units == '1'\n np.testing.assert_allclose(fixed_dataset.variables['a'][:], [1.0, 2.0])\n np.testing.assert_allclose(fixed_dataset.variables['b'][:], [0.0, 1.0])\n np.testing.assert_allclose(fixed_dataset.variables['a_bnds'][:],\n [[0.0, 1.5], [1.5, 3.0]])\n np.testing.assert_allclose(fixed_dataset.variables['b_bnds'][:],\n [[-1.0, 0.5], [0.5, 2.0]])","def test_compute_Sv_ek80_CW_complex_BB_complex(ek80_cal_path):\n ek80_raw_path = ek80_cal_path / \"2018115-D20181213-T094600.raw\"\n ed = ep.open_raw(ek80_raw_path, sonar_model=\"EK80\")\n ds_Sv = ep.calibrate.compute_Sv(\n ed, waveform_mode=\"CW\", encode_mode=\"complex\"\n )\n assert isinstance(ds_Sv, xr.Dataset)\n ds_Sv = ep.calibrate.compute_Sv(\n ed, waveform_mode=\"BB\", encode_mode=\"complex\"\n )\n assert isinstance(ds_Sv, xr.Dataset)","def test_CFCalculation_txt_files():\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\n\n #Make sure new script produces the same result as old one\n expected_results = [\n CFCoefficient(l=2,\n m=0,\n spin_up=-419.7891726292168,\n spin_down=-414.7152560307904,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=4,\n m=0,\n spin_up=-35.92607948104669,\n spin_down=-26.384951772020756,\n unit='K',\n convention='Stevens'),\n CFCoefficient(l=6, m=0, spin_up=6.522900740505054, spin_down=5.488104692050172, unit='K', convention='Stevens')\n ]\n\n cf = CFCalculation(reference_radius='cdn')\n cf.readPot('files/cf_calculation/VKS.2.0.dat',\n 'files/cf_calculation/VKS.4.0.dat',\n 'files/cf_calculation/VKS.6.0.dat',\n lm=[(2, 0), (4, 0), (6, 0)])\n cf.readCDN('files/cf_calculation/Nd.dat', header=3)\n cf.cdn['RMT'] = 3.138049652\n results = cf.performIntegration()\n\n assert results == expected_results","def sky_orbits(test=True):\n \n t = Table.read('/home/ana/data/baumgardt_positions.fits')\n \n ind_disterr = ~np.isfinite(t['e_Rsun'])\n t['e_Rsun'][ind_disterr] = 0.1 * t['Rsun'][ind_disterr]\n e_max = np.nanmax(t['e_Rsun'][~ind_disterr])\n ind_cap = t['e_Rsun']>e_max\n t['e_Rsun'][ind_cap] = e_max\n \n clusters = ['NGC 3201', 'NGC 4590', 'NGC 5824', 'NGC 5272', 'NGC 5139', 'NGC 5024']\n #clusters = ['NGC 5824', 'NGC 5024']\n N = len(clusters)\n \n match = dict()\n match['NGC 3201'] = dict(streams=['gjoll'], direction=[-1], nstep=[35], gc_label='NGC\\n3201', gcra_off=0*u.deg, gcdec_off=-13*u.deg, gcl_off=0*u.deg, gcb_off=-13*u.deg, stream_label=['$Gj\\\\\\\" oll$'], stream_ra=[-156*u.deg], stream_dec=[-4.5*u.deg], eq_angle=[-45*u.deg], stream_l=[-148*u.deg], stream_b=[-33*u.deg], gal_angle=[22*u.deg])\n \n match['NGC 4590'] = dict(streams=['fjorm'], direction=[1], nstep=[100], gc_label='NGC\\n4590', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=-13*u.deg, gcb_off=-10*u.deg, stream_label=['$Fj\\\\\\\" orm$'], stream_ra=[-22*u.deg], stream_dec=[66*u.deg], eq_angle=[35*u.deg], stream_l=[110*u.deg], stream_b=[50*u.deg], gal_angle=[-50*u.deg])\n \n match['NGC 5024'] = dict(streams=['sylgr', 'ravi'], direction=[-1, 1], nstep=[300,500], gc_label='NGC\\n5024', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=10*u.deg, gcb_off=-20*u.deg, stream_label=['Sylgr', 'Ravi'], stream_ra=[-70*u.deg, 83*u.deg], stream_dec=[2*u.deg, -47*u.deg], eq_angle=[25*u.deg, 65*u.deg], stream_l=[-110*u.deg, -18.5*u.deg], stream_b=[62*u.deg, -47*u.deg], gal_angle=[30*u.deg, -10*u.deg])\n \n match['NGC 5139'] = dict(streams=['fimbulthul'], direction=[-1], nstep=[70], gc_label='NGC\\n5139', gcra_off=-5*u.deg, gcdec_off=-15*u.deg, gcl_off=0*u.deg, gcb_off=-12*u.deg, stream_label=['Fimbulthul'], stream_ra=[-20*u.deg], stream_dec=[-15*u.deg], eq_angle=[0*u.deg], stream_l=[-20*u.deg], stream_b=[45*u.deg], gal_angle=[0*u.deg])\n \n match['NGC 5272'] = dict(streams=['svol'], direction=[1], nstep=[70], gc_label='NGC\\n5272', gcra_off=-15*u.deg, gcdec_off=10*u.deg, gcl_off=-23*u.deg, gcb_off=-17*u.deg, stream_label=['$Sv\\\\\\\" ol$'], stream_ra=[-2*u.deg], stream_dec=[34*u.deg], eq_angle=[-10*u.deg], stream_l=[55*u.deg], stream_b=[55*u.deg], gal_angle=[-65*u.deg])\n \n match['NGC 5824'] = dict(streams=['triangulum', 'turbio'], direction=[1,1], nstep=[700,1], gc_label='NGC\\n5824', gcra_off=15*u.deg, gcdec_off=-5*u.deg, gcl_off=15*u.deg, gcb_off=-5*u.deg, stream_label=['Triangulum', 'Turbio'], stream_ra=[152*u.deg, 130*u.deg], stream_dec=[32*u.deg, -51*u.deg], eq_angle=[-48*u.deg, 30*u.deg], stream_l=[120*u.deg, -82*u.deg], stream_b=[-31*u.deg, -57*u.deg], gal_angle=[70*u.deg, 105*u.deg])\n \n dt = 0.5*u.Myr\n wangle = 180*u.deg\n ra_off = 120*u.deg\n l_off = 0*u.deg\n \n colors = [mpl.cm.plasma(0.95*x/N) for x in range(N)]\n \n np.random.seed(27529)\n if test:\n Nsample = 1\n else:\n Nsample = 100\n \n plt.close()\n fig = plt.figure(figsize=(12,12))\n \n ax0 = fig.add_subplot(211, projection='mollweide')\n ax1 = fig.add_subplot(212, projection='mollweide')\n ax = [ax0, ax1]\n \n for i in range(N):\n #ind = t['Name']== clusters[i]\n ind = t['Name']==clusters[i]\n t_ = t[ind]\n \n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\n cgal = c.transform_to(coord.Galactic)\n #w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n color = colors[i]\n alpha_text = 0.8\n \n plt.sca(ax[0])\n plt.plot((c.ra + ra_off).wrap_at(wangle).rad, c.dec.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\n plt.text((c.ra + ra_off + match[clusters[i]]['gcra_off']).wrap_at(wangle).rad, (c.dec + match[clusters[i]]['gcdec_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\n \n plt.sca(ax[1])\n plt.plot((cgal.l + l_off).wrap_at(wangle).rad, cgal.b.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\n plt.text((cgal.l + l_off + match[clusters[i]]['gcl_off']).wrap_at(wangle).rad, (cgal.b + match[clusters[i]]['gcb_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\n \n\n for j in range(len(match[clusters[i]]['direction'])):\n # sample gc positional uncertainties\n for k in range(-1, Nsample):\n if k==-1:\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n lw = 1.5\n alpha = 1\n else:\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'] + np.random.randn()*t_['e_Rsun'], pm_ra_cosdec=t_['pmRA_'] + np.random.randn()*t_['e_pmRA_'], pm_dec=t_['pmDE'] + np.random.randn()*t_['e_pmDE'], radial_velocity=t_['RV'] + np.random.randn()*t_['e_RV'], frame='icrs')\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\n \n lw = 1\n alpha = 0.1\n \n orbit = ham.integrate_orbit(w0, dt=dt*match[clusters[i]]['direction'][j], n_steps=match[clusters[i]]['nstep'][j])\n orbit_eq = orbit.to_coord_frame(coord.ICRS, galactocentric_frame=gc_frame)\n orbit_gal = orbit.to_coord_frame(coord.Galactic, galactocentric_frame=gc_frame)\n \n \n plt.sca(ax[0])\n dra = (orbit_eq.ra+ra_off).wrap_at(wangle)[1:] - (orbit_eq.ra+ra_off).wrap_at(wangle)[:-1]\n if np.any(np.abs(dra)>180*u.deg):\n pos_break = dra>180*u.deg\n ind_break = np.argmax(pos_break)\n ipad = 1\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_eq.dec.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_eq.dec.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\n else:\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad, orbit_eq.dec.rad, '-', color=color, lw=lw, label='', alpha=alpha)\n \n plt.sca(ax[1])\n dl = orbit_gal.l.wrap_at(wangle)[1:] - orbit_gal.l.wrap_at(wangle)[:-1]\n if np.any(np.abs(dl)>180*u.deg):\n pos_break = dl>180*u.deg\n ind_break = np.argmax(pos_break)\n ipad = 1\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_gal.b.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_gal.b.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\n else:\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad, orbit_gal.b.rad, '-', color=color, lw=lw, label='', alpha=alpha)\n \n # add streams\n pkl = pickle.load(open('../data/streams/data_{:s}.pkl'.format(match[clusters[i]]['streams'][j]), 'rb'))\n cs = coord.SkyCoord(ra=pkl['dec'][0], dec=pkl['dec'][1], frame='icrs')\n cs_gal = cs.transform_to(coord.Galactic)\n \n plt.sca(ax[0])\n plt.plot((cs.ra+ra_off).wrap_at(wangle).rad, cs.dec.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\n plt.text(coord.Longitude(match[clusters[i]]['stream_ra'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_dec'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['eq_angle'][j].value, ha='center', va='center')\n \n plt.sca(ax[1])\n plt.plot((cs_gal.l+l_off).wrap_at(wangle).rad, cs_gal.b.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\n plt.text(coord.Longitude(match[clusters[i]]['stream_l'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_b'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['gal_angle'][j].value, ha='center', va='center')\n \n \n plt.sca(ax[0])\n plt.grid(ls=':')\n plt.xlabel('R.A. [deg]')\n plt.ylabel('Dec [deg]')\n\n plt.gca().xaxis.set_ticklabels([])\n \n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\n xloc = np.delete(xloc, [3])\n yloc = coord.Latitude(5*u.deg)\n Nx = len(xloc)\n \n for i in range(Nx):\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\degree$'.format((xloc[i]-ra_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\n \n \n plt.sca(ax[1])\n plt.grid(ls=':')\n plt.xlabel('Galactic longitude [deg]')\n plt.ylabel('Galactic latitude [deg]')\n \n plt.gca().xaxis.set_ticklabels([])\n \n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\n xloc = np.delete(xloc, [2,3])\n yloc = coord.Latitude(5*u.deg)\n Nx = len(xloc)\n \n for i in range(Nx):\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\degree$'.format((xloc[i]+l_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\n \n \n \n plt.tight_layout(h_pad=2)\n plt.savefig('../paper/sky_orbits.pdf')","def Test_data():\n print (\"loading test data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\n test_real = f['test_real'][:]\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\n test_imag = f['test_imag'][:]\n test_real = np.transpose(test_real, (0, 1, 3, 2))\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\n test_data = test_real+1j*test_imag\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end - time_start))\n return test_data","def test_CFCalculation_hdf_files_wybourne_convention():\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\n\n expected_results = [\n CFCoefficient(l=2,\n m=0,\n spin_up=(-1143.37690772798 + 0j),\n spin_down=(-1116.4673949314702 + 0j),\n unit='K',\n convention='Wybourne'),\n CFCoefficient(l=4,\n m=0,\n spin_up=(-279.86031845844036 + 0j),\n spin_down=(-174.80348694839867 + 0j),\n unit='K',\n convention='Wybourne'),\n CFCoefficient(l=6,\n m=0,\n spin_up=(61.60559164788924 + 0j),\n spin_down=(34.69144207186498 + 0j),\n unit='K',\n convention='Wybourne'),\n CFCoefficient(l=6,\n m=-6,\n spin_up=(116.32750335918315 + 4.696327749935313e-06j),\n spin_down=(90.09789430612014 + 3.6373963939901583e-06j),\n unit='K',\n convention='Wybourne'),\n CFCoefficient(l=6,\n m=6,\n spin_up=(116.32750335918315 - 4.696327749935313e-06j),\n spin_down=(90.09789430612014 - 3.6373963939901583e-06j),\n unit='K',\n convention='Wybourne')\n ]\n\n cf = CFCalculation()\n cf.readPot('files/cf_calculation/CFdata.hdf')\n cf.readCDN('files/cf_calculation/CFdata.hdf')\n results = cf.performIntegration(convert=False)\n\n print(results)\n assert results == expected_results","def test_species_to_sdf_file(self):\n path = os.path.join(ARC_PATH, 'arc', 'testing', 'mol.sdf')\n spc = ARCSpecies(label='NCC', smiles='NCC')\n converter.species_to_sdf_file(spc, path)\n with open(path, 'r') as f:\n sdf_content = f.read()\n expected_sdf = \"\"\"\n RDKit 3D\n\n 10 9 0 0 0 0 0 0 0 0999 V2000\n 1.1517 -0.3760 -0.5231 N 0 0 0 0 0 0 0 0 0 0 0 0\n 0.2893 0.4500 0.3115 C 0 0 0 0 0 0 0 0 0 0 0 0\n -1.1415 -0.0561 0.2592 C 0 0 0 0 0 0 0 0 0 0 0 0\n 1.1386 -1.3376 -0.1854 H 0 0 0 0 0 0 0 0 0 0 0 0\n 2.1151 -0.0555 -0.4352 H 0 0 0 0 0 0 0 0 0 0 0 0\n 0.6517 0.4342 1.3447 H 0 0 0 0 0 0 0 0 0 0 0 0\n 0.3279 1.4855 -0.0414 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.2133 -1.0839 0.6308 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.7870 0.5726 0.8809 H 0 0 0 0 0 0 0 0 0 0 0 0\n -1.5327 -0.0332 -0.7636 H 0 0 0 0 0 0 0 0 0 0 0 0\n 1 2 1 0\n 1 4 1 0\n 1 5 1 0\n 2 3 1 0\n 2 6 1 0\n 2 7 1 0\n 3 8 1 0\n 3 9 1 0\n 3 10 1 0\nM END\n$$$$\n\"\"\"\n self.assertEqual(sdf_content, expected_sdf)","def constant_2015():\n\n #Load the CMIP6 historical\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\n #Get low and high level emissions just in the last year (2014)\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\n final_cubes = iris.cube.CubeList()\n for cube in cubes:\n final_cube = cube[-12:]\n final_cubes.append(final_cube)\n \n #Set the year-on-year proportional reductions to be nothing\n yoy_rates = calc_perc_reducts()\n yoy_rates = np.array(yoy_rates)\n yoy_rates = np.ones_like(yoy_rates)\n\n #Create coordinates for new nc file between 2014 and 2100\n lat_coord = cubes[0].coord('latitude')\n lon_coord = cubes[0].coord('longitude')\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\n\n #Create the cube date\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n #Set first year equal to 2014 in CMIP6 historical\n cube_data_surf[:12,...] = final_cubes[0].data\n cube_data_high[:12,...] = final_cubes[1].data\n #Apply equal emissions in all other years too\n for i in range(12,cube_data_surf.shape[0]):\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\n #Make the output cubes\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\n\n fut_cube_high.var_name = 'field569_1'\n fut_cube_high.units='kg/m2/s'\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\n fut_cube_surf.var_name = 'field569'\n fut_cube_surf.units='kg/m2/s'\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\n\n #Load the DMS cube from standard RCP2.6\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\n\n dms_cube.var_name = 'field570'\n dms_cube.attributes.pop('name')\n dms_cube.coord('time').var_name = 'time'\n dms_cube.coord('time').long_name = 'time'\n\n fut_cube_high = fut_cube_high[:-2]\n fut_cube_surf = fut_cube_surf[:-2]\n\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\n\n #Save the final cubes as netcdf (cutting them to be the same length)\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \"SO2DMS_const2014.nc\")\n os.system('ncatted -O -a calendar,time,m,c,\"360_day\" '+data_dir+ \"SO2DMS_const2014.nc\")\n\n return","def convert_calculations(filename, hdf5_data):\n x1 = []\n\n with open(filename, 'r') as inp:\n for line in inp:\n x1.append(line)\n\n idx = 1\n dset = require_dataset(hdf5_data, structure.H5_ENV_VOLUME, (1,), dtype=settings.NEMOH_FLOAT)\n dset[0] = float(x1[idx].split()[0])\n set_hdf5_attributes(dset, structure.H5_ENV_VOLUME_ATTR)\n idx += 1\n\n dset = require_dataset(hdf5_data, structure.H5_ENV_GRAVITY, (1,), dtype=settings.NEMOH_FLOAT)\n dset[0] = float(x1[idx].split()[0])\n set_hdf5_attributes(dset, structure.H5_ENV_GRAVITY_ATTR)\n idx += 1\n\n\n dset = require_dataset(hdf5_data, structure.H5_ENV_DEPTH, (1,), dtype=settings.NEMOH_FLOAT)\n dset[0] = float(x1[idx].split()[0])\n set_hdf5_attributes(dset, structure.H5_ENV_DEPTH_ATTR)\n idx += 1\n\n dset = require_dataset(hdf5_data, structure.H5_ENV_WAVE_POINT, (2,), dtype=settings.NEMOH_FLOAT)\n x2 = x1[idx].split()\n dset[0] = float(x2[0])\n dset[1] = float(x2[1])\n set_hdf5_attributes(dset, structure.H5_ENV_WAVE_POINT_ATTR)\n\n idx = 6\n\n num_bodies = int(x1[idx].split()[0])\n\n for i in range(num_bodies):\n\n body = structure.H5_BODIES + structure.H5_BODY_BASE + str(i+1) + '/'\n idx += 2\n\n mesh_x = []\n\n mesh_path = os.path.join(os.path.abspath(os.path.dirname(filename)), str(x1[idx].split()[0]).strip(' \\t\\n\\r'))\n\n with open(mesh_path, 'r') as mesh_file:\n for line in mesh_file:\n mesh_x.append(line)\n\n idx += 1\n x2 = x1[idx].split()\n\n num_points = int(x2[0])\n num_panels = int(x2[1])\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_NUM_POINTS, (1, ), dtype=settings.NEMOH_INT)\n dset[0] = num_points\n set_hdf5_attributes(dset, structure.H5_BODY_NUM_POINTS_ATTR)\n\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_NUM_PANELS, (1, ), dtype=settings.NEMOH_INT)\n dset[0] = num_panels\n set_hdf5_attributes(dset, structure.H5_BODY_NUM_PANELS_ATTR)\n\n mesh_idx = 0\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_MESH, (num_points+num_panels+1, 4), dtype=settings.NEMOH_FLOAT)\n mesh_x2 = mesh_x[mesh_idx].split()\n set_hdf5_attributes(dset, structure.H5_BODY_MESH_ATTR)\n\n dset[0, 0] = int(mesh_x2[0])\n dset[0, 1] = int(mesh_x2[1])\n\n for j in range(1, num_points+num_panels+1):\n mesh_idx += 1\n mesh_x2 = mesh_x[mesh_idx].split()\n dset[j, :] = [float(x) for x in mesh_x2[:4]]\n\n if j == num_points:\n mesh_idx += 1\n\n idx += 1\n num = int(x1[idx].split()[0])\n dset = require_dataset(hdf5_data, body + structure.H5_FREEDOM_DEGREE, (num, 7), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_FREEDOM_DEGREE_ATTR)\n for j in range(num):\n idx += 1\n x2 = x1[idx].split()\n dset[j, :] = np.array([float(x) for x in x2[:7]])\n\n idx += 1\n num = int(x1[idx].split()[0])\n dset = require_dataset(hdf5_data, body + structure.H5_GENERALISED_FORCES, (num, 7), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_GENERALISED_FORCES_ATTR)\n for j in range(num):\n idx += 1\n x2 = x1[idx].split()\n dset[j, :] = [float(x) for x in x2[:7]]\n\n idx += 1\n num = int(x1[idx].split()[0])\n for j in range(num):\n idx += 1\n\n idx += 2\n x2 = x1[idx].split()\n\n dset = require_dataset(hdf5_data, structure.H5_NUM_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_NUM_WAVE_FREQUENCIES_ATTR)\n dset[0] = int(x2[0])\n dset = require_dataset(hdf5_data, structure.H5_MIN_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_MIN_WAVE_FREQUENCIES_ATTR)\n dset[0] = float(x2[1])\n dset = require_dataset(hdf5_data, structure.H5_MAX_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_MAX_WAVE_FREQUENCIES_ATTR)\n dset[0] = float(x2[2])\n idx += 1\n x2 = x1[idx].split()\n dset = require_dataset(hdf5_data, structure.H5_NUM_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_NUM_WAVE_DIRECTIONS_ATTR)\n dset[0] = int(x2[0])\n\n dset = require_dataset(hdf5_data, structure.H5_MIN_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_MIN_WAVE_DIRECTIONS_ATTR)\n dset[0] = float(x2[1])\n\n dset = require_dataset(hdf5_data, structure.H5_MAX_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_MAX_WAVE_DIRECTIONS_ATTR)\n dset[0] = float(x2[2])\n\n idx += 2\n x2 = x1[idx].split()\n\n dset = require_dataset(hdf5_data, structure.H5_COMPUTE_IRF, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_COMPUTE_IRF_ATTR)\n dset[0] = int(x2[0])\n\n dset = require_dataset(hdf5_data, structure.H5_IRF_TIME_STEP, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_IRF_TIME_STEP_ATTR)\n dset[0] = float(x2[1])\n dset = require_dataset(hdf5_data, structure.H5_IRF_DURATION, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_IRF_DURATION_ATTR)\n dset[0] = float(x2[2])\n\n idx += 1\n x2 = x1[idx].split()\n dset = require_dataset(hdf5_data, structure.H5_SHOW_PRESSURE, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_SHOW_PRESSURE_ATTR)\n dset[0] = int(x2[0])\n\n idx += 1\n x2 = x1[idx].split()\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_NUMBER, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_KOCHIN_NUMBER_ATTR)\n dset[0] = float(x2[0])\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_MIN, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_KOCHIN_MIN_ATTR)\n dset[0] = float(x2[1])\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_MAX, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_KOCHIN_MAX_ATTR)\n dset[0] = float(x2[2])\n\n\n idx += 1\n x2 = x1[idx].split()\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_POINTS_X, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_POINTS_X_ATTR)\n dset[0] = int(x2[0])\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_POINTS_Y, (1,), dtype=settings.NEMOH_INT)\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_POINTS_Y_ATTR)\n dset[0] = int(x2[1])\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_DIMENSION_X, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_DIMENSION_X_ATTR)\n dset[0] = float(x2[2])\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_DIMENSION_Y, (1,), dtype=settings.NEMOH_FLOAT)\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_DIMENSION_Y_ATTR)\n dset[0] = float(x2[3])","def initialize_data(self , station = '', datasets = {} ):\n \n self.datasets = datasets\n self.datasets_keys = datasets.keys()\n self.station = station\n \n data = {} # container for the data of each dataset\n source_configuration = {} # container for the source_configuration of each dataset\n \n\n \n \"\"\" Looping over the datasets \"\"\"\n logging.info('*** Reading and Initializing the data from the netCDF files ')\n \n \n for k,v in datasets.items() :\n logging.info(' Initialising the dataset: *** %s ' , k )\n data[k] = {} \n data['cdm_tables'] = {} \n \n ### alternative with xarray \n #ds = xr.load_dataset(v) \n #observations_table = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \n \n ### alternative with netCDF4\n #ds = nc.Dataset(v) \n #data[k]['dateindex'] = ds.variables['dateindex'][0,:] # storing the dateindex \n \n ###for h5py but cant extract date time units !!!\n ds = h5py.File(v , driver=\"core\" ) \n data[k]['df'] = ds # storing the entire file \n try: \n data[k]['source_file'] = ds['source_configuration']['source_file'][0]\n except:\n data[k]['source_file'] = str(v) # temp fix \n \n #data[k]['product_code'] = ds['source_configuration']['product_code'][0] \n #data[k]['recordtimestamp'] = ds['recordtimestamp'].value\n #data[k]['recordindex'] = ds['recordindex'].value \n #ds.close() \n logging.debug('Reading the file with h5py ')\n \n \n # add here appending datasets for the case of ncar_w and ncar_t \n \n \n self.data = data\n self.make_dataframe()\n ds.close()\n \n \"\"\" Reading the header_table, station_configuration, source_configuration \"\"\"\n for k,v in datasets.items() : \n \n #d = xr.open_dataset(v , engine = 'h5netcdf' ) \n #data[k]['recordtimestamp'] = d['recordtimestamp'].values\n #data[k]['recordindex'] = d['recordindex'].values \n \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'station_configuration') \n data[k]['station_configuration'] = d.to_dataframe() \n #data[k]['station_configuration'] = d ### USELESS ? \n logging.debug('Done with %s station_configuration' , str(k) )\n \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'header_table') \n logging.debug('Loading the header_table') \n if 'header_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\n self.attributes['header_table'] = {}\n for var in d.variables:\n self.attributes['header_table'][var] = {}\n self.attributes['header_table'][var]['description'] = d[var].description\n self.attributes['header_table'][var]['external_table'] = d[var].external_table \n data[k]['header_table'] = d.to_dataframe() \n logging.debug('Done with %s ' , k )\n \n logging.info(\"*** Loading the observations_table (might take time) %s\" , k ) \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \n \n if 'observations_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\n self.attributes['observations_table'] = {}\n for var in d.variables:\n self.attributes['observations_table'][var] = {}\n self.attributes['observations_table'][var]['description'] = d[var].description\n self.attributes['observations_table'][var]['external_table'] = d[var].external_table\n \n \n logging.info(\"*** Loading the source configuration %s\" , k ) \n try: \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'source_configuration')\n d = d.isel(hdrlen=[0])\n data[k]['source_configuration'] = d.to_dataframe() ### USELESS ? \n logging.debug('Done with %s source_configuration' , k )\n except: \n data[k]['source_configuration']= pd.DataFrame(np.array( [ [ self.data[k]['source_file'] ] ] ) , columns=['source_file'] ) \n \n if k == 'era5_1': # reading the whole era5_1 feedback (including reanalysis)\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'era5fb') \n data[k]['era5fb'] = d.to_dataframe() \n logging.debug('Done with %s era5 feedback ', k )\n \n \"\"\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \"\"\" \n if list(datasets.keys()).index(k) == 0 :\n for t in [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type']: \n \n d = xr.open_dataset(v , engine = 'h5netcdf' , group = t) \n #data['cdm_tables'][t] = d.to_dataframe() ### USELESS ?\n data['cdm_tables'][t] = d \n \n d.close() \n ds.close()\n\n \"\"\" Reading the name of the original source file \"\"\"\n source_configuration[k] = {} \n source_configuration[k]['source_file'] = [ c for c in v.split('/') if '.nc' in c][0]\n\n \n \"\"\" Storing the station configurations \"\"\" \n self.source_configuration = source_configuration \n \n \"\"\" Making all date_times \"\"\" \n self.make_all_datetime()\n \n \n \"\"\" feedback columns \"\"\"\n if 'era5_1' in list (self.data.keys() ):\n self.fb_columns = list(self.data['era5_1']['era5fb'].columns ) \n else:\n self.fb_columns = ['empty']","def test_brainvision_data():\n assert_raises(IOError, read_raw_brainvision, vmrk_path)\n assert_raises(ValueError, read_raw_brainvision, vhdr_path, montage,\n preload=True, scale=\"foo\")\n with warnings.catch_warnings(record=True) as w: # event parsing\n raw_py = _test_raw_reader(\n read_raw_brainvision, vhdr_fname=vhdr_path, montage=montage,\n eog=eog)\n assert_true(all('parse triggers that' in str(ww.message) for ww in w))\n assert_true('RawBrainVision' in repr(raw_py))\n\n assert_equal(raw_py.info['highpass'], 0.)\n assert_equal(raw_py.info['lowpass'], 250.)\n\n picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads')\n data_py, times_py = raw_py[picks]\n\n # compare with a file that was generated using MNE-C\n raw_bin = Raw(eeg_bin, preload=True)\n picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads')\n data_bin, times_bin = raw_bin[picks]\n\n assert_array_almost_equal(data_py, data_bin)\n assert_array_almost_equal(times_py, times_bin)\n\n # Make sure EOG channels are marked correctly\n for ch in raw_py.info['chs']:\n if ch['ch_name'] in eog:\n assert_equal(ch['kind'], FIFF.FIFFV_EOG_CH)\n elif ch['ch_name'] == 'STI 014':\n assert_equal(ch['kind'], FIFF.FIFFV_STIM_CH)\n elif ch['ch_name'] in raw_py.info['ch_names']:\n assert_equal(ch['kind'], FIFF.FIFFV_EEG_CH)\n else:\n raise RuntimeError(\"Unknown Channel: %s\" % ch['ch_name'])\n\n # test loading v2\n read_raw_brainvision(vhdr_v2_path, eog=eog, preload=True,\n response_trig_shift=1000)","def test_compute_Sv_ek80_BB_complex(ek80_path):\n ek80_raw_path = str(\n ek80_path.joinpath('ar2.0-D20201209-T235955.raw')\n ) # CW complex\n echodata = ep.open_raw(ek80_raw_path, sonar_model='EK80')\n ds_Sv = ep.calibrate.compute_Sv(\n echodata, waveform_mode='BB', encode_mode='complex'\n )\n assert isinstance(ds_Sv, xr.Dataset) is True\n ds_TS = ep.calibrate.compute_TS(\n echodata, waveform_mode='BB', encode_mode='complex'\n )\n assert isinstance(ds_TS, xr.Dataset) is True","def test_defect_calculation_control():\n csnet = example.control.cs_network()\n slaves, connections = csnet\n step_sizes = {name: Fraction(1, 2) for name in slaves}\n make_zoh: cs.ConverterConstructor = cs.Zoh\n rate_converters = {cs.Connection(src, dst): make_zoh for dst, src in connections.items()}\n initial_tokens = {sdf.Dst('PI', 'u'): [0.], sdf.Dst('PT2', 'u'): [0.]}\n cosim = csnet, step_sizes, rate_converters, initial_tokens\n defect = cs.evaluate(cosim, Fraction(20.))\n for val in defect.connection.values():\n assert val < float('inf')\n for val in defect.output.values():\n assert val < float('inf')","def read_h5(self):\n infile = h5py.File(self.inf_name,'r')\n\n vardict = self.labdict\n #store data with the correct labels\n for k in infile['plasma/1d'].keys():\n try:\n vardict[k] = infile[self.labdict[k]].value\n except:\n vardict[k] = []\n\n vardict['a_ions']=infile['/plasma/anum'].value\n vardict['znum']=infile['/plasma/znum'].value\n \n\n self.rho_in = vardict['rho']\n self._rho_vol = infile['distributions/rhoDist/abscissae/dim1'].value[1:]\n self._volumes = infile['distributions/rhoDist/shellVolume'].value\n self.nrho_in = np.size(self.rho_in)\n\n if vardict['a_ions'][0]!='/':\n self.nspec = len(vardict['a_ions'])\n else:\n self.nspec = vardict['ni'].shape[1]\n print(\"Number of ions: \", self.nspec)\n if len(vardict['a_ions'])!=len(vardict['znum']):\n print(\"ERROR! array of A and Z don't have the same length\")\n\n self.A = vardict['a_ions']\n self.Z = vardict['znum']\n self.nion = self.nspec\n \n self.te_in = vardict['te'][:]\n self.ne_in = vardict['ne'][:]\n self.ti_in = vardict['ti'][:]\n ni1_in = vardict['ni'][:,0]\n self.ni_in = np.zeros((self.nion, self.nrho_in),dtype=float)\n self.ni_in[0,:] = ni1_in\n if self.nion==2:\n ni2_in = vardict['ni'][:,1]\n self.ni_in[1,:] = ni2_in\n elif self.nion==3:\n ni2_in = vardict['ni'][:,1]\n ni3_in = vardict['ni'][:,2]\n self.ni_in[1,:] = ni2_in\n self.ni_in[2,:] = ni3_in\n\n try:\n self.vt_in = vardict['vtor']\n except:\n self.vt_in = np.zeros(self.nrho_in,dtype=float)\n\n try:\n self.zeff_in = vardict['zeff'][:]\n except:\n self.zeff_in = np.zeros(self.nrho_in,dtype=float)\n\n self.ni = np.zeros((self.nion, self.nrho),dtype = float)\n self.spline()","def read_satellite(filename, ftype):\n #ftype = 'l3c'\n #filename = '/gws/nopw/j04/cds_c3s_sst/output/v2.6.0/l3c/AVHRR19_G/2018/03/01/20180301120000-C3S-L3C_GHRSST-SSTskin-AVHRR19_G-ICDR2.0_day-v02.0-fv01.0.nc'\n #ftype = 'l4'\n #filename = '/gws/nopw/j04/cds_c3s_sst/public/data/ICDR_v2/Analysis/L4/v2.0/2018/01/01/20180101120000-C3S-L4_GHRSST-SSTdepth-OSTIA-GLOB_ICDR2.0-v02.0-fv01.0.nc'\n print \"Reading %s file: %s\" % (ftype, filename)\n \n # Read data - L4 or L3C (note L4 mask and L3C quality level have same array name)\n ncin = netCDF4.Dataset(filename)\n if ftype == 'l4':\n lon = ncin.variables['lon'][:]\n lat = ncin.variables['lat'][:]\n time_read = ncin.variables['time'][:]\n sst = ncin.variables['analysed_sst'][:]\n unc = ncin.variables['analysis_uncertainty'][:]\n sea_ice_frac = ncin.variables['sea_ice_fraction'][:]\n ql = ncin.variables['mask'][:]\n sstfill = ncin.variables['analysed_sst']._FillValue\n sstao = ncin.variables['analysed_sst'].add_offset\n sstsf = ncin.variables['analysed_sst'].scale_factor\n elif ftype == 'l3c':\n lon = ncin.variables['lon'][:]\n lat = ncin.variables['lat'][:]\n time_read = ncin.variables['time'][:]\n time_bnds = ncin.variables['time_bnds'][:]\n sst = ncin.variables['sea_surface_temperature'][:]\n sst_depth = ncin.variables['sea_surface_temperature_depth'][:]\n sst_dtime = ncin.variables['sst_dtime'][:]\n sst_depth_dtime = ncin.variables['sst_depth_dtime'][:]\n sses_bias = ncin.variables['sses_bias'][:]\n sses_sd = ncin.variables['sses_standard_deviation'][:]\n sst_depth_total_unc = ncin.variables['sst_depth_total_uncertainty'][:]\n l2p_flags = ncin.variables['l2p_flags'][:]\n ql = ncin.variables['quality_level'][:]\n wind_speed = ncin.variables['wind_speed'][:]\n large_scale_cor_unc = ncin.variables['large_scale_correlated_uncertainty'][:]\n synop_cor_unc = ncin.variables['synoptically_correlated_uncertainty'][:]\n uncor_unc = ncin.variables['uncorrelated_uncertainty'][:]\n adj_unc = ncin.variables['adjustment_uncertainty'][:]\n aerosol_dyn_ind = ncin.variables['aerosol_dynamic_indicator'][:]\n sens = ncin.variables['sensitivity'][:]\n tfill = ncin.variables['sst_dtime']._FillValue\n sstfill = ncin.variables['sea_surface_temperature']._FillValue\n sstao = ncin.variables['sea_surface_temperature'].add_offset\n sstsf = ncin.variables['sea_surface_temperature'].scale_factor\n else:\n print 'ftype not recognised or supported'\n \n # Create time field\n # -> If L4 then create a time field set to time in L4 file\n # -> Also add a time fill value to keep coding simple later on\n if ftype == 'l4':\n time = np.empty((7200,3600))\n time[:,:] = time_read\n tfill = -2147483648\n else:\n time = copy.deepcopy(sst_dtime) # Need to make a hard copy\n mask = sst_dtime.mask == False; mask = mask[0,:,:]\n row, col = np.where(mask==True)\n time.data[0, row, col] = time.data[0,row, col] + time_read\n \n # Create output structure\n if ftype == 'l4':\n data = dict(lon=lon,\n lat=lat,\n time_read=time_read,\n time=time,\n sst=sst,\n unc=unc,\n sea_ice_frac=sea_ice_frac,\n ql=ql,\n tfill=tfill,\n sstfill=sstfill,\n sstao=sstao,\n sstsf=sstsf)\n elif ftype == 'l3c':\n data = dict(lon=lon,\n lat=lat,\n time_read=time_read,\n time=time,\n time_bnds=time_bnds,\n sst=sst,\n sst_depth=sst_depth,\n sst_dtime=sst_dtime,\n sst_depth_dtime=sst_depth_dtime,\n sses_bias=sses_bias,\n sses_sd=sses_sd,\n sst_depth_total_unc=sst_depth_total_unc,\n l2p_flags=l2p_flags,\n ql=ql,\n wind_speed=wind_speed,\n large_scale_cor_unc=large_scale_cor_unc,\n synop_cor_unc=synop_cor_unc,\n uncor_unc=uncor_unc,\n adj_unc=adj_unc,\n aerosol_dyn_ind=aerosol_dyn_ind,\n sens=sens,\n tfill=tfill,\n sstfill=sstfill,\n sstao=sstao,\n sstsf=sstsf)\n else:\n print 'ftype not recognised or supported'\n \n return data","def read_skyh5(\n self, filename, run_check=True, check_extra=True, run_check_acceptability=True\n ):\n with h5py.File(filename, \"r\") as fileobj:\n if \"/Header\" not in fileobj:\n raise ValueError(\"This is not a proper skyh5 file.\")\n\n init_params = {\"filename\": os.path.basename(filename)}\n\n with h5py.File(filename, \"r\") as fileobj:\n # extract header information\n header = fileobj[\"/Header\"]\n header_params = [\n \"_Ncomponents\",\n \"_Nfreqs\",\n \"_component_type\",\n \"_spectral_type\",\n \"_history\",\n \"_name\",\n \"_nside\",\n \"_hpx_order\",\n \"_hpx_inds\",\n \"_freq_array\",\n \"_freq_edge_array\",\n \"_reference_frequency\",\n \"_spectral_index\",\n \"_stokes_error\",\n \"_beam_amp\",\n \"_extended_model_group\",\n ]\n\n optional_params = [\n \"_hpx_order\",\n \"_freq_array\",\n \"_freq_edge_array\",\n \"_reference_frequency\",\n \"_spectral_index\",\n \"_stokes_error\",\n \"_beam_amp\",\n \"_extended_model_group\",\n ]\n\n self.component_type = header[\"component_type\"][()].tobytes().decode(\"utf-8\")\n\n if self.component_type != \"healpix\":\n optional_params.extend([\"_nside\", \"_hpx_inds\"])\n if \"skycoord\" in header:\n skycoord_dict = {}\n for key in header[\"skycoord\"]:\n if key in [\"frame\", \"representation_type\"]:\n expected_type = str\n else:\n expected_type = None\n skycoord_dict[key] = _get_value_hdf5_group(\n header[\"skycoord\"], key, expected_type\n )\n init_params[\"skycoord\"] = SkyCoord(**skycoord_dict)\n else:\n if \"lat\" in header and \"lon\" in header and \"frame\" in header:\n header_params += [\"lat\", \"lon\", \"frame\"]\n optional_params += [\"lat\", \"lon\", \"frame\"]\n elif \"ra\" in header and \"dec\" in header:\n header_params += [\"ra\", \"dec\"]\n optional_params += [\"ra\", \"dec\"]\n else:\n raise ValueError(\n \"No component location information found in file.\"\n )\n warnings.warn(\n \"Parameter skycoord not found in skyh5 file. \"\n \"This skyh5 file was written by an older version of pyradiosky. \"\n \"Consider re-writing this file to ensure future compatibility\"\n )\n else:\n optional_params.append(\"_name\")\n\n if \"hpx_frame\" in header:\n if isinstance(header[\"hpx_frame\"], h5py.Dataset):\n # hpx_frame was stored as a string\n frame_str = _get_value_hdf5_group(header, \"hpx_frame\", str)\n dummy_coord = SkyCoord(0, 0, unit=\"rad\", frame=frame_str)\n init_params[\n \"hpx_frame\"\n ] = dummy_coord.frame.replicate_without_data(copy=True)\n else:\n # hpx_frame was stored as a nested dset\n skycoord_dict = {}\n for key in header[\"hpx_frame\"]:\n if key in [\"frame\", \"representation_type\"]:\n expected_type = str\n else:\n expected_type = None\n skycoord_dict[key] = _get_value_hdf5_group(\n header[\"hpx_frame\"], key, expected_type\n )\n dummy_coord = SkyCoord(0, 0, unit=\"rad\", **skycoord_dict)\n init_params[\n \"hpx_frame\"\n ] = dummy_coord.frame.replicate_without_data(copy=True)\n elif \"frame\" in header:\n # frame was stored as a string\n frame_str = _get_value_hdf5_group(header, \"frame\", str)\n dummy_coord = SkyCoord(0, 0, unit=\"rad\", frame=frame_str)\n init_params[\"hpx_frame\"] = dummy_coord.frame.replicate_without_data(\n copy=True\n )\n\n for par in header_params:\n if par in [\"lat\", \"lon\", \"frame\", \"ra\", \"dec\"]:\n parname = par\n if par == \"frame\":\n expected_type = \"str\"\n else:\n expected_type = Quantity\n else:\n param = getattr(self, par)\n parname = param.name\n expected_type = param.expected_type\n\n # skip optional params if not present\n if par in optional_params:\n if parname not in header:\n continue\n\n if parname not in header:\n raise ValueError(\n f\"Expected parameter {parname} is missing in file.\"\n )\n\n value = _get_value_hdf5_group(header, parname, expected_type)\n\n if parname == \"nside\":\n value = int(value)\n\n init_params[parname] = value\n\n # check that the parameters not passed to the init make sense\n if init_params[\"component_type\"] == \"healpix\":\n if init_params[\"Ncomponents\"] != init_params[\"hpx_inds\"].size:\n raise ValueError(\n \"Ncomponents is not equal to the size of 'hpx_inds'.\"\n )\n else:\n if init_params[\"Ncomponents\"] != init_params[\"name\"].size:\n raise ValueError(\"Ncomponents is not equal to the size of 'name'.\")\n\n if \"freq_array\" in init_params.keys():\n if init_params[\"Nfreqs\"] != init_params[\"freq_array\"].size:\n raise ValueError(\"Nfreqs is not equal to the size of 'freq_array'.\")\n\n if init_params[\"spectral_type\"] == \"subband\":\n if \"freq_edge_array\" not in init_params.keys():\n try:\n init_params[\n \"freq_edge_array\"\n ] = _get_freq_edges_from_centers(\n init_params[\"freq_array\"], self._freq_array.tols\n )\n except ValueError:\n warnings.warn(\n \"No freq_edge_array in this file and frequencies are \"\n \"not evenly spaced, so spectral_type will be set to \"\n \"'full' rather than 'subband'.\"\n )\n init_params[\"spectral_type\"] = \"full\"\n\n # remove parameters not needed in __init__\n init_params.pop(\"Ncomponents\")\n init_params.pop(\"Nfreqs\")\n\n # get stokes array\n dgrp = fileobj[\"/Data\"]\n init_params[\"stokes\"] = dgrp[\"stokes\"] * units.Unit(\n dgrp[\"stokes\"].attrs[\"unit\"]\n )\n # frame is a new parameter, check if it exists and try to read\n # otherwise default to ICRS (the old assumed frame.)\n if \"skycoord\" not in init_params and self.component_type != \"healpix\":\n if \"frame\" in header:\n init_params[\"frame\"] = header[\"frame\"][()].tobytes().decode(\"utf8\")\n else:\n warnings.warn(\n \"No frame available in this file, assuming 'icrs'. \"\n \"Consider re-writing this file to ensure future compatility.\"\n )\n init_params[\"frame\"] = \"icrs\"\n\n if self.component_type == \"healpix\" and \"hpx_frame\" in init_params.keys():\n init_params[\"frame\"] = init_params[\"hpx_frame\"]\n del init_params[\"hpx_frame\"]\n\n if self.component_type == \"healpix\" and \"frame\" not in init_params:\n warnings.warn(\n \"No frame available in this file, assuming 'icrs'. \"\n \"Consider re-writing this file to ensure future compatility.\"\n )\n init_params[\"frame\"] = \"icrs\"\n\n self.__init__(**init_params)\n\n if run_check:\n self.check(\n check_extra=check_extra, run_check_acceptability=run_check_acceptability\n )","def run_main_test():\r\n\r\n print(\"\"\"\r\n +++++++++++++++++++++++++++++++++++++++++++\r\n +++ Performing Main LZJD Full File Test +++\r\n +++++++++++++++++++++++++++++++++++++++++++\r\n \"\"\")\r\n # iterate over the files in the directory\r\n for f in listdir(SRC):\r\n if isfile(join(SRC, f)):\r\n # prepare a dictionary with the digests ready to compare\r\n DIGESTS[f] = {'src': None, 'r2': None, 'ghidra': None}\r\n\r\n # calculate digest of src file\r\n DIGESTS[f]['src'] = digest(join(SRC, f))\r\n\r\n # name adjustment\r\n f2 = f.replace(\".c\", \".o\")\r\n\r\n # calculate digest of ghidra and r2 outputs\r\n DIGESTS[f]['ghidra'] = digest(join(GHIDRA_PATH, GHIDRA_NAME.format(f2)))\r\n DIGESTS[f]['r2'] = digest(join(R2DEC_PATH, R2DEC_NAME.format(f2)))\r\n\r\n # obtain the similarity from source\r\n SCORES[f] = {'ghidra': get_lzjd_sim(DIGESTS[f]['src'], DIGESTS[f]['ghidra']),\r\n 'r2': get_lzjd_sim(DIGESTS[f]['src'], DIGESTS[f]['r2']),\r\n 'x': get_lzjd_sim(DIGESTS[f]['ghidra'], DIGESTS[f]['r2'])}\r\n\r\n gidra_doms = 0\r\n for f in SCORES:\r\n print(\"{0:12}: Scores G:{1:20} R2:{2:20} X:{3:20} D:{4:20}\".format(f,\r\n SCORES[f]['ghidra'],\r\n SCORES[f]['r2'],\r\n SCORES[f]['x'],\r\n SCORES[f]['ghidra'] - SCORES[f]['r2']))\r\n if SCORES[f]['ghidra'] > SCORES[f]['r2']:\r\n gidra_doms += 1\r\n print(\"Ghidra Dominated on {} files\".format(gidra_doms))\r\n # This section of code prepares visualizations on the data for easy analysis\r\n plot_scatter(SCORES, title=\"LZJD Full File scores\")\r\n\r\n # obtian the scores as input data to the plots\r\n bxplt_data_gd = [score['ghidra'] for score in SCORES.values()]\r\n bxplt_data_r2 = [score['r2'] for score in SCORES.values()]\r\n\r\n # run pairwise t test\r\n print(\"Performing T-Test on LZJD Distance of files\")\r\n run_ttest(bxplt_data_gd, bxplt_data_r2)","def time_calibration(input_file):\n original_path = os.getcwd()\n save_path = input_file['save_path']\n #change to save data reduction directory\n os.chdir(save_path)\n print '\\n Reading the list of images ....\\n'\n planet = input_file['exoplanet'] #set exoplanet name\n images = sorted(glob.glob('AB'+planet+'*.fits'))\n print images\n #include de RA,DEC and epoch of the exoplanet\n RA,DEC,epoch = input_file['RA'],input_file['DEC'],input_file['epoch']\n #obtain ST JD using iraf task and introduce in the header\n for i in range(len(images)):\n hdr = fits.getheader(images[i])\n if int(split(hdr['UT'],':')[0]) < int(hdr['timezone']):\n new_date = use.yesterday(hdr['date-obs'])\n #print images[i], new_date\n else:\n new_date = hdr['date-obs']\n year,month,day = split(new_date,'-')\n iraf.asttimes(year=year,month=month,day=day,time=hdr['loctime'],obs=input_file['observatory'])\n JD = iraf.asttimes.jd #obtain julian date\n LMST = iraf.asttimes.lmst #obtain the sideral time\n LMST = use.sexagesimal_format(LMST) #convert sideral time in sexagesimal format\n iraf.hedit(images[i],'ST',LMST,add='yes',verify='no',show='no',update='yes') #create the ST keyword in the header\n iraf.ccdhedit(images[i],'LMST',LMST,type='string') #include the mean sideral time in the header\n iraf.ccdhedit(images[i],'JD',JD,type='string') #include de julian date in the header\n #include RA, and DEC of the object in your header\n iraf.ccdhedit(images[i],\"RA\",RA,type=\"string\") #include right ascention in the header\n iraf.ccdhedit(images[i],\"DEC\",DEC,type=\"string\") #include declination in the header\n iraf.ccdhedit(images[i],\"epoch\",epoch,type=\"string\") #include epoch in the header\n # use.update_progress((i+1.)/len(images))\n print '\\n Setting airmass ....\\n'\n for i in range(len(images)):\n print '# ',images[i]\n #iraf.hedit(images[i],'airmass',airmass,add='yes')\n #iraf.hedit(images[i],'HJD',HJD,add='yes')\n iraf.setairmass.observatory = input_file['observatory']\n iraf.setairmass(images[i])\n iraf.setjd.time = 'ut'\n iraf.setjd(images[i])\n print '\\n.... done.\\n'\n #export information\n hjd, jd, airmass, st = [],[],[],[]\n for i in range(len(images)):\n hdr = fits.getheader(images[i])\n hjd.append(hdr['HJD'])\n jd.append(hdr['JD'])\n airmass.append(hdr['airmass'])\n st.append(hdr['st'])\n #saving the data\n data = DataFrame([list(hjd),list(jd),list(st),list(airmass)]).T\n data.columns = ['HJD','JD','ST','Airmass']\n data.to_csv('results_iraf_calibrations.csv')\n #change to workings directory\n os.chdir(original_path)\n return","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs\"\n \"/lake_analysis_one_21_Jun_2021\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022\")\n ref_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_flowtocell.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_catchments.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_catchments.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_flowtorivermouths.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_flowtorivermouths.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n None,\n #\"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\",\n #additional_matches_list_filename=\\\n #\"additional_matches_ice6g_vs_ice5g_lgm.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='HD')","def optimize_dcr(dg):\n # files to consider. fixme: right now only works with one file\n sto = lh5.Store()\n lh5_dir = os.path.expandvars(dg.config['lh5_dir'])\n raw_list = lh5_dir + dg.fileDB['raw_path'] + '/' + dg.fileDB['raw_file']\n f_raw = raw_list.values[0] \n \n tb_raw = 'ORSIS3302DecoderForEnergy/raw/'\n tb_data = sto.read_object(tb_raw, f_raw)\n \n cycle = dg.fileDB['cycle'].values[0]\n f_results = f'./temp_{cycle}.h5'\n \n write_output = True\n \n # adjust dsp config \n with open('opt_dcr.json') as f:\n dsp_config = json.load(f, object_pairs_hook=OrderedDict)\n # pprint(dsp_config)\n # exit()\n \n # set dcr parameters\n # rise, flat, dcr_tstart = 200, 1000, 'tp_0+1.5*us' # default\n # dcr_rise, dcr_flat, dcr_tstart = 100, 3000, 'tp_0+3*us' # best so far?\n dcr_rise, dcr_flat, dcr_tstart = 100, 2500, 'tp_0+1*us'\n dsp_config['processors']['dcr_raw']['args'][1] = dcr_rise\n dsp_config['processors']['dcr_raw']['args'][2] = dcr_flat\n dsp_config['processors']['dcr_raw']['args'][3] = dcr_tstart\n \n # set trap energy parameters\n # ene_rise, ene_flat = \"2*us\", \"1*us\" # best? from optimize_trap\n ene_rise, ene_flat = \"10*us\", \"5*us\"\n dsp_config['processors']['wf_trap']['args'][1] = ene_rise\n dsp_config['processors']['wf_trap']['args'][2] = ene_flat\n \n # adjust pole-zero constant\n dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '64.4*us'\n # dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '50*us'\n # dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '100*us'\n \n # run dsp\n print('Running DSP ...')\n t_start = time.time()\n pc, tb_out = build_processing_chain(tb_data, dsp_config, verbosity=1)\n pc.execute()\n t_elap = (time.time() - t_start)/60\n print(f'Done. Elapsed: {t_elap:.2f} min')\n \n df_out = tb_out.get_dataframe()\n \n if write_output:\n df_out.to_hdf(f_results, key='opt_dcr')\n print('Wrote output file:', f_results)","def vorticity(tsr,solidity):\n \n # Reading in csv file (vorticity database)\n basepath = path.join(path.dirname(path.realpath(__file__)),'data')\n fdata = basepath + path.sep + 'vortdatabase.csv'\n f = open(fdata)\n csv_f = csv.reader(f)\n \n i = 0\n sol_d = np.array([])\n for row in csv_f:\n if i == 0:\n raw = row\n raw = np.delete(raw,0)\n vortdat = raw\n tsr_d = raw # range of tip-speed ratios included\n if row[0] == 'solidity':\n sol_d = np.append(sol_d,float(row[1])) # range of solidities included\n elif row[0] != 'TSR' and row[0] != 'solidity':\n raw = row\n raw = np.delete(raw,0)\n vortdat = np.vstack([vortdat,raw]) # adding entry to vorticity database array\n i += 1\n f.close()\n \n vortdat = np.delete(vortdat,(0),axis=0) # eliminating first row used as a placeholder\n tsr_d = tsr_d.astype(np.float) # converting tip-speed ratio entries into floats\n vortdat = vortdat.astype(np.float) # converting vorticity database entries into floats\n \n # Creating arrays for each EMG parameter\n for i in range(np.size(sol_d)):\n sol = str(i+1)\n \n exec('s'+sol+'_loc1 = vortdat[i*10]\\ns'+sol+'_loc2 = vortdat[i*10+1]\\ns'+sol+'_loc3 = vortdat[i*10+2]\\ns'+sol+'_spr1 = vortdat[i*10+3]\\ns'+sol+'_spr2 = vortdat[i*10+4]\\ns'+sol+'_skw1 = vortdat[i*10+5]\\ns'+sol+'_skw2 = vortdat[i*10+6]\\ns'+sol+'_scl1 = vortdat[i*10+7]\\ns'+sol+'_scl2 = vortdat[i*10+8]\\ns'+sol+'_scl3 = vortdat[i*10+9]\\n')\n \n # BIVARIATE SPLINE FITTING\n \n iz = np.size(sol_d)\n jz = np.size(tsr_d)\n \n # Initializing rectangular matrices\n Z_loc1 = np.zeros((iz,jz))\n Z_loc2 = np.zeros((iz,jz))\n Z_loc3 = np.zeros((iz,jz))\n Z_spr1 = np.zeros((iz,jz))\n Z_spr2 = np.zeros((iz,jz))\n Z_skw1 = np.zeros((iz,jz))\n Z_skw2 = np.zeros((iz,jz))\n Z_scl1 = np.zeros((iz,jz))\n Z_scl2 = np.zeros((iz,jz))\n Z_scl3 = np.zeros((iz,jz))\n \n # Transferring raw data into rectangular matrices\n for i in range(iz):\n for j in range(jz):\n sol = str(i+1)\n exec('Z_loc1[i,j] = s'+sol+'_loc1[j]')\n exec('Z_loc2[i,j] = s'+sol+'_loc2[j]')\n exec('Z_loc3[i,j] = s'+sol+'_loc3[j]')\n exec('Z_spr1[i,j] = s'+sol+'_spr1[j]')\n exec('Z_spr2[i,j] = s'+sol+'_spr2[j]')\n exec('Z_skw1[i,j] = s'+sol+'_skw1[j]')\n exec('Z_skw2[i,j] = s'+sol+'_skw2[j]')\n exec('Z_scl1[i,j] = s'+sol+'_scl1[j]')\n exec('Z_scl2[i,j] = s'+sol+'_scl2[j]')\n exec('Z_scl3[i,j] = s'+sol+'_scl3[j]')\n \n # Creating a rectangular bivariate spline of the parameter data\n s_loc1 = RectBivariateSpline(sol_d,tsr_d,Z_loc1)\n s_loc2 = RectBivariateSpline(sol_d,tsr_d,Z_loc2)\n s_loc3 = RectBivariateSpline(sol_d,tsr_d,Z_loc3)\n s_spr1 = RectBivariateSpline(sol_d,tsr_d,Z_spr1)\n s_spr2 = RectBivariateSpline(sol_d,tsr_d,Z_spr2)\n s_skw1 = RectBivariateSpline(sol_d,tsr_d,Z_skw1)\n s_skw2 = RectBivariateSpline(sol_d,tsr_d,Z_skw2)\n s_scl1 = RectBivariateSpline(sol_d,tsr_d,Z_scl1)\n s_scl2 = RectBivariateSpline(sol_d,tsr_d,Z_scl2)\n s_scl3 = RectBivariateSpline(sol_d,tsr_d,Z_scl3)\n \n # Selecting the specific parameters to use for TSR and solidity\n loc1 = s_loc1(solidity,tsr)\n loc2 = s_loc2(solidity,tsr)\n loc3 = s_loc3(solidity,tsr)\n spr1 = s_spr1(solidity,tsr)\n spr2 = s_spr2(solidity,tsr)\n skw1 = s_skw1(solidity,tsr)\n skw2 = s_skw2(solidity,tsr)\n scl1 = s_scl1(solidity,tsr)\n scl2 = s_scl2(solidity,tsr)\n scl3 = s_scl3(solidity,tsr)\n \n # Creating arrays of the parameters\n loc = np.array([loc1[0,0],loc2[0,0],loc3[0,0]])\n spr = np.array([spr1[0,0],spr2[0,0]])\n skw = np.array([skw1[0,0],skw2[0,0]])\n scl = np.array([scl1[0,0],scl2[0,0],scl3[0,0]])\n \n return loc,spr,skw,scl","def main() -> int:\n ucvm_out = \"\"\n for j in frange(CORNERS[\"bl\"][\"n\"], CORNERS[\"ur\"][\"n\"], SPACING):\n for i in frange(CORNERS[\"bl\"][\"e\"], CORNERS[\"ur\"][\"e\"] + SPACING, SPACING):\n ucvm_out += \"%.2f %.2f 0\\n\" % (i, j)\n os.chdir(\"/Users/davidgil/ucvm-15.10.0/bin\")\n proc = Popen(\n [\"./ucvm_query\", \"-f\", \"../conf/ucvm.conf\"], stdout=PIPE, stdin=PIPE, stderr=STDOUT\n )\n out_arr = np.zeros(\n shape=(\n int((CORNERS[\"ur\"][\"n\"] - CORNERS[\"bl\"][\"n\"]) / SPACING) + 2,\n int((CORNERS[\"ur\"][\"e\"] - CORNERS[\"bl\"][\"e\"]) / SPACING) + 2\n )\n )\n output = proc.communicate(input=ucvm_out.encode(\"ASCII\"))[0]\n i = 0\n j = 0\n for line in output.decode(\"ASCII\").split(\"\\n\")[2:-1]:\n line_split = line.split()\n try:\n out_arr[j][i] = float(line_split[4])\n except IndexError:\n print(line_split)\n if i == int((CORNERS[\"ur\"][\"e\"] - CORNERS[\"bl\"][\"e\"]) / SPACING):\n i = 0\n j += 1\n else:\n i += 1\n np.save(\"vs30.dat\", out_arr)\n return 0","def run(config, tim=None):\n import common_lib\n import dr_lib\n import DST\n \n if tim is not None:\n tim.getTime(False)\n old_time = tim.getOldTime()\n\n if config.data is None:\n raise RuntimeError(\"Need to pass a data filename to the driver \"\\\n +\"script.\")\n\n # Read in geometry if one is provided\n if config.inst_geom is not None:\n if config.verbose:\n print \"Reading in instrument geometry file\"\n \n inst_geom_dst = DST.getInstance(\"application/x-NxsGeom\",\n config.inst_geom)\n else:\n inst_geom_dst = None\n\n config.so_axis = \"time_of_flight\"\n\n # Steps 1-3: Produce a scaled summed dark current dataset\n dc_som = dr_lib.scaled_summed_data(config.dkcur, config,\n dataset_type=\"dark_current\",\n timer=tim)\n\n # Perform Steps 3-6 on black can data\n if config.bcan is not None:\n b_som1 = dr_lib.calibrate_dgs_data(config.bcan, config, dc_som,\n dataset_type=\"black_can\",\n inst_geom_dst=inst_geom_dst,\n tib_const=config.tib_const,\n cwp=config.cwp_bcan,\n timer=tim)\n else:\n b_som1 = None\n\n # Perform Steps 3-6 on empty can data \n if config.ecan is not None:\n e_som1 = dr_lib.calibrate_dgs_data(config.ecan, config, dc_som,\n dataset_type=\"empty_can\",\n inst_geom_dst=inst_geom_dst,\n tib_const=config.tib_const,\n cwp=config.cwp_ecan,\n timer=tim)\n else:\n e_som1 = None\n\n # Perform Steps 3-6 on normalization data\n n_som1 = dr_lib.calibrate_dgs_data(config.data, config, dc_som,\n dataset_type=\"normalization\",\n inst_geom_dst=inst_geom_dst,\n tib_const=config.tib_const,\n cwp=config.cwp_data,\n timer=tim)\n\n # Perform Steps 7-16 on normalization data\n if config.norm_trans_coeff is None:\n norm_trans_coeff = None\n else:\n norm_trans_coeff = config.norm_trans_coeff.toValErrTuple()\n\n # Determine if we need to rebin the empty or black can data\n if config.ecan is not None and e_som1 is not None:\n ecan_cwp = True\n else:\n ecan_cwp = False\n\n if config.bcan is not None and b_som1 is not None:\n bcan_cwp = True\n else:\n bcan_cwp = False \n\n cwp_used = ecan_cwp or bcan_cwp\n\n n_som2 = dr_lib.process_dgs_data(n_som1, config, b_som1, e_som1,\n norm_trans_coeff,\n dataset_type=\"normalization\",\n cwp_used=cwp_used,\n timer=tim)\n \n del n_som1, b_som1, e_som1\n\n # Step 17: Integrate normalization spectra\n if config.verbose:\n print \"Integrating normalization spectra\"\n\n if tim is not None:\n tim.getTime(False)\n\n if config.norm_int_range is None:\n start_val = float(\"inf\")\n end_val = float(\"inf\")\n else:\n if not config.wb_norm:\n # Translate energy transfer to final energy\n ef_start = config.initial_energy.getValue() - \\\n config.norm_int_range[0]\n ef_end = config.initial_energy.getValue() - \\\n config.norm_int_range[1]\n # Convert final energy to final wavelength\n start_val = common_lib.energy_to_wavelength((ef_start, 0.0))[0]\n end_val = common_lib.energy_to_wavelength((ef_end, 0.0))[0]\n else:\n start_val = config.norm_int_range[0]\n end_val = config.norm_int_range[1]\n \n n_som3 = dr_lib.integrate_spectra(n_som2, start=start_val,\n end=end_val, width=True)\n\n del n_som2\n \n if tim is not None:\n tim.getTime(msg=\"After integrating normalization spectra \")\n\n file_comment = \"Normalization Integration range: %0.3fA, %0.3fA\" \\\n % (start_val, end_val)\n \n hlr_utils.write_file(config.output, \"text/num-info\", n_som3,\n output_ext=\"norm\",\n data_ext=config.ext_replacement,\n path_replacement=config.path_replacement,\n verbose=config.verbose,\n message=\"normalization values\",\n comments=[file_comment],\n tag=\"Integral\", units=\"counts\") \n \n if tim is not None:\n tim.getTime(False)\n\n if config.verbose:\n print \"Making mask file\"\n\n # Make mask file from threshold\n dr_lib.filter_normalization(n_som3, config.lo_threshold,\n config.hi_threshold, config)\n\n if tim is not None:\n tim.getTime(msg=\"After making mask file \")\n\n # Write out RMD file\n n_som3.attr_list[\"config\"] = config\n\n hlr_utils.write_file(config.output, \"text/rmd\", n_som3,\n output_ext=\"rmd\",\n data_ext=config.ext_replacement, \n path_replacement=config.path_replacement,\n verbose=config.verbose,\n message=\"metadata\")\n \n if tim is not None:\n tim.setOldTime(old_time)\n tim.getTime(msg=\"Total Running Time\")","def test_fill_data(self):\n self.full_iv.get_data()\n df_iv = self.full_iv.calc_iv()\n\n self.assertTrue(len(df_iv))\n\n db = pd.HDFStore('test.h5')\n db['iv'] = df_iv\n db.close()","def test_compute_Sv_ek80_CW_power_BB_complex(ek80_path):\n ek80_raw_path = ek80_path / \"Summer2018--D20180905-T033113.raw\"\n ed = ep.open_raw(ek80_raw_path, sonar_model=\"EK80\")\n ds_Sv = ep.calibrate.compute_Sv(\n ed, waveform_mode=\"CW\", encode_mode=\"power\"\n )\n assert isinstance(ds_Sv, xr.Dataset)\n ds_Sv = ep.calibrate.compute_Sv(\n ed, waveform_mode=\"BB\", encode_mode=\"complex\"\n )\n assert isinstance(ds_Sv, xr.Dataset)","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_one_21_Jun_2021/rivers/results/\"\n \"default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022/\"\n \"rivers/results/diag_version_32_date_0_with_truesinks\")\n ref_filename=os.path.join(ref_base_dir,\"10min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\"10min_flowtocell.nc\")\n #lsmask_filename=os.path.join(self.plots_data_dir,\n # \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n lsmask_filename=None\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"10min_catchments_ext.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"10min_catchments_ext.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"10min_rdirs.nc\")\n data_rdirs_filename=os.path.join(data_base_dir,\n \"10min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"10min_rmouth_flowtocell.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"10min_rmouth_flowtocell.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=20*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=20*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=5*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=5*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=2*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')","def test_calc_SR5():\n tb = TradeBot(\n pair='GBP_JPY',\n timeframe='D',\n start='2018-12-20 22:00:00',\n end='2019-01-17 22:00:00',\n settingf=\"../../data/settings.ini\"\n )\n\n harealst = tb.calc_SR(datetime.datetime(2019, 1, 7, 22, 0))\n\n assert len(harealst.halist) == 6\n assert 0","def read_inversion_info(file_dic):\n #print_file_test = open('file_test.txt','w')\n\n if not ( check_inversion_files(file_dic) ):\n print 'error(read_inversion_info): problem with lenstool file names'\n return 0\n \n file_generate_arcs = file_dic['file_generate_arcs']\n info_input_lens = fc.extract_second_identifiers( file_generate_arcs, \\\n 'potential' )\n#-------------------------------------------------------------------------------\n\n file_source = file_dic['file_source']\n info_src = np.loadtxt(file_source, unpack=False)\n if len(info_src) == 8 and np.isscalar(info_src[0]):\n #FIXME - check if the second condition is all we need\n info_src = [info_src]\n#-------------------------------------------------------------------------------\n\n file_make_inversion = file_dic['file_make_inversion']\n info_fited_param = fc.extract_second_identifiers( file_make_inversion, \\\n 'limit' )\n info_forme = fc.extract_parameter(file_make_inversion, 'forme')[0][0]\n\n#-------------------------------------------------------------------------------\n\n file_best_fit = file_dic['file_best_fit']\n info_best_fit = fc.extract_second_identifiers( file_best_fit, \\\n 'potentiel' )\n\n info_xi2 = fc.extract_parameter(file_best_fit, '#Chi2pos:')\n\n#-------------------------------------------------------------------------------\n file_chires = file_dic['file_chires']\n\n info_chires = extract_parameter(file_chires, '0')\n rmss_mean = [0.0, 0.0]\n rmsi_mean = [0.0, 0.0]\n for i in info_chires:\n if i[0] != 'A':\n rmss_mean[0] = rmss_mean[0] + float(i[7])\n rmss_mean[1] = rmss_mean[1] + 1.0\n \n rmsi_mean[0] = rmsi_mean[0] + float(i[8])\n rmsi_mean[1] = rmsi_mean[1] + 1.0\n\n rmss_mean = rmss_mean[0]/rmss_mean[1]\n rmsi_mean = rmsi_mean[0]/rmsi_mean[1]\n#-------------------------------------------------------------------------------\n out_dict = { 'xi2' : float(info_xi2[0][0]), \\\n 'best_fit_lens' : info_best_fit, \\\n 'rmsi_mean' : rmsi_mean, \\\n 'rmss_mean' : rmss_mean, \\\n 'fited_parameters' : info_fited_param[0].keys(), \\\n 'input_lens' : info_input_lens[len(info_input_lens) - 1], \\\n 'forme' : info_forme \\\n }\n #for i in out_dict.keys():\n # print i, out_dict[i]\n return out_dict","def test_data_handling_nc_cc():\n\n input_files = [os.path.join(TEST_DATA_DIR, 'ua_test.nc'),\n os.path.join(TEST_DATA_DIR, 'va_test.nc'),\n os.path.join(TEST_DATA_DIR, 'orog_test.nc'),\n os.path.join(TEST_DATA_DIR, 'zg_test.nc')]\n\n with xr.open_mfdataset(input_files) as fh:\n min_lat = np.min(fh.lat.values)\n min_lon = np.min(fh.lon.values)\n target = (min_lat, min_lon)\n plevel = fh.plev[-1]\n ua = np.transpose(fh['ua'][:, -1, ...].values, (1, 2, 0))\n va = np.transpose(fh['va'][:, -1, ...].values, (1, 2, 0))\n\n handler = DataHandlerNCforCC(input_files, features=['U_100m', 'V_100m'],\n target=target, shape=(20, 20),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n assert handler.data.shape == (20, 20, 20, 2)\n\n handler = DataHandlerNCforCC(input_files,\n features=[f'U_{int(plevel)}pa',\n f'V_{int(plevel)}pa'],\n target=target, shape=(20, 20),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n if handler.invert_lat:\n handler.data = handler.data[::-1]\n assert handler.data.shape == (20, 20, 20, 2)\n assert np.allclose(ua, handler.data[..., 0])\n assert np.allclose(va, handler.data[..., 1])","def test_cambridge_rent_price_per_sqft():\n dataframe = get_final_zillow_dataframe()\n cambridge = get_city_state_row(dataframe, 'cambridge', 'massachusetts')\n assert round(cambridge.iloc[0].get('ZRIFAH'), 1) == 2.9","def test_3d_steam_time():\n dic,data = ng.pipe.read(\"common_data/3d_pipe/full3D.fid\")\n assert data.shape == (128, 88, 1250)\n assert data.dtype == 'complex64'\n assert round(data[0,1,2].real,2) == -7.98\n assert round(data[0,1,2].imag,2) == 33.82\n assert round(data[10,22,5].real,2) == 15.71\n assert round(data[10,22,5].imag,2) == 15.1\n write_readback(dic,data)","def test_CCI_SM_v033_025Ds_img_reading():\n parameter = ['sm']\n data_path = os.path.join(os.path.dirname(__file__), \"esa_cci_sm-test-data\",\n \"esa_cci_sm_dailyImages\", \"v03.3\", \"combined\")\n img_c = CCI_SM_025Ds(data_path=data_path, parameter=parameter,\n subgrid=None, array_1D=False)\n\n image_c = img_c.read(datetime(2016, 1, 1, 0))\n\n assert sorted(image_c.data.keys()) == sorted(parameter)\n assert image_c.timestamp == datetime(2016, 1, 1, 0)\n nptest.assert_almost_equal(image_c.data['sm'][273, 693], 0.142998, 5)\n assert image_c.lon.shape == image_c.lat.shape == (720, 1440)\n\n\n data_path = os.path.join(os.path.dirname(__file__), \"esa_cci_sm-test-data\",\n \"esa_cci_sm_dailyImages\", \"v03.3\", \"active\")\n img_a = CCI_SM_025Ds(data_path=data_path, parameter=parameter, subgrid=None,\n array_1D=False)\n image_a = img_a.read(datetime(2016, 1, 1, 0))\n\n assert sorted(image_a.data.keys()) == sorted(parameter)\n assert image_a.timestamp == datetime(2016, 1, 1, 0)\n nptest.assert_almost_equal(image_a.data['sm'][273, 693], 18.92771, 5)\n assert image_a.lon.shape == image_a.lat.shape == (720, 1440)\n\n\n data_path = os.path.join(os.path.dirname(__file__), \"esa_cci_sm-test-data\",\n \"esa_cci_sm_dailyImages\", \"v03.3\", \"passive\")\n img_p = CCI_SM_025Ds(data_path=data_path, parameter=parameter, subgrid=None,\n array_1D=False)\n\n image_p = img_p.read(datetime(2016, 1, 1, 0))\n\n assert sorted(image_p.data.keys()) == sorted(parameter)\n assert image_p.timestamp == datetime(2016, 1, 1, 0)\n nptest.assert_almost_equal(image_p.data['sm'][273, 693], 0.0700, 5)\n\n assert image_p.lon.shape == image_p.lat.shape == (720, 1440)","def compute_contrast_sphere_offline(path_raw,path_reduced,path_output,debug=True):\r\n try:\r\n if not type(path_raw) is PosixPath:\r\n path_raw = Path(path_raw)\r\n if type(path_reduced) is PosixPath:\r\n path_reduced = Path(path_reduced)\r\n if not type(path_raw) is PosixPath:\r\n path_output = Path(path_output) \r\n for path in [path_raw,path_reduced]:\r\n if not path.exists():\r\n print('The input path {0:s} does not exists. Returning'.format(str(path)))\r\n return\r\n if not path_output.exists():\r\n path_output.mkdir()\r\n except:\r\n print(sys.exc_info()[0])\r\n \r\n \r\n #%% Step 0 : \r\n # Load all raw frames and list the original filename, along with the type \r\n # and archive names\r\n\r\n raw_files = []\r\n raw_archive_names = []\r\n raw_dpr_types = []\r\n \r\n files_sphere_raw = sorted(path_raw.glob('SPHERE*IRDIS*OBS*fits'))\r\n for file in files_sphere_raw:\r\n try:\r\n h=fits.getheader(file)\r\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR'] and 'IRDIS' in h['HIERARCH ESO SEQ ARM']: \r\n raw_files.append(files_sphere_raw)\r\n raw_archive_names.append(h['ARCFILE'])\r\n raw_dpr_types.append(h['HIERACH ESO DPR TYPE'])\r\n except:\r\n continue\r\n \r\n\r\n #%% Step 1 : \r\n \r\n # You look for all reduced frames that correspond to \r\n # coronagraphic data with PRO.CATG as \r\n # - IRD_SCIENCE_DBI_LEFT_CUBE \r\n # - IRD_SCIENCE_DBI_RIGHT_CUBE\r\n # - IRD_STAR_CENTER\r\n \r\n files_sphere_reduced = sorted(path_reduced.glob('r.SPHER*.fits'))\r\n reduced_files_dbi_left = [] \r\n raw_files_dbi_left = [] # careful !! This is not the raw file name as saved in raw/date/\r\n \r\n reduced_files_dbi_right = []\r\n raw_files_dbi_right = []\r\n \r\n for file in files_sphere_reduced:\r\n try:\r\n h=fits.getheader(file)\r\n # check whether this is a coronagraphic frame\r\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR']:\r\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_LEFT_CUBE':\r\n reduced_files_dbi_left.append(file)\r\n raw_files_dbi_left.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\r\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_RIGHT_CUBE':\r\n reduced_files_dbi_right.append(file)\r\n raw_files_dbi_right.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\r\n except:\r\n continue\r\n\r\n \r\n \r\n #%% Step 2: \r\n # You isolate for each raw frames one single reduced left and right cube \r\n # (currently the pipeline does multiple reductions of the same raw cube for \r\n # an unknown reason, we need to get rid of the duplicates here).\r\n \r\n unique_reduced_files_dbi_left,indices = np.unique(reduced_files_dbi_left,return_index=True)\r\n unique_raw_files_dbi_left = [raw_files_dbi_left[i] for i in indices]\r\n \r\n unique_reduced_files_dbi_right,indices = np.unique(reduced_files_dbi_right,return_index=True)\r\n unique_raw_files_dbi_right = [raw_files_dbi_right[i] for i in indices]\r\n \r\n \r\n #%% Step 3\r\n # You extract DIT, NDIT, NAXIS3, coronagraph name:\r\n # Lyot stop: HIERARCH ESO INS1 OPTI1 NAME\r\n # Lyot mask: HIERARCH ESO INS4 OPTI11 NAME\r\n # coro combination name: HIERARCH ESO INS COMB ICOR\r\n # along with the ND filter and the IRDIS filter from each RAW frame.\r\n # Also extract all info that will be useful later for the analysis:\r\n # star name and magnitude, airmass, seeing, coherence time, telescope Seeing...)\r\n # This is important to do that on each raw frame on not on each reduced frame\r\n # as the keywords are changed by the pipeline and unreliable.\r\n \r\n \r\n \r\n #%% Step 4\r\n # Assoiate each FLUX with a CORONAGRAPHIC image\r\n \r\n \r\n \r\n #%% Step 5\r\n # Work on the Flux frame first:\r\n # - Detect the central star\r\n # - measure the FWHM, validate that this is the star by checking the FWHM\r\n # (should be the diffraction limit)\r\n # - aperture photometry on the star using a diameter of 1 lambda/D \r\n # - divide the flux by the DIT and correct by the ND transmission: this\r\n # gives you the star reference flux\r\n \r\n \r\n #%% Step 6\r\n # Work on the coronographic frame now:\r\n # - Detect the coronagraphic center.\r\n # - compute the contrast (using the standard deviation of many apertures \r\n # place at a given separation, using for instance the python module VIP)\r\n\r\n\r\n #%% Step 7:\r\n # Divide the azinuthal standard deviations by the star reference flux to obtain\r\n # the contrast as a function of radius. \r\n # Plot the result and save in a csv file along with all relevant parameters \r\n # for the analysis (coronagraph name, star magnitude, airmass, seeing, coherence time)\r","def initialize_data(self , station = '', datasets = {} ): \n self.datasets = datasets\n self.datasets_keys = datasets.keys()\n self.station = station\n self.out_name = self.out_dir + '/' + self.station + '_CEUAS_premerged_v0.nc'\n\n self.observations_table_vars = ['date_time', 'z_coordinate' , 'z_coordinate_type', 'observed_variable' , 'observation_value' , 'report_id' , 'observation_id' , 'latitude' , 'longitude', 'units', 'source_id']\n\n \"\"\" Loading the econding of the tables created from the harvester script and to be applied again \"\"\"\n self.encodings = np.load('groups_encodings.npy' , allow_pickle = True ).item()\n self.encodings['era5fb'] = np.load('era5fb_encodings_all.npy' , allow_pickle = True ).item() \n self.dic_type_attributes = np.load('dic_type_attributes.npy',allow_pickle= True).item()\n \n self.era5fb_columns = self.dic_type_attributes['era5fb'].keys()\n\n self.obstab_nans_filled = False \n\n data['cdm_tables'] = {} \n \n \"\"\" Loop over all the datasets \n k: name of the dataset \n v: list of file paths, eg 'era5_1':[filepath_1, filepath_2 ] \"\"\" \n for k,v in self.datasets.items() :\n data[k] = {}\n for F in v:\n \n logging.info(' Dataset ::: *** %s %s ' , k , F ) \n \n data[k][F] = {}\n\n h5py_file = h5py.File(F, 'r')\n data[k][F]['h5py_file'] = h5py_file \n \n a = h5py_file['recordtimestamp']\n \n data[k][F]['recordtimestamp'] = a\n data[k][F]['recordindex'] = h5py_file['recordindex']\n data[k][F]['dateindex'] = h5py_file['dateindex']\n a = h5py_file['recordtimestamp']\n data[k][F]['max_date'] = max(a)\n data[k][F]['min_date'] = min(a)\n \n data[k][F]['counter'] = 0\n\n #######\n # HEADER TABLE\n #######\n head_tab = h5py_file['header_table']\n logging.info('*** header_table')\n data[k][F]['header_table'] = {}\n for var in head_tab.keys():\n if ('string' in var or 'hdrlen' in var): continue\n try: \n data[k][F]['header_table'][var] = (np.array(head_tab[var][:])).astype(self.dic_type_attributes['header_table'][var]['type'] )\n except:\n print('failed convertion type header' , k , ' ' , F , ' ' , var )\n \n ####### \n # STATION CONFIGURATION\n ####### \n d = xr.open_dataset(F , engine = 'h5netcdf' , group = 'station_configuration' , decode_times = False )\n data[k][F]['station_configuration'] = d.to_dataframe()\n logging.debug('Done with %s station_configuration' , str(k) )\n d.close()\n\n ####### \n # SOURCE CONFIGURATION \n ####### \n d = xr.open_dataset(F , engine = 'h5netcdf' , group = 'source_configuration' , decode_times = False )\n data[k][F]['source_configuration'] = d\n logging.debug('Done with %s source_configuration' , str(k) )\n d.close()\n\n\n data['cdm_tables'] = {}\n \"\"\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \"\"\"\n for t in self.standard_cdm: # [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type', 'station_configuration_codes'] \n if t not in data['cdm_tables'].keys():\n #data['cdm_tables'][t] = ''\n cdm = xr.open_dataset(F , engine = 'h5netcdf' , group = t )\n data['cdm_tables'][t] = cdm \n\n print(blue + 'Memory used after reading data: ', process.memory_info().rss/1000000000 , cend)\n\n self.data = data\n\n \"\"\" Making all date_times \"\"\"\n self.make_all_datetime()","def Read_Spectrum(Path,borne1 = 0,borne2 = 0) :\n x,y=[],[]\n fs = open(Path, 'r')\n #print('Open new fic') \n#index_array = 0\n while 1: \n txt = fs.readline()\n #print(txt)\n if ((txt =='')|(txt == '\\r\\n')): \n break\n #print(txt)\n ii=-1\n while 1: # on cherche le premier espace qui limite le premier nombre\n ii = ii+1\n #print(ii)\n if ((txt[ii] == ' ') |(txt[ii] == '\\t')):\n break\n \n x.append(float(txt[0:ii]))\n y.append(float(txt[ii:])) \n# if len(txt) == 21 : #nu >= 10000 cm-1\n# x.append(float(txt[0:11]))\n# y.append(float(txt[11:]))\n# elif len(txt) == 20 : #nu >= 1000 cm-1\n# x.append(float(txt[0:10]))\n# y.append(float(txt[10:]))\n# elif len(txt) == 19 : #nu >= 100 cm-1\n# x.append(float(txt[0:9]))\n# y.append(float(txt[9:]))\n# elif len(txt) == 18 : #nu >= 10 cm-1\n# x.append(float(txt[0:8]))\n# y.append(float(txt[8:]))\n# elif len(txt) == 17 : #nu >= 1 cm-1\n# x.append(float(txt[0:7]))\n# y.append(float(txt[7:]))\n\n #x[index_array],y[index_array] = float(txt[0:9]),float(txt[10:17])\n #index_array = index_array+1\n \n fs.close()\n x = np.array(x)\n y = np.array(y)\n if ((borne1 == 0) & (borne2 == 0)) :\n pass \n else :\n index_ok = ((x<borne2) & (x>borne1))\n x = x[index_ok]\n y = y[index_ok]\n\n return x,y","def analyzeViSDEMData(dict):\n \n if 'path_in' in dict:\n path_in = dict['path_in']\n else:\n print(\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\") \n return\n \n path_out_default = '../colordeficiency-data/' \n if 'path_out' in dict:\n path_out = dict['path_out']\n else:\n print(\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \"+str(path_out_default))\n path_out = path_out_default\n \n if 'round' in dict:\n round = dict['round']\n else:\n print(\"Error: You have to chose a round first.\")\n \n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\n \n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\n if round == 1:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids.csv\")\n elif round == 2:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids_2.csv\")\n \n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\";\")\n \n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\n observer_ids = os.path.join(path,\"observer_ids.csv\")\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\";\")\n \n # 1. Step: Read all the XLSX data in the path\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\n dataArray = pandas.DataFrame()\n i=1\n for xlsx_file in xlsx_files:\n sys.stdout.write(xlsx_file)\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\n \n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\n \n if \"2. Session\" in extraDataDict:\n sessionID = int(extraDataDict['2. Session'])\n newDataArray['session_id'] = sessionID\n \n if 'group' in extraDataDict:\n obsGroup = str(extraDataDict['group'])\n newDataArray['obsGroup'] = obsGroup\n \n if '0. Participant ID' in extraDataDict:\n obsID = int(extraDataDict['0. Participant ID'])\n \n newDataArray['observer_id'] = obsID\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\n \n dataArray = pandas.concat([dataArray, newDataArray])\n sys.stdout.write(' . ')\n if (i%5)==0: sys.stdout.write('\\n')\n i+=1\n sys.stdout.write('\\n')\n \n # 2. Step: Adapt values to programstandards\n for item in settings.colDefLong2ID:\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\n \n for item in settings.dalt2ID:\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\n \n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\n \n \n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\n 'coldef_type': 'coldef_type',\n 'resp.corr_raw': 'is_correct',\n 'resp.rt_raw': 'resp_time',\n 'stimFile': 'filepath'})\n dataArray = dataArray.reset_index()\n \n # Adding set_id, motive_id and variant_id to each file\n for index, row in dataArray.iterrows():\n path_tmp = row['filepath']\n filename = os.path.basename(path_tmp).split('.')[0]\n dict_tmp = getStatsFromFilename(filename)\n imgID_tmp = int(dict_tmp['img_id'])\n \n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\n \n dataArray.at[index,'image_id'] = imgID_tmp\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\n\n dataArray.image_id = dataArray.image_id.astype(int)\n dataArray.set_id = dataArray.set_id.astype(int)\n dataArray.motive_id = dataArray.motive_id.astype(int)\n dataArray.variant_id = dataArray.variant_id.astype(int)\n dataArray.is_correct = dataArray.is_correct.astype(bool)\n \n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\n \n # 3. Saving data to file\n try:\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\";\")\n sys.stdout.write(\"Success: ViSDEM data successfully saved in '\"+str(path_out)+\"'.\\n\")\n except Exception as e:\n print(e)","def execute(self, in_nc, in_weight_table, out_nc, grid_name, conversion_flag, in_time_interval=\"6hr\"): # modified this line CJB 20190218\r\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\r\n # and upstream correction of the cdo grid conversion units attribute.\r\n\r\n # Validate the netcdf dataset\r\n vars_oi_index = self.dataValidation(in_nc)\r\n \r\n \"\"\"get conversion factor the flag is used to differentiate forecasts converted \r\n to netCDF from GRIB and the original netCDF. They both use the same weight tables\r\n but the original netCDF is in mm whereas the stock GRIB forecasts are in meters.\r\n Set the conversion_flag in the run.py configuration file.\r\n \"\"\"\r\n if conversion_flag: # Line Added CJB 20190218\r\n conversion_factor = 1.0 #Line Modified CJB 20190218\r\n elif grid_name == 'ecmwf_t1279' or grid_name == 'ecmwf_tco639': # Line Modified CJB 20190218\r\n #if grid_name == 'ecmwf_HRES_F' or grid_name == 'ecmwf_ENS_F': # Line Added/Modified CJB 20190108\r\n #new grids in mm instead of m\r\n conversion_factor = 0.001\r\n else: #set the conversion factor to 1 for everything else (data is in m but legacy installations do not have a flag) Line Added CJB 20190218\r\n conversion_factor = 1.0 # Line Added CJB 20190218\r\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\r\n # and upstream correction of the cdo grid conversion units attribute.\r\n # identify if the input netcdf data is the High Resolution data with three different time intervals\r\n id_data = self.dataIdentify(in_nc)\r\n if id_data is None:\r\n raise Exception(self.errorMessages[3])\r\n\r\n ''' Read the netcdf dataset'''\r\n data_in_nc = NET.Dataset(in_nc)\r\n time = data_in_nc.variables['time'][:]\r\n\r\n # Check the size of time variable in the netcdf data\r\n if len(time) == 0: # *** MJS This change seems like it is too loose an error trap; should it account for instances when nc file time var is != in length with id_data lenght?\r\n raise Exception(self.errorMessages[3])\r\n #if len(time) != self.length_time[id_data]:\r\n # raise Exception(self.errorMessages[3])\r\n\r\n ''' Read the weight table '''\r\n print(\"Reading the weight table...\", in_weight_table)\r\n dict_list = {self.header_wt[0]:[], self.header_wt[1]:[], self.header_wt[2]:[],\r\n self.header_wt[3]:[], self.header_wt[4]:[]}\r\n\r\n with open(in_weight_table, \"r\") as csvfile:\r\n reader = csv.reader(csvfile)\r\n count = 0\r\n for row in reader:\r\n if count == 0:\r\n #check number of columns in the weight table\r\n if len(row) < len(self.header_wt):\r\n raise Exception(self.errorMessages[4])\r\n #check header\r\n if row[1:len(self.header_wt)] != self.header_wt[1:]:\r\n raise Exception(self.errorMessages[5])\r\n count += 1\r\n else:\r\n for i in range(len(self.header_wt)):\r\n dict_list[self.header_wt[i]].append(row[i])\r\n count += 1\r\n\r\n ''' Calculate water inflows\r\n as a reminder, the first 91 time steps are T=0 to T=90 and are 1-hourly for HRES\r\n\t\t the next 18 time steps for HRES are T=93 to T=144 at 3-hourly\r\n then the final 16 time steps are T=150 to T=240 at 6-hourly for a total of 125 records\r\n\t\t\tFor ENS, the first 49 time steps are T=0 to T=144 at 3-hourly\r\n\t\t\tthe final 35 time steps are T=150 to T=360 at 6-hourly for a total of 84 records\r\n '''\r\n\t\t\t\r\n print(\"Calculating water inflows...\")\r\n\t\t\r\n ''' \r\n added the next section CJB 20180122 \r\n '''\r\n\r\n\t\t# Get the overall number of time steps\r\n size_time = self.getTimeSize(in_nc) #CJB 20180122\r\n # Determine the size of time steps in each group (1-hourly, 3-hourly, and/or 6-hourly)\r\n if id_data == \"HRES1\": # T <= 90 \r\n time_size = (size_time - 1)\r\n elif id_data == \"HRES13\": # 93 <= T <= 144\r\n if in_time_interval == \"1hr\":\r\n time_size = self.length_time_opt[\"HighRes-1hr\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"HighRes-1hr\"] - 1)\r\n elif id_data == \"HRES136\": # 150 <= T <= 240\r\n if in_time_interval == \"1hr\":\r\n time_size = self.length_time_opt[\"HighRes-1hr\"]\r\n elif in_time_interval == \"3hr\": # MJS Doesn't seem to be a case used currently, but added just in case later need.\r\n time_size = self.length_time_opt[\"HighRes-3hr-sub\"] # MJS This is HRES136, i.e., if for some reason in ecmwf_rapid_multi a 3 hr is asked for for this case, it should still have the 3hr_sub number of times\r\n elif in_time_interval == \"3hr_subset\":\r\n time_size = self.length_time_opt[\"HighRes-3hr-Sub\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"HighRes-1hr\"] - self.length_time_opt[\"HighRes-3hr-Sub\"] - 1)\r\n elif id_data == \"ENS3\": # T <= 144\r\n time_size = (size_time - 1)\r\n elif id_data == \"ENS36\": # 150 <= T <= 360\r\n if in_time_interval == \"3hr_subset\":\r\n time_size = self.length_time_opt[\"LowResFull-3hr-Sub\"]\r\n else:\r\n time_size = (size_time - self.length_time_opt[\"LowResFull-3hr-Sub\"] - 1)\r\n else: # id_data == \"ENS6\": # T <= 360 but all 6-hourly\r\n time_size = (size_time - 1)\r\n #else: # something is wrong and need to throw an error message - likely a corrupt forecast file\r\n # raise Exception(self.errorMessages[3])\r\n #''' end of added section CJB 20180122 \r\n #'''\r\n\r\n #if id_data == \"LowRes\":\r\n # size_time = self.length_time_opt[\"LowRes-6hr\"]\r\n #elif id_data == \"Low3HrRes\":\r\n # size_time = self.length_time_opt[\"LowRes-3hr\"]\r\n #elif id_data == \"LowResFull\":\r\n # if in_time_interval == \"3hr_subset\":\r\n # size_time = self.length_time_opt[\"LowResFull-3hr-Sub\"]\r\n # elif in_time_interval == \"6hr_subset\":\r\n # size_time = self.length_time_opt[\"LowResFull-6hr-Sub\"]\r\n # else:\r\n # size_time = self.length_time_opt[\"LowRes-6hr\"]\r\n #else: #HighRes\r\n # if in_time_interval == \"1hr\":\r\n # size_time = self.length_time_opt[\"HighRes-1hr\"]\r\n # elif in_time_interval == \"3hr\":\r\n # size_time = self.length_time_opt[\"HighRes-3hr\"]\r\n # elif in_time_interval == \"3hr_subset\":\r\n # size_time = self.length_time_opt[\"HighRes-3hr-Sub\"]\r\n # elif in_time_interval == \"6hr_subset\":\r\n # size_time = self.length_time_opt[\"HighRes-6hr-Sub\"]\r\n # else:\r\n # size_time = self.length_time_opt[\"HighRes-6hr\"]\r\n\r\n size_streamID = len(set(dict_list[self.header_wt[0]]))\r\n\r\n # Create output inflow netcdf data\r\n # data_out_nc = NET.Dataset(out_nc, \"w\") # by default format = \"NETCDF4\"\r\n data_out_nc = NET.Dataset(out_nc, \"w\", format = \"NETCDF3_CLASSIC\")\r\n #dim_Time = data_out_nc.createDimension('Time', size_time)\r\n dim_Time = data_out_nc.createDimension('Time', time_size)\r\n dim_RiverID = data_out_nc.createDimension('rivid', size_streamID)\r\n var_m3_riv = data_out_nc.createVariable('m3_riv', 'f4', \r\n ('Time', 'rivid'),\r\n fill_value=0)\r\n \r\n #data_temp = NUM.empty(shape = [size_time, size_streamID])\r\n data_temp = NUM.empty(shape = [time_size, size_streamID])\r\n\r\n lon_ind_all = [int(i) for i in dict_list[self.header_wt[2]]]\r\n lat_ind_all = [int(j) for j in dict_list[self.header_wt[3]]]\r\n\r\n # Obtain a subset of runoff data based on the indices in the weight table\r\n min_lon_ind_all = min(lon_ind_all)\r\n max_lon_ind_all = max(lon_ind_all)\r\n min_lat_ind_all = min(lat_ind_all)\r\n max_lat_ind_all = max(lat_ind_all)\r\n\r\n # self.vars_oi[vars_oi_index][3] = RO; get that variable's 3D structure (time, lat_index, lon_index) ready to reshape into 2D (time, lat_index x lon_index)\r\n data_subset_all = data_in_nc.variables[self.vars_oi[vars_oi_index][3]][:, min_lat_ind_all:max_lat_ind_all+1, min_lon_ind_all:max_lon_ind_all+1]\r\n len_time_subset_all = data_subset_all.shape[0]\r\n len_lat_subset_all = data_subset_all.shape[1]\r\n len_lon_subset_all = data_subset_all.shape[2]\r\n data_subset_all = data_subset_all.reshape(len_time_subset_all, (len_lat_subset_all * len_lon_subset_all))\r\n\r\n # compute new indices based on the data_subset_all\r\n index_new = []\r\n for r in range(0,count-1):\r\n ind_lat_orig = lat_ind_all[r]\r\n ind_lon_orig = lon_ind_all[r]\r\n index_new.append((ind_lat_orig - min_lat_ind_all)*len_lon_subset_all + (ind_lon_orig - min_lon_ind_all))\r\n\r\n # obtain a new subset of data\r\n data_subset_new = data_subset_all[:,index_new]*conversion_factor\r\n\r\n # start compute inflow\r\n pointer = 0\r\n for s in range(0, size_streamID):\r\n npoints = int(dict_list[self.header_wt[4]][pointer])\r\n # Check if all npoints points correspond to the same streamID\r\n if len(set(dict_list[self.header_wt[0]][pointer : (pointer + npoints)])) != 1:\r\n print(\"ROW INDEX {0}\".format(pointer))\r\n print(\"RIVID {0}\".format(dict_list[self.header_wt[0]][pointer]))\r\n raise Exception(self.errorMessages[2])\r\n\r\n area_sqm_npoints = [float(k) for k in dict_list[self.header_wt[1]][pointer : (pointer + npoints)]]\r\n area_sqm_npoints = NUM.array(area_sqm_npoints)\r\n area_sqm_npoints = area_sqm_npoints.reshape(1, npoints)\r\n data_goal = data_subset_new[:, pointer:(pointer + npoints)]\r\n \r\n \r\n #remove noise from data\r\n data_goal[data_goal<=0.00001] = 0\r\n\r\n ''' IMPORTANT NOTE: runoff variable in ECMWF dataset is cumulative instead of incremental through time\r\n '''\r\n # For data with Low Resolution, there's only one time interval 6 hrs\r\n if id_data == \"ENS6\": # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints\r\n elif id_data == \"ENS3\": # there's only one time interval 3 hrs # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\r\n elif id_data == \"HRES1\": # there's only one time interval 1 hrs # Line Added/Modified CJB 20190108\r\n #ro_stream = data_goal * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\t\r\n #For data with the full version of Low Resolution, from Hour 0 to 144 (the first 49 time points) are of 3 hr time interval,\r\n # then from Hour 144 to 360 (36 time points) are of 6 hour time interval\r\n elif id_data == \"ENS36\": # Line Added/Modified CJB 20190108\r\n if in_time_interval == \"3hr_subset\":\r\n #use only the 3hr time interval\r\n ro_stream = NUM.subtract(data_goal[1:49,], data_goal[:48,]) * area_sqm_npoints\r\n elif in_time_interval == \"6hr_subset\":\r\n #use only the 6hr time interval\r\n ro_stream = NUM.subtract(data_goal[49:,], data_goal[48:-1,]) * area_sqm_npoints\r\n else: #\"LowRes-6hr\"\r\n ######################################################\r\n # MJS Always assume this case will have a full ECMWF 240\r\n # hour forecast to work with. It's actually never re-\r\n # quested by ecmwf_rapid_multiprocess anyhow.\r\n ######################################################\r\n #convert all to 6hr\r\n # calculate time series of 6 hr data from 3 hr data\r\n ro_6hr_a = NUM.subtract(data_goal[2:49:2,], data_goal[:48:2,])\r\n # get the time series of 6 hr data\r\n ro_6hr_b = NUM.subtract(data_goal[49:,], data_goal[48:-1,])\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b]) * area_sqm_npoints\r\n #For data with High Resolution, from Hour 0 to 90 (the first 91 time points) are of 1 hr time interval,\r\n # then from Hour 90 to 144 (18 time points) are of 3 hour time interval, and from Hour 144 to 240 (16 time points)\r\n # are of 6 hour time interval\r\n ##########################################################\r\n # MJS The following should handle id_data = HRES13 and HRES136\r\n ##########################################################\r\n else:\r\n if in_time_interval == \"1hr\":\r\n #ro_stream = NUM.subtract(data_goal[1:91,],data_goal[:90,]) * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[1:1+time_size,],data_goal[:time_size,]) * area_sqm_npoints # Line Added/Modified CJB, MJS 20190108\r\n elif in_time_interval == \"3hr\": # MJS HRES 3hr not currently used\r\n # calculate time series of 3 hr data from 1 hr data\r\n ro_3hr_a = NUM.subtract(data_goal[3:91:3,],data_goal[:88:3,])\r\n # get the time series of 3 hr data\r\n #ro_3hr_b = NUM.subtract(data_goal[91:109,], data_goal[90:108,])\r\n ro_3hr_b = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) # MJS modified again; seems no case for this, but just in case later... Line Added/Modified CJB 20190108\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_3hr_a, ro_3hr_b]) * area_sqm_npoints\r\n elif in_time_interval == \"3hr_subset\":\r\n #use only the 3hr time interval\r\n #ro_stream = NUM.subtract(data_goal[91:109,], data_goal[90:108,]) * area_sqm_npoints\r\n ro_stream = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) * area_sqm_npoints # MJS modified again; needs to handle HRES13 that might not have complete 3hr set... Line Added/Modified CJB 20190108\r\n elif in_time_interval == \"6hr_subset\":\r\n #use only the 6hr time interval\r\n ro_stream = NUM.subtract(data_goal[109:,], data_goal[108:-1,]) * area_sqm_npoints\r\n ######################################################\r\n # MJS Always assume this case will have a full ECMWF 240 \r\n # hour forecast to work with. It's actually never re-\r\n # quested by ecmwf_rapid_multiprocess anyhow.\r\n ######################################################\r\n else: # in_time_interval == \"6hr\"\r\n #arcpy.AddMessage(\"6hr\")\r\n # calculate time series of 6 hr data from 1 hr data\r\n ro_6hr_a = NUM.subtract(data_goal[6:91:6,], data_goal[:85:6,])\r\n # calculate time series of 6 hr data from 3 hr data\r\n ro_6hr_b = NUM.subtract(data_goal[92:109:2,], data_goal[90:107:2,])\r\n # get the time series of 6 hr data\r\n ro_6hr_c = NUM.subtract(data_goal[109:,], data_goal[108:-1,])\r\n # concatenate all time series\r\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b, ro_6hr_c]) * area_sqm_npoints\r\n \r\n #remove negative values\r\n ro_stream[ro_stream<0] = 0\r\n data_temp[:,s] = ro_stream.sum(axis = 1)\r\n\r\n pointer += npoints\r\n\r\n\r\n '''Write inflow data'''\r\n print(\"Writing inflow data...\")\r\n var_m3_riv[:] = data_temp\r\n # close the input and output netcdf datasets\r\n data_in_nc.close()\r\n data_out_nc.close()","def openMCSH5File(filename, verbose=False):\n rf = h5py.File(filename, 'r')\n \n stream = rf.require_group('/Data/Recording_0/AnalogStream/Stream_0')\n data = np.array(stream.get('ChannelData'),dtype=np.int)\n timestamps = np.array(stream.get('ChannelDataTimeStamps'))\n info = np.array(stream.get('InfoChannel'))\n \n Unit = info['Unit'][0]\n Tick = info['Tick'][0]/1e6\n exponent = info['Exponent'][0]\n convFact = info['ConversionFactor'][0]\n \n nRecCh, nFrames = data.shape\n channel_ids = info['ChannelID']\n assert len(np.unique(channel_ids)) == len(channel_ids), 'Duplicate MCS channel IDs found'\n electrodeLabels = info['Label']\n \n TimeVals = np.arange(timestamps[0][0],timestamps[0][2]+1,1)*Tick\n \n assert Unit==b'V', 'Unexpected units found, expected volts, found {}'.format(Unit.decode('UTF-8'))\n data_V = data*convFact.astype(float)*(10.0**(exponent))\n \n timestep_avg = np.mean(TimeVals[1:]-TimeVals[0:-1])\n timestep_std = np.std(TimeVals[1:]-TimeVals[0:-1])\n timestep_min = np.min(TimeVals[1:]-TimeVals[0:-1])\n timestep_max = np.min(TimeVals[1:]-TimeVals[0:-1])\n assert all(np.abs(np.array((timestep_min, timestep_max))-timestep_avg)/timestep_avg < 1e-6), 'Time steps vary by more than 1 ppm'\n samplingRate = 1./timestep_avg\n\n if verbose:\n print('# MCS H5 data format')\n print('#')\n print('# File: {}'.format(rf.filename))\n print('# File size: {:.2f} MB'.format(rf.id.get_filesize()/1024**2))\n print('#')\n for key in rf.attrs.keys():\n print('# {}: {}'.format(key,rf.attrs[key]))\n print('#')\n print('# Signal range: {:.2f} to {:.2f} µV'.format(np.amin(data_V)*1e6,np.amax(data_V)*1e6))\n print('# Number of channels: {}'.format(nRecCh))\n print('# Number of frames: {}'.format(nFrames))\n print('# Time step: {:.2f} µs ± {:.5f} % (range {} to {})'.format(timestep_avg*1e6, timestep_std/timestep_avg*100, timestep_min*1e6, timestep_max*1e6))\n print('# Sampling rate: {:.2f} Hz'.format(samplingRate))\n print('#')\n print('# MCSH5RecordingExtractor currently only reads /Data/Recording_0/AnalogStream/Stream_0')\n\n return (rf, nFrames, samplingRate, nRecCh, channel_ids, electrodeLabels, exponent, convFact)","def test_simple_recov(self):\r\n\r\n # ND072022.PD0 contains a single ADCPA ensemble\r\n with open(os.path.join(RESOURCE_PATH, 'ND072022.PD0'), 'rb') as stream_handle:\r\n\r\n parser = AdcpPd0Parser(self.config_recov, stream_handle, self.exception_callback)\r\n particles = parser.get_records(1)\r\n \r\n log.debug('got back %d particles', len(particles))\r\n \r\n self.assert_particles(particles, 'ND072022_recov.yml', RESOURCE_PATH)","def ncwrt_retrieval_obs_s2(retr_setup, outname=None):\n\n #-- set name of file to be generated\n act_outname = outname if outname!=None else 'obs_s2.nc'\n msg = \"Start writing configuration file ***{}***...\".format(act_outname)\n FileLogger.info(msg)\n\n #-- compression settings\n zlev = retr_setup.zlev\n use_zlib = retr_setup.use_zlib\n\n #-- retrieval settings\n s2_table = retr_setup.obs_dct['S2']\n timepts = s2_table.geom.date_utc\n npts = len(timepts)\n s2_satid = np.array(s2_table.sat_id_lst, dtype=str)\n s2_data = s2_table.data\n s2_dataunc = s2_table.dataunc\n nt,nbands = s2_data.shape\n\n #-- temporal settings, create time-values (time-since)\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\n time_values = nc4.date2num(timepts, time_unit)\n\n #-- ensure directory exists\n mkdirp_smart(os.path.dirname(act_outname))\n\n #-- open file pointer\n ncfp = nc4.Dataset(act_outname, 'w')\n #-- add dimensions\n d1 = ncfp.createDimension('npoints',npts)\n d2 = ncfp.createDimension('nbands',nbands)\n\n #-- time-value\n ncvar = ncfp.createVariable( 'time', np.float64, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('standard_name','time')\n ncvar.setncattr('long_name','time')\n ncvar.setncattr('units', time_unit)\n ncvar[:] = time_values[:]\n\n #-- unit (in correct type)\n unit_one = np.array([1]).astype(s2_data.dtype)[0]\n\n # BRF\n ncvar = ncfp.createVariable( 'brf', np.float64, ('npoints','nbands'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'BRF top-of-canopy reflectances')\n ncvar.setncattr('units',unit_one)\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\n ncvar[:,:] = s2_data[:,:]\n\n # BRF uncertainty\n ncvar = ncfp.createVariable( 'brf_unc', np.float64, ('npoints','nbands'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'BRF top-of-canopy reflectances')\n ncvar.setncattr('units',unit_one)\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\n comment = \"BRF uncertainties are derived as {:.2f}[%] relative uncertainty \".format(\n 100.*retr_setup.s2_relunc)\n comment += \"and an uncertainty floor value of {:.4f} is applied.\".format(retr_setup.s2_uncfloor)\n ncvar.setncattr('comment', comment)\n ncvar[:,:] = s2_dataunc[:,:]\n\n # satellite identifier\n ncvar = ncfp.createVariable( 'satellite_id', str, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'satellite identifer')\n ncvar[:] = s2_satid[:]\n\n #-- global attributes\n ncfp.setncattr('creator_name',\"The Inversion Lab, Hamburg, Germany\")\n ncfp.setncattr('creator_email', \"Michael.Vossbeck(at)Inversion-Lab.com\")\n ncfp.setncattr('netcdf_libversion',\"{}\".format(nc4.__netcdf4libversion__))\n ncfp.setncattr('date_created',\"{}\".format(dt.datetime.utcnow().isoformat()))\n ncfp.setncattr('time_coverage_start',time_coverage_start)\n ncfp.setncattr('time_coverage_end',time_coverage_end)\n\n #-- close file pointer\n ncfp.close()\n\n # logging\n msg = \"...writing ***{}*** DONE\".format(act_outname)\n FileLogger.info(msg)","def convert_input(filename, hdf5_data):\n x1 = []\n with open(filename, 'r') as inp:\n for line in inp:\n x1.append(line)\n idx = 1\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_TYPE, (1,), dtype=settings.NEMOH_INT)\n dset[0] = int(float(x1[idx].split()[0]))\n set_hdf5_attributes(dset, structure.H5_SOLVER_TYPE_ATTR)\n idx += 1\n\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_RESTART, (1,), dtype=settings.NEMOH_INT)\n dset[0] = int(float(x1[idx].split()[0]))\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_RESTART_ATTR)\n idx += 1\n\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_STOPPING, (1,), dtype=settings.NEMOH_FLOAT)\n dset[0] = float(x1[idx].split()[0])\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_STOPPING_ATTR)\n idx += 1\n\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_MAX_ITERATIONS, (1,), dtype=settings.NEMOH_INT)\n dset[0] = int(float(x1[idx].split()[0]))\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_MAX_ITERATIONS_ATTR)","def test_solinst_colon_decimalsep(test_files_dir, testfile):\n solinst_file = hsr.SolinstFileReader(osp.join(test_files_dir, testfile))\n\n records = solinst_file.records\n assert len(records) == 10\n\n assert records.index.tolist()[0] == Timestamp('2016-11-23 19:00:00')\n assert records.iloc[0].iloc[0] == 1813.03\n assert records.iloc[0].iloc[1] == 9.182\n\n assert records.index.tolist()[-1] == Timestamp('2016-11-23 21:15:00')\n assert records.iloc[-1].iloc[0] == 1812.59\n assert records.iloc[-1].iloc[1] == 9.179\n\n assert list(records.columns) == [\"LEVEL_cm\", \"TEMPERATURE_°C\"]\n\n sites = solinst_file.sites\n assert sites.instrument_serial_number == \"2048469\"\n assert sites.project_name == \"03040008\"\n assert sites.site_name == \"Rougemont_Plus profond\"","def test_extract_sensitivity_cube(tmpdir, datadir, datevshot):\n \n h5fn = datadir.join(\"test_hdf.h5\").strpath\n outfn = tmpdir.join(\"test.fits\").strpath \n \n if datevshot:\n args = [h5fn, \"--datevshot\", datevshot, \"063\", outfn]\n else:\n args = [h5fn, \"063\", outfn] \n\n extract_sensitivity_cube(args=args)\n \n assert isfile(outfn)","def main(planckfile, dustfile, tomofile, colnames, names, pol, res,\\\n part='all', distcut=None):\n if (pol == 'P') or (pol == 'Q') or (pol == 'U'):\n polarisation = True\n elif (pol == 'p') or (pol == 'q') or (pol == 'u') or (pol == 'qu'):\n polarisation = True\n else:\n polarisation = False\n\n print(pol, polarisation)\n\n if distcut is None:\n distcut = 900\n\n if (polarisation is True):\n # read smoothed planck maps.\n print('load planck 353GHz data')\n # read_smooth_maps(filename, name, shape)\n IQU_smaps = smooth.read_smooth_maps(planckfile, names[0], 3)\n dust_smap = smooth.read_smooth_maps(dustfile, names[1], 1)[0]\n T_smap = IQU_smaps[0]\n Q_smap = IQU_smaps[1]\n U_smap = IQU_smaps[2]\n \n Nside = hp.get_nside(T_smap)\n print('Using Nside={}'.format(Nside))\n print(planckfile)\n band = planckfile.split('_')[2]\n if len(band) > 3:\n band = band[:3]\n if band == '15a':\n band = '353'\n print(band)\n\n if int(band) < 353:\n # load cmb intensity and subtract form polarization maps\n cmbfile = 'Data/IQU_Nside{}_CMB_10arcmin.h5'.format(Nside)\n cmbmaps = tools.Read_H5(cmbfile, 'IQU')*1e6\n Q_cmb = cmbmaps[1,:]\n U_cmb = cmbmaps[1,:]\n Q_smap = Q_smap - Q_cmb\n U_smap = U_smap - U_cmb\n \n print(np.mean(Q_smap), np.mean(U_smap))\n #sys.exit()\n # load tomography data:\n data = load.load_tomographydata(tomofile, colnames)\n print('Data loaded, using Nside={}'.format(Nside))\n\n p_map, q_map, u_map, sigma, r_map, pix =\\\n load.tomo_map(data, Nside, part=part, distcut=distcut)\n u_map = -u_map # to Healpix convention\n mask = np.unique(pix)\n print(len(mask))\n u_smap = smooth.smooth_tomo_map(u_map, mask, Nside, res)\n q_smap = smooth.smooth_tomo_map(q_map, mask, Nside, res)\n p_smap = smooth.smooth_tomo_map(p_map, mask, Nside, res)\n print('Tomography maps smoothed')\n print(np.mean(q_smap[mask]), np.mean(dust_smap[mask]), np.mean(Q_smap[mask]))\n dPsi = np.full(len(u_map), hp.UNSEEN)\n #sys.exit()\n\n l, b = tools.convert2galactic(data[:,0], data[:,1])\n theta, phi = hp.pix2ang(Nside, pix) \n lon = np.mean(phi)*180/np.pi\n lat = 90 - np.mean(theta)*180/np.pi\n print(lon, lat)\n\n x = 0.5*np.arctan2(U_smap[mask], Q_smap[mask])\n #x[x<0.] += np.pi\n #x[x>=np.pi] -= np.pi\n\n x_v = 0.5*np.arctan2(u_smap[mask], q_smap[mask])\n #psi_v[psi_v<0] += np.pi\n #psi_v[psi_v>=np.pi] -= np.pi \n print('Polarization angles of planck (mean, min, max) [deg]:')\n print(np.mean(x)*180/np.pi,np.min(x)*180/np.pi, np.max(x)*180/np.pi)\n print(np.mean(x_v)*180/np.pi,np.min(x_v)*180/np.pi,np.max(x_v)*180/np.pi)\n #print(np.mean(x+np.pi/2-psi_v))\n if (pol == 'P') or (pol == 'p'):\n print('-- P polarisation --')\n\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\n U_smap[mask],u_smap[mask])\\\n #, plot=True, name='smooth2')\n\n dPsi[mask] = psi\n full_IQU = [T_smap, Q_smap, U_smap]\n tot_res, frac_res, dust = tools.map_analysis_function(p_smap, T_smap,\\\n dust_smap, mask, Nside)\n\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\n\n elif (pol == 'Q') or (pol == 'q'):\n print('-- Q polarisation --')\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask], U_smap[mask],\\\n u_smap[mask], plot=True)\n\n dPsi[mask] = psi\n full_IQU = [T_smap, Q_smap, U_smap]\n tot_res, frac_res, dust = tools.map_analysis_function(q_smap, Q_smap,\\\n dust_smap, mask, Nside)\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\n\n elif (pol == 'U') or (pol == 'u'):\n print('-- U polarisation --')\n print(len(u_smap))\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\n U_smap[mask],u_smap[mask], plot=True)\n\n dPsi[mask] = psi\n full_IQU = [T_smap, Q_smap, U_smap]\n tot_res, frac_res, dust = tools.map_analysis_function(u_smap, U_smap,\\\n dust_smap, mask, Nside)\n\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\n\n elif (pol == 'QU') or (pol == 'qu'):\n print('-- Q,U polarisation --')\n print('Return: tomo, planck, dust, mask, dpsi, fullIQU, [lon,lat], r')\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\n U_smap[mask], u_smap[mask])\n #, plot=True, name=Nside)\n\n dPsi[mask] = psi\n full_IQU = [T_smap, Q_smap, U_smap]\n tomo = [q_smap, u_smap, p_smap, sigma[1], sigma[2], sigma[0]]\n planck = [Q_smap, U_smap]\n coord = [lon, lat]\n angles = [dPsi[mask], psi_v, psi_s, sigma[3]]\n return(tomo, planck, dust_smap, coord, full_IQU, mask, r_map, angles)\n\n\n else:\n # use unsmoothe maps\n print('Use non smoothed maps')\n # load planck\n print('load planck 353GHz data')\n\n #T, P, Q, U = load.load_planck_map(planckfile, p=True)\n data = load.load_planck_map(planckfile, p=True)\n d353 = load.load_planck_map(dustfile)\n sys.exit()\n dust353 = tools.Krj2Kcmb(d353) * 1e6\n T = T*1e6\n P = P*1e6\n Q = Q*1e6\n U = U*1e6\n Nside = hp.get_nside(T_smap)\n\n data = load.load_tomographydata(tomofile, colnames)\n p_map, q_map, u_map, sigma, r_map, pix = load.tomo_map(data, Nside)\n u_map = -u_map # to Healpix convention\n mask = np.unique(pix)\n\n l, b = tools.convert2galactic(data[:,0], data[:,1])\n lon = np.mean(l)\n lat = np.mean(b)\n\n dPsi = np.full(len(u_map), hp.UNSEEN)\n\n if Ppol == True:\n print('-- P polarisation --')\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\n u_map[mask], plot=True)\n dPsi[mask] = psi\n full_IQU = [T, Q, U]\n tot_res, frac_res, dust = tools.map_analysis_function(p_map, T,\\\n dust353, mask)\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\n\n elif Qpol == True:\n print('-- Q polarisation --')\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\n u_map[mask], plot=True)\n dPsi[mask] = psi\n full_IQU = [T, Q, U]\n tot_res, frac_res, dust = tools.map_analysis_function(q_map, Q,\\\n dust353, mask)\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\n\n if Upol == True:\n print('-- U polarisation --')\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\n u_map[mask], plot=True)\n dPsi[mask] = psi\n full_IQU = [T, Q, U]\n tot_res, frac_res, dust = tools.map_analysis_function(u_map, U,\\\n dust353, mask)\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)","def test():\n import os\n import ClearMap.ImageProcessing.SpotDetection as self\n reload(self)\n import ClearMap.IO as io \n import ClearMap.Settings as settings\n \n basedir = settings.ClearMapPath;\n #fn = '/home/ckirst/Science/Projects/BrainActivityMap/Data/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims';\n fn = os.path.join(basedir, 'Test/Data/Synthetic/label_iDISCO_\\d{3}.tif');\n fn = os.path.join(basedir, 'Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\\d{4}.ome.tif');\n #fn = '/run/media/ckirst/ChristophsBackuk4TB/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims';\n #fn = '/home/nicolas/Windows/Nico/cfosRegistrations/Adult cfos C row 20HF 150524 - Copy.ims';\n #fn = '/home/ckirst/Science/Projects/BrainActivityMap/iDISCO_2015_04/test for spots added spot.ims'\n\n img = io.readData(fn);\n #img = dataset[0:500,0:500,1000:1008];\n #img = dataset[600:1000,1600:1800,800:830];\n #img = dataset[500:1500,500:1500,800:809]; \n img = img.astype('int16');\n \n #m = sys.modules['iDISCO.ImageProcessing.SpotDetection']\n #c = self.detectCells(img);\n \n c = self.detectCells(img, dogSize = None, cellShapeThreshold = 1, cellShapeFile = '/home/ckirst/Science/Projects/BrainActivityMap/Analysis/iDISCO/Test/Data/CellShape/cellshape_\\d{3}.tif');\n \n print ('done, found %d cells !' % c[0].shape[0])\n\n\n #test intensities:\n import numpy;\n x = numpy.random.rand(30,30,10);\n centers = numpy.array([[0,0,0], [29,29,9]]);\n i = self.findIntensity(x, centers, boxSize = (1,1,1));\n print (i)","def _initialize_output(self, time_len, id_len):\r\n\r\n log('Initializing new file %s' % self.cf_compliant_file, 'INFO')\r\n \r\n self.cf_nc = Dataset(self.cf_compliant_file, 'w', format='NETCDF3_CLASSIC')\r\n \r\n # Create global attributes\r\n log(' globals', 'DEBUG', self.print_debug)\r\n self.cf_nc.featureType = 'timeSeries'\r\n self.cf_nc.Metadata_Conventions = 'Unidata Dataset Discovery v1.0'\r\n self.cf_nc.Conventions = 'CF-1.6'\r\n self.cf_nc.cdm_data_type = 'Station'\r\n self.cf_nc.nodc_template_version = (\r\n 'NODC_NetCDF_TimeSeries_Orthogonal_Template_v1.1')\r\n self.cf_nc.standard_name_vocabulary = ('NetCDF Climate and Forecast (CF) ' +\r\n 'Metadata Convention Standard Name ' +\r\n 'Table v28')\r\n self.cf_nc.title = 'RAPID Result'\r\n self.cf_nc.summary = (\"Results of RAPID river routing simulation. Each river \" +\r\n \"reach (i.e., feature) is represented by a point \" +\r\n \"feature at its midpoint, and is identified by the \" +\r\n \"reach's unique NHDPlus COMID identifier.\")\r\n self.cf_nc.time_coverage_resolution = 'point'\r\n self.cf_nc.geospatial_lat_min = 0.0\r\n self.cf_nc.geospatial_lat_max = 0.0\r\n self.cf_nc.geospatial_lat_units = 'degrees_north'\r\n self.cf_nc.geospatial_lat_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_lon_min = 0.0\r\n self.cf_nc.geospatial_lon_max = 0.0\r\n self.cf_nc.geospatial_lon_units = 'degrees_east'\r\n self.cf_nc.geospatial_lon_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_vertical_min = 0.0\r\n self.cf_nc.geospatial_vertical_max = 0.0\r\n self.cf_nc.geospatial_vertical_units = 'm'\r\n self.cf_nc.geospatial_vertical_resolution = 'midpoint of stream feature'\r\n self.cf_nc.geospatial_vertical_positive = 'up'\r\n self.cf_nc.project = self.project_name\r\n self.cf_nc.processing_level = 'Raw simulation result'\r\n self.cf_nc.keywords_vocabulary = ('NASA/Global Change Master Directory ' +\r\n '(GCMD) Earth Science Keywords. Version ' +\r\n '8.0.0.0.0')\r\n self.cf_nc.keywords = 'DISCHARGE/FLOW'\r\n self.cf_nc.comment = 'Result time step(s) (seconds): ' + str(self.time_step_array)\r\n \r\n timestamp = datetime.utcnow().isoformat() + 'Z'\r\n self.cf_nc.date_created = timestamp\r\n self.cf_nc.history = (timestamp + '; added time, lat, lon, z, crs variables; ' +\r\n 'added metadata to conform to NODC_NetCDF_TimeSeries_' +\r\n 'Orthogonal_Template_v1.1')\r\n \r\n # Create dimensions\r\n log(' dimming', 'DEBUG', self.print_debug)\r\n self.cf_nc.createDimension('time', time_len)\r\n self.cf_nc.createDimension(self.output_id_dim_name, id_len)\r\n \r\n # Create variables\r\n log(' timeSeries_var', 'DEBUG', self.print_debug)\r\n timeSeries_var = self.cf_nc.createVariable(self.output_id_dim_name, 'i4', \r\n (self.output_id_dim_name,))\r\n timeSeries_var.long_name = (\r\n 'Unique NHDPlus COMID identifier for each river reach feature')\r\n timeSeries_var.cf_role = 'timeseries_id'\r\n \r\n log(' time_var', 'DEBUG', self.print_debug)\r\n time_var = self.cf_nc.createVariable('time', 'i4', ('time',))\r\n time_var.long_name = 'time'\r\n time_var.standard_name = 'time'\r\n time_var.units = 'seconds since 1970-01-01 00:00:00 0:00'\r\n time_var.axis = 'T'\r\n \r\n #only add if user adds\r\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\r\n log(' lat_var', 'DEBUG', self.print_debug)\r\n lat_var = self.cf_nc.createVariable('lat', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n lat_var.long_name = 'latitude'\r\n lat_var.standard_name = 'latitude'\r\n lat_var.units = 'degrees_north'\r\n lat_var.axis = 'Y'\r\n \r\n log(' lon_var', 'DEBUG', self.print_debug)\r\n lon_var = self.cf_nc.createVariable('lon', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n lon_var.long_name = 'longitude'\r\n lon_var.standard_name = 'longitude'\r\n lon_var.units = 'degrees_east'\r\n lon_var.axis = 'X'\r\n \r\n log(' z_var', 'DEBUG', self.print_debug)\r\n z_var = self.cf_nc.createVariable('z', 'f8', (self.output_id_dim_name,),\r\n fill_value=-9999.0)\r\n z_var.long_name = ('Elevation referenced to the North American ' +\r\n 'Vertical Datum of 1988 (NAVD88)')\r\n z_var.standard_name = 'surface_altitude'\r\n z_var.units = 'm'\r\n z_var.axis = 'Z'\r\n z_var.positive = 'up'\r\n \r\n log(' crs_var', 'DEBUG', self.print_debug)\r\n crs_var = self.cf_nc.createVariable('crs', 'i4')\r\n crs_var.grid_mapping_name = 'latitude_longitude'\r\n crs_var.epsg_code = 'EPSG:4326' # WGS 84\r\n crs_var.semi_major_axis = 6378137.0\r\n crs_var.inverse_flattening = 298.257223563","def test_ccds(self):\n #TODO write ccds tests","def get_data(eh, file_list):\n x_pos = []\n y_pos = []\n x_vel = []\n y_vel = []\n z_vel = []\n unique_x = []\n unique_y = []\n\n # reading data\n for file in file_list:\n with open(file, 'r') as f:\n f.readline() # Ignores first line\n for line in f:\n line = line.strip()\n column = line.split()\n if len(column) == 4:\n if file == file_list[0]:\n # Only takes position data from first file as the same in each file\n x_pos.append(float(column[0]))\n y_pos.append(float(column[1]))\n\n x_vel.append(float(column[2]))\n y_vel.append(float(column[3]))\n z_vel.append(0.0)\n\n if float(column[0]) not in unique_x:\n unique_x.append(float(column[0]))\n if float(column[1]) not in unique_y:\n unique_y.append(float(column[1]))\n else:\n x_vel.append(float(column[2]))\n y_vel.append(float(column[3]))\n z_vel.append(0.0)\n else:\n print \"Error: TXT file is not correct!\"\n\n ux = len(unique_x)\n uy = len(unique_y)\n\n\n # xmid and ymid are used to get xz- and yz-planes. The median value is used. If the number of\n # unique xs and ys is even, then the median value will be one that does not correspond to a\n # measurement. When this is the case, the first value is ignored so that the number of uniques is\n # odd, resulting in a median value that corresponds to a measurement.\n if ux % 2 == 0:\n xmid = np.median(unique_x[1:])\n else:\n xmid = np.median(unique_x)\n\n if uy % 2 == 0:\n ymid = np.median(unique_y[1:])\n else:\n ymid = np.median(unique_y)\n\n if eh == exp_h_list[-1]:\n print \"All data read.\"\n\n\n # checks list lengths to ensure matching and then averages the velocities for all files\n # and then returns an array with position and average velocities\n if len(x_pos) == len(y_pos):\n pos_count = len(x_pos)\n if len(x_vel) == len(y_vel) and len(x_vel) == len(z_vel):\n vel_count = len(x_vel)\n nof = vel_count / pos_count # equals number of files for each height\n ax_vel, ay_vel, az_vel = avg_data_each_h(nof, pos_count, x_vel, y_vel, z_vel)\n\n if make_sg:\n subgrid_array = sub_grid(ux, x_pos, y_pos, eh, ax_vel, ay_vel, az_vel)\n return subgrid_array\n else:\n z_pos = [eh] * len(x_pos)\n return xmid, ymid, zip(x_pos, y_pos, z_pos, ax_vel, ay_vel, az_vel)\n else:\n print \"Error: different number of velocities!\"\n else:\n print \"Error: not all x-positions have a corresponding y-position!\"","def test_calculate_r_i():\n \n with open(HsHis6_PEX5C_vs_HsPEX5C_calc_r_I, 'rb') as file: # load the list with expexcted data frames from .pkl file\n expected_list = pickle.load(file)\n \n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\n test_object.background_correct()\n test_object.calculate_r_i(correct=True, plot_i=False, thr=50)\n \n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_raw'], expected_list[0], atol=1E-6)\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['r_raw'], expected_list[1], atol=1E-6)\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_corrected'], expected_list[2], atol=1E-6)\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['r_corrected'], expected_list[3], atol=1E-6)\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_percent'], expected_list[4], atol=1E-6)","def run(self, dataset_dir, sensor_data, output_dir,\n pc_input=None, save_pc=None,\n gn_input=None, save_gn=None,\n software_cfg=None,\n tolPC=TOLPC, tol=TOL, tolA=TOLA, tolB=TOLB, tolU=TOLU,\n show=1,\n return_covariance=True):\n\n # Default to save residual data\n res = True\n\n ################################################################################################################\n # 1.\tRead Harmonisation Matchup Data\n ################################################################################################################\n\n print \"\\nOpening data...\"\n HData = open_matchup(dataset_dir)\n HData.setSensorData(sensor_data)\n print \"Complete\"\n\n print \"\\nData Info\"\n print \"==========\"\n print \"Reference Sensors - \", [str(sensor) for sensor in HData.idx['sensors']\n if sensor not in HData.idx[\"parameter_sensor\"]]\n print \"Harmonising Sensors - \", [str(sensor) for sensor in HData.idx['sensors']\n if sensor in HData.idx[\"parameter_sensor\"]]\n print \"Total Match-Ups - \", HData.idx['cNm'][-1]\n print \"Total Sensor State Data Values - \", HData.idx['idx'][-1]\n print \"Total Harmonisation Paramaters - \", len(HData.idx['parameter_sensor'])\n\n ################################################################################################################\n # 2.\tPerform harmonisation\n ################################################################################################################\n\n print \"\\nBeginning Harmonisation...\"\n Harmonisation = HarmonisationEIV()\n HarmonisationOutput = Harmonisation.run(HData,\n pc_input=pc_input, save_pc=save_pc,\n gn_input=gn_input, save_gn=save_gn,\n show=show)\n\n print \"Final Solution:\"\n print HarmonisationOutput.parameter\n print HarmonisationOutput.parameter_covariance_matrix\n\n ################################################################################################################\n # 3.\tWrite data to file\n ################################################################################################################\n\n print 'Writing data to file...'\n # Add metadata\n startDate = \"\"\n endDate = \"\"\n HarmonisationOutput.additional_attributes = {\"software\": software_cfg['software'],\n \"software_version\": software_cfg['version'],\n \"software_tag\": software_cfg['tag'],\n \"job_id\": software_cfg[\"job_id\"],\n \"matchup_dataset\": \"_\".join((software_cfg['matchup_dataset'],\n startDate, endDate))}\n\n # Write data\n fname_output = \"_\".join((\"harm\", software_cfg['software'], software_cfg['version'],\n software_cfg['tag'], software_cfg[\"job_id\"],\n software_cfg['matchup_dataset'])) + \".nc\"\n HarmonisationOutput.save(pjoin(output_dir, fname_output), save_residuals=res)\n\n print \"\\nOutput Data Written To:\"\n print \">\", output_dir","def test_T2():\n infile = \"cisd/T2.in\"\n assert(os.path.exists(infile))\n with open(infile) as f:\n lines = f.readlines()\n assert(len(lines) == 10)\n\n hl1 = HirataLine(lines[0])\n assert(set(hl1.free_indices.split()) == set(\"p3 p4 h1 h2\".split()))\n assert(hl1.summation_indices == '')\n assert(hl1.prefactors == [\"+ 1.0 \"])\n assert(hl1.postfactors == ['v ( p3 p4 h1 h2 )'])\n assert(str(hl1) == lines[0].replace('\\n', ''))\n cl1 = Cc4sLine(hl1)\n assert(set(cl1.free_indices.split()) == set([\"c\", \"d\", \"i\", \"j\"]))\n assert(cl1.summation_indices == \"\")\n assert(cl1.prefactors == [\"+ 1.0 \"])\n assert(cl1.postfactors == ['Vabij[\"cdij\"]'])\n assert(cl1.to_cpp() == ['( + 1.0 ) * Vabij[\"cdij\"];'])\n\n hl8 = HirataLine(lines[7])\n assert(set(hl8.free_indices.split()) == set(\"p3 p4 h1 h2\".split()))\n assert(hl8.summation_indices == ' h6 p5 ')\n assert(\n hl8.prefactors == [\n '+ 1.0 ',\n '- 1.0 * P( p3 p4 h2 h1 => p4 p3 h2 h1 ) ',\n '- 1.0 * P( p3 p4 h2 h1 => p3 p4 h1 h2 ) ',\n '+ 1.0 * P( p3 p4 h2 h1 => p4 p3 h1 h2 ) '\n ]\n )\n assert(\n hl8.postfactors ==\n ['Sum ( h6 p5 )', 't ( p5 p3 h6 h2 )', 'v ( h6 p4 h1 p5 )']\n )\n assert(str(hl8) == lines[7].replace('\\n', ''))\n cl8 = Cc4sLine(hl8)\n assert(set(cl8.free_indices.split()) == set([\"c\", \"d\", \"i\", \"j\"]))\n assert(cl8.summation_indices == \" n e \")\n assert(\n cl8.prefactors ==\n ['+ 1.0 ',\n '- 1.0 * P( c d j i => d c j i ) ',\n '- 1.0 * P( c d j i => c d i j ) ',\n '+ 1.0 * P( c d j i => d c i j ) ']\n )\n assert(cl8.postfactors == ['Tabij[\"ecnj\"]', 'Viajb[\"ndie\"]'])\n assert(\n cl8.to_cpp() == [\n '( + 1.0 ) * Tabij[\"ecnj\"] * Viajb[\"ndie\"];',\n '( - 1.0 ) * Tabij[\"ednj\"] * Viajb[\"ncie\"];',\n '( - 1.0 ) * Tabij[\"ecni\"] * Viajb[\"ndje\"];',\n '( + 1.0 ) * Tabij[\"edni\"] * Viajb[\"ncje\"];'\n ]\n )","def read(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\n\n data = []\n comb = True if diagram == 'C4+D' else False\n\n for cnfg in lookup_cnfg:\n # filename and path\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\n try:\n fh = h5py.File(filename, \"r\")\n except IOError:\n print 'file %s not found' % filename\n raise\n\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\n # each loop seperately\n # TODO: is it necessary to build that completely or can that be \n # constructed by successively storing each operator with pd.HDFStore()?\n data_qn = DataFrame()\n# print DataFrame(lookup_p)\n# print DataFrame(lookup_g)\n\n for op in lookup_qn.index:\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\n g = lookup_qn.ix[op, ['\\gamma_{so}', '\\gamma_{si}']]\n groupname = set_groupname(diagram, p, g)\n\n # read data from file as numpy array and interpret as complex\n # numbers for easier treatment\n try:\n tmp = np.asarray(fh[groupname]).view(complex)\n except KeyError:\n print(\"could not read %s for config %d\" % (groupname, cnfg))\n continue\n\n # in case diagram is C4+D perform last mutliplication of factorizing\n # traces\n # the file contains 4 numbers per time slice: ReRe, ReIm, ImRe, and ImIm,\n # here combined 2 complex number\n if comb:\n # reshaping so we can extract the data easier\n tmp = tmp.reshape((-1,2))\n # extracting right combination, assuming ImIm contains only noise\n dtmp = 1.j * (tmp[:,1].real + tmp[:,0].imag) + tmp[:,0].real\n tmp = dtmp.copy()\n\n # save data into data frame\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\n data.append(data_qn)\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\n\n if verbose:\n print '\\tfinished reading'\n\n return data.sort_index(level=[0,1])","def test_compute_Sv_ek80_CW_complex(ek80_path):\n ek80_raw_path = str(\n ek80_path.joinpath('ar2.0-D20201210-T000409.raw')\n ) # CW complex\n echodata = ep.open_raw(ek80_raw_path, sonar_model='EK80')\n ds_Sv = ep.calibrate.compute_Sv(\n echodata, waveform_mode='CW', encode_mode='complex'\n )\n assert isinstance(ds_Sv, xr.Dataset) is True\n ds_TS = ep.calibrate.compute_TS(\n echodata, waveform_mode='CW', encode_mode='complex'\n )\n assert isinstance(ds_TS, xr.Dataset) is True","def test5(self):\n tgts = [ ('CCC(O)C(=O)O',\n ('O[CH-][CH2-]','O[CH-][C-]=O')),\n ]\n for smi,matches in tgts:\n m = Chem.MolFromSmiles(smi)\n fp1 = Chem.RDKFingerprint(m,2,7,9192,4,1)\n obs = fp1.GetOnBits()\n for match in matches:\n m2 = Chem.MolFromSmiles(match)\n fp2 = Chem.RDKFingerprint(m2,2,7,9192,4,1)\n v1,v2 = DataStructs.OnBitProjSimilarity(fp2,fp1)\n assert feq(v1,1.0000),'substruct %s not properly contained in %s'%(match,smi)","def test_header_update5(self, capsys):\n\n # Prepare input files.\n self.get_data(\"input\", \"ocyw05afq_raw.fits\")\n self.get_data(\"input\", \"ocyw05afq_spt.fits\")\n\n capsys.readouterr()\n\n tastis('ocyw05afq_raw.fits', update=True)\n\n captured = capsys.readouterr()\n assert captured.out == \"===============================================================================\\n\" \\\n \"ocyw05afq HST/STIS G430L 0.2X0.09 ACQ/PEAK-UP\\n\" \\\n \"prop: 14084 visit: 05 line: 2 target: BD-11D916\\n\" \\\n \"obs date, time: 2016-09-22 08:33:17 exposure time: 1.80\\n\" \\\n \"dom GS/FGS: S2AE000156F1 sub-dom GS/FGS: S2AE000086F2\\n\" \\\n \"ACQ params: bias sub: 1510 method: MAX-FLUX-CENTROID\\n\" \\\n \"subarray (axis1,axis2): size=(1022,32) corner=(26,500)\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"Scan type: LINEARAXIS2 Step size (mas): 150\\n\" \\\n \"\\n\" \\\n \" [ 5139 67252 0]\\n\" \\\n \"\\n\" \\\n \" axis1 axis2 axis1 axis2 V2 V3\\n\" \\\n \" (pixels) (arcsec) (arcsec)\\n\" \\\n \"Estimated slew: 0.0 0.0 0.000 0.000 0.000 0.000\\n\" \\\n \"Flux in post-slew confirmation image (907707) - Pedestal (838752) = 68955 DN\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"The confirmation image has a flux between 0.8 and 2.0 times the\\n\" \\\n \"maximum flux in the peakup, which is typical of a successful ACQ/PEAK.\\n\" \\\n \"===============================================================================\\n\"\n\n # Compare results\n outputs = [(\"ocyw05afq_raw.fits\", \"ocyw05afq_raw_ref.fits\")]\n self.compare_outputs(outputs)","def test_sim(self):\n nxfe = 4\n ipopt = get_solver(\"ipopt\")\n\n m_steady = self.make_steady_model(nfe=nxfe)\n self.fix_model_inlets(m_steady, inlet_pressure=50.0 * pyo.units.bar)\n m_steady.fs.compressor.boost_pressure[:].fix(7.0 * pyo.units.bar)\n ipopt.solve(m_steady, tee=True)\n time_steady = m_steady.fs.time\n scalar_data = self.get_scalar_data_from_model(m_steady, time_steady)\n initial_data = self.get_data_from_model_at_time(m_steady, time_steady)\n\n m = pyo.ConcreteModel()\n default = {\n \"dynamic\": True,\n \"time_set\": [0.0, 20.0],\n \"time_units\": pyo.units.hr,\n }\n m.fs = idaes.FlowsheetBlock(**default)\n m.fs.properties = NaturalGasParameterBlock()\n pipeline_config = {\n \"property_package\": m.fs.properties,\n \"finite_elements\": nxfe,\n }\n m.fs.pipeline = GasPipeline(**pipeline_config)\n pipeline = m.fs.pipeline\n compressor_config = {\"property_package\": m.fs.properties}\n m.fs.compressor = Compressor(**compressor_config)\n compressor = m.fs.compressor\n m._compressor_to_pipeline = Arc(\n ports=(compressor.outlet_port, pipeline.inlet_port),\n )\n expand_arcs = pyo.TransformationFactory(\"network.expand_arcs\")\n expand_arcs.apply_to(m)\n\n cv = m.fs.pipeline.control_volume\n assert_units_consistent(m)\n\n disc = pyo.TransformationFactory(\"dae.finite_difference\")\n ntfe = 20\n disc.apply_to(m, nfe=ntfe, wrt=m.fs.time, scheme=\"BACKWARD\")\n\n time = m.fs.time\n t0 = m.fs.time.first()\n x0 = cv.length_domain.first()\n xf = cv.length_domain.last()\n j = next(iter(m.fs.properties.component_list))\n\n # Fix geometry variables\n m.fs.pipeline.diameter.fix(0.92 * pyo.units.m)\n cv.length.fix(300.0 * pyo.units.km)\n\n # Fix boost pressure\n compressor.boost_pressure[:].fix()\n\n # Inlets to the compressor are fixed, except for flow, where\n # the outlet is fixed.\n state = compressor.inlet_state\n state[:].pressure.fix()\n state[:].mole_frac_comp[j].fix()\n state[:].temperature.fix()\n cv.flow_mass[:, xf].fix()\n\n # Fix initial conditions. Here, pressure and volume for all\n # non-specified points.\n for x in cv.length_domain:\n if x != x0:\n cv.pressure[t0, x].fix()\n if x != xf:\n cv.flow_mass[t0, x].fix()\n\n # I want to deactivate differential equations at (t0, xf)\n # Material balance already doesn't exist here.\n cv.momentum_balance[t0, xf].deactivate()\n\n self.assertEqual(degrees_of_freedom(m), 0)\n\n # Load initial steady state into model at all time points.\n for name, val in initial_data.items():\n var = m.find_component(name)\n for t in time:\n var[t].set_value(val)\n # Load scalar data from initial steady state\n # (initialize area, basically)\n for name, val in scalar_data.items():\n var = m.find_component(name)\n var.set_value(val)\n\n cv.material_accumulation[...].set_value(0.0)\n cv.flow_mass_dt[...].set_value(0.0)\n\n for con in large_residuals_set(m):\n resid = pyo.value(con.body - con.upper)\n print(resid, con.name)\n ipopt.solve(m, tee=True)\n\n # Load input sequence into model\n sample_points = [4.0, 20.0]\n input_name = \"fs.pipeline.control_volume.flow_mass[*,1.0]\"\n nominal_density = 0.72\n val = 12.0 * 1e6 / 24 * nominal_density # 12 (1e6 SCM)/day\n input_series_data = (\n sample_points,\n {input_name: [val, val]},\n )\n input_interval_data = interval_data_from_time_series(input_series_data)\n load_inputs_into_model(m, time, input_interval_data)\n # Solve with loaded inputs\n res = ipopt.solve(m, tee=True)\n self.assertIs(\n res.solver.termination_condition,\n pyo.TerminationCondition.optimal,\n )\n\n # These predicted values come from a simulation of a single pipeline\n # model from the Pyomo DAE example. flow_mass has been converted\n # to kg/hr from (1e4 SCM/hr) by a factor of 0.72*1e4, where\n # 0.72 kg/m**3 is the gas density at standard conditions.\n pred_values = (\n list(time),\n {\n \"fs.pipeline.control_volume.flow_mass[*,%s]\"\n % x0: [\n 3.000e5,\n 2.999e5,\n 2.999e5,\n 2.999e5,\n 3.000e5,\n 3.174e5,\n 3.301e5,\n 3.389e5,\n 3.449e5,\n 3.492e5,\n 3.523e5,\n 3.544e5,\n 3.560e5,\n 3.571e5,\n 3.579e5,\n 3.585e5,\n 3.589e5,\n 3.592e5,\n 3.594e5,\n 3.595e5,\n 3.597e5,\n ],\n \"fs.pipeline.control_volume.pressure[*,%s]\"\n % xf: [\n 50.90,\n 50.90,\n 50.90,\n 50.90,\n 50.90,\n 49.83,\n 49.31,\n 48.95,\n 48.69,\n 48.51,\n 48.38,\n 48.29,\n 48.22,\n 48.17,\n 48.14,\n 48.11,\n 48.10,\n 48.08,\n 48.07,\n 48.07,\n 48.06,\n ],\n \"fs.compressor.power[*]\": [\n 1.590e3,\n 1.590e3,\n 1.590e3,\n 1.590e3,\n 1.590e3,\n 1.682e3,\n 1.750e3,\n 1.796e3,\n 1.828e3,\n 1.851e3,\n 1.867e3,\n 1.878e3,\n 1.887e3,\n 1.892e3,\n 1.897e3,\n 1.900e3,\n 1.902e3,\n 1.904e3,\n 1.905e3,\n 1.906e3,\n 1.906e3,\n ],\n },\n )\n output_names = [\n \"fs.pipeline.control_volume.flow_mass[*,%s]\" % x0,\n \"fs.pipeline.control_volume.pressure[*,%s]\" % xf,\n \"fs.compressor.power[*]\",\n ]\n actual_values = (\n list(time),\n {\n name: [var.value for var in m.find_component(name).values()]\n for name in output_names\n },\n )\n # Note: We fail with a reltol of 0.01, due to flow rate discrepancies\n # in positions 6, 7, 8, and 9. A reltol of 0.02 seems reasonable to me.\n self.assertStructuredAlmostEqual(pred_values, actual_values, reltol=0.02)","def loadData(fname='Unstra.out2.00008.athdf'):\n #data=ath.athdf(fname,quantities=['B1','B2','B3'])\n time,data=ath.athdf(fname,quantities=['Bcc1'])\n bx = data['Bcc1']\n time,data=ath.athdf(fname,quantities=['Bcc2'])\n by = data['Bcc2']\n time,data=ath.athdf(fname,quantities=['Bcc3'])\n bz = data['Bcc3']\n x = data['x1f']\n y = data['x2f']\n z = data['x3f']\n # refinement\n rfac = 1.0\n ##if bx.shape[0] < 512:\n ## nz,ny,nx = bx.shape\n ## rfac = int(512/bx.shape[0])\n ## bx = np.repeat(bx,rfac,axis=0)\n ## bx = np.repeat(bx,rfac,axis=1)\n ## bx = np.repeat(bx,rfac,axis=2)\n ## by = np.repeat(by,rfac,axis=0)\n ## by = np.repeat(by,rfac,axis=1)\n ## by = np.repeat(by,rfac,axis=2)\n ## bz = np.repeat(bz,rfac,axis=0)\n ## bz = np.repeat(bz,rfac,axis=1)\n ## bz = np.repeat(bz,rfac,axis=2)\n # ---\n def curl(vx,vy,vz,dx,dy,dz):\n [dzvx,dyvx,dxvx] = np.gradient(vx)\n [dzvy,dyvy,dxvy] = np.gradient(vy)\n [dzvz,dyvz,dxvz] = np.gradient(vz)\n cx = dyvz/dy-dzvy/dz\n cy = dzvx/dz-dxvz/dx\n cz = dxvy/dx-dyvx/dy\n # No need to del the reference by one manually\n # allow python to perform its own garbage collection\n # after the function return cxyz\n #del dzvx\n #del dzvy\n #del dzvz\n return cx,cy,cz\n # ---\n dx = dz = (x[1]-x[0])/rfac\n dy = (y[1]-y[0])/rfac\n jx,jy,jz = curl(bx,by,bz,dx,dy,dz)\n j2 = jx**2+jy**2+jz**2\n return j2","def test_radar_request_site_historic_sweep_pcp_v_hdf5_yesterday(default_settings):\n\n timestamp = dt.datetime.utcnow() - dt.timedelta(days=1)\n\n request = DwdRadarValues(\n parameter=DwdRadarParameter.SWEEP_PCP_VELOCITY_H,\n start_date=timestamp,\n site=DwdRadarSite.BOO,\n fmt=DwdRadarDataFormat.HDF5,\n subset=DwdRadarDataSubset.SIMPLE,\n settings=default_settings,\n )\n results = list(request.query())\n\n if len(results) == 0:\n raise pytest.skip(\"Data currently not available\")\n\n # Verify number of elements.\n assert len(results) == 1\n\n # Get payload.\n buffer = results[0][1]\n payload = buffer.getvalue()\n\n # Verify data.\n assert payload.startswith(b\"\\x89HDF\\r\\n\")\n\n # Verify more details.\n # h5dump ras07-stqual-pcpng01_sweeph5onem_vradh_00-2020093000403400-boo-10132-hd5\n\n hdf = h5py.File(buffer, \"r\")\n\n assert hdf[\"/how/radar_system\"] is not None\n assert hdf[\"/how\"].attrs.get(\"task\") == b\"Sc_Pcp-NG-01_BOO\"\n assert hdf[\"/what\"].attrs.get(\"source\") == b\"WMO:10132,NOD:deboo\"\n\n assert hdf[\"/how\"].attrs.get(\"scan_count\") == 1\n assert hdf[\"/dataset1/how\"].attrs.get(\"scan_index\") == 1\n\n assert hdf[\"/dataset1/data1/data\"].shape in ((360, 600), (359, 600), (358, 600), (357, 600))\n\n timestamp = round_minutes(request.start_date, 5)\n assert hdf[\"/what\"].attrs.get(\"date\") == bytes(timestamp.strftime(\"%Y%m%d\"), encoding=\"ascii\")\n assert hdf[\"/what\"].attrs.get(\"time\").startswith(bytes(timestamp.strftime(\"%H%M\"), encoding=\"ascii\"))","def test_Lueker_Data_Csys(self):\n ld = pd.read_csv(\n \"tests/test_data/Lueker2000/Lueker2000_Table3.csv\", comment=\"#\"\n )\n\n # Calculate using cbsys\n # TA from DIC and fCO2\n cTA = Csys(\n DIC=ld.DIC.values,\n fCO2=ld.fCO2.values,\n T_in=ld.Temp.values,\n S_in=ld.Sal.values,\n )\n dTA = ld.TA - cTA.TA\n dTA_median = np.median(dTA)\n dTA_pc95 = np.percentile(dTA, [2.5, 97.5])\n self.assertLessEqual(abs(dTA_median), 2.5, msg=\"TA Offset <= 2.5\")\n self.assertTrue(all(abs(dTA_pc95 - dTA_median) <= 16), msg=\"TA 95% Conf <= 16\")\n\n # fCO2 from TA and DIC\n cfCO2 = Csys(\n TA=ld.TA.values, DIC=ld.DIC.values, T_in=ld.Temp.values, S_in=ld.Sal.values\n )\n dfCO2 = ld.fCO2 - cfCO2.fCO2\n dfCO2_median = np.median(dfCO2)\n # dfCO2_pc95 = np.percentile(dfCO2, [2.5, 97.5])\n dfCO2_percent_offset = 100 * dfCO2 / ld.fCO2\n self.assertLessEqual(dfCO2_median, 2.5, msg=\"fCO2 Offset <= 2.5\")\n self.assertLessEqual(np.std(dfCO2_percent_offset), 3, msg=\"fCO2 STD within 3%\")\n # print(dfCO2_pc95)\n # self.assertTrue(all(abs(dfCO2_pc95) <= 70), msg='fCO2 95% Conc <= 70')\n\n # DIC from TA and fCO2\n cDIC = Csys(\n TA=ld.TA.values,\n fCO2=ld.fCO2.values,\n T_in=ld.Temp.values,\n S_in=ld.Sal.values,\n )\n dDIC = ld.DIC - cDIC.DIC\n dDIC_median = np.median(dDIC)\n dDIC_pc95 = np.percentile(dDIC, [2.5, 97.5])\n self.assertLessEqual(abs(dDIC_median), 2, msg=\"DIC Offset <= 2\")\n self.assertTrue(all(abs(dDIC_pc95) <= 15), msg=\"DIC 95% Conc <= 15\")\n\n return","def test_sky_coord_classic(self):\n sc_cen = SkyCoord(SCS_CENTER)\n tab = conesearch.conesearch(\n sc_cen, SCS_RADIUS, catalog_db=self.url, verbose=self.verbose)\n assert len(tab) > 0","def test_GLODAPv2_Csys(self):\n # load GLODAP data\n gd = pd.read_csv(\"tests/test_data/GLODAP_data/GLODAPv2_pH_DIC_ALK_subset.csv\")\n gd.dropna(\n subset=[\n \"phtsinsitutp\",\n \"temperature\",\n \"salinity\",\n \"tco2\",\n \"talk\",\n \"pressure\",\n \"phosphate\",\n \"silicate\",\n ],\n inplace=True,\n )\n gd.pressure /= 10 # convert pressure to bar\n\n # set negative nutrient values to zero\n gd.phosphate[gd.phosphate < 0] = 0\n gd.silicate[gd.silicate < 0] = 0\n \n # exclude weird cruise 270 data\n gd = gd.loc[gd.cruise != 270]\n\n # calculate pH from TA and DIC\n cpH = Csys(\n TA=gd.talk,\n DIC=gd.tco2,\n T_in=gd.temperature,\n S_in=gd.salinity,\n P_in=gd.pressure,\n PT=gd.phosphate,\n SiT=gd.silicate,\n BT=415.7,\n )\n pH_resid = gd.phtsinsitutp - cpH.pHtot\n pH_median = np.median(pH_resid)\n pH_pc95 = np.percentile(pH_resid, [2.5, 97.5])\n\n self.assertLessEqual(abs(pH_median), 0.005, msg=\"pH Offset <= 0.005\")\n self.assertTrue(all(abs(pH_pc95) <= 0.05), msg=\"pH 95% Conf <= 0.05\")\n\n # calculate TA from pH and DIC\n cTA = Csys(\n pHtot=gd.phtsinsitutp,\n DIC=gd.tco2,\n T_in=gd.temperature,\n S_in=gd.salinity,\n P_in=gd.pressure,\n PT=gd.phosphate,\n SiT=gd.silicate,\n BT=415.7,\n )\n TA_resid = gd.talk - cTA.TA\n TA_median = np.median(TA_resid)\n TA_pc95 = np.percentile(TA_resid, [2.5, 97.5])\n\n self.assertLessEqual(abs(TA_median), 0.5, msg=\"TA Offset <= 0.5\")\n self.assertTrue(all(abs(TA_pc95) < 13), msg=\"TA 95% Conf <= 13\")\n\n # calculate DIC from TA and pH\n cDIC = Csys(\n pHtot=gd.phtsinsitutp,\n TA=gd.talk,\n T_in=gd.temperature,\n S_in=gd.salinity,\n P_in=gd.pressure,\n PT=gd.phosphate,\n SiT=gd.silicate,\n BT=415.7,\n )\n DIC_resid = gd.tco2 - cDIC.DIC\n DIC_median = np.median(DIC_resid)\n DIC_pc95 = np.percentile(DIC_resid, [2.5, 97.5])\n\n self.assertLessEqual(abs(DIC_median), 0.5, msg=\"DIC Offset <= 0.5\")\n self.assertTrue(all(abs(DIC_pc95) < 13), msg=\"DIC 95% Conf <= 13\")\n\n return","def create_output_database():\n\n# Do not alter the hdf5 file if it already exists\n if os.path.exists(database_path):\n print(\"DATABASE STATUS:\")\n print(\"\\t\" + database_path + \" already exists and is ready to store the results of computations\")\n return None\n# Create hdf5 file. The flag \"-w\" means \"create file, fail if exists\" \n else:\n computations_database = h5py.File(database_path, \"w-\")\n\n# Create initial data datasets and write initial data into them \n for initial_condition in initial_conditions:\n for k in range (6,17):\n dataset_initial_path = initial_condition + \"/k = \" + str(k) + \" initial_data\"\n computations_database[dataset_initial_path] = initial_data(initial_condition, k)\n# Create data groups for storing the results of computations \n for flux in fluxes: \n group_path = initial_condition + \"/\" + flux\n computations_database.create_group(group_path)\n\n# Write the appropriate attributes that are needed for particular computations, \n# i.e. create the appropriate environment for each computational method \n computations_database[group_path].attrs[\"a\"] = 3.0\n computations_database[group_path].attrs[\"T\"] = 9.0\n if flux == \"Lax_Wendroff_Fourth_Order\": \n computations_database[group_path].attrs[\"CFL\"] = 0.2\n elif flux in [\"Fromm_CFL_0.5\", \"Fromm_van_Leer_CFL_0.5\"]:\n computations_database[group_path].attrs[\"CFL\"] = 0.5\n else:\n computations_database[group_path].attrs[\"CFL\"] = 0.9\n \n computations_database.close() \n print(\"DATABASE STATUS:\")\n print(\"\\t\" + database_path + \" has been created and is ready to store the results of computations\")","def ncwrt_retrieval_config( retr_setup, outname=None ):\n\n #-- set name of file to be generated\n act_outname = outname if outname!=None else 'retrconfig.nc'\n msg = \"Start writing configuration file ***{}***...\".format(act_outname)\n FileLogger.info(msg)\n\n\n #-- compression settings\n zlev = retr_setup.zlev\n use_zlib = retr_setup.use_zlib\n\n #--\n schedule_dct = retr_setup.schedule_dct\n statevector = retr_setup.prstate\n #-- turn list into array\n sim_typ = np.array(schedule_dct['sim_typ'], dtype=np.int32)\n timepts = schedule_dct['date_utc']\n nstvar,npts = statevector.shape\n #-- overpass geometries SZA,SAA,VZA,VAA\n ivgeom = np.empty((npts,4), dtype=np.float64)\n ivgeom[:,0] = schedule_dct['sza']\n ivgeom[:,1] = schedule_dct['saa']\n ivgeom[:,2] = schedule_dct['vza']\n ivgeom[:,3] = schedule_dct['vaa']\n\n #-- temporal settings, create time-values (time-since)\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\n time_values = nc4.date2num(timepts, time_unit)\n\n #-- ensure directory exists\n mkdirp_smart(os.path.dirname(act_outname))\n\n #-- open file pointer\n ncfp = nc4.Dataset(act_outname, 'w')\n #-- add dimensions\n d1 = ncfp.createDimension('npoints',npts)\n d2 = ncfp.createDimension('ngeo',4)\n\n #-- time-value\n ncvar = ncfp.createVariable( 'time', statevector.dtype, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('standard_name','time')\n ncvar.setncattr('long_name','time')\n ncvar.setncattr('units', time_unit)\n ncvar[:] = time_values[:]\n\n #-- simulation type\n ncvar = ncfp.createVariable( 'sim_typ', sim_typ.dtype, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar[:] = sim_typ[:]\n ncvar.setncattr('long_name','simulation_type')\n ncvar.setncattr('comment', 'integer value which is to be bit-interpreted')\n ncvar.setncattr('nobits_set', 'time-point with other state')\n ncvar.setncattr('bit0_is_set', 'time-point for S1 simulation')\n ncvar.setncattr('bit1_is_set', 'time-point for S2 simulation')\n ncvar.setncattr('bit2_is_set', 'time-point for S1A simulation')\n ncvar.setncattr('bit3_is_set', 'time-point for S1B simulation')\n ncvar.setncattr('bit4_is_set', 'time-point for S2A simulation')\n ncvar.setncattr('bit5_is_set', 'time-point for S2B simulation')\n \n #-- illumination-view geometry\n ncvar = ncfp.createVariable( 'ivgeom', ivgeom.dtype, ('npoints','ngeo'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('sza','igeo: 0')\n ncvar.setncattr('saa','igeo: 1')\n ncvar.setncattr('vza','igeo: 2')\n ncvar.setncattr('vaa','igeo: 3')\n ncvar[:,:] = ivgeom[:,:]\n \n #-- global attributes\n ncfp.setncattr('creator_name',\"The Inversion Lab, Hamburg, Germany\")\n ncfp.setncattr('creator_email', \"Michael.Vossbeck(at)Inversion-Lab.com\")\n ncfp.setncattr('netcdf_libversion',\"{}\".format(nc4.__netcdf4libversion__))\n ncfp.setncattr('date_created',\"{}\".format(dt.datetime.utcnow().isoformat()))\n ncfp.setncattr('time_coverage_start',time_coverage_start)\n ncfp.setncattr('time_coverage_end',time_coverage_end)\n\n #-- close file pointer\n ncfp.close()\n\n # logging\n msg = \"...writing ***{}*** DONE\".format(act_outname)\n FileLogger.info(msg)","def test_NeuroPath1(self):\n \n self.delayDisplay(\"Starting the test\")\n #\n # first, get some data\n #\n import urllib\n downloads = (\n ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolume),\n )\n \n for url,name,loader in downloads:\n filePath = slicer.app.temporaryPath + '/' + name\n if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:\n logging.info('Requesting download %s from %s...\\n' % (name, url))\n urllib.urlretrieve(url, filePath)\n if loader:\n logging.info('Loading %s...' % (name,))\n loader(filePath)\n self.delayDisplay('Finished with download and loading')\n \n volumeNode = slicer.util.getNode(pattern=\"FA\")\n logic = NeuroPathLogic()\n self.assertTrue( logic.hasImageData(volumeNode) )\n self.delayDisplay('Test passed!')","def test_run_read(self):\n\n self.ictrl[0] = 1 + 2 + 4 + 8\n vmec_f90wrap.runvmec(self.ictrl, self.filename, self.verbose, \\\n self.fcomm, reset_file)\n\n self.assertTrue(self.ictrl[1] in success_codes)\n\n self.assertEqual(vmec_f90wrap.vmec_input.nfp, 3)\n self.assertEqual(vmec_f90wrap.vmec_input.mpol, 4)\n self.assertEqual(vmec_f90wrap.vmec_input.ntor, 3)\n print('rbc.shape:', vmec_f90wrap.vmec_input.rbc.shape)\n print('rbc:',vmec_f90wrap.vmec_input.rbc[101:103, 0:4])\n\n # n = 0, m = 0:\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.rbc[101,0], 1.3782)\n\n # n = 0, m = 1:\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.zbs[101,1], 4.6465E-01)\n\n # n = 1, m = 1:\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.zbs[102,1], 1.6516E-01)\n\n # Now try reading in the output\n wout_file = os.path.join(os.path.dirname(__file__), 'wout_li383_low_res.nc')\n ierr = 0\n vmec_f90wrap.read_wout_mod.read_wout_file(wout_file, ierr)\n self.assertEqual(ierr, 0)\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.betatot, \\\n 0.0426215030653306, places=4)\n\n print('iotaf.shape:',vmec_f90wrap.read_wout_mod.iotaf.shape)\n print('rmnc.shape:',vmec_f90wrap.read_wout_mod.rmnc.shape)\n\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.iotaf[-1], \\\n 0.654868168783638, places=4)\n\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.rmnc[0, 0], \\\n 1.4773028173065, places=4)","def test_h5file(dl2_shower_geometry_file):\n from ctapipe.io.tableloader import TableLoader\n\n # no input raises error\n with pytest.raises(ValueError):\n with TableLoader():\n pass\n\n # test we can use an already open file\n with tables.open_file(dl2_shower_geometry_file, mode=\"r+\") as h5file:\n with TableLoader(h5file=h5file) as loader:\n assert 25 in loader.subarray.tel\n loader.read_subarray_events()\n loader.read_telescope_events()","def _write_nemo_hr_file(rpn_hr_ds_path, nemo_hr_ds_path):\n with xarray.open_dataset(rpn_hr_ds_path) as rpn_hr:\n logging.debug(\n f\"calculating specific humidity & incoming longwave radiation from {rpn_hr_ds_path}\"\n )\n qair, ilwr, rh = _calc_qair_ilwr(rpn_hr)\n u_out, v_out = _rotate_winds(rpn_hr)\n data_vars = {\n \"nav_lon\": rpn_hr.nav_lon,\n \"nav_lat\": rpn_hr.nav_lat,\n # [:, 0] drops z dimension that NEMO will not tolerate\n \"qair\": qair[:, 0],\n \"RH_2maboveground\": rh[:, 0],\n \"therm_rad\": ilwr[:, 0],\n \"u_wind\": u_out[:, 0],\n \"v_wind\": v_out[:, 0],\n # \"LHTFL_surface\": ** needs to be calculated**,\n }\n nemo_rpn_vars = (\n (\"atmpres\", \"PN\"),\n (\"percentcloud\", \"NT\"),\n (\"PRATE_surface\", \"RT\"),\n (\"precip\", \"PR\"),\n (\"solar\", \"FB\"),\n (\"tair\", \"TT\"),\n )\n missing_vars = \"\"\n for nemo_var, rpn_var in nemo_rpn_vars:\n try:\n # [:, 0] drops z dimension that NEMO will not tolerate\n data_vars.update({nemo_var: getattr(rpn_hr, rpn_var)[:, 0]})\n except AttributeError:\n # Variable is missing from RPN dataset, so provide a placeholder DataArray\n # full of NaNs that we will deal with later via interpolation\n data_vars.update(\n {nemo_var: xarray.DataArray(numpy.full_like(qair[:, 0], numpy.nan))}\n )\n missing_vars = (\n \", \".join((missing_vars, nemo_var)) if missing_vars else nemo_var\n )\n logging.warning(f\"missing RPN variable {rpn_var} from {rpn_hr_ds_path}\")\n nemo_hr = xarray.Dataset(\n data_vars=data_vars, coords=rpn_hr.coords, attrs=rpn_hr.attrs\n )\n nemo_hr.attrs[\"history\"] += (\n f\"\\n{arrow.now().format('ddd MMM DD HH:mm:ss YYYY')}: \"\n f\"Add specific and relative humidity and incoming longwave radiation variables from \"\n f\"correlations\"\n )\n if missing_vars:\n nemo_hr.attrs[\"missing_variables\"] = missing_vars\n _add_vars_metadata(nemo_hr)\n _write_netcdf_file(nemo_hr, nemo_hr_ds_path)","def test_imsim():\n import yaml\n import astropy.units as u\n import matplotlib.pyplot as plt\n from tqdm import tqdm\n # Need these for `eval` below\n from numpy import array\n import coord\n\n with open(DATA_DIR / \"wcs_466749.yaml\", 'r') as f:\n wcss = yaml.safe_load(f)\n\n cmds = {}\n with open(DATA_DIR / \"phosim_cat_466749.txt\", 'r') as f:\n for line in f:\n k, v = line.split()\n try:\n v = int(v)\n except ValueError:\n try:\n v = float(v)\n except ValueError:\n pass\n cmds[k] = v\n\n # Values below (and others) from phosim_cat_466749.txt\n rc = cmds['rightascension']\n dc = cmds['declination']\n boresight = galsim.CelestialCoord(\n rc*galsim.degrees,\n dc*galsim.degrees\n )\n obstime = Time(cmds['mjd'], format='mjd', scale='tai')\n obstime -= 15*u.s\n band = \"ugrizy\"[cmds['filter']]\n wavelength_dict = dict(\n u=365.49,\n g=480.03,\n r=622.20,\n i=754.06,\n z=868.21,\n y=991.66\n )\n wavelength = wavelength_dict[band]\n camera = imsim.get_camera()\n\n rotTelPos = cmds['rottelpos'] * galsim.degrees\n telescope = imsim.load_telescope(f\"LSST_{band}.yaml\", rotTelPos=rotTelPos)\n # Ambient conditions\n # These are a guess.\n temperature = 293.\n pressure = 69.0\n H2O_pressure = 1.0\n\n # Start by constructing a refractionless factory, which we can use to\n # cross-check some of the other values in the phosim cmd file.\n factory = imsim.BatoidWCSFactory(\n boresight, obstime, telescope, wavelength,\n camera,\n temperature=temperature,\n pressure=0.0,\n H2O_pressure=H2O_pressure\n )\n\n aob, zob, hob, dob, rob, eo = factory._ICRF_to_observed(\n boresight.ra.rad, boresight.dec.rad, all=True\n )\n np.testing.assert_allclose(\n np.rad2deg(aob)*3600, cmds['azimuth']*3600,\n rtol=0, atol=2.0\n )\n np.testing.assert_allclose(\n (90-np.rad2deg(zob))*3600, cmds['altitude']*3600,\n rtol=0, atol=6.0,\n )\n q = factory.q * galsim.radians\n rotSkyPos = rotTelPos - q\n # Hmmm.. Seems like we ought to be able to do better than 30 arcsec on the\n # rotator? Maybe this is defined at a different point in time? Doesn't seem\n # to affect the final WCS much though.\n np.testing.assert_allclose(\n rotSkyPos.deg*3600, cmds['rotskypos']*3600,\n rtol=0, atol=30.0,\n )\n\n # We accidentally simulated DC2 with the camera rotated 180 degrees too far.\n # That includes the regression test data here. So to fix the WCS code, but\n # still use the same regression data, we need to add 180 degrees here. Just\n # rotate the camera by another 180 degrees\n telescope = telescope.withLocallyRotatedOptic(\n \"LSSTCamera\", batoid.RotZ(np.deg2rad(180))\n )\n\n # For actual WCS check, we use a factory that _does_ know about refraction.\n factory = imsim.BatoidWCSFactory(\n boresight, obstime, telescope, wavelength,\n camera,\n temperature=temperature,\n pressure=pressure,\n H2O_pressure=H2O_pressure\n )\n\n do_plot = False\n my_centers = []\n imsim_centers = []\n if do_plot:\n _, ax = plt.subplots(nrows=1, ncols=1, figsize=(12, 12))\n i = 0\n r1 = []\n d1 = []\n r2 = []\n d2 = []\n rng = np.random.default_rng(1234)\n for k, v in tqdm(wcss.items()):\n name = k[18:25].replace('-', '_')\n det = camera[name]\n cpix = det.getCenter(cameraGeom.PIXELS)\n\n wcs = factory.getWCS(det, order=2)\n wcs1 = eval(v)\n # Need to adjust ab parameters to new GalSim convention\n wcs1.ab[0,1,0] = 1.0\n wcs1.ab[1,0,1] = 1.0\n\n my_centers.append(wcs.posToWorld(galsim.PositionD(cpix.x, cpix.y)))\n imsim_centers.append(wcs1.posToWorld(galsim.PositionD(cpix.x, cpix.y)))\n\n corners = det.getCorners(cameraGeom.PIXELS)\n xs = np.array([corner.x for corner in corners])\n ys = np.array([corner.y for corner in corners])\n ra1, dec1 = wcs.xyToradec(xs, ys, units='radians')\n ra2, dec2 = wcs1.xyToradec(xs, ys, units='radians')\n if i == 0:\n labels = ['batoid', 'PhoSim']\n else:\n labels = [None]*2\n if do_plot:\n ax.plot(ra1, dec1, c='r', label=labels[0])\n ax.plot(ra2, dec2, c='b', label=labels[1])\n\n # add corners to ra/dec check lists\n r1.extend(ra1)\n d1.extend(dec1)\n r2.extend(ra2)\n d2.extend(dec2)\n # Add some random points as well\n xs = rng.uniform(0, 4000, 100)\n ys = rng.uniform(0, 4000, 100)\n ra1, dec1 = wcs.xyToradec(xs, ys, units='radians')\n ra2, dec2 = wcs1.xyToradec(xs, ys, units='radians')\n r1.extend(ra1)\n d1.extend(dec1)\n r2.extend(ra2)\n d2.extend(dec2)\n i += 1\n\n if do_plot:\n ax.legend()\n xlim = ax.get_xlim()\n ax.set_xlim(xlim[1], xlim[0])\n plt.show()\n\n dist = sphere_dist(r1, d1, r2, d2)\n print(\"sphere dist mean, max, std\")\n print(\n np.rad2deg(np.mean(dist))*3600,\n np.rad2deg(np.max(dist))*3600,\n np.rad2deg(np.std(dist))*3600,\n )\n np.testing.assert_array_less(\n np.rad2deg(np.mean(dist))*3600,\n 5.0\n )\n if do_plot:\n plt.hist(np.rad2deg(dist)*3600, bins=100)\n plt.show()\n\n if do_plot:\n r1 = np.array([c.ra.rad for c in my_centers])\n d1 = np.array([c.dec.rad for c in my_centers])\n r2 = np.array([c.ra.rad for c in imsim_centers])\n d2 = np.array([c.dec.rad for c in imsim_centers])\n cd = np.cos(np.deg2rad(cmds['declination']))\n q = plt.quiver(r1, d1, np.rad2deg(r1-r2)*3600*cd, np.rad2deg(d1-d2)*3600)\n plt.quiverkey(q, 0.5, 1.1, 5.0, \"5 arcsec\", labelpos='E')\n plt.show()","def write_cfradial(output_filename, start_dt, minutes, timeres_s = 5, \n altres_m =60, maxtimeslice_td=datetime.timedelta(seconds=30*60), \n instrument='gvhsrl', min_alt_m=0, max_alt_m=5000,store_calibrations=False):\n\n cdl = locate_file('hsrl_cfradial.cdl', forModule=lgtb)\n print 'CDL = ', cdl\n timeres_td = datetime.timedelta(seconds=timeres_s)\n\n netcdf = Dataset(output_filename, 'w', clobber=True)\n delta = datetime.timedelta(minutes=minutes)\n timeres_delta = datetime.timedelta(seconds=timeres_s)\n end_dt = start_dt + delta\n\n gen = dpl_hsrl(instrument)\n\n if store_calibrations: # to store calibrations, newer actors are needed, as well as the precall methods (FIXME better design)\n import maestro.netcdf_precall as npc\n args=[]\n kwargs=dict(output=netcdf,template=cdl,usecfradial=True,basetime=start_dt)\n x=npc.addConstantsToParms(npc.addCalibrationsToNetCDF())\n hsrlnar=gen(start_dt, end_dt, timeres_timedelta=timeres_delta, min_alt_m=min_alt_m, max_alt_m=max_alt_m, altres_m=altres_m)\n x(hsrlnar,args,kwargs)\n nar=artists.dpl_netcdf_artist(hsrlnar,*args,**kwargs)\n #framestream,template,outputfilename=None,format=None,usecfradial=None,selected_bindings=None,output=None,forModule=None,withUnlimited=None,basetime=None,addAttributes={}):\n for x in nar:\n pass\n else:\n v = None\n try:\n # store each lidar record\n for tzg in gen(start_dt, end_dt, timeres_timedelta=timeres_delta, min_alt_m=min_alt_m, max_alt_m=max_alt_m, altres_m=altres_m):\n if v == None:\n v = cfr.DplCreateCfradial(cdl, netcdf, tzg)\n v.append_data(tzg)\n\n v.close()\n\n except RuntimeError, msg:\n print msg\n traceback.print_exc()\n print 'write_cfradial: could not process data for %s starting at %s' % \\\n (instrument, start_dt.strftime('%Y-%m-%d %H:%M:%S'))","def read_dr3_spectrum(path, common_dispersion=None, bounds_error=False):\n\n header_keys = (\"helio_rv\", \"z\", \"z_err\")\n\n with fits.open(path) as image:\n # data array indices:\n # flux, inverse variance, wavelength, andmask, ormask.\n flux, ivar, dispersion, and_mask, or_mask = image[0].data\n\n # Create a meta dictionary that contains things we will probably care \n # about later on, and the path so that we can trace provenance of other\n # things as needed.\n meta = dict(path=path)\n for header_key in header_keys:\n meta[header_key] = image[0].header[header_key.upper()]\n\n # Use the OR mask to set the inverse variances to zero for any pixels with\n # indications of being bad. For example, the bit mask meanings are:\n # 1 : BADCCD : bad pixel on CCD\n # 2 : BADPROFILE : bad profile in extraction\n # 3 : NOSKY : no sky information at this wavelength\n # 4 : BRIGHTSKY : sky level too high\n # 5 : BADCENTER : fibre trace out of the CCD\n # 6 : NODATA : no good data.\n\n # From http://dr3.lamost.org/doc/data-production-description\n\n # These are all bad things. And the LAMOST pipeline people are more familiar\n # with the data than we are. So let's believe them.\n\n rest_dispersion = dispersion * (1 - meta[\"z\"])\n ivar[or_mask > 0] = 0.0\n\n if common_dispersion is not None:\n flux = (interpolate.interp1d(rest_dispersion, flux,\n bounds_error=bounds_error, fill_value=1))(common_dispersion)\n ivar = (interpolate.interp1d(rest_dispersion, ivar,\n bounds_error=bounds_error, fill_value=0))(common_dispersion)\n\n rest_dispersion = common_dispersion\n ivar[ivar < 0] = 0\n\n assert np.all(ivar >= 0), \"negative inverse variances\"\n assert np.all(np.isfinite(flux)), \"non-finite fluxes\"\n\n return (rest_dispersion, flux, ivar, meta)","def find_hrc_calib_obsid(inst):\n##\n##--- create a list of already processed data\n##\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/6* > '+ zspace\n# os.system(cmd)\n# with open(zspace, 'r') as f:\n# ftest = f.read()\n# wrd = str(inst) + '/61'\n# mc = re.search(wrd, ftest)\n# if mc is not None:\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/61* >' + zspace\n# os.system(cmd)\n#\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/62* >' + zspace\n# os.system(cmd)\n#\n# data = mcf.read_data_file(zspace, remove=1)\n# prev_list = []\n# for ent in data:\n# atemp = re.split('\\/', ent)\n# prev_list.append(int(float(atemp[-1])))\n#\n##\n##--- find today's date and set checking range for the last 30 days\n##\n# today = time.strftime('%Y:%j:%H:%M:%S', time.gmtime())\n# today = int(Chandra.Time.DateTime(today).secs)\n# start = today - 10 * 86400\n##\n##--- extract hrc obsid information\n##\n# line = 'operation=browse\\n'\n# line = line + 'dataset=flight\\n'\n# line = line + 'level=1\\n'\n# line = line + 'detector=hrc\\n'\n# line = line + 'filetype=evt1\\n'\n# line = line + 'tstart=' + str(start) + '\\n'\n# line = line + 'tstop=' + str(today) + '\\n'\n# line = line + 'go\\n'\n#\n# with open('zline', 'w') as fo:\n# fo.write(line)\n#\n# cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > ' + zspace\n# os.system(cmd)\n#\n# mcf.rm_files('./zline')\n#\n# data = mcf.read_data_file(zspace, remove=1)\n##\n##--- select obsids with 61* and 62* starting\n##\n# h_list = []\n# for ent in data:\n# mc = re.search('hrcf', ent)\n# if mc is not None:\n# atemp = re.split('hrcf', ent)\n# btemp = re.split('_', atemp[1])\n# obsid = int(float(btemp[0]))\n# if obsid > 61000 and obsid < 63000:\n##\n##--- if it is already observed skip it\n##\n# if obsid in prev_list:\n# continue\n##\n##--- check which instrument\n##\n# chk = check_inst(obsid)\n# if chk == inst:\n# h_list.append(obsid)\n\n\n\n h_list = ['62410', '62423', '62435', '62437', '62439', '62441', '62443', '62635', '62637', '62649', '62973', '62997', '62422', '62426', '62436', '62438', '62440', '62442', '62446', '62636', '62638', '62796', '62991']\n\n\n return h_list","def HD_input_sncosmo_data(self, sn_list):\n\n dico = cPickle.load(open(SUGAR_parameter_pkl))\n self.read_sncosmo(path='../sugar_analysis_data/results/res_salt2_SNF_5_nomodelcov.txt')\n self.read_meta()\n self.read_snfit_results()\n Filtre = np.array([True]*len(self.sncosmo_sn_name))\n self.zcmb = []\n self.z_err = []\n for j, sn_name in enumerate(self.sncosmo_sn_name):\n# if self.sncosmo_sn_name[j] in dico.keys():\n#\n# for i in range (len(self.meta_sn_name_list)):\n# if self.sncosmo_sn_name[j] == self.meta_sn_name_list[i]:\n# \n# self.z_err.append(self.meta_zhl_err[i])\n# self.zcmb.append(self.meta_zcmb[i])\n# if np.abs(self.sncosmo_x1[j] - self.x1[i]) > 0.01:\n# i print 'problem with %s include in sample but big difference between sncosmo and snfit'%(self.sncosmo_sn_name[j])\n# else:\n# Filtre[j] = False\n if sn_name in sn_list:\n Filtre[j] = True\n else:\n Filtre[j] = False\n\n for p in dico.keys():\n if p not in self.sncosmo_sn_name:\n print p\n\n self.sncosmo_x1 = self.sncosmo_x1[Filtre]\n self.sncosmo_x1_err = self.sncosmo_x1_err[Filtre] \n self.sncosmo_c = self.sncosmo_c[Filtre]\n self.sncosmo_c_err = self.sncosmo_c_err[Filtre]\n self.sncosmo_mb = self.sncosmo_mb[Filtre]\n self.sncosmo_mb_err = self.sncosmo_mb_err[Filtre]\n self.sncosmo_cov_x1_c = self.sncosmo_cov_x1_c[Filtre]\n self.sncosmo_cov_mb_x1 = self.sncosmo_cov_mb_x1[Filtre]\n self.sncosmo_cov_mb_c = self.sncosmo_cov_mb_c[Filtre]\n self.sncosmo_z = self.sncosmo_z[Filtre]\n self.zcmb = np.array(self.zcmb)\n self.z_err = np.array(self.z_err)\n\n self.sncosmo_cov_y = np.zeros((len(self.sncosmo_mb)*3,len(self.sncosmo_mb)*3))\n \n for i in range (len(self.sncosmo_mb)):\n self.sncosmo_cov_y[i*3,i*3] = self.sncosmo_mb_err[i]**2\n self.sncosmo_cov_y[i*3+ 1,i*3+ 1] = self.sncosmo_x1_err[i]**2\n \n self.sncosmo_cov_y[i*3+ 2,i*3+ 2] = self.sncosmo_c_err[i]**2\n self.sncosmo_cov_y[i*3+ 0,i*3+ 1] = self.sncosmo_cov_mb_x1[i]\n self.sncosmo_cov_y[i*3+ 1,i*3+ 0] = self.sncosmo_cov_mb_x1[i]\n self.sncosmo_cov_y[i*3+ 0,i*3+ 2] = self.sncosmo_cov_mb_c[i]\n self.sncosmo_cov_y[i*3+ 2,i*3+ 0] = self.sncosmo_cov_mb_c[i]\n self.sncosmo_cov_y[i*3+ 1,i*3+ 2] = self.sncosmo_cov_x1_c[i] \n self.sncosmo_cov_y[i*3+ 2,i*3+ 1] = self.sncosmo_cov_x1_c[i] \n \n self.salt_parm = np.array([self.sncosmo_mb,self.sncosmo_x1,self.sncosmo_c]).T\n print len(self.salt_parm), len(self.sncosmo_cov_y), len(self.sncosmo_z), len(self.zcmb)\n return self.salt_parm, self.sncosmo_cov_y, self.sncosmo_z, self.zcmb, self.z_err","def consolidate(max_rounds, int_fwm,master_index, index, filename = 'data_large'):\n\n\n layer_0 = '0/0'\n filepath = 'output{}/output{}/data/'.format(master_index, index)\n file_read = filepath + filename\n file_save = filepath + filename+'_conc'\n \n # Input data, small, no need to cons\n D = read_variables(file_read, '0/0')\n save_variables(file_save, 'input', **D)\n\n if max_rounds ==0:\n max_rounds +=1\n U_cons = np.zeros([4,max_rounds, 7*int_fwm.nt], dtype = np.complex128)\n # Reading of all the oscillating spectra and sending them to a 3D array\n unfortmated_string = '{}/{}/U'\n with h5py.File(file_read+'.hdf5', 'r') as f:\n for pop in range(1,5):\n for r in range(max_rounds):\n U_cons[pop - 1,r,:] = f.get(unfortmated_string.format(pop,r)).value\n save_variables(file_save, 'results', U = U_cons) \n os.system('mv '+file_save+'.hdf5 '+file_read+'.hdf5')\n return None","def test_real_file(self):\n log.info('===== START TEST BYTE LOSS =====')\n\n # Recovered\n file_path = os.path.join(RESOURCE_PATH, '11079364_SNA_SNA.txt')\n\n stream_handle = open(file_path, MODE_ASCII_READ)\n\n self.create_parser(stream_handle, telem_flag=False)\n\n particles = self.parser.get_records(182)\n\n log.debug(\"*** test_real_file Num particles %s\", len(particles))\n\n # check all the values against expected results.\n self.assert_particles(particles, '11079364_SNA_SNA_recov.yml', RESOURCE_PATH)\n self.assertEquals(self.exception_callback_value, [])\n stream_handle.close()\n\n # Telemetered\n file_path = os.path.join(RESOURCE_PATH, '11079419_SNA_SNA.txt')\n\n stream_handle = open(file_path, MODE_ASCII_READ)\n\n self.create_parser(stream_handle)\n\n particles = self.parser.get_records(172)\n\n log.debug(\"*** test_real_file Num particles %s\", len(particles))\n\n # check all the values against expected results.\n self.assert_particles(particles, '11079419_SNA_SNA_telem.yml', RESOURCE_PATH)\n stream_handle.close()\n\n log.info('===== END TEST REAL FILE =====')","def test_header_update8(self, capsys):\n\n # Prepare input files.\n self.get_data(\"input\", \"ocu252cmq_raw.fits\")\n self.get_data(\"input\", \"ocu252cmq_spt.fits\")\n\n capsys.readouterr()\n\n tastis('ocu252cmq_raw.fits', update=True)\n\n captured = capsys.readouterr()\n assert captured.out == \"===============================================================================\\n\" \\\n \"ocu252cmq HST/STIS MIRVIS F28X50OII ACQ/POINT\\n\" \\\n \"prop: 14143 visit: 52 line: 1 target: BD+41-3306\\n\" \\\n \"obs date, time: 2016-06-06 08:30:05 exposure time: 2.10\\n\" \\\n \"dom GS/FGS: N2JU001340F2 sub-dom GS/FGS: N2K1001229F1\\n\" \\\n \"ACQ params: bias sub: 1510 checkbox: 3 method: FLUX CENTROID\\n\" \\\n \"subarray (axis1,axis2): size=(100,100) corner=(487,466)\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"Coarse locate phase: Target flux in max checkbox (DN): 1442\\n\" \\\n \"\\n\" \\\n \" global local\\n\" \\\n \" axis1 axis2 axis1 axis2\\n\" \\\n \"Target location: 527.8 513.1 41.8 48.1\\n\" \\\n \"\\n\" \\\n \" axis1 axis2 axis1 axis2 V2 V3\\n\" \\\n \" (pixels) (arcsec) (arcsec)\\n\" \\\n \"Estimated slew: -7.9 -2.9 -0.400 -0.147 -0.387 -0.179\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"Fine locate phase: Target flux in max checkbox (DN): 611\\n\" \\\n \"\\n\" \\\n \" global local\\n\" \\\n \" axis1 axis2 axis1 axis2\\n\" \\\n \"Target location: 534.1 516.1 48.1 51.1\\n\" \\\n \"Ref ap location: 537.5 516.5 19.5 16.5\\n\" \\\n \"\\n\" \\\n \" axis1 axis2 axis1 axis2 V2 V3\\n\" \\\n \" (pixels) (arcsec) (arcsec)\\n\" \\\n \"Estimated slew: -2.1 -0.4 -0.106 -0.020 -0.089 -0.061\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"Total est. slew: -10.0 -3.3 -0.506 -0.168 -0.477 -0.239\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"The fluxes in the maximum checkbox in the fine and coarse stages differ\\n\" \\\n \"by more than 25%. This may indicate a problem with your acquisition.\\n\" \\\n \"\\n\" \\\n \"===============================================================================\\n\"\n\n # Compare results\n outputs = [(\"ocu252cmq_raw.fits\", \"ocu252cmq_raw_ref.fits\")]\n self.compare_outputs(outputs)","def read(files, save):\n\t# NOTE all soundings are size obs long, they must be filled in with zeros for this data format...\n\t# create the HDF5 document\n\tdoc = h5(save)\n\tsize = 450 # this hopefully exceeds the size of the arrays # CPIN Files are much shorter...\n\tdoc.create(pres=size, temp=size, dewpt=size, rh=size, r=size, u=size, v=size, z=size, lat=1, lon=1, theta=size, thte=size,\n\t\twspd=size, wdir=size, gamma=size, stab=size, N=size, rich=size, thtdef=size, cpin=size)\n\t# those last two do not have to be included...\n\t# Z=geopotenital height\n\n\t# now read the files!\n\tfor f in sorted(files):\n\t\tfname = f.split('/')[-1]\n\t\t# if 'smth' not in fname and NCAR not in fname: continue\n\t\tl.info('reading ' + fname)\n\t\t# launch time comes from line 2 of the file, the last element\n\t\tdf = open(f, 'r')\n\t\ttxt = df.read(2000).split('\\n') # way more than we need\n\t\tdf.close()\n\t\tlatln = txt[0].split() # keys 1,2 will be what we want\n\t\ttry:\n\t\t\ttm = s2t(txt[1].split()[-1] + 'UTC', '%Y%m%d%H%M%Z')\n\t\texcept:\n\t\t\t# drat.\n\t\t\tprint txt.split('\\n')[1]\n\t\t\tcontinue\n\t\ttry:\n\t\t\tif 'cpin' in fname:\n\t\t\t\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich, thtdef, cpin = np.loadtxt(f, skiprows=4, unpack=True)\n\t\t\t\t# r is mixing ratio\n\t\t\telse:\n\t\t\t\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich = np.loadtxt(f, skiprows=4, unpack=True)\n\t\t\t\t# r is mixing ratio\n\t\texcept:\n\t\t\tl.warning('This file could not be read')\n\t\t\tcontinue\n\n\t\t# and append this data! I will trust the time seconds, instead of recomputing the time\n\t\t# but, before that, we have to make them all the same size - size long\n\t\tnl = np.zeros(size - t.shape[0]) - 999.00 # -999 array to fluff the end\n\t\tp = np.concatenate((p, nl))\n\t\tt = np.concatenate((t, nl))\n\t\ttd = np.concatenate((td, nl))\n\t\trh = np.concatenate((rh, nl))\n\t\tr = np.concatenate((r, nl))\n\t\ttv = np.concatenate((tv, nl))\n\t\ttht = np.concatenate((tht, nl))\n\t\tthte = np.concatenate((thte, nl))\n\t\tws = np.concatenate((ws, nl))\n\t\twd = np.concatenate((wd, nl))\n\t\tgamma = np.concatenate((gamma, nl))\n\t\tstab = np.concatenate((stab, nl))\n\t\tN = np.concatenate((N, nl))\n\t\trich = np.concatenate((rich, nl))\n\t\tu = np.concatenate((u, nl))\n\t\tv = np.concatenate((v, nl))\n\t\tz = np.concatenate((z, nl))\n\t\tif 'cpin' in fname:\n\t\t\tcpin = np.concatenate((cpin, nl))\n\t\t\tthtdef = np.concatenate((thtdef, nl))\n\t\t\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\n\t\t\t\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich, cpin=cpin, thtdef=thtdef)\n\t\telse:\n\t\t\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\n\t\t\t\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich)\n\tdoc.close()","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs\"\n \"/lake_analysis_one_21_Jun_2021\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022\")\n ref_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\",\n \"30min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_flowtocell.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\",\n \"30min_catchments.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_catchments.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\",\n \"30min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\",\n \"30min_rmouth_flowtocell.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_rmouth_flowtocell.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='default',\n catchment_and_outflows_mods_list_filename=\\\n None,\n #additional_matches_list_filename=\\\n #\"additional_matches_ice6g_vs_ice5g_lgm.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='HD')","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 retrieve_cloudmask(\n self, output_binary=True, include_thermal_test=True, include_channel_r5=True\n ):\n\n # Read visual near infrared (VNIR) channels at 15m resolution.\n r1 = self.get_reflectance(channel=\"1\")\n r2 = self.get_reflectance(channel=\"2\")\n r3N = self.get_reflectance(channel=\"3N\")\n\n # Read short-wave infrared (SWIR) channels at 30m resolution and match\n # VNIR resolution.\n r5 = self.get_reflectance(channel=\"5\")\n if self.datetime > datetime.datetime(2007, 5, 1) or not include_channel_r5:\n # The SWIR sensor suffered from temperature problems after May\n # 2007. Images later on are set to a dummy value \"1\", which won't\n # influence the following thresholding tests. Swath edge NaN pixels\n # stay NaN.\n r5[~np.isnan(r5)] = 1\n r5 = np.repeat(np.repeat(r5, 2, axis=0), 2, axis=1)\n\n # Read thermal (TIR) channel at 90m resolution and match VNIR\n # resolution.\n bt14 = self.get_brightnesstemperature(channel=\"14\")\n bt14 = np.repeat(np.repeat(bt14, 6, axis=0), 6, axis=1)\n\n # Ratios for clear-cloudy-tests.\n r3N2 = r3N / r2\n r12 = r1 / r2\n\n ### TEST 1-4 ###\n # Set cloud mask to default \"confidently clear\".\n clmask = np.ones(r1.shape, dtype=np.float) * 2\n\n with np.warnings.catch_warnings():\n np.warnings.filterwarnings(\"ignore\", r\"invalid value encountered\")\n\n # Set \"probably clear\" pixels.\n clmask[\n multiple_logical(\n r3N > 0.03,\n r5 > 0.01,\n 0.7 < r3N2,\n r3N2 < 1.75,\n r12 < 1.45,\n func=np.logical_and,\n )\n ] = PROBABLY_CLEAR\n\n # Set \"probably cloudy\" pixels.\n clmask[\n multiple_logical(\n r3N > 0.03,\n r5 > 0.015,\n 0.75 < r3N2,\n r3N2 < 1.75,\n r12 < 1.35,\n func=np.logical_and,\n )\n ] = PROBABLY_CLOUDY\n\n # Set \"confidently cloudy\" pixels\n clmask[\n multiple_logical(\n r3N > 0.065,\n r5 > 0.02,\n 0.8 < r3N2,\n r3N2 < 1.75,\n r12 < 1.2,\n func=np.logical_and,\n )\n ] = CONFIDENTLY_CLOUDY\n\n # Combine swath edge pixels.\n clmask[\n multiple_logical(\n np.isnan(r1),\n np.isnan(r2),\n np.isnan(r3N),\n np.isnan(r5),\n func=np.logical_or,\n )\n ] = np.nan\n\n if include_thermal_test:\n ### TEST 5 ###\n # Uncertain warm ocean pixels, higher than the 5th percentile of\n # brightness temperature values from all \"confidently clear\"\n # labeled pixels, are overwritten with \"confidently clear\".\n\n # Check for available \"confidently clear\" pixels.\n nc = np.sum(clmask == 2) / np.sum(~np.isnan(clmask))\n if nc > 0.03:\n bt14_p05 = np.nanpercentile(bt14[clmask == 2], 5)\n else:\n # If less than 3% of pixels are \"confidently clear\", test 5\n # cannot be applied according to Werner et al., 2016. However,\n # a sensitivity study showed that combining \"probably clear\"\n # and \"confidently clear\" pixels in such cases leads to\n # plausible results and we derive a threshold correspondingly.\n bt14_p05 = np.nanpercentile(\n bt14[np.logical_or(clmask == 2, clmask == 3)], 5\n )\n\n with np.warnings.catch_warnings():\n np.warnings.filterwarnings(\"ignore\", r\"invalid value encountered\")\n # Pixels with brightness temperature values above the 5th\n # percentile of clear ocean pixels are overwritten with\n # \"confidently clear\".\n clmask[np.logical_and(bt14 > bt14_p05, ~np.isnan(clmask))] = 2\n\n # Combine swath edge pixels.\n clmask[np.logical_or(np.isnan(clmask), np.isnan(bt14))] = np.nan\n\n if output_binary:\n clmask[np.logical_or(clmask == 2, clmask == 3)] = 0 # clear\n clmask[np.logical_or(clmask == 4, clmask == 5)] = 1 # cloudy\n\n return clmask","def ncwrt_retrieval_obs_s1(retr_setup, outname=None):\n\n #-- set name of file to be generated\n act_outname = outname if outname!=None else 'obs_s1.nc'\n msg = \"Start writing configuration file ***{}***...\".format(act_outname)\n FileLogger.info(msg)\n\n #-- compression settings\n zlev = retr_setup.zlev\n use_zlib = retr_setup.use_zlib\n\n #-- retrieval settings\n s1_table = retr_setup.obs_dct['S1']\n timepts = s1_table.geom.date_utc\n npts = len(timepts)\n s1_satid = np.array(s1_table.sat_id_lst, dtype=str)\n s1_data = s1_table.data\n s1_dataunc = s1_table.dataunc\n nt,npol = s1_data.shape\n\n #-- temporal settings, create time-values (time-since)\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\n time_values = nc4.date2num(timepts, time_unit)\n\n #-- ensure directory exists\n mkdirp_smart(os.path.dirname(act_outname))\n\n #-- open file pointer\n ncfp = nc4.Dataset(act_outname, 'w')\n #-- add dimensions\n d1 = ncfp.createDimension('npoints',npts)\n d2 = ncfp.createDimension('npol',npol)\n\n #-- time-value\n ncvar = ncfp.createVariable( 'time', np.float64, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('standard_name','time')\n ncvar.setncattr('long_name','time')\n ncvar.setncattr('units', time_unit)\n ncvar[:] = time_values[:]\n\n unit_one = np.float64(1)\n # backscatter\n ncvar = ncfp.createVariable( 'backscatter', np.float64, ('npoints','npol'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'backscatter in VH and VV polarisation')\n comment = \"VH is associated to npol=0, VV to npol=1.\"\n comment += \" linear units are used (not [dB]).\"\n ncvar.setncattr('comment', comment)\n ncvar.setncattr('units',unit_one)\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\n ncvar[:,:] = s1_data[:,:]\n\n # backscatter uncertainty\n ncvar = ncfp.createVariable( 'backscatter_unc', np.float64, ('npoints','npol'),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'backscatter uncertainty in VH and VV polarisation')\n comment = \"uniform uncertainty of {} [dB] was applied on the observed backscatter\".format(\n retr_setup.s1_unc_db)\n ncvar.setncattr('comment', comment)\n ncvar.setncattr('units',unit_one)\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\n ncvar[:,:] = s1_dataunc[:,:]\n\n # satellite identifier\n ncvar = ncfp.createVariable( 'satellite_id', str, ('npoints',),\n zlib=use_zlib, complevel=zlev )\n ncvar.setncattr('long_name', 'satellite identifer')\n ncvar[:] = s1_satid[:]\n\n #-- global attributes\n ncfp.setncattr('creator_name',\"The Inversion Lab, Hamburg, Germany\")\n ncfp.setncattr('creator_email', \"Michael.Vossbeck(at)Inversion-Lab.com\")\n ncfp.setncattr('netcdf_libversion',\"{}\".format(nc4.__netcdf4libversion__))\n ncfp.setncattr('date_created',\"{}\".format(dt.datetime.utcnow().isoformat()))\n ncfp.setncattr('time_coverage_start',time_coverage_start)\n ncfp.setncattr('time_coverage_end',time_coverage_end)\n\n #-- close file pointer\n ncfp.close()\n\n # logging\n msg = \"...writing ***{}*** DONE\".format(act_outname)\n FileLogger.info(msg)","def getCSD (LFP_input_data=None,LFP_input_file=None,sampr=None,dt=None,spacing_um=None,minf=0.05,maxf=300,norm=True,vaknin=True,save_to_sim=True,getAllData=False): # timeRange=None,\n\n ############### DEFAULT -- CONDITION 1 : LFP DATA COMES FROM SIMULATION ###############\n\n if LFP_input_data is None and LFP_input_file is None: ### GET LFP DATA FROM SIMULATION\n try:\n from .. import sim \n except:\n print('No LFP input data, input file, or existing simulation. Cannot calculate CSD.')\n else:\n ## Check if LFP was recorded during the simulation \n print('getCSD() is using LFP data from existing simulation.')\n\n\n # time step used in simulation recording \n if dt is None:\n dt = sim.cfg.recordStep # units: ms \n print('dt = ' + str(dt) + ' (units: ms)')\n\n\n sim_data_categories = sim.allSimData.keys()\n \n # Get LFP data from sim and instantiate as a numpy array \n if 'LFP' in sim_data_categories:\n lfp_data = np.array(sim.allSimData['LFP'])\n print('lfp_data shape = ' + str(lfp_data.shape))\n elif 'LFP' not in sim_data_categories:\n print('!! WARNING: NO LFP DATA !! Need to re-run simulation with cfg.recordLFP enabled')\n\n\n # Sampling rate of data recording during the simulation \n if sampr is None:\n sampr = 1./(sim.cfg.recordStep/1000.0) # divide by 1000.0 to turn denominator from units of ms to s\n\n\n # Spacing between electrodes --> convert from micron to mm \n if spacing_um is None:\n print('NOTE: using sim.cfg.recordLFP to determine spacing_um !!')\n spacing_um = sim.cfg.recordLFP[1][1] - sim.cfg.recordLFP[0][1]\n\n\n\n\n ############### CONDITION 2 : ARBITRARY LFP DATA ############################\n ## NOTE: EXPAND CAPABILITY TO INCLUDE LIST OF MULTIPLE FILES \n \n ## LOAD SIM DATA FROM JSON FILE\n elif LFP_input_data is None and '.json' in LFP_input_file:\n data = {}\n with open(LFP_input_file) as file:\n data['json_input_data'] = json.load(file)\n\n ## FOR MULTIPLE FILES\n #for x in LFP_input_file:\n #with open(x) as file:\n #data[x] = json.load(file)\n\n\n ## EXTRACT LFP DATA \n for key in data.keys:\n lfp_data_list = data[key]['simData']['LFP'] # only works in the 1 input file scenario; expand capability for multiple files \n \n ## CAST LFP DATA AS NUMPY ARRAY \n lfp_data = np.array(lfp_data_list)\n\n ## GET CSD DATA AND RELEVANT PLOTTING PARAMS \n csd_data = {}\n for i in data.keys():\n csd_data[i] = {} # e.g. csd['json_input_data'] = {}\n\n if sampr is None:\n csd_data[i]['sampr'] = 1./((data[i]['simConfig']['recordStep'])/1000.0) # assumes that data[i]['simConfig']['recordStep'] is in units of ms\n sampr = csd_data[i]['sampr']\n else:\n csd_data[i]['sampr'] = sampr\n\n if spacing_um is None:\n csd_data[i]['spacing_um'] = data[i]['simConfig']['recordLFP'][1][1] - data[i]['simConfig']['recordLFP'][0][1]\n spacing_um = csd_data[i]['spacing_um']\n else:\n csd_data[i]['spacing_um'] = spacing_um\n\n if dt is None:\n csd_data[i]['dt'] = data[i]['simConfig']['recordStep']\n dt = csd_data[i]['dt']\n else:\n csd_data[i]['dt'] = dt\n\n\n\n ## FOR LIST OF LFP DATA WITHOUT ANY .JSON INPUT FILE \n elif len(LFP_input_data) > 0 and LFP_input_file is None: # elif LFP_input_file is None and ...\n lfp_data = np.array(LFP_input_data) # get lfp_data and cast as numpy array\n\n\n\n\n ##############################################################################\n # Now lfp_data exists for either existing (e.g. empirical) or simulated data \n ##############################################################################\n\n # Convert spacing from microns to mm \n spacing_mm = spacing_um/1000\n\n # Bandpass filter the LFP data with getbandpass() fx defined above\n datband = getbandpass(lfp_data,sampr,minf,maxf) \n\n # Take CSD along smaller dimension\n if datband.shape[0] > datband.shape[1]:\n ax = 1\n else:\n ax = 0\n\n # VAKNIN CORRECTION\n if vaknin: \n datband = Vaknin(datband)\n\n # NORM <-- ASKING SAM MORE ABOUT THIS\n if norm: \n removemean(datband,ax=ax)\n\n # now each column (or row) is an electrode -- take CSD along electrodes\n CSD_data = -np.diff(datband,n=2,axis=ax)/spacing_mm**2 ## CSD_data should be in mV/mm**2, assuming that LFP data is in mV. \n \n\n ########################################\n ########## noBandpass trial ############\n ########################################\n datband_noBandpass = lfp_data.T\n \n if datband_noBandpass.shape[0] > datband_noBandpass.shape[1]:\n ax = 1\n else:\n ax = 0\n \n if vaknin:\n datband_noBandpass = Vaknin(datband_noBandpass)\n \n if norm:\n removemean(datband_noBandpass,ax=ax)\n \n CSD_data_noBandpass = -np.diff(datband_noBandpass,n=2,axis=ax)/spacing_mm**2 # noBandpass trial \n ##########################################\n\n\n\n ################## SAVING DATA ##########################\n # Add CSD and other param values to sim.allSimData for access outside of this function or script \n if save_to_sim is True: ## FROM SIM \n try:\n from .. import sim \n sim.allSimData['CSD'] = {}\n #sim.allSimData['CSD']['timeRange'] = timeRange \n sim.allSimData['CSD']['sampr'] = sampr\n sim.allSimData['CSD']['spacing_um'] = spacing_um \n sim.allSimData['CSD']['CSD_data'] = CSD_data\n sim.allSimData['CSD']['CSD_data_noBandpass'] = CSD_data_noBandpass # noBandpass trial \n except:\n print('NOTE: No sim.allSimData construct available to store CSD data')\n\n\n\n # RETURN CSD AND OTHER RELEVANT PARAM VALUES, IF DESIRED \n if getAllData is True:\n return lfp_data, CSD_data, sampr, spacing_um, dt\n if getAllData is False:\n return CSD_data # returns CSD in units of mV/mm**2 (assuming lfps are in mV)","def dsinfomaker(compath, backpath, mwb, tcfs, SR=\"SR\"):#yrs, ves,\r\n\tdsinfo = OrderedDict()\r\n\t# ==========\r\n\tdsinfo[\"GFED\"] = ({\"alias\":\"GFED4.1\",\"long_name\":\"FRI\", \"units\":\"yrs\"})\r\n\tdsinfo[\"MODIS\"] = ({\"alias\":\"MCD64A1\", \"long_name\":\"FRI\",\"units\":\"yrs\", \"version\":\"v006\"})\r\n\tdsinfo[\"esacci\"] = ({\"alias\":\"FireCCI5.1\", \"long_name\":\"FRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"COPERN_BA\"] = ({\"alias\":\"CGLS\", \"long_name\":\"FRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"HANSEN_AFmask\"] = ({\"alias\":\"Hansen GFC & MCD14ML\", \"long_name\":f'FRI$_{{{SR}}}$',\"units\":\"yrs\"})\r\n\tdsinfo[\"HANSEN\"] = ({\"alias\":\"Hansen GFC\", \"long_name\":\"DRI\",\"units\":\"yrs\"})\r\n\tdsinfo[\"Risk\"] = ({\"alias\":\"Forest Loss Risk\"})\r\n\t# dsinfo[\"FutureRisk\"] = ({\"alias\":\"Forest Loss Risk\"})\r\n\tdsinfo[\"SRfrac\"] = ({\"alias\":\"Stand Replacing Fire Percentage\", \"long_name\":f'FRI$_{{{\"SR\"}}}$ %'})\r\n\r\n\tfor dsnm in dsinfo:\r\n\t\tif dsnm.startswith(\"H\"):\r\n\t\t\t# +++++ make a path +++++\r\n\t\t\tppath = compath + \"/BurntArea/HANSEN/FRI/\"\r\n\t\t\tfname = \"%s%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, tcfs, mwb)\r\n\t\t\t# fname = \"%s%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\telif dsnm == \"Risk\":\r\n\t\t\tppath = compath + \"/BurntArea/Risk/FRI/\"\r\n\t\t\tfname = \"%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\t\tcf.pymkdir(ppath)\r\n\t\t# elif dsnm == \"FutureRisk\":\r\n\t\t# \tppath = compath + \"/BurntArea/Risk/FRI/\"\r\n\t\t# \tfname = f\"{dsnm}_annual_burns_MW_{mwb}degreeBox_{yrs}yrs_{ves}.nc\" \r\n\t\t# \tcf.pymkdir(ppath)\r\n\t\telse:\r\n\t\t\t# fname = \"Hansen_GFC-2018-v1.6_regrided_esacci_FRI_%ddegMW_SIBERIA\" % (mwb)\r\n\t\t\tppath = compath + \"/BurntArea/%s/FRI/\" % dsnm\r\n\t\t\tfname = \"%s_annual_burns_MW_%ddegreeBox.nc\" % (dsnm, mwb)\r\n\t\t# +++++ open the datasets +++++\r\n\t\tdsinfo[dsnm][\"fname\"] = ppath+fname\r\n\r\n\r\n\treturn dsinfo","def txt2hdf5_mudis(config, init_file=0, final_file=100, step=1, expo='100'):\n # --------SKYMAP--------------\n # Create the directory to save the results\n os.makedirs(os.path.dirname(cwd + '/config_files/'), exist_ok=True)\n\n alignment = add_align()\n\n # Extract skymap from alignment file\n skymap = np.zeros((len(alignment), 2))\n\n for i in np.arange(len(skymap)):\n skymap[i] = alignment['Azimuth'][i], alignment['Zenith'][i]\n\n # Save Skymap information\n with h5py.File(cwd + '/config_files/skymap_radiance.h5', 'w') as sky:\n\n if not list(sky.items()):\n sky.create_dataset('/skymap', data=skymap)\n else:\n del sky['skymap']\n\n sky.create_dataset('/skymap', data=skymap, dtype='f4')\n sky['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\n sky['skymap'].dims[0].label = 'channel'\n sky['skymap'].dims[1].label = 'Azimuth, Zenith'\n\n config['skymap'] = skymap\n\n # Save MUDIS file information\n\n # Import the radiance data from sensor\n files = sorted(\n glob.glob(config['raw_dir'] + '/radiance/{}/data/data_*.txt'.format(config['date'])))\n\n print('Total files in the directory: ' + str(len(files)) + ' files')\n\n ans = input('convert all files? (y/n): ')\n\n if ans == 'n':\n print('configure initial and final file index in the function options')\n else:\n init_file = 0\n final_file = len(files)\n\n for fil in np.arange(init_file, final_file):\n # Import the data from the file\n file = np.genfromtxt(files[fil], delimiter='', skip_header=11)\n\n # ------------RADIANCE DATA RAW---------------\n # create the radiance matrix\n data = np.zeros([113, 992])\n\n for i in np.arange(113):\n if str(alignment.iloc[i][3]) == 'nan':\n data[i] = np.nan\n else:\n try:\n data[i] = file[:, int(alignment.iloc[i][3] + config['channel_pixel_adj'])] #\n except:\n pass #\n # read the pixels index\n # in the alignment file and copy the\n # data in the radiance matrix']))\n\n # Correct time for the file UTC\n name = os.path.split(files[fil])\n\n # Read name of the file (correct time)\n time = name[1][6:25]\n # convert time to datetime format\n time = datetime.datetime.strptime(time, '%d.%m.%Y_%H_%M_%S')\n # print(time)\n new_name = datetime.datetime.strftime(time, '%Y%m%d_%H%M%S')\n\n with open(files[fil], 'r') as file:\n dat = file.readlines()\n\n # Extract information from .dat file\n exposure = int(dat[4][12:-1])\n NumAve = int(dat[7][17:-1])\n CCDTemp = int(dat[8][15:-1])\n NumSingMes = int(dat[10][27:-1])\n ElectrTemp = int(dat[9][23:-1])\n\n # Create the directory to save the results\n os.makedirs(os.path.dirname(config['str_dir'] + '/radiance/{}/data/').format(config['date']),\n exist_ok=True)\n\n if exposure == expo:\n # Create a file in the disk\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(config['date'], new_name),\n 'w') as datos:\n\n if not list(datos.items()):\n # Create two datasets(use only one time)\n datos.create_dataset('/data', data=data, dtype='f4')\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\n else:\n del datos['data']\n del datos['skymap']\n print('data deleted and corrected')\n datos.create_dataset('/data', data=data, dtype='f4')\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\n\n # Add attributes to datasets\n datos['data'].attrs['time'] = str(time)\n datos['data'].attrs['Exposure'] = exposure\n datos['data'].attrs['NumAver'] = NumAve\n datos['data'].attrs['CCDTemp'] = CCDTemp\n datos['data'].attrs['NumSingMes'] = NumSingMes\n datos['data'].attrs['ElectrTemp'] = ElectrTemp\n datos['data'].attrs['Latitude'] = '52.39N'\n datos['data'].attrs['Longitude'] = '9.7E'\n datos['data'].attrs['Altitude'] = '65 AMSL'\n datos['data'].dims[0].label = 'channel'\n datos['data'].dims[1].label = 'wavelength'\n\n datos['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\n\n datos.close()\n\n print('File ' + str(fil + init_file + 1) + ' of ' +\n str((final_file - init_file)) + ' saved')\n else:\n print('Exposure are not same', expo, exposure)\n break\n\n print('Completed')","def test_calc_ch4_working_cap():\n OUTPUT_PARAMETERS = Dict(\n dict={\n 'Density': 0.440527,\n 'Density_unit': 'g/cm^3',\n 'Estimated_saturation_loading': 41.985376,\n 'Estimated_saturation_loading_unit': 'mol/kg',\n 'Input_block': [1.865, 100],\n 'Input_ha': 'DEF',\n 'Input_structure_filename': 'tmp4a13iby3.cif',\n 'Input_volpo': [1.865, 1.865, 100000],\n 'Number_of_blocking_spheres': 0,\n 'POAV_A^3': 8623.69,\n 'POAV_A^3_unit': 'A^3',\n 'POAV_Volume_fraction': 0.67999,\n 'POAV_Volume_fraction_unit': None,\n 'POAV_cm^3/g': 1.54358,\n 'POAV_cm^3/g_unit': 'cm^3/g',\n 'PONAV_A^3': 0.0,\n 'PONAV_A^3_unit': 'A^3',\n 'PONAV_Volume_fraction': 0.0,\n 'PONAV_Volume_fraction_unit': None,\n 'PONAV_cm^3/g': 0.0,\n 'PONAV_cm^3/g_unit': 'cm^3/g',\n 'Unitcell_volume': 12682.1,\n 'Unitcell_volume_unit': 'A^3',\n 'adsorption_energy_widom_average': -11.1626207486,\n 'adsorption_energy_widom_dev': 0.02083606,\n 'adsorption_energy_widom_unit': 'kJ/mol',\n 'conversion_factor_molec_uc_to_cm3stp_cm3': 2.9347915768,\n 'conversion_factor_molec_uc_to_mg_g': 4.7676018308,\n 'conversion_factor_molec_uc_to_mol_kg': 0.2972320343,\n 'henry_coefficient_average': 7.71003e-06,\n 'henry_coefficient_dev': 1.65115e-08,\n 'henry_coefficient_unit': 'mol/kg/Pa',\n 'is_kh_enough': True,\n 'is_porous': True,\n 'isotherm': {\n 'enthalpy_of_adsorption_average': [-13.510607783958, -10.787702310577],\n 'enthalpy_of_adsorption_dev': [0.76886345231266, 1.0196832123586],\n 'enthalpy_of_adsorption_unit': 'kJ/mol',\n 'loading_absolute_average': [3.6279844874624, 16.11968088498],\n 'loading_absolute_dev': [0.15865715470393, 0.075109385284932],\n 'loading_absolute_unit': 'mol/kg',\n 'pressure': [5.8, 65],\n 'pressure_unit': 'bar'\n },\n 'temperature': 298,\n 'temperature_unit': 'K'\n })\n\n results = engine.run(calc_ch4_working_cap, OUTPUT_PARAMETERS)\n results_dict = results.get_dict()\n\n assert results_dict['wc_65bar_mol/kg_average'] == pytest.approx(12.5, abs=0.1)","def main():\n #diffuser_data_dir = r'F:\\TEMPO\\Data\\GroundTest\\FPS\\Spectrometer\\Diffuser_Irradiance\\saved_quads\\3845_ms\\saved_plots_modified'\n #diffuser_light_data = os.path.join(diffuser_data_dir,'Light_data')\n #diffuser_dark_data = os.path.join(diffuser_data_dir, 'Dark_data')\n #print(diffuser_data_dir)\n #cc\n #int_time_diffuser = 3845.0\n\n# radiance_data_dir_UV = r'F:\\TEMPO\\Data\\GroundTest\\FPS\\Spectrometer\\Radiance_Cal_UV_Lamp\\saved_quads\\saved_plots_modified'\n# radiance_light_data_UV = os.path.join(radiance_data_dir_UV,'DSS-Y')\n# radiance_dark_data_UV = os.path.join(radiance_data_dir_UV, 'Dark_data')\n## #int_time_radiance = 93.0\n## print(radiance_data_dir_UV)\n##\n radiance_data_dir_VIS = r'F:\\TEMPO\\Data\\GroundTest\\FPS\\Spectrometer\\Radiance_Cal_UV_Lamp\\saved_quads\\processed_h5'\n radiance_light_data_VISminusY = os.path.join(radiance_data_dir_VIS,'DSS-Y')\n radiance_light_data_VIS_Center = os.path.join(radiance_data_dir_VIS,'DSS_Center')\n radiance_light_data_VISplusY = os.path.join(radiance_data_dir_VIS,'DSS+Y') \n radiance_dark_data_VIS = os.path.join(radiance_data_dir_VIS, 'Dark_Data')\n\n\n\n # mean_diffuser_data = calculate_mean(diffuser_light_data)\n #mean_diffuser_dark_data = calculate_mean(diffuser_dark_data)\n#\n#\n# #Let's correct for dark current and work in signal rates unit\n# diffuser_dc_corrected = (mean_diffuser_data - mean_diffuser_dark_data)\n# diffuser_dc_corrected = np.round(diffuser_dc_corrected, 2)\n# diffuser_dc_corrected[diffuser_dc_corrected <0] = 0\n# mean_save_dir = os.path.join(diffuser_data_dir,'processed_average_data')\n# mean_save_irradiance = os.path.join(mean_save_dir, 'mean_irradiance_3845ms.csv')\n# np.savetxt(mean_save_irradiance, diffuser_dc_corrected, fmt='%1.3f', delimiter=\",\")\n \n\n\n\n# mean_radiance_data_UV = calculate_mean(radiance_light_data_UV)\n# mean_radiance_dark_data_UV = calculate_mean(radiance_dark_data_UV)\n# radiance_dc_corrected_UV = (mean_radiance_data_UV - mean_radiance_dark_data_UV)\n# radiance_dc_corrected_UV = np.round(radiance_dc_corrected_UV, 2)\n# radiance_dc_corrected_UV[radiance_dc_corrected_UV < 0] = 0\n###\n mean_radiance_dark_data_VIS = calculate_mean_dark(radiance_dark_data_VIS)\n \n \n # Correct for Dark current\n mean_radiance_data_VISminusY = calculate_mean(radiance_light_data_VISminusY) - mean_radiance_dark_data_VIS\n mean_radiance_data_VIS_Center = calculate_mean(radiance_light_data_VIS_Center)- mean_radiance_dark_data_VIS\n mean_radiance_data_VISplusY = calculate_mean(radiance_light_data_VISplusY) - mean_radiance_dark_data_VIS\n \n \n #radiance_dc_corrected_VIS[radiance_dc_corrected_VIS < 0] = 0\n#\n# \n\n# \n# mean_save_dir_UV = os.path.join(radiance_data_dir_UV,'processed_average_data')\n mean_save_dir_VIS = os.path.join(radiance_data_dir_VIS,'Mean_Processed_Data')\n if not os.path.exists(mean_save_dir_VIS):\n os.makedirs(mean_save_dir_VIS)\n #\n# mean_save_radiance_UV = os.path.join(mean_save_dir_UV, 'mean_radiance_DSSminus_UV.csv')\n# mean_save_radiance_VIS = os.path.join(mean_save_dir_VIS, 'mean_radiance_DSSminus_VIS.csv')\n# #\n# \n# np.savetxt(mean_save_radiance_UV, radiance_dc_corrected_UV, fmt='%1.3f', delimiter=\",\")\n# np.savetxt(mean_save_radiance_VIS, radiance_dc_corrected_VIS, fmt='%1.3f', delimiter=\",\")\n print('DONE')\n\n #Write into h5file\n hf_name = os.path.join(mean_save_dir_VIS,'Mean_Data.h5')\n hf = h5py.File(hf_name,'w')\n hf.create_dataset('DSS-Y', data= mean_radiance_data_VISminusY)\n hf.create_dataset('DSS_Center', data=mean_radiance_data_VIS_Center)\n hf.create_dataset('DSS+Y', data= mean_radiance_data_VISplusY)","def test_run(self):\n files = [\n (\"AS1-1.phy_r8s.txt\", \"AS1-1.phy_r8s.txt_2.5.txt\"),\n (\"AS1-3.phy_r8s.txt\", \"AS1-3.phy_r8s.txt_2.5.txt\"),\n (\"AS1-4.phy_r8s.txt\", \"AS1-4.phy_r8s.txt_2.5.txt\"),\n ]\n for file_pair in files:\n input_file = file_pair[0]\n expected_file = file_pair[1]\n infile = self.test_data_path + input_file\n outfile = self.test_data_path + expected_file\n divnum = 2.5\n result = run(infile, divnum)\n\n with open(outfile) as handle:\n expected_result = handle.read()\n self.assertEqual(expected_result, result)","def get_data(tstart, tstop, year, grad_list, out_dir):\n print(\"Period: \" + str(tstart) + '<-->' + str(tstop) + ' in Year: ' + str(year))\n#\n#--- extract ecach group data\n#\n for group in grad_list:\n print(group)\n\n line = 'operation=retrieve\\n'\n line = line + 'dataset = mta\\n'\n line = line + 'detector = grad\\n'\n line = line + 'level = 0.5\\n'\n line = line + 'filetype = ' + group + '\\n'\n line = line + 'tstart = ' + str(tstart) + '\\n'\n line = line + 'tstop = ' + str(tstop) + '\\n'\n line = line + 'go\\n'\n\n data_list = mcf.run_arc5gl_process(line)\n#\n#--- read the first fits file and prep for the data list\n#\n [cols, tbdata] = ecf.read_fits_file(data_list[0])\n col_list = []\n for ent in cols:\n if ent.lower() == 'time':\n continue\n mc = re.search('st_', ent.lower())\n if mc is not None:\n continue\n\n col_list.append(ent)\n\n mcf.rm_files(data_list[0])\n tdata = tbdata['time']\n mdata = []\n for col in col_list:\n mdata.append(tbdata[col])\n#\n#--- read the rest of the data\n#\n clen = len(col_list)\n for k in range(1, len(data_list)):\n fits = data_list[k]\n [cols, tbdata] = ecf.read_fits_file(fits)\n tdata = numpy.append(tdata, tbdata['time'])\n\n for m in range(0, clen):\n cdata = tbdata[col_list[m]]\n mdata[m] = numpy.append(mdata[m], cdata)\n\n mcf.rm_files(fits)\n\n dout = out_dir + group.capitalize() + '/'\n\n if not os.path.isdir(dout):\n cmd = 'mkdir ' + dout\n os.system(cmd)\n#\n#--- write out the data to fits file\n#\n for k in range(0, clen):\n col = col_list[k]\n ocols = ['time', col.lower()]\n cdata = [tdata, mdata[k]]\n\n ofits = dout + col.lower()+ '_full_data_' + str(year) +'.fits'\n\n if os.path.isfile(ofits):\n ecf.update_fits_file(ofits, ocols, cdata)\n else:\n ecf.create_fits_file(ofits, ocols, cdata)\n\n#\n#--- zip the fits file from the last year at the beginning of the year\n#\n ecf.check_zip_possible(dout)","def test_conus():\n sat = gini.GINIZFile(get_test_file(\"TIGN02\", fponly=True))\n assert sat.archive_filename() == \"GOES_SUPER_IR_201509281745.png\"\n assert sat.awips_grid() == 0\n assert sat.metadata[\"map_projection\"] == 5","def test_fetch_station_data_wdc_format_hour_data_from_wdc(tmpdir): # pylint: disable=invalid-name\n cadence = 'hour'\n station = 'NGK'\n start_date = date(2015, 4, 1)\n end_date = date(2015, 4, 30)\n service = 'WDC'\n expected_filename = 'ngk2015.wdc'\n configpath = os.path.join(DATAPATH, 'wdc_minute_data_wdcoutput.ini')\n # TODO: cf fetch_station_data vs oracle files\n # oraclefile = os.path.join(ORACLEPATH, 'ngk2015.wdc')\n\n # ensure we have somewhere to put the data\n manualdir = os.path.join(str(tmpdir), 'manual')\n funcdir = os.path.join(os.path.dirname(manualdir),\n 'via__fetch_station_data')\n for dir_ in (manualdir, funcdir):\n os.mkdir(dir_)\n manualfile = os.path.join(manualdir, expected_filename)\n funcfile = os.path.join(funcdir, expected_filename)\n\n # 'manual' way\n config = cws.ParsedConfigFile(configpath, service)\n form_data = cws.FormData(config)\n form_data.set_datasets(start_date, end_date, station, cadence, service)\n req_wdc = cws.DataRequest()\n req_wdc.read_attributes(config)\n req_wdc.set_form_data(form_data.as_dict())\n resp_wdc = rq.post(\n req_wdc.url, data=req_wdc.form_data, headers=req_wdc.headers\n )\n\n cws.check_response(resp_wdc.status_code, resp_wdc.content)\n\n with zipfile.ZipFile(BytesIO(resp_wdc.content)) as fzip:\n fzip.extractall(manualdir)\n\n assert not os.path.isfile(funcfile)\n # with wrapper function\n cws.fetch_station_data(\n start_date=start_date, end_date=end_date,\n station=station, cadence=cadence,\n service=service, saveroot=funcdir, configpath=configpath\n )\n assert os.path.isfile(funcfile)\n assert_all_lines_same(funcfile, manualfile)"],"string":"[\n \"def main():\\n regexham = r'\\\\s+\\\\((\\\\d+,\\\\s*\\\\d+)\\\\)\\\\s+([\\\\-+]?\\\\d+\\\\.\\\\d+[eEdD]?[\\\\-+]?\\\\d+)' #to extract the Hamiltonian.\\n root = '.'\\n #fname = 'output_files/'\\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\\n #print ciffci.calc_overlap(cifdoci)\\n #print e.get_groundstate('00000000000011|00000000000011') \\n\\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\\n\\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\\n count = 0\\n for det in detlist:\\n for det2 in detlist:\\n #+ because the eigenvectors have already a different phasefactor of 1.\\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \\\" col: \\\" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \\n count += 1\\n print 'There were ' , count , ' different elements'\",\n \"def load_data():\\n\\t\\t# load the data\\n\\t\\tDATPATH = \\\"../data/\\\"\\n\\t\\t#fnino = DATPATH + \\\"nino3.csv\\\" # 1871-2000\\n\\t\\tfnino = DATPATH + \\\"tas_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_nino3_tseries.csv\\\" # 1871-2016\\n\\t\\t#fnino = DATPATH + \\\"nino34.long.data\\\"\\n\\t\\t#nc_data_nino3 = netCDF4.Dataset(fnino)\\n\\t\\t#nino3_load = nc_data_nino3.variables['tas'][:]\\n\\t\\t#dnino = nino3_load.flatten()\\n\\n\\t\\tdnino = np.genfromtxt(fnino, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fismr = DATPATH + \\\"ismr.csv\\\" # 1871-2000\\n\\t\\t#fismr = DATPATH + \\\"psl_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_1_india_goswami_2002_tseries.csv\\\" # 1871-2016\\n\\t\\tfismr = DATPATH + \\\"pr_Amon_IPSL-CM5A-LR_past1000_r1i1p1_0850_1850_goswami_india_tseries.csv\\\" # 1871-2016\\n\\t\\tdismr = np.genfromtxt(fismr, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t#fvolc = DATPATH + \\\"robock.txt\\\" # 1871-2000\\n\\t\\tfvolc = DATPATH + \\\"sigl.txt\\\" # 1871-2016\\n\\t\\tdvolc = np.genfromtxt(fvolc, delimiter=\\\",\\\", dtype=float).flatten()\\n\\n\\t\\tfvolc_source = DATPATH + \\\"volc_source_850_1850.csv\\\" # 1871-2016\\n\\t\\tdvolc_source = np.genfromtxt(fvolc_source, delimiter=\\\",\\\", dtype=float).flatten()\\n\\t\\t# simple check for data consistency\\n\\t\\tassert dnino.shape == dismr.shape, \\\"Data sets are unequal!\\\"\\n\\t\\tassert int(dismr.shape[0]/12) == dvolc.shape[0], \\\"Data sets are unequal\\\"\\n\\t\\treturn dnino, dismr, dvolc, dvolc_source\",\n \"def runTest(self):\\n ncfile = netCDF4.Dataset(URL)\\n assert varname in ncfile.variables.keys()\\n var = ncfile.variables[varname]\\n assert var.shape == varshape\\n data = var[:]\\n assert_array_almost_equal(data.min(),varmin)\\n assert_array_almost_equal(data.max(),varmax)\\n ncfile.close()\\n # test https support (linked curl lib must built with openssl support)\\n ncfile = netCDF4.Dataset(URL_https)\\n assert(ncfile['sst'].long_name=='Sea Surface Temperature') \\n ncfile.close()\",\n \"def runTest(self):\\n nc = Dataset(self.file)\\n data = nc['vl'][-1]\\n # check max error of compression\\n err = np.abs(data - self.data)\\n assert(err.max() < nc['vl'].scale_factor)\\n # turn off auto-scaling\\n nc.set_auto_maskandscale(False)\\n data = nc['vl'][-1]\\n assert(data[-1] == np.around(self.data[-1]/nc['vl'].scale_factor))\\n nc.close()\",\n \"def nc_to_hdf5_mudis(dataset, config):\\n np.warnings.filterwarnings('ignore')\\n\\n date = datetime.datetime.strptime(dataset.recorddate,\\n '%d.%m.%Y') # read date from dateset\\n date_name = datetime.datetime.strftime(date,\\n '%Y%m%d') # convert date to YYYYMMDD format\\n config['date'] = date_name\\n\\n # Create the directory to save the results\\n path = config['str_dir'] + '/radiance/{}/data/'.format(config['date'])\\n os.makedirs(os.path.dirname(path), exist_ok=True)\\n\\n # Read time of the file (correct time)\\n time = datetime.datetime.strptime(dataset.recordtime, '%H:%M:%S.')\\n time = datetime.datetime.time(time)\\n\\n # convert time to datetime format\\n datetime_name = datetime.datetime.combine(date, time)\\n new_name = datetime.datetime.strftime(datetime_name, '%Y%m%d_%H%M%S')\\n\\n # radiance = dataset.variables['data'][:].reshape(113, 1281)\\n # wavelength_axis = dataset.variables['xAxis'][:]\\n\\n # Create a file in the disk\\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(\\n config['date'], new_name), 'w') as datos:\\n\\n if not list(datos.items()):\\n # Create two datasets(use only one time)\\n datos.create_dataset('/data',\\n data=dataset['data'][:].reshape(113, 1281),\\n dtype='f4')\\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n else:\\n del datos['data']\\n # del datos['skymap']\\n print('data deleted and corrected')\\n datos.create_dataset('/data', data=data, dtype='f4')\\n # datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n\\n # Add attributes to datasets\\n datos['data'].attrs['time'] = str(time)\\n datos['data'].attrs['Exposure'] = dataset.exposuretime\\n datos['data'].attrs['NumAver'] = dataset.AVERAGED\\n datos['data'].attrs['CCDTemp'] = dataset.detectortemperature\\n datos['data'].attrs['NumSingMes'] = dataset.noofaccumulations\\n # datos['data'].attrs['ElectrTemp'] = dataset.\\n datos['data'].attrs['Latitude'] = '52.39N'\\n datos['data'].attrs['Longitude'] = '9.7E'\\n datos['data'].attrs['Altitude'] = '65 AMSL'\\n\\n chn = np.arange(1, 114)\\n datos.create_dataset('/channel', data=chn, dtype=np.float32)\\n datos.create_dataset('/wavelength', data=dataset['xAxis'][:])\\n\\n datos['data'].dims.create_scale(datos['channel'], 'channel')\\n datos['data'].dims[0].attach_scale(datos['channel'])\\n datos['data'].dims[0].label = 'channel'\\n datos['data'].dims[1].label = 'wavelength'\\n\\n # datos['skymap'].dims[0].label = 'channel'\\n # datos['skymap'].dims[1].label = 'Azimuth, Zenith'\\n\\n datos.close()\",\n \"def extract_hrc_data(obsid, data_dir):\\n#\\n#--- extract fits data\\n#\\n line = 'operation=retrieve\\\\n'\\n line = line + 'dataset=flight\\\\n'\\n line = line + 'level=1\\\\n'\\n line = line + 'detector=hrc\\\\n'\\n line = line + 'obsid=' + str(obsid) + '\\\\n'\\n line = line + 'go\\\\n'\\n\\n with open('zline', 'w') as fo:\\n fo.write(line)\\n\\n cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > zout'\\n os.system(cmd)\\n#\\n#--- create directories and move the data into them\\n#\\n cmd = 'mkdir primary secondary'\\n os.system(cmd)\\n \\n cmd = 'mv *dtf1*fits* *fov*fits* ./primary/.'\\n os.system(cmd)\\n\\n cmd = 'mv *bpix1*fits* *evt1*fits* *msk1*fits* *mtl1*fits* \\\\\\n *std_dtfstat1.fits* *std_flt1.fits* ./secondary/.'\\n os.system(cmd)\\n\\n line = 'operation=retrieve\\\\n'\\n line = line + 'dataset=flight\\\\n'\\n line = line + 'level=1\\\\n'\\n line = line + 'detector=pcad\\\\n'\\n line = line + 'subdetector=aca\\\\n'\\n line = line + 'obsid=' + str(obsid) + '\\\\n'\\n line = line + 'go\\\\n'\\n\\n with open('zline', 'w') as fo:\\n fo.write(line)\\n\\n cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > zout'\\n os.system(cmd)\\n cmd = 'mv *asol*fits* ./primary/.'\\n os.system(cmd)\\n\\n cmd = 'rm -rf *fits* zline zout'\\n os.system(cmd)\\n\\n hdir = data_dir + '/' + str(obsid)\\n if os.path.isdir(hdir):\\n cmd = 'rm -rf ' + hdir + '/*'\\n os.system(cmd)\\n else:\\n cmd = 'mkdir ' + hdir \\n os.system(cmd)\\n\\n cmd = 'chmod 774 primary/* secondary/*'\\n os.system(cmd)\\n\\n#\\n#--- check whether there are duplicated fits files extracted; if so, remove older ones\\n#\\n h_list = ['dtf1', 'fov1', 'asol1']\\n sdir = 'primary'\\n remove_duplicate(h_list, sdir)\\n\\n h_list = ['bpix1', 'evt1', 'msk1', 'mtl1', 'std_dtfstat1', 'std_flt1']\\n sdir = 'secondary'\\n remove_duplicate(h_list, sdir)\\n\\n cmd = 'mv primary secondary ' + hdir + '/.'\\n os.system(cmd)\\n\\n cmd = 'rm -rf ' + hdir + '/analysis/* ' \\n os.system(cmd)\\n\\n return check_data_exist(hdir)\",\n \"def main_bf_MISR(h5f, output_folder, SPATIAL_RESOLUTION=0.5, VZA_MAX=18, CAMERA='AN'):\\n\\n # =============================================================================\\n # 1. Initialization\\n # calculate constant parameters\\n # initialize output arrays and output hdf5 file\\n # check the number of CERES granules \\n # =============================================================================\\n\\n print(\\\"-------MISR----->\\\", h5f)\\n print(\\\"-------FID------<>\\\", h5f.fid)\\n print(\\\"---->\\\", type(h5f))\\n if type(h5f.fid) is str:\\n output_nc_name = h5f.fid.split('/')[-1].replace('TERRA_BF_L1B', 'CLIMARBLE')\\n else:\\n output_nc_name = h5f.fid.name. \\\\\\n decode(\\\"utf-8\\\").split('/')[-1]. \\\\\\n replace('TERRA_BF_L1B', 'CLIMARBLE')\\n\\n output_nc_name = output_nc_name.replace('.h5', '.nc')\\n\\n # \\n NUM_POINTS = 1 / SPATIAL_RESOLUTION\\n NUM_LATS = int(180 / SPATIAL_RESOLUTION)\\n NUM_LONS = int(360 / SPATIAL_RESOLUTION)\\n\\n LAT_EDGES = np.arange(-90.0, 90.0001, SPATIAL_RESOLUTION)\\n LON_EDGES = np.arange(-180.0, 180.0001, SPATIAL_RESOLUTION)\\n\\n # \\n orbit_radiance_sum = np.zeros((NUM_LATS, NUM_LONS, 4))\\n orbit_radiance_num = np.zeros((NUM_LATS, NUM_LONS, 4))\\n orbit_nc_out = os.path.join(output_folder, output_nc_name)\\n\\n\\n # =============================================================================\\n # 2. Main processing\\n # Loop through each CERES granule and sort radiances into the corresponding lat/lon bins\\n # When encounters an asceding granule, script will move to the next granule\\n # =============================================================================\\n\\n # USE MODIS granules to match first and last time of the descending node\\n MISR_blocks = get_descending(h5f, 'MISR.{}'.format(CAMERA))\\n if MISR_blocks[0] == 0:\\n print(\\\">> IOError( no available MODIS granule in orbit {} )\\\".format(bf_file))\\n return\\n\\n # LOAD lat/lon here\\n lat = h5f['MISR/Geolocation/GeoLatitude'][:]\\n lon = h5f['MISR/Geolocation/GeoLongitude'][:]\\n\\n # LOAD radiance here\\n MISR_bands = ['Blue', 'Green', 'Red', 'NIR']\\n rads_all = []\\n for iband in MISR_bands:\\n rads_all.append(h5f['MISR/{}/Data_Fields/{}_Radiance'.format(CAMERA, iband)][:])\\n\\n # SPECIFY data dimension to interpolate SZA/VZA\\n rad_shape = (128, 512)\\n \\n\\n # LOOP through MISR blocks (starts from 0)\\n for iblk in MISR_blocks:\\n\\n # INTERPOLATE sza and vza (this part can be replaced by a more accurate function)\\n raw_sza = h5f['MISR/Solar_Geometry/SolarZenith'][iblk]\\n raw_vza = h5f['MISR/{}/Sensor_Geometry/{}Zenith'.format(CAMERA, ''.join(c.lower() if i==1 else c for i,c in enumerate(CAMERA)))][iblk]\\n np.place(raw_sza, raw_sza<0, np.nan)\\n np.place(raw_vza, raw_vza<0, np.nan)\\n blk_sza = resize(raw_sza, rad_shape)\\n blk_vza = resize(raw_vza, rad_shape)\\n\\n\\n # SELECT lat/lon\\n idx_geometry = np.where((blk_sza<89.0) & (blk_vza<VZA_MAX))\\n select_lat = lat[iblk][idx_geometry]\\n select_lon = lon[iblk][idx_geometry]\\n\\n\\n # SELECT spectral radiances here\\n # Aggregate 275-m res data to 1.1-km when necessary\\n # Separate band by band to allow one (or more) band(s) failure\\n for iband, band_name in enumerate(MISR_bands, start=0):\\n blk_rad = rads_all[iband][iblk]\\n # blk_rad = h5f['MISR/{}/Data_Fields/{}_Radiance'.format(CAMERA, band_name)][iblk]\\n\\n if blk_rad.shape == (512, 2048): \\n # 275-m res band\\n np.place(blk_rad, blk_rad<0, np.nan)\\n fnl_blk_rad = np.nanmean(np.reshape(blk_rad, (blk_rad.shape[0]//4, 4, blk_rad.shape[1]//4,4)), axis=(1,3))\\n else:\\n fnl_blk_rad = blk_rad\\n\\n\\n select_rad = np.nan_to_num(fnl_blk_rad[idx_geometry])\\n fnl_idx = np.where((select_rad>0)&(select_rad<1000))[0]\\n\\n fnl_lat = select_lat[fnl_idx] * -1\\n fnl_lon = select_lon[fnl_idx]\\n fnl_rad = select_rad[fnl_idx]\\n\\n try:\\n rad_sum, binedges, bin_numbers = binned_statistic_dd((fnl_lat, fnl_lon), fnl_rad, bins=[LAT_EDGES, LON_EDGES], statistic='sum')\\n rad_cnt, binedges, bin_numbers = binned_statistic_dd((fnl_lat, fnl_lon), fnl_rad, bins=[LAT_EDGES, LON_EDGES], statistic='count')\\n\\n orbit_radiance_sum[:, :, iband] += rad_sum\\n orbit_radiance_num[:, :, iband] += rad_cnt\\n except ValueError:\\n continue\\n\\n # =============================================================================\\n # 3. Save results\\n # =============================================================================\\n orbit_radiance_num = np.array(orbit_radiance_num, dtype='int16')\\n\\n coords_lats = np.linspace(90-SPATIAL_RESOLUTION/2, -90+SPATIAL_RESOLUTION/2, NUM_LATS)\\n coords_lons = np.linspace(-180+SPATIAL_RESOLUTION/2, 180-SPATIAL_RESOLUTION/2, NUM_LONS)\\n\\n xr_rad_sum = xr.DataArray(orbit_radiance_sum, coords=[('latitude', coords_lats), ('longitude', coords_lons), ('misr_channel', range(4))])\\n xr_rad_num = xr.DataArray(orbit_radiance_num, coords=[('latitude', coords_lats), ('longitude', coords_lons), ('misr_channel', range(4))])\\n xr_rad_sum.encoding['_FillValue'] = 0\\n xr_rad_num.encoding['_FillValue'] = 0\\n xr_rad_sum.name = 'MISR spec rad sum'\\n xr_rad_num.name = 'MISR spec rad num'\\n xr_rad_sum.to_netcdf(orbit_nc_out, 'a')\\n xr_rad_num.to_netcdf(orbit_nc_out, 'a')\\n return orbit_nc_out\",\n \"def test_CFCalculation_hdf_files():\\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\\n\\n expected_results = [\\n CFCoefficient(l=2, m=0, spin_up=-571.68845386399, spin_down=-558.2336974657351, unit='K', convention='Stevens'),\\n CFCoefficient(l=4,\\n m=0,\\n spin_up=-34.982539807305045,\\n spin_down=-21.850435868549834,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=6, m=0, spin_up=3.8503494779930776, spin_down=2.168215129491561, unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=6,\\n m=-6,\\n spin_up=110.50156137060345,\\n spin_down=85.58558990378205,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=6, m=6, spin_up=110.50156137060345, spin_down=85.58558990378205, unit='K', convention='Stevens')\\n ]\\n\\n cf = CFCalculation()\\n cf.readPot('files/cf_calculation/CFdata.hdf')\\n cf.readCDN('files/cf_calculation/CFdata.hdf')\\n results = cf.performIntegration()\\n\\n assert results == expected_results\",\n \"def read_test_data_file(self, filename):\\n if not os.path.isfile(filename):\\n raise Error(\\\"Test data file does not exist or problem with file: \\\" + filename)\\n txt = open(filename, 'r').readlines()\\n search_params = {}\\n for curlinenum, curline in enumerate(txt):\\n if curline.startswith('#END'): # end of search parameters\\n break\\n search_params[curline.split('=')[0].replace('#', '').strip()] = {\\n 'value': curline.split('=')[1].split('/', 1)[0].strip(),\\n 'comment': curline.split('/', 1)[1].strip()}\\n while not txt[curlinenum].startswith('#1'):\\n curlinenum += 1\\n hdrline1 = txt[curlinenum]\\n while not txt[curlinenum].startswith('#2'):\\n curlinenum += 1\\n hdrline2 = txt[curlinenum]\\n headers1 = [a.strip() for a in hdrline1[2:].split('|')]\\n headers2 = [a.strip() for a in hdrline2[2:].split('|')]\\n headers = [headers1[i] + ' ' + headers2[i] for i in range(len(headers1))][:-1]\\n headers = [a.replace(' mag', 'mag') for a in headers]\\n split_at = [a.start() for a in re.finditer('\\\\|', hdrline1)][:-1]\\n split_row = lambda row: [row[i:j].replace('\\\\n', '') for i, j in zip([0] + split_at, split_at + [None])]\\n data = [split_row(row) for row in txt[curlinenum + 2:]]\\n df = DataFrame(data, columns=headers)\\n df.index = df['id id'].apply(lambda x: x.strip())\\n df.index.name = 'NOMAD id'\\n columns_to_drop = ['id id']\\n df['RAJ2000'] = (df['RA hh mm ss'].apply(lambda x: float(x.split()[0])) +\\n df['RA hh mm ss'].apply(lambda x: float(x.split()[1])) / 60. +\\n df['RA hh mm ss'].apply(lambda x: float(x.split()[2])) / 3600.) * 15.\\n columns_to_drop.append('RA hh mm ss')\\n dec_sign = lambda x: -1.0 if x.strip()[0] == '-' else 1.0\\n df['DEJ2000'] = (df['DEC dd mm ss'].apply(dec_sign) *\\n (df['DEC dd mm ss'].apply(lambda x: float(x.split()[0].replace('+', '').replace('-', ''))) +\\n df['DEC dd mm ss'].apply(lambda x: float(x.split()[1])) / 60. +\\n df['DEC dd mm ss'].apply(lambda x: float(x.split()[2])) / 3600.))\\n columns_to_drop.append('DEC dd mm ss')\\n columns_to_drop.append('ExtractID id')\\n df = df.drop(columns_to_drop, axis=1)\\n for column in df: # check first in each column for ability to convert to integer, then float, then leave alone\\n if df[column].dtype == object and column != 'Flags hex':\\n if df[column][0].strip().lstrip('-').lstrip('+').isdigit():\\n df[column] = df[column].apply(np.int)\\n elif df[column][0].strip().lstrip('-').lstrip('+').replace('.', '0').isdigit():\\n df[column] = df[column].apply(np.float)\\n return search_params, df\",\n \"def spectra_analysis(file_name, sky_file_name): \\n\\n # read file name and select out the id that we are dealing with\\n curr_file_name = file_name.split('.')\\n curr_file_name = curr_file_name[0].split('/')\\n stk_f_n = curr_file_name[-1]\\n cube_id = int(re.search(r'\\\\d+', stk_f_n).group())\\n\\n # read catalogue and obtain the HST redshift estimate\\n #catalogue = np.load(\\\"data/matched_catalogue.npy\\\")\\n catalogue = np.load(\\\"data/low_redshift_catalogue.npy\\\")\\n cat_loc = np.where(catalogue[:,0] == cube_id)[0]\\n cube_info = catalogue[cat_loc][0]\\n \\n hst_redshift = cube_info[7]\\n\\n # spectra and sky noise data\\n spectra_data = spectrum_creator(file_name)\\n wl_soln = wavelength_solution(file_name)\\n sn_data = sky_noise(sky_file_name)\\n\\n galaxy_data = spectra_data['galaxy']\\n\\n # removing baseline from data\\n base = peakutils.baseline(galaxy_data, 3)\\n gd_mc = galaxy_data - base\\n\\n # scaling sky-noise to be similar to spectra data\\n gd_max = np.amax(galaxy_data)\\n sn_data_max = np.amax(sn_data)\\n sn_scale = gd_max / sn_data_max\\n\\n sn_data = sn_data * sn_scale\\n\\n # spectra lines\\n sl = {\\n 'emis': {\\n '[OII]': '3727',\\n 'CaK': '3933',\\n 'CaH': '3968',\\n 'Hdelta': '4101', \\n }, \\n 'abs': {'K': '3934.777',\\n }\\n } \\n\\n # we can use the redshift from the HST catalogue to define the region to search for\\n # the doublet in\\n\\n # lower and upper bound on wavelength range\\n lower_lambda = (1+hst_redshift)*3600\\n upper_lambda = (1+hst_redshift)*3850\\n\\n # x-axis data\\n data_h_range = np.linspace(wl_soln['begin'], wl_soln['end'], wl_soln['steps'])\\n mask = (lower_lambda < data_h_range) & (data_h_range < upper_lambda) \\n\\n lambda_data = data_h_range[mask]\\n flux_data = gd_mc[mask] \\n \\n # Finding peaks with PeakUtils\\n pu_peaks = peakutils.indexes(flux_data, thres=600, thres_abs=True)\\n pu_peaks_x = peakutils.interpolate(lambda_data, flux_data, pu_peaks)\\n\\n pu_peaks_x = np.sort(pu_peaks_x)\\n pu_peaks_x = pu_peaks_x[lower_lambda < pu_peaks_x]\\n pu_peaks_x = pu_peaks_x[pu_peaks_x < upper_lambda]\\n \\n data_dir = 'cube_results/' + stk_f_n\\n if not os.path.exists(data_dir):\\n os.mkdir(data_dir)\\n\\n peaks_file = open(data_dir + '/' + stk_f_n + '_peaks.txt', 'w')\\n peaks_file.write(\\\"Peaks found on \\\" + str(datetime.datetime.now()) + \\\"\\\\n\\\\n\\\")\\n\\n peaks_file.write(\\\"Number Wavelength \\\\n\\\")\\n for i_peak in range(len(pu_peaks_x)):\\n curr_peak = pu_peaks_x[i_peak]\\n peaks_file.write(str(i_peak) + \\\" \\\" + str(curr_peak) + \\\"\\\\n\\\")\\n\\n # manually selecting which peak is the [OII] peak - given in wavelength\\n if (pu_peaks_x.size != 0):\\n otwo_wav = float(pu_peaks_x[0]) \\n otwo_acc = float(sl['emis']['[OII]'])\\n\\n redshift = (otwo_wav / otwo_acc) - 1\\n else:\\n # accepting HST redshift if cannot find peak\\n redshift = hst_redshift\\n\\n return {'gd_shifted': gd_mc, 'sky_noise': sn_data, 'spectra': sl, 'redshift': \\n redshift, 'pu_peaks': pu_peaks_x}\",\n \"def F_read_S5P_nc(self,fn,data_fields,data_fields_l2g=[]):\\n from netCDF4 import Dataset\\n ncid = Dataset(fn,'r')\\n outp = {}\\n for i in range(len(data_fields)):\\n tmp = ncid[data_fields[i]]\\n tmpdtype = tmp.dtype\\n if not data_fields_l2g:\\n varname = tmp.name\\n else:\\n varname = data_fields_l2g[i]\\n if tmpdtype is \\\"str\\\":\\n outp[varname] = tmp[:]\\n else:\\n outp[varname] = np.squeeze(tmp[:])\\n ## scale factor already applied?! so confusing\\n# try:\\n# outp[varname] = outp[varname]*tmp.scale_factor\\n# if tmp.scale_factor != 1:\\n# print(varname+' has a scale_factor of '+'%s'%tmp.scale_factor)\\n# except Exception:\\n# #print(e)\\n# print(varname+' has no scale_factor!')\\n if 'time_utc' in outp.keys():\\n UTC_matlab_datenum = np.zeros((len(outp['time_utc']),1),dtype=np.float64)\\n for i in range(len(outp['time_utc'])):\\n tmp = datetime.datetime.strptime(outp['time_utc'][i],'%Y-%m-%dT%H:%M:%S.%fZ')\\n UTC_matlab_datenum[i] = (tmp.toordinal()\\\\\\n +tmp.hour/24.\\\\\\n +tmp.minute/1440.\\\\\\n +tmp.second/86400.\\\\\\n +tmp.microsecond/86400/1000000+366.)\\n outp['UTC_matlab_datenum'] = np.tile(UTC_matlab_datenum,(1,outp['latc'].shape[1]))\\n else: # hcho l2 does not have time_utc\\n # the delta_time field of hcho fills all across track position, but ch4 is one per scanline\\n if len(outp['delta_time'].shape) == 1:\\n outp['delta_time'] = np.tile(outp['delta_time'][...,None],(1,outp['latc'].shape[1]))\\n outp['UTC_matlab_datenum'] = (outp['time']+outp['delta_time']/1000.)/86400.+734139.\\n \\n outp['across_track_position'] = np.tile(np.arange(1.,outp['latc'].shape[1]+1),\\\\\\n (outp['latc'].shape[0],1)).astype(np.int16)\\n return outp\",\n \"def test_cl_fix_file(mock_get_filepath, cl_file, tmp_path):\\n mock_get_filepath.return_value = os.path.join(tmp_path,\\n 'fixed_cesm2_waccm_cl.nc')\\n fix = Cl(None)\\n fixed_file = fix.fix_file(cl_file, tmp_path)\\n mock_get_filepath.assert_called_once_with(tmp_path, cl_file)\\n fixed_dataset = Dataset(fixed_file, mode='r')\\n assert fixed_dataset.variables['lev'].standard_name == (\\n 'atmosphere_hybrid_sigma_pressure_coordinate')\\n assert fixed_dataset.variables['lev'].formula_terms == (\\n 'p0: p0 a: a b: b ps: ps')\\n assert fixed_dataset.variables['lev'].units == '1'\\n np.testing.assert_allclose(fixed_dataset.variables['a'][:], [1.0, 2.0])\\n np.testing.assert_allclose(fixed_dataset.variables['b'][:], [0.0, 1.0])\\n np.testing.assert_allclose(fixed_dataset.variables['a_bnds'][:],\\n [[0.0, 1.5], [1.5, 3.0]])\\n np.testing.assert_allclose(fixed_dataset.variables['b_bnds'][:],\\n [[-1.0, 0.5], [0.5, 2.0]])\",\n \"def test_compute_Sv_ek80_CW_complex_BB_complex(ek80_cal_path):\\n ek80_raw_path = ek80_cal_path / \\\"2018115-D20181213-T094600.raw\\\"\\n ed = ep.open_raw(ek80_raw_path, sonar_model=\\\"EK80\\\")\\n ds_Sv = ep.calibrate.compute_Sv(\\n ed, waveform_mode=\\\"CW\\\", encode_mode=\\\"complex\\\"\\n )\\n assert isinstance(ds_Sv, xr.Dataset)\\n ds_Sv = ep.calibrate.compute_Sv(\\n ed, waveform_mode=\\\"BB\\\", encode_mode=\\\"complex\\\"\\n )\\n assert isinstance(ds_Sv, xr.Dataset)\",\n \"def test_CFCalculation_txt_files():\\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\\n\\n #Make sure new script produces the same result as old one\\n expected_results = [\\n CFCoefficient(l=2,\\n m=0,\\n spin_up=-419.7891726292168,\\n spin_down=-414.7152560307904,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=4,\\n m=0,\\n spin_up=-35.92607948104669,\\n spin_down=-26.384951772020756,\\n unit='K',\\n convention='Stevens'),\\n CFCoefficient(l=6, m=0, spin_up=6.522900740505054, spin_down=5.488104692050172, unit='K', convention='Stevens')\\n ]\\n\\n cf = CFCalculation(reference_radius='cdn')\\n cf.readPot('files/cf_calculation/VKS.2.0.dat',\\n 'files/cf_calculation/VKS.4.0.dat',\\n 'files/cf_calculation/VKS.6.0.dat',\\n lm=[(2, 0), (4, 0), (6, 0)])\\n cf.readCDN('files/cf_calculation/Nd.dat', header=3)\\n cf.cdn['RMT'] = 3.138049652\\n results = cf.performIntegration()\\n\\n assert results == expected_results\",\n \"def sky_orbits(test=True):\\n \\n t = Table.read('/home/ana/data/baumgardt_positions.fits')\\n \\n ind_disterr = ~np.isfinite(t['e_Rsun'])\\n t['e_Rsun'][ind_disterr] = 0.1 * t['Rsun'][ind_disterr]\\n e_max = np.nanmax(t['e_Rsun'][~ind_disterr])\\n ind_cap = t['e_Rsun']>e_max\\n t['e_Rsun'][ind_cap] = e_max\\n \\n clusters = ['NGC 3201', 'NGC 4590', 'NGC 5824', 'NGC 5272', 'NGC 5139', 'NGC 5024']\\n #clusters = ['NGC 5824', 'NGC 5024']\\n N = len(clusters)\\n \\n match = dict()\\n match['NGC 3201'] = dict(streams=['gjoll'], direction=[-1], nstep=[35], gc_label='NGC\\\\n3201', gcra_off=0*u.deg, gcdec_off=-13*u.deg, gcl_off=0*u.deg, gcb_off=-13*u.deg, stream_label=['$Gj\\\\\\\\\\\\\\\" oll$'], stream_ra=[-156*u.deg], stream_dec=[-4.5*u.deg], eq_angle=[-45*u.deg], stream_l=[-148*u.deg], stream_b=[-33*u.deg], gal_angle=[22*u.deg])\\n \\n match['NGC 4590'] = dict(streams=['fjorm'], direction=[1], nstep=[100], gc_label='NGC\\\\n4590', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=-13*u.deg, gcb_off=-10*u.deg, stream_label=['$Fj\\\\\\\\\\\\\\\" orm$'], stream_ra=[-22*u.deg], stream_dec=[66*u.deg], eq_angle=[35*u.deg], stream_l=[110*u.deg], stream_b=[50*u.deg], gal_angle=[-50*u.deg])\\n \\n match['NGC 5024'] = dict(streams=['sylgr', 'ravi'], direction=[-1, 1], nstep=[300,500], gc_label='NGC\\\\n5024', gcra_off=-15*u.deg, gcdec_off=0*u.deg, gcl_off=10*u.deg, gcb_off=-20*u.deg, stream_label=['Sylgr', 'Ravi'], stream_ra=[-70*u.deg, 83*u.deg], stream_dec=[2*u.deg, -47*u.deg], eq_angle=[25*u.deg, 65*u.deg], stream_l=[-110*u.deg, -18.5*u.deg], stream_b=[62*u.deg, -47*u.deg], gal_angle=[30*u.deg, -10*u.deg])\\n \\n match['NGC 5139'] = dict(streams=['fimbulthul'], direction=[-1], nstep=[70], gc_label='NGC\\\\n5139', gcra_off=-5*u.deg, gcdec_off=-15*u.deg, gcl_off=0*u.deg, gcb_off=-12*u.deg, stream_label=['Fimbulthul'], stream_ra=[-20*u.deg], stream_dec=[-15*u.deg], eq_angle=[0*u.deg], stream_l=[-20*u.deg], stream_b=[45*u.deg], gal_angle=[0*u.deg])\\n \\n match['NGC 5272'] = dict(streams=['svol'], direction=[1], nstep=[70], gc_label='NGC\\\\n5272', gcra_off=-15*u.deg, gcdec_off=10*u.deg, gcl_off=-23*u.deg, gcb_off=-17*u.deg, stream_label=['$Sv\\\\\\\\\\\\\\\" ol$'], stream_ra=[-2*u.deg], stream_dec=[34*u.deg], eq_angle=[-10*u.deg], stream_l=[55*u.deg], stream_b=[55*u.deg], gal_angle=[-65*u.deg])\\n \\n match['NGC 5824'] = dict(streams=['triangulum', 'turbio'], direction=[1,1], nstep=[700,1], gc_label='NGC\\\\n5824', gcra_off=15*u.deg, gcdec_off=-5*u.deg, gcl_off=15*u.deg, gcb_off=-5*u.deg, stream_label=['Triangulum', 'Turbio'], stream_ra=[152*u.deg, 130*u.deg], stream_dec=[32*u.deg, -51*u.deg], eq_angle=[-48*u.deg, 30*u.deg], stream_l=[120*u.deg, -82*u.deg], stream_b=[-31*u.deg, -57*u.deg], gal_angle=[70*u.deg, 105*u.deg])\\n \\n dt = 0.5*u.Myr\\n wangle = 180*u.deg\\n ra_off = 120*u.deg\\n l_off = 0*u.deg\\n \\n colors = [mpl.cm.plasma(0.95*x/N) for x in range(N)]\\n \\n np.random.seed(27529)\\n if test:\\n Nsample = 1\\n else:\\n Nsample = 100\\n \\n plt.close()\\n fig = plt.figure(figsize=(12,12))\\n \\n ax0 = fig.add_subplot(211, projection='mollweide')\\n ax1 = fig.add_subplot(212, projection='mollweide')\\n ax = [ax0, ax1]\\n \\n for i in range(N):\\n #ind = t['Name']== clusters[i]\\n ind = t['Name']==clusters[i]\\n t_ = t[ind]\\n \\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n cgal = c.transform_to(coord.Galactic)\\n #w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n color = colors[i]\\n alpha_text = 0.8\\n \\n plt.sca(ax[0])\\n plt.plot((c.ra + ra_off).wrap_at(wangle).rad, c.dec.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((c.ra + ra_off + match[clusters[i]]['gcra_off']).wrap_at(wangle).rad, (c.dec + match[clusters[i]]['gcdec_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n plt.sca(ax[1])\\n plt.plot((cgal.l + l_off).wrap_at(wangle).rad, cgal.b.rad, '+', color=color, mew=3, ms=15, label=t_['Name'][0])\\n plt.text((cgal.l + l_off + match[clusters[i]]['gcl_off']).wrap_at(wangle).rad, (cgal.b + match[clusters[i]]['gcb_off']).rad, match[clusters[i]]['gc_label'], fontsize='small', ha='center', va='center', alpha=alpha_text)\\n \\n\\n for j in range(len(match[clusters[i]]['direction'])):\\n # sample gc positional uncertainties\\n for k in range(-1, Nsample):\\n if k==-1:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'], pm_ra_cosdec=t_['pmRA_'], pm_dec=t_['pmDE'], radial_velocity=t_['RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1.5\\n alpha = 1\\n else:\\n c = coord.SkyCoord(ra=t_['RAJ2000'], dec=t_['DEJ2000'], distance=t_['Rsun'] + np.random.randn()*t_['e_Rsun'], pm_ra_cosdec=t_['pmRA_'] + np.random.randn()*t_['e_pmRA_'], pm_dec=t_['pmDE'] + np.random.randn()*t_['e_pmDE'], radial_velocity=t_['RV'] + np.random.randn()*t_['e_RV'], frame='icrs')\\n w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)[0]\\n \\n lw = 1\\n alpha = 0.1\\n \\n orbit = ham.integrate_orbit(w0, dt=dt*match[clusters[i]]['direction'][j], n_steps=match[clusters[i]]['nstep'][j])\\n orbit_eq = orbit.to_coord_frame(coord.ICRS, galactocentric_frame=gc_frame)\\n orbit_gal = orbit.to_coord_frame(coord.Galactic, galactocentric_frame=gc_frame)\\n \\n \\n plt.sca(ax[0])\\n dra = (orbit_eq.ra+ra_off).wrap_at(wangle)[1:] - (orbit_eq.ra+ra_off).wrap_at(wangle)[:-1]\\n if np.any(np.abs(dra)>180*u.deg):\\n pos_break = dra>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_eq.dec.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_eq.dec.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_eq.ra+ra_off).wrap_at(wangle).rad, orbit_eq.dec.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n plt.sca(ax[1])\\n dl = orbit_gal.l.wrap_at(wangle)[1:] - orbit_gal.l.wrap_at(wangle)[:-1]\\n if np.any(np.abs(dl)>180*u.deg):\\n pos_break = dl>180*u.deg\\n ind_break = np.argmax(pos_break)\\n ipad = 1\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[:ind_break-ipad], orbit_gal.b.rad[:ind_break-ipad], '-', color=color, lw=lw, label='', alpha=alpha)\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad[ind_break+ipad:], orbit_gal.b.rad[ind_break+ipad:], '-', color=color, lw=lw, label='', alpha=alpha)\\n else:\\n plt.plot((orbit_gal.l+l_off).wrap_at(wangle).rad, orbit_gal.b.rad, '-', color=color, lw=lw, label='', alpha=alpha)\\n \\n # add streams\\n pkl = pickle.load(open('../data/streams/data_{:s}.pkl'.format(match[clusters[i]]['streams'][j]), 'rb'))\\n cs = coord.SkyCoord(ra=pkl['dec'][0], dec=pkl['dec'][1], frame='icrs')\\n cs_gal = cs.transform_to(coord.Galactic)\\n \\n plt.sca(ax[0])\\n plt.plot((cs.ra+ra_off).wrap_at(wangle).rad, cs.dec.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_ra'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_dec'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['eq_angle'][j].value, ha='center', va='center')\\n \\n plt.sca(ax[1])\\n plt.plot((cs_gal.l+l_off).wrap_at(wangle).rad, cs_gal.b.rad, 'o', color=color, ms=8, label=match[clusters[i]]['streams'][j])\\n plt.text(coord.Longitude(match[clusters[i]]['stream_l'][j]).wrap_at(wangle).rad, coord.Latitude(match[clusters[i]]['stream_b'][j]).rad, match[clusters[i]]['stream_label'][j], fontsize='small', alpha=alpha_text, rotation=match[clusters[i]]['gal_angle'][j].value, ha='center', va='center')\\n \\n \\n plt.sca(ax[0])\\n plt.grid(ls=':')\\n plt.xlabel('R.A. [deg]')\\n plt.ylabel('Dec [deg]')\\n\\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]-ra_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n plt.sca(ax[1])\\n plt.grid(ls=':')\\n plt.xlabel('Galactic longitude [deg]')\\n plt.ylabel('Galactic latitude [deg]')\\n \\n plt.gca().xaxis.set_ticklabels([])\\n \\n xloc = coord.Longitude(np.arange(-150,180,30)*u.deg)\\n xloc = np.delete(xloc, [2,3])\\n yloc = coord.Latitude(5*u.deg)\\n Nx = len(xloc)\\n \\n for i in range(Nx):\\n plt.text(xloc[i].wrap_at(wangle).rad, yloc.rad, '{:.0f}$\\\\degree$'.format((xloc[i]+l_off).wrap_at(wangle).degree), alpha=0.6, ha='center', va='center')\\n \\n \\n \\n plt.tight_layout(h_pad=2)\\n plt.savefig('../paper/sky_orbits.pdf')\",\n \"def Test_data():\\n print (\\\"loading test data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n\\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\\n test_real = f['test_real'][:]\\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\\n test_imag = f['test_imag'][:]\\n test_real = np.transpose(test_real, (0, 1, 3, 2))\\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\\n test_data = test_real+1j*test_imag\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end - time_start))\\n return test_data\",\n \"def test_CFCalculation_hdf_files_wybourne_convention():\\n from masci_tools.tools.cf_calculation import CFCalculation, CFCoefficient\\n\\n expected_results = [\\n CFCoefficient(l=2,\\n m=0,\\n spin_up=(-1143.37690772798 + 0j),\\n spin_down=(-1116.4673949314702 + 0j),\\n unit='K',\\n convention='Wybourne'),\\n CFCoefficient(l=4,\\n m=0,\\n spin_up=(-279.86031845844036 + 0j),\\n spin_down=(-174.80348694839867 + 0j),\\n unit='K',\\n convention='Wybourne'),\\n CFCoefficient(l=6,\\n m=0,\\n spin_up=(61.60559164788924 + 0j),\\n spin_down=(34.69144207186498 + 0j),\\n unit='K',\\n convention='Wybourne'),\\n CFCoefficient(l=6,\\n m=-6,\\n spin_up=(116.32750335918315 + 4.696327749935313e-06j),\\n spin_down=(90.09789430612014 + 3.6373963939901583e-06j),\\n unit='K',\\n convention='Wybourne'),\\n CFCoefficient(l=6,\\n m=6,\\n spin_up=(116.32750335918315 - 4.696327749935313e-06j),\\n spin_down=(90.09789430612014 - 3.6373963939901583e-06j),\\n unit='K',\\n convention='Wybourne')\\n ]\\n\\n cf = CFCalculation()\\n cf.readPot('files/cf_calculation/CFdata.hdf')\\n cf.readCDN('files/cf_calculation/CFdata.hdf')\\n results = cf.performIntegration(convert=False)\\n\\n print(results)\\n assert results == expected_results\",\n \"def test_species_to_sdf_file(self):\\n path = os.path.join(ARC_PATH, 'arc', 'testing', 'mol.sdf')\\n spc = ARCSpecies(label='NCC', smiles='NCC')\\n converter.species_to_sdf_file(spc, path)\\n with open(path, 'r') as f:\\n sdf_content = f.read()\\n expected_sdf = \\\"\\\"\\\"\\n RDKit 3D\\n\\n 10 9 0 0 0 0 0 0 0 0999 V2000\\n 1.1517 -0.3760 -0.5231 N 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.2893 0.4500 0.3115 C 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.1415 -0.0561 0.2592 C 0 0 0 0 0 0 0 0 0 0 0 0\\n 1.1386 -1.3376 -0.1854 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 2.1151 -0.0555 -0.4352 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.6517 0.4342 1.3447 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 0.3279 1.4855 -0.0414 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.2133 -1.0839 0.6308 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.7870 0.5726 0.8809 H 0 0 0 0 0 0 0 0 0 0 0 0\\n -1.5327 -0.0332 -0.7636 H 0 0 0 0 0 0 0 0 0 0 0 0\\n 1 2 1 0\\n 1 4 1 0\\n 1 5 1 0\\n 2 3 1 0\\n 2 6 1 0\\n 2 7 1 0\\n 3 8 1 0\\n 3 9 1 0\\n 3 10 1 0\\nM END\\n$$$$\\n\\\"\\\"\\\"\\n self.assertEqual(sdf_content, expected_sdf)\",\n \"def constant_2015():\\n\\n #Load the CMIP6 historical\\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\\n #Get low and high level emissions just in the last year (2014)\\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\\n final_cubes = iris.cube.CubeList()\\n for cube in cubes:\\n final_cube = cube[-12:]\\n final_cubes.append(final_cube)\\n \\n #Set the year-on-year proportional reductions to be nothing\\n yoy_rates = calc_perc_reducts()\\n yoy_rates = np.array(yoy_rates)\\n yoy_rates = np.ones_like(yoy_rates)\\n\\n #Create coordinates for new nc file between 2014 and 2100\\n lat_coord = cubes[0].coord('latitude')\\n lon_coord = cubes[0].coord('longitude')\\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\\n\\n #Create the cube date\\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n #Set first year equal to 2014 in CMIP6 historical\\n cube_data_surf[:12,...] = final_cubes[0].data\\n cube_data_high[:12,...] = final_cubes[1].data\\n #Apply equal emissions in all other years too\\n for i in range(12,cube_data_surf.shape[0]):\\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\\n #Make the output cubes\\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\\n\\n fut_cube_high.var_name = 'field569_1'\\n fut_cube_high.units='kg/m2/s'\\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\\n fut_cube_surf.var_name = 'field569'\\n fut_cube_surf.units='kg/m2/s'\\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\\n\\n #Load the DMS cube from standard RCP2.6\\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\\n\\n dms_cube.var_name = 'field570'\\n dms_cube.attributes.pop('name')\\n dms_cube.coord('time').var_name = 'time'\\n dms_cube.coord('time').long_name = 'time'\\n\\n fut_cube_high = fut_cube_high[:-2]\\n fut_cube_surf = fut_cube_surf[:-2]\\n\\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\\n\\n #Save the final cubes as netcdf (cutting them to be the same length)\\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n os.system('ncatted -O -a calendar,time,m,c,\\\"360_day\\\" '+data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n\\n return\",\n \"def convert_calculations(filename, hdf5_data):\\n x1 = []\\n\\n with open(filename, 'r') as inp:\\n for line in inp:\\n x1.append(line)\\n\\n idx = 1\\n dset = require_dataset(hdf5_data, structure.H5_ENV_VOLUME, (1,), dtype=settings.NEMOH_FLOAT)\\n dset[0] = float(x1[idx].split()[0])\\n set_hdf5_attributes(dset, structure.H5_ENV_VOLUME_ATTR)\\n idx += 1\\n\\n dset = require_dataset(hdf5_data, structure.H5_ENV_GRAVITY, (1,), dtype=settings.NEMOH_FLOAT)\\n dset[0] = float(x1[idx].split()[0])\\n set_hdf5_attributes(dset, structure.H5_ENV_GRAVITY_ATTR)\\n idx += 1\\n\\n\\n dset = require_dataset(hdf5_data, structure.H5_ENV_DEPTH, (1,), dtype=settings.NEMOH_FLOAT)\\n dset[0] = float(x1[idx].split()[0])\\n set_hdf5_attributes(dset, structure.H5_ENV_DEPTH_ATTR)\\n idx += 1\\n\\n dset = require_dataset(hdf5_data, structure.H5_ENV_WAVE_POINT, (2,), dtype=settings.NEMOH_FLOAT)\\n x2 = x1[idx].split()\\n dset[0] = float(x2[0])\\n dset[1] = float(x2[1])\\n set_hdf5_attributes(dset, structure.H5_ENV_WAVE_POINT_ATTR)\\n\\n idx = 6\\n\\n num_bodies = int(x1[idx].split()[0])\\n\\n for i in range(num_bodies):\\n\\n body = structure.H5_BODIES + structure.H5_BODY_BASE + str(i+1) + '/'\\n idx += 2\\n\\n mesh_x = []\\n\\n mesh_path = os.path.join(os.path.abspath(os.path.dirname(filename)), str(x1[idx].split()[0]).strip(' \\\\t\\\\n\\\\r'))\\n\\n with open(mesh_path, 'r') as mesh_file:\\n for line in mesh_file:\\n mesh_x.append(line)\\n\\n idx += 1\\n x2 = x1[idx].split()\\n\\n num_points = int(x2[0])\\n num_panels = int(x2[1])\\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_NUM_POINTS, (1, ), dtype=settings.NEMOH_INT)\\n dset[0] = num_points\\n set_hdf5_attributes(dset, structure.H5_BODY_NUM_POINTS_ATTR)\\n\\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_NUM_PANELS, (1, ), dtype=settings.NEMOH_INT)\\n dset[0] = num_panels\\n set_hdf5_attributes(dset, structure.H5_BODY_NUM_PANELS_ATTR)\\n\\n mesh_idx = 0\\n dset = require_dataset(hdf5_data, body + structure.H5_BODY_MESH, (num_points+num_panels+1, 4), dtype=settings.NEMOH_FLOAT)\\n mesh_x2 = mesh_x[mesh_idx].split()\\n set_hdf5_attributes(dset, structure.H5_BODY_MESH_ATTR)\\n\\n dset[0, 0] = int(mesh_x2[0])\\n dset[0, 1] = int(mesh_x2[1])\\n\\n for j in range(1, num_points+num_panels+1):\\n mesh_idx += 1\\n mesh_x2 = mesh_x[mesh_idx].split()\\n dset[j, :] = [float(x) for x in mesh_x2[:4]]\\n\\n if j == num_points:\\n mesh_idx += 1\\n\\n idx += 1\\n num = int(x1[idx].split()[0])\\n dset = require_dataset(hdf5_data, body + structure.H5_FREEDOM_DEGREE, (num, 7), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_FREEDOM_DEGREE_ATTR)\\n for j in range(num):\\n idx += 1\\n x2 = x1[idx].split()\\n dset[j, :] = np.array([float(x) for x in x2[:7]])\\n\\n idx += 1\\n num = int(x1[idx].split()[0])\\n dset = require_dataset(hdf5_data, body + structure.H5_GENERALISED_FORCES, (num, 7), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_GENERALISED_FORCES_ATTR)\\n for j in range(num):\\n idx += 1\\n x2 = x1[idx].split()\\n dset[j, :] = [float(x) for x in x2[:7]]\\n\\n idx += 1\\n num = int(x1[idx].split()[0])\\n for j in range(num):\\n idx += 1\\n\\n idx += 2\\n x2 = x1[idx].split()\\n\\n dset = require_dataset(hdf5_data, structure.H5_NUM_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_NUM_WAVE_FREQUENCIES_ATTR)\\n dset[0] = int(x2[0])\\n dset = require_dataset(hdf5_data, structure.H5_MIN_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_MIN_WAVE_FREQUENCIES_ATTR)\\n dset[0] = float(x2[1])\\n dset = require_dataset(hdf5_data, structure.H5_MAX_WAVE_FREQUENCIES, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_MAX_WAVE_FREQUENCIES_ATTR)\\n dset[0] = float(x2[2])\\n idx += 1\\n x2 = x1[idx].split()\\n dset = require_dataset(hdf5_data, structure.H5_NUM_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_NUM_WAVE_DIRECTIONS_ATTR)\\n dset[0] = int(x2[0])\\n\\n dset = require_dataset(hdf5_data, structure.H5_MIN_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_MIN_WAVE_DIRECTIONS_ATTR)\\n dset[0] = float(x2[1])\\n\\n dset = require_dataset(hdf5_data, structure.H5_MAX_WAVE_DIRECTIONS, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_MAX_WAVE_DIRECTIONS_ATTR)\\n dset[0] = float(x2[2])\\n\\n idx += 2\\n x2 = x1[idx].split()\\n\\n dset = require_dataset(hdf5_data, structure.H5_COMPUTE_IRF, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_COMPUTE_IRF_ATTR)\\n dset[0] = int(x2[0])\\n\\n dset = require_dataset(hdf5_data, structure.H5_IRF_TIME_STEP, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_IRF_TIME_STEP_ATTR)\\n dset[0] = float(x2[1])\\n dset = require_dataset(hdf5_data, structure.H5_IRF_DURATION, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_IRF_DURATION_ATTR)\\n dset[0] = float(x2[2])\\n\\n idx += 1\\n x2 = x1[idx].split()\\n dset = require_dataset(hdf5_data, structure.H5_SHOW_PRESSURE, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_SHOW_PRESSURE_ATTR)\\n dset[0] = int(x2[0])\\n\\n idx += 1\\n x2 = x1[idx].split()\\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_NUMBER, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_KOCHIN_NUMBER_ATTR)\\n dset[0] = float(x2[0])\\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_MIN, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_KOCHIN_MIN_ATTR)\\n dset[0] = float(x2[1])\\n dset = require_dataset(hdf5_data, structure.H5_KOCHIN_MAX, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_KOCHIN_MAX_ATTR)\\n dset[0] = float(x2[2])\\n\\n\\n idx += 1\\n x2 = x1[idx].split()\\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_POINTS_X, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_POINTS_X_ATTR)\\n dset[0] = int(x2[0])\\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_POINTS_Y, (1,), dtype=settings.NEMOH_INT)\\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_POINTS_Y_ATTR)\\n dset[0] = int(x2[1])\\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_DIMENSION_X, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_DIMENSION_X_ATTR)\\n dset[0] = float(x2[2])\\n dset = require_dataset(hdf5_data, structure.H5_FREE_SURFACE_DIMENSION_Y, (1,), dtype=settings.NEMOH_FLOAT)\\n set_hdf5_attributes(dset, structure.H5_FREE_SURFACE_DIMENSION_Y_ATTR)\\n dset[0] = float(x2[3])\",\n \"def initialize_data(self , station = '', datasets = {} ):\\n \\n self.datasets = datasets\\n self.datasets_keys = datasets.keys()\\n self.station = station\\n \\n data = {} # container for the data of each dataset\\n source_configuration = {} # container for the source_configuration of each dataset\\n \\n\\n \\n \\\"\\\"\\\" Looping over the datasets \\\"\\\"\\\"\\n logging.info('*** Reading and Initializing the data from the netCDF files ')\\n \\n \\n for k,v in datasets.items() :\\n logging.info(' Initialising the dataset: *** %s ' , k )\\n data[k] = {} \\n data['cdm_tables'] = {} \\n \\n ### alternative with xarray \\n #ds = xr.load_dataset(v) \\n #observations_table = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n ### alternative with netCDF4\\n #ds = nc.Dataset(v) \\n #data[k]['dateindex'] = ds.variables['dateindex'][0,:] # storing the dateindex \\n \\n ###for h5py but cant extract date time units !!!\\n ds = h5py.File(v , driver=\\\"core\\\" ) \\n data[k]['df'] = ds # storing the entire file \\n try: \\n data[k]['source_file'] = ds['source_configuration']['source_file'][0]\\n except:\\n data[k]['source_file'] = str(v) # temp fix \\n \\n #data[k]['product_code'] = ds['source_configuration']['product_code'][0] \\n #data[k]['recordtimestamp'] = ds['recordtimestamp'].value\\n #data[k]['recordindex'] = ds['recordindex'].value \\n #ds.close() \\n logging.debug('Reading the file with h5py ')\\n \\n \\n # add here appending datasets for the case of ncar_w and ncar_t \\n \\n \\n self.data = data\\n self.make_dataframe()\\n ds.close()\\n \\n \\\"\\\"\\\" Reading the header_table, station_configuration, source_configuration \\\"\\\"\\\"\\n for k,v in datasets.items() : \\n \\n #d = xr.open_dataset(v , engine = 'h5netcdf' ) \\n #data[k]['recordtimestamp'] = d['recordtimestamp'].values\\n #data[k]['recordindex'] = d['recordindex'].values \\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'station_configuration') \\n data[k]['station_configuration'] = d.to_dataframe() \\n #data[k]['station_configuration'] = d ### USELESS ? \\n logging.debug('Done with %s station_configuration' , str(k) )\\n \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'header_table') \\n logging.debug('Loading the header_table') \\n if 'header_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['header_table'] = {}\\n for var in d.variables:\\n self.attributes['header_table'][var] = {}\\n self.attributes['header_table'][var]['description'] = d[var].description\\n self.attributes['header_table'][var]['external_table'] = d[var].external_table \\n data[k]['header_table'] = d.to_dataframe() \\n logging.debug('Done with %s ' , k )\\n \\n logging.info(\\\"*** Loading the observations_table (might take time) %s\\\" , k ) \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'observations_table') \\n \\n if 'observations_table' not in list( self.attributes.keys() ): # saving the attributes to be re-applied at the end\\n self.attributes['observations_table'] = {}\\n for var in d.variables:\\n self.attributes['observations_table'][var] = {}\\n self.attributes['observations_table'][var]['description'] = d[var].description\\n self.attributes['observations_table'][var]['external_table'] = d[var].external_table\\n \\n \\n logging.info(\\\"*** Loading the source configuration %s\\\" , k ) \\n try: \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'source_configuration')\\n d = d.isel(hdrlen=[0])\\n data[k]['source_configuration'] = d.to_dataframe() ### USELESS ? \\n logging.debug('Done with %s source_configuration' , k )\\n except: \\n data[k]['source_configuration']= pd.DataFrame(np.array( [ [ self.data[k]['source_file'] ] ] ) , columns=['source_file'] ) \\n \\n if k == 'era5_1': # reading the whole era5_1 feedback (including reanalysis)\\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = 'era5fb') \\n data[k]['era5fb'] = d.to_dataframe() \\n logging.debug('Done with %s era5 feedback ', k )\\n \\n \\\"\\\"\\\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \\\"\\\"\\\" \\n if list(datasets.keys()).index(k) == 0 :\\n for t in [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type']: \\n \\n d = xr.open_dataset(v , engine = 'h5netcdf' , group = t) \\n #data['cdm_tables'][t] = d.to_dataframe() ### USELESS ?\\n data['cdm_tables'][t] = d \\n \\n d.close() \\n ds.close()\\n\\n \\\"\\\"\\\" Reading the name of the original source file \\\"\\\"\\\"\\n source_configuration[k] = {} \\n source_configuration[k]['source_file'] = [ c for c in v.split('/') if '.nc' in c][0]\\n\\n \\n \\\"\\\"\\\" Storing the station configurations \\\"\\\"\\\" \\n self.source_configuration = source_configuration \\n \\n \\\"\\\"\\\" Making all date_times \\\"\\\"\\\" \\n self.make_all_datetime()\\n \\n \\n \\\"\\\"\\\" feedback columns \\\"\\\"\\\"\\n if 'era5_1' in list (self.data.keys() ):\\n self.fb_columns = list(self.data['era5_1']['era5fb'].columns ) \\n else:\\n self.fb_columns = ['empty']\",\n \"def test_brainvision_data():\\n assert_raises(IOError, read_raw_brainvision, vmrk_path)\\n assert_raises(ValueError, read_raw_brainvision, vhdr_path, montage,\\n preload=True, scale=\\\"foo\\\")\\n with warnings.catch_warnings(record=True) as w: # event parsing\\n raw_py = _test_raw_reader(\\n read_raw_brainvision, vhdr_fname=vhdr_path, montage=montage,\\n eog=eog)\\n assert_true(all('parse triggers that' in str(ww.message) for ww in w))\\n assert_true('RawBrainVision' in repr(raw_py))\\n\\n assert_equal(raw_py.info['highpass'], 0.)\\n assert_equal(raw_py.info['lowpass'], 250.)\\n\\n picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads')\\n data_py, times_py = raw_py[picks]\\n\\n # compare with a file that was generated using MNE-C\\n raw_bin = Raw(eeg_bin, preload=True)\\n picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads')\\n data_bin, times_bin = raw_bin[picks]\\n\\n assert_array_almost_equal(data_py, data_bin)\\n assert_array_almost_equal(times_py, times_bin)\\n\\n # Make sure EOG channels are marked correctly\\n for ch in raw_py.info['chs']:\\n if ch['ch_name'] in eog:\\n assert_equal(ch['kind'], FIFF.FIFFV_EOG_CH)\\n elif ch['ch_name'] == 'STI 014':\\n assert_equal(ch['kind'], FIFF.FIFFV_STIM_CH)\\n elif ch['ch_name'] in raw_py.info['ch_names']:\\n assert_equal(ch['kind'], FIFF.FIFFV_EEG_CH)\\n else:\\n raise RuntimeError(\\\"Unknown Channel: %s\\\" % ch['ch_name'])\\n\\n # test loading v2\\n read_raw_brainvision(vhdr_v2_path, eog=eog, preload=True,\\n response_trig_shift=1000)\",\n \"def test_compute_Sv_ek80_BB_complex(ek80_path):\\n ek80_raw_path = str(\\n ek80_path.joinpath('ar2.0-D20201209-T235955.raw')\\n ) # CW complex\\n echodata = ep.open_raw(ek80_raw_path, sonar_model='EK80')\\n ds_Sv = ep.calibrate.compute_Sv(\\n echodata, waveform_mode='BB', encode_mode='complex'\\n )\\n assert isinstance(ds_Sv, xr.Dataset) is True\\n ds_TS = ep.calibrate.compute_TS(\\n echodata, waveform_mode='BB', encode_mode='complex'\\n )\\n assert isinstance(ds_TS, xr.Dataset) is True\",\n \"def test_defect_calculation_control():\\n csnet = example.control.cs_network()\\n slaves, connections = csnet\\n step_sizes = {name: Fraction(1, 2) for name in slaves}\\n make_zoh: cs.ConverterConstructor = cs.Zoh\\n rate_converters = {cs.Connection(src, dst): make_zoh for dst, src in connections.items()}\\n initial_tokens = {sdf.Dst('PI', 'u'): [0.], sdf.Dst('PT2', 'u'): [0.]}\\n cosim = csnet, step_sizes, rate_converters, initial_tokens\\n defect = cs.evaluate(cosim, Fraction(20.))\\n for val in defect.connection.values():\\n assert val < float('inf')\\n for val in defect.output.values():\\n assert val < float('inf')\",\n \"def read_h5(self):\\n infile = h5py.File(self.inf_name,'r')\\n\\n vardict = self.labdict\\n #store data with the correct labels\\n for k in infile['plasma/1d'].keys():\\n try:\\n vardict[k] = infile[self.labdict[k]].value\\n except:\\n vardict[k] = []\\n\\n vardict['a_ions']=infile['/plasma/anum'].value\\n vardict['znum']=infile['/plasma/znum'].value\\n \\n\\n self.rho_in = vardict['rho']\\n self._rho_vol = infile['distributions/rhoDist/abscissae/dim1'].value[1:]\\n self._volumes = infile['distributions/rhoDist/shellVolume'].value\\n self.nrho_in = np.size(self.rho_in)\\n\\n if vardict['a_ions'][0]!='/':\\n self.nspec = len(vardict['a_ions'])\\n else:\\n self.nspec = vardict['ni'].shape[1]\\n print(\\\"Number of ions: \\\", self.nspec)\\n if len(vardict['a_ions'])!=len(vardict['znum']):\\n print(\\\"ERROR! array of A and Z don't have the same length\\\")\\n\\n self.A = vardict['a_ions']\\n self.Z = vardict['znum']\\n self.nion = self.nspec\\n \\n self.te_in = vardict['te'][:]\\n self.ne_in = vardict['ne'][:]\\n self.ti_in = vardict['ti'][:]\\n ni1_in = vardict['ni'][:,0]\\n self.ni_in = np.zeros((self.nion, self.nrho_in),dtype=float)\\n self.ni_in[0,:] = ni1_in\\n if self.nion==2:\\n ni2_in = vardict['ni'][:,1]\\n self.ni_in[1,:] = ni2_in\\n elif self.nion==3:\\n ni2_in = vardict['ni'][:,1]\\n ni3_in = vardict['ni'][:,2]\\n self.ni_in[1,:] = ni2_in\\n self.ni_in[2,:] = ni3_in\\n\\n try:\\n self.vt_in = vardict['vtor']\\n except:\\n self.vt_in = np.zeros(self.nrho_in,dtype=float)\\n\\n try:\\n self.zeff_in = vardict['zeff'][:]\\n except:\\n self.zeff_in = np.zeros(self.nrho_in,dtype=float)\\n\\n self.ni = np.zeros((self.nion, self.nrho),dtype = float)\\n self.spline()\",\n \"def read_satellite(filename, ftype):\\n #ftype = 'l3c'\\n #filename = '/gws/nopw/j04/cds_c3s_sst/output/v2.6.0/l3c/AVHRR19_G/2018/03/01/20180301120000-C3S-L3C_GHRSST-SSTskin-AVHRR19_G-ICDR2.0_day-v02.0-fv01.0.nc'\\n #ftype = 'l4'\\n #filename = '/gws/nopw/j04/cds_c3s_sst/public/data/ICDR_v2/Analysis/L4/v2.0/2018/01/01/20180101120000-C3S-L4_GHRSST-SSTdepth-OSTIA-GLOB_ICDR2.0-v02.0-fv01.0.nc'\\n print \\\"Reading %s file: %s\\\" % (ftype, filename)\\n \\n # Read data - L4 or L3C (note L4 mask and L3C quality level have same array name)\\n ncin = netCDF4.Dataset(filename)\\n if ftype == 'l4':\\n lon = ncin.variables['lon'][:]\\n lat = ncin.variables['lat'][:]\\n time_read = ncin.variables['time'][:]\\n sst = ncin.variables['analysed_sst'][:]\\n unc = ncin.variables['analysis_uncertainty'][:]\\n sea_ice_frac = ncin.variables['sea_ice_fraction'][:]\\n ql = ncin.variables['mask'][:]\\n sstfill = ncin.variables['analysed_sst']._FillValue\\n sstao = ncin.variables['analysed_sst'].add_offset\\n sstsf = ncin.variables['analysed_sst'].scale_factor\\n elif ftype == 'l3c':\\n lon = ncin.variables['lon'][:]\\n lat = ncin.variables['lat'][:]\\n time_read = ncin.variables['time'][:]\\n time_bnds = ncin.variables['time_bnds'][:]\\n sst = ncin.variables['sea_surface_temperature'][:]\\n sst_depth = ncin.variables['sea_surface_temperature_depth'][:]\\n sst_dtime = ncin.variables['sst_dtime'][:]\\n sst_depth_dtime = ncin.variables['sst_depth_dtime'][:]\\n sses_bias = ncin.variables['sses_bias'][:]\\n sses_sd = ncin.variables['sses_standard_deviation'][:]\\n sst_depth_total_unc = ncin.variables['sst_depth_total_uncertainty'][:]\\n l2p_flags = ncin.variables['l2p_flags'][:]\\n ql = ncin.variables['quality_level'][:]\\n wind_speed = ncin.variables['wind_speed'][:]\\n large_scale_cor_unc = ncin.variables['large_scale_correlated_uncertainty'][:]\\n synop_cor_unc = ncin.variables['synoptically_correlated_uncertainty'][:]\\n uncor_unc = ncin.variables['uncorrelated_uncertainty'][:]\\n adj_unc = ncin.variables['adjustment_uncertainty'][:]\\n aerosol_dyn_ind = ncin.variables['aerosol_dynamic_indicator'][:]\\n sens = ncin.variables['sensitivity'][:]\\n tfill = ncin.variables['sst_dtime']._FillValue\\n sstfill = ncin.variables['sea_surface_temperature']._FillValue\\n sstao = ncin.variables['sea_surface_temperature'].add_offset\\n sstsf = ncin.variables['sea_surface_temperature'].scale_factor\\n else:\\n print 'ftype not recognised or supported'\\n \\n # Create time field\\n # -> If L4 then create a time field set to time in L4 file\\n # -> Also add a time fill value to keep coding simple later on\\n if ftype == 'l4':\\n time = np.empty((7200,3600))\\n time[:,:] = time_read\\n tfill = -2147483648\\n else:\\n time = copy.deepcopy(sst_dtime) # Need to make a hard copy\\n mask = sst_dtime.mask == False; mask = mask[0,:,:]\\n row, col = np.where(mask==True)\\n time.data[0, row, col] = time.data[0,row, col] + time_read\\n \\n # Create output structure\\n if ftype == 'l4':\\n data = dict(lon=lon,\\n lat=lat,\\n time_read=time_read,\\n time=time,\\n sst=sst,\\n unc=unc,\\n sea_ice_frac=sea_ice_frac,\\n ql=ql,\\n tfill=tfill,\\n sstfill=sstfill,\\n sstao=sstao,\\n sstsf=sstsf)\\n elif ftype == 'l3c':\\n data = dict(lon=lon,\\n lat=lat,\\n time_read=time_read,\\n time=time,\\n time_bnds=time_bnds,\\n sst=sst,\\n sst_depth=sst_depth,\\n sst_dtime=sst_dtime,\\n sst_depth_dtime=sst_depth_dtime,\\n sses_bias=sses_bias,\\n sses_sd=sses_sd,\\n sst_depth_total_unc=sst_depth_total_unc,\\n l2p_flags=l2p_flags,\\n ql=ql,\\n wind_speed=wind_speed,\\n large_scale_cor_unc=large_scale_cor_unc,\\n synop_cor_unc=synop_cor_unc,\\n uncor_unc=uncor_unc,\\n adj_unc=adj_unc,\\n aerosol_dyn_ind=aerosol_dyn_ind,\\n sens=sens,\\n tfill=tfill,\\n sstfill=sstfill,\\n sstao=sstao,\\n sstsf=sstsf)\\n else:\\n print 'ftype not recognised or supported'\\n \\n return data\",\n \"def read_skyh5(\\n self, filename, run_check=True, check_extra=True, run_check_acceptability=True\\n ):\\n with h5py.File(filename, \\\"r\\\") as fileobj:\\n if \\\"/Header\\\" not in fileobj:\\n raise ValueError(\\\"This is not a proper skyh5 file.\\\")\\n\\n init_params = {\\\"filename\\\": os.path.basename(filename)}\\n\\n with h5py.File(filename, \\\"r\\\") as fileobj:\\n # extract header information\\n header = fileobj[\\\"/Header\\\"]\\n header_params = [\\n \\\"_Ncomponents\\\",\\n \\\"_Nfreqs\\\",\\n \\\"_component_type\\\",\\n \\\"_spectral_type\\\",\\n \\\"_history\\\",\\n \\\"_name\\\",\\n \\\"_nside\\\",\\n \\\"_hpx_order\\\",\\n \\\"_hpx_inds\\\",\\n \\\"_freq_array\\\",\\n \\\"_freq_edge_array\\\",\\n \\\"_reference_frequency\\\",\\n \\\"_spectral_index\\\",\\n \\\"_stokes_error\\\",\\n \\\"_beam_amp\\\",\\n \\\"_extended_model_group\\\",\\n ]\\n\\n optional_params = [\\n \\\"_hpx_order\\\",\\n \\\"_freq_array\\\",\\n \\\"_freq_edge_array\\\",\\n \\\"_reference_frequency\\\",\\n \\\"_spectral_index\\\",\\n \\\"_stokes_error\\\",\\n \\\"_beam_amp\\\",\\n \\\"_extended_model_group\\\",\\n ]\\n\\n self.component_type = header[\\\"component_type\\\"][()].tobytes().decode(\\\"utf-8\\\")\\n\\n if self.component_type != \\\"healpix\\\":\\n optional_params.extend([\\\"_nside\\\", \\\"_hpx_inds\\\"])\\n if \\\"skycoord\\\" in header:\\n skycoord_dict = {}\\n for key in header[\\\"skycoord\\\"]:\\n if key in [\\\"frame\\\", \\\"representation_type\\\"]:\\n expected_type = str\\n else:\\n expected_type = None\\n skycoord_dict[key] = _get_value_hdf5_group(\\n header[\\\"skycoord\\\"], key, expected_type\\n )\\n init_params[\\\"skycoord\\\"] = SkyCoord(**skycoord_dict)\\n else:\\n if \\\"lat\\\" in header and \\\"lon\\\" in header and \\\"frame\\\" in header:\\n header_params += [\\\"lat\\\", \\\"lon\\\", \\\"frame\\\"]\\n optional_params += [\\\"lat\\\", \\\"lon\\\", \\\"frame\\\"]\\n elif \\\"ra\\\" in header and \\\"dec\\\" in header:\\n header_params += [\\\"ra\\\", \\\"dec\\\"]\\n optional_params += [\\\"ra\\\", \\\"dec\\\"]\\n else:\\n raise ValueError(\\n \\\"No component location information found in file.\\\"\\n )\\n warnings.warn(\\n \\\"Parameter skycoord not found in skyh5 file. \\\"\\n \\\"This skyh5 file was written by an older version of pyradiosky. \\\"\\n \\\"Consider re-writing this file to ensure future compatibility\\\"\\n )\\n else:\\n optional_params.append(\\\"_name\\\")\\n\\n if \\\"hpx_frame\\\" in header:\\n if isinstance(header[\\\"hpx_frame\\\"], h5py.Dataset):\\n # hpx_frame was stored as a string\\n frame_str = _get_value_hdf5_group(header, \\\"hpx_frame\\\", str)\\n dummy_coord = SkyCoord(0, 0, unit=\\\"rad\\\", frame=frame_str)\\n init_params[\\n \\\"hpx_frame\\\"\\n ] = dummy_coord.frame.replicate_without_data(copy=True)\\n else:\\n # hpx_frame was stored as a nested dset\\n skycoord_dict = {}\\n for key in header[\\\"hpx_frame\\\"]:\\n if key in [\\\"frame\\\", \\\"representation_type\\\"]:\\n expected_type = str\\n else:\\n expected_type = None\\n skycoord_dict[key] = _get_value_hdf5_group(\\n header[\\\"hpx_frame\\\"], key, expected_type\\n )\\n dummy_coord = SkyCoord(0, 0, unit=\\\"rad\\\", **skycoord_dict)\\n init_params[\\n \\\"hpx_frame\\\"\\n ] = dummy_coord.frame.replicate_without_data(copy=True)\\n elif \\\"frame\\\" in header:\\n # frame was stored as a string\\n frame_str = _get_value_hdf5_group(header, \\\"frame\\\", str)\\n dummy_coord = SkyCoord(0, 0, unit=\\\"rad\\\", frame=frame_str)\\n init_params[\\\"hpx_frame\\\"] = dummy_coord.frame.replicate_without_data(\\n copy=True\\n )\\n\\n for par in header_params:\\n if par in [\\\"lat\\\", \\\"lon\\\", \\\"frame\\\", \\\"ra\\\", \\\"dec\\\"]:\\n parname = par\\n if par == \\\"frame\\\":\\n expected_type = \\\"str\\\"\\n else:\\n expected_type = Quantity\\n else:\\n param = getattr(self, par)\\n parname = param.name\\n expected_type = param.expected_type\\n\\n # skip optional params if not present\\n if par in optional_params:\\n if parname not in header:\\n continue\\n\\n if parname not in header:\\n raise ValueError(\\n f\\\"Expected parameter {parname} is missing in file.\\\"\\n )\\n\\n value = _get_value_hdf5_group(header, parname, expected_type)\\n\\n if parname == \\\"nside\\\":\\n value = int(value)\\n\\n init_params[parname] = value\\n\\n # check that the parameters not passed to the init make sense\\n if init_params[\\\"component_type\\\"] == \\\"healpix\\\":\\n if init_params[\\\"Ncomponents\\\"] != init_params[\\\"hpx_inds\\\"].size:\\n raise ValueError(\\n \\\"Ncomponents is not equal to the size of 'hpx_inds'.\\\"\\n )\\n else:\\n if init_params[\\\"Ncomponents\\\"] != init_params[\\\"name\\\"].size:\\n raise ValueError(\\\"Ncomponents is not equal to the size of 'name'.\\\")\\n\\n if \\\"freq_array\\\" in init_params.keys():\\n if init_params[\\\"Nfreqs\\\"] != init_params[\\\"freq_array\\\"].size:\\n raise ValueError(\\\"Nfreqs is not equal to the size of 'freq_array'.\\\")\\n\\n if init_params[\\\"spectral_type\\\"] == \\\"subband\\\":\\n if \\\"freq_edge_array\\\" not in init_params.keys():\\n try:\\n init_params[\\n \\\"freq_edge_array\\\"\\n ] = _get_freq_edges_from_centers(\\n init_params[\\\"freq_array\\\"], self._freq_array.tols\\n )\\n except ValueError:\\n warnings.warn(\\n \\\"No freq_edge_array in this file and frequencies are \\\"\\n \\\"not evenly spaced, so spectral_type will be set to \\\"\\n \\\"'full' rather than 'subband'.\\\"\\n )\\n init_params[\\\"spectral_type\\\"] = \\\"full\\\"\\n\\n # remove parameters not needed in __init__\\n init_params.pop(\\\"Ncomponents\\\")\\n init_params.pop(\\\"Nfreqs\\\")\\n\\n # get stokes array\\n dgrp = fileobj[\\\"/Data\\\"]\\n init_params[\\\"stokes\\\"] = dgrp[\\\"stokes\\\"] * units.Unit(\\n dgrp[\\\"stokes\\\"].attrs[\\\"unit\\\"]\\n )\\n # frame is a new parameter, check if it exists and try to read\\n # otherwise default to ICRS (the old assumed frame.)\\n if \\\"skycoord\\\" not in init_params and self.component_type != \\\"healpix\\\":\\n if \\\"frame\\\" in header:\\n init_params[\\\"frame\\\"] = header[\\\"frame\\\"][()].tobytes().decode(\\\"utf8\\\")\\n else:\\n warnings.warn(\\n \\\"No frame available in this file, assuming 'icrs'. \\\"\\n \\\"Consider re-writing this file to ensure future compatility.\\\"\\n )\\n init_params[\\\"frame\\\"] = \\\"icrs\\\"\\n\\n if self.component_type == \\\"healpix\\\" and \\\"hpx_frame\\\" in init_params.keys():\\n init_params[\\\"frame\\\"] = init_params[\\\"hpx_frame\\\"]\\n del init_params[\\\"hpx_frame\\\"]\\n\\n if self.component_type == \\\"healpix\\\" and \\\"frame\\\" not in init_params:\\n warnings.warn(\\n \\\"No frame available in this file, assuming 'icrs'. \\\"\\n \\\"Consider re-writing this file to ensure future compatility.\\\"\\n )\\n init_params[\\\"frame\\\"] = \\\"icrs\\\"\\n\\n self.__init__(**init_params)\\n\\n if run_check:\\n self.check(\\n check_extra=check_extra, run_check_acceptability=run_check_acceptability\\n )\",\n \"def run_main_test():\\r\\n\\r\\n print(\\\"\\\"\\\"\\r\\n +++++++++++++++++++++++++++++++++++++++++++\\r\\n +++ Performing Main LZJD Full File Test +++\\r\\n +++++++++++++++++++++++++++++++++++++++++++\\r\\n \\\"\\\"\\\")\\r\\n # iterate over the files in the directory\\r\\n for f in listdir(SRC):\\r\\n if isfile(join(SRC, f)):\\r\\n # prepare a dictionary with the digests ready to compare\\r\\n DIGESTS[f] = {'src': None, 'r2': None, 'ghidra': None}\\r\\n\\r\\n # calculate digest of src file\\r\\n DIGESTS[f]['src'] = digest(join(SRC, f))\\r\\n\\r\\n # name adjustment\\r\\n f2 = f.replace(\\\".c\\\", \\\".o\\\")\\r\\n\\r\\n # calculate digest of ghidra and r2 outputs\\r\\n DIGESTS[f]['ghidra'] = digest(join(GHIDRA_PATH, GHIDRA_NAME.format(f2)))\\r\\n DIGESTS[f]['r2'] = digest(join(R2DEC_PATH, R2DEC_NAME.format(f2)))\\r\\n\\r\\n # obtain the similarity from source\\r\\n SCORES[f] = {'ghidra': get_lzjd_sim(DIGESTS[f]['src'], DIGESTS[f]['ghidra']),\\r\\n 'r2': get_lzjd_sim(DIGESTS[f]['src'], DIGESTS[f]['r2']),\\r\\n 'x': get_lzjd_sim(DIGESTS[f]['ghidra'], DIGESTS[f]['r2'])}\\r\\n\\r\\n gidra_doms = 0\\r\\n for f in SCORES:\\r\\n print(\\\"{0:12}: Scores G:{1:20} R2:{2:20} X:{3:20} D:{4:20}\\\".format(f,\\r\\n SCORES[f]['ghidra'],\\r\\n SCORES[f]['r2'],\\r\\n SCORES[f]['x'],\\r\\n SCORES[f]['ghidra'] - SCORES[f]['r2']))\\r\\n if SCORES[f]['ghidra'] > SCORES[f]['r2']:\\r\\n gidra_doms += 1\\r\\n print(\\\"Ghidra Dominated on {} files\\\".format(gidra_doms))\\r\\n # This section of code prepares visualizations on the data for easy analysis\\r\\n plot_scatter(SCORES, title=\\\"LZJD Full File scores\\\")\\r\\n\\r\\n # obtian the scores as input data to the plots\\r\\n bxplt_data_gd = [score['ghidra'] for score in SCORES.values()]\\r\\n bxplt_data_r2 = [score['r2'] for score in SCORES.values()]\\r\\n\\r\\n # run pairwise t test\\r\\n print(\\\"Performing T-Test on LZJD Distance of files\\\")\\r\\n run_ttest(bxplt_data_gd, bxplt_data_r2)\",\n \"def time_calibration(input_file):\\n original_path = os.getcwd()\\n save_path = input_file['save_path']\\n #change to save data reduction directory\\n os.chdir(save_path)\\n print '\\\\n Reading the list of images ....\\\\n'\\n planet = input_file['exoplanet'] #set exoplanet name\\n images = sorted(glob.glob('AB'+planet+'*.fits'))\\n print images\\n #include de RA,DEC and epoch of the exoplanet\\n RA,DEC,epoch = input_file['RA'],input_file['DEC'],input_file['epoch']\\n #obtain ST JD using iraf task and introduce in the header\\n for i in range(len(images)):\\n hdr = fits.getheader(images[i])\\n if int(split(hdr['UT'],':')[0]) < int(hdr['timezone']):\\n new_date = use.yesterday(hdr['date-obs'])\\n #print images[i], new_date\\n else:\\n new_date = hdr['date-obs']\\n year,month,day = split(new_date,'-')\\n iraf.asttimes(year=year,month=month,day=day,time=hdr['loctime'],obs=input_file['observatory'])\\n JD = iraf.asttimes.jd #obtain julian date\\n LMST = iraf.asttimes.lmst #obtain the sideral time\\n LMST = use.sexagesimal_format(LMST) #convert sideral time in sexagesimal format\\n iraf.hedit(images[i],'ST',LMST,add='yes',verify='no',show='no',update='yes') #create the ST keyword in the header\\n iraf.ccdhedit(images[i],'LMST',LMST,type='string') #include the mean sideral time in the header\\n iraf.ccdhedit(images[i],'JD',JD,type='string') #include de julian date in the header\\n #include RA, and DEC of the object in your header\\n iraf.ccdhedit(images[i],\\\"RA\\\",RA,type=\\\"string\\\") #include right ascention in the header\\n iraf.ccdhedit(images[i],\\\"DEC\\\",DEC,type=\\\"string\\\") #include declination in the header\\n iraf.ccdhedit(images[i],\\\"epoch\\\",epoch,type=\\\"string\\\") #include epoch in the header\\n # use.update_progress((i+1.)/len(images))\\n print '\\\\n Setting airmass ....\\\\n'\\n for i in range(len(images)):\\n print '# ',images[i]\\n #iraf.hedit(images[i],'airmass',airmass,add='yes')\\n #iraf.hedit(images[i],'HJD',HJD,add='yes')\\n iraf.setairmass.observatory = input_file['observatory']\\n iraf.setairmass(images[i])\\n iraf.setjd.time = 'ut'\\n iraf.setjd(images[i])\\n print '\\\\n.... done.\\\\n'\\n #export information\\n hjd, jd, airmass, st = [],[],[],[]\\n for i in range(len(images)):\\n hdr = fits.getheader(images[i])\\n hjd.append(hdr['HJD'])\\n jd.append(hdr['JD'])\\n airmass.append(hdr['airmass'])\\n st.append(hdr['st'])\\n #saving the data\\n data = DataFrame([list(hjd),list(jd),list(st),list(airmass)]).T\\n data.columns = ['HJD','JD','ST','Airmass']\\n data.to_csv('results_iraf_calibrations.csv')\\n #change to workings directory\\n os.chdir(original_path)\\n return\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs\\\"\\n \\\"/lake_analysis_one_21_Jun_2021\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022\\\")\\n ref_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_flowtocell.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_catchments.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_catchments.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_flowtorivermouths.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_flowtorivermouths.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n None,\\n #\\\"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\\\",\\n #additional_matches_list_filename=\\\\\\n #\\\"additional_matches_ice6g_vs_ice5g_lgm.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='HD')\",\n \"def optimize_dcr(dg):\\n # files to consider. fixme: right now only works with one file\\n sto = lh5.Store()\\n lh5_dir = os.path.expandvars(dg.config['lh5_dir'])\\n raw_list = lh5_dir + dg.fileDB['raw_path'] + '/' + dg.fileDB['raw_file']\\n f_raw = raw_list.values[0] \\n \\n tb_raw = 'ORSIS3302DecoderForEnergy/raw/'\\n tb_data = sto.read_object(tb_raw, f_raw)\\n \\n cycle = dg.fileDB['cycle'].values[0]\\n f_results = f'./temp_{cycle}.h5'\\n \\n write_output = True\\n \\n # adjust dsp config \\n with open('opt_dcr.json') as f:\\n dsp_config = json.load(f, object_pairs_hook=OrderedDict)\\n # pprint(dsp_config)\\n # exit()\\n \\n # set dcr parameters\\n # rise, flat, dcr_tstart = 200, 1000, 'tp_0+1.5*us' # default\\n # dcr_rise, dcr_flat, dcr_tstart = 100, 3000, 'tp_0+3*us' # best so far?\\n dcr_rise, dcr_flat, dcr_tstart = 100, 2500, 'tp_0+1*us'\\n dsp_config['processors']['dcr_raw']['args'][1] = dcr_rise\\n dsp_config['processors']['dcr_raw']['args'][2] = dcr_flat\\n dsp_config['processors']['dcr_raw']['args'][3] = dcr_tstart\\n \\n # set trap energy parameters\\n # ene_rise, ene_flat = \\\"2*us\\\", \\\"1*us\\\" # best? from optimize_trap\\n ene_rise, ene_flat = \\\"10*us\\\", \\\"5*us\\\"\\n dsp_config['processors']['wf_trap']['args'][1] = ene_rise\\n dsp_config['processors']['wf_trap']['args'][2] = ene_flat\\n \\n # adjust pole-zero constant\\n dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '64.4*us'\\n # dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '50*us'\\n # dsp_config['processors']['wf_pz']['defaults']['db.pz.tau'] = '100*us'\\n \\n # run dsp\\n print('Running DSP ...')\\n t_start = time.time()\\n pc, tb_out = build_processing_chain(tb_data, dsp_config, verbosity=1)\\n pc.execute()\\n t_elap = (time.time() - t_start)/60\\n print(f'Done. Elapsed: {t_elap:.2f} min')\\n \\n df_out = tb_out.get_dataframe()\\n \\n if write_output:\\n df_out.to_hdf(f_results, key='opt_dcr')\\n print('Wrote output file:', f_results)\",\n \"def vorticity(tsr,solidity):\\n \\n # Reading in csv file (vorticity database)\\n basepath = path.join(path.dirname(path.realpath(__file__)),'data')\\n fdata = basepath + path.sep + 'vortdatabase.csv'\\n f = open(fdata)\\n csv_f = csv.reader(f)\\n \\n i = 0\\n sol_d = np.array([])\\n for row in csv_f:\\n if i == 0:\\n raw = row\\n raw = np.delete(raw,0)\\n vortdat = raw\\n tsr_d = raw # range of tip-speed ratios included\\n if row[0] == 'solidity':\\n sol_d = np.append(sol_d,float(row[1])) # range of solidities included\\n elif row[0] != 'TSR' and row[0] != 'solidity':\\n raw = row\\n raw = np.delete(raw,0)\\n vortdat = np.vstack([vortdat,raw]) # adding entry to vorticity database array\\n i += 1\\n f.close()\\n \\n vortdat = np.delete(vortdat,(0),axis=0) # eliminating first row used as a placeholder\\n tsr_d = tsr_d.astype(np.float) # converting tip-speed ratio entries into floats\\n vortdat = vortdat.astype(np.float) # converting vorticity database entries into floats\\n \\n # Creating arrays for each EMG parameter\\n for i in range(np.size(sol_d)):\\n sol = str(i+1)\\n \\n exec('s'+sol+'_loc1 = vortdat[i*10]\\\\ns'+sol+'_loc2 = vortdat[i*10+1]\\\\ns'+sol+'_loc3 = vortdat[i*10+2]\\\\ns'+sol+'_spr1 = vortdat[i*10+3]\\\\ns'+sol+'_spr2 = vortdat[i*10+4]\\\\ns'+sol+'_skw1 = vortdat[i*10+5]\\\\ns'+sol+'_skw2 = vortdat[i*10+6]\\\\ns'+sol+'_scl1 = vortdat[i*10+7]\\\\ns'+sol+'_scl2 = vortdat[i*10+8]\\\\ns'+sol+'_scl3 = vortdat[i*10+9]\\\\n')\\n \\n # BIVARIATE SPLINE FITTING\\n \\n iz = np.size(sol_d)\\n jz = np.size(tsr_d)\\n \\n # Initializing rectangular matrices\\n Z_loc1 = np.zeros((iz,jz))\\n Z_loc2 = np.zeros((iz,jz))\\n Z_loc3 = np.zeros((iz,jz))\\n Z_spr1 = np.zeros((iz,jz))\\n Z_spr2 = np.zeros((iz,jz))\\n Z_skw1 = np.zeros((iz,jz))\\n Z_skw2 = np.zeros((iz,jz))\\n Z_scl1 = np.zeros((iz,jz))\\n Z_scl2 = np.zeros((iz,jz))\\n Z_scl3 = np.zeros((iz,jz))\\n \\n # Transferring raw data into rectangular matrices\\n for i in range(iz):\\n for j in range(jz):\\n sol = str(i+1)\\n exec('Z_loc1[i,j] = s'+sol+'_loc1[j]')\\n exec('Z_loc2[i,j] = s'+sol+'_loc2[j]')\\n exec('Z_loc3[i,j] = s'+sol+'_loc3[j]')\\n exec('Z_spr1[i,j] = s'+sol+'_spr1[j]')\\n exec('Z_spr2[i,j] = s'+sol+'_spr2[j]')\\n exec('Z_skw1[i,j] = s'+sol+'_skw1[j]')\\n exec('Z_skw2[i,j] = s'+sol+'_skw2[j]')\\n exec('Z_scl1[i,j] = s'+sol+'_scl1[j]')\\n exec('Z_scl2[i,j] = s'+sol+'_scl2[j]')\\n exec('Z_scl3[i,j] = s'+sol+'_scl3[j]')\\n \\n # Creating a rectangular bivariate spline of the parameter data\\n s_loc1 = RectBivariateSpline(sol_d,tsr_d,Z_loc1)\\n s_loc2 = RectBivariateSpline(sol_d,tsr_d,Z_loc2)\\n s_loc3 = RectBivariateSpline(sol_d,tsr_d,Z_loc3)\\n s_spr1 = RectBivariateSpline(sol_d,tsr_d,Z_spr1)\\n s_spr2 = RectBivariateSpline(sol_d,tsr_d,Z_spr2)\\n s_skw1 = RectBivariateSpline(sol_d,tsr_d,Z_skw1)\\n s_skw2 = RectBivariateSpline(sol_d,tsr_d,Z_skw2)\\n s_scl1 = RectBivariateSpline(sol_d,tsr_d,Z_scl1)\\n s_scl2 = RectBivariateSpline(sol_d,tsr_d,Z_scl2)\\n s_scl3 = RectBivariateSpline(sol_d,tsr_d,Z_scl3)\\n \\n # Selecting the specific parameters to use for TSR and solidity\\n loc1 = s_loc1(solidity,tsr)\\n loc2 = s_loc2(solidity,tsr)\\n loc3 = s_loc3(solidity,tsr)\\n spr1 = s_spr1(solidity,tsr)\\n spr2 = s_spr2(solidity,tsr)\\n skw1 = s_skw1(solidity,tsr)\\n skw2 = s_skw2(solidity,tsr)\\n scl1 = s_scl1(solidity,tsr)\\n scl2 = s_scl2(solidity,tsr)\\n scl3 = s_scl3(solidity,tsr)\\n \\n # Creating arrays of the parameters\\n loc = np.array([loc1[0,0],loc2[0,0],loc3[0,0]])\\n spr = np.array([spr1[0,0],spr2[0,0]])\\n skw = np.array([skw1[0,0],skw2[0,0]])\\n scl = np.array([scl1[0,0],scl2[0,0],scl3[0,0]])\\n \\n return loc,spr,skw,scl\",\n \"def main() -> int:\\n ucvm_out = \\\"\\\"\\n for j in frange(CORNERS[\\\"bl\\\"][\\\"n\\\"], CORNERS[\\\"ur\\\"][\\\"n\\\"], SPACING):\\n for i in frange(CORNERS[\\\"bl\\\"][\\\"e\\\"], CORNERS[\\\"ur\\\"][\\\"e\\\"] + SPACING, SPACING):\\n ucvm_out += \\\"%.2f %.2f 0\\\\n\\\" % (i, j)\\n os.chdir(\\\"/Users/davidgil/ucvm-15.10.0/bin\\\")\\n proc = Popen(\\n [\\\"./ucvm_query\\\", \\\"-f\\\", \\\"../conf/ucvm.conf\\\"], stdout=PIPE, stdin=PIPE, stderr=STDOUT\\n )\\n out_arr = np.zeros(\\n shape=(\\n int((CORNERS[\\\"ur\\\"][\\\"n\\\"] - CORNERS[\\\"bl\\\"][\\\"n\\\"]) / SPACING) + 2,\\n int((CORNERS[\\\"ur\\\"][\\\"e\\\"] - CORNERS[\\\"bl\\\"][\\\"e\\\"]) / SPACING) + 2\\n )\\n )\\n output = proc.communicate(input=ucvm_out.encode(\\\"ASCII\\\"))[0]\\n i = 0\\n j = 0\\n for line in output.decode(\\\"ASCII\\\").split(\\\"\\\\n\\\")[2:-1]:\\n line_split = line.split()\\n try:\\n out_arr[j][i] = float(line_split[4])\\n except IndexError:\\n print(line_split)\\n if i == int((CORNERS[\\\"ur\\\"][\\\"e\\\"] - CORNERS[\\\"bl\\\"][\\\"e\\\"]) / SPACING):\\n i = 0\\n j += 1\\n else:\\n i += 1\\n np.save(\\\"vs30.dat\\\", out_arr)\\n return 0\",\n \"def run(config, tim=None):\\n import common_lib\\n import dr_lib\\n import DST\\n \\n if tim is not None:\\n tim.getTime(False)\\n old_time = tim.getOldTime()\\n\\n if config.data is None:\\n raise RuntimeError(\\\"Need to pass a data filename to the driver \\\"\\\\\\n +\\\"script.\\\")\\n\\n # Read in geometry if one is provided\\n if config.inst_geom is not None:\\n if config.verbose:\\n print \\\"Reading in instrument geometry file\\\"\\n \\n inst_geom_dst = DST.getInstance(\\\"application/x-NxsGeom\\\",\\n config.inst_geom)\\n else:\\n inst_geom_dst = None\\n\\n config.so_axis = \\\"time_of_flight\\\"\\n\\n # Steps 1-3: Produce a scaled summed dark current dataset\\n dc_som = dr_lib.scaled_summed_data(config.dkcur, config,\\n dataset_type=\\\"dark_current\\\",\\n timer=tim)\\n\\n # Perform Steps 3-6 on black can data\\n if config.bcan is not None:\\n b_som1 = dr_lib.calibrate_dgs_data(config.bcan, config, dc_som,\\n dataset_type=\\\"black_can\\\",\\n inst_geom_dst=inst_geom_dst,\\n tib_const=config.tib_const,\\n cwp=config.cwp_bcan,\\n timer=tim)\\n else:\\n b_som1 = None\\n\\n # Perform Steps 3-6 on empty can data \\n if config.ecan is not None:\\n e_som1 = dr_lib.calibrate_dgs_data(config.ecan, config, dc_som,\\n dataset_type=\\\"empty_can\\\",\\n inst_geom_dst=inst_geom_dst,\\n tib_const=config.tib_const,\\n cwp=config.cwp_ecan,\\n timer=tim)\\n else:\\n e_som1 = None\\n\\n # Perform Steps 3-6 on normalization data\\n n_som1 = dr_lib.calibrate_dgs_data(config.data, config, dc_som,\\n dataset_type=\\\"normalization\\\",\\n inst_geom_dst=inst_geom_dst,\\n tib_const=config.tib_const,\\n cwp=config.cwp_data,\\n timer=tim)\\n\\n # Perform Steps 7-16 on normalization data\\n if config.norm_trans_coeff is None:\\n norm_trans_coeff = None\\n else:\\n norm_trans_coeff = config.norm_trans_coeff.toValErrTuple()\\n\\n # Determine if we need to rebin the empty or black can data\\n if config.ecan is not None and e_som1 is not None:\\n ecan_cwp = True\\n else:\\n ecan_cwp = False\\n\\n if config.bcan is not None and b_som1 is not None:\\n bcan_cwp = True\\n else:\\n bcan_cwp = False \\n\\n cwp_used = ecan_cwp or bcan_cwp\\n\\n n_som2 = dr_lib.process_dgs_data(n_som1, config, b_som1, e_som1,\\n norm_trans_coeff,\\n dataset_type=\\\"normalization\\\",\\n cwp_used=cwp_used,\\n timer=tim)\\n \\n del n_som1, b_som1, e_som1\\n\\n # Step 17: Integrate normalization spectra\\n if config.verbose:\\n print \\\"Integrating normalization spectra\\\"\\n\\n if tim is not None:\\n tim.getTime(False)\\n\\n if config.norm_int_range is None:\\n start_val = float(\\\"inf\\\")\\n end_val = float(\\\"inf\\\")\\n else:\\n if not config.wb_norm:\\n # Translate energy transfer to final energy\\n ef_start = config.initial_energy.getValue() - \\\\\\n config.norm_int_range[0]\\n ef_end = config.initial_energy.getValue() - \\\\\\n config.norm_int_range[1]\\n # Convert final energy to final wavelength\\n start_val = common_lib.energy_to_wavelength((ef_start, 0.0))[0]\\n end_val = common_lib.energy_to_wavelength((ef_end, 0.0))[0]\\n else:\\n start_val = config.norm_int_range[0]\\n end_val = config.norm_int_range[1]\\n \\n n_som3 = dr_lib.integrate_spectra(n_som2, start=start_val,\\n end=end_val, width=True)\\n\\n del n_som2\\n \\n if tim is not None:\\n tim.getTime(msg=\\\"After integrating normalization spectra \\\")\\n\\n file_comment = \\\"Normalization Integration range: %0.3fA, %0.3fA\\\" \\\\\\n % (start_val, end_val)\\n \\n hlr_utils.write_file(config.output, \\\"text/num-info\\\", n_som3,\\n output_ext=\\\"norm\\\",\\n data_ext=config.ext_replacement,\\n path_replacement=config.path_replacement,\\n verbose=config.verbose,\\n message=\\\"normalization values\\\",\\n comments=[file_comment],\\n tag=\\\"Integral\\\", units=\\\"counts\\\") \\n \\n if tim is not None:\\n tim.getTime(False)\\n\\n if config.verbose:\\n print \\\"Making mask file\\\"\\n\\n # Make mask file from threshold\\n dr_lib.filter_normalization(n_som3, config.lo_threshold,\\n config.hi_threshold, config)\\n\\n if tim is not None:\\n tim.getTime(msg=\\\"After making mask file \\\")\\n\\n # Write out RMD file\\n n_som3.attr_list[\\\"config\\\"] = config\\n\\n hlr_utils.write_file(config.output, \\\"text/rmd\\\", n_som3,\\n output_ext=\\\"rmd\\\",\\n data_ext=config.ext_replacement, \\n path_replacement=config.path_replacement,\\n verbose=config.verbose,\\n message=\\\"metadata\\\")\\n \\n if tim is not None:\\n tim.setOldTime(old_time)\\n tim.getTime(msg=\\\"Total Running Time\\\")\",\n \"def test_fill_data(self):\\n self.full_iv.get_data()\\n df_iv = self.full_iv.calc_iv()\\n\\n self.assertTrue(len(df_iv))\\n\\n db = pd.HDFStore('test.h5')\\n db['iv'] = df_iv\\n db.close()\",\n \"def test_compute_Sv_ek80_CW_power_BB_complex(ek80_path):\\n ek80_raw_path = ek80_path / \\\"Summer2018--D20180905-T033113.raw\\\"\\n ed = ep.open_raw(ek80_raw_path, sonar_model=\\\"EK80\\\")\\n ds_Sv = ep.calibrate.compute_Sv(\\n ed, waveform_mode=\\\"CW\\\", encode_mode=\\\"power\\\"\\n )\\n assert isinstance(ds_Sv, xr.Dataset)\\n ds_Sv = ep.calibrate.compute_Sv(\\n ed, waveform_mode=\\\"BB\\\", encode_mode=\\\"complex\\\"\\n )\\n assert isinstance(ds_Sv, xr.Dataset)\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_one_21_Jun_2021/rivers/results/\\\"\\n \\\"default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022/\\\"\\n \\\"rivers/results/diag_version_32_date_0_with_truesinks\\\")\\n ref_filename=os.path.join(ref_base_dir,\\\"10min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\\"10min_flowtocell.nc\\\")\\n #lsmask_filename=os.path.join(self.plots_data_dir,\\n # \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n lsmask_filename=None\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"10min_catchments_ext.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"10min_catchments_ext.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"10min_rdirs.nc\\\")\\n data_rdirs_filename=os.path.join(data_base_dir,\\n \\\"10min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"10min_rmouth_flowtocell.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"10min_rmouth_flowtocell.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=20*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=20*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=5*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=5*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=2*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\",\n \"def test_calc_SR5():\\n tb = TradeBot(\\n pair='GBP_JPY',\\n timeframe='D',\\n start='2018-12-20 22:00:00',\\n end='2019-01-17 22:00:00',\\n settingf=\\\"../../data/settings.ini\\\"\\n )\\n\\n harealst = tb.calc_SR(datetime.datetime(2019, 1, 7, 22, 0))\\n\\n assert len(harealst.halist) == 6\\n assert 0\",\n \"def read_inversion_info(file_dic):\\n #print_file_test = open('file_test.txt','w')\\n\\n if not ( check_inversion_files(file_dic) ):\\n print 'error(read_inversion_info): problem with lenstool file names'\\n return 0\\n \\n file_generate_arcs = file_dic['file_generate_arcs']\\n info_input_lens = fc.extract_second_identifiers( file_generate_arcs, \\\\\\n 'potential' )\\n#-------------------------------------------------------------------------------\\n\\n file_source = file_dic['file_source']\\n info_src = np.loadtxt(file_source, unpack=False)\\n if len(info_src) == 8 and np.isscalar(info_src[0]):\\n #FIXME - check if the second condition is all we need\\n info_src = [info_src]\\n#-------------------------------------------------------------------------------\\n\\n file_make_inversion = file_dic['file_make_inversion']\\n info_fited_param = fc.extract_second_identifiers( file_make_inversion, \\\\\\n 'limit' )\\n info_forme = fc.extract_parameter(file_make_inversion, 'forme')[0][0]\\n\\n#-------------------------------------------------------------------------------\\n\\n file_best_fit = file_dic['file_best_fit']\\n info_best_fit = fc.extract_second_identifiers( file_best_fit, \\\\\\n 'potentiel' )\\n\\n info_xi2 = fc.extract_parameter(file_best_fit, '#Chi2pos:')\\n\\n#-------------------------------------------------------------------------------\\n file_chires = file_dic['file_chires']\\n\\n info_chires = extract_parameter(file_chires, '0')\\n rmss_mean = [0.0, 0.0]\\n rmsi_mean = [0.0, 0.0]\\n for i in info_chires:\\n if i[0] != 'A':\\n rmss_mean[0] = rmss_mean[0] + float(i[7])\\n rmss_mean[1] = rmss_mean[1] + 1.0\\n \\n rmsi_mean[0] = rmsi_mean[0] + float(i[8])\\n rmsi_mean[1] = rmsi_mean[1] + 1.0\\n\\n rmss_mean = rmss_mean[0]/rmss_mean[1]\\n rmsi_mean = rmsi_mean[0]/rmsi_mean[1]\\n#-------------------------------------------------------------------------------\\n out_dict = { 'xi2' : float(info_xi2[0][0]), \\\\\\n 'best_fit_lens' : info_best_fit, \\\\\\n 'rmsi_mean' : rmsi_mean, \\\\\\n 'rmss_mean' : rmss_mean, \\\\\\n 'fited_parameters' : info_fited_param[0].keys(), \\\\\\n 'input_lens' : info_input_lens[len(info_input_lens) - 1], \\\\\\n 'forme' : info_forme \\\\\\n }\\n #for i in out_dict.keys():\\n # print i, out_dict[i]\\n return out_dict\",\n \"def test_data_handling_nc_cc():\\n\\n input_files = [os.path.join(TEST_DATA_DIR, 'ua_test.nc'),\\n os.path.join(TEST_DATA_DIR, 'va_test.nc'),\\n os.path.join(TEST_DATA_DIR, 'orog_test.nc'),\\n os.path.join(TEST_DATA_DIR, 'zg_test.nc')]\\n\\n with xr.open_mfdataset(input_files) as fh:\\n min_lat = np.min(fh.lat.values)\\n min_lon = np.min(fh.lon.values)\\n target = (min_lat, min_lon)\\n plevel = fh.plev[-1]\\n ua = np.transpose(fh['ua'][:, -1, ...].values, (1, 2, 0))\\n va = np.transpose(fh['va'][:, -1, ...].values, (1, 2, 0))\\n\\n handler = DataHandlerNCforCC(input_files, features=['U_100m', 'V_100m'],\\n target=target, shape=(20, 20),\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n\\n assert handler.data.shape == (20, 20, 20, 2)\\n\\n handler = DataHandlerNCforCC(input_files,\\n features=[f'U_{int(plevel)}pa',\\n f'V_{int(plevel)}pa'],\\n target=target, shape=(20, 20),\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n if handler.invert_lat:\\n handler.data = handler.data[::-1]\\n assert handler.data.shape == (20, 20, 20, 2)\\n assert np.allclose(ua, handler.data[..., 0])\\n assert np.allclose(va, handler.data[..., 1])\",\n \"def test_cambridge_rent_price_per_sqft():\\n dataframe = get_final_zillow_dataframe()\\n cambridge = get_city_state_row(dataframe, 'cambridge', 'massachusetts')\\n assert round(cambridge.iloc[0].get('ZRIFAH'), 1) == 2.9\",\n \"def test_3d_steam_time():\\n dic,data = ng.pipe.read(\\\"common_data/3d_pipe/full3D.fid\\\")\\n assert data.shape == (128, 88, 1250)\\n assert data.dtype == 'complex64'\\n assert round(data[0,1,2].real,2) == -7.98\\n assert round(data[0,1,2].imag,2) == 33.82\\n assert round(data[10,22,5].real,2) == 15.71\\n assert round(data[10,22,5].imag,2) == 15.1\\n write_readback(dic,data)\",\n \"def test_CCI_SM_v033_025Ds_img_reading():\\n parameter = ['sm']\\n data_path = os.path.join(os.path.dirname(__file__), \\\"esa_cci_sm-test-data\\\",\\n \\\"esa_cci_sm_dailyImages\\\", \\\"v03.3\\\", \\\"combined\\\")\\n img_c = CCI_SM_025Ds(data_path=data_path, parameter=parameter,\\n subgrid=None, array_1D=False)\\n\\n image_c = img_c.read(datetime(2016, 1, 1, 0))\\n\\n assert sorted(image_c.data.keys()) == sorted(parameter)\\n assert image_c.timestamp == datetime(2016, 1, 1, 0)\\n nptest.assert_almost_equal(image_c.data['sm'][273, 693], 0.142998, 5)\\n assert image_c.lon.shape == image_c.lat.shape == (720, 1440)\\n\\n\\n data_path = os.path.join(os.path.dirname(__file__), \\\"esa_cci_sm-test-data\\\",\\n \\\"esa_cci_sm_dailyImages\\\", \\\"v03.3\\\", \\\"active\\\")\\n img_a = CCI_SM_025Ds(data_path=data_path, parameter=parameter, subgrid=None,\\n array_1D=False)\\n image_a = img_a.read(datetime(2016, 1, 1, 0))\\n\\n assert sorted(image_a.data.keys()) == sorted(parameter)\\n assert image_a.timestamp == datetime(2016, 1, 1, 0)\\n nptest.assert_almost_equal(image_a.data['sm'][273, 693], 18.92771, 5)\\n assert image_a.lon.shape == image_a.lat.shape == (720, 1440)\\n\\n\\n data_path = os.path.join(os.path.dirname(__file__), \\\"esa_cci_sm-test-data\\\",\\n \\\"esa_cci_sm_dailyImages\\\", \\\"v03.3\\\", \\\"passive\\\")\\n img_p = CCI_SM_025Ds(data_path=data_path, parameter=parameter, subgrid=None,\\n array_1D=False)\\n\\n image_p = img_p.read(datetime(2016, 1, 1, 0))\\n\\n assert sorted(image_p.data.keys()) == sorted(parameter)\\n assert image_p.timestamp == datetime(2016, 1, 1, 0)\\n nptest.assert_almost_equal(image_p.data['sm'][273, 693], 0.0700, 5)\\n\\n assert image_p.lon.shape == image_p.lat.shape == (720, 1440)\",\n \"def compute_contrast_sphere_offline(path_raw,path_reduced,path_output,debug=True):\\r\\n try:\\r\\n if not type(path_raw) is PosixPath:\\r\\n path_raw = Path(path_raw)\\r\\n if type(path_reduced) is PosixPath:\\r\\n path_reduced = Path(path_reduced)\\r\\n if not type(path_raw) is PosixPath:\\r\\n path_output = Path(path_output) \\r\\n for path in [path_raw,path_reduced]:\\r\\n if not path.exists():\\r\\n print('The input path {0:s} does not exists. Returning'.format(str(path)))\\r\\n return\\r\\n if not path_output.exists():\\r\\n path_output.mkdir()\\r\\n except:\\r\\n print(sys.exc_info()[0])\\r\\n \\r\\n \\r\\n #%% Step 0 : \\r\\n # Load all raw frames and list the original filename, along with the type \\r\\n # and archive names\\r\\n\\r\\n raw_files = []\\r\\n raw_archive_names = []\\r\\n raw_dpr_types = []\\r\\n \\r\\n files_sphere_raw = sorted(path_raw.glob('SPHERE*IRDIS*OBS*fits'))\\r\\n for file in files_sphere_raw:\\r\\n try:\\r\\n h=fits.getheader(file)\\r\\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR'] and 'IRDIS' in h['HIERARCH ESO SEQ ARM']: \\r\\n raw_files.append(files_sphere_raw)\\r\\n raw_archive_names.append(h['ARCFILE'])\\r\\n raw_dpr_types.append(h['HIERACH ESO DPR TYPE'])\\r\\n except:\\r\\n continue\\r\\n \\r\\n\\r\\n #%% Step 1 : \\r\\n \\r\\n # You look for all reduced frames that correspond to \\r\\n # coronagraphic data with PRO.CATG as \\r\\n # - IRD_SCIENCE_DBI_LEFT_CUBE \\r\\n # - IRD_SCIENCE_DBI_RIGHT_CUBE\\r\\n # - IRD_STAR_CENTER\\r\\n \\r\\n files_sphere_reduced = sorted(path_reduced.glob('r.SPHER*.fits'))\\r\\n reduced_files_dbi_left = [] \\r\\n raw_files_dbi_left = [] # careful !! This is not the raw file name as saved in raw/date/\\r\\n \\r\\n reduced_files_dbi_right = []\\r\\n raw_files_dbi_right = []\\r\\n \\r\\n for file in files_sphere_reduced:\\r\\n try:\\r\\n h=fits.getheader(file)\\r\\n # check whether this is a coronagraphic frame\\r\\n if 'ALC' in h['HIERARCH ESO INS COMB ICOR']:\\r\\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_LEFT_CUBE':\\r\\n reduced_files_dbi_left.append(file)\\r\\n raw_files_dbi_left.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\\r\\n if h['HIERARCH ESO PRO CATG'] == 'IRD_SCIENCE_DBI_RIGHT_CUBE':\\r\\n reduced_files_dbi_right.append(file)\\r\\n raw_files_dbi_right.append(h['HIERARCH ESO PRO REC1 RAW1 NAME'])\\r\\n except:\\r\\n continue\\r\\n\\r\\n \\r\\n \\r\\n #%% Step 2: \\r\\n # You isolate for each raw frames one single reduced left and right cube \\r\\n # (currently the pipeline does multiple reductions of the same raw cube for \\r\\n # an unknown reason, we need to get rid of the duplicates here).\\r\\n \\r\\n unique_reduced_files_dbi_left,indices = np.unique(reduced_files_dbi_left,return_index=True)\\r\\n unique_raw_files_dbi_left = [raw_files_dbi_left[i] for i in indices]\\r\\n \\r\\n unique_reduced_files_dbi_right,indices = np.unique(reduced_files_dbi_right,return_index=True)\\r\\n unique_raw_files_dbi_right = [raw_files_dbi_right[i] for i in indices]\\r\\n \\r\\n \\r\\n #%% Step 3\\r\\n # You extract DIT, NDIT, NAXIS3, coronagraph name:\\r\\n # Lyot stop: HIERARCH ESO INS1 OPTI1 NAME\\r\\n # Lyot mask: HIERARCH ESO INS4 OPTI11 NAME\\r\\n # coro combination name: HIERARCH ESO INS COMB ICOR\\r\\n # along with the ND filter and the IRDIS filter from each RAW frame.\\r\\n # Also extract all info that will be useful later for the analysis:\\r\\n # star name and magnitude, airmass, seeing, coherence time, telescope Seeing...)\\r\\n # This is important to do that on each raw frame on not on each reduced frame\\r\\n # as the keywords are changed by the pipeline and unreliable.\\r\\n \\r\\n \\r\\n \\r\\n #%% Step 4\\r\\n # Assoiate each FLUX with a CORONAGRAPHIC image\\r\\n \\r\\n \\r\\n \\r\\n #%% Step 5\\r\\n # Work on the Flux frame first:\\r\\n # - Detect the central star\\r\\n # - measure the FWHM, validate that this is the star by checking the FWHM\\r\\n # (should be the diffraction limit)\\r\\n # - aperture photometry on the star using a diameter of 1 lambda/D \\r\\n # - divide the flux by the DIT and correct by the ND transmission: this\\r\\n # gives you the star reference flux\\r\\n \\r\\n \\r\\n #%% Step 6\\r\\n # Work on the coronographic frame now:\\r\\n # - Detect the coronagraphic center.\\r\\n # - compute the contrast (using the standard deviation of many apertures \\r\\n # place at a given separation, using for instance the python module VIP)\\r\\n\\r\\n\\r\\n #%% Step 7:\\r\\n # Divide the azinuthal standard deviations by the star reference flux to obtain\\r\\n # the contrast as a function of radius. \\r\\n # Plot the result and save in a csv file along with all relevant parameters \\r\\n # for the analysis (coronagraph name, star magnitude, airmass, seeing, coherence time)\\r\",\n \"def initialize_data(self , station = '', datasets = {} ): \\n self.datasets = datasets\\n self.datasets_keys = datasets.keys()\\n self.station = station\\n self.out_name = self.out_dir + '/' + self.station + '_CEUAS_premerged_v0.nc'\\n\\n self.observations_table_vars = ['date_time', 'z_coordinate' , 'z_coordinate_type', 'observed_variable' , 'observation_value' , 'report_id' , 'observation_id' , 'latitude' , 'longitude', 'units', 'source_id']\\n\\n \\\"\\\"\\\" Loading the econding of the tables created from the harvester script and to be applied again \\\"\\\"\\\"\\n self.encodings = np.load('groups_encodings.npy' , allow_pickle = True ).item()\\n self.encodings['era5fb'] = np.load('era5fb_encodings_all.npy' , allow_pickle = True ).item() \\n self.dic_type_attributes = np.load('dic_type_attributes.npy',allow_pickle= True).item()\\n \\n self.era5fb_columns = self.dic_type_attributes['era5fb'].keys()\\n\\n self.obstab_nans_filled = False \\n\\n data['cdm_tables'] = {} \\n \\n \\\"\\\"\\\" Loop over all the datasets \\n k: name of the dataset \\n v: list of file paths, eg 'era5_1':[filepath_1, filepath_2 ] \\\"\\\"\\\" \\n for k,v in self.datasets.items() :\\n data[k] = {}\\n for F in v:\\n \\n logging.info(' Dataset ::: *** %s %s ' , k , F ) \\n \\n data[k][F] = {}\\n\\n h5py_file = h5py.File(F, 'r')\\n data[k][F]['h5py_file'] = h5py_file \\n \\n a = h5py_file['recordtimestamp']\\n \\n data[k][F]['recordtimestamp'] = a\\n data[k][F]['recordindex'] = h5py_file['recordindex']\\n data[k][F]['dateindex'] = h5py_file['dateindex']\\n a = h5py_file['recordtimestamp']\\n data[k][F]['max_date'] = max(a)\\n data[k][F]['min_date'] = min(a)\\n \\n data[k][F]['counter'] = 0\\n\\n #######\\n # HEADER TABLE\\n #######\\n head_tab = h5py_file['header_table']\\n logging.info('*** header_table')\\n data[k][F]['header_table'] = {}\\n for var in head_tab.keys():\\n if ('string' in var or 'hdrlen' in var): continue\\n try: \\n data[k][F]['header_table'][var] = (np.array(head_tab[var][:])).astype(self.dic_type_attributes['header_table'][var]['type'] )\\n except:\\n print('failed convertion type header' , k , ' ' , F , ' ' , var )\\n \\n ####### \\n # STATION CONFIGURATION\\n ####### \\n d = xr.open_dataset(F , engine = 'h5netcdf' , group = 'station_configuration' , decode_times = False )\\n data[k][F]['station_configuration'] = d.to_dataframe()\\n logging.debug('Done with %s station_configuration' , str(k) )\\n d.close()\\n\\n ####### \\n # SOURCE CONFIGURATION \\n ####### \\n d = xr.open_dataset(F , engine = 'h5netcdf' , group = 'source_configuration' , decode_times = False )\\n data[k][F]['source_configuration'] = d\\n logging.debug('Done with %s source_configuration' , str(k) )\\n d.close()\\n\\n\\n data['cdm_tables'] = {}\\n \\\"\\\"\\\" Reading the CDM tables that do not depend on specific stations or observations (fixed values), for the first file only \\\"\\\"\\\"\\n for t in self.standard_cdm: # [ 'crs' , 'observed_variable', 'units' , 'z_coordinate_type' , 'station_type', 'station_configuration_codes'] \\n if t not in data['cdm_tables'].keys():\\n #data['cdm_tables'][t] = ''\\n cdm = xr.open_dataset(F , engine = 'h5netcdf' , group = t )\\n data['cdm_tables'][t] = cdm \\n\\n print(blue + 'Memory used after reading data: ', process.memory_info().rss/1000000000 , cend)\\n\\n self.data = data\\n\\n \\\"\\\"\\\" Making all date_times \\\"\\\"\\\"\\n self.make_all_datetime()\",\n \"def Read_Spectrum(Path,borne1 = 0,borne2 = 0) :\\n x,y=[],[]\\n fs = open(Path, 'r')\\n #print('Open new fic') \\n#index_array = 0\\n while 1: \\n txt = fs.readline()\\n #print(txt)\\n if ((txt =='')|(txt == '\\\\r\\\\n')): \\n break\\n #print(txt)\\n ii=-1\\n while 1: # on cherche le premier espace qui limite le premier nombre\\n ii = ii+1\\n #print(ii)\\n if ((txt[ii] == ' ') |(txt[ii] == '\\\\t')):\\n break\\n \\n x.append(float(txt[0:ii]))\\n y.append(float(txt[ii:])) \\n# if len(txt) == 21 : #nu >= 10000 cm-1\\n# x.append(float(txt[0:11]))\\n# y.append(float(txt[11:]))\\n# elif len(txt) == 20 : #nu >= 1000 cm-1\\n# x.append(float(txt[0:10]))\\n# y.append(float(txt[10:]))\\n# elif len(txt) == 19 : #nu >= 100 cm-1\\n# x.append(float(txt[0:9]))\\n# y.append(float(txt[9:]))\\n# elif len(txt) == 18 : #nu >= 10 cm-1\\n# x.append(float(txt[0:8]))\\n# y.append(float(txt[8:]))\\n# elif len(txt) == 17 : #nu >= 1 cm-1\\n# x.append(float(txt[0:7]))\\n# y.append(float(txt[7:]))\\n\\n #x[index_array],y[index_array] = float(txt[0:9]),float(txt[10:17])\\n #index_array = index_array+1\\n \\n fs.close()\\n x = np.array(x)\\n y = np.array(y)\\n if ((borne1 == 0) & (borne2 == 0)) :\\n pass \\n else :\\n index_ok = ((x<borne2) & (x>borne1))\\n x = x[index_ok]\\n y = y[index_ok]\\n\\n return x,y\",\n \"def analyzeViSDEMData(dict):\\n \\n if 'path_in' in dict:\\n path_in = dict['path_in']\\n else:\\n print(\\\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\\\") \\n return\\n \\n path_out_default = '../colordeficiency-data/' \\n if 'path_out' in dict:\\n path_out = dict['path_out']\\n else:\\n print(\\\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \\\"+str(path_out_default))\\n path_out = path_out_default\\n \\n if 'round' in dict:\\n round = dict['round']\\n else:\\n print(\\\"Error: You have to chose a round first.\\\")\\n \\n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\\n \\n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\\n if round == 1:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids.csv\\\")\\n elif round == 2:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids_2.csv\\\")\\n \\n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\\\";\\\")\\n \\n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\\n observer_ids = os.path.join(path,\\\"observer_ids.csv\\\")\\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\\\";\\\")\\n \\n # 1. Step: Read all the XLSX data in the path\\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\\n dataArray = pandas.DataFrame()\\n i=1\\n for xlsx_file in xlsx_files:\\n sys.stdout.write(xlsx_file)\\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\\n \\n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\\n \\n if \\\"2. Session\\\" in extraDataDict:\\n sessionID = int(extraDataDict['2. Session'])\\n newDataArray['session_id'] = sessionID\\n \\n if 'group' in extraDataDict:\\n obsGroup = str(extraDataDict['group'])\\n newDataArray['obsGroup'] = obsGroup\\n \\n if '0. Participant ID' in extraDataDict:\\n obsID = int(extraDataDict['0. Participant ID'])\\n \\n newDataArray['observer_id'] = obsID\\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\\n \\n dataArray = pandas.concat([dataArray, newDataArray])\\n sys.stdout.write(' . ')\\n if (i%5)==0: sys.stdout.write('\\\\n')\\n i+=1\\n sys.stdout.write('\\\\n')\\n \\n # 2. Step: Adapt values to programstandards\\n for item in settings.colDefLong2ID:\\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\\n \\n for item in settings.dalt2ID:\\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\\n \\n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\\n \\n \\n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\\n 'coldef_type': 'coldef_type',\\n 'resp.corr_raw': 'is_correct',\\n 'resp.rt_raw': 'resp_time',\\n 'stimFile': 'filepath'})\\n dataArray = dataArray.reset_index()\\n \\n # Adding set_id, motive_id and variant_id to each file\\n for index, row in dataArray.iterrows():\\n path_tmp = row['filepath']\\n filename = os.path.basename(path_tmp).split('.')[0]\\n dict_tmp = getStatsFromFilename(filename)\\n imgID_tmp = int(dict_tmp['img_id'])\\n \\n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\\n \\n dataArray.at[index,'image_id'] = imgID_tmp\\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\\n\\n dataArray.image_id = dataArray.image_id.astype(int)\\n dataArray.set_id = dataArray.set_id.astype(int)\\n dataArray.motive_id = dataArray.motive_id.astype(int)\\n dataArray.variant_id = dataArray.variant_id.astype(int)\\n dataArray.is_correct = dataArray.is_correct.astype(bool)\\n \\n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\\n \\n # 3. Saving data to file\\n try:\\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\\\";\\\")\\n sys.stdout.write(\\\"Success: ViSDEM data successfully saved in '\\\"+str(path_out)+\\\"'.\\\\n\\\")\\n except Exception as e:\\n print(e)\",\n \"def execute(self, in_nc, in_weight_table, out_nc, grid_name, conversion_flag, in_time_interval=\\\"6hr\\\"): # modified this line CJB 20190218\\r\\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\\r\\n # and upstream correction of the cdo grid conversion units attribute.\\r\\n\\r\\n # Validate the netcdf dataset\\r\\n vars_oi_index = self.dataValidation(in_nc)\\r\\n \\r\\n \\\"\\\"\\\"get conversion factor the flag is used to differentiate forecasts converted \\r\\n to netCDF from GRIB and the original netCDF. They both use the same weight tables\\r\\n but the original netCDF is in mm whereas the stock GRIB forecasts are in meters.\\r\\n Set the conversion_flag in the run.py configuration file.\\r\\n \\\"\\\"\\\"\\r\\n if conversion_flag: # Line Added CJB 20190218\\r\\n conversion_factor = 1.0 #Line Modified CJB 20190218\\r\\n elif grid_name == 'ecmwf_t1279' or grid_name == 'ecmwf_tco639': # Line Modified CJB 20190218\\r\\n #if grid_name == 'ecmwf_HRES_F' or grid_name == 'ecmwf_ENS_F': # Line Added/Modified CJB 20190108\\r\\n #new grids in mm instead of m\\r\\n conversion_factor = 0.001\\r\\n else: #set the conversion factor to 1 for everything else (data is in m but legacy installations do not have a flag) Line Added CJB 20190218\\r\\n conversion_factor = 1.0 # Line Added CJB 20190218\\r\\n # MJS I might consider netCDF4.Dataset.variables['RO'].units\\r\\n # and upstream correction of the cdo grid conversion units attribute.\\r\\n # identify if the input netcdf data is the High Resolution data with three different time intervals\\r\\n id_data = self.dataIdentify(in_nc)\\r\\n if id_data is None:\\r\\n raise Exception(self.errorMessages[3])\\r\\n\\r\\n ''' Read the netcdf dataset'''\\r\\n data_in_nc = NET.Dataset(in_nc)\\r\\n time = data_in_nc.variables['time'][:]\\r\\n\\r\\n # Check the size of time variable in the netcdf data\\r\\n if len(time) == 0: # *** MJS This change seems like it is too loose an error trap; should it account for instances when nc file time var is != in length with id_data lenght?\\r\\n raise Exception(self.errorMessages[3])\\r\\n #if len(time) != self.length_time[id_data]:\\r\\n # raise Exception(self.errorMessages[3])\\r\\n\\r\\n ''' Read the weight table '''\\r\\n print(\\\"Reading the weight table...\\\", in_weight_table)\\r\\n dict_list = {self.header_wt[0]:[], self.header_wt[1]:[], self.header_wt[2]:[],\\r\\n self.header_wt[3]:[], self.header_wt[4]:[]}\\r\\n\\r\\n with open(in_weight_table, \\\"r\\\") as csvfile:\\r\\n reader = csv.reader(csvfile)\\r\\n count = 0\\r\\n for row in reader:\\r\\n if count == 0:\\r\\n #check number of columns in the weight table\\r\\n if len(row) < len(self.header_wt):\\r\\n raise Exception(self.errorMessages[4])\\r\\n #check header\\r\\n if row[1:len(self.header_wt)] != self.header_wt[1:]:\\r\\n raise Exception(self.errorMessages[5])\\r\\n count += 1\\r\\n else:\\r\\n for i in range(len(self.header_wt)):\\r\\n dict_list[self.header_wt[i]].append(row[i])\\r\\n count += 1\\r\\n\\r\\n ''' Calculate water inflows\\r\\n as a reminder, the first 91 time steps are T=0 to T=90 and are 1-hourly for HRES\\r\\n\\t\\t the next 18 time steps for HRES are T=93 to T=144 at 3-hourly\\r\\n then the final 16 time steps are T=150 to T=240 at 6-hourly for a total of 125 records\\r\\n\\t\\t\\tFor ENS, the first 49 time steps are T=0 to T=144 at 3-hourly\\r\\n\\t\\t\\tthe final 35 time steps are T=150 to T=360 at 6-hourly for a total of 84 records\\r\\n '''\\r\\n\\t\\t\\t\\r\\n print(\\\"Calculating water inflows...\\\")\\r\\n\\t\\t\\r\\n ''' \\r\\n added the next section CJB 20180122 \\r\\n '''\\r\\n\\r\\n\\t\\t# Get the overall number of time steps\\r\\n size_time = self.getTimeSize(in_nc) #CJB 20180122\\r\\n # Determine the size of time steps in each group (1-hourly, 3-hourly, and/or 6-hourly)\\r\\n if id_data == \\\"HRES1\\\": # T <= 90 \\r\\n time_size = (size_time - 1)\\r\\n elif id_data == \\\"HRES13\\\": # 93 <= T <= 144\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"HighRes-1hr\\\"] - 1)\\r\\n elif id_data == \\\"HRES136\\\": # 150 <= T <= 240\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n elif in_time_interval == \\\"3hr\\\": # MJS Doesn't seem to be a case used currently, but added just in case later need.\\r\\n time_size = self.length_time_opt[\\\"HighRes-3hr-sub\\\"] # MJS This is HRES136, i.e., if for some reason in ecmwf_rapid_multi a 3 hr is asked for for this case, it should still have the 3hr_sub number of times\\r\\n elif in_time_interval == \\\"3hr_subset\\\":\\r\\n time_size = self.length_time_opt[\\\"HighRes-3hr-Sub\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"HighRes-1hr\\\"] - self.length_time_opt[\\\"HighRes-3hr-Sub\\\"] - 1)\\r\\n elif id_data == \\\"ENS3\\\": # T <= 144\\r\\n time_size = (size_time - 1)\\r\\n elif id_data == \\\"ENS36\\\": # 150 <= T <= 360\\r\\n if in_time_interval == \\\"3hr_subset\\\":\\r\\n time_size = self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"]\\r\\n else:\\r\\n time_size = (size_time - self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"] - 1)\\r\\n else: # id_data == \\\"ENS6\\\": # T <= 360 but all 6-hourly\\r\\n time_size = (size_time - 1)\\r\\n #else: # something is wrong and need to throw an error message - likely a corrupt forecast file\\r\\n # raise Exception(self.errorMessages[3])\\r\\n #''' end of added section CJB 20180122 \\r\\n #'''\\r\\n\\r\\n #if id_data == \\\"LowRes\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowRes-6hr\\\"]\\r\\n #elif id_data == \\\"Low3HrRes\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowRes-3hr\\\"]\\r\\n #elif id_data == \\\"LowResFull\\\":\\r\\n # if in_time_interval == \\\"3hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowResFull-3hr-Sub\\\"]\\r\\n # elif in_time_interval == \\\"6hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"LowResFull-6hr-Sub\\\"]\\r\\n # else:\\r\\n # size_time = self.length_time_opt[\\\"LowRes-6hr\\\"]\\r\\n #else: #HighRes\\r\\n # if in_time_interval == \\\"1hr\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-1hr\\\"]\\r\\n # elif in_time_interval == \\\"3hr\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-3hr\\\"]\\r\\n # elif in_time_interval == \\\"3hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-3hr-Sub\\\"]\\r\\n # elif in_time_interval == \\\"6hr_subset\\\":\\r\\n # size_time = self.length_time_opt[\\\"HighRes-6hr-Sub\\\"]\\r\\n # else:\\r\\n # size_time = self.length_time_opt[\\\"HighRes-6hr\\\"]\\r\\n\\r\\n size_streamID = len(set(dict_list[self.header_wt[0]]))\\r\\n\\r\\n # Create output inflow netcdf data\\r\\n # data_out_nc = NET.Dataset(out_nc, \\\"w\\\") # by default format = \\\"NETCDF4\\\"\\r\\n data_out_nc = NET.Dataset(out_nc, \\\"w\\\", format = \\\"NETCDF3_CLASSIC\\\")\\r\\n #dim_Time = data_out_nc.createDimension('Time', size_time)\\r\\n dim_Time = data_out_nc.createDimension('Time', time_size)\\r\\n dim_RiverID = data_out_nc.createDimension('rivid', size_streamID)\\r\\n var_m3_riv = data_out_nc.createVariable('m3_riv', 'f4', \\r\\n ('Time', 'rivid'),\\r\\n fill_value=0)\\r\\n \\r\\n #data_temp = NUM.empty(shape = [size_time, size_streamID])\\r\\n data_temp = NUM.empty(shape = [time_size, size_streamID])\\r\\n\\r\\n lon_ind_all = [int(i) for i in dict_list[self.header_wt[2]]]\\r\\n lat_ind_all = [int(j) for j in dict_list[self.header_wt[3]]]\\r\\n\\r\\n # Obtain a subset of runoff data based on the indices in the weight table\\r\\n min_lon_ind_all = min(lon_ind_all)\\r\\n max_lon_ind_all = max(lon_ind_all)\\r\\n min_lat_ind_all = min(lat_ind_all)\\r\\n max_lat_ind_all = max(lat_ind_all)\\r\\n\\r\\n # self.vars_oi[vars_oi_index][3] = RO; get that variable's 3D structure (time, lat_index, lon_index) ready to reshape into 2D (time, lat_index x lon_index)\\r\\n data_subset_all = data_in_nc.variables[self.vars_oi[vars_oi_index][3]][:, min_lat_ind_all:max_lat_ind_all+1, min_lon_ind_all:max_lon_ind_all+1]\\r\\n len_time_subset_all = data_subset_all.shape[0]\\r\\n len_lat_subset_all = data_subset_all.shape[1]\\r\\n len_lon_subset_all = data_subset_all.shape[2]\\r\\n data_subset_all = data_subset_all.reshape(len_time_subset_all, (len_lat_subset_all * len_lon_subset_all))\\r\\n\\r\\n # compute new indices based on the data_subset_all\\r\\n index_new = []\\r\\n for r in range(0,count-1):\\r\\n ind_lat_orig = lat_ind_all[r]\\r\\n ind_lon_orig = lon_ind_all[r]\\r\\n index_new.append((ind_lat_orig - min_lat_ind_all)*len_lon_subset_all + (ind_lon_orig - min_lon_ind_all))\\r\\n\\r\\n # obtain a new subset of data\\r\\n data_subset_new = data_subset_all[:,index_new]*conversion_factor\\r\\n\\r\\n # start compute inflow\\r\\n pointer = 0\\r\\n for s in range(0, size_streamID):\\r\\n npoints = int(dict_list[self.header_wt[4]][pointer])\\r\\n # Check if all npoints points correspond to the same streamID\\r\\n if len(set(dict_list[self.header_wt[0]][pointer : (pointer + npoints)])) != 1:\\r\\n print(\\\"ROW INDEX {0}\\\".format(pointer))\\r\\n print(\\\"RIVID {0}\\\".format(dict_list[self.header_wt[0]][pointer]))\\r\\n raise Exception(self.errorMessages[2])\\r\\n\\r\\n area_sqm_npoints = [float(k) for k in dict_list[self.header_wt[1]][pointer : (pointer + npoints)]]\\r\\n area_sqm_npoints = NUM.array(area_sqm_npoints)\\r\\n area_sqm_npoints = area_sqm_npoints.reshape(1, npoints)\\r\\n data_goal = data_subset_new[:, pointer:(pointer + npoints)]\\r\\n \\r\\n \\r\\n #remove noise from data\\r\\n data_goal[data_goal<=0.00001] = 0\\r\\n\\r\\n ''' IMPORTANT NOTE: runoff variable in ECMWF dataset is cumulative instead of incremental through time\\r\\n '''\\r\\n # For data with Low Resolution, there's only one time interval 6 hrs\\r\\n if id_data == \\\"ENS6\\\": # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints\\r\\n elif id_data == \\\"ENS3\\\": # there's only one time interval 3 hrs # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\\r\\n elif id_data == \\\"HRES1\\\": # there's only one time interval 1 hrs # Line Added/Modified CJB 20190108\\r\\n #ro_stream = data_goal * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:,],data_goal[:-1,]) * area_sqm_npoints # Line Added/Modified CJB 20190108\\t\\r\\n #For data with the full version of Low Resolution, from Hour 0 to 144 (the first 49 time points) are of 3 hr time interval,\\r\\n # then from Hour 144 to 360 (36 time points) are of 6 hour time interval\\r\\n elif id_data == \\\"ENS36\\\": # Line Added/Modified CJB 20190108\\r\\n if in_time_interval == \\\"3hr_subset\\\":\\r\\n #use only the 3hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[1:49,], data_goal[:48,]) * area_sqm_npoints\\r\\n elif in_time_interval == \\\"6hr_subset\\\":\\r\\n #use only the 6hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[49:,], data_goal[48:-1,]) * area_sqm_npoints\\r\\n else: #\\\"LowRes-6hr\\\"\\r\\n ######################################################\\r\\n # MJS Always assume this case will have a full ECMWF 240\\r\\n # hour forecast to work with. It's actually never re-\\r\\n # quested by ecmwf_rapid_multiprocess anyhow.\\r\\n ######################################################\\r\\n #convert all to 6hr\\r\\n # calculate time series of 6 hr data from 3 hr data\\r\\n ro_6hr_a = NUM.subtract(data_goal[2:49:2,], data_goal[:48:2,])\\r\\n # get the time series of 6 hr data\\r\\n ro_6hr_b = NUM.subtract(data_goal[49:,], data_goal[48:-1,])\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b]) * area_sqm_npoints\\r\\n #For data with High Resolution, from Hour 0 to 90 (the first 91 time points) are of 1 hr time interval,\\r\\n # then from Hour 90 to 144 (18 time points) are of 3 hour time interval, and from Hour 144 to 240 (16 time points)\\r\\n # are of 6 hour time interval\\r\\n ##########################################################\\r\\n # MJS The following should handle id_data = HRES13 and HRES136\\r\\n ##########################################################\\r\\n else:\\r\\n if in_time_interval == \\\"1hr\\\":\\r\\n #ro_stream = NUM.subtract(data_goal[1:91,],data_goal[:90,]) * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[1:1+time_size,],data_goal[:time_size,]) * area_sqm_npoints # Line Added/Modified CJB, MJS 20190108\\r\\n elif in_time_interval == \\\"3hr\\\": # MJS HRES 3hr not currently used\\r\\n # calculate time series of 3 hr data from 1 hr data\\r\\n ro_3hr_a = NUM.subtract(data_goal[3:91:3,],data_goal[:88:3,])\\r\\n # get the time series of 3 hr data\\r\\n #ro_3hr_b = NUM.subtract(data_goal[91:109,], data_goal[90:108,])\\r\\n ro_3hr_b = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) # MJS modified again; seems no case for this, but just in case later... Line Added/Modified CJB 20190108\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_3hr_a, ro_3hr_b]) * area_sqm_npoints\\r\\n elif in_time_interval == \\\"3hr_subset\\\":\\r\\n #use only the 3hr time interval\\r\\n #ro_stream = NUM.subtract(data_goal[91:109,], data_goal[90:108,]) * area_sqm_npoints\\r\\n ro_stream = NUM.subtract(data_goal[91:91+time_size,], data_goal[90:90+time_size,]) * area_sqm_npoints # MJS modified again; needs to handle HRES13 that might not have complete 3hr set... Line Added/Modified CJB 20190108\\r\\n elif in_time_interval == \\\"6hr_subset\\\":\\r\\n #use only the 6hr time interval\\r\\n ro_stream = NUM.subtract(data_goal[109:,], data_goal[108:-1,]) * area_sqm_npoints\\r\\n ######################################################\\r\\n # MJS Always assume this case will have a full ECMWF 240 \\r\\n # hour forecast to work with. It's actually never re-\\r\\n # quested by ecmwf_rapid_multiprocess anyhow.\\r\\n ######################################################\\r\\n else: # in_time_interval == \\\"6hr\\\"\\r\\n #arcpy.AddMessage(\\\"6hr\\\")\\r\\n # calculate time series of 6 hr data from 1 hr data\\r\\n ro_6hr_a = NUM.subtract(data_goal[6:91:6,], data_goal[:85:6,])\\r\\n # calculate time series of 6 hr data from 3 hr data\\r\\n ro_6hr_b = NUM.subtract(data_goal[92:109:2,], data_goal[90:107:2,])\\r\\n # get the time series of 6 hr data\\r\\n ro_6hr_c = NUM.subtract(data_goal[109:,], data_goal[108:-1,])\\r\\n # concatenate all time series\\r\\n ro_stream = NUM.concatenate([ro_6hr_a, ro_6hr_b, ro_6hr_c]) * area_sqm_npoints\\r\\n \\r\\n #remove negative values\\r\\n ro_stream[ro_stream<0] = 0\\r\\n data_temp[:,s] = ro_stream.sum(axis = 1)\\r\\n\\r\\n pointer += npoints\\r\\n\\r\\n\\r\\n '''Write inflow data'''\\r\\n print(\\\"Writing inflow data...\\\")\\r\\n var_m3_riv[:] = data_temp\\r\\n # close the input and output netcdf datasets\\r\\n data_in_nc.close()\\r\\n data_out_nc.close()\",\n \"def openMCSH5File(filename, verbose=False):\\n rf = h5py.File(filename, 'r')\\n \\n stream = rf.require_group('/Data/Recording_0/AnalogStream/Stream_0')\\n data = np.array(stream.get('ChannelData'),dtype=np.int)\\n timestamps = np.array(stream.get('ChannelDataTimeStamps'))\\n info = np.array(stream.get('InfoChannel'))\\n \\n Unit = info['Unit'][0]\\n Tick = info['Tick'][0]/1e6\\n exponent = info['Exponent'][0]\\n convFact = info['ConversionFactor'][0]\\n \\n nRecCh, nFrames = data.shape\\n channel_ids = info['ChannelID']\\n assert len(np.unique(channel_ids)) == len(channel_ids), 'Duplicate MCS channel IDs found'\\n electrodeLabels = info['Label']\\n \\n TimeVals = np.arange(timestamps[0][0],timestamps[0][2]+1,1)*Tick\\n \\n assert Unit==b'V', 'Unexpected units found, expected volts, found {}'.format(Unit.decode('UTF-8'))\\n data_V = data*convFact.astype(float)*(10.0**(exponent))\\n \\n timestep_avg = np.mean(TimeVals[1:]-TimeVals[0:-1])\\n timestep_std = np.std(TimeVals[1:]-TimeVals[0:-1])\\n timestep_min = np.min(TimeVals[1:]-TimeVals[0:-1])\\n timestep_max = np.min(TimeVals[1:]-TimeVals[0:-1])\\n assert all(np.abs(np.array((timestep_min, timestep_max))-timestep_avg)/timestep_avg < 1e-6), 'Time steps vary by more than 1 ppm'\\n samplingRate = 1./timestep_avg\\n\\n if verbose:\\n print('# MCS H5 data format')\\n print('#')\\n print('# File: {}'.format(rf.filename))\\n print('# File size: {:.2f} MB'.format(rf.id.get_filesize()/1024**2))\\n print('#')\\n for key in rf.attrs.keys():\\n print('# {}: {}'.format(key,rf.attrs[key]))\\n print('#')\\n print('# Signal range: {:.2f} to {:.2f} µV'.format(np.amin(data_V)*1e6,np.amax(data_V)*1e6))\\n print('# Number of channels: {}'.format(nRecCh))\\n print('# Number of frames: {}'.format(nFrames))\\n print('# Time step: {:.2f} µs ± {:.5f} % (range {} to {})'.format(timestep_avg*1e6, timestep_std/timestep_avg*100, timestep_min*1e6, timestep_max*1e6))\\n print('# Sampling rate: {:.2f} Hz'.format(samplingRate))\\n print('#')\\n print('# MCSH5RecordingExtractor currently only reads /Data/Recording_0/AnalogStream/Stream_0')\\n\\n return (rf, nFrames, samplingRate, nRecCh, channel_ids, electrodeLabels, exponent, convFact)\",\n \"def test_simple_recov(self):\\r\\n\\r\\n # ND072022.PD0 contains a single ADCPA ensemble\\r\\n with open(os.path.join(RESOURCE_PATH, 'ND072022.PD0'), 'rb') as stream_handle:\\r\\n\\r\\n parser = AdcpPd0Parser(self.config_recov, stream_handle, self.exception_callback)\\r\\n particles = parser.get_records(1)\\r\\n \\r\\n log.debug('got back %d particles', len(particles))\\r\\n \\r\\n self.assert_particles(particles, 'ND072022_recov.yml', RESOURCE_PATH)\",\n \"def ncwrt_retrieval_obs_s2(retr_setup, outname=None):\\n\\n #-- set name of file to be generated\\n act_outname = outname if outname!=None else 'obs_s2.nc'\\n msg = \\\"Start writing configuration file ***{}***...\\\".format(act_outname)\\n FileLogger.info(msg)\\n\\n #-- compression settings\\n zlev = retr_setup.zlev\\n use_zlib = retr_setup.use_zlib\\n\\n #-- retrieval settings\\n s2_table = retr_setup.obs_dct['S2']\\n timepts = s2_table.geom.date_utc\\n npts = len(timepts)\\n s2_satid = np.array(s2_table.sat_id_lst, dtype=str)\\n s2_data = s2_table.data\\n s2_dataunc = s2_table.dataunc\\n nt,nbands = s2_data.shape\\n\\n #-- temporal settings, create time-values (time-since)\\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\\n time_values = nc4.date2num(timepts, time_unit)\\n\\n #-- ensure directory exists\\n mkdirp_smart(os.path.dirname(act_outname))\\n\\n #-- open file pointer\\n ncfp = nc4.Dataset(act_outname, 'w')\\n #-- add dimensions\\n d1 = ncfp.createDimension('npoints',npts)\\n d2 = ncfp.createDimension('nbands',nbands)\\n\\n #-- time-value\\n ncvar = ncfp.createVariable( 'time', np.float64, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('standard_name','time')\\n ncvar.setncattr('long_name','time')\\n ncvar.setncattr('units', time_unit)\\n ncvar[:] = time_values[:]\\n\\n #-- unit (in correct type)\\n unit_one = np.array([1]).astype(s2_data.dtype)[0]\\n\\n # BRF\\n ncvar = ncfp.createVariable( 'brf', np.float64, ('npoints','nbands'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'BRF top-of-canopy reflectances')\\n ncvar.setncattr('units',unit_one)\\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\\n ncvar[:,:] = s2_data[:,:]\\n\\n # BRF uncertainty\\n ncvar = ncfp.createVariable( 'brf_unc', np.float64, ('npoints','nbands'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'BRF top-of-canopy reflectances')\\n ncvar.setncattr('units',unit_one)\\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\\n comment = \\\"BRF uncertainties are derived as {:.2f}[%] relative uncertainty \\\".format(\\n 100.*retr_setup.s2_relunc)\\n comment += \\\"and an uncertainty floor value of {:.4f} is applied.\\\".format(retr_setup.s2_uncfloor)\\n ncvar.setncattr('comment', comment)\\n ncvar[:,:] = s2_dataunc[:,:]\\n\\n # satellite identifier\\n ncvar = ncfp.createVariable( 'satellite_id', str, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'satellite identifer')\\n ncvar[:] = s2_satid[:]\\n\\n #-- global attributes\\n ncfp.setncattr('creator_name',\\\"The Inversion Lab, Hamburg, Germany\\\")\\n ncfp.setncattr('creator_email', \\\"Michael.Vossbeck(at)Inversion-Lab.com\\\")\\n ncfp.setncattr('netcdf_libversion',\\\"{}\\\".format(nc4.__netcdf4libversion__))\\n ncfp.setncattr('date_created',\\\"{}\\\".format(dt.datetime.utcnow().isoformat()))\\n ncfp.setncattr('time_coverage_start',time_coverage_start)\\n ncfp.setncattr('time_coverage_end',time_coverage_end)\\n\\n #-- close file pointer\\n ncfp.close()\\n\\n # logging\\n msg = \\\"...writing ***{}*** DONE\\\".format(act_outname)\\n FileLogger.info(msg)\",\n \"def convert_input(filename, hdf5_data):\\n x1 = []\\n with open(filename, 'r') as inp:\\n for line in inp:\\n x1.append(line)\\n idx = 1\\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_TYPE, (1,), dtype=settings.NEMOH_INT)\\n dset[0] = int(float(x1[idx].split()[0]))\\n set_hdf5_attributes(dset, structure.H5_SOLVER_TYPE_ATTR)\\n idx += 1\\n\\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_RESTART, (1,), dtype=settings.NEMOH_INT)\\n dset[0] = int(float(x1[idx].split()[0]))\\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_RESTART_ATTR)\\n idx += 1\\n\\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_STOPPING, (1,), dtype=settings.NEMOH_FLOAT)\\n dset[0] = float(x1[idx].split()[0])\\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_STOPPING_ATTR)\\n idx += 1\\n\\n dset = require_dataset(hdf5_data, structure.H5_SOLVER_GMRES_MAX_ITERATIONS, (1,), dtype=settings.NEMOH_INT)\\n dset[0] = int(float(x1[idx].split()[0]))\\n set_hdf5_attributes(dset, structure.H5_SOLVER_GMRES_MAX_ITERATIONS_ATTR)\",\n \"def test_solinst_colon_decimalsep(test_files_dir, testfile):\\n solinst_file = hsr.SolinstFileReader(osp.join(test_files_dir, testfile))\\n\\n records = solinst_file.records\\n assert len(records) == 10\\n\\n assert records.index.tolist()[0] == Timestamp('2016-11-23 19:00:00')\\n assert records.iloc[0].iloc[0] == 1813.03\\n assert records.iloc[0].iloc[1] == 9.182\\n\\n assert records.index.tolist()[-1] == Timestamp('2016-11-23 21:15:00')\\n assert records.iloc[-1].iloc[0] == 1812.59\\n assert records.iloc[-1].iloc[1] == 9.179\\n\\n assert list(records.columns) == [\\\"LEVEL_cm\\\", \\\"TEMPERATURE_°C\\\"]\\n\\n sites = solinst_file.sites\\n assert sites.instrument_serial_number == \\\"2048469\\\"\\n assert sites.project_name == \\\"03040008\\\"\\n assert sites.site_name == \\\"Rougemont_Plus profond\\\"\",\n \"def test_extract_sensitivity_cube(tmpdir, datadir, datevshot):\\n \\n h5fn = datadir.join(\\\"test_hdf.h5\\\").strpath\\n outfn = tmpdir.join(\\\"test.fits\\\").strpath \\n \\n if datevshot:\\n args = [h5fn, \\\"--datevshot\\\", datevshot, \\\"063\\\", outfn]\\n else:\\n args = [h5fn, \\\"063\\\", outfn] \\n\\n extract_sensitivity_cube(args=args)\\n \\n assert isfile(outfn)\",\n \"def main(planckfile, dustfile, tomofile, colnames, names, pol, res,\\\\\\n part='all', distcut=None):\\n if (pol == 'P') or (pol == 'Q') or (pol == 'U'):\\n polarisation = True\\n elif (pol == 'p') or (pol == 'q') or (pol == 'u') or (pol == 'qu'):\\n polarisation = True\\n else:\\n polarisation = False\\n\\n print(pol, polarisation)\\n\\n if distcut is None:\\n distcut = 900\\n\\n if (polarisation is True):\\n # read smoothed planck maps.\\n print('load planck 353GHz data')\\n # read_smooth_maps(filename, name, shape)\\n IQU_smaps = smooth.read_smooth_maps(planckfile, names[0], 3)\\n dust_smap = smooth.read_smooth_maps(dustfile, names[1], 1)[0]\\n T_smap = IQU_smaps[0]\\n Q_smap = IQU_smaps[1]\\n U_smap = IQU_smaps[2]\\n \\n Nside = hp.get_nside(T_smap)\\n print('Using Nside={}'.format(Nside))\\n print(planckfile)\\n band = planckfile.split('_')[2]\\n if len(band) > 3:\\n band = band[:3]\\n if band == '15a':\\n band = '353'\\n print(band)\\n\\n if int(band) < 353:\\n # load cmb intensity and subtract form polarization maps\\n cmbfile = 'Data/IQU_Nside{}_CMB_10arcmin.h5'.format(Nside)\\n cmbmaps = tools.Read_H5(cmbfile, 'IQU')*1e6\\n Q_cmb = cmbmaps[1,:]\\n U_cmb = cmbmaps[1,:]\\n Q_smap = Q_smap - Q_cmb\\n U_smap = U_smap - U_cmb\\n \\n print(np.mean(Q_smap), np.mean(U_smap))\\n #sys.exit()\\n # load tomography data:\\n data = load.load_tomographydata(tomofile, colnames)\\n print('Data loaded, using Nside={}'.format(Nside))\\n\\n p_map, q_map, u_map, sigma, r_map, pix =\\\\\\n load.tomo_map(data, Nside, part=part, distcut=distcut)\\n u_map = -u_map # to Healpix convention\\n mask = np.unique(pix)\\n print(len(mask))\\n u_smap = smooth.smooth_tomo_map(u_map, mask, Nside, res)\\n q_smap = smooth.smooth_tomo_map(q_map, mask, Nside, res)\\n p_smap = smooth.smooth_tomo_map(p_map, mask, Nside, res)\\n print('Tomography maps smoothed')\\n print(np.mean(q_smap[mask]), np.mean(dust_smap[mask]), np.mean(Q_smap[mask]))\\n dPsi = np.full(len(u_map), hp.UNSEEN)\\n #sys.exit()\\n\\n l, b = tools.convert2galactic(data[:,0], data[:,1])\\n theta, phi = hp.pix2ang(Nside, pix) \\n lon = np.mean(phi)*180/np.pi\\n lat = 90 - np.mean(theta)*180/np.pi\\n print(lon, lat)\\n\\n x = 0.5*np.arctan2(U_smap[mask], Q_smap[mask])\\n #x[x<0.] += np.pi\\n #x[x>=np.pi] -= np.pi\\n\\n x_v = 0.5*np.arctan2(u_smap[mask], q_smap[mask])\\n #psi_v[psi_v<0] += np.pi\\n #psi_v[psi_v>=np.pi] -= np.pi \\n print('Polarization angles of planck (mean, min, max) [deg]:')\\n print(np.mean(x)*180/np.pi,np.min(x)*180/np.pi, np.max(x)*180/np.pi)\\n print(np.mean(x_v)*180/np.pi,np.min(x_v)*180/np.pi,np.max(x_v)*180/np.pi)\\n #print(np.mean(x+np.pi/2-psi_v))\\n if (pol == 'P') or (pol == 'p'):\\n print('-- P polarisation --')\\n\\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\\\\n U_smap[mask],u_smap[mask])\\\\\\n #, plot=True, name='smooth2')\\n\\n dPsi[mask] = psi\\n full_IQU = [T_smap, Q_smap, U_smap]\\n tot_res, frac_res, dust = tools.map_analysis_function(p_smap, T_smap,\\\\\\n dust_smap, mask, Nside)\\n\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\\n\\n elif (pol == 'Q') or (pol == 'q'):\\n print('-- Q polarisation --')\\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask], U_smap[mask],\\\\\\n u_smap[mask], plot=True)\\n\\n dPsi[mask] = psi\\n full_IQU = [T_smap, Q_smap, U_smap]\\n tot_res, frac_res, dust = tools.map_analysis_function(q_smap, Q_smap,\\\\\\n dust_smap, mask, Nside)\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\\n\\n elif (pol == 'U') or (pol == 'u'):\\n print('-- U polarisation --')\\n print(len(u_smap))\\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\\\\n U_smap[mask],u_smap[mask], plot=True)\\n\\n dPsi[mask] = psi\\n full_IQU = [T_smap, Q_smap, U_smap]\\n tot_res, frac_res, dust = tools.map_analysis_function(u_smap, U_smap,\\\\\\n dust_smap, mask, Nside)\\n\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\\n\\n elif (pol == 'QU') or (pol == 'qu'):\\n print('-- Q,U polarisation --')\\n print('Return: tomo, planck, dust, mask, dpsi, fullIQU, [lon,lat], r')\\n psi, psi_v, psi_s = tools.delta_psi(Q_smap[mask], q_smap[mask],\\\\\\n U_smap[mask], u_smap[mask])\\n #, plot=True, name=Nside)\\n\\n dPsi[mask] = psi\\n full_IQU = [T_smap, Q_smap, U_smap]\\n tomo = [q_smap, u_smap, p_smap, sigma[1], sigma[2], sigma[0]]\\n planck = [Q_smap, U_smap]\\n coord = [lon, lat]\\n angles = [dPsi[mask], psi_v, psi_s, sigma[3]]\\n return(tomo, planck, dust_smap, coord, full_IQU, mask, r_map, angles)\\n\\n\\n else:\\n # use unsmoothe maps\\n print('Use non smoothed maps')\\n # load planck\\n print('load planck 353GHz data')\\n\\n #T, P, Q, U = load.load_planck_map(planckfile, p=True)\\n data = load.load_planck_map(planckfile, p=True)\\n d353 = load.load_planck_map(dustfile)\\n sys.exit()\\n dust353 = tools.Krj2Kcmb(d353) * 1e6\\n T = T*1e6\\n P = P*1e6\\n Q = Q*1e6\\n U = U*1e6\\n Nside = hp.get_nside(T_smap)\\n\\n data = load.load_tomographydata(tomofile, colnames)\\n p_map, q_map, u_map, sigma, r_map, pix = load.tomo_map(data, Nside)\\n u_map = -u_map # to Healpix convention\\n mask = np.unique(pix)\\n\\n l, b = tools.convert2galactic(data[:,0], data[:,1])\\n lon = np.mean(l)\\n lat = np.mean(b)\\n\\n dPsi = np.full(len(u_map), hp.UNSEEN)\\n\\n if Ppol == True:\\n print('-- P polarisation --')\\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\\\\n u_map[mask], plot=True)\\n dPsi[mask] = psi\\n full_IQU = [T, Q, U]\\n tot_res, frac_res, dust = tools.map_analysis_function(p_map, T,\\\\\\n dust353, mask)\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\\n\\n elif Qpol == True:\\n print('-- Q polarisation --')\\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\\\\n u_map[mask], plot=True)\\n dPsi[mask] = psi\\n full_IQU = [T, Q, U]\\n tot_res, frac_res, dust = tools.map_analysis_function(q_map, Q,\\\\\\n dust353, mask)\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\\n\\n if Upol == True:\\n print('-- U polarisation --')\\n psi = tools.delta_psi(Q[mask], q_map[mask], U[mask],\\\\\\n u_map[mask], plot=True)\\n dPsi[mask] = psi\\n full_IQU = [T, Q, U]\\n tot_res, frac_res, dust = tools.map_analysis_function(u_map, U,\\\\\\n dust353, mask)\\n return(tot_res, frac_res, dust, [lon, lat], full_IQU, mask, r_map, dPsi)\",\n \"def test():\\n import os\\n import ClearMap.ImageProcessing.SpotDetection as self\\n reload(self)\\n import ClearMap.IO as io \\n import ClearMap.Settings as settings\\n \\n basedir = settings.ClearMapPath;\\n #fn = '/home/ckirst/Science/Projects/BrainActivityMap/Data/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims';\\n fn = os.path.join(basedir, 'Test/Data/Synthetic/label_iDISCO_\\\\d{3}.tif');\\n fn = os.path.join(basedir, 'Test/Data/OME/16-17-27_0_8X-s3-20HF_UltraII_C00_xyz-Table Z\\\\d{4}.ome.tif');\\n #fn = '/run/media/ckirst/ChristophsBackuk4TB/iDISCO_2015_06/Adult cfos C row 20HF 150524.ims';\\n #fn = '/home/nicolas/Windows/Nico/cfosRegistrations/Adult cfos C row 20HF 150524 - Copy.ims';\\n #fn = '/home/ckirst/Science/Projects/BrainActivityMap/iDISCO_2015_04/test for spots added spot.ims'\\n\\n img = io.readData(fn);\\n #img = dataset[0:500,0:500,1000:1008];\\n #img = dataset[600:1000,1600:1800,800:830];\\n #img = dataset[500:1500,500:1500,800:809]; \\n img = img.astype('int16');\\n \\n #m = sys.modules['iDISCO.ImageProcessing.SpotDetection']\\n #c = self.detectCells(img);\\n \\n c = self.detectCells(img, dogSize = None, cellShapeThreshold = 1, cellShapeFile = '/home/ckirst/Science/Projects/BrainActivityMap/Analysis/iDISCO/Test/Data/CellShape/cellshape_\\\\d{3}.tif');\\n \\n print ('done, found %d cells !' % c[0].shape[0])\\n\\n\\n #test intensities:\\n import numpy;\\n x = numpy.random.rand(30,30,10);\\n centers = numpy.array([[0,0,0], [29,29,9]]);\\n i = self.findIntensity(x, centers, boxSize = (1,1,1));\\n print (i)\",\n \"def _initialize_output(self, time_len, id_len):\\r\\n\\r\\n log('Initializing new file %s' % self.cf_compliant_file, 'INFO')\\r\\n \\r\\n self.cf_nc = Dataset(self.cf_compliant_file, 'w', format='NETCDF3_CLASSIC')\\r\\n \\r\\n # Create global attributes\\r\\n log(' globals', 'DEBUG', self.print_debug)\\r\\n self.cf_nc.featureType = 'timeSeries'\\r\\n self.cf_nc.Metadata_Conventions = 'Unidata Dataset Discovery v1.0'\\r\\n self.cf_nc.Conventions = 'CF-1.6'\\r\\n self.cf_nc.cdm_data_type = 'Station'\\r\\n self.cf_nc.nodc_template_version = (\\r\\n 'NODC_NetCDF_TimeSeries_Orthogonal_Template_v1.1')\\r\\n self.cf_nc.standard_name_vocabulary = ('NetCDF Climate and Forecast (CF) ' +\\r\\n 'Metadata Convention Standard Name ' +\\r\\n 'Table v28')\\r\\n self.cf_nc.title = 'RAPID Result'\\r\\n self.cf_nc.summary = (\\\"Results of RAPID river routing simulation. Each river \\\" +\\r\\n \\\"reach (i.e., feature) is represented by a point \\\" +\\r\\n \\\"feature at its midpoint, and is identified by the \\\" +\\r\\n \\\"reach's unique NHDPlus COMID identifier.\\\")\\r\\n self.cf_nc.time_coverage_resolution = 'point'\\r\\n self.cf_nc.geospatial_lat_min = 0.0\\r\\n self.cf_nc.geospatial_lat_max = 0.0\\r\\n self.cf_nc.geospatial_lat_units = 'degrees_north'\\r\\n self.cf_nc.geospatial_lat_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_lon_min = 0.0\\r\\n self.cf_nc.geospatial_lon_max = 0.0\\r\\n self.cf_nc.geospatial_lon_units = 'degrees_east'\\r\\n self.cf_nc.geospatial_lon_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_vertical_min = 0.0\\r\\n self.cf_nc.geospatial_vertical_max = 0.0\\r\\n self.cf_nc.geospatial_vertical_units = 'm'\\r\\n self.cf_nc.geospatial_vertical_resolution = 'midpoint of stream feature'\\r\\n self.cf_nc.geospatial_vertical_positive = 'up'\\r\\n self.cf_nc.project = self.project_name\\r\\n self.cf_nc.processing_level = 'Raw simulation result'\\r\\n self.cf_nc.keywords_vocabulary = ('NASA/Global Change Master Directory ' +\\r\\n '(GCMD) Earth Science Keywords. Version ' +\\r\\n '8.0.0.0.0')\\r\\n self.cf_nc.keywords = 'DISCHARGE/FLOW'\\r\\n self.cf_nc.comment = 'Result time step(s) (seconds): ' + str(self.time_step_array)\\r\\n \\r\\n timestamp = datetime.utcnow().isoformat() + 'Z'\\r\\n self.cf_nc.date_created = timestamp\\r\\n self.cf_nc.history = (timestamp + '; added time, lat, lon, z, crs variables; ' +\\r\\n 'added metadata to conform to NODC_NetCDF_TimeSeries_' +\\r\\n 'Orthogonal_Template_v1.1')\\r\\n \\r\\n # Create dimensions\\r\\n log(' dimming', 'DEBUG', self.print_debug)\\r\\n self.cf_nc.createDimension('time', time_len)\\r\\n self.cf_nc.createDimension(self.output_id_dim_name, id_len)\\r\\n \\r\\n # Create variables\\r\\n log(' timeSeries_var', 'DEBUG', self.print_debug)\\r\\n timeSeries_var = self.cf_nc.createVariable(self.output_id_dim_name, 'i4', \\r\\n (self.output_id_dim_name,))\\r\\n timeSeries_var.long_name = (\\r\\n 'Unique NHDPlus COMID identifier for each river reach feature')\\r\\n timeSeries_var.cf_role = 'timeseries_id'\\r\\n \\r\\n log(' time_var', 'DEBUG', self.print_debug)\\r\\n time_var = self.cf_nc.createVariable('time', 'i4', ('time',))\\r\\n time_var.long_name = 'time'\\r\\n time_var.standard_name = 'time'\\r\\n time_var.units = 'seconds since 1970-01-01 00:00:00 0:00'\\r\\n time_var.axis = 'T'\\r\\n \\r\\n #only add if user adds\\r\\n if self.comid_lat_lon_z_file and os.path.exists(self.comid_lat_lon_z_file):\\r\\n log(' lat_var', 'DEBUG', self.print_debug)\\r\\n lat_var = self.cf_nc.createVariable('lat', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n lat_var.long_name = 'latitude'\\r\\n lat_var.standard_name = 'latitude'\\r\\n lat_var.units = 'degrees_north'\\r\\n lat_var.axis = 'Y'\\r\\n \\r\\n log(' lon_var', 'DEBUG', self.print_debug)\\r\\n lon_var = self.cf_nc.createVariable('lon', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n lon_var.long_name = 'longitude'\\r\\n lon_var.standard_name = 'longitude'\\r\\n lon_var.units = 'degrees_east'\\r\\n lon_var.axis = 'X'\\r\\n \\r\\n log(' z_var', 'DEBUG', self.print_debug)\\r\\n z_var = self.cf_nc.createVariable('z', 'f8', (self.output_id_dim_name,),\\r\\n fill_value=-9999.0)\\r\\n z_var.long_name = ('Elevation referenced to the North American ' +\\r\\n 'Vertical Datum of 1988 (NAVD88)')\\r\\n z_var.standard_name = 'surface_altitude'\\r\\n z_var.units = 'm'\\r\\n z_var.axis = 'Z'\\r\\n z_var.positive = 'up'\\r\\n \\r\\n log(' crs_var', 'DEBUG', self.print_debug)\\r\\n crs_var = self.cf_nc.createVariable('crs', 'i4')\\r\\n crs_var.grid_mapping_name = 'latitude_longitude'\\r\\n crs_var.epsg_code = 'EPSG:4326' # WGS 84\\r\\n crs_var.semi_major_axis = 6378137.0\\r\\n crs_var.inverse_flattening = 298.257223563\",\n \"def test_ccds(self):\\n #TODO write ccds tests\",\n \"def get_data(eh, file_list):\\n x_pos = []\\n y_pos = []\\n x_vel = []\\n y_vel = []\\n z_vel = []\\n unique_x = []\\n unique_y = []\\n\\n # reading data\\n for file in file_list:\\n with open(file, 'r') as f:\\n f.readline() # Ignores first line\\n for line in f:\\n line = line.strip()\\n column = line.split()\\n if len(column) == 4:\\n if file == file_list[0]:\\n # Only takes position data from first file as the same in each file\\n x_pos.append(float(column[0]))\\n y_pos.append(float(column[1]))\\n\\n x_vel.append(float(column[2]))\\n y_vel.append(float(column[3]))\\n z_vel.append(0.0)\\n\\n if float(column[0]) not in unique_x:\\n unique_x.append(float(column[0]))\\n if float(column[1]) not in unique_y:\\n unique_y.append(float(column[1]))\\n else:\\n x_vel.append(float(column[2]))\\n y_vel.append(float(column[3]))\\n z_vel.append(0.0)\\n else:\\n print \\\"Error: TXT file is not correct!\\\"\\n\\n ux = len(unique_x)\\n uy = len(unique_y)\\n\\n\\n # xmid and ymid are used to get xz- and yz-planes. The median value is used. If the number of\\n # unique xs and ys is even, then the median value will be one that does not correspond to a\\n # measurement. When this is the case, the first value is ignored so that the number of uniques is\\n # odd, resulting in a median value that corresponds to a measurement.\\n if ux % 2 == 0:\\n xmid = np.median(unique_x[1:])\\n else:\\n xmid = np.median(unique_x)\\n\\n if uy % 2 == 0:\\n ymid = np.median(unique_y[1:])\\n else:\\n ymid = np.median(unique_y)\\n\\n if eh == exp_h_list[-1]:\\n print \\\"All data read.\\\"\\n\\n\\n # checks list lengths to ensure matching and then averages the velocities for all files\\n # and then returns an array with position and average velocities\\n if len(x_pos) == len(y_pos):\\n pos_count = len(x_pos)\\n if len(x_vel) == len(y_vel) and len(x_vel) == len(z_vel):\\n vel_count = len(x_vel)\\n nof = vel_count / pos_count # equals number of files for each height\\n ax_vel, ay_vel, az_vel = avg_data_each_h(nof, pos_count, x_vel, y_vel, z_vel)\\n\\n if make_sg:\\n subgrid_array = sub_grid(ux, x_pos, y_pos, eh, ax_vel, ay_vel, az_vel)\\n return subgrid_array\\n else:\\n z_pos = [eh] * len(x_pos)\\n return xmid, ymid, zip(x_pos, y_pos, z_pos, ax_vel, ay_vel, az_vel)\\n else:\\n print \\\"Error: different number of velocities!\\\"\\n else:\\n print \\\"Error: not all x-positions have a corresponding y-position!\\\"\",\n \"def test_calculate_r_i():\\n \\n with open(HsHis6_PEX5C_vs_HsPEX5C_calc_r_I, 'rb') as file: # load the list with expexcted data frames from .pkl file\\n expected_list = pickle.load(file)\\n \\n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\\n test_object.background_correct()\\n test_object.calculate_r_i(correct=True, plot_i=False, thr=50)\\n \\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_raw'], expected_list[0], atol=1E-6)\\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['r_raw'], expected_list[1], atol=1E-6)\\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_corrected'], expected_list[2], atol=1E-6)\\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['r_corrected'], expected_list[3], atol=1E-6)\\n pd.testing.assert_frame_equal(test_object.data_dict['repeat_1']['data']['i_percent'], expected_list[4], atol=1E-6)\",\n \"def run(self, dataset_dir, sensor_data, output_dir,\\n pc_input=None, save_pc=None,\\n gn_input=None, save_gn=None,\\n software_cfg=None,\\n tolPC=TOLPC, tol=TOL, tolA=TOLA, tolB=TOLB, tolU=TOLU,\\n show=1,\\n return_covariance=True):\\n\\n # Default to save residual data\\n res = True\\n\\n ################################################################################################################\\n # 1.\\tRead Harmonisation Matchup Data\\n ################################################################################################################\\n\\n print \\\"\\\\nOpening data...\\\"\\n HData = open_matchup(dataset_dir)\\n HData.setSensorData(sensor_data)\\n print \\\"Complete\\\"\\n\\n print \\\"\\\\nData Info\\\"\\n print \\\"==========\\\"\\n print \\\"Reference Sensors - \\\", [str(sensor) for sensor in HData.idx['sensors']\\n if sensor not in HData.idx[\\\"parameter_sensor\\\"]]\\n print \\\"Harmonising Sensors - \\\", [str(sensor) for sensor in HData.idx['sensors']\\n if sensor in HData.idx[\\\"parameter_sensor\\\"]]\\n print \\\"Total Match-Ups - \\\", HData.idx['cNm'][-1]\\n print \\\"Total Sensor State Data Values - \\\", HData.idx['idx'][-1]\\n print \\\"Total Harmonisation Paramaters - \\\", len(HData.idx['parameter_sensor'])\\n\\n ################################################################################################################\\n # 2.\\tPerform harmonisation\\n ################################################################################################################\\n\\n print \\\"\\\\nBeginning Harmonisation...\\\"\\n Harmonisation = HarmonisationEIV()\\n HarmonisationOutput = Harmonisation.run(HData,\\n pc_input=pc_input, save_pc=save_pc,\\n gn_input=gn_input, save_gn=save_gn,\\n show=show)\\n\\n print \\\"Final Solution:\\\"\\n print HarmonisationOutput.parameter\\n print HarmonisationOutput.parameter_covariance_matrix\\n\\n ################################################################################################################\\n # 3.\\tWrite data to file\\n ################################################################################################################\\n\\n print 'Writing data to file...'\\n # Add metadata\\n startDate = \\\"\\\"\\n endDate = \\\"\\\"\\n HarmonisationOutput.additional_attributes = {\\\"software\\\": software_cfg['software'],\\n \\\"software_version\\\": software_cfg['version'],\\n \\\"software_tag\\\": software_cfg['tag'],\\n \\\"job_id\\\": software_cfg[\\\"job_id\\\"],\\n \\\"matchup_dataset\\\": \\\"_\\\".join((software_cfg['matchup_dataset'],\\n startDate, endDate))}\\n\\n # Write data\\n fname_output = \\\"_\\\".join((\\\"harm\\\", software_cfg['software'], software_cfg['version'],\\n software_cfg['tag'], software_cfg[\\\"job_id\\\"],\\n software_cfg['matchup_dataset'])) + \\\".nc\\\"\\n HarmonisationOutput.save(pjoin(output_dir, fname_output), save_residuals=res)\\n\\n print \\\"\\\\nOutput Data Written To:\\\"\\n print \\\">\\\", output_dir\",\n \"def test_T2():\\n infile = \\\"cisd/T2.in\\\"\\n assert(os.path.exists(infile))\\n with open(infile) as f:\\n lines = f.readlines()\\n assert(len(lines) == 10)\\n\\n hl1 = HirataLine(lines[0])\\n assert(set(hl1.free_indices.split()) == set(\\\"p3 p4 h1 h2\\\".split()))\\n assert(hl1.summation_indices == '')\\n assert(hl1.prefactors == [\\\"+ 1.0 \\\"])\\n assert(hl1.postfactors == ['v ( p3 p4 h1 h2 )'])\\n assert(str(hl1) == lines[0].replace('\\\\n', ''))\\n cl1 = Cc4sLine(hl1)\\n assert(set(cl1.free_indices.split()) == set([\\\"c\\\", \\\"d\\\", \\\"i\\\", \\\"j\\\"]))\\n assert(cl1.summation_indices == \\\"\\\")\\n assert(cl1.prefactors == [\\\"+ 1.0 \\\"])\\n assert(cl1.postfactors == ['Vabij[\\\"cdij\\\"]'])\\n assert(cl1.to_cpp() == ['( + 1.0 ) * Vabij[\\\"cdij\\\"];'])\\n\\n hl8 = HirataLine(lines[7])\\n assert(set(hl8.free_indices.split()) == set(\\\"p3 p4 h1 h2\\\".split()))\\n assert(hl8.summation_indices == ' h6 p5 ')\\n assert(\\n hl8.prefactors == [\\n '+ 1.0 ',\\n '- 1.0 * P( p3 p4 h2 h1 => p4 p3 h2 h1 ) ',\\n '- 1.0 * P( p3 p4 h2 h1 => p3 p4 h1 h2 ) ',\\n '+ 1.0 * P( p3 p4 h2 h1 => p4 p3 h1 h2 ) '\\n ]\\n )\\n assert(\\n hl8.postfactors ==\\n ['Sum ( h6 p5 )', 't ( p5 p3 h6 h2 )', 'v ( h6 p4 h1 p5 )']\\n )\\n assert(str(hl8) == lines[7].replace('\\\\n', ''))\\n cl8 = Cc4sLine(hl8)\\n assert(set(cl8.free_indices.split()) == set([\\\"c\\\", \\\"d\\\", \\\"i\\\", \\\"j\\\"]))\\n assert(cl8.summation_indices == \\\" n e \\\")\\n assert(\\n cl8.prefactors ==\\n ['+ 1.0 ',\\n '- 1.0 * P( c d j i => d c j i ) ',\\n '- 1.0 * P( c d j i => c d i j ) ',\\n '+ 1.0 * P( c d j i => d c i j ) ']\\n )\\n assert(cl8.postfactors == ['Tabij[\\\"ecnj\\\"]', 'Viajb[\\\"ndie\\\"]'])\\n assert(\\n cl8.to_cpp() == [\\n '( + 1.0 ) * Tabij[\\\"ecnj\\\"] * Viajb[\\\"ndie\\\"];',\\n '( - 1.0 ) * Tabij[\\\"ednj\\\"] * Viajb[\\\"ncie\\\"];',\\n '( - 1.0 ) * Tabij[\\\"ecni\\\"] * Viajb[\\\"ndje\\\"];',\\n '( + 1.0 ) * Tabij[\\\"edni\\\"] * Viajb[\\\"ncje\\\"];'\\n ]\\n )\",\n \"def read(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\\n\\n data = []\\n comb = True if diagram == 'C4+D' else False\\n\\n for cnfg in lookup_cnfg:\\n # filename and path\\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\\n try:\\n fh = h5py.File(filename, \\\"r\\\")\\n except IOError:\\n print 'file %s not found' % filename\\n raise\\n\\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\\n # each loop seperately\\n # TODO: is it necessary to build that completely or can that be \\n # constructed by successively storing each operator with pd.HDFStore()?\\n data_qn = DataFrame()\\n# print DataFrame(lookup_p)\\n# print DataFrame(lookup_g)\\n\\n for op in lookup_qn.index:\\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\\n g = lookup_qn.ix[op, ['\\\\gamma_{so}', '\\\\gamma_{si}']]\\n groupname = set_groupname(diagram, p, g)\\n\\n # read data from file as numpy array and interpret as complex\\n # numbers for easier treatment\\n try:\\n tmp = np.asarray(fh[groupname]).view(complex)\\n except KeyError:\\n print(\\\"could not read %s for config %d\\\" % (groupname, cnfg))\\n continue\\n\\n # in case diagram is C4+D perform last mutliplication of factorizing\\n # traces\\n # the file contains 4 numbers per time slice: ReRe, ReIm, ImRe, and ImIm,\\n # here combined 2 complex number\\n if comb:\\n # reshaping so we can extract the data easier\\n tmp = tmp.reshape((-1,2))\\n # extracting right combination, assuming ImIm contains only noise\\n dtmp = 1.j * (tmp[:,1].real + tmp[:,0].imag) + tmp[:,0].real\\n tmp = dtmp.copy()\\n\\n # save data into data frame\\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\\n data.append(data_qn)\\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\\n\\n if verbose:\\n print '\\\\tfinished reading'\\n\\n return data.sort_index(level=[0,1])\",\n \"def test_compute_Sv_ek80_CW_complex(ek80_path):\\n ek80_raw_path = str(\\n ek80_path.joinpath('ar2.0-D20201210-T000409.raw')\\n ) # CW complex\\n echodata = ep.open_raw(ek80_raw_path, sonar_model='EK80')\\n ds_Sv = ep.calibrate.compute_Sv(\\n echodata, waveform_mode='CW', encode_mode='complex'\\n )\\n assert isinstance(ds_Sv, xr.Dataset) is True\\n ds_TS = ep.calibrate.compute_TS(\\n echodata, waveform_mode='CW', encode_mode='complex'\\n )\\n assert isinstance(ds_TS, xr.Dataset) is True\",\n \"def test5(self):\\n tgts = [ ('CCC(O)C(=O)O',\\n ('O[CH-][CH2-]','O[CH-][C-]=O')),\\n ]\\n for smi,matches in tgts:\\n m = Chem.MolFromSmiles(smi)\\n fp1 = Chem.RDKFingerprint(m,2,7,9192,4,1)\\n obs = fp1.GetOnBits()\\n for match in matches:\\n m2 = Chem.MolFromSmiles(match)\\n fp2 = Chem.RDKFingerprint(m2,2,7,9192,4,1)\\n v1,v2 = DataStructs.OnBitProjSimilarity(fp2,fp1)\\n assert feq(v1,1.0000),'substruct %s not properly contained in %s'%(match,smi)\",\n \"def test_header_update5(self, capsys):\\n\\n # Prepare input files.\\n self.get_data(\\\"input\\\", \\\"ocyw05afq_raw.fits\\\")\\n self.get_data(\\\"input\\\", \\\"ocyw05afq_spt.fits\\\")\\n\\n capsys.readouterr()\\n\\n tastis('ocyw05afq_raw.fits', update=True)\\n\\n captured = capsys.readouterr()\\n assert captured.out == \\\"===============================================================================\\\\n\\\" \\\\\\n \\\"ocyw05afq HST/STIS G430L 0.2X0.09 ACQ/PEAK-UP\\\\n\\\" \\\\\\n \\\"prop: 14084 visit: 05 line: 2 target: BD-11D916\\\\n\\\" \\\\\\n \\\"obs date, time: 2016-09-22 08:33:17 exposure time: 1.80\\\\n\\\" \\\\\\n \\\"dom GS/FGS: S2AE000156F1 sub-dom GS/FGS: S2AE000086F2\\\\n\\\" \\\\\\n \\\"ACQ params: bias sub: 1510 method: MAX-FLUX-CENTROID\\\\n\\\" \\\\\\n \\\"subarray (axis1,axis2): size=(1022,32) corner=(26,500)\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"Scan type: LINEARAXIS2 Step size (mas): 150\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" [ 5139 67252 0]\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2 V2 V3\\\\n\\\" \\\\\\n \\\" (pixels) (arcsec) (arcsec)\\\\n\\\" \\\\\\n \\\"Estimated slew: 0.0 0.0 0.000 0.000 0.000 0.000\\\\n\\\" \\\\\\n \\\"Flux in post-slew confirmation image (907707) - Pedestal (838752) = 68955 DN\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"The confirmation image has a flux between 0.8 and 2.0 times the\\\\n\\\" \\\\\\n \\\"maximum flux in the peakup, which is typical of a successful ACQ/PEAK.\\\\n\\\" \\\\\\n \\\"===============================================================================\\\\n\\\"\\n\\n # Compare results\\n outputs = [(\\\"ocyw05afq_raw.fits\\\", \\\"ocyw05afq_raw_ref.fits\\\")]\\n self.compare_outputs(outputs)\",\n \"def test_sim(self):\\n nxfe = 4\\n ipopt = get_solver(\\\"ipopt\\\")\\n\\n m_steady = self.make_steady_model(nfe=nxfe)\\n self.fix_model_inlets(m_steady, inlet_pressure=50.0 * pyo.units.bar)\\n m_steady.fs.compressor.boost_pressure[:].fix(7.0 * pyo.units.bar)\\n ipopt.solve(m_steady, tee=True)\\n time_steady = m_steady.fs.time\\n scalar_data = self.get_scalar_data_from_model(m_steady, time_steady)\\n initial_data = self.get_data_from_model_at_time(m_steady, time_steady)\\n\\n m = pyo.ConcreteModel()\\n default = {\\n \\\"dynamic\\\": True,\\n \\\"time_set\\\": [0.0, 20.0],\\n \\\"time_units\\\": pyo.units.hr,\\n }\\n m.fs = idaes.FlowsheetBlock(**default)\\n m.fs.properties = NaturalGasParameterBlock()\\n pipeline_config = {\\n \\\"property_package\\\": m.fs.properties,\\n \\\"finite_elements\\\": nxfe,\\n }\\n m.fs.pipeline = GasPipeline(**pipeline_config)\\n pipeline = m.fs.pipeline\\n compressor_config = {\\\"property_package\\\": m.fs.properties}\\n m.fs.compressor = Compressor(**compressor_config)\\n compressor = m.fs.compressor\\n m._compressor_to_pipeline = Arc(\\n ports=(compressor.outlet_port, pipeline.inlet_port),\\n )\\n expand_arcs = pyo.TransformationFactory(\\\"network.expand_arcs\\\")\\n expand_arcs.apply_to(m)\\n\\n cv = m.fs.pipeline.control_volume\\n assert_units_consistent(m)\\n\\n disc = pyo.TransformationFactory(\\\"dae.finite_difference\\\")\\n ntfe = 20\\n disc.apply_to(m, nfe=ntfe, wrt=m.fs.time, scheme=\\\"BACKWARD\\\")\\n\\n time = m.fs.time\\n t0 = m.fs.time.first()\\n x0 = cv.length_domain.first()\\n xf = cv.length_domain.last()\\n j = next(iter(m.fs.properties.component_list))\\n\\n # Fix geometry variables\\n m.fs.pipeline.diameter.fix(0.92 * pyo.units.m)\\n cv.length.fix(300.0 * pyo.units.km)\\n\\n # Fix boost pressure\\n compressor.boost_pressure[:].fix()\\n\\n # Inlets to the compressor are fixed, except for flow, where\\n # the outlet is fixed.\\n state = compressor.inlet_state\\n state[:].pressure.fix()\\n state[:].mole_frac_comp[j].fix()\\n state[:].temperature.fix()\\n cv.flow_mass[:, xf].fix()\\n\\n # Fix initial conditions. Here, pressure and volume for all\\n # non-specified points.\\n for x in cv.length_domain:\\n if x != x0:\\n cv.pressure[t0, x].fix()\\n if x != xf:\\n cv.flow_mass[t0, x].fix()\\n\\n # I want to deactivate differential equations at (t0, xf)\\n # Material balance already doesn't exist here.\\n cv.momentum_balance[t0, xf].deactivate()\\n\\n self.assertEqual(degrees_of_freedom(m), 0)\\n\\n # Load initial steady state into model at all time points.\\n for name, val in initial_data.items():\\n var = m.find_component(name)\\n for t in time:\\n var[t].set_value(val)\\n # Load scalar data from initial steady state\\n # (initialize area, basically)\\n for name, val in scalar_data.items():\\n var = m.find_component(name)\\n var.set_value(val)\\n\\n cv.material_accumulation[...].set_value(0.0)\\n cv.flow_mass_dt[...].set_value(0.0)\\n\\n for con in large_residuals_set(m):\\n resid = pyo.value(con.body - con.upper)\\n print(resid, con.name)\\n ipopt.solve(m, tee=True)\\n\\n # Load input sequence into model\\n sample_points = [4.0, 20.0]\\n input_name = \\\"fs.pipeline.control_volume.flow_mass[*,1.0]\\\"\\n nominal_density = 0.72\\n val = 12.0 * 1e6 / 24 * nominal_density # 12 (1e6 SCM)/day\\n input_series_data = (\\n sample_points,\\n {input_name: [val, val]},\\n )\\n input_interval_data = interval_data_from_time_series(input_series_data)\\n load_inputs_into_model(m, time, input_interval_data)\\n # Solve with loaded inputs\\n res = ipopt.solve(m, tee=True)\\n self.assertIs(\\n res.solver.termination_condition,\\n pyo.TerminationCondition.optimal,\\n )\\n\\n # These predicted values come from a simulation of a single pipeline\\n # model from the Pyomo DAE example. flow_mass has been converted\\n # to kg/hr from (1e4 SCM/hr) by a factor of 0.72*1e4, where\\n # 0.72 kg/m**3 is the gas density at standard conditions.\\n pred_values = (\\n list(time),\\n {\\n \\\"fs.pipeline.control_volume.flow_mass[*,%s]\\\"\\n % x0: [\\n 3.000e5,\\n 2.999e5,\\n 2.999e5,\\n 2.999e5,\\n 3.000e5,\\n 3.174e5,\\n 3.301e5,\\n 3.389e5,\\n 3.449e5,\\n 3.492e5,\\n 3.523e5,\\n 3.544e5,\\n 3.560e5,\\n 3.571e5,\\n 3.579e5,\\n 3.585e5,\\n 3.589e5,\\n 3.592e5,\\n 3.594e5,\\n 3.595e5,\\n 3.597e5,\\n ],\\n \\\"fs.pipeline.control_volume.pressure[*,%s]\\\"\\n % xf: [\\n 50.90,\\n 50.90,\\n 50.90,\\n 50.90,\\n 50.90,\\n 49.83,\\n 49.31,\\n 48.95,\\n 48.69,\\n 48.51,\\n 48.38,\\n 48.29,\\n 48.22,\\n 48.17,\\n 48.14,\\n 48.11,\\n 48.10,\\n 48.08,\\n 48.07,\\n 48.07,\\n 48.06,\\n ],\\n \\\"fs.compressor.power[*]\\\": [\\n 1.590e3,\\n 1.590e3,\\n 1.590e3,\\n 1.590e3,\\n 1.590e3,\\n 1.682e3,\\n 1.750e3,\\n 1.796e3,\\n 1.828e3,\\n 1.851e3,\\n 1.867e3,\\n 1.878e3,\\n 1.887e3,\\n 1.892e3,\\n 1.897e3,\\n 1.900e3,\\n 1.902e3,\\n 1.904e3,\\n 1.905e3,\\n 1.906e3,\\n 1.906e3,\\n ],\\n },\\n )\\n output_names = [\\n \\\"fs.pipeline.control_volume.flow_mass[*,%s]\\\" % x0,\\n \\\"fs.pipeline.control_volume.pressure[*,%s]\\\" % xf,\\n \\\"fs.compressor.power[*]\\\",\\n ]\\n actual_values = (\\n list(time),\\n {\\n name: [var.value for var in m.find_component(name).values()]\\n for name in output_names\\n },\\n )\\n # Note: We fail with a reltol of 0.01, due to flow rate discrepancies\\n # in positions 6, 7, 8, and 9. A reltol of 0.02 seems reasonable to me.\\n self.assertStructuredAlmostEqual(pred_values, actual_values, reltol=0.02)\",\n \"def loadData(fname='Unstra.out2.00008.athdf'):\\n #data=ath.athdf(fname,quantities=['B1','B2','B3'])\\n time,data=ath.athdf(fname,quantities=['Bcc1'])\\n bx = data['Bcc1']\\n time,data=ath.athdf(fname,quantities=['Bcc2'])\\n by = data['Bcc2']\\n time,data=ath.athdf(fname,quantities=['Bcc3'])\\n bz = data['Bcc3']\\n x = data['x1f']\\n y = data['x2f']\\n z = data['x3f']\\n # refinement\\n rfac = 1.0\\n ##if bx.shape[0] < 512:\\n ## nz,ny,nx = bx.shape\\n ## rfac = int(512/bx.shape[0])\\n ## bx = np.repeat(bx,rfac,axis=0)\\n ## bx = np.repeat(bx,rfac,axis=1)\\n ## bx = np.repeat(bx,rfac,axis=2)\\n ## by = np.repeat(by,rfac,axis=0)\\n ## by = np.repeat(by,rfac,axis=1)\\n ## by = np.repeat(by,rfac,axis=2)\\n ## bz = np.repeat(bz,rfac,axis=0)\\n ## bz = np.repeat(bz,rfac,axis=1)\\n ## bz = np.repeat(bz,rfac,axis=2)\\n # ---\\n def curl(vx,vy,vz,dx,dy,dz):\\n [dzvx,dyvx,dxvx] = np.gradient(vx)\\n [dzvy,dyvy,dxvy] = np.gradient(vy)\\n [dzvz,dyvz,dxvz] = np.gradient(vz)\\n cx = dyvz/dy-dzvy/dz\\n cy = dzvx/dz-dxvz/dx\\n cz = dxvy/dx-dyvx/dy\\n # No need to del the reference by one manually\\n # allow python to perform its own garbage collection\\n # after the function return cxyz\\n #del dzvx\\n #del dzvy\\n #del dzvz\\n return cx,cy,cz\\n # ---\\n dx = dz = (x[1]-x[0])/rfac\\n dy = (y[1]-y[0])/rfac\\n jx,jy,jz = curl(bx,by,bz,dx,dy,dz)\\n j2 = jx**2+jy**2+jz**2\\n return j2\",\n \"def test_radar_request_site_historic_sweep_pcp_v_hdf5_yesterday(default_settings):\\n\\n timestamp = dt.datetime.utcnow() - dt.timedelta(days=1)\\n\\n request = DwdRadarValues(\\n parameter=DwdRadarParameter.SWEEP_PCP_VELOCITY_H,\\n start_date=timestamp,\\n site=DwdRadarSite.BOO,\\n fmt=DwdRadarDataFormat.HDF5,\\n subset=DwdRadarDataSubset.SIMPLE,\\n settings=default_settings,\\n )\\n results = list(request.query())\\n\\n if len(results) == 0:\\n raise pytest.skip(\\\"Data currently not available\\\")\\n\\n # Verify number of elements.\\n assert len(results) == 1\\n\\n # Get payload.\\n buffer = results[0][1]\\n payload = buffer.getvalue()\\n\\n # Verify data.\\n assert payload.startswith(b\\\"\\\\x89HDF\\\\r\\\\n\\\")\\n\\n # Verify more details.\\n # h5dump ras07-stqual-pcpng01_sweeph5onem_vradh_00-2020093000403400-boo-10132-hd5\\n\\n hdf = h5py.File(buffer, \\\"r\\\")\\n\\n assert hdf[\\\"/how/radar_system\\\"] is not None\\n assert hdf[\\\"/how\\\"].attrs.get(\\\"task\\\") == b\\\"Sc_Pcp-NG-01_BOO\\\"\\n assert hdf[\\\"/what\\\"].attrs.get(\\\"source\\\") == b\\\"WMO:10132,NOD:deboo\\\"\\n\\n assert hdf[\\\"/how\\\"].attrs.get(\\\"scan_count\\\") == 1\\n assert hdf[\\\"/dataset1/how\\\"].attrs.get(\\\"scan_index\\\") == 1\\n\\n assert hdf[\\\"/dataset1/data1/data\\\"].shape in ((360, 600), (359, 600), (358, 600), (357, 600))\\n\\n timestamp = round_minutes(request.start_date, 5)\\n assert hdf[\\\"/what\\\"].attrs.get(\\\"date\\\") == bytes(timestamp.strftime(\\\"%Y%m%d\\\"), encoding=\\\"ascii\\\")\\n assert hdf[\\\"/what\\\"].attrs.get(\\\"time\\\").startswith(bytes(timestamp.strftime(\\\"%H%M\\\"), encoding=\\\"ascii\\\"))\",\n \"def test_Lueker_Data_Csys(self):\\n ld = pd.read_csv(\\n \\\"tests/test_data/Lueker2000/Lueker2000_Table3.csv\\\", comment=\\\"#\\\"\\n )\\n\\n # Calculate using cbsys\\n # TA from DIC and fCO2\\n cTA = Csys(\\n DIC=ld.DIC.values,\\n fCO2=ld.fCO2.values,\\n T_in=ld.Temp.values,\\n S_in=ld.Sal.values,\\n )\\n dTA = ld.TA - cTA.TA\\n dTA_median = np.median(dTA)\\n dTA_pc95 = np.percentile(dTA, [2.5, 97.5])\\n self.assertLessEqual(abs(dTA_median), 2.5, msg=\\\"TA Offset <= 2.5\\\")\\n self.assertTrue(all(abs(dTA_pc95 - dTA_median) <= 16), msg=\\\"TA 95% Conf <= 16\\\")\\n\\n # fCO2 from TA and DIC\\n cfCO2 = Csys(\\n TA=ld.TA.values, DIC=ld.DIC.values, T_in=ld.Temp.values, S_in=ld.Sal.values\\n )\\n dfCO2 = ld.fCO2 - cfCO2.fCO2\\n dfCO2_median = np.median(dfCO2)\\n # dfCO2_pc95 = np.percentile(dfCO2, [2.5, 97.5])\\n dfCO2_percent_offset = 100 * dfCO2 / ld.fCO2\\n self.assertLessEqual(dfCO2_median, 2.5, msg=\\\"fCO2 Offset <= 2.5\\\")\\n self.assertLessEqual(np.std(dfCO2_percent_offset), 3, msg=\\\"fCO2 STD within 3%\\\")\\n # print(dfCO2_pc95)\\n # self.assertTrue(all(abs(dfCO2_pc95) <= 70), msg='fCO2 95% Conc <= 70')\\n\\n # DIC from TA and fCO2\\n cDIC = Csys(\\n TA=ld.TA.values,\\n fCO2=ld.fCO2.values,\\n T_in=ld.Temp.values,\\n S_in=ld.Sal.values,\\n )\\n dDIC = ld.DIC - cDIC.DIC\\n dDIC_median = np.median(dDIC)\\n dDIC_pc95 = np.percentile(dDIC, [2.5, 97.5])\\n self.assertLessEqual(abs(dDIC_median), 2, msg=\\\"DIC Offset <= 2\\\")\\n self.assertTrue(all(abs(dDIC_pc95) <= 15), msg=\\\"DIC 95% Conc <= 15\\\")\\n\\n return\",\n \"def test_sky_coord_classic(self):\\n sc_cen = SkyCoord(SCS_CENTER)\\n tab = conesearch.conesearch(\\n sc_cen, SCS_RADIUS, catalog_db=self.url, verbose=self.verbose)\\n assert len(tab) > 0\",\n \"def test_GLODAPv2_Csys(self):\\n # load GLODAP data\\n gd = pd.read_csv(\\\"tests/test_data/GLODAP_data/GLODAPv2_pH_DIC_ALK_subset.csv\\\")\\n gd.dropna(\\n subset=[\\n \\\"phtsinsitutp\\\",\\n \\\"temperature\\\",\\n \\\"salinity\\\",\\n \\\"tco2\\\",\\n \\\"talk\\\",\\n \\\"pressure\\\",\\n \\\"phosphate\\\",\\n \\\"silicate\\\",\\n ],\\n inplace=True,\\n )\\n gd.pressure /= 10 # convert pressure to bar\\n\\n # set negative nutrient values to zero\\n gd.phosphate[gd.phosphate < 0] = 0\\n gd.silicate[gd.silicate < 0] = 0\\n \\n # exclude weird cruise 270 data\\n gd = gd.loc[gd.cruise != 270]\\n\\n # calculate pH from TA and DIC\\n cpH = Csys(\\n TA=gd.talk,\\n DIC=gd.tco2,\\n T_in=gd.temperature,\\n S_in=gd.salinity,\\n P_in=gd.pressure,\\n PT=gd.phosphate,\\n SiT=gd.silicate,\\n BT=415.7,\\n )\\n pH_resid = gd.phtsinsitutp - cpH.pHtot\\n pH_median = np.median(pH_resid)\\n pH_pc95 = np.percentile(pH_resid, [2.5, 97.5])\\n\\n self.assertLessEqual(abs(pH_median), 0.005, msg=\\\"pH Offset <= 0.005\\\")\\n self.assertTrue(all(abs(pH_pc95) <= 0.05), msg=\\\"pH 95% Conf <= 0.05\\\")\\n\\n # calculate TA from pH and DIC\\n cTA = Csys(\\n pHtot=gd.phtsinsitutp,\\n DIC=gd.tco2,\\n T_in=gd.temperature,\\n S_in=gd.salinity,\\n P_in=gd.pressure,\\n PT=gd.phosphate,\\n SiT=gd.silicate,\\n BT=415.7,\\n )\\n TA_resid = gd.talk - cTA.TA\\n TA_median = np.median(TA_resid)\\n TA_pc95 = np.percentile(TA_resid, [2.5, 97.5])\\n\\n self.assertLessEqual(abs(TA_median), 0.5, msg=\\\"TA Offset <= 0.5\\\")\\n self.assertTrue(all(abs(TA_pc95) < 13), msg=\\\"TA 95% Conf <= 13\\\")\\n\\n # calculate DIC from TA and pH\\n cDIC = Csys(\\n pHtot=gd.phtsinsitutp,\\n TA=gd.talk,\\n T_in=gd.temperature,\\n S_in=gd.salinity,\\n P_in=gd.pressure,\\n PT=gd.phosphate,\\n SiT=gd.silicate,\\n BT=415.7,\\n )\\n DIC_resid = gd.tco2 - cDIC.DIC\\n DIC_median = np.median(DIC_resid)\\n DIC_pc95 = np.percentile(DIC_resid, [2.5, 97.5])\\n\\n self.assertLessEqual(abs(DIC_median), 0.5, msg=\\\"DIC Offset <= 0.5\\\")\\n self.assertTrue(all(abs(DIC_pc95) < 13), msg=\\\"DIC 95% Conf <= 13\\\")\\n\\n return\",\n \"def create_output_database():\\n\\n# Do not alter the hdf5 file if it already exists\\n if os.path.exists(database_path):\\n print(\\\"DATABASE STATUS:\\\")\\n print(\\\"\\\\t\\\" + database_path + \\\" already exists and is ready to store the results of computations\\\")\\n return None\\n# Create hdf5 file. The flag \\\"-w\\\" means \\\"create file, fail if exists\\\" \\n else:\\n computations_database = h5py.File(database_path, \\\"w-\\\")\\n\\n# Create initial data datasets and write initial data into them \\n for initial_condition in initial_conditions:\\n for k in range (6,17):\\n dataset_initial_path = initial_condition + \\\"/k = \\\" + str(k) + \\\" initial_data\\\"\\n computations_database[dataset_initial_path] = initial_data(initial_condition, k)\\n# Create data groups for storing the results of computations \\n for flux in fluxes: \\n group_path = initial_condition + \\\"/\\\" + flux\\n computations_database.create_group(group_path)\\n\\n# Write the appropriate attributes that are needed for particular computations, \\n# i.e. create the appropriate environment for each computational method \\n computations_database[group_path].attrs[\\\"a\\\"] = 3.0\\n computations_database[group_path].attrs[\\\"T\\\"] = 9.0\\n if flux == \\\"Lax_Wendroff_Fourth_Order\\\": \\n computations_database[group_path].attrs[\\\"CFL\\\"] = 0.2\\n elif flux in [\\\"Fromm_CFL_0.5\\\", \\\"Fromm_van_Leer_CFL_0.5\\\"]:\\n computations_database[group_path].attrs[\\\"CFL\\\"] = 0.5\\n else:\\n computations_database[group_path].attrs[\\\"CFL\\\"] = 0.9\\n \\n computations_database.close() \\n print(\\\"DATABASE STATUS:\\\")\\n print(\\\"\\\\t\\\" + database_path + \\\" has been created and is ready to store the results of computations\\\")\",\n \"def ncwrt_retrieval_config( retr_setup, outname=None ):\\n\\n #-- set name of file to be generated\\n act_outname = outname if outname!=None else 'retrconfig.nc'\\n msg = \\\"Start writing configuration file ***{}***...\\\".format(act_outname)\\n FileLogger.info(msg)\\n\\n\\n #-- compression settings\\n zlev = retr_setup.zlev\\n use_zlib = retr_setup.use_zlib\\n\\n #--\\n schedule_dct = retr_setup.schedule_dct\\n statevector = retr_setup.prstate\\n #-- turn list into array\\n sim_typ = np.array(schedule_dct['sim_typ'], dtype=np.int32)\\n timepts = schedule_dct['date_utc']\\n nstvar,npts = statevector.shape\\n #-- overpass geometries SZA,SAA,VZA,VAA\\n ivgeom = np.empty((npts,4), dtype=np.float64)\\n ivgeom[:,0] = schedule_dct['sza']\\n ivgeom[:,1] = schedule_dct['saa']\\n ivgeom[:,2] = schedule_dct['vza']\\n ivgeom[:,3] = schedule_dct['vaa']\\n\\n #-- temporal settings, create time-values (time-since)\\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\\n time_values = nc4.date2num(timepts, time_unit)\\n\\n #-- ensure directory exists\\n mkdirp_smart(os.path.dirname(act_outname))\\n\\n #-- open file pointer\\n ncfp = nc4.Dataset(act_outname, 'w')\\n #-- add dimensions\\n d1 = ncfp.createDimension('npoints',npts)\\n d2 = ncfp.createDimension('ngeo',4)\\n\\n #-- time-value\\n ncvar = ncfp.createVariable( 'time', statevector.dtype, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('standard_name','time')\\n ncvar.setncattr('long_name','time')\\n ncvar.setncattr('units', time_unit)\\n ncvar[:] = time_values[:]\\n\\n #-- simulation type\\n ncvar = ncfp.createVariable( 'sim_typ', sim_typ.dtype, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar[:] = sim_typ[:]\\n ncvar.setncattr('long_name','simulation_type')\\n ncvar.setncattr('comment', 'integer value which is to be bit-interpreted')\\n ncvar.setncattr('nobits_set', 'time-point with other state')\\n ncvar.setncattr('bit0_is_set', 'time-point for S1 simulation')\\n ncvar.setncattr('bit1_is_set', 'time-point for S2 simulation')\\n ncvar.setncattr('bit2_is_set', 'time-point for S1A simulation')\\n ncvar.setncattr('bit3_is_set', 'time-point for S1B simulation')\\n ncvar.setncattr('bit4_is_set', 'time-point for S2A simulation')\\n ncvar.setncattr('bit5_is_set', 'time-point for S2B simulation')\\n \\n #-- illumination-view geometry\\n ncvar = ncfp.createVariable( 'ivgeom', ivgeom.dtype, ('npoints','ngeo'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('sza','igeo: 0')\\n ncvar.setncattr('saa','igeo: 1')\\n ncvar.setncattr('vza','igeo: 2')\\n ncvar.setncattr('vaa','igeo: 3')\\n ncvar[:,:] = ivgeom[:,:]\\n \\n #-- global attributes\\n ncfp.setncattr('creator_name',\\\"The Inversion Lab, Hamburg, Germany\\\")\\n ncfp.setncattr('creator_email', \\\"Michael.Vossbeck(at)Inversion-Lab.com\\\")\\n ncfp.setncattr('netcdf_libversion',\\\"{}\\\".format(nc4.__netcdf4libversion__))\\n ncfp.setncattr('date_created',\\\"{}\\\".format(dt.datetime.utcnow().isoformat()))\\n ncfp.setncattr('time_coverage_start',time_coverage_start)\\n ncfp.setncattr('time_coverage_end',time_coverage_end)\\n\\n #-- close file pointer\\n ncfp.close()\\n\\n # logging\\n msg = \\\"...writing ***{}*** DONE\\\".format(act_outname)\\n FileLogger.info(msg)\",\n \"def test_NeuroPath1(self):\\n \\n self.delayDisplay(\\\"Starting the test\\\")\\n #\\n # first, get some data\\n #\\n import urllib\\n downloads = (\\n ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolume),\\n )\\n \\n for url,name,loader in downloads:\\n filePath = slicer.app.temporaryPath + '/' + name\\n if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:\\n logging.info('Requesting download %s from %s...\\\\n' % (name, url))\\n urllib.urlretrieve(url, filePath)\\n if loader:\\n logging.info('Loading %s...' % (name,))\\n loader(filePath)\\n self.delayDisplay('Finished with download and loading')\\n \\n volumeNode = slicer.util.getNode(pattern=\\\"FA\\\")\\n logic = NeuroPathLogic()\\n self.assertTrue( logic.hasImageData(volumeNode) )\\n self.delayDisplay('Test passed!')\",\n \"def test_run_read(self):\\n\\n self.ictrl[0] = 1 + 2 + 4 + 8\\n vmec_f90wrap.runvmec(self.ictrl, self.filename, self.verbose, \\\\\\n self.fcomm, reset_file)\\n\\n self.assertTrue(self.ictrl[1] in success_codes)\\n\\n self.assertEqual(vmec_f90wrap.vmec_input.nfp, 3)\\n self.assertEqual(vmec_f90wrap.vmec_input.mpol, 4)\\n self.assertEqual(vmec_f90wrap.vmec_input.ntor, 3)\\n print('rbc.shape:', vmec_f90wrap.vmec_input.rbc.shape)\\n print('rbc:',vmec_f90wrap.vmec_input.rbc[101:103, 0:4])\\n\\n # n = 0, m = 0:\\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.rbc[101,0], 1.3782)\\n\\n # n = 0, m = 1:\\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.zbs[101,1], 4.6465E-01)\\n\\n # n = 1, m = 1:\\n self.assertAlmostEqual(vmec_f90wrap.vmec_input.zbs[102,1], 1.6516E-01)\\n\\n # Now try reading in the output\\n wout_file = os.path.join(os.path.dirname(__file__), 'wout_li383_low_res.nc')\\n ierr = 0\\n vmec_f90wrap.read_wout_mod.read_wout_file(wout_file, ierr)\\n self.assertEqual(ierr, 0)\\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.betatot, \\\\\\n 0.0426215030653306, places=4)\\n\\n print('iotaf.shape:',vmec_f90wrap.read_wout_mod.iotaf.shape)\\n print('rmnc.shape:',vmec_f90wrap.read_wout_mod.rmnc.shape)\\n\\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.iotaf[-1], \\\\\\n 0.654868168783638, places=4)\\n\\n self.assertAlmostEqual(vmec_f90wrap.read_wout_mod.rmnc[0, 0], \\\\\\n 1.4773028173065, places=4)\",\n \"def test_h5file(dl2_shower_geometry_file):\\n from ctapipe.io.tableloader import TableLoader\\n\\n # no input raises error\\n with pytest.raises(ValueError):\\n with TableLoader():\\n pass\\n\\n # test we can use an already open file\\n with tables.open_file(dl2_shower_geometry_file, mode=\\\"r+\\\") as h5file:\\n with TableLoader(h5file=h5file) as loader:\\n assert 25 in loader.subarray.tel\\n loader.read_subarray_events()\\n loader.read_telescope_events()\",\n \"def _write_nemo_hr_file(rpn_hr_ds_path, nemo_hr_ds_path):\\n with xarray.open_dataset(rpn_hr_ds_path) as rpn_hr:\\n logging.debug(\\n f\\\"calculating specific humidity & incoming longwave radiation from {rpn_hr_ds_path}\\\"\\n )\\n qair, ilwr, rh = _calc_qair_ilwr(rpn_hr)\\n u_out, v_out = _rotate_winds(rpn_hr)\\n data_vars = {\\n \\\"nav_lon\\\": rpn_hr.nav_lon,\\n \\\"nav_lat\\\": rpn_hr.nav_lat,\\n # [:, 0] drops z dimension that NEMO will not tolerate\\n \\\"qair\\\": qair[:, 0],\\n \\\"RH_2maboveground\\\": rh[:, 0],\\n \\\"therm_rad\\\": ilwr[:, 0],\\n \\\"u_wind\\\": u_out[:, 0],\\n \\\"v_wind\\\": v_out[:, 0],\\n # \\\"LHTFL_surface\\\": ** needs to be calculated**,\\n }\\n nemo_rpn_vars = (\\n (\\\"atmpres\\\", \\\"PN\\\"),\\n (\\\"percentcloud\\\", \\\"NT\\\"),\\n (\\\"PRATE_surface\\\", \\\"RT\\\"),\\n (\\\"precip\\\", \\\"PR\\\"),\\n (\\\"solar\\\", \\\"FB\\\"),\\n (\\\"tair\\\", \\\"TT\\\"),\\n )\\n missing_vars = \\\"\\\"\\n for nemo_var, rpn_var in nemo_rpn_vars:\\n try:\\n # [:, 0] drops z dimension that NEMO will not tolerate\\n data_vars.update({nemo_var: getattr(rpn_hr, rpn_var)[:, 0]})\\n except AttributeError:\\n # Variable is missing from RPN dataset, so provide a placeholder DataArray\\n # full of NaNs that we will deal with later via interpolation\\n data_vars.update(\\n {nemo_var: xarray.DataArray(numpy.full_like(qair[:, 0], numpy.nan))}\\n )\\n missing_vars = (\\n \\\", \\\".join((missing_vars, nemo_var)) if missing_vars else nemo_var\\n )\\n logging.warning(f\\\"missing RPN variable {rpn_var} from {rpn_hr_ds_path}\\\")\\n nemo_hr = xarray.Dataset(\\n data_vars=data_vars, coords=rpn_hr.coords, attrs=rpn_hr.attrs\\n )\\n nemo_hr.attrs[\\\"history\\\"] += (\\n f\\\"\\\\n{arrow.now().format('ddd MMM DD HH:mm:ss YYYY')}: \\\"\\n f\\\"Add specific and relative humidity and incoming longwave radiation variables from \\\"\\n f\\\"correlations\\\"\\n )\\n if missing_vars:\\n nemo_hr.attrs[\\\"missing_variables\\\"] = missing_vars\\n _add_vars_metadata(nemo_hr)\\n _write_netcdf_file(nemo_hr, nemo_hr_ds_path)\",\n \"def test_imsim():\\n import yaml\\n import astropy.units as u\\n import matplotlib.pyplot as plt\\n from tqdm import tqdm\\n # Need these for `eval` below\\n from numpy import array\\n import coord\\n\\n with open(DATA_DIR / \\\"wcs_466749.yaml\\\", 'r') as f:\\n wcss = yaml.safe_load(f)\\n\\n cmds = {}\\n with open(DATA_DIR / \\\"phosim_cat_466749.txt\\\", 'r') as f:\\n for line in f:\\n k, v = line.split()\\n try:\\n v = int(v)\\n except ValueError:\\n try:\\n v = float(v)\\n except ValueError:\\n pass\\n cmds[k] = v\\n\\n # Values below (and others) from phosim_cat_466749.txt\\n rc = cmds['rightascension']\\n dc = cmds['declination']\\n boresight = galsim.CelestialCoord(\\n rc*galsim.degrees,\\n dc*galsim.degrees\\n )\\n obstime = Time(cmds['mjd'], format='mjd', scale='tai')\\n obstime -= 15*u.s\\n band = \\\"ugrizy\\\"[cmds['filter']]\\n wavelength_dict = dict(\\n u=365.49,\\n g=480.03,\\n r=622.20,\\n i=754.06,\\n z=868.21,\\n y=991.66\\n )\\n wavelength = wavelength_dict[band]\\n camera = imsim.get_camera()\\n\\n rotTelPos = cmds['rottelpos'] * galsim.degrees\\n telescope = imsim.load_telescope(f\\\"LSST_{band}.yaml\\\", rotTelPos=rotTelPos)\\n # Ambient conditions\\n # These are a guess.\\n temperature = 293.\\n pressure = 69.0\\n H2O_pressure = 1.0\\n\\n # Start by constructing a refractionless factory, which we can use to\\n # cross-check some of the other values in the phosim cmd file.\\n factory = imsim.BatoidWCSFactory(\\n boresight, obstime, telescope, wavelength,\\n camera,\\n temperature=temperature,\\n pressure=0.0,\\n H2O_pressure=H2O_pressure\\n )\\n\\n aob, zob, hob, dob, rob, eo = factory._ICRF_to_observed(\\n boresight.ra.rad, boresight.dec.rad, all=True\\n )\\n np.testing.assert_allclose(\\n np.rad2deg(aob)*3600, cmds['azimuth']*3600,\\n rtol=0, atol=2.0\\n )\\n np.testing.assert_allclose(\\n (90-np.rad2deg(zob))*3600, cmds['altitude']*3600,\\n rtol=0, atol=6.0,\\n )\\n q = factory.q * galsim.radians\\n rotSkyPos = rotTelPos - q\\n # Hmmm.. Seems like we ought to be able to do better than 30 arcsec on the\\n # rotator? Maybe this is defined at a different point in time? Doesn't seem\\n # to affect the final WCS much though.\\n np.testing.assert_allclose(\\n rotSkyPos.deg*3600, cmds['rotskypos']*3600,\\n rtol=0, atol=30.0,\\n )\\n\\n # We accidentally simulated DC2 with the camera rotated 180 degrees too far.\\n # That includes the regression test data here. So to fix the WCS code, but\\n # still use the same regression data, we need to add 180 degrees here. Just\\n # rotate the camera by another 180 degrees\\n telescope = telescope.withLocallyRotatedOptic(\\n \\\"LSSTCamera\\\", batoid.RotZ(np.deg2rad(180))\\n )\\n\\n # For actual WCS check, we use a factory that _does_ know about refraction.\\n factory = imsim.BatoidWCSFactory(\\n boresight, obstime, telescope, wavelength,\\n camera,\\n temperature=temperature,\\n pressure=pressure,\\n H2O_pressure=H2O_pressure\\n )\\n\\n do_plot = False\\n my_centers = []\\n imsim_centers = []\\n if do_plot:\\n _, ax = plt.subplots(nrows=1, ncols=1, figsize=(12, 12))\\n i = 0\\n r1 = []\\n d1 = []\\n r2 = []\\n d2 = []\\n rng = np.random.default_rng(1234)\\n for k, v in tqdm(wcss.items()):\\n name = k[18:25].replace('-', '_')\\n det = camera[name]\\n cpix = det.getCenter(cameraGeom.PIXELS)\\n\\n wcs = factory.getWCS(det, order=2)\\n wcs1 = eval(v)\\n # Need to adjust ab parameters to new GalSim convention\\n wcs1.ab[0,1,0] = 1.0\\n wcs1.ab[1,0,1] = 1.0\\n\\n my_centers.append(wcs.posToWorld(galsim.PositionD(cpix.x, cpix.y)))\\n imsim_centers.append(wcs1.posToWorld(galsim.PositionD(cpix.x, cpix.y)))\\n\\n corners = det.getCorners(cameraGeom.PIXELS)\\n xs = np.array([corner.x for corner in corners])\\n ys = np.array([corner.y for corner in corners])\\n ra1, dec1 = wcs.xyToradec(xs, ys, units='radians')\\n ra2, dec2 = wcs1.xyToradec(xs, ys, units='radians')\\n if i == 0:\\n labels = ['batoid', 'PhoSim']\\n else:\\n labels = [None]*2\\n if do_plot:\\n ax.plot(ra1, dec1, c='r', label=labels[0])\\n ax.plot(ra2, dec2, c='b', label=labels[1])\\n\\n # add corners to ra/dec check lists\\n r1.extend(ra1)\\n d1.extend(dec1)\\n r2.extend(ra2)\\n d2.extend(dec2)\\n # Add some random points as well\\n xs = rng.uniform(0, 4000, 100)\\n ys = rng.uniform(0, 4000, 100)\\n ra1, dec1 = wcs.xyToradec(xs, ys, units='radians')\\n ra2, dec2 = wcs1.xyToradec(xs, ys, units='radians')\\n r1.extend(ra1)\\n d1.extend(dec1)\\n r2.extend(ra2)\\n d2.extend(dec2)\\n i += 1\\n\\n if do_plot:\\n ax.legend()\\n xlim = ax.get_xlim()\\n ax.set_xlim(xlim[1], xlim[0])\\n plt.show()\\n\\n dist = sphere_dist(r1, d1, r2, d2)\\n print(\\\"sphere dist mean, max, std\\\")\\n print(\\n np.rad2deg(np.mean(dist))*3600,\\n np.rad2deg(np.max(dist))*3600,\\n np.rad2deg(np.std(dist))*3600,\\n )\\n np.testing.assert_array_less(\\n np.rad2deg(np.mean(dist))*3600,\\n 5.0\\n )\\n if do_plot:\\n plt.hist(np.rad2deg(dist)*3600, bins=100)\\n plt.show()\\n\\n if do_plot:\\n r1 = np.array([c.ra.rad for c in my_centers])\\n d1 = np.array([c.dec.rad for c in my_centers])\\n r2 = np.array([c.ra.rad for c in imsim_centers])\\n d2 = np.array([c.dec.rad for c in imsim_centers])\\n cd = np.cos(np.deg2rad(cmds['declination']))\\n q = plt.quiver(r1, d1, np.rad2deg(r1-r2)*3600*cd, np.rad2deg(d1-d2)*3600)\\n plt.quiverkey(q, 0.5, 1.1, 5.0, \\\"5 arcsec\\\", labelpos='E')\\n plt.show()\",\n \"def write_cfradial(output_filename, start_dt, minutes, timeres_s = 5, \\n altres_m =60, maxtimeslice_td=datetime.timedelta(seconds=30*60), \\n instrument='gvhsrl', min_alt_m=0, max_alt_m=5000,store_calibrations=False):\\n\\n cdl = locate_file('hsrl_cfradial.cdl', forModule=lgtb)\\n print 'CDL = ', cdl\\n timeres_td = datetime.timedelta(seconds=timeres_s)\\n\\n netcdf = Dataset(output_filename, 'w', clobber=True)\\n delta = datetime.timedelta(minutes=minutes)\\n timeres_delta = datetime.timedelta(seconds=timeres_s)\\n end_dt = start_dt + delta\\n\\n gen = dpl_hsrl(instrument)\\n\\n if store_calibrations: # to store calibrations, newer actors are needed, as well as the precall methods (FIXME better design)\\n import maestro.netcdf_precall as npc\\n args=[]\\n kwargs=dict(output=netcdf,template=cdl,usecfradial=True,basetime=start_dt)\\n x=npc.addConstantsToParms(npc.addCalibrationsToNetCDF())\\n hsrlnar=gen(start_dt, end_dt, timeres_timedelta=timeres_delta, min_alt_m=min_alt_m, max_alt_m=max_alt_m, altres_m=altres_m)\\n x(hsrlnar,args,kwargs)\\n nar=artists.dpl_netcdf_artist(hsrlnar,*args,**kwargs)\\n #framestream,template,outputfilename=None,format=None,usecfradial=None,selected_bindings=None,output=None,forModule=None,withUnlimited=None,basetime=None,addAttributes={}):\\n for x in nar:\\n pass\\n else:\\n v = None\\n try:\\n # store each lidar record\\n for tzg in gen(start_dt, end_dt, timeres_timedelta=timeres_delta, min_alt_m=min_alt_m, max_alt_m=max_alt_m, altres_m=altres_m):\\n if v == None:\\n v = cfr.DplCreateCfradial(cdl, netcdf, tzg)\\n v.append_data(tzg)\\n\\n v.close()\\n\\n except RuntimeError, msg:\\n print msg\\n traceback.print_exc()\\n print 'write_cfradial: could not process data for %s starting at %s' % \\\\\\n (instrument, start_dt.strftime('%Y-%m-%d %H:%M:%S'))\",\n \"def read_dr3_spectrum(path, common_dispersion=None, bounds_error=False):\\n\\n header_keys = (\\\"helio_rv\\\", \\\"z\\\", \\\"z_err\\\")\\n\\n with fits.open(path) as image:\\n # data array indices:\\n # flux, inverse variance, wavelength, andmask, ormask.\\n flux, ivar, dispersion, and_mask, or_mask = image[0].data\\n\\n # Create a meta dictionary that contains things we will probably care \\n # about later on, and the path so that we can trace provenance of other\\n # things as needed.\\n meta = dict(path=path)\\n for header_key in header_keys:\\n meta[header_key] = image[0].header[header_key.upper()]\\n\\n # Use the OR mask to set the inverse variances to zero for any pixels with\\n # indications of being bad. For example, the bit mask meanings are:\\n # 1 : BADCCD : bad pixel on CCD\\n # 2 : BADPROFILE : bad profile in extraction\\n # 3 : NOSKY : no sky information at this wavelength\\n # 4 : BRIGHTSKY : sky level too high\\n # 5 : BADCENTER : fibre trace out of the CCD\\n # 6 : NODATA : no good data.\\n\\n # From http://dr3.lamost.org/doc/data-production-description\\n\\n # These are all bad things. And the LAMOST pipeline people are more familiar\\n # with the data than we are. So let's believe them.\\n\\n rest_dispersion = dispersion * (1 - meta[\\\"z\\\"])\\n ivar[or_mask > 0] = 0.0\\n\\n if common_dispersion is not None:\\n flux = (interpolate.interp1d(rest_dispersion, flux,\\n bounds_error=bounds_error, fill_value=1))(common_dispersion)\\n ivar = (interpolate.interp1d(rest_dispersion, ivar,\\n bounds_error=bounds_error, fill_value=0))(common_dispersion)\\n\\n rest_dispersion = common_dispersion\\n ivar[ivar < 0] = 0\\n\\n assert np.all(ivar >= 0), \\\"negative inverse variances\\\"\\n assert np.all(np.isfinite(flux)), \\\"non-finite fluxes\\\"\\n\\n return (rest_dispersion, flux, ivar, meta)\",\n \"def find_hrc_calib_obsid(inst):\\n##\\n##--- create a list of already processed data\\n##\\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/6* > '+ zspace\\n# os.system(cmd)\\n# with open(zspace, 'r') as f:\\n# ftest = f.read()\\n# wrd = str(inst) + '/61'\\n# mc = re.search(wrd, ftest)\\n# if mc is not None:\\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/61* >' + zspace\\n# os.system(cmd)\\n#\\n# cmd = 'ls -d /data/hrc/' + str(inst) + '/62* >' + zspace\\n# os.system(cmd)\\n#\\n# data = mcf.read_data_file(zspace, remove=1)\\n# prev_list = []\\n# for ent in data:\\n# atemp = re.split('\\\\/', ent)\\n# prev_list.append(int(float(atemp[-1])))\\n#\\n##\\n##--- find today's date and set checking range for the last 30 days\\n##\\n# today = time.strftime('%Y:%j:%H:%M:%S', time.gmtime())\\n# today = int(Chandra.Time.DateTime(today).secs)\\n# start = today - 10 * 86400\\n##\\n##--- extract hrc obsid information\\n##\\n# line = 'operation=browse\\\\n'\\n# line = line + 'dataset=flight\\\\n'\\n# line = line + 'level=1\\\\n'\\n# line = line + 'detector=hrc\\\\n'\\n# line = line + 'filetype=evt1\\\\n'\\n# line = line + 'tstart=' + str(start) + '\\\\n'\\n# line = line + 'tstop=' + str(today) + '\\\\n'\\n# line = line + 'go\\\\n'\\n#\\n# with open('zline', 'w') as fo:\\n# fo.write(line)\\n#\\n# cmd = ' /proj/sot/ska/bin/arc5gl -user isobe -script zline > ' + zspace\\n# os.system(cmd)\\n#\\n# mcf.rm_files('./zline')\\n#\\n# data = mcf.read_data_file(zspace, remove=1)\\n##\\n##--- select obsids with 61* and 62* starting\\n##\\n# h_list = []\\n# for ent in data:\\n# mc = re.search('hrcf', ent)\\n# if mc is not None:\\n# atemp = re.split('hrcf', ent)\\n# btemp = re.split('_', atemp[1])\\n# obsid = int(float(btemp[0]))\\n# if obsid > 61000 and obsid < 63000:\\n##\\n##--- if it is already observed skip it\\n##\\n# if obsid in prev_list:\\n# continue\\n##\\n##--- check which instrument\\n##\\n# chk = check_inst(obsid)\\n# if chk == inst:\\n# h_list.append(obsid)\\n\\n\\n\\n h_list = ['62410', '62423', '62435', '62437', '62439', '62441', '62443', '62635', '62637', '62649', '62973', '62997', '62422', '62426', '62436', '62438', '62440', '62442', '62446', '62636', '62638', '62796', '62991']\\n\\n\\n return h_list\",\n \"def HD_input_sncosmo_data(self, sn_list):\\n\\n dico = cPickle.load(open(SUGAR_parameter_pkl))\\n self.read_sncosmo(path='../sugar_analysis_data/results/res_salt2_SNF_5_nomodelcov.txt')\\n self.read_meta()\\n self.read_snfit_results()\\n Filtre = np.array([True]*len(self.sncosmo_sn_name))\\n self.zcmb = []\\n self.z_err = []\\n for j, sn_name in enumerate(self.sncosmo_sn_name):\\n# if self.sncosmo_sn_name[j] in dico.keys():\\n#\\n# for i in range (len(self.meta_sn_name_list)):\\n# if self.sncosmo_sn_name[j] == self.meta_sn_name_list[i]:\\n# \\n# self.z_err.append(self.meta_zhl_err[i])\\n# self.zcmb.append(self.meta_zcmb[i])\\n# if np.abs(self.sncosmo_x1[j] - self.x1[i]) > 0.01:\\n# i print 'problem with %s include in sample but big difference between sncosmo and snfit'%(self.sncosmo_sn_name[j])\\n# else:\\n# Filtre[j] = False\\n if sn_name in sn_list:\\n Filtre[j] = True\\n else:\\n Filtre[j] = False\\n\\n for p in dico.keys():\\n if p not in self.sncosmo_sn_name:\\n print p\\n\\n self.sncosmo_x1 = self.sncosmo_x1[Filtre]\\n self.sncosmo_x1_err = self.sncosmo_x1_err[Filtre] \\n self.sncosmo_c = self.sncosmo_c[Filtre]\\n self.sncosmo_c_err = self.sncosmo_c_err[Filtre]\\n self.sncosmo_mb = self.sncosmo_mb[Filtre]\\n self.sncosmo_mb_err = self.sncosmo_mb_err[Filtre]\\n self.sncosmo_cov_x1_c = self.sncosmo_cov_x1_c[Filtre]\\n self.sncosmo_cov_mb_x1 = self.sncosmo_cov_mb_x1[Filtre]\\n self.sncosmo_cov_mb_c = self.sncosmo_cov_mb_c[Filtre]\\n self.sncosmo_z = self.sncosmo_z[Filtre]\\n self.zcmb = np.array(self.zcmb)\\n self.z_err = np.array(self.z_err)\\n\\n self.sncosmo_cov_y = np.zeros((len(self.sncosmo_mb)*3,len(self.sncosmo_mb)*3))\\n \\n for i in range (len(self.sncosmo_mb)):\\n self.sncosmo_cov_y[i*3,i*3] = self.sncosmo_mb_err[i]**2\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 1] = self.sncosmo_x1_err[i]**2\\n \\n self.sncosmo_cov_y[i*3+ 2,i*3+ 2] = self.sncosmo_c_err[i]**2\\n self.sncosmo_cov_y[i*3+ 0,i*3+ 1] = self.sncosmo_cov_mb_x1[i]\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 0] = self.sncosmo_cov_mb_x1[i]\\n self.sncosmo_cov_y[i*3+ 0,i*3+ 2] = self.sncosmo_cov_mb_c[i]\\n self.sncosmo_cov_y[i*3+ 2,i*3+ 0] = self.sncosmo_cov_mb_c[i]\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 2] = self.sncosmo_cov_x1_c[i] \\n self.sncosmo_cov_y[i*3+ 2,i*3+ 1] = self.sncosmo_cov_x1_c[i] \\n \\n self.salt_parm = np.array([self.sncosmo_mb,self.sncosmo_x1,self.sncosmo_c]).T\\n print len(self.salt_parm), len(self.sncosmo_cov_y), len(self.sncosmo_z), len(self.zcmb)\\n return self.salt_parm, self.sncosmo_cov_y, self.sncosmo_z, self.zcmb, self.z_err\",\n \"def consolidate(max_rounds, int_fwm,master_index, index, filename = 'data_large'):\\n\\n\\n layer_0 = '0/0'\\n filepath = 'output{}/output{}/data/'.format(master_index, index)\\n file_read = filepath + filename\\n file_save = filepath + filename+'_conc'\\n \\n # Input data, small, no need to cons\\n D = read_variables(file_read, '0/0')\\n save_variables(file_save, 'input', **D)\\n\\n if max_rounds ==0:\\n max_rounds +=1\\n U_cons = np.zeros([4,max_rounds, 7*int_fwm.nt], dtype = np.complex128)\\n # Reading of all the oscillating spectra and sending them to a 3D array\\n unfortmated_string = '{}/{}/U'\\n with h5py.File(file_read+'.hdf5', 'r') as f:\\n for pop in range(1,5):\\n for r in range(max_rounds):\\n U_cons[pop - 1,r,:] = f.get(unfortmated_string.format(pop,r)).value\\n save_variables(file_save, 'results', U = U_cons) \\n os.system('mv '+file_save+'.hdf5 '+file_read+'.hdf5')\\n return None\",\n \"def test_real_file(self):\\n log.info('===== START TEST BYTE LOSS =====')\\n\\n # Recovered\\n file_path = os.path.join(RESOURCE_PATH, '11079364_SNA_SNA.txt')\\n\\n stream_handle = open(file_path, MODE_ASCII_READ)\\n\\n self.create_parser(stream_handle, telem_flag=False)\\n\\n particles = self.parser.get_records(182)\\n\\n log.debug(\\\"*** test_real_file Num particles %s\\\", len(particles))\\n\\n # check all the values against expected results.\\n self.assert_particles(particles, '11079364_SNA_SNA_recov.yml', RESOURCE_PATH)\\n self.assertEquals(self.exception_callback_value, [])\\n stream_handle.close()\\n\\n # Telemetered\\n file_path = os.path.join(RESOURCE_PATH, '11079419_SNA_SNA.txt')\\n\\n stream_handle = open(file_path, MODE_ASCII_READ)\\n\\n self.create_parser(stream_handle)\\n\\n particles = self.parser.get_records(172)\\n\\n log.debug(\\\"*** test_real_file Num particles %s\\\", len(particles))\\n\\n # check all the values against expected results.\\n self.assert_particles(particles, '11079419_SNA_SNA_telem.yml', RESOURCE_PATH)\\n stream_handle.close()\\n\\n log.info('===== END TEST REAL FILE =====')\",\n \"def test_header_update8(self, capsys):\\n\\n # Prepare input files.\\n self.get_data(\\\"input\\\", \\\"ocu252cmq_raw.fits\\\")\\n self.get_data(\\\"input\\\", \\\"ocu252cmq_spt.fits\\\")\\n\\n capsys.readouterr()\\n\\n tastis('ocu252cmq_raw.fits', update=True)\\n\\n captured = capsys.readouterr()\\n assert captured.out == \\\"===============================================================================\\\\n\\\" \\\\\\n \\\"ocu252cmq HST/STIS MIRVIS F28X50OII ACQ/POINT\\\\n\\\" \\\\\\n \\\"prop: 14143 visit: 52 line: 1 target: BD+41-3306\\\\n\\\" \\\\\\n \\\"obs date, time: 2016-06-06 08:30:05 exposure time: 2.10\\\\n\\\" \\\\\\n \\\"dom GS/FGS: N2JU001340F2 sub-dom GS/FGS: N2K1001229F1\\\\n\\\" \\\\\\n \\\"ACQ params: bias sub: 1510 checkbox: 3 method: FLUX CENTROID\\\\n\\\" \\\\\\n \\\"subarray (axis1,axis2): size=(100,100) corner=(487,466)\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"Coarse locate phase: Target flux in max checkbox (DN): 1442\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" global local\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2\\\\n\\\" \\\\\\n \\\"Target location: 527.8 513.1 41.8 48.1\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2 V2 V3\\\\n\\\" \\\\\\n \\\" (pixels) (arcsec) (arcsec)\\\\n\\\" \\\\\\n \\\"Estimated slew: -7.9 -2.9 -0.400 -0.147 -0.387 -0.179\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"Fine locate phase: Target flux in max checkbox (DN): 611\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" global local\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2\\\\n\\\" \\\\\\n \\\"Target location: 534.1 516.1 48.1 51.1\\\\n\\\" \\\\\\n \\\"Ref ap location: 537.5 516.5 19.5 16.5\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2 V2 V3\\\\n\\\" \\\\\\n \\\" (pixels) (arcsec) (arcsec)\\\\n\\\" \\\\\\n \\\"Estimated slew: -2.1 -0.4 -0.106 -0.020 -0.089 -0.061\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"Total est. slew: -10.0 -3.3 -0.506 -0.168 -0.477 -0.239\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"The fluxes in the maximum checkbox in the fine and coarse stages differ\\\\n\\\" \\\\\\n \\\"by more than 25%. This may indicate a problem with your acquisition.\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\"===============================================================================\\\\n\\\"\\n\\n # Compare results\\n outputs = [(\\\"ocu252cmq_raw.fits\\\", \\\"ocu252cmq_raw_ref.fits\\\")]\\n self.compare_outputs(outputs)\",\n \"def read(files, save):\\n\\t# NOTE all soundings are size obs long, they must be filled in with zeros for this data format...\\n\\t# create the HDF5 document\\n\\tdoc = h5(save)\\n\\tsize = 450 # this hopefully exceeds the size of the arrays # CPIN Files are much shorter...\\n\\tdoc.create(pres=size, temp=size, dewpt=size, rh=size, r=size, u=size, v=size, z=size, lat=1, lon=1, theta=size, thte=size,\\n\\t\\twspd=size, wdir=size, gamma=size, stab=size, N=size, rich=size, thtdef=size, cpin=size)\\n\\t# those last two do not have to be included...\\n\\t# Z=geopotenital height\\n\\n\\t# now read the files!\\n\\tfor f in sorted(files):\\n\\t\\tfname = f.split('/')[-1]\\n\\t\\t# if 'smth' not in fname and NCAR not in fname: continue\\n\\t\\tl.info('reading ' + fname)\\n\\t\\t# launch time comes from line 2 of the file, the last element\\n\\t\\tdf = open(f, 'r')\\n\\t\\ttxt = df.read(2000).split('\\\\n') # way more than we need\\n\\t\\tdf.close()\\n\\t\\tlatln = txt[0].split() # keys 1,2 will be what we want\\n\\t\\ttry:\\n\\t\\t\\ttm = s2t(txt[1].split()[-1] + 'UTC', '%Y%m%d%H%M%Z')\\n\\t\\texcept:\\n\\t\\t\\t# drat.\\n\\t\\t\\tprint txt.split('\\\\n')[1]\\n\\t\\t\\tcontinue\\n\\t\\ttry:\\n\\t\\t\\tif 'cpin' in fname:\\n\\t\\t\\t\\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich, thtdef, cpin = np.loadtxt(f, skiprows=4, unpack=True)\\n\\t\\t\\t\\t# r is mixing ratio\\n\\t\\t\\telse:\\n\\t\\t\\t\\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich = np.loadtxt(f, skiprows=4, unpack=True)\\n\\t\\t\\t\\t# r is mixing ratio\\n\\t\\texcept:\\n\\t\\t\\tl.warning('This file could not be read')\\n\\t\\t\\tcontinue\\n\\n\\t\\t# and append this data! I will trust the time seconds, instead of recomputing the time\\n\\t\\t# but, before that, we have to make them all the same size - size long\\n\\t\\tnl = np.zeros(size - t.shape[0]) - 999.00 # -999 array to fluff the end\\n\\t\\tp = np.concatenate((p, nl))\\n\\t\\tt = np.concatenate((t, nl))\\n\\t\\ttd = np.concatenate((td, nl))\\n\\t\\trh = np.concatenate((rh, nl))\\n\\t\\tr = np.concatenate((r, nl))\\n\\t\\ttv = np.concatenate((tv, nl))\\n\\t\\ttht = np.concatenate((tht, nl))\\n\\t\\tthte = np.concatenate((thte, nl))\\n\\t\\tws = np.concatenate((ws, nl))\\n\\t\\twd = np.concatenate((wd, nl))\\n\\t\\tgamma = np.concatenate((gamma, nl))\\n\\t\\tstab = np.concatenate((stab, nl))\\n\\t\\tN = np.concatenate((N, nl))\\n\\t\\trich = np.concatenate((rich, nl))\\n\\t\\tu = np.concatenate((u, nl))\\n\\t\\tv = np.concatenate((v, nl))\\n\\t\\tz = np.concatenate((z, nl))\\n\\t\\tif 'cpin' in fname:\\n\\t\\t\\tcpin = np.concatenate((cpin, nl))\\n\\t\\t\\tthtdef = np.concatenate((thtdef, nl))\\n\\t\\t\\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\\n\\t\\t\\t\\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich, cpin=cpin, thtdef=thtdef)\\n\\t\\telse:\\n\\t\\t\\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\\n\\t\\t\\t\\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich)\\n\\tdoc.close()\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs\\\"\\n \\\"/lake_analysis_one_21_Jun_2021\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022\\\")\\n ref_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_flowtocell.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_catchments.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_catchments.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_rmouth_flowtocell.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_rmouth_flowtocell.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='default',\\n catchment_and_outflows_mods_list_filename=\\\\\\n None,\\n #additional_matches_list_filename=\\\\\\n #\\\"additional_matches_ice6g_vs_ice5g_lgm.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='HD')\",\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 retrieve_cloudmask(\\n self, output_binary=True, include_thermal_test=True, include_channel_r5=True\\n ):\\n\\n # Read visual near infrared (VNIR) channels at 15m resolution.\\n r1 = self.get_reflectance(channel=\\\"1\\\")\\n r2 = self.get_reflectance(channel=\\\"2\\\")\\n r3N = self.get_reflectance(channel=\\\"3N\\\")\\n\\n # Read short-wave infrared (SWIR) channels at 30m resolution and match\\n # VNIR resolution.\\n r5 = self.get_reflectance(channel=\\\"5\\\")\\n if self.datetime > datetime.datetime(2007, 5, 1) or not include_channel_r5:\\n # The SWIR sensor suffered from temperature problems after May\\n # 2007. Images later on are set to a dummy value \\\"1\\\", which won't\\n # influence the following thresholding tests. Swath edge NaN pixels\\n # stay NaN.\\n r5[~np.isnan(r5)] = 1\\n r5 = np.repeat(np.repeat(r5, 2, axis=0), 2, axis=1)\\n\\n # Read thermal (TIR) channel at 90m resolution and match VNIR\\n # resolution.\\n bt14 = self.get_brightnesstemperature(channel=\\\"14\\\")\\n bt14 = np.repeat(np.repeat(bt14, 6, axis=0), 6, axis=1)\\n\\n # Ratios for clear-cloudy-tests.\\n r3N2 = r3N / r2\\n r12 = r1 / r2\\n\\n ### TEST 1-4 ###\\n # Set cloud mask to default \\\"confidently clear\\\".\\n clmask = np.ones(r1.shape, dtype=np.float) * 2\\n\\n with np.warnings.catch_warnings():\\n np.warnings.filterwarnings(\\\"ignore\\\", r\\\"invalid value encountered\\\")\\n\\n # Set \\\"probably clear\\\" pixels.\\n clmask[\\n multiple_logical(\\n r3N > 0.03,\\n r5 > 0.01,\\n 0.7 < r3N2,\\n r3N2 < 1.75,\\n r12 < 1.45,\\n func=np.logical_and,\\n )\\n ] = PROBABLY_CLEAR\\n\\n # Set \\\"probably cloudy\\\" pixels.\\n clmask[\\n multiple_logical(\\n r3N > 0.03,\\n r5 > 0.015,\\n 0.75 < r3N2,\\n r3N2 < 1.75,\\n r12 < 1.35,\\n func=np.logical_and,\\n )\\n ] = PROBABLY_CLOUDY\\n\\n # Set \\\"confidently cloudy\\\" pixels\\n clmask[\\n multiple_logical(\\n r3N > 0.065,\\n r5 > 0.02,\\n 0.8 < r3N2,\\n r3N2 < 1.75,\\n r12 < 1.2,\\n func=np.logical_and,\\n )\\n ] = CONFIDENTLY_CLOUDY\\n\\n # Combine swath edge pixels.\\n clmask[\\n multiple_logical(\\n np.isnan(r1),\\n np.isnan(r2),\\n np.isnan(r3N),\\n np.isnan(r5),\\n func=np.logical_or,\\n )\\n ] = np.nan\\n\\n if include_thermal_test:\\n ### TEST 5 ###\\n # Uncertain warm ocean pixels, higher than the 5th percentile of\\n # brightness temperature values from all \\\"confidently clear\\\"\\n # labeled pixels, are overwritten with \\\"confidently clear\\\".\\n\\n # Check for available \\\"confidently clear\\\" pixels.\\n nc = np.sum(clmask == 2) / np.sum(~np.isnan(clmask))\\n if nc > 0.03:\\n bt14_p05 = np.nanpercentile(bt14[clmask == 2], 5)\\n else:\\n # If less than 3% of pixels are \\\"confidently clear\\\", test 5\\n # cannot be applied according to Werner et al., 2016. However,\\n # a sensitivity study showed that combining \\\"probably clear\\\"\\n # and \\\"confidently clear\\\" pixels in such cases leads to\\n # plausible results and we derive a threshold correspondingly.\\n bt14_p05 = np.nanpercentile(\\n bt14[np.logical_or(clmask == 2, clmask == 3)], 5\\n )\\n\\n with np.warnings.catch_warnings():\\n np.warnings.filterwarnings(\\\"ignore\\\", r\\\"invalid value encountered\\\")\\n # Pixels with brightness temperature values above the 5th\\n # percentile of clear ocean pixels are overwritten with\\n # \\\"confidently clear\\\".\\n clmask[np.logical_and(bt14 > bt14_p05, ~np.isnan(clmask))] = 2\\n\\n # Combine swath edge pixels.\\n clmask[np.logical_or(np.isnan(clmask), np.isnan(bt14))] = np.nan\\n\\n if output_binary:\\n clmask[np.logical_or(clmask == 2, clmask == 3)] = 0 # clear\\n clmask[np.logical_or(clmask == 4, clmask == 5)] = 1 # cloudy\\n\\n return clmask\",\n \"def ncwrt_retrieval_obs_s1(retr_setup, outname=None):\\n\\n #-- set name of file to be generated\\n act_outname = outname if outname!=None else 'obs_s1.nc'\\n msg = \\\"Start writing configuration file ***{}***...\\\".format(act_outname)\\n FileLogger.info(msg)\\n\\n #-- compression settings\\n zlev = retr_setup.zlev\\n use_zlib = retr_setup.use_zlib\\n\\n #-- retrieval settings\\n s1_table = retr_setup.obs_dct['S1']\\n timepts = s1_table.geom.date_utc\\n npts = len(timepts)\\n s1_satid = np.array(s1_table.sat_id_lst, dtype=str)\\n s1_data = s1_table.data\\n s1_dataunc = s1_table.dataunc\\n nt,npol = s1_data.shape\\n\\n #-- temporal settings, create time-values (time-since)\\n time_start, time_end = datelst_get_month_aligned_bounds(timepts)\\n time_coverage_start = time_start.strftime('%Y-%m-%dT%H:%M:%S')\\n time_coverage_end = time_end.strftime('%Y-%m-%dT%H:%M:%S')\\n ref_time = dt.datetime(timepts[0].year,1,1) #January1st in year of first point in time\\n time_unit = 'seconds since {}'.format(ref_time.strftime('%Y-%m-%dT%H:%M:%S'))\\n time_values = nc4.date2num(timepts, time_unit)\\n\\n #-- ensure directory exists\\n mkdirp_smart(os.path.dirname(act_outname))\\n\\n #-- open file pointer\\n ncfp = nc4.Dataset(act_outname, 'w')\\n #-- add dimensions\\n d1 = ncfp.createDimension('npoints',npts)\\n d2 = ncfp.createDimension('npol',npol)\\n\\n #-- time-value\\n ncvar = ncfp.createVariable( 'time', np.float64, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('standard_name','time')\\n ncvar.setncattr('long_name','time')\\n ncvar.setncattr('units', time_unit)\\n ncvar[:] = time_values[:]\\n\\n unit_one = np.float64(1)\\n # backscatter\\n ncvar = ncfp.createVariable( 'backscatter', np.float64, ('npoints','npol'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'backscatter in VH and VV polarisation')\\n comment = \\\"VH is associated to npol=0, VV to npol=1.\\\"\\n comment += \\\" linear units are used (not [dB]).\\\"\\n ncvar.setncattr('comment', comment)\\n ncvar.setncattr('units',unit_one)\\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\\n ncvar[:,:] = s1_data[:,:]\\n\\n # backscatter uncertainty\\n ncvar = ncfp.createVariable( 'backscatter_unc', np.float64, ('npoints','npol'),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'backscatter uncertainty in VH and VV polarisation')\\n comment = \\\"uniform uncertainty of {} [dB] was applied on the observed backscatter\\\".format(\\n retr_setup.s1_unc_db)\\n ncvar.setncattr('comment', comment)\\n ncvar.setncattr('units',unit_one)\\n ncvar.setncattr('missing_value', retr_setup.obs_fill_value)\\n ncvar[:,:] = s1_dataunc[:,:]\\n\\n # satellite identifier\\n ncvar = ncfp.createVariable( 'satellite_id', str, ('npoints',),\\n zlib=use_zlib, complevel=zlev )\\n ncvar.setncattr('long_name', 'satellite identifer')\\n ncvar[:] = s1_satid[:]\\n\\n #-- global attributes\\n ncfp.setncattr('creator_name',\\\"The Inversion Lab, Hamburg, Germany\\\")\\n ncfp.setncattr('creator_email', \\\"Michael.Vossbeck(at)Inversion-Lab.com\\\")\\n ncfp.setncattr('netcdf_libversion',\\\"{}\\\".format(nc4.__netcdf4libversion__))\\n ncfp.setncattr('date_created',\\\"{}\\\".format(dt.datetime.utcnow().isoformat()))\\n ncfp.setncattr('time_coverage_start',time_coverage_start)\\n ncfp.setncattr('time_coverage_end',time_coverage_end)\\n\\n #-- close file pointer\\n ncfp.close()\\n\\n # logging\\n msg = \\\"...writing ***{}*** DONE\\\".format(act_outname)\\n FileLogger.info(msg)\",\n \"def getCSD (LFP_input_data=None,LFP_input_file=None,sampr=None,dt=None,spacing_um=None,minf=0.05,maxf=300,norm=True,vaknin=True,save_to_sim=True,getAllData=False): # timeRange=None,\\n\\n ############### DEFAULT -- CONDITION 1 : LFP DATA COMES FROM SIMULATION ###############\\n\\n if LFP_input_data is None and LFP_input_file is None: ### GET LFP DATA FROM SIMULATION\\n try:\\n from .. import sim \\n except:\\n print('No LFP input data, input file, or existing simulation. Cannot calculate CSD.')\\n else:\\n ## Check if LFP was recorded during the simulation \\n print('getCSD() is using LFP data from existing simulation.')\\n\\n\\n # time step used in simulation recording \\n if dt is None:\\n dt = sim.cfg.recordStep # units: ms \\n print('dt = ' + str(dt) + ' (units: ms)')\\n\\n\\n sim_data_categories = sim.allSimData.keys()\\n \\n # Get LFP data from sim and instantiate as a numpy array \\n if 'LFP' in sim_data_categories:\\n lfp_data = np.array(sim.allSimData['LFP'])\\n print('lfp_data shape = ' + str(lfp_data.shape))\\n elif 'LFP' not in sim_data_categories:\\n print('!! WARNING: NO LFP DATA !! Need to re-run simulation with cfg.recordLFP enabled')\\n\\n\\n # Sampling rate of data recording during the simulation \\n if sampr is None:\\n sampr = 1./(sim.cfg.recordStep/1000.0) # divide by 1000.0 to turn denominator from units of ms to s\\n\\n\\n # Spacing between electrodes --> convert from micron to mm \\n if spacing_um is None:\\n print('NOTE: using sim.cfg.recordLFP to determine spacing_um !!')\\n spacing_um = sim.cfg.recordLFP[1][1] - sim.cfg.recordLFP[0][1]\\n\\n\\n\\n\\n ############### CONDITION 2 : ARBITRARY LFP DATA ############################\\n ## NOTE: EXPAND CAPABILITY TO INCLUDE LIST OF MULTIPLE FILES \\n \\n ## LOAD SIM DATA FROM JSON FILE\\n elif LFP_input_data is None and '.json' in LFP_input_file:\\n data = {}\\n with open(LFP_input_file) as file:\\n data['json_input_data'] = json.load(file)\\n\\n ## FOR MULTIPLE FILES\\n #for x in LFP_input_file:\\n #with open(x) as file:\\n #data[x] = json.load(file)\\n\\n\\n ## EXTRACT LFP DATA \\n for key in data.keys:\\n lfp_data_list = data[key]['simData']['LFP'] # only works in the 1 input file scenario; expand capability for multiple files \\n \\n ## CAST LFP DATA AS NUMPY ARRAY \\n lfp_data = np.array(lfp_data_list)\\n\\n ## GET CSD DATA AND RELEVANT PLOTTING PARAMS \\n csd_data = {}\\n for i in data.keys():\\n csd_data[i] = {} # e.g. csd['json_input_data'] = {}\\n\\n if sampr is None:\\n csd_data[i]['sampr'] = 1./((data[i]['simConfig']['recordStep'])/1000.0) # assumes that data[i]['simConfig']['recordStep'] is in units of ms\\n sampr = csd_data[i]['sampr']\\n else:\\n csd_data[i]['sampr'] = sampr\\n\\n if spacing_um is None:\\n csd_data[i]['spacing_um'] = data[i]['simConfig']['recordLFP'][1][1] - data[i]['simConfig']['recordLFP'][0][1]\\n spacing_um = csd_data[i]['spacing_um']\\n else:\\n csd_data[i]['spacing_um'] = spacing_um\\n\\n if dt is None:\\n csd_data[i]['dt'] = data[i]['simConfig']['recordStep']\\n dt = csd_data[i]['dt']\\n else:\\n csd_data[i]['dt'] = dt\\n\\n\\n\\n ## FOR LIST OF LFP DATA WITHOUT ANY .JSON INPUT FILE \\n elif len(LFP_input_data) > 0 and LFP_input_file is None: # elif LFP_input_file is None and ...\\n lfp_data = np.array(LFP_input_data) # get lfp_data and cast as numpy array\\n\\n\\n\\n\\n ##############################################################################\\n # Now lfp_data exists for either existing (e.g. empirical) or simulated data \\n ##############################################################################\\n\\n # Convert spacing from microns to mm \\n spacing_mm = spacing_um/1000\\n\\n # Bandpass filter the LFP data with getbandpass() fx defined above\\n datband = getbandpass(lfp_data,sampr,minf,maxf) \\n\\n # Take CSD along smaller dimension\\n if datband.shape[0] > datband.shape[1]:\\n ax = 1\\n else:\\n ax = 0\\n\\n # VAKNIN CORRECTION\\n if vaknin: \\n datband = Vaknin(datband)\\n\\n # NORM <-- ASKING SAM MORE ABOUT THIS\\n if norm: \\n removemean(datband,ax=ax)\\n\\n # now each column (or row) is an electrode -- take CSD along electrodes\\n CSD_data = -np.diff(datband,n=2,axis=ax)/spacing_mm**2 ## CSD_data should be in mV/mm**2, assuming that LFP data is in mV. \\n \\n\\n ########################################\\n ########## noBandpass trial ############\\n ########################################\\n datband_noBandpass = lfp_data.T\\n \\n if datband_noBandpass.shape[0] > datband_noBandpass.shape[1]:\\n ax = 1\\n else:\\n ax = 0\\n \\n if vaknin:\\n datband_noBandpass = Vaknin(datband_noBandpass)\\n \\n if norm:\\n removemean(datband_noBandpass,ax=ax)\\n \\n CSD_data_noBandpass = -np.diff(datband_noBandpass,n=2,axis=ax)/spacing_mm**2 # noBandpass trial \\n ##########################################\\n\\n\\n\\n ################## SAVING DATA ##########################\\n # Add CSD and other param values to sim.allSimData for access outside of this function or script \\n if save_to_sim is True: ## FROM SIM \\n try:\\n from .. import sim \\n sim.allSimData['CSD'] = {}\\n #sim.allSimData['CSD']['timeRange'] = timeRange \\n sim.allSimData['CSD']['sampr'] = sampr\\n sim.allSimData['CSD']['spacing_um'] = spacing_um \\n sim.allSimData['CSD']['CSD_data'] = CSD_data\\n sim.allSimData['CSD']['CSD_data_noBandpass'] = CSD_data_noBandpass # noBandpass trial \\n except:\\n print('NOTE: No sim.allSimData construct available to store CSD data')\\n\\n\\n\\n # RETURN CSD AND OTHER RELEVANT PARAM VALUES, IF DESIRED \\n if getAllData is True:\\n return lfp_data, CSD_data, sampr, spacing_um, dt\\n if getAllData is False:\\n return CSD_data # returns CSD in units of mV/mm**2 (assuming lfps are in mV)\",\n \"def dsinfomaker(compath, backpath, mwb, tcfs, SR=\\\"SR\\\"):#yrs, ves,\\r\\n\\tdsinfo = OrderedDict()\\r\\n\\t# ==========\\r\\n\\tdsinfo[\\\"GFED\\\"] = ({\\\"alias\\\":\\\"GFED4.1\\\",\\\"long_name\\\":\\\"FRI\\\", \\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"MODIS\\\"] = ({\\\"alias\\\":\\\"MCD64A1\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\", \\\"version\\\":\\\"v006\\\"})\\r\\n\\tdsinfo[\\\"esacci\\\"] = ({\\\"alias\\\":\\\"FireCCI5.1\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"COPERN_BA\\\"] = ({\\\"alias\\\":\\\"CGLS\\\", \\\"long_name\\\":\\\"FRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"HANSEN_AFmask\\\"] = ({\\\"alias\\\":\\\"Hansen GFC & MCD14ML\\\", \\\"long_name\\\":f'FRI$_{{{SR}}}$',\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"HANSEN\\\"] = ({\\\"alias\\\":\\\"Hansen GFC\\\", \\\"long_name\\\":\\\"DRI\\\",\\\"units\\\":\\\"yrs\\\"})\\r\\n\\tdsinfo[\\\"Risk\\\"] = ({\\\"alias\\\":\\\"Forest Loss Risk\\\"})\\r\\n\\t# dsinfo[\\\"FutureRisk\\\"] = ({\\\"alias\\\":\\\"Forest Loss Risk\\\"})\\r\\n\\tdsinfo[\\\"SRfrac\\\"] = ({\\\"alias\\\":\\\"Stand Replacing Fire Percentage\\\", \\\"long_name\\\":f'FRI$_{{{\\\"SR\\\"}}}$ %'})\\r\\n\\r\\n\\tfor dsnm in dsinfo:\\r\\n\\t\\tif dsnm.startswith(\\\"H\\\"):\\r\\n\\t\\t\\t# +++++ make a path +++++\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/HANSEN/FRI/\\\"\\r\\n\\t\\t\\tfname = \\\"%s%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, tcfs, mwb)\\r\\n\\t\\t\\t# fname = \\\"%s%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\telif dsnm == \\\"Risk\\\":\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/Risk/FRI/\\\"\\r\\n\\t\\t\\tfname = \\\"%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\t\\tcf.pymkdir(ppath)\\r\\n\\t\\t# elif dsnm == \\\"FutureRisk\\\":\\r\\n\\t\\t# \\tppath = compath + \\\"/BurntArea/Risk/FRI/\\\"\\r\\n\\t\\t# \\tfname = f\\\"{dsnm}_annual_burns_MW_{mwb}degreeBox_{yrs}yrs_{ves}.nc\\\" \\r\\n\\t\\t# \\tcf.pymkdir(ppath)\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# fname = \\\"Hansen_GFC-2018-v1.6_regrided_esacci_FRI_%ddegMW_SIBERIA\\\" % (mwb)\\r\\n\\t\\t\\tppath = compath + \\\"/BurntArea/%s/FRI/\\\" % dsnm\\r\\n\\t\\t\\tfname = \\\"%s_annual_burns_MW_%ddegreeBox.nc\\\" % (dsnm, mwb)\\r\\n\\t\\t# +++++ open the datasets +++++\\r\\n\\t\\tdsinfo[dsnm][\\\"fname\\\"] = ppath+fname\\r\\n\\r\\n\\r\\n\\treturn dsinfo\",\n \"def txt2hdf5_mudis(config, init_file=0, final_file=100, step=1, expo='100'):\\n # --------SKYMAP--------------\\n # Create the directory to save the results\\n os.makedirs(os.path.dirname(cwd + '/config_files/'), exist_ok=True)\\n\\n alignment = add_align()\\n\\n # Extract skymap from alignment file\\n skymap = np.zeros((len(alignment), 2))\\n\\n for i in np.arange(len(skymap)):\\n skymap[i] = alignment['Azimuth'][i], alignment['Zenith'][i]\\n\\n # Save Skymap information\\n with h5py.File(cwd + '/config_files/skymap_radiance.h5', 'w') as sky:\\n\\n if not list(sky.items()):\\n sky.create_dataset('/skymap', data=skymap)\\n else:\\n del sky['skymap']\\n\\n sky.create_dataset('/skymap', data=skymap, dtype='f4')\\n sky['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\\n sky['skymap'].dims[0].label = 'channel'\\n sky['skymap'].dims[1].label = 'Azimuth, Zenith'\\n\\n config['skymap'] = skymap\\n\\n # Save MUDIS file information\\n\\n # Import the radiance data from sensor\\n files = sorted(\\n glob.glob(config['raw_dir'] + '/radiance/{}/data/data_*.txt'.format(config['date'])))\\n\\n print('Total files in the directory: ' + str(len(files)) + ' files')\\n\\n ans = input('convert all files? (y/n): ')\\n\\n if ans == 'n':\\n print('configure initial and final file index in the function options')\\n else:\\n init_file = 0\\n final_file = len(files)\\n\\n for fil in np.arange(init_file, final_file):\\n # Import the data from the file\\n file = np.genfromtxt(files[fil], delimiter='', skip_header=11)\\n\\n # ------------RADIANCE DATA RAW---------------\\n # create the radiance matrix\\n data = np.zeros([113, 992])\\n\\n for i in np.arange(113):\\n if str(alignment.iloc[i][3]) == 'nan':\\n data[i] = np.nan\\n else:\\n try:\\n data[i] = file[:, int(alignment.iloc[i][3] + config['channel_pixel_adj'])] #\\n except:\\n pass #\\n # read the pixels index\\n # in the alignment file and copy the\\n # data in the radiance matrix']))\\n\\n # Correct time for the file UTC\\n name = os.path.split(files[fil])\\n\\n # Read name of the file (correct time)\\n time = name[1][6:25]\\n # convert time to datetime format\\n time = datetime.datetime.strptime(time, '%d.%m.%Y_%H_%M_%S')\\n # print(time)\\n new_name = datetime.datetime.strftime(time, '%Y%m%d_%H%M%S')\\n\\n with open(files[fil], 'r') as file:\\n dat = file.readlines()\\n\\n # Extract information from .dat file\\n exposure = int(dat[4][12:-1])\\n NumAve = int(dat[7][17:-1])\\n CCDTemp = int(dat[8][15:-1])\\n NumSingMes = int(dat[10][27:-1])\\n ElectrTemp = int(dat[9][23:-1])\\n\\n # Create the directory to save the results\\n os.makedirs(os.path.dirname(config['str_dir'] + '/radiance/{}/data/').format(config['date']),\\n exist_ok=True)\\n\\n if exposure == expo:\\n # Create a file in the disk\\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(config['date'], new_name),\\n 'w') as datos:\\n\\n if not list(datos.items()):\\n # Create two datasets(use only one time)\\n datos.create_dataset('/data', data=data, dtype='f4')\\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n else:\\n del datos['data']\\n del datos['skymap']\\n print('data deleted and corrected')\\n datos.create_dataset('/data', data=data, dtype='f4')\\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n\\n # Add attributes to datasets\\n datos['data'].attrs['time'] = str(time)\\n datos['data'].attrs['Exposure'] = exposure\\n datos['data'].attrs['NumAver'] = NumAve\\n datos['data'].attrs['CCDTemp'] = CCDTemp\\n datos['data'].attrs['NumSingMes'] = NumSingMes\\n datos['data'].attrs['ElectrTemp'] = ElectrTemp\\n datos['data'].attrs['Latitude'] = '52.39N'\\n datos['data'].attrs['Longitude'] = '9.7E'\\n datos['data'].attrs['Altitude'] = '65 AMSL'\\n datos['data'].dims[0].label = 'channel'\\n datos['data'].dims[1].label = 'wavelength'\\n\\n datos['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\\n\\n datos.close()\\n\\n print('File ' + str(fil + init_file + 1) + ' of ' +\\n str((final_file - init_file)) + ' saved')\\n else:\\n print('Exposure are not same', expo, exposure)\\n break\\n\\n print('Completed')\",\n \"def test_calc_ch4_working_cap():\\n OUTPUT_PARAMETERS = Dict(\\n dict={\\n 'Density': 0.440527,\\n 'Density_unit': 'g/cm^3',\\n 'Estimated_saturation_loading': 41.985376,\\n 'Estimated_saturation_loading_unit': 'mol/kg',\\n 'Input_block': [1.865, 100],\\n 'Input_ha': 'DEF',\\n 'Input_structure_filename': 'tmp4a13iby3.cif',\\n 'Input_volpo': [1.865, 1.865, 100000],\\n 'Number_of_blocking_spheres': 0,\\n 'POAV_A^3': 8623.69,\\n 'POAV_A^3_unit': 'A^3',\\n 'POAV_Volume_fraction': 0.67999,\\n 'POAV_Volume_fraction_unit': None,\\n 'POAV_cm^3/g': 1.54358,\\n 'POAV_cm^3/g_unit': 'cm^3/g',\\n 'PONAV_A^3': 0.0,\\n 'PONAV_A^3_unit': 'A^3',\\n 'PONAV_Volume_fraction': 0.0,\\n 'PONAV_Volume_fraction_unit': None,\\n 'PONAV_cm^3/g': 0.0,\\n 'PONAV_cm^3/g_unit': 'cm^3/g',\\n 'Unitcell_volume': 12682.1,\\n 'Unitcell_volume_unit': 'A^3',\\n 'adsorption_energy_widom_average': -11.1626207486,\\n 'adsorption_energy_widom_dev': 0.02083606,\\n 'adsorption_energy_widom_unit': 'kJ/mol',\\n 'conversion_factor_molec_uc_to_cm3stp_cm3': 2.9347915768,\\n 'conversion_factor_molec_uc_to_mg_g': 4.7676018308,\\n 'conversion_factor_molec_uc_to_mol_kg': 0.2972320343,\\n 'henry_coefficient_average': 7.71003e-06,\\n 'henry_coefficient_dev': 1.65115e-08,\\n 'henry_coefficient_unit': 'mol/kg/Pa',\\n 'is_kh_enough': True,\\n 'is_porous': True,\\n 'isotherm': {\\n 'enthalpy_of_adsorption_average': [-13.510607783958, -10.787702310577],\\n 'enthalpy_of_adsorption_dev': [0.76886345231266, 1.0196832123586],\\n 'enthalpy_of_adsorption_unit': 'kJ/mol',\\n 'loading_absolute_average': [3.6279844874624, 16.11968088498],\\n 'loading_absolute_dev': [0.15865715470393, 0.075109385284932],\\n 'loading_absolute_unit': 'mol/kg',\\n 'pressure': [5.8, 65],\\n 'pressure_unit': 'bar'\\n },\\n 'temperature': 298,\\n 'temperature_unit': 'K'\\n })\\n\\n results = engine.run(calc_ch4_working_cap, OUTPUT_PARAMETERS)\\n results_dict = results.get_dict()\\n\\n assert results_dict['wc_65bar_mol/kg_average'] == pytest.approx(12.5, abs=0.1)\",\n \"def main():\\n #diffuser_data_dir = r'F:\\\\TEMPO\\\\Data\\\\GroundTest\\\\FPS\\\\Spectrometer\\\\Diffuser_Irradiance\\\\saved_quads\\\\3845_ms\\\\saved_plots_modified'\\n #diffuser_light_data = os.path.join(diffuser_data_dir,'Light_data')\\n #diffuser_dark_data = os.path.join(diffuser_data_dir, 'Dark_data')\\n #print(diffuser_data_dir)\\n #cc\\n #int_time_diffuser = 3845.0\\n\\n# radiance_data_dir_UV = r'F:\\\\TEMPO\\\\Data\\\\GroundTest\\\\FPS\\\\Spectrometer\\\\Radiance_Cal_UV_Lamp\\\\saved_quads\\\\saved_plots_modified'\\n# radiance_light_data_UV = os.path.join(radiance_data_dir_UV,'DSS-Y')\\n# radiance_dark_data_UV = os.path.join(radiance_data_dir_UV, 'Dark_data')\\n## #int_time_radiance = 93.0\\n## print(radiance_data_dir_UV)\\n##\\n radiance_data_dir_VIS = r'F:\\\\TEMPO\\\\Data\\\\GroundTest\\\\FPS\\\\Spectrometer\\\\Radiance_Cal_UV_Lamp\\\\saved_quads\\\\processed_h5'\\n radiance_light_data_VISminusY = os.path.join(radiance_data_dir_VIS,'DSS-Y')\\n radiance_light_data_VIS_Center = os.path.join(radiance_data_dir_VIS,'DSS_Center')\\n radiance_light_data_VISplusY = os.path.join(radiance_data_dir_VIS,'DSS+Y') \\n radiance_dark_data_VIS = os.path.join(radiance_data_dir_VIS, 'Dark_Data')\\n\\n\\n\\n # mean_diffuser_data = calculate_mean(diffuser_light_data)\\n #mean_diffuser_dark_data = calculate_mean(diffuser_dark_data)\\n#\\n#\\n# #Let's correct for dark current and work in signal rates unit\\n# diffuser_dc_corrected = (mean_diffuser_data - mean_diffuser_dark_data)\\n# diffuser_dc_corrected = np.round(diffuser_dc_corrected, 2)\\n# diffuser_dc_corrected[diffuser_dc_corrected <0] = 0\\n# mean_save_dir = os.path.join(diffuser_data_dir,'processed_average_data')\\n# mean_save_irradiance = os.path.join(mean_save_dir, 'mean_irradiance_3845ms.csv')\\n# np.savetxt(mean_save_irradiance, diffuser_dc_corrected, fmt='%1.3f', delimiter=\\\",\\\")\\n \\n\\n\\n\\n# mean_radiance_data_UV = calculate_mean(radiance_light_data_UV)\\n# mean_radiance_dark_data_UV = calculate_mean(radiance_dark_data_UV)\\n# radiance_dc_corrected_UV = (mean_radiance_data_UV - mean_radiance_dark_data_UV)\\n# radiance_dc_corrected_UV = np.round(radiance_dc_corrected_UV, 2)\\n# radiance_dc_corrected_UV[radiance_dc_corrected_UV < 0] = 0\\n###\\n mean_radiance_dark_data_VIS = calculate_mean_dark(radiance_dark_data_VIS)\\n \\n \\n # Correct for Dark current\\n mean_radiance_data_VISminusY = calculate_mean(radiance_light_data_VISminusY) - mean_radiance_dark_data_VIS\\n mean_radiance_data_VIS_Center = calculate_mean(radiance_light_data_VIS_Center)- mean_radiance_dark_data_VIS\\n mean_radiance_data_VISplusY = calculate_mean(radiance_light_data_VISplusY) - mean_radiance_dark_data_VIS\\n \\n \\n #radiance_dc_corrected_VIS[radiance_dc_corrected_VIS < 0] = 0\\n#\\n# \\n\\n# \\n# mean_save_dir_UV = os.path.join(radiance_data_dir_UV,'processed_average_data')\\n mean_save_dir_VIS = os.path.join(radiance_data_dir_VIS,'Mean_Processed_Data')\\n if not os.path.exists(mean_save_dir_VIS):\\n os.makedirs(mean_save_dir_VIS)\\n #\\n# mean_save_radiance_UV = os.path.join(mean_save_dir_UV, 'mean_radiance_DSSminus_UV.csv')\\n# mean_save_radiance_VIS = os.path.join(mean_save_dir_VIS, 'mean_radiance_DSSminus_VIS.csv')\\n# #\\n# \\n# np.savetxt(mean_save_radiance_UV, radiance_dc_corrected_UV, fmt='%1.3f', delimiter=\\\",\\\")\\n# np.savetxt(mean_save_radiance_VIS, radiance_dc_corrected_VIS, fmt='%1.3f', delimiter=\\\",\\\")\\n print('DONE')\\n\\n #Write into h5file\\n hf_name = os.path.join(mean_save_dir_VIS,'Mean_Data.h5')\\n hf = h5py.File(hf_name,'w')\\n hf.create_dataset('DSS-Y', data= mean_radiance_data_VISminusY)\\n hf.create_dataset('DSS_Center', data=mean_radiance_data_VIS_Center)\\n hf.create_dataset('DSS+Y', data= mean_radiance_data_VISplusY)\",\n \"def test_run(self):\\n files = [\\n (\\\"AS1-1.phy_r8s.txt\\\", \\\"AS1-1.phy_r8s.txt_2.5.txt\\\"),\\n (\\\"AS1-3.phy_r8s.txt\\\", \\\"AS1-3.phy_r8s.txt_2.5.txt\\\"),\\n (\\\"AS1-4.phy_r8s.txt\\\", \\\"AS1-4.phy_r8s.txt_2.5.txt\\\"),\\n ]\\n for file_pair in files:\\n input_file = file_pair[0]\\n expected_file = file_pair[1]\\n infile = self.test_data_path + input_file\\n outfile = self.test_data_path + expected_file\\n divnum = 2.5\\n result = run(infile, divnum)\\n\\n with open(outfile) as handle:\\n expected_result = handle.read()\\n self.assertEqual(expected_result, result)\",\n \"def get_data(tstart, tstop, year, grad_list, out_dir):\\n print(\\\"Period: \\\" + str(tstart) + '<-->' + str(tstop) + ' in Year: ' + str(year))\\n#\\n#--- extract ecach group data\\n#\\n for group in grad_list:\\n print(group)\\n\\n line = 'operation=retrieve\\\\n'\\n line = line + 'dataset = mta\\\\n'\\n line = line + 'detector = grad\\\\n'\\n line = line + 'level = 0.5\\\\n'\\n line = line + 'filetype = ' + group + '\\\\n'\\n line = line + 'tstart = ' + str(tstart) + '\\\\n'\\n line = line + 'tstop = ' + str(tstop) + '\\\\n'\\n line = line + 'go\\\\n'\\n\\n data_list = mcf.run_arc5gl_process(line)\\n#\\n#--- read the first fits file and prep for the data list\\n#\\n [cols, tbdata] = ecf.read_fits_file(data_list[0])\\n col_list = []\\n for ent in cols:\\n if ent.lower() == 'time':\\n continue\\n mc = re.search('st_', ent.lower())\\n if mc is not None:\\n continue\\n\\n col_list.append(ent)\\n\\n mcf.rm_files(data_list[0])\\n tdata = tbdata['time']\\n mdata = []\\n for col in col_list:\\n mdata.append(tbdata[col])\\n#\\n#--- read the rest of the data\\n#\\n clen = len(col_list)\\n for k in range(1, len(data_list)):\\n fits = data_list[k]\\n [cols, tbdata] = ecf.read_fits_file(fits)\\n tdata = numpy.append(tdata, tbdata['time'])\\n\\n for m in range(0, clen):\\n cdata = tbdata[col_list[m]]\\n mdata[m] = numpy.append(mdata[m], cdata)\\n\\n mcf.rm_files(fits)\\n\\n dout = out_dir + group.capitalize() + '/'\\n\\n if not os.path.isdir(dout):\\n cmd = 'mkdir ' + dout\\n os.system(cmd)\\n#\\n#--- write out the data to fits file\\n#\\n for k in range(0, clen):\\n col = col_list[k]\\n ocols = ['time', col.lower()]\\n cdata = [tdata, mdata[k]]\\n\\n ofits = dout + col.lower()+ '_full_data_' + str(year) +'.fits'\\n\\n if os.path.isfile(ofits):\\n ecf.update_fits_file(ofits, ocols, cdata)\\n else:\\n ecf.create_fits_file(ofits, ocols, cdata)\\n\\n#\\n#--- zip the fits file from the last year at the beginning of the year\\n#\\n ecf.check_zip_possible(dout)\",\n \"def test_conus():\\n sat = gini.GINIZFile(get_test_file(\\\"TIGN02\\\", fponly=True))\\n assert sat.archive_filename() == \\\"GOES_SUPER_IR_201509281745.png\\\"\\n assert sat.awips_grid() == 0\\n assert sat.metadata[\\\"map_projection\\\"] == 5\",\n \"def test_fetch_station_data_wdc_format_hour_data_from_wdc(tmpdir): # pylint: disable=invalid-name\\n cadence = 'hour'\\n station = 'NGK'\\n start_date = date(2015, 4, 1)\\n end_date = date(2015, 4, 30)\\n service = 'WDC'\\n expected_filename = 'ngk2015.wdc'\\n configpath = os.path.join(DATAPATH, 'wdc_minute_data_wdcoutput.ini')\\n # TODO: cf fetch_station_data vs oracle files\\n # oraclefile = os.path.join(ORACLEPATH, 'ngk2015.wdc')\\n\\n # ensure we have somewhere to put the data\\n manualdir = os.path.join(str(tmpdir), 'manual')\\n funcdir = os.path.join(os.path.dirname(manualdir),\\n 'via__fetch_station_data')\\n for dir_ in (manualdir, funcdir):\\n os.mkdir(dir_)\\n manualfile = os.path.join(manualdir, expected_filename)\\n funcfile = os.path.join(funcdir, expected_filename)\\n\\n # 'manual' way\\n config = cws.ParsedConfigFile(configpath, service)\\n form_data = cws.FormData(config)\\n form_data.set_datasets(start_date, end_date, station, cadence, service)\\n req_wdc = cws.DataRequest()\\n req_wdc.read_attributes(config)\\n req_wdc.set_form_data(form_data.as_dict())\\n resp_wdc = rq.post(\\n req_wdc.url, data=req_wdc.form_data, headers=req_wdc.headers\\n )\\n\\n cws.check_response(resp_wdc.status_code, resp_wdc.content)\\n\\n with zipfile.ZipFile(BytesIO(resp_wdc.content)) as fzip:\\n fzip.extractall(manualdir)\\n\\n assert not os.path.isfile(funcfile)\\n # with wrapper function\\n cws.fetch_station_data(\\n start_date=start_date, end_date=end_date,\\n station=station, cadence=cadence,\\n service=service, saveroot=funcdir, configpath=configpath\\n )\\n assert os.path.isfile(funcfile)\\n assert_all_lines_same(funcfile, manualfile)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6232863","0.6190931","0.6065787","0.5965935","0.59624934","0.5858929","0.5856982","0.5837951","0.5831565","0.58128524","0.5789938","0.57884246","0.5777758","0.5774943","0.57337826","0.5721014","0.569534","0.5672289","0.56514597","0.5634904","0.5580489","0.55664647","0.55572945","0.5547208","0.55148506","0.55077463","0.5495898","0.5479068","0.5474958","0.5472551","0.5470454","0.5461943","0.54608774","0.5442911","0.54394644","0.54363304","0.54341155","0.5418639","0.5418111","0.5405701","0.5403194","0.5401926","0.54009503","0.5383155","0.53806305","0.53765905","0.53734565","0.5370778","0.5370048","0.5363304","0.535799","0.5355772","0.5353627","0.5347003","0.53448147","0.53417337","0.53401864","0.5337057","0.53322285","0.53289014","0.53220975","0.5317635","0.5310569","0.53078103","0.5307153","0.5301299","0.5297263","0.52959245","0.5291642","0.5287759","0.5287055","0.5282357","0.5279186","0.52728444","0.5271845","0.5265456","0.5261367","0.52588433","0.5247685","0.52444565","0.5241643","0.5239588","0.52374953","0.5237098","0.5229478","0.522735","0.5225439","0.52252835","0.5219018","0.52186453","0.52182627","0.5214632","0.52143496","0.52094245","0.5206825","0.5204791","0.52047503","0.52006483","0.5199394","0.51990664"],"string":"[\n \"0.6232863\",\n \"0.6190931\",\n \"0.6065787\",\n \"0.5965935\",\n \"0.59624934\",\n \"0.5858929\",\n \"0.5856982\",\n \"0.5837951\",\n \"0.5831565\",\n \"0.58128524\",\n \"0.5789938\",\n \"0.57884246\",\n \"0.5777758\",\n \"0.5774943\",\n \"0.57337826\",\n \"0.5721014\",\n \"0.569534\",\n \"0.5672289\",\n \"0.56514597\",\n \"0.5634904\",\n \"0.5580489\",\n \"0.55664647\",\n \"0.55572945\",\n \"0.5547208\",\n \"0.55148506\",\n \"0.55077463\",\n \"0.5495898\",\n \"0.5479068\",\n \"0.5474958\",\n \"0.5472551\",\n \"0.5470454\",\n \"0.5461943\",\n \"0.54608774\",\n \"0.5442911\",\n \"0.54394644\",\n \"0.54363304\",\n \"0.54341155\",\n \"0.5418639\",\n \"0.5418111\",\n \"0.5405701\",\n \"0.5403194\",\n \"0.5401926\",\n \"0.54009503\",\n \"0.5383155\",\n \"0.53806305\",\n \"0.53765905\",\n \"0.53734565\",\n \"0.5370778\",\n \"0.5370048\",\n \"0.5363304\",\n \"0.535799\",\n \"0.5355772\",\n \"0.5353627\",\n \"0.5347003\",\n \"0.53448147\",\n \"0.53417337\",\n \"0.53401864\",\n \"0.5337057\",\n \"0.53322285\",\n \"0.53289014\",\n \"0.53220975\",\n \"0.5317635\",\n \"0.5310569\",\n \"0.53078103\",\n \"0.5307153\",\n \"0.5301299\",\n \"0.5297263\",\n \"0.52959245\",\n \"0.5291642\",\n \"0.5287759\",\n \"0.5287055\",\n \"0.5282357\",\n \"0.5279186\",\n \"0.52728444\",\n \"0.5271845\",\n \"0.5265456\",\n \"0.5261367\",\n \"0.52588433\",\n \"0.5247685\",\n \"0.52444565\",\n \"0.5241643\",\n \"0.5239588\",\n \"0.52374953\",\n \"0.5237098\",\n \"0.5229478\",\n \"0.522735\",\n \"0.5225439\",\n \"0.52252835\",\n \"0.5219018\",\n \"0.52186453\",\n \"0.52182627\",\n \"0.5214632\",\n \"0.52143496\",\n \"0.52094245\",\n \"0.5206825\",\n \"0.5204791\",\n \"0.52047503\",\n \"0.52006483\",\n \"0.5199394\",\n \"0.51990664\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7407615"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":587,"cells":{"query":{"kind":"string","value":"Perform a 'run' action on a module. Module should have status LOADED for a System to actually call this method."},"document":{"kind":"string","value":"def run(self, **kwargs) -> None:\n raise NotImplementedError()"},"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 module_runner(module):\n task_queue.put(1)\n result = sys.modules[module].run()\n task_queue.get()\n store_module_result(result) # Store the result in our repo","def do_run(self, line: str):\n if self._real_module is None:\n print(\"'run' command depends on using a module. See 'use' for help.\")\n return\n\n self._real_module.run()","def run_module(self, path):\n\n module = self.import_module(path)\n result = None\n\n if module:\n try:\n result = module.run()\n except AttributeError:\n self.error('Error Running Module: Missing run() method.')\n except Exception:\n e = sys.exc_info()[1]\n traceback = sys.exc_info()[2]\n self.warning('Exeption caught in module: {0} line: {1}'.format(\n e,\n traceback.tb_lineno))\n self.calls.append({path: result})\n state.save_hook_call(path, result)\n return result","def RunModule(self):\n module = self.statModules.GetActive()\n \n self.ShutdownStatModule()\n \n if module is not None:\n wx.LogMessage(\"Running stat module...\")\n self.statPage = module.Load(self.nb, self)\n self.SetView(self.statModules.caption, self.statPage)","def do_run(self, args):\n logger.debug(\"do_run() was called\")\n\t\n parser = CrispyArgumentParser(description=self.do_run.__doc__, prog=\"run\")\n parser.add_argument(\"module\", metavar=\"<module>\", help=\"module name\")\n parser.add_argument(\"session_id\", metavar=\"<session id>\", help=\"session to run on\")\n parser.add_argument(\"arguments\", nargs=argparse.REMAINDER, metavar=\"<arguments>\", help=\"module arguments\")\n \n try:\n pargs = parser.parse_args(shlex.split(args))\n except MyParserException as e:\n print e\n return\n\n try:\n target = self.srv.get_client(int(pargs.session_id))\n except Exception as e:\n fprint.error(\"Session id should be an integer.\")\n return\n\n if not target:\n fprint.error(\"Improper session id.\")\n return\n\n try:\n mod = self.srv.get_module(pargs.module)(target)\n except Exception as me:\n fprint.error(\"Error loading \\\"{}\\\" module: {}\".format(pargs.module, me))\n return\n\n try:\n margs = mod.check_args(pargs.arguments)\n except MyParserException as e:\n print e\n return\n\n try:\n target.run_module(mod, margs)\n except Exception as e:\n fprint.error(\"Error running module: {}\".format(e))\n return","def execute_module(self):\n raise NotImplementedError","def exec_module(self, module):\n pass","def run(self):\n\n self._action.execute()","def run_module(self, module_name, args=[], kwargs={}):\n if not module_loader.has_plugin(module_name):\n raise UnsupportedAnsibleModule(\"Unsupported ansible module \\\"{}\\\"\".format(module_name))\n self.module_name = module_name\n\n previous_frame = inspect.currentframe().f_back\n caller_info = inspect.getframeinfo(previous_frame)\n kwargs.update({\"caller_info\": caller_info})\n\n return self._run_ansible_module(*args, **kwargs)","def run_case(self, **kwargs):\n module_name = kwargs.get('module_name', None)\n if self.result:\n self.success_msg.append('>>>%s PASSED' % module_name or sys.modules[__name__])\n else:\n self.fail_msg.insert(0, '>>>%s FAILED' % module_name or sys.modules[__name__])","def run(self, task):\n\n self._setup()\n\n runnable = load_from_module(task.task)\n runnable(*task.get_args(), **task.get_kwargs())","def do_workload(self):\n module_manager = self._core.get_module_manager()\n module = module_manager.get_module_by_name(self._values[\"name\"])\n module_manager.update_module(module)","def run_module(self):\n try:\n self.output_dict['wind_delay'] = self.calculate_wind_delay()\n return 0 # module ran successfully\n except:\n return 1 # module did not run successfully","def _run_ansible_module(self, *args, **kwargs):\n caller_info = kwargs.pop(\"caller_info\", None)\n if not caller_info:\n previous_frame = inspect.currentframe().f_back\n caller_info = inspect.getframeinfo(previous_frame)\n\n module_args = copy.deepcopy(args)\n module_kwargs = copy.deepcopy(kwargs)\n\n verbosity = module_kwargs.pop(\"verbosity\", None)\n if not verbosity:\n verbosity = self.options.get(\"verbosity\", 2)\n module_ignore_errors = module_kwargs.pop(\"module_ignore_errors\", False)\n module_attrs = module_kwargs.pop(\"module_attrs\", {})\n\n module_info = {\n \"module_name\": self.module_name,\n \"args\": module_args,\n \"kwargs\": module_kwargs,\n \"module_attrs\": module_attrs\n }\n self._log_modules(caller_info, module_info, verbosity)\n\n task = self.build_task(**module_info)\n results = self.run_tasks(self.host_pattern, self.loader, self.im, self.vm, self.options, tasks=[task])\n\n self._log_results(caller_info, module_info, results, verbosity)\n self._check_results(caller_info, module_info, results, module_ignore_errors, verbosity)\n\n if isinstance(self, AnsibleHost):\n results = results[self.hostnames[0]]\n\n return results","def run(self):\r\n self.inst.write(':RUN')","def RunModule(self):\n\n module = self.viewModule.GetActive()\n self.ShutdownViewModule()\n overviewText = \"\"\n\n # o The RunTest() for all samples must now return a window that can\n # be placed in a tab in the main notebook.\n # o If an error occurs (or has occurred before) an error tab is created.\n\n if module is not None:\n wx.LogMessage(\"Loading view module...\")\n if hasattr(module, \"overview\"):\n overviewText = module.overview\n\n try:\n if hasattr(module, \"GetWindow\"):\n self.viewPage = module.GetWindow(self, self.nb, self)\n elif hasattr(module, \"runTest\"): # Obsoleted\n self.viewPage = module.runTest(self, self.nb, self)\n except:\n self.viewPage = ViewModuleErrorPanel(self.nb, self.codePage,\n ViewModuleError(sys.exc_info()), self)\n\n wx.LogMessage(\"Loaded %s for module %s\" % (self.viewPage, module))\n\n bg = self.nb.GetThemeBackgroundColour()\n if bg:\n self.viewPage.SetBackgroundColour(bg)\n\n assert self.viewPage is not None, \"runTest must return a window!\"\n\n else:\n # There was a previous error in compiling or exec-ing\n self.viewPage = ViewModuleErrorPanel(self.nb, self.codePage,\n self.viewModule.GetErrorInfo(), self)\n\n self.SetOverview(self.viewModule.name + \" Help\", overviewText)\n\n if self.firstTime:\n # change to the view page the first time a module is run\n self.UpdateNotebook(2)\n self.firstTime = False\n else:\n # otherwise just stay on the same tab in case the user has changed to another one\n self.UpdateNotebook()","def run_run(self, cmds):\n pass","def tfrun(args, build_modules, build_workspace, build_env):\n\n # loop through each selected module(s) and apply the action as specified by user\n for m in build_modules:\n print(\"\\n\\n****************************************************************************\")\n print(\"Permforming action \\\"{0}\\\" for module {1}\".format(args.action, m))\n print(\"****************************************************************************\\n\\n\")\n run_module(args, m, build_workspace, build_env)","def action_run(self):\n pass","def main():\n obj = UnityFilesystem()\n obj.perform_module_operation()","def modExec(module):\n modName = module.split('_')[-1]\n if \"live\" in module:\n dn = '{0} (live)'.format(modName.upper())\n else:\n dn = '{0}'.format(modName.upper())\n\n try:\n modStart = datetime.utcnow()\n log.info(\"Running {0}\".format(dn))\n modImport = 'modules.' + module\n\n import_module(modImport)\n\n modOutput = [i for i in glob.glob(outputdir + '/*') if all(p in i for p in [modName, runID])]\n try:\n arch = [archive.add_file(os.path.basename(outfile)) for outfile in modOutput]\n except IndexError:\n pass\n\n modEnd = datetime.utcnow()\n modRuntime = modEnd - modStart\n log.debug(\"{0} finished in {1}.\".format(dn, modRuntime))\n\n except KeyboardInterrupt:\n sys.stdout.write('\\r')\n sys.stdout.flush()\n log.error(\"{0} was killed. \".format(module))\n\n except Exception:\n log.error(\"{0} failed: {1}\".format(module, [traceback.format_exc()]))","def run(self):\n self._setupLogger()\n self.setup()\n\n self.logger.info(self.moduleName + \" starting run loop.\")\n\n while True:\n self.loop()","def Run():\r\n pass","def run_script(self):\n pass","def run(self):\n try:\n self._run()\n except Exception as err:\n # TODO: Do Task Failure to run exception handling\n pass","def execute_module(self, \n project_id: str, \n branch_id: str, \n module: ModuleHandle, \n artifacts: Dict[str, ArtifactDescriptor]\n ) -> None:\n task = ExtendedTaskHandle(\n project_id=project_id,\n branch_id=branch_id,\n module_id=module.identifier,\n controller=self\n )\n self.tasks[task.task_id] = task\n # print(\"Starting execution of {} with artifacts: [{}]\".format(module.command.command_id, artifacts))\n self.backend.execute_async(\n task=task,\n command=module.command,\n artifacts=artifacts,\n resources=module.provenance.resources\n )","def run(self):\n# log.trace(\" run task %s \", self.name)\n return self.target.send(self.params)","def exec_module(cls, *args, **kwargs): # real signature unknown\n pass","def exec_module(cls, *args, **kwargs): # real signature unknown\n pass","def run(self):\n self.run()","def main():\n module = IRODSPermissionModule()\n module.run()","def run(self, script, *args, **kwargs):\n return self._run('run', script, *args, **kwargs)","def setup_module(module):\n print(\"Start rishabhSetupModule of Program\")","def run(self, host_list, module_name, module_args):\n # create play with tasks\n play_source = dict(\n name=\"Ansible Play\",\n hosts=host_list,\n gather_facts='no',\n tasks=[dict(action=dict(module=module_name, args=module_args))]\n )\n play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)\n\n # actually run it\n tqm = None\n self.callback = ResultsCollector()\n try:\n tqm = TaskQueueManager(\n inventory=self.inventory,\n variable_manager=self.variable_manager,\n loader=self.loader,\n options=self.options,\n passwords=self.passwords,\n )\n tqm._stdout_callback = self.callback\n tqm.run(play)\n finally:\n if tqm is not None:\n tqm.cleanup()","def do_load(self, name):\n try:\n self.runner.run()\n\n except():\n print('Loading failed')","def run_step(self):\n self.control_instance.run_step()","def run(self):\n # check param and env\n self.sanity_check()\n\n # only-check mode\n if self.module.check_mode:\n self.module.exit_json(**self.result)\n\n self.init_session()\n\n action = self.select_action()\n action()","def run(self):\n self.__power_on()\n\n self.__main()","def run(self, host_list, module_name, module_args):\n # create play with tasks\n play_source = dict(\n name=\"Ansible Play\",\n hosts=host_list,\n gather_facts='no',\n tasks=[dict(action=dict(module=module_name, args=module_args))]\n )\n play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)\n\n # actually run it\n tqm = None\n self.callback = AnsibleTaskResultCallback()\n try:\n tqm = TaskQueueManager(\n inventory=self.inventory,\n variable_manager=self.variable_manager,\n loader=self.loader,\n options=self.options,\n passwords=self.passwords,\n )\n tqm._stdout_callback = self.callback\n tqm.run(play)\n finally:\n if tqm is not None:\n tqm.cleanup()","def run_module_with_output(self, mod, payload=None, run_as_job=False, timeout=301):\n options_str = 'use {}/{}\\n'.format(mod.moduletype, mod.modulename)\n if self.rpc.consoles.console(self.cid).is_busy():\n raise MsfError('Console {} is busy'.format(self.cid))\n self.rpc.consoles.console(self.cid).read() # clear data buffer\n opts = mod.runoptions.copy()\n if payload is None:\n opts['DisablePayloadHandler'] = True\n\n # Set module params\n for k in opts.keys():\n options_str += 'set {} {}\\n'.format(k, opts[k])\n\n # Set payload params\n if mod.moduletype == 'exploit':\n opts['TARGET'] = mod.target\n options_str += 'set TARGET {}\\n'.format(mod.target)\n\n if 'DisablePayloadHandler' in opts and opts['DisablePayloadHandler']:\n pass\n elif isinstance(payload, PayloadModule):\n if payload.modulename not in mod.payloads:\n raise ValueError(\n 'Invalid payload ({}) for given target ({}).'.format(payload.modulename, mod.target))\n options_str += 'set payload {}\\n'.format(payload.modulename)\n for k, v in payload.runoptions.items():\n if v is None or (isinstance(v, str) and not v):\n continue\n options_str += 'set {} {}\\n'.format(k, v)\n else:\n raise ValueError('No valid PayloadModule provided for exploit execution.')\n\n # Run the module without directly opening a command line\n options_str += 'run -z'\n if run_as_job:\n options_str += \" -j\"\n self.rpc.consoles.console(self.cid).write(options_str)\n data = ''\n timer = 0\n while data == '' or self.rpc.consoles.console(self.cid).is_busy():\n time.sleep(1)\n data += self.rpc.consoles.console(self.cid).read()['data']\n timer += 1\n if timer > timeout:\n break\n return data","def __run(self):\n sys.settrace(self.globaltrace)\n self.__run_backup()\n self.run = self.__run_backup","def run(self):\n raise NotImplementedError('Run method not implemented in %s' % type(self).__name__)","def _doRun(self, model: Model):\n raise Exception(\"Not implemented\")","def run(self, tmp=None, task_vars=None):\n if not task_vars:\n task_vars = {}\n\n result = ActionBase.run(self, tmp=tmp, task_vars=task_vars)\n result.update(\n self._execute_module(\n module_name=self.module_name,\n module_args=self._task.args,\n task_vars=task_vars,\n wrap_async=self._task.async_val\n )\n )\n\n return result","def run(self):\n run_simple(self.hostname, self.port, self.dispatch,\n use_reloader=self.debug)","def run(_):\n pass","def run(self, *args, **kwargs):\n raise NotImplementedError('Tasks must define the run method.')","def execute(self):\n # Do the task that the module is suppose to do.\n\n # Return a message telling the user that the task is done.\n return \"\\nTemplate module did ...\"","def local_run(self, parameters=None) -> \"Run\":\n # NOTE -is there a use-case for this?\n raise NotImplementedError()","def do_workload(self):\n module_manager = self._core.get_module_manager()\n module = module_manager.get_module_by_name(self._values[\"name\"])\n module_manager.uninstall_module(module)","def run (self):\n t = threading.Thread(target=self.runController)\n t.start()","def do_workload(self):\n module_manager = self._core.get_module_manager()\n module_manager.install_module(self.get_meta())","def run_cmd(self):\r\n self.run = True","def run_suite(self, name=\"_\", result=None):\n result = result if result else self.result\n self.mod_suites[name].run(result)","def run(self):\n return self.private_run()","def run_script(extension_invocation_info):\n acm.RunModuleWithParameters(__name__, acm.GetDefaultContext())","async def run_controller(self, request):\n self.run()\n return {\"status\": \"ok\"}","def run_game_logic(self):\n pass","def run(self):\r\n self.log(texto=f\"Executando {self._name}\")","def execute_module(self, module, *args, **opts):\n module_file = module.__file__\n if module_file.endswith('.pyc'):\n module_file = module_file[:-1]\n cmd = [self._path]\n if 'python_options' in opts:\n cmd.extend(opts['python_options'])\n del opts['python_options']\n cmd.append(module_file)\n cmd.extend(args)\n return get_cmd_output(*cmd, **opts)","def run_module():\n parser = ap.ArgumentParser()\n parser.add_argument(\"--dry_run\", action=\"store_true\", help=\"When provided, return zero exit\"\n \" status irrespective of the number of failures\")\n args = parser.parse_args()\n params = read_params()\n assert \"validation\" in params\n dry_run_param = params[\"validation\"][\"common\"].get(\"dry_run\", False)\n params[\"validation\"][\"common\"][\"dry_run\"] = args.dry_run or dry_run_param\n validator = Validator(params)\n validator.validate().print_and_exit(\n get_structured_logger(__name__,\n params[\"common\"].get(\"log_filename\", None)),\n not (args.dry_run or dry_run_param))","def run_script(self, params, config_no):\n raise NotImplementedError()","def run(self, run):\n\n self._run = run","def run_module_ground_plan(args):\n raise NotImplementedError","def run(self, action_name=None, reuse=False, parallel=False):\n os.environ['WORKSPACE'] = self.workspace\n\n self.download_actions()\n self.instantiate_runners()\n\n if action_name:\n self.wf['action'][action_name]['runner'].run(reuse)\n else:\n for s in self.get_stages():\n self.run_stage(s, reuse, parallel)","def _run(self):\n raise NotImplemented(\"Abstract method '_run' need to be defined\")","def run():\n main()","def run(self) -> None:\n soc = self.make_soc()\n soc_builder = self.build_soc(soc)\n if self.args.load:\n self.load(soc, soc_builder)","def __run(self):\n sys.settrace(self.globaltrace) # set self.globaltrace before thread start\n self.__run_backup()\n self.run = self.__run_backup","def Run(self):\n pass","def _run(self):\n\n self.is_running = False\n self.start()\n self.function(*self.args, **self.kwargs)","def run(self):\n self.tcex.log.trace('run')","def run(self):\n\n input_args = {}\n self._execute(input_args, self.args)","def _run(self):\n raise NotImplementedError","def _run(self):\n raise NotImplementedError","def __run(self):\n try:\n sys.settrace(self.globaltrace)\n self.__run_backup()\n self.run = self.__run_backup\n except Exception, e:\n e.message = e.__class__.__name__ + ' in ' + self.getName() + ': ' + e.message\n self.__exception = e","def RUN(self):","def call(self, **params):\n # NOTE - use __call__??\n # TODO - move exec_script here?\n # TODO - call should handle param defaults\n from datapane.runner.exec_script import run\n\n run(self, params)","def exec_module(self, module):\n\n if not self.filename.endswith(config.FILE_EXT) and not self.filename.endswith(\n \"__init__.py\"\n ):\n print(\"Fatal error: ExtensionLoader is asked to load a normal file.\")\n print(\"filename:\", self.filename)\n print(\"Expected extension:\", config.FILE_EXT)\n raise SystemExit\n\n name = module.__name__\n if module.__name__ == config.MAIN_MODULE_NAME:\n module.__name__ = \"__main__\"\n config.MAIN_MODULE_NAME = None\n\n with open(self.filename) as f:\n source = f.read()\n\n transforms.identify_requested_transformers(source)\n\n if config.TRANSFORMERS:\n original = source\n source = transforms.add_all_imports(source)\n source = transforms.apply_source_transformations(source)\n\n if config.DIFF and original != source:\n self.write_html_diff(name, original, source)\n\n if config.CONVERT and self.filename.endswith(config.FILE_EXT):\n print(\"############### Original source: ############\\n\")\n print(original)\n print(\"\\n############### Converted source: ############\\n\")\n print(source)\n print(\"=\" * 50, \"\\n\")\n\n source = transforms.apply_ast_transformations(source)\n exec(source, vars(module))","def test_load_simple_module():\n loader = Loader()\n main_fname = loader.load(\"https://gist.githubusercontent.com/miohtama/80391980c2e73b285cfe/raw/dd89a55497ba33a6014453d9bb7432ab424c01cf/kivyhello.py#main\")\n mod = path_to_mod_name(main_fname)\n result = loader.run(mod, \"hello\")\n assert result == \"Hello there\"\n loader.close()","def run():\n\n args = parse_arguments()\n app = rummage_app.RummageApp(args)\n app.MainLoop()\n\n return 0","def run(self, *args, **kwargs):\n self.actions()\n\n for funcName, action in self._actions.items():\n actionName, actionParams = action\n if actionParams == None:\n func = getattr(self, funcName)\n print('Running %s.%s' % (self._title, funcName))\n func()\n else:\n self.runAction(actionName, funcName)\n self._db.commit_db()","def runner(self):\n\n if self.__do_initialize:\n self.do_initialize()\n self.__do_initialize = False\n\n elif self.__do_start_running:\n self.do_start_running()\n self.__do_start_running = False\n\n elif self.__do_stop_running:\n #self.do_command(\"Stop\")\n self.do_stop_running()\n self.__do_stop_running = False\n\n elif self.__do_terminate:\n self.do_terminate()\n self.__do_terminate = False\n\n elif self.__do_pause_running:\n self.do_command(\"Pause\")\n self.__do_pause_running = False\n\n elif self.__do_resume_running:\n self.do_command(\"Resume\")\n self.__do_resume_running = False\n\n elif self.__do_recover:\n self.do_recover()\n self.__do_recover = False\n\n elif self.state(self.name) != \"stopped\":\n self.check_proc_heartbeats()\n self.check_proc_exceptions()\n\n if self.state(self.name) == \"running\":\n self.display_lbne_artdaq_output()","def _run(self):\n raise NotImplementedError","def runModtran(self, run):\n # Call for the MODTRAN card class\n modcard = ModtranCards()\n modcard.setDefaults()\n # Write the cards to the disk\n modcard.writeModtranCards(self.modtran_visits[run], self.outfilename)\n modcard.runModtran()","def run_target(self):\n\n self.logger.info('run_target')\n\n # Clear all fields in GUI\n self.clear_gui_sig.emit()\n\n # Stop a previous target if it had a process running\n self.debugger.stop_target()\n\n if self.mode == self.AppMode.DYN_LINK:\n self.run_target_dynlink()\n elif self.mode == self.AppMode.DYN_LOAD:\n self.run_target_dynload()","def run_command(self):\n global global_cycles_completed\n global_cycles_completed = 0\n\n cycles = self.on_spin(wx.SpinCtrl)\n\n # check that this function has been called on pressing run button\n text = \"\".join(\n [_(u\"run_command function has been called, number of cycles is: \"), str(cycles)])\n if self.state == 0:\n self.canvas_2d.render(text, True)\n else:\n self.canvas_3d.render()\n\n if cycles is not None: # if the number of cycles provided is valid\n self.monitors.reset_monitors()\n print(\"\".join([_(u\"Running for \"), str(cycles), _(u\" cycles\")]))\n self.devices.cold_startup()\n if self.run_network(cycles):\n global_cycles_completed += cycles","def run(run_type, module, config):\n print(\" -----------------------------------------------------------------\")\n print(\" Beginning \" + run_type.lower() + \" test suite \")\n print(\" -----------------------------------------------------------------\")\n print(\"\")\n summary = run_quiet(run_type, module, config)\n print(\" -----------------------------------------------------------------\")\n print(\" \" + run_type.capitalize() + \" test suite complete \")\n print(\" -----------------------------------------------------------------\")\n print(\"\")\n return summary","def run_component(self):\n raise NotImplementedError","def _run ( self ) :\n raise NotImplementedError ( \"AppBase: method _run() should be implemented in a subclass\" )","def run(self):\n if len(self.modules) == 0:\n raise ValueError(\"no modules registered\")\n while True:\n if not self._has_files() and not self._has_timeouts():\n break\n timeout = self._calculate_timeout()\n ready, _, _ = select(self._files(), [], [], timeout)\n self._dispatch_timeouts()\n for file in ready:\n self._trigger_file(file)","def main():\n module = AnsibleModule(argument_spec=L3_interfaceArgs.argument_spec,\n supports_check_mode=True)\n\n result = L3_interface(module).execute_module()\n module.exit_json(**result)","def onReloadAndTest(self, moduleName=\"NeedleFinder\"):\r\n print \"onReloadAndTest\"; msgbox(whoami())\r\n try:\r\n self.onReload()\r\n evalString = 'globals()[\"%s\"].%sTest()' % (moduleName, moduleName)\r\n tester = eval(evalString)\r\n tester.runTest()\r\n except Exception, e:\r\n import traceback\r\n traceback.print_exc()\r\n qt.QMessageBox.warning(slicer.util.mainWindow(),\r\n \"Reload and Test\", 'Exception!\\n\\n' + str(e) + \"\\n\\nSee Python Console for Stack Trace\")","def run(self, threaded=False):\n if threaded:\n Thread(target=self._run).start()\n else:\n self._run()","def run(self) -> None:\n self._hass.turn_on('scene.{0}'.format(self._args['scene']))","def run():\n import hmmmAssembler ; reload(hmmmAssembler) # import helpers\n hmmmAssembler.main(Random) # this runs the code!","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass"],"string":"[\n \"def module_runner(module):\\n task_queue.put(1)\\n result = sys.modules[module].run()\\n task_queue.get()\\n store_module_result(result) # Store the result in our repo\",\n \"def do_run(self, line: str):\\n if self._real_module is None:\\n print(\\\"'run' command depends on using a module. See 'use' for help.\\\")\\n return\\n\\n self._real_module.run()\",\n \"def run_module(self, path):\\n\\n module = self.import_module(path)\\n result = None\\n\\n if module:\\n try:\\n result = module.run()\\n except AttributeError:\\n self.error('Error Running Module: Missing run() method.')\\n except Exception:\\n e = sys.exc_info()[1]\\n traceback = sys.exc_info()[2]\\n self.warning('Exeption caught in module: {0} line: {1}'.format(\\n e,\\n traceback.tb_lineno))\\n self.calls.append({path: result})\\n state.save_hook_call(path, result)\\n return result\",\n \"def RunModule(self):\\n module = self.statModules.GetActive()\\n \\n self.ShutdownStatModule()\\n \\n if module is not None:\\n wx.LogMessage(\\\"Running stat module...\\\")\\n self.statPage = module.Load(self.nb, self)\\n self.SetView(self.statModules.caption, self.statPage)\",\n \"def do_run(self, args):\\n logger.debug(\\\"do_run() was called\\\")\\n\\t\\n parser = CrispyArgumentParser(description=self.do_run.__doc__, prog=\\\"run\\\")\\n parser.add_argument(\\\"module\\\", metavar=\\\"<module>\\\", help=\\\"module name\\\")\\n parser.add_argument(\\\"session_id\\\", metavar=\\\"<session id>\\\", help=\\\"session to run on\\\")\\n parser.add_argument(\\\"arguments\\\", nargs=argparse.REMAINDER, metavar=\\\"<arguments>\\\", help=\\\"module arguments\\\")\\n \\n try:\\n pargs = parser.parse_args(shlex.split(args))\\n except MyParserException as e:\\n print e\\n return\\n\\n try:\\n target = self.srv.get_client(int(pargs.session_id))\\n except Exception as e:\\n fprint.error(\\\"Session id should be an integer.\\\")\\n return\\n\\n if not target:\\n fprint.error(\\\"Improper session id.\\\")\\n return\\n\\n try:\\n mod = self.srv.get_module(pargs.module)(target)\\n except Exception as me:\\n fprint.error(\\\"Error loading \\\\\\\"{}\\\\\\\" module: {}\\\".format(pargs.module, me))\\n return\\n\\n try:\\n margs = mod.check_args(pargs.arguments)\\n except MyParserException as e:\\n print e\\n return\\n\\n try:\\n target.run_module(mod, margs)\\n except Exception as e:\\n fprint.error(\\\"Error running module: {}\\\".format(e))\\n return\",\n \"def execute_module(self):\\n raise NotImplementedError\",\n \"def exec_module(self, module):\\n pass\",\n \"def run(self):\\n\\n self._action.execute()\",\n \"def run_module(self, module_name, args=[], kwargs={}):\\n if not module_loader.has_plugin(module_name):\\n raise UnsupportedAnsibleModule(\\\"Unsupported ansible module \\\\\\\"{}\\\\\\\"\\\".format(module_name))\\n self.module_name = module_name\\n\\n previous_frame = inspect.currentframe().f_back\\n caller_info = inspect.getframeinfo(previous_frame)\\n kwargs.update({\\\"caller_info\\\": caller_info})\\n\\n return self._run_ansible_module(*args, **kwargs)\",\n \"def run_case(self, **kwargs):\\n module_name = kwargs.get('module_name', None)\\n if self.result:\\n self.success_msg.append('>>>%s PASSED' % module_name or sys.modules[__name__])\\n else:\\n self.fail_msg.insert(0, '>>>%s FAILED' % module_name or sys.modules[__name__])\",\n \"def run(self, task):\\n\\n self._setup()\\n\\n runnable = load_from_module(task.task)\\n runnable(*task.get_args(), **task.get_kwargs())\",\n \"def do_workload(self):\\n module_manager = self._core.get_module_manager()\\n module = module_manager.get_module_by_name(self._values[\\\"name\\\"])\\n module_manager.update_module(module)\",\n \"def run_module(self):\\n try:\\n self.output_dict['wind_delay'] = self.calculate_wind_delay()\\n return 0 # module ran successfully\\n except:\\n return 1 # module did not run successfully\",\n \"def _run_ansible_module(self, *args, **kwargs):\\n caller_info = kwargs.pop(\\\"caller_info\\\", None)\\n if not caller_info:\\n previous_frame = inspect.currentframe().f_back\\n caller_info = inspect.getframeinfo(previous_frame)\\n\\n module_args = copy.deepcopy(args)\\n module_kwargs = copy.deepcopy(kwargs)\\n\\n verbosity = module_kwargs.pop(\\\"verbosity\\\", None)\\n if not verbosity:\\n verbosity = self.options.get(\\\"verbosity\\\", 2)\\n module_ignore_errors = module_kwargs.pop(\\\"module_ignore_errors\\\", False)\\n module_attrs = module_kwargs.pop(\\\"module_attrs\\\", {})\\n\\n module_info = {\\n \\\"module_name\\\": self.module_name,\\n \\\"args\\\": module_args,\\n \\\"kwargs\\\": module_kwargs,\\n \\\"module_attrs\\\": module_attrs\\n }\\n self._log_modules(caller_info, module_info, verbosity)\\n\\n task = self.build_task(**module_info)\\n results = self.run_tasks(self.host_pattern, self.loader, self.im, self.vm, self.options, tasks=[task])\\n\\n self._log_results(caller_info, module_info, results, verbosity)\\n self._check_results(caller_info, module_info, results, module_ignore_errors, verbosity)\\n\\n if isinstance(self, AnsibleHost):\\n results = results[self.hostnames[0]]\\n\\n return results\",\n \"def run(self):\\r\\n self.inst.write(':RUN')\",\n \"def RunModule(self):\\n\\n module = self.viewModule.GetActive()\\n self.ShutdownViewModule()\\n overviewText = \\\"\\\"\\n\\n # o The RunTest() for all samples must now return a window that can\\n # be placed in a tab in the main notebook.\\n # o If an error occurs (or has occurred before) an error tab is created.\\n\\n if module is not None:\\n wx.LogMessage(\\\"Loading view module...\\\")\\n if hasattr(module, \\\"overview\\\"):\\n overviewText = module.overview\\n\\n try:\\n if hasattr(module, \\\"GetWindow\\\"):\\n self.viewPage = module.GetWindow(self, self.nb, self)\\n elif hasattr(module, \\\"runTest\\\"): # Obsoleted\\n self.viewPage = module.runTest(self, self.nb, self)\\n except:\\n self.viewPage = ViewModuleErrorPanel(self.nb, self.codePage,\\n ViewModuleError(sys.exc_info()), self)\\n\\n wx.LogMessage(\\\"Loaded %s for module %s\\\" % (self.viewPage, module))\\n\\n bg = self.nb.GetThemeBackgroundColour()\\n if bg:\\n self.viewPage.SetBackgroundColour(bg)\\n\\n assert self.viewPage is not None, \\\"runTest must return a window!\\\"\\n\\n else:\\n # There was a previous error in compiling or exec-ing\\n self.viewPage = ViewModuleErrorPanel(self.nb, self.codePage,\\n self.viewModule.GetErrorInfo(), self)\\n\\n self.SetOverview(self.viewModule.name + \\\" Help\\\", overviewText)\\n\\n if self.firstTime:\\n # change to the view page the first time a module is run\\n self.UpdateNotebook(2)\\n self.firstTime = False\\n else:\\n # otherwise just stay on the same tab in case the user has changed to another one\\n self.UpdateNotebook()\",\n \"def run_run(self, cmds):\\n pass\",\n \"def tfrun(args, build_modules, build_workspace, build_env):\\n\\n # loop through each selected module(s) and apply the action as specified by user\\n for m in build_modules:\\n print(\\\"\\\\n\\\\n****************************************************************************\\\")\\n print(\\\"Permforming action \\\\\\\"{0}\\\\\\\" for module {1}\\\".format(args.action, m))\\n print(\\\"****************************************************************************\\\\n\\\\n\\\")\\n run_module(args, m, build_workspace, build_env)\",\n \"def action_run(self):\\n pass\",\n \"def main():\\n obj = UnityFilesystem()\\n obj.perform_module_operation()\",\n \"def modExec(module):\\n modName = module.split('_')[-1]\\n if \\\"live\\\" in module:\\n dn = '{0} (live)'.format(modName.upper())\\n else:\\n dn = '{0}'.format(modName.upper())\\n\\n try:\\n modStart = datetime.utcnow()\\n log.info(\\\"Running {0}\\\".format(dn))\\n modImport = 'modules.' + module\\n\\n import_module(modImport)\\n\\n modOutput = [i for i in glob.glob(outputdir + '/*') if all(p in i for p in [modName, runID])]\\n try:\\n arch = [archive.add_file(os.path.basename(outfile)) for outfile in modOutput]\\n except IndexError:\\n pass\\n\\n modEnd = datetime.utcnow()\\n modRuntime = modEnd - modStart\\n log.debug(\\\"{0} finished in {1}.\\\".format(dn, modRuntime))\\n\\n except KeyboardInterrupt:\\n sys.stdout.write('\\\\r')\\n sys.stdout.flush()\\n log.error(\\\"{0} was killed. \\\".format(module))\\n\\n except Exception:\\n log.error(\\\"{0} failed: {1}\\\".format(module, [traceback.format_exc()]))\",\n \"def run(self):\\n self._setupLogger()\\n self.setup()\\n\\n self.logger.info(self.moduleName + \\\" starting run loop.\\\")\\n\\n while True:\\n self.loop()\",\n \"def Run():\\r\\n pass\",\n \"def run_script(self):\\n pass\",\n \"def run(self):\\n try:\\n self._run()\\n except Exception as err:\\n # TODO: Do Task Failure to run exception handling\\n pass\",\n \"def execute_module(self, \\n project_id: str, \\n branch_id: str, \\n module: ModuleHandle, \\n artifacts: Dict[str, ArtifactDescriptor]\\n ) -> None:\\n task = ExtendedTaskHandle(\\n project_id=project_id,\\n branch_id=branch_id,\\n module_id=module.identifier,\\n controller=self\\n )\\n self.tasks[task.task_id] = task\\n # print(\\\"Starting execution of {} with artifacts: [{}]\\\".format(module.command.command_id, artifacts))\\n self.backend.execute_async(\\n task=task,\\n command=module.command,\\n artifacts=artifacts,\\n resources=module.provenance.resources\\n )\",\n \"def run(self):\\n# log.trace(\\\" run task %s \\\", self.name)\\n return self.target.send(self.params)\",\n \"def exec_module(cls, *args, **kwargs): # real signature unknown\\n pass\",\n \"def exec_module(cls, *args, **kwargs): # real signature unknown\\n pass\",\n \"def run(self):\\n self.run()\",\n \"def main():\\n module = IRODSPermissionModule()\\n module.run()\",\n \"def run(self, script, *args, **kwargs):\\n return self._run('run', script, *args, **kwargs)\",\n \"def setup_module(module):\\n print(\\\"Start rishabhSetupModule of Program\\\")\",\n \"def run(self, host_list, module_name, module_args):\\n # create play with tasks\\n play_source = dict(\\n name=\\\"Ansible Play\\\",\\n hosts=host_list,\\n gather_facts='no',\\n tasks=[dict(action=dict(module=module_name, args=module_args))]\\n )\\n play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)\\n\\n # actually run it\\n tqm = None\\n self.callback = ResultsCollector()\\n try:\\n tqm = TaskQueueManager(\\n inventory=self.inventory,\\n variable_manager=self.variable_manager,\\n loader=self.loader,\\n options=self.options,\\n passwords=self.passwords,\\n )\\n tqm._stdout_callback = self.callback\\n tqm.run(play)\\n finally:\\n if tqm is not None:\\n tqm.cleanup()\",\n \"def do_load(self, name):\\n try:\\n self.runner.run()\\n\\n except():\\n print('Loading failed')\",\n \"def run_step(self):\\n self.control_instance.run_step()\",\n \"def run(self):\\n # check param and env\\n self.sanity_check()\\n\\n # only-check mode\\n if self.module.check_mode:\\n self.module.exit_json(**self.result)\\n\\n self.init_session()\\n\\n action = self.select_action()\\n action()\",\n \"def run(self):\\n self.__power_on()\\n\\n self.__main()\",\n \"def run(self, host_list, module_name, module_args):\\n # create play with tasks\\n play_source = dict(\\n name=\\\"Ansible Play\\\",\\n hosts=host_list,\\n gather_facts='no',\\n tasks=[dict(action=dict(module=module_name, args=module_args))]\\n )\\n play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)\\n\\n # actually run it\\n tqm = None\\n self.callback = AnsibleTaskResultCallback()\\n try:\\n tqm = TaskQueueManager(\\n inventory=self.inventory,\\n variable_manager=self.variable_manager,\\n loader=self.loader,\\n options=self.options,\\n passwords=self.passwords,\\n )\\n tqm._stdout_callback = self.callback\\n tqm.run(play)\\n finally:\\n if tqm is not None:\\n tqm.cleanup()\",\n \"def run_module_with_output(self, mod, payload=None, run_as_job=False, timeout=301):\\n options_str = 'use {}/{}\\\\n'.format(mod.moduletype, mod.modulename)\\n if self.rpc.consoles.console(self.cid).is_busy():\\n raise MsfError('Console {} is busy'.format(self.cid))\\n self.rpc.consoles.console(self.cid).read() # clear data buffer\\n opts = mod.runoptions.copy()\\n if payload is None:\\n opts['DisablePayloadHandler'] = True\\n\\n # Set module params\\n for k in opts.keys():\\n options_str += 'set {} {}\\\\n'.format(k, opts[k])\\n\\n # Set payload params\\n if mod.moduletype == 'exploit':\\n opts['TARGET'] = mod.target\\n options_str += 'set TARGET {}\\\\n'.format(mod.target)\\n\\n if 'DisablePayloadHandler' in opts and opts['DisablePayloadHandler']:\\n pass\\n elif isinstance(payload, PayloadModule):\\n if payload.modulename not in mod.payloads:\\n raise ValueError(\\n 'Invalid payload ({}) for given target ({}).'.format(payload.modulename, mod.target))\\n options_str += 'set payload {}\\\\n'.format(payload.modulename)\\n for k, v in payload.runoptions.items():\\n if v is None or (isinstance(v, str) and not v):\\n continue\\n options_str += 'set {} {}\\\\n'.format(k, v)\\n else:\\n raise ValueError('No valid PayloadModule provided for exploit execution.')\\n\\n # Run the module without directly opening a command line\\n options_str += 'run -z'\\n if run_as_job:\\n options_str += \\\" -j\\\"\\n self.rpc.consoles.console(self.cid).write(options_str)\\n data = ''\\n timer = 0\\n while data == '' or self.rpc.consoles.console(self.cid).is_busy():\\n time.sleep(1)\\n data += self.rpc.consoles.console(self.cid).read()['data']\\n timer += 1\\n if timer > timeout:\\n break\\n return data\",\n \"def __run(self):\\n sys.settrace(self.globaltrace)\\n self.__run_backup()\\n self.run = self.__run_backup\",\n \"def run(self):\\n raise NotImplementedError('Run method not implemented in %s' % type(self).__name__)\",\n \"def _doRun(self, model: Model):\\n raise Exception(\\\"Not implemented\\\")\",\n \"def run(self, tmp=None, task_vars=None):\\n if not task_vars:\\n task_vars = {}\\n\\n result = ActionBase.run(self, tmp=tmp, task_vars=task_vars)\\n result.update(\\n self._execute_module(\\n module_name=self.module_name,\\n module_args=self._task.args,\\n task_vars=task_vars,\\n wrap_async=self._task.async_val\\n )\\n )\\n\\n return result\",\n \"def run(self):\\n run_simple(self.hostname, self.port, self.dispatch,\\n use_reloader=self.debug)\",\n \"def run(_):\\n pass\",\n \"def run(self, *args, **kwargs):\\n raise NotImplementedError('Tasks must define the run method.')\",\n \"def execute(self):\\n # Do the task that the module is suppose to do.\\n\\n # Return a message telling the user that the task is done.\\n return \\\"\\\\nTemplate module did ...\\\"\",\n \"def local_run(self, parameters=None) -> \\\"Run\\\":\\n # NOTE -is there a use-case for this?\\n raise NotImplementedError()\",\n \"def do_workload(self):\\n module_manager = self._core.get_module_manager()\\n module = module_manager.get_module_by_name(self._values[\\\"name\\\"])\\n module_manager.uninstall_module(module)\",\n \"def run (self):\\n t = threading.Thread(target=self.runController)\\n t.start()\",\n \"def do_workload(self):\\n module_manager = self._core.get_module_manager()\\n module_manager.install_module(self.get_meta())\",\n \"def run_cmd(self):\\r\\n self.run = True\",\n \"def run_suite(self, name=\\\"_\\\", result=None):\\n result = result if result else self.result\\n self.mod_suites[name].run(result)\",\n \"def run(self):\\n return self.private_run()\",\n \"def run_script(extension_invocation_info):\\n acm.RunModuleWithParameters(__name__, acm.GetDefaultContext())\",\n \"async def run_controller(self, request):\\n self.run()\\n return {\\\"status\\\": \\\"ok\\\"}\",\n \"def run_game_logic(self):\\n pass\",\n \"def run(self):\\r\\n self.log(texto=f\\\"Executando {self._name}\\\")\",\n \"def execute_module(self, module, *args, **opts):\\n module_file = module.__file__\\n if module_file.endswith('.pyc'):\\n module_file = module_file[:-1]\\n cmd = [self._path]\\n if 'python_options' in opts:\\n cmd.extend(opts['python_options'])\\n del opts['python_options']\\n cmd.append(module_file)\\n cmd.extend(args)\\n return get_cmd_output(*cmd, **opts)\",\n \"def run_module():\\n parser = ap.ArgumentParser()\\n parser.add_argument(\\\"--dry_run\\\", action=\\\"store_true\\\", help=\\\"When provided, return zero exit\\\"\\n \\\" status irrespective of the number of failures\\\")\\n args = parser.parse_args()\\n params = read_params()\\n assert \\\"validation\\\" in params\\n dry_run_param = params[\\\"validation\\\"][\\\"common\\\"].get(\\\"dry_run\\\", False)\\n params[\\\"validation\\\"][\\\"common\\\"][\\\"dry_run\\\"] = args.dry_run or dry_run_param\\n validator = Validator(params)\\n validator.validate().print_and_exit(\\n get_structured_logger(__name__,\\n params[\\\"common\\\"].get(\\\"log_filename\\\", None)),\\n not (args.dry_run or dry_run_param))\",\n \"def run_script(self, params, config_no):\\n raise NotImplementedError()\",\n \"def run(self, run):\\n\\n self._run = run\",\n \"def run_module_ground_plan(args):\\n raise NotImplementedError\",\n \"def run(self, action_name=None, reuse=False, parallel=False):\\n os.environ['WORKSPACE'] = self.workspace\\n\\n self.download_actions()\\n self.instantiate_runners()\\n\\n if action_name:\\n self.wf['action'][action_name]['runner'].run(reuse)\\n else:\\n for s in self.get_stages():\\n self.run_stage(s, reuse, parallel)\",\n \"def _run(self):\\n raise NotImplemented(\\\"Abstract method '_run' need to be defined\\\")\",\n \"def run():\\n main()\",\n \"def run(self) -> None:\\n soc = self.make_soc()\\n soc_builder = self.build_soc(soc)\\n if self.args.load:\\n self.load(soc, soc_builder)\",\n \"def __run(self):\\n sys.settrace(self.globaltrace) # set self.globaltrace before thread start\\n self.__run_backup()\\n self.run = self.__run_backup\",\n \"def Run(self):\\n pass\",\n \"def _run(self):\\n\\n self.is_running = False\\n self.start()\\n self.function(*self.args, **self.kwargs)\",\n \"def run(self):\\n self.tcex.log.trace('run')\",\n \"def run(self):\\n\\n input_args = {}\\n self._execute(input_args, self.args)\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def __run(self):\\n try:\\n sys.settrace(self.globaltrace)\\n self.__run_backup()\\n self.run = self.__run_backup\\n except Exception, e:\\n e.message = e.__class__.__name__ + ' in ' + self.getName() + ': ' + e.message\\n self.__exception = e\",\n \"def RUN(self):\",\n \"def call(self, **params):\\n # NOTE - use __call__??\\n # TODO - move exec_script here?\\n # TODO - call should handle param defaults\\n from datapane.runner.exec_script import run\\n\\n run(self, params)\",\n \"def exec_module(self, module):\\n\\n if not self.filename.endswith(config.FILE_EXT) and not self.filename.endswith(\\n \\\"__init__.py\\\"\\n ):\\n print(\\\"Fatal error: ExtensionLoader is asked to load a normal file.\\\")\\n print(\\\"filename:\\\", self.filename)\\n print(\\\"Expected extension:\\\", config.FILE_EXT)\\n raise SystemExit\\n\\n name = module.__name__\\n if module.__name__ == config.MAIN_MODULE_NAME:\\n module.__name__ = \\\"__main__\\\"\\n config.MAIN_MODULE_NAME = None\\n\\n with open(self.filename) as f:\\n source = f.read()\\n\\n transforms.identify_requested_transformers(source)\\n\\n if config.TRANSFORMERS:\\n original = source\\n source = transforms.add_all_imports(source)\\n source = transforms.apply_source_transformations(source)\\n\\n if config.DIFF and original != source:\\n self.write_html_diff(name, original, source)\\n\\n if config.CONVERT and self.filename.endswith(config.FILE_EXT):\\n print(\\\"############### Original source: ############\\\\n\\\")\\n print(original)\\n print(\\\"\\\\n############### Converted source: ############\\\\n\\\")\\n print(source)\\n print(\\\"=\\\" * 50, \\\"\\\\n\\\")\\n\\n source = transforms.apply_ast_transformations(source)\\n exec(source, vars(module))\",\n \"def test_load_simple_module():\\n loader = Loader()\\n main_fname = loader.load(\\\"https://gist.githubusercontent.com/miohtama/80391980c2e73b285cfe/raw/dd89a55497ba33a6014453d9bb7432ab424c01cf/kivyhello.py#main\\\")\\n mod = path_to_mod_name(main_fname)\\n result = loader.run(mod, \\\"hello\\\")\\n assert result == \\\"Hello there\\\"\\n loader.close()\",\n \"def run():\\n\\n args = parse_arguments()\\n app = rummage_app.RummageApp(args)\\n app.MainLoop()\\n\\n return 0\",\n \"def run(self, *args, **kwargs):\\n self.actions()\\n\\n for funcName, action in self._actions.items():\\n actionName, actionParams = action\\n if actionParams == None:\\n func = getattr(self, funcName)\\n print('Running %s.%s' % (self._title, funcName))\\n func()\\n else:\\n self.runAction(actionName, funcName)\\n self._db.commit_db()\",\n \"def runner(self):\\n\\n if self.__do_initialize:\\n self.do_initialize()\\n self.__do_initialize = False\\n\\n elif self.__do_start_running:\\n self.do_start_running()\\n self.__do_start_running = False\\n\\n elif self.__do_stop_running:\\n #self.do_command(\\\"Stop\\\")\\n self.do_stop_running()\\n self.__do_stop_running = False\\n\\n elif self.__do_terminate:\\n self.do_terminate()\\n self.__do_terminate = False\\n\\n elif self.__do_pause_running:\\n self.do_command(\\\"Pause\\\")\\n self.__do_pause_running = False\\n\\n elif self.__do_resume_running:\\n self.do_command(\\\"Resume\\\")\\n self.__do_resume_running = False\\n\\n elif self.__do_recover:\\n self.do_recover()\\n self.__do_recover = False\\n\\n elif self.state(self.name) != \\\"stopped\\\":\\n self.check_proc_heartbeats()\\n self.check_proc_exceptions()\\n\\n if self.state(self.name) == \\\"running\\\":\\n self.display_lbne_artdaq_output()\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def runModtran(self, run):\\n # Call for the MODTRAN card class\\n modcard = ModtranCards()\\n modcard.setDefaults()\\n # Write the cards to the disk\\n modcard.writeModtranCards(self.modtran_visits[run], self.outfilename)\\n modcard.runModtran()\",\n \"def run_target(self):\\n\\n self.logger.info('run_target')\\n\\n # Clear all fields in GUI\\n self.clear_gui_sig.emit()\\n\\n # Stop a previous target if it had a process running\\n self.debugger.stop_target()\\n\\n if self.mode == self.AppMode.DYN_LINK:\\n self.run_target_dynlink()\\n elif self.mode == self.AppMode.DYN_LOAD:\\n self.run_target_dynload()\",\n \"def run_command(self):\\n global global_cycles_completed\\n global_cycles_completed = 0\\n\\n cycles = self.on_spin(wx.SpinCtrl)\\n\\n # check that this function has been called on pressing run button\\n text = \\\"\\\".join(\\n [_(u\\\"run_command function has been called, number of cycles is: \\\"), str(cycles)])\\n if self.state == 0:\\n self.canvas_2d.render(text, True)\\n else:\\n self.canvas_3d.render()\\n\\n if cycles is not None: # if the number of cycles provided is valid\\n self.monitors.reset_monitors()\\n print(\\\"\\\".join([_(u\\\"Running for \\\"), str(cycles), _(u\\\" cycles\\\")]))\\n self.devices.cold_startup()\\n if self.run_network(cycles):\\n global_cycles_completed += cycles\",\n \"def run(run_type, module, config):\\n print(\\\" -----------------------------------------------------------------\\\")\\n print(\\\" Beginning \\\" + run_type.lower() + \\\" test suite \\\")\\n print(\\\" -----------------------------------------------------------------\\\")\\n print(\\\"\\\")\\n summary = run_quiet(run_type, module, config)\\n print(\\\" -----------------------------------------------------------------\\\")\\n print(\\\" \\\" + run_type.capitalize() + \\\" test suite complete \\\")\\n print(\\\" -----------------------------------------------------------------\\\")\\n print(\\\"\\\")\\n return summary\",\n \"def run_component(self):\\n raise NotImplementedError\",\n \"def _run ( self ) :\\n raise NotImplementedError ( \\\"AppBase: method _run() should be implemented in a subclass\\\" )\",\n \"def run(self):\\n if len(self.modules) == 0:\\n raise ValueError(\\\"no modules registered\\\")\\n while True:\\n if not self._has_files() and not self._has_timeouts():\\n break\\n timeout = self._calculate_timeout()\\n ready, _, _ = select(self._files(), [], [], timeout)\\n self._dispatch_timeouts()\\n for file in ready:\\n self._trigger_file(file)\",\n \"def main():\\n module = AnsibleModule(argument_spec=L3_interfaceArgs.argument_spec,\\n supports_check_mode=True)\\n\\n result = L3_interface(module).execute_module()\\n module.exit_json(**result)\",\n \"def onReloadAndTest(self, moduleName=\\\"NeedleFinder\\\"):\\r\\n print \\\"onReloadAndTest\\\"; msgbox(whoami())\\r\\n try:\\r\\n self.onReload()\\r\\n evalString = 'globals()[\\\"%s\\\"].%sTest()' % (moduleName, moduleName)\\r\\n tester = eval(evalString)\\r\\n tester.runTest()\\r\\n except Exception, e:\\r\\n import traceback\\r\\n traceback.print_exc()\\r\\n qt.QMessageBox.warning(slicer.util.mainWindow(),\\r\\n \\\"Reload and Test\\\", 'Exception!\\\\n\\\\n' + str(e) + \\\"\\\\n\\\\nSee Python Console for Stack Trace\\\")\",\n \"def run(self, threaded=False):\\n if threaded:\\n Thread(target=self._run).start()\\n else:\\n self._run()\",\n \"def run(self) -> None:\\n self._hass.turn_on('scene.{0}'.format(self._args['scene']))\",\n \"def run():\\n import hmmmAssembler ; reload(hmmmAssembler) # import helpers\\n hmmmAssembler.main(Random) # this runs the code!\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.749783","0.74799657","0.70269644","0.69892204","0.68432194","0.67123836","0.6491966","0.64515406","0.6416656","0.64033836","0.63711715","0.6279245","0.6268681","0.6221671","0.6220211","0.62159735","0.6164637","0.61534256","0.6147704","0.61080045","0.608897","0.6048644","0.6047645","0.6001457","0.59787935","0.59534276","0.59491783","0.5943702","0.5943702","0.59371805","0.5932379","0.5920788","0.59065926","0.5866129","0.5855437","0.58542293","0.5836355","0.581457","0.580469","0.58029544","0.5801845","0.5780381","0.5763335","0.57618004","0.57483095","0.57394207","0.57389385","0.57294005","0.57263696","0.5719117","0.5708641","0.5702544","0.5695344","0.5690408","0.5681478","0.5672885","0.5636631","0.56073064","0.5605247","0.5604474","0.560312","0.5602961","0.5592514","0.5588278","0.55877286","0.558123","0.55766815","0.5568249","0.5550012","0.5542437","0.5538024","0.5537243","0.55210525","0.55201435","0.55201435","0.5499081","0.5492346","0.54908377","0.5490739","0.54891205","0.5473868","0.5473245","0.5446779","0.54382944","0.54378456","0.5436897","0.5436599","0.5432351","0.5409478","0.5400842","0.5399001","0.53910303","0.5390627","0.5386488","0.53848356","0.53807217","0.5378016","0.5378016","0.5378016","0.5378016","0.5378016"],"string":"[\n \"0.749783\",\n \"0.74799657\",\n \"0.70269644\",\n \"0.69892204\",\n \"0.68432194\",\n \"0.67123836\",\n \"0.6491966\",\n \"0.64515406\",\n \"0.6416656\",\n \"0.64033836\",\n \"0.63711715\",\n \"0.6279245\",\n \"0.6268681\",\n \"0.6221671\",\n \"0.6220211\",\n \"0.62159735\",\n \"0.6164637\",\n \"0.61534256\",\n \"0.6147704\",\n \"0.61080045\",\n \"0.608897\",\n \"0.6048644\",\n \"0.6047645\",\n \"0.6001457\",\n \"0.59787935\",\n \"0.59534276\",\n \"0.59491783\",\n \"0.5943702\",\n \"0.5943702\",\n \"0.59371805\",\n \"0.5932379\",\n \"0.5920788\",\n \"0.59065926\",\n \"0.5866129\",\n \"0.5855437\",\n \"0.58542293\",\n \"0.5836355\",\n \"0.581457\",\n \"0.580469\",\n \"0.58029544\",\n \"0.5801845\",\n \"0.5780381\",\n \"0.5763335\",\n \"0.57618004\",\n \"0.57483095\",\n \"0.57394207\",\n \"0.57389385\",\n \"0.57294005\",\n \"0.57263696\",\n \"0.5719117\",\n \"0.5708641\",\n \"0.5702544\",\n \"0.5695344\",\n \"0.5690408\",\n \"0.5681478\",\n \"0.5672885\",\n \"0.5636631\",\n \"0.56073064\",\n \"0.5605247\",\n \"0.5604474\",\n \"0.560312\",\n \"0.5602961\",\n \"0.5592514\",\n \"0.5588278\",\n \"0.55877286\",\n \"0.558123\",\n \"0.55766815\",\n \"0.5568249\",\n \"0.5550012\",\n \"0.5542437\",\n \"0.5538024\",\n \"0.5537243\",\n \"0.55210525\",\n \"0.55201435\",\n \"0.55201435\",\n \"0.5499081\",\n \"0.5492346\",\n \"0.54908377\",\n \"0.5490739\",\n \"0.54891205\",\n \"0.5473868\",\n \"0.5473245\",\n \"0.5446779\",\n \"0.54382944\",\n \"0.54378456\",\n \"0.5436897\",\n \"0.5436599\",\n \"0.5432351\",\n \"0.5409478\",\n \"0.5400842\",\n \"0.5399001\",\n \"0.53910303\",\n \"0.5390627\",\n \"0.5386488\",\n \"0.53848356\",\n \"0.53807217\",\n \"0.5378016\",\n \"0.5378016\",\n \"0.5378016\",\n \"0.5378016\",\n \"0.5378016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":588,"cells":{"query":{"kind":"string","value":"keys_to_track order is important! Matches will be tested in this order."},"document":{"kind":"string","value":"def __init__(self, keys_to_track):\r\n self.keys_to_track = keys_to_track\r\n self.tracker = {}\r\n for key_to_track in self.keys_to_track:\r\n self.tracker[key_to_track] = {}"},"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 _add_matches(self):\r\n for record in self.records:\r\n match_dict={key_to_track: record.get(key_to_track)\r\n for key_to_track in self.key_matcher.keys()}\r\n self.key_matcher.add(obj=record,\r\n match_dict=match_dict)","def test_matching_tracks(self):\n\n # 5037: Pop 101 (feat. Anami Vice) by Marianas Trench\n # 8755 : Satisfied (feat. Miguel & Queen Latifah) by Sia\n # 6699 : Un Besito Mas (feat. Juan Luis Guerra) by Jesse & Joy\n targets = {5037: '2fGFaTDbE8aS4f31fM0XE4',\n 8755: '1ybJ2itxCxPCPkcA9sOgTO',\n 6699: '1182pxG4uNxr3QqIH8b8k0',\n }\n\n matches = {track.i_id: track.id\n for track in self.tracks\n if track.i_id in targets}\n\n for i_id, s_id in targets.iteritems():\n self.assertEqual(s_id, matches[i_id])","def test_keys(self):\n storage = Storage()\n keys_to_set = {'1': 'hello',\n '2': 'bye',\n '3': [1, 2, 'three'],\n '4': {1: 'one', 2: 'two'},\n 'a': 1,\n 'aa': 2,\n 'abc':3,\n 'hello':4}\n for key in keys_to_set:\n storage.set(key, keys_to_set[key])\n\n pattern_answers = {'?': ['1','2','3','4','a'],\n '*': list(keys_to_set.keys()),\n '[13]': ['1', '3'],\n '[^a]': ['1','2','3','4'],\n '[1-3]': ['1','2','3'],\n '?[ae]*': ['aa', 'hello']}\n for pattern in pattern_answers:\n self.assertEqual(pattern_answers[pattern],\n storage.keys(pattern), f'For pattern \"{pattern}\" expected {pattern_answers[pattern]}.')","def matches(self):\n pass","def match(self, match_dict):\r\n for match_key in match_dict.keys():\r\n assert match_key in self.keys_to_track\r\n\r\n for key_to_track in self.keys_to_track:\r\n if match_dict.has_key(key_to_track):\r\n match_val = match_dict[key_to_track]\r\n if self.tracker[key_to_track].has_key(match_val):\r\n return self.tracker[key_to_track][match_val]\r\n return None","def test_keywords(self):\n\n test_cases = (\n makeTestCase('adele 21',\n AlbumResultMatcher(title=Equals('21'), artist=Equals('adele')),\n ArtistResultMatcher(title=Equals('adele'))),\n makeTestCase('kanye power',\n TrackResultMatcher(title=Equals('power', artist=Equals('kanye west'))),\n ArtistResultMatcher(title=Equals('kanye west')),\n AlbumResultMatcher(title=Equals('my beautiful dark twisted fantasy'))),\n makeTestCase('ratat party with children',\n TrackResultMatcher(title=Equals('party with children', artist=Equals('ratatat'))),\n ArtistResultMatcher(title=Equals('ratatat'))),\n makeTestCase('flobot fight with tools handlebars',\n TrackResultMatcher(title=Equals('handlebars')),\n ArtistResultMatcher(title=Equals('flobots')),\n AlbumResultMatcher(title=Equals('fight with tools')))\n )\n\n self._run_tests(tests, {})","def report_keyset(self):\n for i, matchset in enumerate(self.matches):\n if len(matchset) == 1:\n print \"[%02d]\" % i, fmt(sorted([k for k, data in matchset.items()]), BLUE)\n elif len(matchset) != 0:\n print \"[%02d]\" % i, fmt(sorted([k for k, data in matchset.items()]), WHITE)\n else:\n print \"[%02d]\" % i, fmt(\"[X]\", RED)","def add(self, obj, match_dict):\r\n for match_key in match_dict.keys():\r\n assert match_key in self.keys_to_track\r\n\r\n for key_to_track in self.keys_to_track:\r\n if match_dict.has_key(key_to_track):\r\n match_val = match_dict[key_to_track]\r\n if match_val is None or match_val == '':\r\n pass\r\n else:\r\n self.tracker[key_to_track][match_val] = obj","def test_ms_track_search(helpers):\n item_from_xml, item_from_dict = common_tests(\n MSTrack,\n MS_TRACK_SEARCH_XML,\n MS_TRACK_SEARCH_DICT,\n \"00020064tracksearch:pilgrim\",\n helpers,\n )\n getter_attributes_test(\n \"artist\", item_from_xml, item_from_dict, MS_TRACK_SEARCH_DICT.get(\"artist\")\n )\n getter_attributes_test(\n \"uri\", item_from_xml, item_from_dict, MS_TRACK_SEARCH_DICT[\"uri\"]\n )","def test_keys_eq(self):\n self.assertListEqual(self.result, self.expected)","def match_source_key(self, match):\n raise NotImplementedError","def testTrackDict3(self):\n\n goodTrackDict = {\n \"number\": \"12\", \"uid\": \"301356576\", \"codec_id\": \"S_TEXT/SSA\",\n \"codec_private_length\": \"783\", \"codec_private_data\": \"5b5363726\",\n \"language\": \"slv\", \"track_name\": \"Slovenian\", \"default_track\": \"0\",\n \"forced_track\": \"0\", \"enabled_track\": \"1\"\n }\n\n trackLine = _buildTrackLine(11, 'subtitles', goodTrackDict)\n\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\n\n self.assertEqual(\n goodTrackDict,\n trackDict\n )","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n param = val.parameter_type\n if param.k_bondorder or param.length_bondorder:\n bond = topology.get_bond_between(*key)\n fractional_bond_order = bond.fractional_bond_order\n if not fractional_bond_order:\n assert self._get_uses_interpolation(parameter_handler)\n raise RuntimeError(\n \"Bond orders should already be assigned at this point\",\n )\n else:\n fractional_bond_order = None\n topology_key = BondKey(\n atom_indices=key,\n bond_order=fractional_bond_order,\n )\n\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n bond_order=fractional_bond_order,\n )\n self.key_map[topology_key] = potential_key\n\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n topology=topology,\n assigned_terms=matches,\n valence_terms=valence_terms,\n )","def search_key_full_eq(self, key):\n for i in xrange(len(self.keys)):\n flag = 0\n for indx in range(4):\n if cmp(self.keys[i][indx],key[indx]) == 0:\n flag = 0\n continue\n if cmp(key[indx],\"*\") == 0:\n print \" visited internal! ==>\", self.keys[i]\n return self.pointers[i]\n elif self.keys[i][indx] > key[indx]:\n flag = 1\n else:\n flag = 2\n break \n # print \"searching %s:%s:%d\" %(str(self.keys[i]),str(key),flag)\n if flag == 1:\n if i > 0:\n print \" visited internal ==>\", self.keys[i] \n return self.pointers[i]\n else:\n print \" visited internal ==>\", self.keys[0] \n return self.pointers[0]\n elif flag == 0:\n print \" visited internals ==>\", self.keys[i]\n return self.pointers[i]\n print \" visited internalsed ==>\", self.keys[-1] \n return self.pointers[-1]","def test_audio_features(self):\n\n # 1ehPJRt49h6N0LoryqKZXq, 8737: How Far I'll Go (Alessia Cara Version) by Alessia Cara\n # 2fGFaTDbE8aS4f31fM0XE4, 5037: Pop 101 (feat. Anami Vice) by Marianas Trench\n targets = {8737: {'danceability': 0.317,\n 'energy': 0.562,\n 'key': 9,\n 'loudness': -9.609,\n 'mode': 1,\n 'speechiness': 0.395,\n 'acousticness': 0.124,\n 'instrumentalness': 0.000144,\n 'liveness': 0.0667,\n 'valence': 0.127,\n 'tempo': 181.100,\n 'duration_ms': 175507,\n 'time_signature': 4,\n },\n 5037: {'danceability': 0.756,\n 'energy': 0.658,\n 'key': 11,\n 'loudness': -6.128,\n 'mode': 0,\n 'speechiness': 0.202,\n 'acousticness': 0.0581,\n 'instrumentalness': 0,\n 'liveness': 0.0674,\n 'valence': 0.640,\n 'tempo': 120.018,\n 'duration_ms': 247829,\n 'time_signature': 4,\n },\n }\n\n results = {track.i_id: track for track in self.tracks if track.i_id in targets}\n\n for target, expecteds in targets.iteritems():\n result = results[target]\n for key, expected in expecteds.iteritems():\n self.assertEqual(result.__getattr__(key), expected)","def store_matches(\n self,\n parameter_handler: ImproperTorsionHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n self.key_map = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n parameter_handler._assert_correct_connectivity(\n val,\n [\n (0, 1),\n (1, 2),\n (1, 3),\n ],\n )\n n_terms = len(val.parameter_type.k)\n for n in range(n_terms):\n smirks = val.parameter_type.smirks\n non_central_indices = [key[0], key[2], key[3]]\n\n for permuted_key in [\n (\n non_central_indices[i],\n non_central_indices[j],\n non_central_indices[k],\n )\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\n ]:\n topology_key = ImproperTorsionKey(\n atom_indices=(key[1], *permuted_key),\n mult=n,\n )\n potential_key = PotentialKey(\n id=smirks,\n mult=n,\n associated_handler=\"ImproperTorsions\",\n )\n self.key_map[topology_key] = potential_key","def testTrackDict1(self):\n\n goodTrackDict = {\n \"number\": \"1\", \"uid\": \"1493619965\",\n \"codec_id\": \"V_MPEG4/ISO/AVC\", \"codec_private_length\": \"44\",\n \"codec_private_data\": \"014d4028ffe1001c80\", \"language\": \"eng\",\n \"pixel_dimensions\": \"1920x1080\", \"display_dimensions\": \"1920x1080\",\n \"default_track\": \"1\", \"forced_track\": \"0\", \"enabled_track\": \"1\",\n \"packetizer\": \"mpeg4_p10_video\", \"default_duration\": \"41708332\",\n \"content_encoding_algorithms\": \"3\"\n }\n\n trackLine = _buildTrackLine(0, 'video', goodTrackDict)\n\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\n\n self.assertEqual(\n goodTrackDict,\n trackDict\n )","def test_sample_mapped_keys(self):\r\n\r\n # With num_coverage=1 only the keys will be sampled\r\n actual = sample_mapped_keys(self.test_map, 1)\r\n self.assertEqual(actual, {'1': ['1'], '2': ['2']})\r\n\r\n actual = sample_mapped_keys(self.test_map, 3)\r\n for key in actual.keys():\r\n # check number of sampled keys\r\n self.assertEqual(3, len(actual[key]))\r\n for x in actual[key]:\r\n # check that sampled key is in the full list\r\n correct = list(self.test_map[key])\r\n correct.append(key)\r\n self.assertTrue(x in correct)","def test_match_ordered(self):\n first = dict(\n a=1,\n b=2,\n )\n\n second = OrderedDict(\n b=2,\n a=1,\n )\n\n check_keys_match_recursive(first, second, [])","def keysAll():","def matches(hand):\n return list(sorted(match_iter(hand), reverse=True))","def _match_tracks(artist, title, mb_tracks):\n # pylint: disable=R0914\n dbg(\"artists is %s\", artist)\n dbg(\"title is %s\", title)\n title_artist_str = c.g + title + c.w, c.g + artist + c.w\n xprint(\"\\nSearching for %s by %s\\n\\n\" % title_artist_str)\n\n def dtime(x):\n \"\"\" Format time to M:S. \"\"\"\n return time.strftime('%M:%S', time.gmtime(int(x)))\n\n # do matching\n for track in mb_tracks:\n ttitle = track['title']\n length = track['length']\n xprint(\"Search : %s%s - %s%s - %s\" % (c.y, artist, ttitle, c.w,\n dtime(length)))\n q = \"%s %s\" % (artist, ttitle)\n w = q = ttitle if artist == \"Various Artists\" else q\n query = generate_search_qs(w, 0, result_count=50)\n dbg(query)\n have_results = _search(q, query, splash=False, pre_load=False)\n\n if not have_results:\n xprint(c.r + \"Nothing matched :(\\n\" + c.w)\n continue\n\n results = g.model.songs\n s, score = _best_song_match(results, artist + \" \" + ttitle, length)\n cc = c.g if score > 85 else c.y\n cc = c.r if score < 75 else cc\n xprint(\"Matched: %s%s%s - %s \\n[%sMatch confidence: \"\n \"%s%s]\\n\" % (c.y, s.title, c.w, fmt_time(s.length),\n cc, score, c.w))\n yield s","def _keys_in_sorted(move):\n return (move.picking_id.id, move.product_id.responsible_id.id)","def testSortedNotes(self):\n for simple_score in self.simple_scores.values():\n notes = simple_score.sorted_notes\n assert all(notes[i].start_time <= notes[i + 1].start_time\n for i in range(len(notes) - 1))","def testTrackDict2(self):\n\n goodTrackDict = {\n \"number\": \"2\", \"uid\": \"3442966448\", \"codec_id\": \"A_VORBIS\",\n \"codec_private_length\": \"4412\", \"codec_private_data\": \"020808\",\n \"language\": \"jpn\", \"track_name\": \"2ch\\\\sVorbis\",\n \"default_track\": \"1\", \"forced_track\": \"0\", \"enabled_track\": \"1\",\n \"audio_sampling_frequency\": \"48000\", \"audio_channels\": \"2\"\n }\n\n trackLine = _buildTrackLine(1, 'audio', goodTrackDict)\n\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\n\n self.assertEqual(\n goodTrackDict,\n trackDict\n )","def keys(targets):","def check_keys(self):","def test_match_table_post(self):\n pass","def getPossibleMatchesList(self):\n return [p for p in self._patterns if p.startswith(self._keyCode)]","def store_matches(\n self,\n parameter_handler: ProperTorsionHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n self.key_map: dict[ProperTorsionKey, PotentialKey] = dict() # type: ignore[assignment]\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n param = val.parameter_type\n n_terms = len(val.parameter_type.phase)\n for n in range(n_terms):\n smirks = param.smirks\n if param.k_bondorder:\n # The relevant bond order is that of the _central_ bond in the torsion\n bond = topology.get_bond_between(key[1], key[2])\n fractional_bond_order = bond.fractional_bond_order\n if not fractional_bond_order:\n raise RuntimeError(\n \"Bond orders should already be assigned at this point\",\n )\n else:\n fractional_bond_order = None\n topology_key = ProperTorsionKey(\n atom_indices=key,\n mult=n,\n bond_order=fractional_bond_order,\n )\n potential_key = PotentialKey(\n id=smirks,\n mult=n,\n associated_handler=\"ProperTorsions\",\n bond_order=fractional_bond_order,\n )\n self.key_map[topology_key] = potential_key\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n topology=topology,\n assigned_terms=matches,\n valence_terms=list(topology.propers),\n )","def _fe_keyword_match(self, sample):\n result = OrderedDict()\n\n for item in self._keywords:\n result[item + \"_kw\"] = 1 if item in sample['fqdn'] else 0\n\n return result","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: \"Topology\",\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[\n Union[TopologyKey, LibraryChargeTopologyKey],\n PotentialKey,\n ] = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n topology_key = TopologyKey(atom_indices=key)\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n )\n self.key_map[topology_key] = potential_key\n\n if self.__class__.__name__ in [\n \"SMIRNOFFBondCollection\",\n \"SMIRNOFFAngleCollection\",\n ]:\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n assigned_terms=matches,\n topology=topology,\n valence_terms=valence_terms,\n )","def handleMatch(self, m):\r\n pass","def test_fuzz_insertions(self):\n key_range = 2 ** 64\n value_range = 1024\n key_set = set()\n \n d = SplayDict()\n for value in range(0, value_range):\n key = randint(0, key_range)\n d.put(key, value)\n key_set.add(key)\n \n keys = list(d.keys())\n self.assertEqual(len(keys), len(key_set), \"Length should reflect number of items inserted.\")\n self.assertEqual( len(keys), len(list(keys)), \"Iteration should find all items in tree.\")","def global_matches(self, visualise=False):\n kp = self._common_keypoints(*self.views)\n if visualise:\n self.show()\n logger.debug(f'{len(kp)} common keypoints found')\n return kp","def test_prefilter_exact_matches(self):\r\n seqs = [('s1 comment1', 'ACCTTGTTACTTT'), # three copies\r\n ('s2 comment2', 'ACCTTGTTACTTTC'), # one copy\r\n ('s3 comment3', 'ACCTTGTTACTTTCC'), # two copies\r\n ('s4 comment4', 'ACCTTGTTACTTT'),\r\n ('s5 comment5', 'ACCTTGTTACTTTCC'),\r\n ('s6 comment6', 'ACCTTGTTACTTT')]\r\n expected0 = [('QiimeExactMatch.s1', 'ACCTTGTTACTTT'),\r\n ('QiimeExactMatch.s2', 'ACCTTGTTACTTTC'),\r\n ('QiimeExactMatch.s3', 'ACCTTGTTACTTTCC')]\r\n expected1 = {'QiimeExactMatch.s1': ['s1', 's4', 's6'],\r\n 'QiimeExactMatch.s2': ['s2'],\r\n 'QiimeExactMatch.s3': ['s3', 's5']}\r\n expected = (expected0, expected1)\r\n p = OtuPicker({})\r\n actual = p._prefilter_exact_matches(seqs)\r\n self.assertEqual(actual, expected)","def assertKeys(self, data, expected):\r\n self.assertEqual(sorted(data.keys()), sorted(expected))","def on_match_start(self, *args, **kwargs):\n self._match = list()","def match(self, item):","def exact_match(self, Flow):\n for event in self._events:\n event.match_triad_chord(Flow)","def test_search_key_phrase(self):\n # search via key phrase.\n test = self.data.search(key_phrase='testing entries.', all_names=True)\n self.assertIn('testing entries.', test[0].notes)","def test_fromkeys(self):\n d = SplayDict.fromkeys(['a', 'b', 'c'], 1)\n self.assertIn('a' , d)\n self.assertIn('b' , d)\n self.assertIn('c' , d)\n self.assertEqual(d['a'] , 1)\n self.assertEqual(d['b'] , 1)\n self.assertEqual(d['c'] , 1)","def test_post_chain_search(self):\n pass","def sort_keys( self, results, ignore_cache=False ):\n if self.sorted_keys != None and (not ignore_cache):\n return self.sorted_keys\n mykeys = list( results.keys() ); mykeys.sort()\n self.sorted_keys = mykeys\n return mykeys","def _in_keys(self, key, keys):\n # sorting required for comparison\n key.sort()\n return key in keys","def getMatchIds(self):\n return sorted(self._matches.keys())","def current_source_key(self, match):\n raise NotImplementedError","def matchTracker(category):\n settings = settingsLoader()\n with open(torrentFileName, 'r') as TF:\n trackerInfo = TF.readline().split()[0]\n logging.debug(\"SORT: matchTracker: %s\" % trackerInfo)\n trackerList = (settings['categoriesDictSettings']\n [category]\n ['matches']\n ['matchTracker'])\n logging.debug(\"SORT: matchTracker: %s\" % trackerList)\n for EachTracker in trackerList:\n logging.debug(\"SORT:matchTracker: %s\" % EachTracker)\n if EachTracker in trackerInfo:\n return True\n return False","def set_cur_tracked_neighbors(self, match_det_track):\n neighbor_det_ids = self.cur_neighbor['det_ids']\n\n if neighbor_det_ids is not None:\n tracked_track_ids = []\n tracked_relative_pos = []\n for idx in range(len(neighbor_det_ids)):\n det_id = neighbor_det_ids[idx]\n if det_id in match_det_track.keys():\n tracked_track_ids.append(match_det_track[det_id])\n tracked_relative_pos.append(self.cur_neighbor['relative_pos'][idx])\n self.cur_neighbor['tracked_track_ids'] = tracked_track_ids\n self.cur_neighbor['tracked_relative_pos'] = tracked_relative_pos\n else:\n self.cur_neighbor['tracked_track_ids'] = None\n self.cur_neighbor['tracked_relative_pos'] = None","def keysWhichMatch(cls, *args):\n if len(cls.keys) < len(args) > 0:\n raise ValueError('Number of keys provided is too long.\\n'\n 'Len Class Keys: %s\\n'\n 'Len Provided Keys: %s\\n' % (len(cls.keys), len(args)))\n\n index = 0\n output = cls.db_key_tuples()\n\n for keyToCheck in args:\n temp = []\n for key in output:\n if key[index] == keyToCheck:\n temp.append(key)\n\n index += 1\n output = temp\n\n return output","def test_cmp_to_key(self):\n def compare_pokemon(a, b):\n # ``a`` and ``b`` are tuples of ``(key, class)``.\n return (\n (a[1].popularity < b[1].popularity)\n - (a[1].popularity > b[1].popularity)\n )\n\n registry =\\\n SortedClassRegistry(\n attr_name = 'element',\n sort_key = cmp_to_key(compare_pokemon),\n )\n\n @registry.register\n class Onix(Pokemon):\n element = 'rock'\n popularity = 50\n\n @registry.register\n class Cubone(Pokemon):\n element = 'water'\n popularity = 100\n\n @registry.register\n class Exeggcute(Pokemon):\n element = 'grass'\n popularity = 10\n\n # The registry iterates over registered classes in descending\n # order by ``popularity``.\n self.assertListEqual(\n list(registry.values()),\n [Cubone, Onix, Exeggcute],\n )","def _match(self) -> None:\n self.matched = [i for i in self.data if self.match(i)]\n self.unmatched = [i for i in self.data if not self.match(i)]","def match_track_spotify(\n track: Track,\n access_token: str,\n match_title=True,\n match_album=True,\n match_artist=True,\n *match_custom\n) -> bool:\n # Make sure all the custom attributes are valid\n for req in match_custom:\n if not hasattr(track, req):\n raise AttributeError\n spotify_results = spotify_track_search(\n \"{} {}\".format(track.title, track.artist)\n if track.artist != UNKNOWN_ARTIST\n else track.title,\n access_token,\n )\n if \"error\" in spotify_results:\n print(\"error {} {}\".format(spotify_results[\"status\"], spotify_results[\"error\"]))\n return False\n for strack in spotify_results:\n if match_title and strack[\"name\"] != track.title:\n continue\n if match_artist and strack[\"artists\"][0][\"name\"] != track.artist:\n continue\n if match_album and strack[\"album\"][\"name\"] != track.album:\n continue\n reqs_matched = False if match_custom else True\n for req in match_custom:\n if req not in strack:\n raise AttributeError\n if strack[req] != getattr(track, req):\n reqs_matched = False\n break\n if not reqs_matched:\n continue\n track.spotify_id = strack[\"id\"]\n track.save()\n return True\n return False","def test_sorted(self):\n keys = list(set([randint(0, 2^64) for i in range(0, 128)]))\n items = [(key, None) for key in keys]\n d = SplayDict(items)\n self.assertEquals(len(keys), len(d))\n self.assertEqual(len(keys) , len(list(d)))\n self.assertEqual(list(sorted(keys)) , list(d.keys()))","def find(self, image, k=None, ratio=None):\n if not self._targets:\n return []\n k = 2 if k is None else k\n ratio = 0.75 if ratio is None else ratio\n keypoints, descriptors = self._detector.detectAndCompute(image, None)\n if len(keypoints) < self.min_match_count:\n return []\n matches = self._matcher.knnMatch(descriptors, k=int(k))\n matches = [m[0] for m in matches if len(m) == 2 and m[0].distance < m[1].distance * ratio]\n if len(matches) < self.min_match_count:\n return []\n matches_by_id = [[] for _ in xrange(len(self._targets))]\n for m in matches:\n matches_by_id[m.imgIdx].append(m)\n tracked = []\n for imgIdx, matches in enumerate(matches_by_id):\n if len(matches) < self.min_match_count:\n continue\n target = self._targets[imgIdx]\n p0 = [target.keypoints[m.trainIdx].pt for m in matches]\n p1 = [keypoints[m.queryIdx].pt for m in matches]\n p0, p1 = np.float32((p0, p1))\n H, status = cv2.findHomography(p0, p1, cv2.RANSAC, 3.0)\n status = status.ravel() != 0\n if status.sum() < self.min_match_count:\n continue\n p0, p1 = np.int32((p0, p1))\n inliers = [((x0, y0), (x1, y1)) for (x0, y0), (x1, y1), s in zip(p0, p1, status) if s]\n outliers = [((x0, y0), (x1, y1)) for (x0, y0), (x1, y1), s in zip(p0, p1, status) if not s]\n quad = cv2.perspectiveTransform(target.quad.reshape(1, -1, 2), H).reshape(-1, 2)\n track = TrackedTarget(target=target, image=image, inliers=inliers, outliers=outliers, H=H, quad=quad)\n tracked.append(track)\n tracked.sort(key = lambda t: len(t.inliers), reverse=True)\n return tracked","def test_token_matching_respects_order() -> None:\n nlp = spacy.blank(\"en\")\n if spacy.__version__ < \"3.0.0\":\n ruler = SpaczzRuler(nlp)\n nlp.add_pipe(ruler, first=True)\n else:\n ruler = nlp.add_pipe(\"spaczz_ruler\", first=True)\n ruler.add_patterns(\n [\n {\n \"label\": \"COMPANY\",\n \"pattern\": [\n {\"IS_UPPER\": True, \"OP\": \"+\"},\n {\"IS_PUNCT\": True, \"OP\": \"?\"},\n {\"TEXT\": {\"REGEX\": r\"S\\.\\s?[A-Z]\\.?\\s?[A-Z]?\\.?\"}},\n {\"IS_PUNCT\": True, \"OP\": \"?\"},\n ],\n \"type\": \"token\",\n \"id\": \"COMPANY SL\",\n }\n ]\n )\n doc = nlp(\"My company is called LARGO AND MARMG S.L.\")\n assert doc.ents[0].text == \"LARGO AND MARMG S.L.\"","def check_exclusive_correct_top_level_keys_loaded_in_redis(tester: TestCase, expected_areas):\n expected_keys = []\n for area_name in expected_areas:\n # we expect each of the keys below for each area\n expected_keys.append(\"%s%s\" % (cities_boundaries_template_key, area_name))\n expected_keys.append(\"%s%s\" % (cities_places_template_key, area_name))\n expected_keys.append(\"%s%s\" % (cities_coordinates_template_key, area_name))\n\n tester.assertEqual(set(expected_keys), set(r.keys(\"*\")))","def keys():","def test_order(self):\n\n # issue a valid query\n # Assure proper execution, and get results from quilt_history\n o = str(quilt_test_core.call_quilt_script('quilt_submit.py', [\n '-y', 'out_of_order']))\n\n o = self.check_query_and_get_results3(o)\n\n # Check results\n # assure that results are in order\n l = []\n for i in xrange(1, 6):\n searchStr = \"{'timestamp': \" + str(i) + '}'\n index = o.find(searchStr)\n logging.debug(\"looking for string: \" + searchStr)\n self.assertTrue(index != -1)\n l.append(index)\n\n isSorted = all(l[i] <= l[i + 1] for i in xrange(len(l) - 1))\n self.assertTrue(isSorted)","def test_track(self):\r\n track = FedexTrackRequest(CONFIG_OBJ)\r\n track.TrackPackageIdentifier.Type = 'TRACKING_NUMBER_OR_DOORTAG'\r\n track.TrackPackageIdentifier.Value = '798114182456'\r\n track.send_request()\r\n \r\n for match in track.response.TrackDetails:\r\n # This should be the same tracking number on the response that we\r\n # asked for in the request.\r\n self.assertEqual(match.TrackingNumber, tracking_num)","def filter_matches_add(self, key, value):\n\t\tif key in self.filter_matches.keys():\n\t\t\tself.filter_matches[key].append(value)\n\t\telse:\n\t\t\tself.filter_matches[key]=[value]","def test_get_top_step_matches(self):\n\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\n\n self.assertEqual(len(results._top_step_matches), 2)\n\n cad3_top_matches = results.get_sample_matches('C_chlorochromatii_CaD3', top=True)\n dsm_273_top_matches = results.get_sample_matches('C_luteolum_DSM_273', top=True)\n\n self.assertEqual(len(cad3_top_matches), 1)\n self.assertEqual(len(dsm_273_top_matches), 1)\n\n self.assertEqual(cad3_top_matches['Protein_Accession'].tolist()[0], 'NC_007514.1_940')\n self.assertEqual(dsm_273_top_matches['Protein_Accession'].tolist()[0], 'NC_007512.1_1088')","def illustrate_matching(self):\n work_dir = self.work_dir\n draw_keys_oriented(work_dir+'matching_keys_im0.txt',\n work_dir+'input_0.orig.png',\n work_dir+'matching_keys_im0.png')\n draw_keys_oriented(work_dir+'matching_keys_im1.txt',\n work_dir+'input_1.orig.png',\n work_dir+'matching_keys_im1.png')\n draw_matches(work_dir+'matches.txt',\n work_dir+'input_0.orig.png',\n work_dir+'input_1.orig.png',\n work_dir+'OUTmatches.png')\n return 1","def make_consistent(self):\r\n\r\n for key in self.get_keys():\r\n self.eliminate_key(key)\r\n\r\n for i_temp in self.indexes(): #i will be a note index\r\n for j_temp in self.get_keys_from_note(i_temp):\r\n if self.key_dict_contains(j_temp):\r\n self.add_key(j_temp,Index(i_temp))\r\n## self.key_dict[j_temp].add(str(Index(i_temp)))\r\n else:\r\n self.initiate_new_key(j_temp,Index(i_temp))","def test_get_matches(self):\n\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\n\n self.assertEqual(len(\n results.step_matches.reset_index()[['Property_Identifier', 'Step_Number']].drop_duplicates()), 1)\n self.assertEqual(len(results.get_sample_matches('C_chlorochromatii_CaD3')), 5)\n self.assertEqual(len(results.get_sample_matches('C_luteolum_DSM_273')), 4)\n\n self.assertEqual(results.get_sample_matches('Your moms house'), None)","def match_candidates(self):\n for event in self._events:\n event.match_candidates()","def on_matching_rules(self, matching_rules):\n pass","def altloc_match(self, other: AtomKey) -> bool:\n ...","def determine_keywords(self):\n\n split = dict()\n split['email_cc'] = re.compile(\"^\\s*CC[-_]?MAIL[:=]\\s*(.*)\")\n split['email_cc2'] = re.compile(\"^\\s*C[Cc][:=]\\s*(.*)\")\n split['fixed_in'] = re.compile(\"^\\s*FIXED[-_]?IN[:=]\\s*(.*)\")\n\n numeric = dict()\n numeric['bug_fixed'] = re.compile(\"^\\s*(?:BUGS?|FEATURE)[:=]\\s*(.+)\")\n numeric['bug_cc'] = re.compile(\"^\\s*CCBUGS?[:=]\\s*(.+)\")\n\n presence = dict()\n presence['email_gui'] = re.compile(\"^\\s*GUI:\")\n presence['silent'] = re.compile(\"(?:CVS|SVN|GIT|SCM).?SILENT\")\n presence['notes'] = re.compile(\"(?:Notes added by 'git notes add'|Notes removed by 'git notes remove')\")\n\n results = defaultdict(list)\n for line in self.commit.message.split(\"\\n\"):\n # If our line starts with Summary: (as it does when using Arcanist's default template) then strip this off\n # This allows for people to fill keywords in the Differential Summary and have this work smoothly for them\n line = re.sub(\"^Summary: (.+)\", \"\\g<1>\", line)\n\n # Start processing our keywords...\n for (name, regex) in split.iteritems():\n match = re.match( regex, line )\n if match:\n results[name] += [result.strip() for result in match.group(1).split(\",\")]\n\n for (name, regex) in numeric.iteritems():\n match = re.match( regex, line )\n if match:\n results[name] += re.findall(\"(\\d{1,10})\", match.group(1))\n\n for (name, regex) in presence.iteritems():\n if re.match( regex, line ):\n results[name] = True\n\n self.keywords = results","def test_tracking_context(self):\n self.assert_expected_token_value({'foo': 'bar'})","def test_find_phrase_matches3(self):\n\t\ttest = sentiment.LibraryRun(self.text3, self.lib)\n\t\tobj_ut = test.find_phrase_matches(self.tokens_generator3)[0]\n\t\tself.assertEqual(dict(obj_ut),\n\t\t\t{'not good': [[2, -1, 0]], 'not very good': [[4, -1, 0]]})","def Keys(self) -> _n_1_t_4:","def recache_matches(self):\n matches = (Match.objects\n .filter(Q(winner = self) | Q(loser = self))\n .order_by('-played_time'))[:CACHED_RATING_LIMIT]\n matches = list(matches)\n matches.reverse()\n\n for match in matches:\n self.add_match(match, include_rank=True)\n\n self.save()","def match(self, key):\n position = key.index(RANGE) # which index to skip\n\n def predicate(keys_0, keys_1):\n \"\"\"whether all other indices match search key\"\"\"\n num_matching = 0\n for i, (k_0, k_1) in enumerate(zip(keys_0, keys_1)):\n if i != position and k_0 == k_1:\n num_matching += 1\n return num_matching == len(key) - 1\n\n # all variables\n keys = list(self.variables.keys())\n # only those which match, including any from the RANGE index\n keys = [k for k in keys if predicate(k, key)]\n # sort along the RANGE index\n keys.sort(key=lambda k: k[position])\n\n return [self.variables[k] for k in keys]","def test_token_function(self):\r\n assert TokenTestModel.objects().count() == 0\r\n for i in range(10):\r\n TokenTestModel.create(key=i, val=i)\r\n assert TokenTestModel.objects().count() == 10\r\n seen_keys = set()\r\n last_token = None\r\n for instance in TokenTestModel.objects().limit(5):\r\n last_token = instance.key\r\n seen_keys.add(last_token)\r\n assert len(seen_keys) == 5\r\n for instance in TokenTestModel.objects(pk__token__gt=functions.Token(last_token)):\r\n seen_keys.add(instance.key)\r\n\r\n assert len(seen_keys) == 10\r\n assert all([i in seen_keys for i in range(10)])","def matches(self, matches):\n\n self._matches = matches","def matches(self, matches):\n\n self._matches = matches","def testMatch2(self):\n self.inv._literals_filter['fruit'] = ['pear', 'apple']\n self.assertFalse(self.inv._Match('fruit', []))\n self.assertFalse(self.inv._Match('fruit', ['grape', 'orange']))\n self.assertTrue(self.inv._Match('fruit', ['grape', 'apple']))\n self.assertTrue(self.inv._Match('fruit', [['grape'], ['orange', 'apple']]))","def subStringMatchExact(target,key):\r\n index = find(target,key)\r\n #print 'here',target,key,index\r\n if index < 0 or len(key) <= 0 or len(target) <= 0:\r\n return ()\r\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\r\n offset = index + len(key)\r\n temp_matches = ()\r\n #print matches\r\n if matches:\r\n for x in range(0, len(matches)) :\r\n temp_matches += ((matches[x] + offset),)\r\n #matches.insert(0,index)\r\n temp_matches = (index,) + temp_matches\r\n return temp_matches","def get_known_words(label_matches):\r\n\tknown_words = set()\r\n\tfor key in label_matches.keys():\r\n\t\tif key[0] not in known_words:\r\n\t\t\tknown_words.add(key[0])\r\n\treturn known_words","def top_matches(self, prefs, p1):\n #print 'top_matches', prefs, p1\n #print '\\n'\n return [(p2, self.similarity(prefs[p1], prefs[p2])) for p2 in prefs if p2 != p1]","def keys(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Expression]:","def match_tracks(\n self,\n others,\n subset=None,\n method=\"simple\",\n interpolate_to=\"other\",\n thresh_dist=250.0,\n time_frac=0.5,\n return_dist_matrix=False,\n beta=100.0,\n r_planet=EARTH_RADIUS,\n ):\n # Recursive call for each of the available categies\n if subset is None:\n if self.is_categorised:\n result = {}\n for subset_key in self.cat_labels:\n result[subset_key] = self.match_tracks(\n others,\n subset=subset_key,\n method=method,\n interpolate_to=interpolate_to,\n thresh_dist=thresh_dist,\n time_frac=time_frac,\n return_dist_matrix=return_dist_matrix,\n beta=beta,\n r_planet=r_planet,\n )\n return result\n else:\n subset = \"all\"\n\n # Select subset\n sub_gb = self[subset].gb\n if len(sub_gb) == 0 or len(others) == 0:\n return []\n if isinstance(others, list):\n # match against a list of DataFrames of tracks\n other_gb = pd.concat(\n [OctantTrack.from_df(df) for df in others],\n keys=range(len(others)),\n names=self._mux_names,\n ).gb\n elif isinstance(others, self.__class__):\n # match against another TrackRun\n other_gb = others[subset].gb\n else:\n raise ArgumentError('Argument \"others\" ' f\"has a wrong type: {type(others)}\")\n match_pairs = []\n if method == \"intersection\":\n for idx, ot in self._pbar(sub_gb): # , desc=\"self tracks\"):\n for other_idx, other_ot in self._pbar(other_gb, leave=False):\n times = other_ot.time.values\n time_match_thresh = time_frac * (times[-1] - times[0]) / HOUR\n\n intersect = pd.merge(other_ot, ot, how=\"inner\", left_on=\"time\", right_on=\"time\")\n n_match_times = intersect.shape[0]\n if n_match_times > 0:\n _tstep_h = intersect.time.diff().values[-1] / HOUR\n dist = intersect[[\"lon_x\", \"lon_y\", \"lat_x\", \"lat_y\"]].apply(\n lambda x: great_circle(*x.values, r_planet=r_planet), axis=1\n )\n prox_time = (dist < (thresh_dist * KM2M)).sum() * _tstep_h\n if (\n n_match_times * _tstep_h > time_match_thresh\n ) and prox_time > time_match_thresh:\n match_pairs.append((idx, other_idx))\n break\n\n elif method == \"simple\":\n # TODO: explain\n ll = [\"lon\", \"lat\"]\n match_pairs = []\n for other_idx, other_ct in self._pbar(other_gb): # , desc=\"other tracks\"):\n candidates = []\n for idx, ct in self._pbar(sub_gb, leave=False): # , desc=\"self tracks\"):\n if interpolate_to == \"other\":\n df1, df2 = ct.copy(), other_ct\n elif interpolate_to == \"self\":\n df1, df2 = other_ct, ct.copy()\n l_start = max(df1.time.values[0], df2.time.values[0])\n e_end = min(df1.time.values[-1], df2.time.values[-1])\n if (e_end - l_start) / HOUR > 0:\n # df1 = df1.set_index('time')[ll]\n # ts = pd.Series(index=df2.time)\n # new_df1 = (pd.concat([df1, ts]).sort_index()\n # .interpolate(method='values')\n # .loc[ts.index])[ll]\n tmp_df2 = pd.DataFrame(\n data={\"lon\": np.nan, \"lat\": np.nan, \"time\": df2.time}, index=df2.index\n )\n new_df1 = (\n pd.concat([df1[[*ll, \"time\"]], tmp_df2], ignore_index=True, keys=\"time\")\n .set_index(\"time\")\n .sort_index()\n .interpolate(method=\"values\")\n .loc[tmp_df2.time]\n )[ll]\n new_df1 = new_df1[~new_df1.lon.isnull()]\n\n # thr = (time_frac * 0.5\n # * (df2.time.values[-1] - df2.time.values[0]\n # + df1.time.values[-1] - df2.time.values[0]))\n thr = time_frac * df2.shape[0]\n dist_diff = np.full(new_df1.shape[0], FILLVAL)\n for i, ((x1, y1), (x2, y2)) in enumerate(\n zip(new_df1[ll].values, df2[ll].values)\n ):\n dist_diff[i] = great_circle(x1, x2, y1, y2, r_planet=r_planet)\n within_r_idx = dist_diff < (thresh_dist * KM2M)\n # if within_r_idx.any():\n # if (new_df1[within_r_idx].index[-1]\n # - new_df1[within_r_idx].index[0]) > thr:\n # candidates.append((idx, within_r_idx.sum()))\n if within_r_idx.sum() > thr:\n candidates.append((idx, within_r_idx.sum()))\n if len(candidates) > 0:\n candidates = sorted(candidates, key=lambda x: x[1])\n final_idx = candidates[-1][0]\n match_pairs.append((final_idx, other_idx))\n\n elif method == \"bs2000\":\n # sub_list = [i[0] for i in list(sub_gb)]\n sub_indices = list(sub_gb.indices.keys())\n other_indices = list(other_gb.indices.keys())\n dist_matrix = np.full((len(sub_gb), len(other_gb)), FILLVAL)\n for i, (_, ct) in enumerate(self._pbar(sub_gb, leave=False)): # , desc=\"self tracks\"):\n x1, y1, t1 = ct.coord_view\n for j, (_, other_ct) in enumerate(self._pbar(other_gb, leave=False)):\n x2, y2, t2 = other_ct.coord_view\n dist_matrix[i, j] = distance_metric(\n x1, y1, t1, x2, y2, t2, beta=float(beta), r_planet=r_planet\n )\n for i, idx1 in enumerate(np.nanargmin(dist_matrix, axis=0)):\n for j, idx2 in enumerate(np.nanargmin(dist_matrix, axis=1)):\n if i == idx2 and j == idx1:\n match_pairs.append((sub_indices[idx1], other_indices[idx2]))\n if return_dist_matrix:\n return match_pairs, dist_matrix\n else:\n raise ArgumentError(f\"Unknown method: {method}\")\n\n return match_pairs","def test_compare_keys(self):\n dict1 = {\"a\":1 , \"b\":2 , \"c\":3}\n dict2 = {\"b\":1 ,\"a\":2 , \"c\":3}\n dict3 = {\"b\":1 ,\"d\":2 , \"c\":3}\n self.assertEqual(True, comparator.compare_keys(dict1, dict2))\n self.assertEqual(False, comparator.compare_keys(dict2, dict3))","def _matchUp(token, labels):\n ret = []\n\n # strip parens from the token, since they often appear in the\n # display_name, but are removed from the comment.\n token = utils.normalizeToken(token)\n decimalToken = _parseNumbers(token)\n\n # Iterate through the labels in descending order of label importance.\n for label_key in ['name', 'unit', 'qty', 'comment', 'range_end']:\n label_value = labels[label_key]\n if isinstance(label_value, basestring):\n for n, vt in enumerate(tokenizer.tokenize(label_value)):\n if utils.normalizeToken(vt).decode('utf-8') == token:\n ret.append(label_key.upper())\n\n elif decimalToken is not None:\n if label_value == decimalToken:\n ret.append(label_key.upper())\n\n return ret","def test_get_igv_tracks():\n\n # GIVEN an app with public cloud tracks initialized\n patched_track = {\"37\": [{\"name\": \"test track\"}]}\n cloud_tracks.public_tracks = patched_track\n\n # THEN the get_igv_tracks controller should return the default tracks\n igv_tracks = get_igv_tracks()\n for track in IGV_TRACKS[\"37\"]:\n assert track[\"name\"] in igv_tracks\n\n # and the name of the public cloud track\n assert \"test track\" in igv_tracks","def get_similar_tracks_for_original_track(track_svc, original_track):\n similar_tracks: Dict[str, StreamingServiceTrack] = {}\n for svc in SUPPORTED_STREAMING_SERVICES:\n if svc is track_svc:\n continue\n\n track = None\n with svc() as svc_client:\n try:\n track = svc_client.search_one_track(\n original_track.searchable_name\n )\n except Exception:\n log.error(\"Searching one track\", exc_info=True)\n\n if track:\n if tracks_are_similar(original_track, track):\n similar_tracks[svc.__name__] = track\n else:\n similar_tracks[svc.__name__] = None\n log.warning(\n f'Track title \"{track.searchable_name}\" for '\n f\"svc {svc.__name__} is not similar enough to \"\n f'\"{original_track.searchable_name}\".'\n )\n else:\n similar_tracks[svc.__name__] = None\n\n return similar_tracks","def test_get_filter_results_location_includes(self):\r\n\r\n data_file = open('data.txt', 'r')\r\n twitter_dict = tf.process_data(data_file)\r\n data_file.close()\r\n\r\n actual = tf.get_filter_results(twitter_dict, ['tomCruise', \\\r\n 'PerezHilton', 'tomfan'], {'follower': 'katieH'})\r\n expected = ['tomCruise', 'PerezHilton']\r\n self.assertEqual(actual, expected)","def orderPairs(self):\n pairsByTickers = {}\n for asset in self.availableTickers:\n holder = []\n for pair in self.allPairs:\n if asset.lower() in pair:\n holder.append(pair)\n pairsByTickers[asset] = holder\n return pairsByTickers","def assert_keys_match(keys, expected, allow_missing=True):\n if not allow_missing:\n missing = expected - keys\n assert not missing, 'missing keys: %s' % missing\n extra = keys - expected\n assert not extra, 'extraneous keys: %s' % extra","def test_fuzzy_matching_multi_match(\n nlp: Language, countries: List[Dict[str, Any]]\n) -> None:\n ruler = SpaczzRuler(nlp, spaczz_fuzzy_defaults={\"min_r2\": 85})\n ruler.add_patterns(countries)\n doc = nlp(\"This is a test that should find Northern Ireland and Ireland\")\n doc = ruler(doc)\n matches = [(ent.ent_id_, ent.text) for ent in doc.ents if ent.label_ == \"COUNTRY\"]\n assert matches == [(\"Northern Ireland\", \"Northern Ireland\"), (\"Ireland\", \"Ireland\")]","def test_keys(self):\n obs = self.tester.keys()\n self.assertTrue(isinstance(obs, Iterable))\n self.assertEqual(set(obs), self.exp_sample_ids)","def test_keys(self):\n obs = self.tester.keys()\n self.assertTrue(isinstance(obs, Iterable))\n self.assertEqual(set(obs), self.exp_sample_ids)","def _gen_matches(target_units, source_units, stoplist_set, features_size):\n for hits2positions in gen_hits2positions(\n target_units, source_units, stoplist_set, features_size):\n overhits2positions = {\n k: np.array(v) for k, v in hits2positions.items()\n if len(v) >= 2}\n for (t_ind, s_ind), positions in overhits2positions.items():\n yield (t_ind, s_ind, positions)","def split_by_home(matches, team_id):\n\n sorted_matches = {\n \"home\": [],\n \"away\": []\n }\n\n for match_id, match in matches.items():\n if match.hometeam.team_id == team_id:\n sorted_matches[\"home\"].append(match_id)\n elif match.awayteam.team_id == team_id:\n sorted_matches[\"away\"].append(match_id)\n\n return sorted_matches","def step040():\n logger.logMessage('Begin: matching work files')\n sKey = ''\n mKey = ''\n def readFile(f):\n line = f.readline().rstrip()\n if line == '':\n key = 'ZZZZZZZZZZZZZZZZZZZZZZZZZ'\n return None,key\n else:\n sp = line.split(';')\n key = '{0:25s}'.format(sp[1])[0:19]\n return sp,key\n\n m = open(dbDumpFile,'r')\n s = open(sortedCandidatesFile,'r')\n numrecs = 0\n with open(matchFile,'w') as match:\n mFields,mKey = readFile(m)\n sFields,sKey = readFile(s)\n while mFields != None or sFields != None:\n if sKey == mKey:\n match.write('{0:014d};{1:25s};{2:32s};{3:31s}\\n'.format(int(mFields[0]),mKey,sFields[2],sFields[3]))\n numrecs += 1\n if numrecs % 1000 == 0:\n logger.logMessage(level='DEBUG',message=\"{0:9d} records matched\".format(numrecs))\n sFields,sKey = readFile(s)\n mFields,mKey = readFile(m)\n elif sKey < mKey:\n sFields,sKey = readFile(s)\n else:\n logger.logMessage(level='WARNING',message='Record not matched: {0}'.format(mFields))\n mFields,mKey = readFile(m)\n logger.logMessage(\"Total matched: {0:d}\".format(numrecs))\n\n m.close()\n s.close()\n logger.logMessage('End : matching work files')","def add_match(self, event):\n event = copy.deepcopy(event)\n # Convert datetime's back to timestamps\n ts = self.rules.get(\"timestamp_field\")\n if ts in event:\n event[ts] = dt_to_ts(event[ts])\n\n self.matches.append(event)","def match_api_keys(key, ip):","def buffers_with_matches(self):\n _set = set(self.misc.buffers()) & set(self.matches.keys())\n _set.add(self.curr_buf.number)\n return list(_set)","def _add_to_recently_called(self, match, reporter):\n if utils.istrcmp(match.player1_tag, reporter):\n other = match.player2_tag\n else:\n other = match.player1_tag\n self.recently_called[other] = time()"],"string":"[\n \"def _add_matches(self):\\r\\n for record in self.records:\\r\\n match_dict={key_to_track: record.get(key_to_track)\\r\\n for key_to_track in self.key_matcher.keys()}\\r\\n self.key_matcher.add(obj=record,\\r\\n match_dict=match_dict)\",\n \"def test_matching_tracks(self):\\n\\n # 5037: Pop 101 (feat. Anami Vice) by Marianas Trench\\n # 8755 : Satisfied (feat. Miguel & Queen Latifah) by Sia\\n # 6699 : Un Besito Mas (feat. Juan Luis Guerra) by Jesse & Joy\\n targets = {5037: '2fGFaTDbE8aS4f31fM0XE4',\\n 8755: '1ybJ2itxCxPCPkcA9sOgTO',\\n 6699: '1182pxG4uNxr3QqIH8b8k0',\\n }\\n\\n matches = {track.i_id: track.id\\n for track in self.tracks\\n if track.i_id in targets}\\n\\n for i_id, s_id in targets.iteritems():\\n self.assertEqual(s_id, matches[i_id])\",\n \"def test_keys(self):\\n storage = Storage()\\n keys_to_set = {'1': 'hello',\\n '2': 'bye',\\n '3': [1, 2, 'three'],\\n '4': {1: 'one', 2: 'two'},\\n 'a': 1,\\n 'aa': 2,\\n 'abc':3,\\n 'hello':4}\\n for key in keys_to_set:\\n storage.set(key, keys_to_set[key])\\n\\n pattern_answers = {'?': ['1','2','3','4','a'],\\n '*': list(keys_to_set.keys()),\\n '[13]': ['1', '3'],\\n '[^a]': ['1','2','3','4'],\\n '[1-3]': ['1','2','3'],\\n '?[ae]*': ['aa', 'hello']}\\n for pattern in pattern_answers:\\n self.assertEqual(pattern_answers[pattern],\\n storage.keys(pattern), f'For pattern \\\"{pattern}\\\" expected {pattern_answers[pattern]}.')\",\n \"def matches(self):\\n pass\",\n \"def match(self, match_dict):\\r\\n for match_key in match_dict.keys():\\r\\n assert match_key in self.keys_to_track\\r\\n\\r\\n for key_to_track in self.keys_to_track:\\r\\n if match_dict.has_key(key_to_track):\\r\\n match_val = match_dict[key_to_track]\\r\\n if self.tracker[key_to_track].has_key(match_val):\\r\\n return self.tracker[key_to_track][match_val]\\r\\n return None\",\n \"def test_keywords(self):\\n\\n test_cases = (\\n makeTestCase('adele 21',\\n AlbumResultMatcher(title=Equals('21'), artist=Equals('adele')),\\n ArtistResultMatcher(title=Equals('adele'))),\\n makeTestCase('kanye power',\\n TrackResultMatcher(title=Equals('power', artist=Equals('kanye west'))),\\n ArtistResultMatcher(title=Equals('kanye west')),\\n AlbumResultMatcher(title=Equals('my beautiful dark twisted fantasy'))),\\n makeTestCase('ratat party with children',\\n TrackResultMatcher(title=Equals('party with children', artist=Equals('ratatat'))),\\n ArtistResultMatcher(title=Equals('ratatat'))),\\n makeTestCase('flobot fight with tools handlebars',\\n TrackResultMatcher(title=Equals('handlebars')),\\n ArtistResultMatcher(title=Equals('flobots')),\\n AlbumResultMatcher(title=Equals('fight with tools')))\\n )\\n\\n self._run_tests(tests, {})\",\n \"def report_keyset(self):\\n for i, matchset in enumerate(self.matches):\\n if len(matchset) == 1:\\n print \\\"[%02d]\\\" % i, fmt(sorted([k for k, data in matchset.items()]), BLUE)\\n elif len(matchset) != 0:\\n print \\\"[%02d]\\\" % i, fmt(sorted([k for k, data in matchset.items()]), WHITE)\\n else:\\n print \\\"[%02d]\\\" % i, fmt(\\\"[X]\\\", RED)\",\n \"def add(self, obj, match_dict):\\r\\n for match_key in match_dict.keys():\\r\\n assert match_key in self.keys_to_track\\r\\n\\r\\n for key_to_track in self.keys_to_track:\\r\\n if match_dict.has_key(key_to_track):\\r\\n match_val = match_dict[key_to_track]\\r\\n if match_val is None or match_val == '':\\r\\n pass\\r\\n else:\\r\\n self.tracker[key_to_track][match_val] = obj\",\n \"def test_ms_track_search(helpers):\\n item_from_xml, item_from_dict = common_tests(\\n MSTrack,\\n MS_TRACK_SEARCH_XML,\\n MS_TRACK_SEARCH_DICT,\\n \\\"00020064tracksearch:pilgrim\\\",\\n helpers,\\n )\\n getter_attributes_test(\\n \\\"artist\\\", item_from_xml, item_from_dict, MS_TRACK_SEARCH_DICT.get(\\\"artist\\\")\\n )\\n getter_attributes_test(\\n \\\"uri\\\", item_from_xml, item_from_dict, MS_TRACK_SEARCH_DICT[\\\"uri\\\"]\\n )\",\n \"def test_keys_eq(self):\\n self.assertListEqual(self.result, self.expected)\",\n \"def match_source_key(self, match):\\n raise NotImplementedError\",\n \"def testTrackDict3(self):\\n\\n goodTrackDict = {\\n \\\"number\\\": \\\"12\\\", \\\"uid\\\": \\\"301356576\\\", \\\"codec_id\\\": \\\"S_TEXT/SSA\\\",\\n \\\"codec_private_length\\\": \\\"783\\\", \\\"codec_private_data\\\": \\\"5b5363726\\\",\\n \\\"language\\\": \\\"slv\\\", \\\"track_name\\\": \\\"Slovenian\\\", \\\"default_track\\\": \\\"0\\\",\\n \\\"forced_track\\\": \\\"0\\\", \\\"enabled_track\\\": \\\"1\\\"\\n }\\n\\n trackLine = _buildTrackLine(11, 'subtitles', goodTrackDict)\\n\\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\\n\\n self.assertEqual(\\n goodTrackDict,\\n trackDict\\n )\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n param = val.parameter_type\\n if param.k_bondorder or param.length_bondorder:\\n bond = topology.get_bond_between(*key)\\n fractional_bond_order = bond.fractional_bond_order\\n if not fractional_bond_order:\\n assert self._get_uses_interpolation(parameter_handler)\\n raise RuntimeError(\\n \\\"Bond orders should already be assigned at this point\\\",\\n )\\n else:\\n fractional_bond_order = None\\n topology_key = BondKey(\\n atom_indices=key,\\n bond_order=fractional_bond_order,\\n )\\n\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n bond_order=fractional_bond_order,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n topology=topology,\\n assigned_terms=matches,\\n valence_terms=valence_terms,\\n )\",\n \"def search_key_full_eq(self, key):\\n for i in xrange(len(self.keys)):\\n flag = 0\\n for indx in range(4):\\n if cmp(self.keys[i][indx],key[indx]) == 0:\\n flag = 0\\n continue\\n if cmp(key[indx],\\\"*\\\") == 0:\\n print \\\" visited internal! ==>\\\", self.keys[i]\\n return self.pointers[i]\\n elif self.keys[i][indx] > key[indx]:\\n flag = 1\\n else:\\n flag = 2\\n break \\n # print \\\"searching %s:%s:%d\\\" %(str(self.keys[i]),str(key),flag)\\n if flag == 1:\\n if i > 0:\\n print \\\" visited internal ==>\\\", self.keys[i] \\n return self.pointers[i]\\n else:\\n print \\\" visited internal ==>\\\", self.keys[0] \\n return self.pointers[0]\\n elif flag == 0:\\n print \\\" visited internals ==>\\\", self.keys[i]\\n return self.pointers[i]\\n print \\\" visited internalsed ==>\\\", self.keys[-1] \\n return self.pointers[-1]\",\n \"def test_audio_features(self):\\n\\n # 1ehPJRt49h6N0LoryqKZXq, 8737: How Far I'll Go (Alessia Cara Version) by Alessia Cara\\n # 2fGFaTDbE8aS4f31fM0XE4, 5037: Pop 101 (feat. Anami Vice) by Marianas Trench\\n targets = {8737: {'danceability': 0.317,\\n 'energy': 0.562,\\n 'key': 9,\\n 'loudness': -9.609,\\n 'mode': 1,\\n 'speechiness': 0.395,\\n 'acousticness': 0.124,\\n 'instrumentalness': 0.000144,\\n 'liveness': 0.0667,\\n 'valence': 0.127,\\n 'tempo': 181.100,\\n 'duration_ms': 175507,\\n 'time_signature': 4,\\n },\\n 5037: {'danceability': 0.756,\\n 'energy': 0.658,\\n 'key': 11,\\n 'loudness': -6.128,\\n 'mode': 0,\\n 'speechiness': 0.202,\\n 'acousticness': 0.0581,\\n 'instrumentalness': 0,\\n 'liveness': 0.0674,\\n 'valence': 0.640,\\n 'tempo': 120.018,\\n 'duration_ms': 247829,\\n 'time_signature': 4,\\n },\\n }\\n\\n results = {track.i_id: track for track in self.tracks if track.i_id in targets}\\n\\n for target, expecteds in targets.iteritems():\\n result = results[target]\\n for key, expected in expecteds.iteritems():\\n self.assertEqual(result.__getattr__(key), expected)\",\n \"def store_matches(\\n self,\\n parameter_handler: ImproperTorsionHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n self.key_map = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n parameter_handler._assert_correct_connectivity(\\n val,\\n [\\n (0, 1),\\n (1, 2),\\n (1, 3),\\n ],\\n )\\n n_terms = len(val.parameter_type.k)\\n for n in range(n_terms):\\n smirks = val.parameter_type.smirks\\n non_central_indices = [key[0], key[2], key[3]]\\n\\n for permuted_key in [\\n (\\n non_central_indices[i],\\n non_central_indices[j],\\n non_central_indices[k],\\n )\\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\\n ]:\\n topology_key = ImproperTorsionKey(\\n atom_indices=(key[1], *permuted_key),\\n mult=n,\\n )\\n potential_key = PotentialKey(\\n id=smirks,\\n mult=n,\\n associated_handler=\\\"ImproperTorsions\\\",\\n )\\n self.key_map[topology_key] = potential_key\",\n \"def testTrackDict1(self):\\n\\n goodTrackDict = {\\n \\\"number\\\": \\\"1\\\", \\\"uid\\\": \\\"1493619965\\\",\\n \\\"codec_id\\\": \\\"V_MPEG4/ISO/AVC\\\", \\\"codec_private_length\\\": \\\"44\\\",\\n \\\"codec_private_data\\\": \\\"014d4028ffe1001c80\\\", \\\"language\\\": \\\"eng\\\",\\n \\\"pixel_dimensions\\\": \\\"1920x1080\\\", \\\"display_dimensions\\\": \\\"1920x1080\\\",\\n \\\"default_track\\\": \\\"1\\\", \\\"forced_track\\\": \\\"0\\\", \\\"enabled_track\\\": \\\"1\\\",\\n \\\"packetizer\\\": \\\"mpeg4_p10_video\\\", \\\"default_duration\\\": \\\"41708332\\\",\\n \\\"content_encoding_algorithms\\\": \\\"3\\\"\\n }\\n\\n trackLine = _buildTrackLine(0, 'video', goodTrackDict)\\n\\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\\n\\n self.assertEqual(\\n goodTrackDict,\\n trackDict\\n )\",\n \"def test_sample_mapped_keys(self):\\r\\n\\r\\n # With num_coverage=1 only the keys will be sampled\\r\\n actual = sample_mapped_keys(self.test_map, 1)\\r\\n self.assertEqual(actual, {'1': ['1'], '2': ['2']})\\r\\n\\r\\n actual = sample_mapped_keys(self.test_map, 3)\\r\\n for key in actual.keys():\\r\\n # check number of sampled keys\\r\\n self.assertEqual(3, len(actual[key]))\\r\\n for x in actual[key]:\\r\\n # check that sampled key is in the full list\\r\\n correct = list(self.test_map[key])\\r\\n correct.append(key)\\r\\n self.assertTrue(x in correct)\",\n \"def test_match_ordered(self):\\n first = dict(\\n a=1,\\n b=2,\\n )\\n\\n second = OrderedDict(\\n b=2,\\n a=1,\\n )\\n\\n check_keys_match_recursive(first, second, [])\",\n \"def keysAll():\",\n \"def matches(hand):\\n return list(sorted(match_iter(hand), reverse=True))\",\n \"def _match_tracks(artist, title, mb_tracks):\\n # pylint: disable=R0914\\n dbg(\\\"artists is %s\\\", artist)\\n dbg(\\\"title is %s\\\", title)\\n title_artist_str = c.g + title + c.w, c.g + artist + c.w\\n xprint(\\\"\\\\nSearching for %s by %s\\\\n\\\\n\\\" % title_artist_str)\\n\\n def dtime(x):\\n \\\"\\\"\\\" Format time to M:S. \\\"\\\"\\\"\\n return time.strftime('%M:%S', time.gmtime(int(x)))\\n\\n # do matching\\n for track in mb_tracks:\\n ttitle = track['title']\\n length = track['length']\\n xprint(\\\"Search : %s%s - %s%s - %s\\\" % (c.y, artist, ttitle, c.w,\\n dtime(length)))\\n q = \\\"%s %s\\\" % (artist, ttitle)\\n w = q = ttitle if artist == \\\"Various Artists\\\" else q\\n query = generate_search_qs(w, 0, result_count=50)\\n dbg(query)\\n have_results = _search(q, query, splash=False, pre_load=False)\\n\\n if not have_results:\\n xprint(c.r + \\\"Nothing matched :(\\\\n\\\" + c.w)\\n continue\\n\\n results = g.model.songs\\n s, score = _best_song_match(results, artist + \\\" \\\" + ttitle, length)\\n cc = c.g if score > 85 else c.y\\n cc = c.r if score < 75 else cc\\n xprint(\\\"Matched: %s%s%s - %s \\\\n[%sMatch confidence: \\\"\\n \\\"%s%s]\\\\n\\\" % (c.y, s.title, c.w, fmt_time(s.length),\\n cc, score, c.w))\\n yield s\",\n \"def _keys_in_sorted(move):\\n return (move.picking_id.id, move.product_id.responsible_id.id)\",\n \"def testSortedNotes(self):\\n for simple_score in self.simple_scores.values():\\n notes = simple_score.sorted_notes\\n assert all(notes[i].start_time <= notes[i + 1].start_time\\n for i in range(len(notes) - 1))\",\n \"def testTrackDict2(self):\\n\\n goodTrackDict = {\\n \\\"number\\\": \\\"2\\\", \\\"uid\\\": \\\"3442966448\\\", \\\"codec_id\\\": \\\"A_VORBIS\\\",\\n \\\"codec_private_length\\\": \\\"4412\\\", \\\"codec_private_data\\\": \\\"020808\\\",\\n \\\"language\\\": \\\"jpn\\\", \\\"track_name\\\": \\\"2ch\\\\\\\\sVorbis\\\",\\n \\\"default_track\\\": \\\"1\\\", \\\"forced_track\\\": \\\"0\\\", \\\"enabled_track\\\": \\\"1\\\",\\n \\\"audio_sampling_frequency\\\": \\\"48000\\\", \\\"audio_channels\\\": \\\"2\\\"\\n }\\n\\n trackLine = _buildTrackLine(1, 'audio', goodTrackDict)\\n\\n trackID, trackType, trackDict = tools._trackInfo(trackLine)\\n\\n self.assertEqual(\\n goodTrackDict,\\n trackDict\\n )\",\n \"def keys(targets):\",\n \"def check_keys(self):\",\n \"def test_match_table_post(self):\\n pass\",\n \"def getPossibleMatchesList(self):\\n return [p for p in self._patterns if p.startswith(self._keyCode)]\",\n \"def store_matches(\\n self,\\n parameter_handler: ProperTorsionHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n self.key_map: dict[ProperTorsionKey, PotentialKey] = dict() # type: ignore[assignment]\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n param = val.parameter_type\\n n_terms = len(val.parameter_type.phase)\\n for n in range(n_terms):\\n smirks = param.smirks\\n if param.k_bondorder:\\n # The relevant bond order is that of the _central_ bond in the torsion\\n bond = topology.get_bond_between(key[1], key[2])\\n fractional_bond_order = bond.fractional_bond_order\\n if not fractional_bond_order:\\n raise RuntimeError(\\n \\\"Bond orders should already be assigned at this point\\\",\\n )\\n else:\\n fractional_bond_order = None\\n topology_key = ProperTorsionKey(\\n atom_indices=key,\\n mult=n,\\n bond_order=fractional_bond_order,\\n )\\n potential_key = PotentialKey(\\n id=smirks,\\n mult=n,\\n associated_handler=\\\"ProperTorsions\\\",\\n bond_order=fractional_bond_order,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n topology=topology,\\n assigned_terms=matches,\\n valence_terms=list(topology.propers),\\n )\",\n \"def _fe_keyword_match(self, sample):\\n result = OrderedDict()\\n\\n for item in self._keywords:\\n result[item + \\\"_kw\\\"] = 1 if item in sample['fqdn'] else 0\\n\\n return result\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: \\\"Topology\\\",\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[\\n Union[TopologyKey, LibraryChargeTopologyKey],\\n PotentialKey,\\n ] = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n topology_key = TopologyKey(atom_indices=key)\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n if self.__class__.__name__ in [\\n \\\"SMIRNOFFBondCollection\\\",\\n \\\"SMIRNOFFAngleCollection\\\",\\n ]:\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n assigned_terms=matches,\\n topology=topology,\\n valence_terms=valence_terms,\\n )\",\n \"def handleMatch(self, m):\\r\\n pass\",\n \"def test_fuzz_insertions(self):\\n key_range = 2 ** 64\\n value_range = 1024\\n key_set = set()\\n \\n d = SplayDict()\\n for value in range(0, value_range):\\n key = randint(0, key_range)\\n d.put(key, value)\\n key_set.add(key)\\n \\n keys = list(d.keys())\\n self.assertEqual(len(keys), len(key_set), \\\"Length should reflect number of items inserted.\\\")\\n self.assertEqual( len(keys), len(list(keys)), \\\"Iteration should find all items in tree.\\\")\",\n \"def global_matches(self, visualise=False):\\n kp = self._common_keypoints(*self.views)\\n if visualise:\\n self.show()\\n logger.debug(f'{len(kp)} common keypoints found')\\n return kp\",\n \"def test_prefilter_exact_matches(self):\\r\\n seqs = [('s1 comment1', 'ACCTTGTTACTTT'), # three copies\\r\\n ('s2 comment2', 'ACCTTGTTACTTTC'), # one copy\\r\\n ('s3 comment3', 'ACCTTGTTACTTTCC'), # two copies\\r\\n ('s4 comment4', 'ACCTTGTTACTTT'),\\r\\n ('s5 comment5', 'ACCTTGTTACTTTCC'),\\r\\n ('s6 comment6', 'ACCTTGTTACTTT')]\\r\\n expected0 = [('QiimeExactMatch.s1', 'ACCTTGTTACTTT'),\\r\\n ('QiimeExactMatch.s2', 'ACCTTGTTACTTTC'),\\r\\n ('QiimeExactMatch.s3', 'ACCTTGTTACTTTCC')]\\r\\n expected1 = {'QiimeExactMatch.s1': ['s1', 's4', 's6'],\\r\\n 'QiimeExactMatch.s2': ['s2'],\\r\\n 'QiimeExactMatch.s3': ['s3', 's5']}\\r\\n expected = (expected0, expected1)\\r\\n p = OtuPicker({})\\r\\n actual = p._prefilter_exact_matches(seqs)\\r\\n self.assertEqual(actual, expected)\",\n \"def assertKeys(self, data, expected):\\r\\n self.assertEqual(sorted(data.keys()), sorted(expected))\",\n \"def on_match_start(self, *args, **kwargs):\\n self._match = list()\",\n \"def match(self, item):\",\n \"def exact_match(self, Flow):\\n for event in self._events:\\n event.match_triad_chord(Flow)\",\n \"def test_search_key_phrase(self):\\n # search via key phrase.\\n test = self.data.search(key_phrase='testing entries.', all_names=True)\\n self.assertIn('testing entries.', test[0].notes)\",\n \"def test_fromkeys(self):\\n d = SplayDict.fromkeys(['a', 'b', 'c'], 1)\\n self.assertIn('a' , d)\\n self.assertIn('b' , d)\\n self.assertIn('c' , d)\\n self.assertEqual(d['a'] , 1)\\n self.assertEqual(d['b'] , 1)\\n self.assertEqual(d['c'] , 1)\",\n \"def test_post_chain_search(self):\\n pass\",\n \"def sort_keys( self, results, ignore_cache=False ):\\n if self.sorted_keys != None and (not ignore_cache):\\n return self.sorted_keys\\n mykeys = list( results.keys() ); mykeys.sort()\\n self.sorted_keys = mykeys\\n return mykeys\",\n \"def _in_keys(self, key, keys):\\n # sorting required for comparison\\n key.sort()\\n return key in keys\",\n \"def getMatchIds(self):\\n return sorted(self._matches.keys())\",\n \"def current_source_key(self, match):\\n raise NotImplementedError\",\n \"def matchTracker(category):\\n settings = settingsLoader()\\n with open(torrentFileName, 'r') as TF:\\n trackerInfo = TF.readline().split()[0]\\n logging.debug(\\\"SORT: matchTracker: %s\\\" % trackerInfo)\\n trackerList = (settings['categoriesDictSettings']\\n [category]\\n ['matches']\\n ['matchTracker'])\\n logging.debug(\\\"SORT: matchTracker: %s\\\" % trackerList)\\n for EachTracker in trackerList:\\n logging.debug(\\\"SORT:matchTracker: %s\\\" % EachTracker)\\n if EachTracker in trackerInfo:\\n return True\\n return False\",\n \"def set_cur_tracked_neighbors(self, match_det_track):\\n neighbor_det_ids = self.cur_neighbor['det_ids']\\n\\n if neighbor_det_ids is not None:\\n tracked_track_ids = []\\n tracked_relative_pos = []\\n for idx in range(len(neighbor_det_ids)):\\n det_id = neighbor_det_ids[idx]\\n if det_id in match_det_track.keys():\\n tracked_track_ids.append(match_det_track[det_id])\\n tracked_relative_pos.append(self.cur_neighbor['relative_pos'][idx])\\n self.cur_neighbor['tracked_track_ids'] = tracked_track_ids\\n self.cur_neighbor['tracked_relative_pos'] = tracked_relative_pos\\n else:\\n self.cur_neighbor['tracked_track_ids'] = None\\n self.cur_neighbor['tracked_relative_pos'] = None\",\n \"def keysWhichMatch(cls, *args):\\n if len(cls.keys) < len(args) > 0:\\n raise ValueError('Number of keys provided is too long.\\\\n'\\n 'Len Class Keys: %s\\\\n'\\n 'Len Provided Keys: %s\\\\n' % (len(cls.keys), len(args)))\\n\\n index = 0\\n output = cls.db_key_tuples()\\n\\n for keyToCheck in args:\\n temp = []\\n for key in output:\\n if key[index] == keyToCheck:\\n temp.append(key)\\n\\n index += 1\\n output = temp\\n\\n return output\",\n \"def test_cmp_to_key(self):\\n def compare_pokemon(a, b):\\n # ``a`` and ``b`` are tuples of ``(key, class)``.\\n return (\\n (a[1].popularity < b[1].popularity)\\n - (a[1].popularity > b[1].popularity)\\n )\\n\\n registry =\\\\\\n SortedClassRegistry(\\n attr_name = 'element',\\n sort_key = cmp_to_key(compare_pokemon),\\n )\\n\\n @registry.register\\n class Onix(Pokemon):\\n element = 'rock'\\n popularity = 50\\n\\n @registry.register\\n class Cubone(Pokemon):\\n element = 'water'\\n popularity = 100\\n\\n @registry.register\\n class Exeggcute(Pokemon):\\n element = 'grass'\\n popularity = 10\\n\\n # The registry iterates over registered classes in descending\\n # order by ``popularity``.\\n self.assertListEqual(\\n list(registry.values()),\\n [Cubone, Onix, Exeggcute],\\n )\",\n \"def _match(self) -> None:\\n self.matched = [i for i in self.data if self.match(i)]\\n self.unmatched = [i for i in self.data if not self.match(i)]\",\n \"def match_track_spotify(\\n track: Track,\\n access_token: str,\\n match_title=True,\\n match_album=True,\\n match_artist=True,\\n *match_custom\\n) -> bool:\\n # Make sure all the custom attributes are valid\\n for req in match_custom:\\n if not hasattr(track, req):\\n raise AttributeError\\n spotify_results = spotify_track_search(\\n \\\"{} {}\\\".format(track.title, track.artist)\\n if track.artist != UNKNOWN_ARTIST\\n else track.title,\\n access_token,\\n )\\n if \\\"error\\\" in spotify_results:\\n print(\\\"error {} {}\\\".format(spotify_results[\\\"status\\\"], spotify_results[\\\"error\\\"]))\\n return False\\n for strack in spotify_results:\\n if match_title and strack[\\\"name\\\"] != track.title:\\n continue\\n if match_artist and strack[\\\"artists\\\"][0][\\\"name\\\"] != track.artist:\\n continue\\n if match_album and strack[\\\"album\\\"][\\\"name\\\"] != track.album:\\n continue\\n reqs_matched = False if match_custom else True\\n for req in match_custom:\\n if req not in strack:\\n raise AttributeError\\n if strack[req] != getattr(track, req):\\n reqs_matched = False\\n break\\n if not reqs_matched:\\n continue\\n track.spotify_id = strack[\\\"id\\\"]\\n track.save()\\n return True\\n return False\",\n \"def test_sorted(self):\\n keys = list(set([randint(0, 2^64) for i in range(0, 128)]))\\n items = [(key, None) for key in keys]\\n d = SplayDict(items)\\n self.assertEquals(len(keys), len(d))\\n self.assertEqual(len(keys) , len(list(d)))\\n self.assertEqual(list(sorted(keys)) , list(d.keys()))\",\n \"def find(self, image, k=None, ratio=None):\\n if not self._targets:\\n return []\\n k = 2 if k is None else k\\n ratio = 0.75 if ratio is None else ratio\\n keypoints, descriptors = self._detector.detectAndCompute(image, None)\\n if len(keypoints) < self.min_match_count:\\n return []\\n matches = self._matcher.knnMatch(descriptors, k=int(k))\\n matches = [m[0] for m in matches if len(m) == 2 and m[0].distance < m[1].distance * ratio]\\n if len(matches) < self.min_match_count:\\n return []\\n matches_by_id = [[] for _ in xrange(len(self._targets))]\\n for m in matches:\\n matches_by_id[m.imgIdx].append(m)\\n tracked = []\\n for imgIdx, matches in enumerate(matches_by_id):\\n if len(matches) < self.min_match_count:\\n continue\\n target = self._targets[imgIdx]\\n p0 = [target.keypoints[m.trainIdx].pt for m in matches]\\n p1 = [keypoints[m.queryIdx].pt for m in matches]\\n p0, p1 = np.float32((p0, p1))\\n H, status = cv2.findHomography(p0, p1, cv2.RANSAC, 3.0)\\n status = status.ravel() != 0\\n if status.sum() < self.min_match_count:\\n continue\\n p0, p1 = np.int32((p0, p1))\\n inliers = [((x0, y0), (x1, y1)) for (x0, y0), (x1, y1), s in zip(p0, p1, status) if s]\\n outliers = [((x0, y0), (x1, y1)) for (x0, y0), (x1, y1), s in zip(p0, p1, status) if not s]\\n quad = cv2.perspectiveTransform(target.quad.reshape(1, -1, 2), H).reshape(-1, 2)\\n track = TrackedTarget(target=target, image=image, inliers=inliers, outliers=outliers, H=H, quad=quad)\\n tracked.append(track)\\n tracked.sort(key = lambda t: len(t.inliers), reverse=True)\\n return tracked\",\n \"def test_token_matching_respects_order() -> None:\\n nlp = spacy.blank(\\\"en\\\")\\n if spacy.__version__ < \\\"3.0.0\\\":\\n ruler = SpaczzRuler(nlp)\\n nlp.add_pipe(ruler, first=True)\\n else:\\n ruler = nlp.add_pipe(\\\"spaczz_ruler\\\", first=True)\\n ruler.add_patterns(\\n [\\n {\\n \\\"label\\\": \\\"COMPANY\\\",\\n \\\"pattern\\\": [\\n {\\\"IS_UPPER\\\": True, \\\"OP\\\": \\\"+\\\"},\\n {\\\"IS_PUNCT\\\": True, \\\"OP\\\": \\\"?\\\"},\\n {\\\"TEXT\\\": {\\\"REGEX\\\": r\\\"S\\\\.\\\\s?[A-Z]\\\\.?\\\\s?[A-Z]?\\\\.?\\\"}},\\n {\\\"IS_PUNCT\\\": True, \\\"OP\\\": \\\"?\\\"},\\n ],\\n \\\"type\\\": \\\"token\\\",\\n \\\"id\\\": \\\"COMPANY SL\\\",\\n }\\n ]\\n )\\n doc = nlp(\\\"My company is called LARGO AND MARMG S.L.\\\")\\n assert doc.ents[0].text == \\\"LARGO AND MARMG S.L.\\\"\",\n \"def check_exclusive_correct_top_level_keys_loaded_in_redis(tester: TestCase, expected_areas):\\n expected_keys = []\\n for area_name in expected_areas:\\n # we expect each of the keys below for each area\\n expected_keys.append(\\\"%s%s\\\" % (cities_boundaries_template_key, area_name))\\n expected_keys.append(\\\"%s%s\\\" % (cities_places_template_key, area_name))\\n expected_keys.append(\\\"%s%s\\\" % (cities_coordinates_template_key, area_name))\\n\\n tester.assertEqual(set(expected_keys), set(r.keys(\\\"*\\\")))\",\n \"def keys():\",\n \"def test_order(self):\\n\\n # issue a valid query\\n # Assure proper execution, and get results from quilt_history\\n o = str(quilt_test_core.call_quilt_script('quilt_submit.py', [\\n '-y', 'out_of_order']))\\n\\n o = self.check_query_and_get_results3(o)\\n\\n # Check results\\n # assure that results are in order\\n l = []\\n for i in xrange(1, 6):\\n searchStr = \\\"{'timestamp': \\\" + str(i) + '}'\\n index = o.find(searchStr)\\n logging.debug(\\\"looking for string: \\\" + searchStr)\\n self.assertTrue(index != -1)\\n l.append(index)\\n\\n isSorted = all(l[i] <= l[i + 1] for i in xrange(len(l) - 1))\\n self.assertTrue(isSorted)\",\n \"def test_track(self):\\r\\n track = FedexTrackRequest(CONFIG_OBJ)\\r\\n track.TrackPackageIdentifier.Type = 'TRACKING_NUMBER_OR_DOORTAG'\\r\\n track.TrackPackageIdentifier.Value = '798114182456'\\r\\n track.send_request()\\r\\n \\r\\n for match in track.response.TrackDetails:\\r\\n # This should be the same tracking number on the response that we\\r\\n # asked for in the request.\\r\\n self.assertEqual(match.TrackingNumber, tracking_num)\",\n \"def filter_matches_add(self, key, value):\\n\\t\\tif key in self.filter_matches.keys():\\n\\t\\t\\tself.filter_matches[key].append(value)\\n\\t\\telse:\\n\\t\\t\\tself.filter_matches[key]=[value]\",\n \"def test_get_top_step_matches(self):\\n\\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\\n\\n self.assertEqual(len(results._top_step_matches), 2)\\n\\n cad3_top_matches = results.get_sample_matches('C_chlorochromatii_CaD3', top=True)\\n dsm_273_top_matches = results.get_sample_matches('C_luteolum_DSM_273', top=True)\\n\\n self.assertEqual(len(cad3_top_matches), 1)\\n self.assertEqual(len(dsm_273_top_matches), 1)\\n\\n self.assertEqual(cad3_top_matches['Protein_Accession'].tolist()[0], 'NC_007514.1_940')\\n self.assertEqual(dsm_273_top_matches['Protein_Accession'].tolist()[0], 'NC_007512.1_1088')\",\n \"def illustrate_matching(self):\\n work_dir = self.work_dir\\n draw_keys_oriented(work_dir+'matching_keys_im0.txt',\\n work_dir+'input_0.orig.png',\\n work_dir+'matching_keys_im0.png')\\n draw_keys_oriented(work_dir+'matching_keys_im1.txt',\\n work_dir+'input_1.orig.png',\\n work_dir+'matching_keys_im1.png')\\n draw_matches(work_dir+'matches.txt',\\n work_dir+'input_0.orig.png',\\n work_dir+'input_1.orig.png',\\n work_dir+'OUTmatches.png')\\n return 1\",\n \"def make_consistent(self):\\r\\n\\r\\n for key in self.get_keys():\\r\\n self.eliminate_key(key)\\r\\n\\r\\n for i_temp in self.indexes(): #i will be a note index\\r\\n for j_temp in self.get_keys_from_note(i_temp):\\r\\n if self.key_dict_contains(j_temp):\\r\\n self.add_key(j_temp,Index(i_temp))\\r\\n## self.key_dict[j_temp].add(str(Index(i_temp)))\\r\\n else:\\r\\n self.initiate_new_key(j_temp,Index(i_temp))\",\n \"def test_get_matches(self):\\n\\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\\n\\n self.assertEqual(len(\\n results.step_matches.reset_index()[['Property_Identifier', 'Step_Number']].drop_duplicates()), 1)\\n self.assertEqual(len(results.get_sample_matches('C_chlorochromatii_CaD3')), 5)\\n self.assertEqual(len(results.get_sample_matches('C_luteolum_DSM_273')), 4)\\n\\n self.assertEqual(results.get_sample_matches('Your moms house'), None)\",\n \"def match_candidates(self):\\n for event in self._events:\\n event.match_candidates()\",\n \"def on_matching_rules(self, matching_rules):\\n pass\",\n \"def altloc_match(self, other: AtomKey) -> bool:\\n ...\",\n \"def determine_keywords(self):\\n\\n split = dict()\\n split['email_cc'] = re.compile(\\\"^\\\\s*CC[-_]?MAIL[:=]\\\\s*(.*)\\\")\\n split['email_cc2'] = re.compile(\\\"^\\\\s*C[Cc][:=]\\\\s*(.*)\\\")\\n split['fixed_in'] = re.compile(\\\"^\\\\s*FIXED[-_]?IN[:=]\\\\s*(.*)\\\")\\n\\n numeric = dict()\\n numeric['bug_fixed'] = re.compile(\\\"^\\\\s*(?:BUGS?|FEATURE)[:=]\\\\s*(.+)\\\")\\n numeric['bug_cc'] = re.compile(\\\"^\\\\s*CCBUGS?[:=]\\\\s*(.+)\\\")\\n\\n presence = dict()\\n presence['email_gui'] = re.compile(\\\"^\\\\s*GUI:\\\")\\n presence['silent'] = re.compile(\\\"(?:CVS|SVN|GIT|SCM).?SILENT\\\")\\n presence['notes'] = re.compile(\\\"(?:Notes added by 'git notes add'|Notes removed by 'git notes remove')\\\")\\n\\n results = defaultdict(list)\\n for line in self.commit.message.split(\\\"\\\\n\\\"):\\n # If our line starts with Summary: (as it does when using Arcanist's default template) then strip this off\\n # This allows for people to fill keywords in the Differential Summary and have this work smoothly for them\\n line = re.sub(\\\"^Summary: (.+)\\\", \\\"\\\\g<1>\\\", line)\\n\\n # Start processing our keywords...\\n for (name, regex) in split.iteritems():\\n match = re.match( regex, line )\\n if match:\\n results[name] += [result.strip() for result in match.group(1).split(\\\",\\\")]\\n\\n for (name, regex) in numeric.iteritems():\\n match = re.match( regex, line )\\n if match:\\n results[name] += re.findall(\\\"(\\\\d{1,10})\\\", match.group(1))\\n\\n for (name, regex) in presence.iteritems():\\n if re.match( regex, line ):\\n results[name] = True\\n\\n self.keywords = results\",\n \"def test_tracking_context(self):\\n self.assert_expected_token_value({'foo': 'bar'})\",\n \"def test_find_phrase_matches3(self):\\n\\t\\ttest = sentiment.LibraryRun(self.text3, self.lib)\\n\\t\\tobj_ut = test.find_phrase_matches(self.tokens_generator3)[0]\\n\\t\\tself.assertEqual(dict(obj_ut),\\n\\t\\t\\t{'not good': [[2, -1, 0]], 'not very good': [[4, -1, 0]]})\",\n \"def Keys(self) -> _n_1_t_4:\",\n \"def recache_matches(self):\\n matches = (Match.objects\\n .filter(Q(winner = self) | Q(loser = self))\\n .order_by('-played_time'))[:CACHED_RATING_LIMIT]\\n matches = list(matches)\\n matches.reverse()\\n\\n for match in matches:\\n self.add_match(match, include_rank=True)\\n\\n self.save()\",\n \"def match(self, key):\\n position = key.index(RANGE) # which index to skip\\n\\n def predicate(keys_0, keys_1):\\n \\\"\\\"\\\"whether all other indices match search key\\\"\\\"\\\"\\n num_matching = 0\\n for i, (k_0, k_1) in enumerate(zip(keys_0, keys_1)):\\n if i != position and k_0 == k_1:\\n num_matching += 1\\n return num_matching == len(key) - 1\\n\\n # all variables\\n keys = list(self.variables.keys())\\n # only those which match, including any from the RANGE index\\n keys = [k for k in keys if predicate(k, key)]\\n # sort along the RANGE index\\n keys.sort(key=lambda k: k[position])\\n\\n return [self.variables[k] for k in keys]\",\n \"def test_token_function(self):\\r\\n assert TokenTestModel.objects().count() == 0\\r\\n for i in range(10):\\r\\n TokenTestModel.create(key=i, val=i)\\r\\n assert TokenTestModel.objects().count() == 10\\r\\n seen_keys = set()\\r\\n last_token = None\\r\\n for instance in TokenTestModel.objects().limit(5):\\r\\n last_token = instance.key\\r\\n seen_keys.add(last_token)\\r\\n assert len(seen_keys) == 5\\r\\n for instance in TokenTestModel.objects(pk__token__gt=functions.Token(last_token)):\\r\\n seen_keys.add(instance.key)\\r\\n\\r\\n assert len(seen_keys) == 10\\r\\n assert all([i in seen_keys for i in range(10)])\",\n \"def matches(self, matches):\\n\\n self._matches = matches\",\n \"def matches(self, matches):\\n\\n self._matches = matches\",\n \"def testMatch2(self):\\n self.inv._literals_filter['fruit'] = ['pear', 'apple']\\n self.assertFalse(self.inv._Match('fruit', []))\\n self.assertFalse(self.inv._Match('fruit', ['grape', 'orange']))\\n self.assertTrue(self.inv._Match('fruit', ['grape', 'apple']))\\n self.assertTrue(self.inv._Match('fruit', [['grape'], ['orange', 'apple']]))\",\n \"def subStringMatchExact(target,key):\\r\\n index = find(target,key)\\r\\n #print 'here',target,key,index\\r\\n if index < 0 or len(key) <= 0 or len(target) <= 0:\\r\\n return ()\\r\\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\\r\\n offset = index + len(key)\\r\\n temp_matches = ()\\r\\n #print matches\\r\\n if matches:\\r\\n for x in range(0, len(matches)) :\\r\\n temp_matches += ((matches[x] + offset),)\\r\\n #matches.insert(0,index)\\r\\n temp_matches = (index,) + temp_matches\\r\\n return temp_matches\",\n \"def get_known_words(label_matches):\\r\\n\\tknown_words = set()\\r\\n\\tfor key in label_matches.keys():\\r\\n\\t\\tif key[0] not in known_words:\\r\\n\\t\\t\\tknown_words.add(key[0])\\r\\n\\treturn known_words\",\n \"def top_matches(self, prefs, p1):\\n #print 'top_matches', prefs, p1\\n #print '\\\\n'\\n return [(p2, self.similarity(prefs[p1], prefs[p2])) for p2 in prefs if p2 != p1]\",\n \"def keys(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Expression]:\",\n \"def match_tracks(\\n self,\\n others,\\n subset=None,\\n method=\\\"simple\\\",\\n interpolate_to=\\\"other\\\",\\n thresh_dist=250.0,\\n time_frac=0.5,\\n return_dist_matrix=False,\\n beta=100.0,\\n r_planet=EARTH_RADIUS,\\n ):\\n # Recursive call for each of the available categies\\n if subset is None:\\n if self.is_categorised:\\n result = {}\\n for subset_key in self.cat_labels:\\n result[subset_key] = self.match_tracks(\\n others,\\n subset=subset_key,\\n method=method,\\n interpolate_to=interpolate_to,\\n thresh_dist=thresh_dist,\\n time_frac=time_frac,\\n return_dist_matrix=return_dist_matrix,\\n beta=beta,\\n r_planet=r_planet,\\n )\\n return result\\n else:\\n subset = \\\"all\\\"\\n\\n # Select subset\\n sub_gb = self[subset].gb\\n if len(sub_gb) == 0 or len(others) == 0:\\n return []\\n if isinstance(others, list):\\n # match against a list of DataFrames of tracks\\n other_gb = pd.concat(\\n [OctantTrack.from_df(df) for df in others],\\n keys=range(len(others)),\\n names=self._mux_names,\\n ).gb\\n elif isinstance(others, self.__class__):\\n # match against another TrackRun\\n other_gb = others[subset].gb\\n else:\\n raise ArgumentError('Argument \\\"others\\\" ' f\\\"has a wrong type: {type(others)}\\\")\\n match_pairs = []\\n if method == \\\"intersection\\\":\\n for idx, ot in self._pbar(sub_gb): # , desc=\\\"self tracks\\\"):\\n for other_idx, other_ot in self._pbar(other_gb, leave=False):\\n times = other_ot.time.values\\n time_match_thresh = time_frac * (times[-1] - times[0]) / HOUR\\n\\n intersect = pd.merge(other_ot, ot, how=\\\"inner\\\", left_on=\\\"time\\\", right_on=\\\"time\\\")\\n n_match_times = intersect.shape[0]\\n if n_match_times > 0:\\n _tstep_h = intersect.time.diff().values[-1] / HOUR\\n dist = intersect[[\\\"lon_x\\\", \\\"lon_y\\\", \\\"lat_x\\\", \\\"lat_y\\\"]].apply(\\n lambda x: great_circle(*x.values, r_planet=r_planet), axis=1\\n )\\n prox_time = (dist < (thresh_dist * KM2M)).sum() * _tstep_h\\n if (\\n n_match_times * _tstep_h > time_match_thresh\\n ) and prox_time > time_match_thresh:\\n match_pairs.append((idx, other_idx))\\n break\\n\\n elif method == \\\"simple\\\":\\n # TODO: explain\\n ll = [\\\"lon\\\", \\\"lat\\\"]\\n match_pairs = []\\n for other_idx, other_ct in self._pbar(other_gb): # , desc=\\\"other tracks\\\"):\\n candidates = []\\n for idx, ct in self._pbar(sub_gb, leave=False): # , desc=\\\"self tracks\\\"):\\n if interpolate_to == \\\"other\\\":\\n df1, df2 = ct.copy(), other_ct\\n elif interpolate_to == \\\"self\\\":\\n df1, df2 = other_ct, ct.copy()\\n l_start = max(df1.time.values[0], df2.time.values[0])\\n e_end = min(df1.time.values[-1], df2.time.values[-1])\\n if (e_end - l_start) / HOUR > 0:\\n # df1 = df1.set_index('time')[ll]\\n # ts = pd.Series(index=df2.time)\\n # new_df1 = (pd.concat([df1, ts]).sort_index()\\n # .interpolate(method='values')\\n # .loc[ts.index])[ll]\\n tmp_df2 = pd.DataFrame(\\n data={\\\"lon\\\": np.nan, \\\"lat\\\": np.nan, \\\"time\\\": df2.time}, index=df2.index\\n )\\n new_df1 = (\\n pd.concat([df1[[*ll, \\\"time\\\"]], tmp_df2], ignore_index=True, keys=\\\"time\\\")\\n .set_index(\\\"time\\\")\\n .sort_index()\\n .interpolate(method=\\\"values\\\")\\n .loc[tmp_df2.time]\\n )[ll]\\n new_df1 = new_df1[~new_df1.lon.isnull()]\\n\\n # thr = (time_frac * 0.5\\n # * (df2.time.values[-1] - df2.time.values[0]\\n # + df1.time.values[-1] - df2.time.values[0]))\\n thr = time_frac * df2.shape[0]\\n dist_diff = np.full(new_df1.shape[0], FILLVAL)\\n for i, ((x1, y1), (x2, y2)) in enumerate(\\n zip(new_df1[ll].values, df2[ll].values)\\n ):\\n dist_diff[i] = great_circle(x1, x2, y1, y2, r_planet=r_planet)\\n within_r_idx = dist_diff < (thresh_dist * KM2M)\\n # if within_r_idx.any():\\n # if (new_df1[within_r_idx].index[-1]\\n # - new_df1[within_r_idx].index[0]) > thr:\\n # candidates.append((idx, within_r_idx.sum()))\\n if within_r_idx.sum() > thr:\\n candidates.append((idx, within_r_idx.sum()))\\n if len(candidates) > 0:\\n candidates = sorted(candidates, key=lambda x: x[1])\\n final_idx = candidates[-1][0]\\n match_pairs.append((final_idx, other_idx))\\n\\n elif method == \\\"bs2000\\\":\\n # sub_list = [i[0] for i in list(sub_gb)]\\n sub_indices = list(sub_gb.indices.keys())\\n other_indices = list(other_gb.indices.keys())\\n dist_matrix = np.full((len(sub_gb), len(other_gb)), FILLVAL)\\n for i, (_, ct) in enumerate(self._pbar(sub_gb, leave=False)): # , desc=\\\"self tracks\\\"):\\n x1, y1, t1 = ct.coord_view\\n for j, (_, other_ct) in enumerate(self._pbar(other_gb, leave=False)):\\n x2, y2, t2 = other_ct.coord_view\\n dist_matrix[i, j] = distance_metric(\\n x1, y1, t1, x2, y2, t2, beta=float(beta), r_planet=r_planet\\n )\\n for i, idx1 in enumerate(np.nanargmin(dist_matrix, axis=0)):\\n for j, idx2 in enumerate(np.nanargmin(dist_matrix, axis=1)):\\n if i == idx2 and j == idx1:\\n match_pairs.append((sub_indices[idx1], other_indices[idx2]))\\n if return_dist_matrix:\\n return match_pairs, dist_matrix\\n else:\\n raise ArgumentError(f\\\"Unknown method: {method}\\\")\\n\\n return match_pairs\",\n \"def test_compare_keys(self):\\n dict1 = {\\\"a\\\":1 , \\\"b\\\":2 , \\\"c\\\":3}\\n dict2 = {\\\"b\\\":1 ,\\\"a\\\":2 , \\\"c\\\":3}\\n dict3 = {\\\"b\\\":1 ,\\\"d\\\":2 , \\\"c\\\":3}\\n self.assertEqual(True, comparator.compare_keys(dict1, dict2))\\n self.assertEqual(False, comparator.compare_keys(dict2, dict3))\",\n \"def _matchUp(token, labels):\\n ret = []\\n\\n # strip parens from the token, since they often appear in the\\n # display_name, but are removed from the comment.\\n token = utils.normalizeToken(token)\\n decimalToken = _parseNumbers(token)\\n\\n # Iterate through the labels in descending order of label importance.\\n for label_key in ['name', 'unit', 'qty', 'comment', 'range_end']:\\n label_value = labels[label_key]\\n if isinstance(label_value, basestring):\\n for n, vt in enumerate(tokenizer.tokenize(label_value)):\\n if utils.normalizeToken(vt).decode('utf-8') == token:\\n ret.append(label_key.upper())\\n\\n elif decimalToken is not None:\\n if label_value == decimalToken:\\n ret.append(label_key.upper())\\n\\n return ret\",\n \"def test_get_igv_tracks():\\n\\n # GIVEN an app with public cloud tracks initialized\\n patched_track = {\\\"37\\\": [{\\\"name\\\": \\\"test track\\\"}]}\\n cloud_tracks.public_tracks = patched_track\\n\\n # THEN the get_igv_tracks controller should return the default tracks\\n igv_tracks = get_igv_tracks()\\n for track in IGV_TRACKS[\\\"37\\\"]:\\n assert track[\\\"name\\\"] in igv_tracks\\n\\n # and the name of the public cloud track\\n assert \\\"test track\\\" in igv_tracks\",\n \"def get_similar_tracks_for_original_track(track_svc, original_track):\\n similar_tracks: Dict[str, StreamingServiceTrack] = {}\\n for svc in SUPPORTED_STREAMING_SERVICES:\\n if svc is track_svc:\\n continue\\n\\n track = None\\n with svc() as svc_client:\\n try:\\n track = svc_client.search_one_track(\\n original_track.searchable_name\\n )\\n except Exception:\\n log.error(\\\"Searching one track\\\", exc_info=True)\\n\\n if track:\\n if tracks_are_similar(original_track, track):\\n similar_tracks[svc.__name__] = track\\n else:\\n similar_tracks[svc.__name__] = None\\n log.warning(\\n f'Track title \\\"{track.searchable_name}\\\" for '\\n f\\\"svc {svc.__name__} is not similar enough to \\\"\\n f'\\\"{original_track.searchable_name}\\\".'\\n )\\n else:\\n similar_tracks[svc.__name__] = None\\n\\n return similar_tracks\",\n \"def test_get_filter_results_location_includes(self):\\r\\n\\r\\n data_file = open('data.txt', 'r')\\r\\n twitter_dict = tf.process_data(data_file)\\r\\n data_file.close()\\r\\n\\r\\n actual = tf.get_filter_results(twitter_dict, ['tomCruise', \\\\\\r\\n 'PerezHilton', 'tomfan'], {'follower': 'katieH'})\\r\\n expected = ['tomCruise', 'PerezHilton']\\r\\n self.assertEqual(actual, expected)\",\n \"def orderPairs(self):\\n pairsByTickers = {}\\n for asset in self.availableTickers:\\n holder = []\\n for pair in self.allPairs:\\n if asset.lower() in pair:\\n holder.append(pair)\\n pairsByTickers[asset] = holder\\n return pairsByTickers\",\n \"def assert_keys_match(keys, expected, allow_missing=True):\\n if not allow_missing:\\n missing = expected - keys\\n assert not missing, 'missing keys: %s' % missing\\n extra = keys - expected\\n assert not extra, 'extraneous keys: %s' % extra\",\n \"def test_fuzzy_matching_multi_match(\\n nlp: Language, countries: List[Dict[str, Any]]\\n) -> None:\\n ruler = SpaczzRuler(nlp, spaczz_fuzzy_defaults={\\\"min_r2\\\": 85})\\n ruler.add_patterns(countries)\\n doc = nlp(\\\"This is a test that should find Northern Ireland and Ireland\\\")\\n doc = ruler(doc)\\n matches = [(ent.ent_id_, ent.text) for ent in doc.ents if ent.label_ == \\\"COUNTRY\\\"]\\n assert matches == [(\\\"Northern Ireland\\\", \\\"Northern Ireland\\\"), (\\\"Ireland\\\", \\\"Ireland\\\")]\",\n \"def test_keys(self):\\n obs = self.tester.keys()\\n self.assertTrue(isinstance(obs, Iterable))\\n self.assertEqual(set(obs), self.exp_sample_ids)\",\n \"def test_keys(self):\\n obs = self.tester.keys()\\n self.assertTrue(isinstance(obs, Iterable))\\n self.assertEqual(set(obs), self.exp_sample_ids)\",\n \"def _gen_matches(target_units, source_units, stoplist_set, features_size):\\n for hits2positions in gen_hits2positions(\\n target_units, source_units, stoplist_set, features_size):\\n overhits2positions = {\\n k: np.array(v) for k, v in hits2positions.items()\\n if len(v) >= 2}\\n for (t_ind, s_ind), positions in overhits2positions.items():\\n yield (t_ind, s_ind, positions)\",\n \"def split_by_home(matches, team_id):\\n\\n sorted_matches = {\\n \\\"home\\\": [],\\n \\\"away\\\": []\\n }\\n\\n for match_id, match in matches.items():\\n if match.hometeam.team_id == team_id:\\n sorted_matches[\\\"home\\\"].append(match_id)\\n elif match.awayteam.team_id == team_id:\\n sorted_matches[\\\"away\\\"].append(match_id)\\n\\n return sorted_matches\",\n \"def step040():\\n logger.logMessage('Begin: matching work files')\\n sKey = ''\\n mKey = ''\\n def readFile(f):\\n line = f.readline().rstrip()\\n if line == '':\\n key = 'ZZZZZZZZZZZZZZZZZZZZZZZZZ'\\n return None,key\\n else:\\n sp = line.split(';')\\n key = '{0:25s}'.format(sp[1])[0:19]\\n return sp,key\\n\\n m = open(dbDumpFile,'r')\\n s = open(sortedCandidatesFile,'r')\\n numrecs = 0\\n with open(matchFile,'w') as match:\\n mFields,mKey = readFile(m)\\n sFields,sKey = readFile(s)\\n while mFields != None or sFields != None:\\n if sKey == mKey:\\n match.write('{0:014d};{1:25s};{2:32s};{3:31s}\\\\n'.format(int(mFields[0]),mKey,sFields[2],sFields[3]))\\n numrecs += 1\\n if numrecs % 1000 == 0:\\n logger.logMessage(level='DEBUG',message=\\\"{0:9d} records matched\\\".format(numrecs))\\n sFields,sKey = readFile(s)\\n mFields,mKey = readFile(m)\\n elif sKey < mKey:\\n sFields,sKey = readFile(s)\\n else:\\n logger.logMessage(level='WARNING',message='Record not matched: {0}'.format(mFields))\\n mFields,mKey = readFile(m)\\n logger.logMessage(\\\"Total matched: {0:d}\\\".format(numrecs))\\n\\n m.close()\\n s.close()\\n logger.logMessage('End : matching work files')\",\n \"def add_match(self, event):\\n event = copy.deepcopy(event)\\n # Convert datetime's back to timestamps\\n ts = self.rules.get(\\\"timestamp_field\\\")\\n if ts in event:\\n event[ts] = dt_to_ts(event[ts])\\n\\n self.matches.append(event)\",\n \"def match_api_keys(key, ip):\",\n \"def buffers_with_matches(self):\\n _set = set(self.misc.buffers()) & set(self.matches.keys())\\n _set.add(self.curr_buf.number)\\n return list(_set)\",\n \"def _add_to_recently_called(self, match, reporter):\\n if utils.istrcmp(match.player1_tag, reporter):\\n other = match.player2_tag\\n else:\\n other = match.player1_tag\\n self.recently_called[other] = time()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72052854","0.6073225","0.5684413","0.5646537","0.55177075","0.54479295","0.54022795","0.5286637","0.5255114","0.52513975","0.5236649","0.52352864","0.5173165","0.5170619","0.5168231","0.51618785","0.51518595","0.51467997","0.5143868","0.51270205","0.5095624","0.5080584","0.5073778","0.5068419","0.5047828","0.50372577","0.5029652","0.5017005","0.5014709","0.5010062","0.49436924","0.49363533","0.4930932","0.49299142","0.4912932","0.49055326","0.49040818","0.49001014","0.4899912","0.48959452","0.4891762","0.4877048","0.48511842","0.48500744","0.4846642","0.48455954","0.48385313","0.48181736","0.4817294","0.48079506","0.48051062","0.47849765","0.47821406","0.47773936","0.4773901","0.4763567","0.47580227","0.4756838","0.47409868","0.47269493","0.4724394","0.47153378","0.4712549","0.47106168","0.470731","0.47038347","0.47031593","0.4697062","0.4693925","0.4690416","0.4685003","0.46813932","0.46786878","0.4663002","0.46624523","0.46567234","0.46567234","0.46456993","0.46456322","0.4644703","0.46441078","0.46425253","0.46395323","0.46254978","0.46200016","0.46120065","0.46096689","0.46073213","0.46033794","0.45916963","0.45887607","0.4585684","0.4585684","0.4582933","0.4581277","0.45746195","0.45712337","0.45690817","0.45671412","0.45652816"],"string":"[\n \"0.72052854\",\n \"0.6073225\",\n \"0.5684413\",\n \"0.5646537\",\n \"0.55177075\",\n \"0.54479295\",\n \"0.54022795\",\n \"0.5286637\",\n \"0.5255114\",\n \"0.52513975\",\n \"0.5236649\",\n \"0.52352864\",\n \"0.5173165\",\n \"0.5170619\",\n \"0.5168231\",\n \"0.51618785\",\n \"0.51518595\",\n \"0.51467997\",\n \"0.5143868\",\n \"0.51270205\",\n \"0.5095624\",\n \"0.5080584\",\n \"0.5073778\",\n \"0.5068419\",\n \"0.5047828\",\n \"0.50372577\",\n \"0.5029652\",\n \"0.5017005\",\n \"0.5014709\",\n \"0.5010062\",\n \"0.49436924\",\n \"0.49363533\",\n \"0.4930932\",\n \"0.49299142\",\n \"0.4912932\",\n \"0.49055326\",\n \"0.49040818\",\n \"0.49001014\",\n \"0.4899912\",\n \"0.48959452\",\n \"0.4891762\",\n \"0.4877048\",\n \"0.48511842\",\n \"0.48500744\",\n \"0.4846642\",\n \"0.48455954\",\n \"0.48385313\",\n \"0.48181736\",\n \"0.4817294\",\n \"0.48079506\",\n \"0.48051062\",\n \"0.47849765\",\n \"0.47821406\",\n \"0.47773936\",\n \"0.4773901\",\n \"0.4763567\",\n \"0.47580227\",\n \"0.4756838\",\n \"0.47409868\",\n \"0.47269493\",\n \"0.4724394\",\n \"0.47153378\",\n \"0.4712549\",\n \"0.47106168\",\n \"0.470731\",\n \"0.47038347\",\n \"0.47031593\",\n \"0.4697062\",\n \"0.4693925\",\n \"0.4690416\",\n \"0.4685003\",\n \"0.46813932\",\n \"0.46786878\",\n \"0.4663002\",\n \"0.46624523\",\n \"0.46567234\",\n \"0.46567234\",\n \"0.46456993\",\n \"0.46456322\",\n \"0.4644703\",\n \"0.46441078\",\n \"0.46425253\",\n \"0.46395323\",\n \"0.46254978\",\n \"0.46200016\",\n \"0.46120065\",\n \"0.46096689\",\n \"0.46073213\",\n \"0.46033794\",\n \"0.45916963\",\n \"0.45887607\",\n \"0.4585684\",\n \"0.4585684\",\n \"0.4582933\",\n \"0.4581277\",\n \"0.45746195\",\n \"0.45712337\",\n \"0.45690817\",\n \"0.45671412\",\n \"0.45652816\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6227405"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":589,"cells":{"query":{"kind":"string","value":"Add obj as a match for match_dict values. Checks to make sure match_dict keys are valid."},"document":{"kind":"string","value":"def add(self, obj, match_dict):\r\n for match_key in match_dict.keys():\r\n assert match_key in self.keys_to_track\r\n\r\n for key_to_track in self.keys_to_track:\r\n if match_dict.has_key(key_to_track):\r\n match_val = match_dict[key_to_track]\r\n if match_val is None or match_val == '':\r\n pass\r\n else:\r\n self.tracker[key_to_track][match_val] = obj"},"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 _add_matches(self):\r\n for record in self.records:\r\n match_dict={key_to_track: record.get(key_to_track)\r\n for key_to_track in self.key_matcher.keys()}\r\n self.key_matcher.add(obj=record,\r\n match_dict=match_dict)","def add_match(self, event):\n event = copy.deepcopy(event)\n # Convert datetime's back to timestamps\n ts = self.rules.get(\"timestamp_field\")\n if ts in event:\n event[ts] = dt_to_ts(event[ts])\n\n self.matches.append(event)","def addMatch(self, id, match):\n self._matches[id] = match","def add_matching(self, matching: list):\n self.matching = matching","def filter_matches_add(self, key, value):\n\t\tif key in self.filter_matches.keys():\n\t\t\tself.filter_matches[key].append(value)\n\t\telse:\n\t\t\tself.filter_matches[key]=[value]","def add_match(self, match):\n self.matches.append(match)","def match(self, match_dict):\r\n for match_key in match_dict.keys():\r\n assert match_key in self.keys_to_track\r\n\r\n for key_to_track in self.keys_to_track:\r\n if match_dict.has_key(key_to_track):\r\n match_val = match_dict[key_to_track]\r\n if self.tracker[key_to_track].has_key(match_val):\r\n return self.tracker[key_to_track][match_val]\r\n return None","def match(self, data_instance: Dict[str, Any]) -> bool:","def add_match(self, match):\n\n # update cache results with game result\n if self.cached_results:\n results = json.loads(self.cached_results)\n else:\n results = []\n\n winner = match.winner == self\n opponent = match.loser if winner else match.winner\n new_rating = match.winner_rating_after if winner else \\\n match.loser_rating_after\n\n results.append({\n 'winner': winner,\n 'opponent_name': opponent.name,\n 'played_time': str(match.played_time),\n 'played_timestamp': get_timestamp(match.played_time)\n })\n self.cached_results = json.dumps(results[-CACHED_RATING_LIMIT:])\n\n # update player with new rating\n self.update_rating(new_rating, match)\n\n # save the player in the database\n self.save()","def __addMatch(db, match, oldRatings, newRatings):\n c = db.cursor()\n player1EloChange = newRatings[0] - oldRatings[0]\n player2EloChange = newRatings[1] - oldRatings[1]\n\n player1 = __playerCache[match['player1-id']]\n player2 = __playerCache[match['player2-id']]\n winner = __playerCache[match['winner-id']]\n\n c.execute(\"INSERT INTO matches \"\n \"VALUES(%s,%s,'%s','%s','%s','%s',%s,%s,%s,%s)\" %\n (match['id'], match['tournament-id'],\n match['updated-at'],\n player1['email-hash'], player2['email-hash'],\n winner['email-hash'],\n oldRatings[0], oldRatings[1],\n player1EloChange, player2EloChange))","def add_match(self, f, exclusions=None, **match_kwargs):\n assert not self._checked, 'can\\'t add after matchlist has been checked'\n\n if not match_kwargs: # Do nothing if no match_kwargs.\n return f\n\n self._verify_match_kwargs(match_kwargs, exclusions)\n self.matchers.append((match_kwargs, exclusions, f))\n return f","def _add_object(self, object_dict):\n # Attempt to map the object first. This will raise an\n # ItemExistsError if a named object of the same type already\n # exists.\n self._add_object_to_map(self.append_key, object_dict)\n\n # Add the object to the end of the model.\n # TODO: which objects need added to the beginning?\n self.model_dict[self.append_key] = object_dict\n\n # Update append key.\n self._update_append_key()","def add_ignored_match(self, secret: dict) -> None:\n\n matches_ignore = [\n match[\"match\"] if isinstance(match, dict) else match\n for match in self.matches_ignore\n ]\n if secret[\"match\"] not in matches_ignore:\n self.matches_ignore.append(secret)\n else:\n for match in self.matches_ignore:\n if (\n isinstance(match, dict)\n and match[\"match\"] == secret[\"match\"]\n and match[\"name\"] == \"\"\n ):\n match.update({\"name\": secret[\"name\"]})","def __add__(aMatchList, bMatchList):\n for id in bMatchList._matches.keys():\n aMatchList.addMatch(id, bMatchList._matches[id])\n return aMatchList","def add(dictionary, iterable, pattern, must_match=True, add_only_keys=None, ignore_errors=False):\n matcher = re.compile(pattern)\n for line in iterable:\n match = matcher.match(line)\n if not match:\n if must_match:\n raise ConfigurationError(\"Cannot match key-value from '%s' with pattern '%s'. Must match is set to true\" % (line, pattern))\n else:\n continue\n key = match.group(1).strip()\n try:\n value = match.group(2).strip()\n value = json.loads(value) if len(value) > 0 else None\n if add_only_keys is None or key in add_only_keys:\n dictionary[key] = value\n logging.debug(\"Key-value item (%s=%s) has been parsed and added to dictionary\", key, str(value))\n except ValueError as err:\n if not ignore_errors:\n raise ConfigurationError(\"Cannot parse JSON string '%s' with key '%s' (key-value definition: '%s'). Error is %s\" % (value, key, line, str(err)))","def _add_object_to_map(self, model_key, object_dict):\n # Grab reference to the object sub-dict.\n object_map = self.model_map['object']\n\n # Get type of object.\n obj_type = object_dict['object']\n\n # Define key object pair\n key_obj = [model_key, object_dict]\n\n # If this type isn't in the map, add it. NOTE: this can lead to\n # empty entries if the object isn't named.\n if obj_type not in object_map:\n object_map[obj_type] = {}\n\n try:\n # Never try to map an already existing named object.\n if object_dict['name'] in object_map[obj_type]:\n s = '{} already exists in the {} map!'\n raise ItemExistsError(s.format(object_dict['name'], obj_type))\n\n except KeyError:\n # Unnamed object. Add it to the unnamed list.\n self.model_map['object_unnamed'].append(key_obj)\n\n else:\n # Named object, map it.\n object_map[obj_type][object_dict['name']] = key_obj\n\n # No need to return; we're directly updating self.model_map","def add_match_result(self, variable, match_result):\n if isinstance(match_result, MatchResult):\n self._match_result_dict[variable] = match_result\n else:\n raise ValueError(\"Input must be a valid TimeSeries object\")","def _add_found_values(self, transform_dict, transform_key,\n lookup_key, lookup_dict):\n try:\n if self._verify_key_exists(lookup_key, lookup_dict):\n transform_dict[transform_key] = \\\n ''.join(nested_lookup(lookup_key, lookup_dict))\n except TypeError:\n pass\n if isinstance(lookup_key, list):\n transform_dict[transform_key] = \\\n ''.join(self._key_list_search(lookup_key, lookup_dict))\n return transform_dict","def match_info(info_dict):\n return True","def test_addEntryByDict(self):\n self.g.entryFormat = ['term', 'tags', 'value']\n b = self.g.add_entry({'term': 'foo', 'tags': 'a', 'value': '1'})\n self.assertTrue(b)","def add_rule_to_dict(rule_dict, lhs, rhs):\n if rhs not in rule_dict:\n rule_dict[rhs] = list()\n rule_dict[rhs].append(lhs) \n return rule_dict","def findMatches3(personDict,matches,skepticalMatches,additionalMatches,personDict2):\n dictConsidered = personDict['ALIAS']\n for alias in dictConsidered:\n if alias == \"\":\n continue\n pairs = itertools.combinations(dictConsidered[alias],2)\n for p in pairs:\n k = tuple(sorted(p))\n if (k not in matches) and (k not in skepticalMatches) and (k not in additionalMatches):\n info1 = personDict['EnterpriseID'][p[0]]\n info2 = personDict['EnterpriseID'][p[1]]\n \n info1b = personDict2['EnterpriseID'][p[0]]\n info2b = personDict2['EnterpriseID'][p[1]]\n score = getScorePair(info1b,info2b)\n if score>=7:\n additionalMatches[k] = score\n\n return additionalMatches","def test_updatewithdictionarybycomparingdictionaries(self):\n s1 = Square(10, 2, 1, 9)\n s1_dictionary = s1.to_dictionary()\n s2 = Square(1, 1)\n s2.update(**s1_dictionary)\n self.assertEqual(s1.__dict__, s2.__dict__)","def matches(self, matches):\n\n self._matches = matches","def matches(self, matches):\n\n self._matches = matches","def test_addDict(self):\n lidi = []\n lidi.append({'term': 'foo', 'tags': 'a', 'value': '1'})\n lidi.append({'term': 'bar', 'tags': 'a, b', 'value': '2'})\n lidi.append({'term': 'gnark', 'tags': 'a, c', 'value': '3'})\n self.g.add_dict(lidi)","def insert_match(self, gameid):\n if Match.query.filter(Match.gameid == gameid).first():\n self.logger.info(\"Match {} already exists in the DB\".format(gameid))\n return True\n match_json = self.rc.get_match(gameid)\n if not match_json:\n self.logger.warning(\"API did not return data for this gameid: {}\".format(gameid))\n return False\n match_json = self.lower_keys(match_json)\n # Get column names\n match_columns = Match.__table__.columns.keys()\n # Remove all k:v pairs that do not match column names\n to_del = []\n for k, v in match_json.items():\n if k not in match_columns:\n to_del.append(k)\n # del match_json[k]\n for k in to_del:\n del match_json[k]\n match = Match(**match_json)\n match.gamecreation = datetime.utcfromtimestamp(match.gamecreation // 1000)\n self.db.session.add(match)\n self.db.session.commit()\n return True","def replace(self, matchobj):\n key = matchobj.group(1)\n if self.dict.has_key(key):\n return self.dict[key]\n else:\n return ''","def addtwodimdict(self, thedict, key_a, key_b, val):\r\n if key_a in thedict:\r\n thedict[key_a].update({key_b: val})\r\n else:\r\n thedict.update({key_a: {key_b: val}})","def add(self, obj: model.IdentifiableArtefact):\n for field, field_info in direct_fields(self.__class__).items():\n # NB for some reason mypy complains here, but not in __contains__(), below\n if isinstance(\n obj, get_args(field_info.outer_type_)[1], # type: ignore [attr-defined]\n ):\n getattr(self, field)[obj.id] = obj\n return\n raise TypeError(type(obj))","def _match_all(self, obj, criteria):\n return all(getattr(obj, key_, None) == value_ for\n key_, value_ in criteria.items())","def add_item(key, obj, dst):\n\n if key not in dst:\n dst[key] = []\n dst[key].append(obj)","def matches_dict(self, answer_dict):\n\n return self.matches(Answer(\n answer_dict['group_id'],\n answer_dict['block_id'],\n answer_dict['answer_id'],\n \"\",\n answer_dict['group_instance'],\n answer_dict['answer_instance'],\n ))","def match(dictionary, query, policy='relaxed', matches=None):\n if query is None:\n return True\n assert policy in ['relaxed', 'strict'], \"\"\n\n for field, value in query.iteritems():\n if field not in dictionary:\n if policy == 'relaxed':\n continue\n else:\n return False\n if isinstance(value, list) or not isinstance(value, basestring):\n values = value if isinstance(value, list) else [value]\n if dictionary[field] not in values:\n return False\n if matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n else:\n if value == '':\n # Take special care if value is an empty string\n if value != dictionary[field]:\n return False\n elif matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n continue\n else:\n match = re.compile(value).match(dictionary[field])\n if not match:\n return False\n else:\n if matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n for index, group in enumerate(match.groups()):\n matches['%s_%d' % (field, index+1)] = group\n continue\n return True","def _match(self, document: dict, query: dict) -> bool:\n\n matches = [\n self._match(document.get(key), value)\n if isinstance(value, dict) and isinstance(document.get(key), dict)\n else document.get(key) == value\n for key, value in query.items()\n ]\n return all(matches)","def append(self, obj):\r\n self.record_count += 1\r\n \r\n if type(obj) == dict:\r\n self._probe_record(obj)\r\n else:\r\n self._probe_row(obj)","def test_dict(self, obj: dict) -> None:\r\n properties = read_properties(obj)\r\n for key, value in properties.items():\r\n conditional_check(key, self.case_check, self.ignored_keys)\r\n if read_type(value) == 'object':\r\n logger.debug('dict -> dict')\r\n self.test_dict(obj=value)\r\n elif read_type(value) == 'array':\r\n logger.debug('dict -> list')\r\n self.test_list(array=value)","def add(enforcer_dict, key, value):\n enforcer_dict['d'] = 4\n assert other.keystring == 'abcd'\n assert other.valuesum == 10\n\n enforcer_dict.update(dict(e=5, f=6))\n assert other.keystring == 'abcdef'\n assert other.valuesum == 21","def _add_match(self, backward_match_list):\n\n already_in = False\n\n for b_match in backward_match_list:\n for l_match in self.match_list:\n if b_match.match == l_match.match:\n index = self.match_list.index(l_match)\n self.match_list[index].qubit.append(b_match.qubit[0])\n already_in = True\n\n if not already_in:\n self.match_list.append(b_match)","def match_source_key(self, match):\n raise NotImplementedError","def validate_match(context):\n\n schema = isinstance(match_schema, ValidateViewHook) and match_schema(request) or match_schema\n\n state = Dummyobj()\n state.request = request\n state.context = context\n try:\n return schema.to_python(request.matchdict, state=state)\n except formencode.Invalid as exc:\n unpacked = exc.unpack_errors()\n request.set_property(lambda ctx: unpacked,\n invalid_match_attr, reify=True)\n if raise_exc is True:\n _raise(invalid_match_exc, unpacked)\n else:\n return {}","def add_match(self, match_id, team1, team2, team_tag1, team_tag2, ip, team1_id, team2_id):\n\n query_select = sC.SELECT_MATCHES_WHERE_IP_.format(ip)\n match_id_ = self.util.match_with_ip_check(query_select)\n\n if match_id_:\n return match_id_\n\n query = sC.INSERT_MATCHES_VALUES_.format(int(match_id),\n team1[:pC.MAX_CHARACTERS_SQL], team2[:pC.MAX_CHARACTERS_SQL],\n team_tag1[:pC.MAX_CHARACTERS_SQL], team_tag2[:pC.MAX_CHARACTERS_SQL],\n ip, team1_id, team2_id, datetime.now())\n\n self.execute_query(query)","def add_attributes_from_dict(self, dict):\n for key in dict:\n val = dict[key]\n if hasattr(self, key):\n setattr(self, key, val)","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n param = val.parameter_type\n if param.k_bondorder or param.length_bondorder:\n bond = topology.get_bond_between(*key)\n fractional_bond_order = bond.fractional_bond_order\n if not fractional_bond_order:\n assert self._get_uses_interpolation(parameter_handler)\n raise RuntimeError(\n \"Bond orders should already be assigned at this point\",\n )\n else:\n fractional_bond_order = None\n topology_key = BondKey(\n atom_indices=key,\n bond_order=fractional_bond_order,\n )\n\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n bond_order=fractional_bond_order,\n )\n self.key_map[topology_key] = potential_key\n\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n topology=topology,\n assigned_terms=matches,\n valence_terms=valence_terms,\n )","def test_add_nested_dict_value():\n\n recursiveKeys = [\n \"reward_signals.extrinsic.strength\",\n \"reward_signals.extrinsic.gamma\",\n \"reward_signals.curiosity.strength\",\n \"reward_signals.curiosity.gamma\",\n ]\n\n expectedDict = {\n 'reward_signals': {\n 'curiosity': {'gamma': 1.0, 'strength': 1.0},\n 'extrinsic': {'gamma': 1.0, 'strength': 1.0},\n }\n }\n\n dictionary = {}\n\n for key in recursiveKeys:\n common.add_nested_dict_value(dictionary, key, 1.0)\n\n assert dictionary == expectedDict\n\n dictionary = {'reward_signals': {'extrinsic': {}}}\n\n for key in recursiveKeys:\n common.add_nested_dict_value(dictionary, key, 1.0)\n\n assert dictionary == expectedDict\n\n dictionary = {'reward_signals': {'extrinsic': {'gamma': 0.99}}}\n\n for key in recursiveKeys:\n common.add_nested_dict_value(dictionary, key, 1.0)\n\n assert dictionary == expectedDict","def addMatchEntry(tmpFD, match, mtype, val):\n tmpFD.write(f\" {match} {mtype} {val}\\n\")","def _add_data_to_response(self, desc_matches, url, page_matches, response):\n\n if desc_matches:\n response.append({\n 'url': url,\n 'matches': desc_matches\n })\n\n if page_matches:\n response.append({\n 'url': url,\n 'matches': page_matches\n })","def match_user(dictionary: 'Climatematch', \n match: 'NGOMatch') -> Dict[str, tuple(int,int)]:\n\n total = {}\n \n for user in dictionary:\n total[user] = {}\n skillsCount = 0\n interestCount = 0\n for sk in dictionary[user]['skills']: \n if sk in match['skills']['technical']:\n skillsCount = skillsCount + 1\n elif sk in match['skills']['interpersonal']:\n skillsCount = skillsCount + 1\n \n for inte in dictionary[user]['interest']: \n if inte in match['interest']:\n interestCount = interestCount + 1\n \n total[user][(skillsCount, interestCount)]\n return total","def _merge_by_query(self, obj_dict):\n _res = self.__session.query(obj_dict[\"class\"]).filter_by(**obj_dict[\"query_dict\"]).first()\n\n if _res is None:\n self._add(obj_dict[\"instance\"])\n else:\n if hasattr(obj_dict[\"instance\"], 'attributes') and \\\n hasattr(obj_dict[\"instance\"], 'p_key'):\n for attr in obj_dict[\"instance\"].attributes:\n if attr not in obj_dict[\"instance\"].p_key:\n setattr(_res, attr, getattr(obj_dict[\"instance\"], attr))\n # updating the instance\n obj_dict[\"instance\"] = _res\n else:\n raise AttributeError(\"Class variable (attributes / p_key) not set for %s\" %\n (obj_dict[\"instance\"],))","def match(self, obj):\n\n return self._match(self.rule, obj)","def add_dict(self, d, record_cls=None):\n rc = record_cls or self._ELE_CLS\n self.add_container(self.from_dict(d, record_cls=rc))\n return len(self)","def add_value(self, thing_key, dkey, value):\n if thing_key in self.things_dict:\n dic = self.things_dict[thing_key]\n if type(dic) != type({}):\n dic = {}\n dic[dkey] = value\n self.things_dict[thing_key] = dic\n self.changed.append(thing_key)\n return True\n return False","def _merge_obj(result, obj, pointer=''): # changed code\n if not isinstance(result, dict):\n result = {}\n\n if not isinstance(obj, dict):\n return obj\n\n for key, value in obj.items():\n if isinstance(value, dict):\n target = result.get(key)\n if isinstance(target, dict):\n _merge_obj(target, value, pointer=f'{pointer}/{key}') # changed code\n continue\n result[key] = {}\n _merge_obj(result[key], value, pointer=f'{pointer}/{key}') # changed code\n continue\n\n # new code\n if key in result:\n pointer_and_key = f'{pointer}/{key}'\n # Exceptions.\n if (value is None and pointer_and_key == '/definitions/Milestone/properties/documents/deprecated' and\n repo_name in ('ocds_milestone_documents_extension', 'public-private-partnerships')):\n warnings.warn(f're-adds {pointer}')\n elif (value == [] and pointer_and_key == '/required' and\n repo_name == 'ocds_pagination_extension'):\n warnings.warn(f'empties {pointer_and_key}')\n else:\n if is_profile:\n message = ' - check for repeats across extension_versions.json, dependencies, testDependencies'\n else:\n message = ''\n raise Exception(f'unexpectedly overwrites {pointer_and_key}{message}')\n\n if value is None:\n result.pop(key, None)\n continue\n result[key] = value\n return result","def add(self, key, obj):\n with self._lock:\n slot = self._dict.get(key, None)\n if slot is None:\n slot = [obj, 0]\n else:\n slot[1] += 1\n self._dict[key] = slot","async def add_dict(self, dic):\n for key in dic:\n await self.set(key, dic[key])","def matchRecordAttrs(mapobj, attrs):\n for k,v in iteritems(attrs):\n try: val = getattr(mapobj, k)\n except AttributeError: # k isn't an attr of record\n if v: return False # if k doesn't exist in mapobj but was required, no match\n else: continue # otherwise ignore attributes that aren't defined for the given map record\n if val != v: return False # if any criteria matches, it's considered a match\n return True # all criteria matched at all","def _add_dict_values(self, d1, d2):\n\n if d1 is None and d2 is None:\n return None\n\n d1 = d1 or {}\n d2 = d2 or {}\n\n added = {}\n for key in set(list(d1.keys()) + list(d2.keys())):\n added[key] = dict(d1.get(key, {}), **(d2.get(key, {})))\n return added","def add_item(dct,item):\r\n if item not in dct[0]:\r\n print \"itemNotFound \",str(item)\r\n return False\r\n\r\n num=len(item)\r\n if num in dct:\r\n if item in dct[num]:\r\n return False\r\n else:\r\n dct[num].append(item)\r\n return True\r\n else:\r\n dct[num]=[item]\r\n return True","def _add_dictionary(self, current, added):\n for key in added:\n if key in current and isinstance(current[key], collections.Mapping):\n self._add_dictionary(current[key], added[key])\n else:\n current[key] = added[key]","def validate_present(self, obj):\n for k, v in obj.items():\n func = self.validation.get(k)\n if func:\n func(k, v)","def add(self, obj: object) -> None:\n self._contains.append(obj)","def test_merge_aggregate_traditional(self):\n mdict = copy.deepcopy(self.dict1)\n mdict[\"A\"] = \"b\"\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\"A\": \"b\"})\n self.assertEqual(mdict, ret)","def match_fill(self,MatchMake_inst):\n if type(MatchMake_inst) is not MatchMake:\n raise TypeError(\"Wrong datatype: MatchMake_inst has to be of custom type MatchMake!\")\n\n res_dict = {}\n for match in MatchMake_inst._score_list:\n try:\n res_dict[match.match_score].append(match.match_target)\n \n except KeyError:\n res_dict[match.match_score] = [match.match_target]\n \n\n self.add(MatchMake_inst._source) # add source in network\n parent = [MatchMake_inst._source]\n for score in sorted(res_dict.keys(),reverse=True):\n for target in res_dict[score]:\n self.add(target,parent,score)\n parent = res_dict[score]","def add_dict(dest, src):\n for key in src.keys():\n if key in dest.keys():\n dest[key] += src[key]\n else:\n dest[key] = src[key]","def from_re_match(cls, match):\n kwargs = match.groupdict()\n player_location = kwargs['player_location'].split()\n kwargs['player_location'] = (int(player_location[0]),\n int(player_location[1]),\n int(player_location[2]))\n target_location = kwargs['target_location'].split()\n kwargs['target_location'] = (int(target_location[0]),\n int(target_location[1]),\n int(target_location[2]))\n if match.string.endswith('(headshot)'):\n kwargs['headshot'] = True\n return cls(**kwargs)","def add(self, key, value):","def find(found_item, hash_table_cell):\n if found_item:\n found_item[1] = obj\n else:\n hash_table_cell.append([key, obj])\n self.size += 1\n self._keys.append(key)","def save(self, **kwargs):\n for k, v in kwargs.items():\n self._validated_data[k] = v\n\n # Create or update direct relations (foreign key, one-to-one)\n related_objects = self._extract_reverse_relations(kwargs)\n self._save_direct_relations(kwargs)\n\n # TODO: move to a specialized class (easier to subclass)\n try:\n match_on = {}\n for field_name, field in self.get_fields().items():\n if self.match_on == '__all__' or field_name in self.match_on:\n match_on[field.source or field_name] = self._validated_data.get(field_name)\n # a parent serializer may inject a value that isn't among the fields, but is in `match_on`\n for key in self.match_on:\n if key not in self.get_fields().keys():\n match_on[key] = self._validated_data.get(key)\n match = self.queryset.get(**match_on)\n for k, v in self._validated_data.items():\n setattr(match, k, v)\n except ObjectDoesNotExist:\n match = self.queryset.model(**self._validated_data)\n except (TypeError, ValueError):\n self.fail('incorrect_type', data_type=type(self._validated_data).__name__)\n match.save()\n\n self._save_reverse_relations(related_objects, instance=match)\n return match","def test_deep_set_create(self):\n mdict = copy.deepcopy(self.dict1)\n res = dictupdate.set_dict_key_value(mdict, \"K:L:M\", \"Q\")\n self.assertEqual(\n {\n \"A\": \"B\",\n \"C\": {\"D\": \"E\", \"F\": {\"G\": \"H\", \"I\": \"J\"}},\n \"K\": {\"L\": {\"M\": \"Q\"}},\n },\n res,\n )","def post(self):\n match_data = self.get_from_body('match')\n try:\n guest_id = match_data['guest']\n guest_points = match_data['guestPoints']\n host_id = match_data['host']\n host_points = match_data['hostPoints']\n if host_id is guest_id:\n self.write_signed_error(400, 'Host and guest id cannot be equal')\n match = Match(guest=ndb.Key(User, guest_id),\n guest_points=guest_points,\n host=ndb.Key(User, host_id),\n host_points=host_points)\n # Asynchronously update player data\n guest_future = User.get_by_id_async(guest_id)\n host_future = User.get_by_id_async(host_id)\n guest = guest_future.get_result()\n host = host_future.get_result()\n guest.experience += guest_points\n host.experience += host_points\n # Update entities\n results = _update_entities(match, host, guest)\n # Prepare message\n match_key = results[0].urlsafe()\n self.write_signed_message(201, 'id', match_key)\n except (KeyError, TypeError):\n self.write_signed_error(400, 'Missing attributes for match')\n except TransactionFailedError:\n self.write_signed_error(507, 'Unable to store match')\n except AttributeError:\n self.write_signed_error(400, 'Invalid id')\n except BadValueError:\n # Thrown when model validations fail\n self.write_signed_error(400, 'Invalid data')","def test_append_to_results_in(self):\n # pre conditions\n field = 'foo'\n value = 'bar'\n existing = ['baz']\n existing.append(value)\n values_dict = {field: existing}\n\n self.assertTrue(value in values_dict.get(field), \"pre-condition failed\")\n\n # test\n result = gen.append_to_results(field, value, values_dict, unique=True)\n\n # post conditions\n expected = ['baz', 'bar']\n self.assertEqual(result, expected)","def test_apply_scalar_map(self):\n super(TestObjDict, self).test_apply_scalar_map(_as_obj=True)","def check_dict(dic, validator, messages):\n check_dict_alg(dic, validator, [], messages, validator, \"NoObject\")","def build_match_clause(field, string):\r\n answer = {}\r\n tmp = {}\r\n tmp[field] = string\r\n answer['match'] = tmp\r\n return answer","def add_to_dict_fail( self, key_0, key_1, list_2 ):\n dict_1_new = { key_1: list_2 }\n\n\n dict_1_current = self._dd_dict.get( key_1 )\n if dict_1_current is None:\n #dict_1_new = dict_1_new\n pass\n\n else:\n dict_1_new = {**dict_1_current, **dict_1_new }\n\n\n dict_0_new = { key_0: dict_1_new } # maybe a merge ??\n\n dict_0_current = self._dd_dict.get( key_0 )\n\n if dict_0_current is None:\n dict_0_new = dict_0_new\n\n else:\n dict_0_new = {**dict_0_current, **dict_0_new }\n\n dict_0_new = {**dict_0_current, **dict_0_new }\n\n self._dd_dict = { **self._dd_dict, **dict_0_new }\n\n print( self._dd_dict )\n\n return self._dd_dict","def func(match, create_new=False, *args, **kwargs):\n\n data = match.group(0)\n\n if create_new:\n dash = data.replace(\"_\", \"-\") if \"_\" in data else data\n\n if dash not in objects:\n new = gen_guid()\n objects[dash] = new\n objects[dash.replace(\"-\", \"_\")] = new.replace(\"-\", \"_\")\n\n if data in objects:\n return (objects[data], True)\n\n return (data, False)","def merge_dict(target, addition):\n for key in addition:\n if key in target and isinstance(target[key], dict) \\\n and isinstance(addition[key], dict):\n merge_dict(target[key], addition[key])\n else:\n target[key] = addition[key]","def __iadd__(self, other):\n if not isinstance(other, dict):\n msg = 'Can not concatenate Dict and {}'.format(type(other))\n raise TypeError(msg)\n for key, val in other.items():\n if key in self:\n self._append_key(key, val)\n else:\n self[key] = val\n return self","def test_adduser_entry(user_tuple, wordlist, input_dict, output_dict):\n\n assert set(adduser_entry(user_tuple, wordlist, input_dict)[user_tuple]) == set(output_dict[user_tuple])\n for key in output_dict:\n assert type(key) == tuple\n assert type(output_dict[user_tuple]) == list","def add_to_dict(from_dict, to_dict):\n for k, v in list(from_dict.items()):\n if hasattr(v, 'copy') and callable(getattr(v, 'copy')):\n to_dict[k] = v.copy()\n else:\n to_dict[k] = v","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: \"Topology\",\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[\n Union[TopologyKey, LibraryChargeTopologyKey],\n PotentialKey,\n ] = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n topology_key = TopologyKey(atom_indices=key)\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n )\n self.key_map[topology_key] = potential_key\n\n if self.__class__.__name__ in [\n \"SMIRNOFFBondCollection\",\n \"SMIRNOFFAngleCollection\",\n ]:\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n assigned_terms=matches,\n topology=topology,\n valence_terms=valence_terms,\n )","def match_id(self, match_id):\n\n self._match_id = match_id","def add(obj):","def create_or_update_match_settings(\n request: MatchSettingsUpdateRequest,\n ) -> MatchSettingsUpdateResponse:\n if config := AdditionalMatchSettingsConfig.get(request.privacy_group_id):\n config.pdq_match_threshold = request.pdq_match_threshold\n hmaconfig.update_config(config)\n\n return MatchSettingsUpdateResponse(\n f\"match_settings updated for pg_id {request.privacy_group_id} with pdq_match_threshold={request.pdq_match_threshold}\"\n )\n\n config = AdditionalMatchSettingsConfig(\n request.privacy_group_id, request.pdq_match_threshold\n )\n hmaconfig.create_config(config)\n return MatchSettingsUpdateResponse(\n f\"match_settings created for pg_id {request.privacy_group_id} with pdq_match_threshold={request.pdq_match_threshold}\"\n )","def _match(self, rule, obj):\n\n for key in rule:\n if key == '$and':\n if not self.handle_and(key, rule[key], obj):\n return False\n\n elif key == '$or':\n if not self.handle_or(key, rule[key], obj):\n return False\n\n elif key == '$nor':\n if not self.handle_nor(key, rule[key], obj):\n return False\n\n elif not self.handle_field(key, rule[key], obj):\n return False\n\n return True","def _find_match(needle: dict, haystack: list, keys: list):\n for item in haystack:\n for key in keys:\n if item.get(key) != needle[key]:\n break\n else:\n return item\n return None","def calculate_match_at_backend():\n\n # Calculate lovermatch list for each user\n user_set = UserInfo.objects\n for u1 in user_set:\n matchlist = {}\n for u2 in user_set:\n if u1 != u2:\n features_to_match = u1.features\n weights = u1.percentage\n sim = get_similarity(u1, u2, features_to_match, weights)\n matchlist[u2.name] = sim\n u1.loverMatch = matchlist\n u1.save()\n\n # Calculate lovermatched list for each user\n user_set = UserInfo.objects\n for u1 in user_set:\n matchedlist = {}\n for u2 in user_set:\n if u1 != u2:\n if u1.name in u2.loverMatch.keys():\n matchedlist[u2.name] = u2.loverMatch[u1.name]\n u1.loverMatched = matchedlist\n u1.save()","def store_matches(\n self,\n parameter_handler: ImproperTorsionHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n self.key_map = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n parameter_handler._assert_correct_connectivity(\n val,\n [\n (0, 1),\n (1, 2),\n (1, 3),\n ],\n )\n n_terms = len(val.parameter_type.k)\n for n in range(n_terms):\n smirks = val.parameter_type.smirks\n non_central_indices = [key[0], key[2], key[3]]\n\n for permuted_key in [\n (\n non_central_indices[i],\n non_central_indices[j],\n non_central_indices[k],\n )\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\n ]:\n topology_key = ImproperTorsionKey(\n atom_indices=(key[1], *permuted_key),\n mult=n,\n )\n potential_key = PotentialKey(\n id=smirks,\n mult=n,\n associated_handler=\"ImproperTorsions\",\n )\n self.key_map[topology_key] = potential_key","def add_object(self, object_to_be_added):\n new_mapping = Map.add_object(self.id, object_to_be_added)\n if new_mapping:\n object_to_be_added.save()\n new_mapping.ref_id = object_to_be_added.id\n return True\n else:\n return False","def test_merge_overwrite_traditional(self):\n mdict = copy.deepcopy(self.dict1)\n mdict[\"A\"] = \"b\"\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\"A\": \"b\"})\n self.assertEqual(mdict, ret)","def from_dict(self,\n d: dict,\n iter_if: FunctionType = None,\n iter_by: FunctionType = None,\n ) -> NoReturn:\n for k, v in d.items():\n if isinstance(iter_if, FunctionType) and not iter_if(k, v):\n continue\n if iter_by:\n v = iter_by(k, v)\n if k not in dir(self): # TODO is it strict?\n # warn develop\n print(f\"warning: a key({k}) not in the document model is inserting into mongodb.\")\n setattr(self, k, v)","def traverse_dict_and_add(self, rootDir, dictH):\n origRootDir = rootDir\n for key, item in dictH.iteritems():\n if item is None or item == {} or item == []:\n attemptedJoin = os.path.normpath(os.path.join(rootDir, key))\n keyPath = None\n if not os.path.isabs(key) and (os.path.isdir(attemptedJoin) or\n os.path.isfile(attemptedJoin)):\n # copy the found file/folder to directory\n keyPath = attemptedJoin\n if os.path.isabs(key) and (os.path.isfile(key) or\n os.path.isdir(key)):\n # copy file/folder to the root location\n if not os.path.isdir(rootDir):\n paths.mkdir_p(rootDir)\n keyPath = paths.path_leaf(key)\n copyLoc = os.path.join(rootDir, keyPath)\n shutil.copy2(key, copyLoc)\n continue # skip the rest of this iteration\n\n if keyPath is not None and not os.path.isdir(keyPath):\n # the string was either not a file/folder or couldn't be\n # resolved from a relative path into a file/folder\n #\n copyLoc = paths.path_leaf(keyPath)\n copyLoc = os.path.join(rootDir, copyLoc)\n print copyLoc\n shutil.copy2(key, copyLoc)\n elif keyPath is None:\n # no directory exists at this location, create one\n dirToMake = os.path.normpath(os.path.join(rootDir, key))\n os.makedirs(dirToMake)\n # sys.exit('Got: \"{f}\", couldn\\'t resolve '\n # 'into file or folder'.format(f=key))\n\n elif isinstance(item, dict):\n newRootDir = os.path.join(rootDir, key)\n newRootDir = os.path.normpath(newRootDir)\n self.traverse_dict_and_add(rootDir=newRootDir,\n dictH=dictH[key])\n else:\n sys.exit('Got: \"{f}\", expected a dictionary, '\n '\\{\\} or None'.format(f=item))","def test_deep_append(self):\n sdict = {\"bar\": {\"baz\": [1, 2]}}\n res = dictupdate.append_dict_key_value(sdict, \"bar:baz\", 42)\n self.assertEqual({\"bar\": {\"baz\": [1, 2, 42]}}, res)\n # Append with alternate delimiter\n res = dictupdate.append_dict_key_value(sdict, \"bar~baz\", 43, delimiter=\"~\")\n self.assertEqual({\"bar\": {\"baz\": [1, 2, 42, 43]}}, res)\n # Append to a not-yet existing list\n res = dictupdate.append_dict_key_value({}, \"foo:bar:baz\", 42)\n self.assertEqual({\"foo\": {\"bar\": {\"baz\": [42]}}}, res)","def _match(self, check):\n matches = []\n tests = {}\n for k, v in check.items():\n if isinstance(v, dict):\n tests[k] = CompositeFilter(v)\n else:\n tests[k] = lambda o: _add_tz(o) == _add_tz(v)\n\n for rec in self._records.values():\n if self._match_one(rec, tests):\n matches.append(deepcopy(rec))\n return matches","def handleMatch(self, m):\r\n pass","def add_dict_entry(dictionary: dict, key: Any, value: Any) -> None:\n try:\n dictionary[key].append(value)\n except KeyError:\n dictionary[key] = [value]","def apply_scalar_map(self, *args, **kwargs):\n kwargs['_as_obj'] = True\n return super(ObjDict, self).apply_scalar_map(*args, **kwargs)","def update_dict(new,old):","def match(self, item):","def find(self, a, b):\n\t\tfor i in b:\n\t\t\tif 'ipv4' in i and 'ipv4' in a:\n\t\t\t\tif i['ipv4'] == a['ipv4']:\n\t\t\t\t\ti.update(a)\n\t\t\t\t\treturn\n\t\t\telif 'ipv6' in i and 'ipv6' in a:\n\t\t\t\tif i['ipv6'] == a['ipv6']:\n\t\t\t\t\ti.update(a)\n\t\t\t\t\treturn\n\t\t\telif 'hostname' in i and 'hostname' in a:\n\t\t\t\tif i['hostname'] == a['hostname']:\n\t\t\t\t\ti.update(a)\n\t\t\t\t\treturn\n\t\tb.append(a)\n\t\treturn"],"string":"[\n \"def _add_matches(self):\\r\\n for record in self.records:\\r\\n match_dict={key_to_track: record.get(key_to_track)\\r\\n for key_to_track in self.key_matcher.keys()}\\r\\n self.key_matcher.add(obj=record,\\r\\n match_dict=match_dict)\",\n \"def add_match(self, event):\\n event = copy.deepcopy(event)\\n # Convert datetime's back to timestamps\\n ts = self.rules.get(\\\"timestamp_field\\\")\\n if ts in event:\\n event[ts] = dt_to_ts(event[ts])\\n\\n self.matches.append(event)\",\n \"def addMatch(self, id, match):\\n self._matches[id] = match\",\n \"def add_matching(self, matching: list):\\n self.matching = matching\",\n \"def filter_matches_add(self, key, value):\\n\\t\\tif key in self.filter_matches.keys():\\n\\t\\t\\tself.filter_matches[key].append(value)\\n\\t\\telse:\\n\\t\\t\\tself.filter_matches[key]=[value]\",\n \"def add_match(self, match):\\n self.matches.append(match)\",\n \"def match(self, match_dict):\\r\\n for match_key in match_dict.keys():\\r\\n assert match_key in self.keys_to_track\\r\\n\\r\\n for key_to_track in self.keys_to_track:\\r\\n if match_dict.has_key(key_to_track):\\r\\n match_val = match_dict[key_to_track]\\r\\n if self.tracker[key_to_track].has_key(match_val):\\r\\n return self.tracker[key_to_track][match_val]\\r\\n return None\",\n \"def match(self, data_instance: Dict[str, Any]) -> bool:\",\n \"def add_match(self, match):\\n\\n # update cache results with game result\\n if self.cached_results:\\n results = json.loads(self.cached_results)\\n else:\\n results = []\\n\\n winner = match.winner == self\\n opponent = match.loser if winner else match.winner\\n new_rating = match.winner_rating_after if winner else \\\\\\n match.loser_rating_after\\n\\n results.append({\\n 'winner': winner,\\n 'opponent_name': opponent.name,\\n 'played_time': str(match.played_time),\\n 'played_timestamp': get_timestamp(match.played_time)\\n })\\n self.cached_results = json.dumps(results[-CACHED_RATING_LIMIT:])\\n\\n # update player with new rating\\n self.update_rating(new_rating, match)\\n\\n # save the player in the database\\n self.save()\",\n \"def __addMatch(db, match, oldRatings, newRatings):\\n c = db.cursor()\\n player1EloChange = newRatings[0] - oldRatings[0]\\n player2EloChange = newRatings[1] - oldRatings[1]\\n\\n player1 = __playerCache[match['player1-id']]\\n player2 = __playerCache[match['player2-id']]\\n winner = __playerCache[match['winner-id']]\\n\\n c.execute(\\\"INSERT INTO matches \\\"\\n \\\"VALUES(%s,%s,'%s','%s','%s','%s',%s,%s,%s,%s)\\\" %\\n (match['id'], match['tournament-id'],\\n match['updated-at'],\\n player1['email-hash'], player2['email-hash'],\\n winner['email-hash'],\\n oldRatings[0], oldRatings[1],\\n player1EloChange, player2EloChange))\",\n \"def add_match(self, f, exclusions=None, **match_kwargs):\\n assert not self._checked, 'can\\\\'t add after matchlist has been checked'\\n\\n if not match_kwargs: # Do nothing if no match_kwargs.\\n return f\\n\\n self._verify_match_kwargs(match_kwargs, exclusions)\\n self.matchers.append((match_kwargs, exclusions, f))\\n return f\",\n \"def _add_object(self, object_dict):\\n # Attempt to map the object first. This will raise an\\n # ItemExistsError if a named object of the same type already\\n # exists.\\n self._add_object_to_map(self.append_key, object_dict)\\n\\n # Add the object to the end of the model.\\n # TODO: which objects need added to the beginning?\\n self.model_dict[self.append_key] = object_dict\\n\\n # Update append key.\\n self._update_append_key()\",\n \"def add_ignored_match(self, secret: dict) -> None:\\n\\n matches_ignore = [\\n match[\\\"match\\\"] if isinstance(match, dict) else match\\n for match in self.matches_ignore\\n ]\\n if secret[\\\"match\\\"] not in matches_ignore:\\n self.matches_ignore.append(secret)\\n else:\\n for match in self.matches_ignore:\\n if (\\n isinstance(match, dict)\\n and match[\\\"match\\\"] == secret[\\\"match\\\"]\\n and match[\\\"name\\\"] == \\\"\\\"\\n ):\\n match.update({\\\"name\\\": secret[\\\"name\\\"]})\",\n \"def __add__(aMatchList, bMatchList):\\n for id in bMatchList._matches.keys():\\n aMatchList.addMatch(id, bMatchList._matches[id])\\n return aMatchList\",\n \"def add(dictionary, iterable, pattern, must_match=True, add_only_keys=None, ignore_errors=False):\\n matcher = re.compile(pattern)\\n for line in iterable:\\n match = matcher.match(line)\\n if not match:\\n if must_match:\\n raise ConfigurationError(\\\"Cannot match key-value from '%s' with pattern '%s'. Must match is set to true\\\" % (line, pattern))\\n else:\\n continue\\n key = match.group(1).strip()\\n try:\\n value = match.group(2).strip()\\n value = json.loads(value) if len(value) > 0 else None\\n if add_only_keys is None or key in add_only_keys:\\n dictionary[key] = value\\n logging.debug(\\\"Key-value item (%s=%s) has been parsed and added to dictionary\\\", key, str(value))\\n except ValueError as err:\\n if not ignore_errors:\\n raise ConfigurationError(\\\"Cannot parse JSON string '%s' with key '%s' (key-value definition: '%s'). Error is %s\\\" % (value, key, line, str(err)))\",\n \"def _add_object_to_map(self, model_key, object_dict):\\n # Grab reference to the object sub-dict.\\n object_map = self.model_map['object']\\n\\n # Get type of object.\\n obj_type = object_dict['object']\\n\\n # Define key object pair\\n key_obj = [model_key, object_dict]\\n\\n # If this type isn't in the map, add it. NOTE: this can lead to\\n # empty entries if the object isn't named.\\n if obj_type not in object_map:\\n object_map[obj_type] = {}\\n\\n try:\\n # Never try to map an already existing named object.\\n if object_dict['name'] in object_map[obj_type]:\\n s = '{} already exists in the {} map!'\\n raise ItemExistsError(s.format(object_dict['name'], obj_type))\\n\\n except KeyError:\\n # Unnamed object. Add it to the unnamed list.\\n self.model_map['object_unnamed'].append(key_obj)\\n\\n else:\\n # Named object, map it.\\n object_map[obj_type][object_dict['name']] = key_obj\\n\\n # No need to return; we're directly updating self.model_map\",\n \"def add_match_result(self, variable, match_result):\\n if isinstance(match_result, MatchResult):\\n self._match_result_dict[variable] = match_result\\n else:\\n raise ValueError(\\\"Input must be a valid TimeSeries object\\\")\",\n \"def _add_found_values(self, transform_dict, transform_key,\\n lookup_key, lookup_dict):\\n try:\\n if self._verify_key_exists(lookup_key, lookup_dict):\\n transform_dict[transform_key] = \\\\\\n ''.join(nested_lookup(lookup_key, lookup_dict))\\n except TypeError:\\n pass\\n if isinstance(lookup_key, list):\\n transform_dict[transform_key] = \\\\\\n ''.join(self._key_list_search(lookup_key, lookup_dict))\\n return transform_dict\",\n \"def match_info(info_dict):\\n return True\",\n \"def test_addEntryByDict(self):\\n self.g.entryFormat = ['term', 'tags', 'value']\\n b = self.g.add_entry({'term': 'foo', 'tags': 'a', 'value': '1'})\\n self.assertTrue(b)\",\n \"def add_rule_to_dict(rule_dict, lhs, rhs):\\n if rhs not in rule_dict:\\n rule_dict[rhs] = list()\\n rule_dict[rhs].append(lhs) \\n return rule_dict\",\n \"def findMatches3(personDict,matches,skepticalMatches,additionalMatches,personDict2):\\n dictConsidered = personDict['ALIAS']\\n for alias in dictConsidered:\\n if alias == \\\"\\\":\\n continue\\n pairs = itertools.combinations(dictConsidered[alias],2)\\n for p in pairs:\\n k = tuple(sorted(p))\\n if (k not in matches) and (k not in skepticalMatches) and (k not in additionalMatches):\\n info1 = personDict['EnterpriseID'][p[0]]\\n info2 = personDict['EnterpriseID'][p[1]]\\n \\n info1b = personDict2['EnterpriseID'][p[0]]\\n info2b = personDict2['EnterpriseID'][p[1]]\\n score = getScorePair(info1b,info2b)\\n if score>=7:\\n additionalMatches[k] = score\\n\\n return additionalMatches\",\n \"def test_updatewithdictionarybycomparingdictionaries(self):\\n s1 = Square(10, 2, 1, 9)\\n s1_dictionary = s1.to_dictionary()\\n s2 = Square(1, 1)\\n s2.update(**s1_dictionary)\\n self.assertEqual(s1.__dict__, s2.__dict__)\",\n \"def matches(self, matches):\\n\\n self._matches = matches\",\n \"def matches(self, matches):\\n\\n self._matches = matches\",\n \"def test_addDict(self):\\n lidi = []\\n lidi.append({'term': 'foo', 'tags': 'a', 'value': '1'})\\n lidi.append({'term': 'bar', 'tags': 'a, b', 'value': '2'})\\n lidi.append({'term': 'gnark', 'tags': 'a, c', 'value': '3'})\\n self.g.add_dict(lidi)\",\n \"def insert_match(self, gameid):\\n if Match.query.filter(Match.gameid == gameid).first():\\n self.logger.info(\\\"Match {} already exists in the DB\\\".format(gameid))\\n return True\\n match_json = self.rc.get_match(gameid)\\n if not match_json:\\n self.logger.warning(\\\"API did not return data for this gameid: {}\\\".format(gameid))\\n return False\\n match_json = self.lower_keys(match_json)\\n # Get column names\\n match_columns = Match.__table__.columns.keys()\\n # Remove all k:v pairs that do not match column names\\n to_del = []\\n for k, v in match_json.items():\\n if k not in match_columns:\\n to_del.append(k)\\n # del match_json[k]\\n for k in to_del:\\n del match_json[k]\\n match = Match(**match_json)\\n match.gamecreation = datetime.utcfromtimestamp(match.gamecreation // 1000)\\n self.db.session.add(match)\\n self.db.session.commit()\\n return True\",\n \"def replace(self, matchobj):\\n key = matchobj.group(1)\\n if self.dict.has_key(key):\\n return self.dict[key]\\n else:\\n return ''\",\n \"def addtwodimdict(self, thedict, key_a, key_b, val):\\r\\n if key_a in thedict:\\r\\n thedict[key_a].update({key_b: val})\\r\\n else:\\r\\n thedict.update({key_a: {key_b: val}})\",\n \"def add(self, obj: model.IdentifiableArtefact):\\n for field, field_info in direct_fields(self.__class__).items():\\n # NB for some reason mypy complains here, but not in __contains__(), below\\n if isinstance(\\n obj, get_args(field_info.outer_type_)[1], # type: ignore [attr-defined]\\n ):\\n getattr(self, field)[obj.id] = obj\\n return\\n raise TypeError(type(obj))\",\n \"def _match_all(self, obj, criteria):\\n return all(getattr(obj, key_, None) == value_ for\\n key_, value_ in criteria.items())\",\n \"def add_item(key, obj, dst):\\n\\n if key not in dst:\\n dst[key] = []\\n dst[key].append(obj)\",\n \"def matches_dict(self, answer_dict):\\n\\n return self.matches(Answer(\\n answer_dict['group_id'],\\n answer_dict['block_id'],\\n answer_dict['answer_id'],\\n \\\"\\\",\\n answer_dict['group_instance'],\\n answer_dict['answer_instance'],\\n ))\",\n \"def match(dictionary, query, policy='relaxed', matches=None):\\n if query is None:\\n return True\\n assert policy in ['relaxed', 'strict'], \\\"\\\"\\n\\n for field, value in query.iteritems():\\n if field not in dictionary:\\n if policy == 'relaxed':\\n continue\\n else:\\n return False\\n if isinstance(value, list) or not isinstance(value, basestring):\\n values = value if isinstance(value, list) else [value]\\n if dictionary[field] not in values:\\n return False\\n if matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n else:\\n if value == '':\\n # Take special care if value is an empty string\\n if value != dictionary[field]:\\n return False\\n elif matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n continue\\n else:\\n match = re.compile(value).match(dictionary[field])\\n if not match:\\n return False\\n else:\\n if matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n for index, group in enumerate(match.groups()):\\n matches['%s_%d' % (field, index+1)] = group\\n continue\\n return True\",\n \"def _match(self, document: dict, query: dict) -> bool:\\n\\n matches = [\\n self._match(document.get(key), value)\\n if isinstance(value, dict) and isinstance(document.get(key), dict)\\n else document.get(key) == value\\n for key, value in query.items()\\n ]\\n return all(matches)\",\n \"def append(self, obj):\\r\\n self.record_count += 1\\r\\n \\r\\n if type(obj) == dict:\\r\\n self._probe_record(obj)\\r\\n else:\\r\\n self._probe_row(obj)\",\n \"def test_dict(self, obj: dict) -> None:\\r\\n properties = read_properties(obj)\\r\\n for key, value in properties.items():\\r\\n conditional_check(key, self.case_check, self.ignored_keys)\\r\\n if read_type(value) == 'object':\\r\\n logger.debug('dict -> dict')\\r\\n self.test_dict(obj=value)\\r\\n elif read_type(value) == 'array':\\r\\n logger.debug('dict -> list')\\r\\n self.test_list(array=value)\",\n \"def add(enforcer_dict, key, value):\\n enforcer_dict['d'] = 4\\n assert other.keystring == 'abcd'\\n assert other.valuesum == 10\\n\\n enforcer_dict.update(dict(e=5, f=6))\\n assert other.keystring == 'abcdef'\\n assert other.valuesum == 21\",\n \"def _add_match(self, backward_match_list):\\n\\n already_in = False\\n\\n for b_match in backward_match_list:\\n for l_match in self.match_list:\\n if b_match.match == l_match.match:\\n index = self.match_list.index(l_match)\\n self.match_list[index].qubit.append(b_match.qubit[0])\\n already_in = True\\n\\n if not already_in:\\n self.match_list.append(b_match)\",\n \"def match_source_key(self, match):\\n raise NotImplementedError\",\n \"def validate_match(context):\\n\\n schema = isinstance(match_schema, ValidateViewHook) and match_schema(request) or match_schema\\n\\n state = Dummyobj()\\n state.request = request\\n state.context = context\\n try:\\n return schema.to_python(request.matchdict, state=state)\\n except formencode.Invalid as exc:\\n unpacked = exc.unpack_errors()\\n request.set_property(lambda ctx: unpacked,\\n invalid_match_attr, reify=True)\\n if raise_exc is True:\\n _raise(invalid_match_exc, unpacked)\\n else:\\n return {}\",\n \"def add_match(self, match_id, team1, team2, team_tag1, team_tag2, ip, team1_id, team2_id):\\n\\n query_select = sC.SELECT_MATCHES_WHERE_IP_.format(ip)\\n match_id_ = self.util.match_with_ip_check(query_select)\\n\\n if match_id_:\\n return match_id_\\n\\n query = sC.INSERT_MATCHES_VALUES_.format(int(match_id),\\n team1[:pC.MAX_CHARACTERS_SQL], team2[:pC.MAX_CHARACTERS_SQL],\\n team_tag1[:pC.MAX_CHARACTERS_SQL], team_tag2[:pC.MAX_CHARACTERS_SQL],\\n ip, team1_id, team2_id, datetime.now())\\n\\n self.execute_query(query)\",\n \"def add_attributes_from_dict(self, dict):\\n for key in dict:\\n val = dict[key]\\n if hasattr(self, key):\\n setattr(self, key, val)\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n param = val.parameter_type\\n if param.k_bondorder or param.length_bondorder:\\n bond = topology.get_bond_between(*key)\\n fractional_bond_order = bond.fractional_bond_order\\n if not fractional_bond_order:\\n assert self._get_uses_interpolation(parameter_handler)\\n raise RuntimeError(\\n \\\"Bond orders should already be assigned at this point\\\",\\n )\\n else:\\n fractional_bond_order = None\\n topology_key = BondKey(\\n atom_indices=key,\\n bond_order=fractional_bond_order,\\n )\\n\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n bond_order=fractional_bond_order,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n topology=topology,\\n assigned_terms=matches,\\n valence_terms=valence_terms,\\n )\",\n \"def test_add_nested_dict_value():\\n\\n recursiveKeys = [\\n \\\"reward_signals.extrinsic.strength\\\",\\n \\\"reward_signals.extrinsic.gamma\\\",\\n \\\"reward_signals.curiosity.strength\\\",\\n \\\"reward_signals.curiosity.gamma\\\",\\n ]\\n\\n expectedDict = {\\n 'reward_signals': {\\n 'curiosity': {'gamma': 1.0, 'strength': 1.0},\\n 'extrinsic': {'gamma': 1.0, 'strength': 1.0},\\n }\\n }\\n\\n dictionary = {}\\n\\n for key in recursiveKeys:\\n common.add_nested_dict_value(dictionary, key, 1.0)\\n\\n assert dictionary == expectedDict\\n\\n dictionary = {'reward_signals': {'extrinsic': {}}}\\n\\n for key in recursiveKeys:\\n common.add_nested_dict_value(dictionary, key, 1.0)\\n\\n assert dictionary == expectedDict\\n\\n dictionary = {'reward_signals': {'extrinsic': {'gamma': 0.99}}}\\n\\n for key in recursiveKeys:\\n common.add_nested_dict_value(dictionary, key, 1.0)\\n\\n assert dictionary == expectedDict\",\n \"def addMatchEntry(tmpFD, match, mtype, val):\\n tmpFD.write(f\\\" {match} {mtype} {val}\\\\n\\\")\",\n \"def _add_data_to_response(self, desc_matches, url, page_matches, response):\\n\\n if desc_matches:\\n response.append({\\n 'url': url,\\n 'matches': desc_matches\\n })\\n\\n if page_matches:\\n response.append({\\n 'url': url,\\n 'matches': page_matches\\n })\",\n \"def match_user(dictionary: 'Climatematch', \\n match: 'NGOMatch') -> Dict[str, tuple(int,int)]:\\n\\n total = {}\\n \\n for user in dictionary:\\n total[user] = {}\\n skillsCount = 0\\n interestCount = 0\\n for sk in dictionary[user]['skills']: \\n if sk in match['skills']['technical']:\\n skillsCount = skillsCount + 1\\n elif sk in match['skills']['interpersonal']:\\n skillsCount = skillsCount + 1\\n \\n for inte in dictionary[user]['interest']: \\n if inte in match['interest']:\\n interestCount = interestCount + 1\\n \\n total[user][(skillsCount, interestCount)]\\n return total\",\n \"def _merge_by_query(self, obj_dict):\\n _res = self.__session.query(obj_dict[\\\"class\\\"]).filter_by(**obj_dict[\\\"query_dict\\\"]).first()\\n\\n if _res is None:\\n self._add(obj_dict[\\\"instance\\\"])\\n else:\\n if hasattr(obj_dict[\\\"instance\\\"], 'attributes') and \\\\\\n hasattr(obj_dict[\\\"instance\\\"], 'p_key'):\\n for attr in obj_dict[\\\"instance\\\"].attributes:\\n if attr not in obj_dict[\\\"instance\\\"].p_key:\\n setattr(_res, attr, getattr(obj_dict[\\\"instance\\\"], attr))\\n # updating the instance\\n obj_dict[\\\"instance\\\"] = _res\\n else:\\n raise AttributeError(\\\"Class variable (attributes / p_key) not set for %s\\\" %\\n (obj_dict[\\\"instance\\\"],))\",\n \"def match(self, obj):\\n\\n return self._match(self.rule, obj)\",\n \"def add_dict(self, d, record_cls=None):\\n rc = record_cls or self._ELE_CLS\\n self.add_container(self.from_dict(d, record_cls=rc))\\n return len(self)\",\n \"def add_value(self, thing_key, dkey, value):\\n if thing_key in self.things_dict:\\n dic = self.things_dict[thing_key]\\n if type(dic) != type({}):\\n dic = {}\\n dic[dkey] = value\\n self.things_dict[thing_key] = dic\\n self.changed.append(thing_key)\\n return True\\n return False\",\n \"def _merge_obj(result, obj, pointer=''): # changed code\\n if not isinstance(result, dict):\\n result = {}\\n\\n if not isinstance(obj, dict):\\n return obj\\n\\n for key, value in obj.items():\\n if isinstance(value, dict):\\n target = result.get(key)\\n if isinstance(target, dict):\\n _merge_obj(target, value, pointer=f'{pointer}/{key}') # changed code\\n continue\\n result[key] = {}\\n _merge_obj(result[key], value, pointer=f'{pointer}/{key}') # changed code\\n continue\\n\\n # new code\\n if key in result:\\n pointer_and_key = f'{pointer}/{key}'\\n # Exceptions.\\n if (value is None and pointer_and_key == '/definitions/Milestone/properties/documents/deprecated' and\\n repo_name in ('ocds_milestone_documents_extension', 'public-private-partnerships')):\\n warnings.warn(f're-adds {pointer}')\\n elif (value == [] and pointer_and_key == '/required' and\\n repo_name == 'ocds_pagination_extension'):\\n warnings.warn(f'empties {pointer_and_key}')\\n else:\\n if is_profile:\\n message = ' - check for repeats across extension_versions.json, dependencies, testDependencies'\\n else:\\n message = ''\\n raise Exception(f'unexpectedly overwrites {pointer_and_key}{message}')\\n\\n if value is None:\\n result.pop(key, None)\\n continue\\n result[key] = value\\n return result\",\n \"def add(self, key, obj):\\n with self._lock:\\n slot = self._dict.get(key, None)\\n if slot is None:\\n slot = [obj, 0]\\n else:\\n slot[1] += 1\\n self._dict[key] = slot\",\n \"async def add_dict(self, dic):\\n for key in dic:\\n await self.set(key, dic[key])\",\n \"def matchRecordAttrs(mapobj, attrs):\\n for k,v in iteritems(attrs):\\n try: val = getattr(mapobj, k)\\n except AttributeError: # k isn't an attr of record\\n if v: return False # if k doesn't exist in mapobj but was required, no match\\n else: continue # otherwise ignore attributes that aren't defined for the given map record\\n if val != v: return False # if any criteria matches, it's considered a match\\n return True # all criteria matched at all\",\n \"def _add_dict_values(self, d1, d2):\\n\\n if d1 is None and d2 is None:\\n return None\\n\\n d1 = d1 or {}\\n d2 = d2 or {}\\n\\n added = {}\\n for key in set(list(d1.keys()) + list(d2.keys())):\\n added[key] = dict(d1.get(key, {}), **(d2.get(key, {})))\\n return added\",\n \"def add_item(dct,item):\\r\\n if item not in dct[0]:\\r\\n print \\\"itemNotFound \\\",str(item)\\r\\n return False\\r\\n\\r\\n num=len(item)\\r\\n if num in dct:\\r\\n if item in dct[num]:\\r\\n return False\\r\\n else:\\r\\n dct[num].append(item)\\r\\n return True\\r\\n else:\\r\\n dct[num]=[item]\\r\\n return True\",\n \"def _add_dictionary(self, current, added):\\n for key in added:\\n if key in current and isinstance(current[key], collections.Mapping):\\n self._add_dictionary(current[key], added[key])\\n else:\\n current[key] = added[key]\",\n \"def validate_present(self, obj):\\n for k, v in obj.items():\\n func = self.validation.get(k)\\n if func:\\n func(k, v)\",\n \"def add(self, obj: object) -> None:\\n self._contains.append(obj)\",\n \"def test_merge_aggregate_traditional(self):\\n mdict = copy.deepcopy(self.dict1)\\n mdict[\\\"A\\\"] = \\\"b\\\"\\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\\\"A\\\": \\\"b\\\"})\\n self.assertEqual(mdict, ret)\",\n \"def match_fill(self,MatchMake_inst):\\n if type(MatchMake_inst) is not MatchMake:\\n raise TypeError(\\\"Wrong datatype: MatchMake_inst has to be of custom type MatchMake!\\\")\\n\\n res_dict = {}\\n for match in MatchMake_inst._score_list:\\n try:\\n res_dict[match.match_score].append(match.match_target)\\n \\n except KeyError:\\n res_dict[match.match_score] = [match.match_target]\\n \\n\\n self.add(MatchMake_inst._source) # add source in network\\n parent = [MatchMake_inst._source]\\n for score in sorted(res_dict.keys(),reverse=True):\\n for target in res_dict[score]:\\n self.add(target,parent,score)\\n parent = res_dict[score]\",\n \"def add_dict(dest, src):\\n for key in src.keys():\\n if key in dest.keys():\\n dest[key] += src[key]\\n else:\\n dest[key] = src[key]\",\n \"def from_re_match(cls, match):\\n kwargs = match.groupdict()\\n player_location = kwargs['player_location'].split()\\n kwargs['player_location'] = (int(player_location[0]),\\n int(player_location[1]),\\n int(player_location[2]))\\n target_location = kwargs['target_location'].split()\\n kwargs['target_location'] = (int(target_location[0]),\\n int(target_location[1]),\\n int(target_location[2]))\\n if match.string.endswith('(headshot)'):\\n kwargs['headshot'] = True\\n return cls(**kwargs)\",\n \"def add(self, key, value):\",\n \"def find(found_item, hash_table_cell):\\n if found_item:\\n found_item[1] = obj\\n else:\\n hash_table_cell.append([key, obj])\\n self.size += 1\\n self._keys.append(key)\",\n \"def save(self, **kwargs):\\n for k, v in kwargs.items():\\n self._validated_data[k] = v\\n\\n # Create or update direct relations (foreign key, one-to-one)\\n related_objects = self._extract_reverse_relations(kwargs)\\n self._save_direct_relations(kwargs)\\n\\n # TODO: move to a specialized class (easier to subclass)\\n try:\\n match_on = {}\\n for field_name, field in self.get_fields().items():\\n if self.match_on == '__all__' or field_name in self.match_on:\\n match_on[field.source or field_name] = self._validated_data.get(field_name)\\n # a parent serializer may inject a value that isn't among the fields, but is in `match_on`\\n for key in self.match_on:\\n if key not in self.get_fields().keys():\\n match_on[key] = self._validated_data.get(key)\\n match = self.queryset.get(**match_on)\\n for k, v in self._validated_data.items():\\n setattr(match, k, v)\\n except ObjectDoesNotExist:\\n match = self.queryset.model(**self._validated_data)\\n except (TypeError, ValueError):\\n self.fail('incorrect_type', data_type=type(self._validated_data).__name__)\\n match.save()\\n\\n self._save_reverse_relations(related_objects, instance=match)\\n return match\",\n \"def test_deep_set_create(self):\\n mdict = copy.deepcopy(self.dict1)\\n res = dictupdate.set_dict_key_value(mdict, \\\"K:L:M\\\", \\\"Q\\\")\\n self.assertEqual(\\n {\\n \\\"A\\\": \\\"B\\\",\\n \\\"C\\\": {\\\"D\\\": \\\"E\\\", \\\"F\\\": {\\\"G\\\": \\\"H\\\", \\\"I\\\": \\\"J\\\"}},\\n \\\"K\\\": {\\\"L\\\": {\\\"M\\\": \\\"Q\\\"}},\\n },\\n res,\\n )\",\n \"def post(self):\\n match_data = self.get_from_body('match')\\n try:\\n guest_id = match_data['guest']\\n guest_points = match_data['guestPoints']\\n host_id = match_data['host']\\n host_points = match_data['hostPoints']\\n if host_id is guest_id:\\n self.write_signed_error(400, 'Host and guest id cannot be equal')\\n match = Match(guest=ndb.Key(User, guest_id),\\n guest_points=guest_points,\\n host=ndb.Key(User, host_id),\\n host_points=host_points)\\n # Asynchronously update player data\\n guest_future = User.get_by_id_async(guest_id)\\n host_future = User.get_by_id_async(host_id)\\n guest = guest_future.get_result()\\n host = host_future.get_result()\\n guest.experience += guest_points\\n host.experience += host_points\\n # Update entities\\n results = _update_entities(match, host, guest)\\n # Prepare message\\n match_key = results[0].urlsafe()\\n self.write_signed_message(201, 'id', match_key)\\n except (KeyError, TypeError):\\n self.write_signed_error(400, 'Missing attributes for match')\\n except TransactionFailedError:\\n self.write_signed_error(507, 'Unable to store match')\\n except AttributeError:\\n self.write_signed_error(400, 'Invalid id')\\n except BadValueError:\\n # Thrown when model validations fail\\n self.write_signed_error(400, 'Invalid data')\",\n \"def test_append_to_results_in(self):\\n # pre conditions\\n field = 'foo'\\n value = 'bar'\\n existing = ['baz']\\n existing.append(value)\\n values_dict = {field: existing}\\n\\n self.assertTrue(value in values_dict.get(field), \\\"pre-condition failed\\\")\\n\\n # test\\n result = gen.append_to_results(field, value, values_dict, unique=True)\\n\\n # post conditions\\n expected = ['baz', 'bar']\\n self.assertEqual(result, expected)\",\n \"def test_apply_scalar_map(self):\\n super(TestObjDict, self).test_apply_scalar_map(_as_obj=True)\",\n \"def check_dict(dic, validator, messages):\\n check_dict_alg(dic, validator, [], messages, validator, \\\"NoObject\\\")\",\n \"def build_match_clause(field, string):\\r\\n answer = {}\\r\\n tmp = {}\\r\\n tmp[field] = string\\r\\n answer['match'] = tmp\\r\\n return answer\",\n \"def add_to_dict_fail( self, key_0, key_1, list_2 ):\\n dict_1_new = { key_1: list_2 }\\n\\n\\n dict_1_current = self._dd_dict.get( key_1 )\\n if dict_1_current is None:\\n #dict_1_new = dict_1_new\\n pass\\n\\n else:\\n dict_1_new = {**dict_1_current, **dict_1_new }\\n\\n\\n dict_0_new = { key_0: dict_1_new } # maybe a merge ??\\n\\n dict_0_current = self._dd_dict.get( key_0 )\\n\\n if dict_0_current is None:\\n dict_0_new = dict_0_new\\n\\n else:\\n dict_0_new = {**dict_0_current, **dict_0_new }\\n\\n dict_0_new = {**dict_0_current, **dict_0_new }\\n\\n self._dd_dict = { **self._dd_dict, **dict_0_new }\\n\\n print( self._dd_dict )\\n\\n return self._dd_dict\",\n \"def func(match, create_new=False, *args, **kwargs):\\n\\n data = match.group(0)\\n\\n if create_new:\\n dash = data.replace(\\\"_\\\", \\\"-\\\") if \\\"_\\\" in data else data\\n\\n if dash not in objects:\\n new = gen_guid()\\n objects[dash] = new\\n objects[dash.replace(\\\"-\\\", \\\"_\\\")] = new.replace(\\\"-\\\", \\\"_\\\")\\n\\n if data in objects:\\n return (objects[data], True)\\n\\n return (data, False)\",\n \"def merge_dict(target, addition):\\n for key in addition:\\n if key in target and isinstance(target[key], dict) \\\\\\n and isinstance(addition[key], dict):\\n merge_dict(target[key], addition[key])\\n else:\\n target[key] = addition[key]\",\n \"def __iadd__(self, other):\\n if not isinstance(other, dict):\\n msg = 'Can not concatenate Dict and {}'.format(type(other))\\n raise TypeError(msg)\\n for key, val in other.items():\\n if key in self:\\n self._append_key(key, val)\\n else:\\n self[key] = val\\n return self\",\n \"def test_adduser_entry(user_tuple, wordlist, input_dict, output_dict):\\n\\n assert set(adduser_entry(user_tuple, wordlist, input_dict)[user_tuple]) == set(output_dict[user_tuple])\\n for key in output_dict:\\n assert type(key) == tuple\\n assert type(output_dict[user_tuple]) == list\",\n \"def add_to_dict(from_dict, to_dict):\\n for k, v in list(from_dict.items()):\\n if hasattr(v, 'copy') and callable(getattr(v, 'copy')):\\n to_dict[k] = v.copy()\\n else:\\n to_dict[k] = v\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: \\\"Topology\\\",\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[\\n Union[TopologyKey, LibraryChargeTopologyKey],\\n PotentialKey,\\n ] = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n topology_key = TopologyKey(atom_indices=key)\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n if self.__class__.__name__ in [\\n \\\"SMIRNOFFBondCollection\\\",\\n \\\"SMIRNOFFAngleCollection\\\",\\n ]:\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n assigned_terms=matches,\\n topology=topology,\\n valence_terms=valence_terms,\\n )\",\n \"def match_id(self, match_id):\\n\\n self._match_id = match_id\",\n \"def add(obj):\",\n \"def create_or_update_match_settings(\\n request: MatchSettingsUpdateRequest,\\n ) -> MatchSettingsUpdateResponse:\\n if config := AdditionalMatchSettingsConfig.get(request.privacy_group_id):\\n config.pdq_match_threshold = request.pdq_match_threshold\\n hmaconfig.update_config(config)\\n\\n return MatchSettingsUpdateResponse(\\n f\\\"match_settings updated for pg_id {request.privacy_group_id} with pdq_match_threshold={request.pdq_match_threshold}\\\"\\n )\\n\\n config = AdditionalMatchSettingsConfig(\\n request.privacy_group_id, request.pdq_match_threshold\\n )\\n hmaconfig.create_config(config)\\n return MatchSettingsUpdateResponse(\\n f\\\"match_settings created for pg_id {request.privacy_group_id} with pdq_match_threshold={request.pdq_match_threshold}\\\"\\n )\",\n \"def _match(self, rule, obj):\\n\\n for key in rule:\\n if key == '$and':\\n if not self.handle_and(key, rule[key], obj):\\n return False\\n\\n elif key == '$or':\\n if not self.handle_or(key, rule[key], obj):\\n return False\\n\\n elif key == '$nor':\\n if not self.handle_nor(key, rule[key], obj):\\n return False\\n\\n elif not self.handle_field(key, rule[key], obj):\\n return False\\n\\n return True\",\n \"def _find_match(needle: dict, haystack: list, keys: list):\\n for item in haystack:\\n for key in keys:\\n if item.get(key) != needle[key]:\\n break\\n else:\\n return item\\n return None\",\n \"def calculate_match_at_backend():\\n\\n # Calculate lovermatch list for each user\\n user_set = UserInfo.objects\\n for u1 in user_set:\\n matchlist = {}\\n for u2 in user_set:\\n if u1 != u2:\\n features_to_match = u1.features\\n weights = u1.percentage\\n sim = get_similarity(u1, u2, features_to_match, weights)\\n matchlist[u2.name] = sim\\n u1.loverMatch = matchlist\\n u1.save()\\n\\n # Calculate lovermatched list for each user\\n user_set = UserInfo.objects\\n for u1 in user_set:\\n matchedlist = {}\\n for u2 in user_set:\\n if u1 != u2:\\n if u1.name in u2.loverMatch.keys():\\n matchedlist[u2.name] = u2.loverMatch[u1.name]\\n u1.loverMatched = matchedlist\\n u1.save()\",\n \"def store_matches(\\n self,\\n parameter_handler: ImproperTorsionHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n self.key_map = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n parameter_handler._assert_correct_connectivity(\\n val,\\n [\\n (0, 1),\\n (1, 2),\\n (1, 3),\\n ],\\n )\\n n_terms = len(val.parameter_type.k)\\n for n in range(n_terms):\\n smirks = val.parameter_type.smirks\\n non_central_indices = [key[0], key[2], key[3]]\\n\\n for permuted_key in [\\n (\\n non_central_indices[i],\\n non_central_indices[j],\\n non_central_indices[k],\\n )\\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\\n ]:\\n topology_key = ImproperTorsionKey(\\n atom_indices=(key[1], *permuted_key),\\n mult=n,\\n )\\n potential_key = PotentialKey(\\n id=smirks,\\n mult=n,\\n associated_handler=\\\"ImproperTorsions\\\",\\n )\\n self.key_map[topology_key] = potential_key\",\n \"def add_object(self, object_to_be_added):\\n new_mapping = Map.add_object(self.id, object_to_be_added)\\n if new_mapping:\\n object_to_be_added.save()\\n new_mapping.ref_id = object_to_be_added.id\\n return True\\n else:\\n return False\",\n \"def test_merge_overwrite_traditional(self):\\n mdict = copy.deepcopy(self.dict1)\\n mdict[\\\"A\\\"] = \\\"b\\\"\\n ret = dictupdate.merge_overwrite(copy.deepcopy(self.dict1), {\\\"A\\\": \\\"b\\\"})\\n self.assertEqual(mdict, ret)\",\n \"def from_dict(self,\\n d: dict,\\n iter_if: FunctionType = None,\\n iter_by: FunctionType = None,\\n ) -> NoReturn:\\n for k, v in d.items():\\n if isinstance(iter_if, FunctionType) and not iter_if(k, v):\\n continue\\n if iter_by:\\n v = iter_by(k, v)\\n if k not in dir(self): # TODO is it strict?\\n # warn develop\\n print(f\\\"warning: a key({k}) not in the document model is inserting into mongodb.\\\")\\n setattr(self, k, v)\",\n \"def traverse_dict_and_add(self, rootDir, dictH):\\n origRootDir = rootDir\\n for key, item in dictH.iteritems():\\n if item is None or item == {} or item == []:\\n attemptedJoin = os.path.normpath(os.path.join(rootDir, key))\\n keyPath = None\\n if not os.path.isabs(key) and (os.path.isdir(attemptedJoin) or\\n os.path.isfile(attemptedJoin)):\\n # copy the found file/folder to directory\\n keyPath = attemptedJoin\\n if os.path.isabs(key) and (os.path.isfile(key) or\\n os.path.isdir(key)):\\n # copy file/folder to the root location\\n if not os.path.isdir(rootDir):\\n paths.mkdir_p(rootDir)\\n keyPath = paths.path_leaf(key)\\n copyLoc = os.path.join(rootDir, keyPath)\\n shutil.copy2(key, copyLoc)\\n continue # skip the rest of this iteration\\n\\n if keyPath is not None and not os.path.isdir(keyPath):\\n # the string was either not a file/folder or couldn't be\\n # resolved from a relative path into a file/folder\\n #\\n copyLoc = paths.path_leaf(keyPath)\\n copyLoc = os.path.join(rootDir, copyLoc)\\n print copyLoc\\n shutil.copy2(key, copyLoc)\\n elif keyPath is None:\\n # no directory exists at this location, create one\\n dirToMake = os.path.normpath(os.path.join(rootDir, key))\\n os.makedirs(dirToMake)\\n # sys.exit('Got: \\\"{f}\\\", couldn\\\\'t resolve '\\n # 'into file or folder'.format(f=key))\\n\\n elif isinstance(item, dict):\\n newRootDir = os.path.join(rootDir, key)\\n newRootDir = os.path.normpath(newRootDir)\\n self.traverse_dict_and_add(rootDir=newRootDir,\\n dictH=dictH[key])\\n else:\\n sys.exit('Got: \\\"{f}\\\", expected a dictionary, '\\n '\\\\{\\\\} or None'.format(f=item))\",\n \"def test_deep_append(self):\\n sdict = {\\\"bar\\\": {\\\"baz\\\": [1, 2]}}\\n res = dictupdate.append_dict_key_value(sdict, \\\"bar:baz\\\", 42)\\n self.assertEqual({\\\"bar\\\": {\\\"baz\\\": [1, 2, 42]}}, res)\\n # Append with alternate delimiter\\n res = dictupdate.append_dict_key_value(sdict, \\\"bar~baz\\\", 43, delimiter=\\\"~\\\")\\n self.assertEqual({\\\"bar\\\": {\\\"baz\\\": [1, 2, 42, 43]}}, res)\\n # Append to a not-yet existing list\\n res = dictupdate.append_dict_key_value({}, \\\"foo:bar:baz\\\", 42)\\n self.assertEqual({\\\"foo\\\": {\\\"bar\\\": {\\\"baz\\\": [42]}}}, res)\",\n \"def _match(self, check):\\n matches = []\\n tests = {}\\n for k, v in check.items():\\n if isinstance(v, dict):\\n tests[k] = CompositeFilter(v)\\n else:\\n tests[k] = lambda o: _add_tz(o) == _add_tz(v)\\n\\n for rec in self._records.values():\\n if self._match_one(rec, tests):\\n matches.append(deepcopy(rec))\\n return matches\",\n \"def handleMatch(self, m):\\r\\n pass\",\n \"def add_dict_entry(dictionary: dict, key: Any, value: Any) -> None:\\n try:\\n dictionary[key].append(value)\\n except KeyError:\\n dictionary[key] = [value]\",\n \"def apply_scalar_map(self, *args, **kwargs):\\n kwargs['_as_obj'] = True\\n return super(ObjDict, self).apply_scalar_map(*args, **kwargs)\",\n \"def update_dict(new,old):\",\n \"def match(self, item):\",\n \"def find(self, a, b):\\n\\t\\tfor i in b:\\n\\t\\t\\tif 'ipv4' in i and 'ipv4' in a:\\n\\t\\t\\t\\tif i['ipv4'] == a['ipv4']:\\n\\t\\t\\t\\t\\ti.update(a)\\n\\t\\t\\t\\t\\treturn\\n\\t\\t\\telif 'ipv6' in i and 'ipv6' in a:\\n\\t\\t\\t\\tif i['ipv6'] == a['ipv6']:\\n\\t\\t\\t\\t\\ti.update(a)\\n\\t\\t\\t\\t\\treturn\\n\\t\\t\\telif 'hostname' in i and 'hostname' in a:\\n\\t\\t\\t\\tif i['hostname'] == a['hostname']:\\n\\t\\t\\t\\t\\ti.update(a)\\n\\t\\t\\t\\t\\treturn\\n\\t\\tb.append(a)\\n\\t\\treturn\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72251153","0.6223135","0.612522","0.6043846","0.6039093","0.5865672","0.5826964","0.5673978","0.5657533","0.56395197","0.5595575","0.55939347","0.5582442","0.55700904","0.55490994","0.54979956","0.5410391","0.5368418","0.536791","0.535772","0.5288205","0.5236559","0.52085674","0.5194137","0.5194137","0.51784515","0.5150603","0.51416355","0.5136652","0.51329386","0.51117957","0.51086485","0.5105162","0.510268","0.5099662","0.5097704","0.50716406","0.5065202","0.5056278","0.50531244","0.50442034","0.50409013","0.50400573","0.50330704","0.50313747","0.5022077","0.49991575","0.49902794","0.4989795","0.49827197","0.49775675","0.4976321","0.4961318","0.49597058","0.4955217","0.49515486","0.49506053","0.49405125","0.4911506","0.4906947","0.49038094","0.4892627","0.48887813","0.48864618","0.48768723","0.4875549","0.48695296","0.48669994","0.486568","0.48595595","0.48559168","0.48544765","0.48503304","0.4849082","0.4839271","0.4839074","0.48311737","0.48275658","0.48261672","0.4813723","0.4808131","0.48005787","0.47974283","0.4796537","0.47934455","0.47928852","0.47928467","0.47869116","0.47856015","0.47749624","0.47642645","0.4747214","0.47470838","0.4745575","0.4741018","0.4740947","0.47349185","0.4734899","0.47285774","0.47275716"],"string":"[\n \"0.72251153\",\n \"0.6223135\",\n \"0.612522\",\n \"0.6043846\",\n \"0.6039093\",\n \"0.5865672\",\n \"0.5826964\",\n \"0.5673978\",\n \"0.5657533\",\n \"0.56395197\",\n \"0.5595575\",\n \"0.55939347\",\n \"0.5582442\",\n \"0.55700904\",\n \"0.55490994\",\n \"0.54979956\",\n \"0.5410391\",\n \"0.5368418\",\n \"0.536791\",\n \"0.535772\",\n \"0.5288205\",\n \"0.5236559\",\n \"0.52085674\",\n \"0.5194137\",\n \"0.5194137\",\n \"0.51784515\",\n \"0.5150603\",\n \"0.51416355\",\n \"0.5136652\",\n \"0.51329386\",\n \"0.51117957\",\n \"0.51086485\",\n \"0.5105162\",\n \"0.510268\",\n \"0.5099662\",\n \"0.5097704\",\n \"0.50716406\",\n \"0.5065202\",\n \"0.5056278\",\n \"0.50531244\",\n \"0.50442034\",\n \"0.50409013\",\n \"0.50400573\",\n \"0.50330704\",\n \"0.50313747\",\n \"0.5022077\",\n \"0.49991575\",\n \"0.49902794\",\n \"0.4989795\",\n \"0.49827197\",\n \"0.49775675\",\n \"0.4976321\",\n \"0.4961318\",\n \"0.49597058\",\n \"0.4955217\",\n \"0.49515486\",\n \"0.49506053\",\n \"0.49405125\",\n \"0.4911506\",\n \"0.4906947\",\n \"0.49038094\",\n \"0.4892627\",\n \"0.48887813\",\n \"0.48864618\",\n \"0.48768723\",\n \"0.4875549\",\n \"0.48695296\",\n \"0.48669994\",\n \"0.486568\",\n \"0.48595595\",\n \"0.48559168\",\n \"0.48544765\",\n \"0.48503304\",\n \"0.4849082\",\n \"0.4839271\",\n \"0.4839074\",\n \"0.48311737\",\n \"0.48275658\",\n \"0.48261672\",\n \"0.4813723\",\n \"0.4808131\",\n \"0.48005787\",\n \"0.47974283\",\n \"0.4796537\",\n \"0.47934455\",\n \"0.47928852\",\n \"0.47928467\",\n \"0.47869116\",\n \"0.47856015\",\n \"0.47749624\",\n \"0.47642645\",\n \"0.4747214\",\n \"0.47470838\",\n \"0.4745575\",\n \"0.4741018\",\n \"0.4740947\",\n \"0.47349185\",\n \"0.4734899\",\n \"0.47285774\",\n \"0.47275716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84316427"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":590,"cells":{"query":{"kind":"string","value":"Find a match using match_dict. Returns None if there is no match. Checks to make sure match_dict keys are valid."},"document":{"kind":"string","value":"def match(self, match_dict):\r\n for match_key in match_dict.keys():\r\n assert match_key in self.keys_to_track\r\n\r\n for key_to_track in self.keys_to_track:\r\n if match_dict.has_key(key_to_track):\r\n match_val = match_dict[key_to_track]\r\n if self.tracker[key_to_track].has_key(match_val):\r\n return self.tracker[key_to_track][match_val]\r\n return 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 _find_match(needle: dict, haystack: list, keys: list):\n for item in haystack:\n for key in keys:\n if item.get(key) != needle[key]:\n break\n else:\n return item\n return None","def dict_match(d, key, default=None):\n\n if key in d and \"[\" not in key:\n return d[key]\n else:\n for pattern, value in iteritems(d):\n if fnmatchcase(key, pattern):\n return value\n return default","def find_match(name, dictionary):\n if name == '':\n # raise \"Didn't find name\"\n return False\n search_name = (' ').join(name.split(' ')[:-1])\n if search_name in dictionary:\n return search_name\n else:\n return find_match(search_name, dictionary)","async def get_match_from_id(match_id: int) -> Match or None:\n if match_id is None:\n return None\n\n if match_id in match_library:\n return match_library[match_id]\n\n raw_data = await matchdb.get_raw_match_data(match_id)\n if raw_data is not None:\n return await make_match_from_raw_db_data(raw_data)\n else:\n return None","def find(self, location, dictionary=None, key_index=1):\n\n # dictionary is self object if no dictionary is provided\n if not dictionary:\n dictionary = self\n\n # take first value field to be found\n value = normalize_name(location[key_index])\n\n # extract matched value from\n value_matched = process.extractOne(value, dictionary.keys())\n\n if value_matched and value_matched[1] > self.THRESHOLD_RATIO:\n key = value_matched[0]\n\n # if there are more values to evaluate, call recursively\n if len(location) > key_index + 1:\n # print value_matched[1],\n return self.find(location, dictionary[key], key_index + 1)\n\n else:\n # print value_matched[1],\n return dictionary[key]\n\n else:\n return None","def search(d, key, default=None):\n stack = [iter(d.items())]\n while stack:\n for k, v in stack[-1]:\n if isinstance(v, dict):\n stack.append(iter(v.items()))\n break\n elif k == key:\n return v\n else:\n stack.pop()\n return default","def get_match_result(self, variable):\n try:\n return self._match_result_dict[variable]\n except KeyError:\n return None","def find(name, *dicts):\n for d in dicts:\n if type(d) == str:\n return d\n elif name in d and d[name] is not None:\n return d[name]\n\n return None","def find_in_dict(obj, key):\n if key in obj:\n return obj[key]\n for k, v in obj.items():\n if isinstance(v,dict):\n item = find_in_dict(v, key)\n if item is not None:\n return item","def _get_value(match_entry: Dict, path0: str) -> any:\n if path0 is None:\n current_el = match_entry\n else:\n path = path0.split('/')\n current_el = match_entry\n for p in path:\n if current_el is None:\n break\n current_el = current_el.get(p)\n return current_el","def find(self, entry_id: str, match: callable = operator.contains) -> Any:\n try:\n return next(self.find_all(entry_id, match))\n except StopIteration as error:\n raise errors.NoEntryFound(f'No entries found which match {entry_id}') from error","def find_value(dic, key):\n return dic[key]","def search_value(d, key, default=None):\n stack = [iter(d.items())]\n while stack:\n for k, v in stack[-1]:\n if isinstance(v, dict):\n stack.append(iter(v.items()))\n break\n elif k == key:\n return v\n else:\n stack.pop()\n return default","def get_match_hash_key(hashkey, table):\n if hashkey in table:\n # assume that this has at least one flow entry\n b = convert_ip_to_int(table[hashkey][0].nw_src)\n a = convert_ip_to_int(table[hashkey][0].nw_dst)\n match_hash = (a * a + a + b) if a >= b else (a + b * b)\n if match_hash in table:\n return match_hash\n else:\n return None\n else:\n return None","def dict_find_name(some_dict: Dict[str, Referent], path: List[str]) -> Result:\n if path:\n head, *tail = path\n try:\n return NameContainer.dict_find_name(\n cast(Dict[str, Referent], some_dict[head]),\n tail)\n except KeyError:\n NameContainer.logger.debug(f\"{head!r} not found in {some_dict.keys()}\")\n raise NameContainer.NotFound(path)\n else:\n return cast(Result, some_dict)","def _parse_line(line):\n\n for key, rx in rx_dict.items():\n match = rx.search(line)\n if match:\n return key, match\n # if there are no matches\n return None, None","def _parse_line(line):\n\n for key, rx in rx_dict.items():\n match = rx.search(line)\n if match:\n return key, match\n # if there are no matches\n return None, None","def _search_list_of_dictionaries(key, value, list_of_dictionaries):\n\n for element in list_of_dictionaries:\n if element.get(key) == value:\n return element\n return None","def findMatcher(self, ch):\n for m in self.matchers:\n if m.match(ch):\n return m\n return None","def match(id=0):\n match = Match.query.get(id)\n if match is not None:\n return render_template('match.html', match=Match.query.get(id))\n abort(404)","def _find_by_key(self, key, find):\n index = hashId(key, self.capacity) # Get the index/ bucket based on hash code of the key\n \n hash_table_cell = self._entry[index]\n found_item = None\n for item in hash_table_cell: #Iterrate the entry array and check the key is matching and if key is same than get the value\n if item[0] == key:\n found_item = item\n break\n\n return find(found_item, hash_table_cell)","def lookup(my_dict, my_key, default_value=None):\n if my_key in my_dict:\n return my_dict[my_key]\n else:\n return default_value","def find(self, answer):\n self._validate(answer)\n\n for index, existing in enumerate(self.answers):\n if answer.matches_dict(existing):\n return index\n\n return None","def parse_line(keyword_dict, line):\n for key, rx in keyword_dict.items():\n match = rx.search(line)\n if match:\n return key, match\n\n return None, None","def get_match_by_id(self, match_id):\n request = rq.get(\n 'https://{region}.api.pvp.net/api/lol/{region}/v{version}/match/{id}?api_key={api_key}'.format(\n region=self.region,\n version=api_version['match'],\n id=match_id,\n api_key=API_KEY\n )\n )\n print(self.region, request)\n check_response(request)\n return request.json()","def findKey(value,dict):\n for key, val in dict.iteritems():\n if value in val:\n return key","def dict_search_recursive(d, k):\n # FIXME: make it generic recursive search over nested graphs and move to smp_base\n\n # print \"#\" * 80\n # print \"searching k = %s \" % (k,),\n if k in d:\n # print \"found k = %s, params = %s\" % (k, d[k]['params'].keys())\n return d[k]\n else:\n # print \"d.keys()\", d.keys()\n for k_, v_ in list(d.items()):\n # if v_[\n if 'graph' in v_['params']: # or v_['params'].has_key('subgraph'):\n # print \"k_\", k_, \"v_\", v_['params'].keys()\n return dict_search_recursive(v_['params']['graph'], k)\n # None found\n return None","def find_item(hash_table_ref, key_sig):\n if not hasattr(key_sig, '__iter___'):\n key_sig = [key_sig]\n\n last_item = key_sig[len(key_sig) - 1]\n for key in key_sig:\n if key != last_item:\n if hasattr(hash_table_ref, 'keys') and key in hash_table_ref:\n hash_table_ref = hash_table_ref[key]\n else:\n # Item not found\n return None\n else:\n if hasattr(hash_table_ref, 'keys') and \\\n key in hash_table_ref:\n return hash_table_ref[key]\n # Item not found\n return None","def findItem(obj, key):\n if key in obj:\n return obj[key]\n if type(obj) == str:\n return None\n for k, v in obj.items():\n if isinstance(v, dict):\n item = findItem(v, key)\n if item is not None:\n return item\n elif isinstance(v, list):\n for list_item in v:\n item = findItem(list_item, key)\n if item is not None:\n return item","def find_one_bykey(cls, keydict, defaultval = None):\n return cls.dbm().modelclass_find_one_bykey(cls, keydict, defaultval)","def lod_find(list_of_dict, key, val, return_val_if_false = False):\n for d in list_of_dict:\n if isinstance(d, dict) and d[key] == val: return d\n return return_val_if_false","def get(self, match_id):\n try:\n match_key = ndb.Key(urlsafe=match_id)\n match = match_key.get()\n json_result = {'id': match_id,\n 'guest': match.guest.id(),\n 'guestPoints': match.guest_points,\n 'host': match.host.id(),\n 'hostPoints': match.host_points,\n 'timestamp': match.timestamp.isoformat()}\n self.write_signed_message(200, 'match', json_result)\n except (AttributeError, BadRequestError, ProtocolBufferDecodeError):\n self.write_signed_error(400, 'Invalid match id')","def depth_first_search(self, target: Dict) -> Optional[Node]:\n\n def search(current_node: Node):\n flag = True\n for k, v in target.items():\n flag = flag and getattr(current_node, k) == v\n if not flag:\n break\n if flag:\n return current_node\n for child in current_node.children:\n ret = search(child)\n if ret:\n return ret\n return search(self.root_node)","def dict_match(left, right, res=None):\n if res is None:\n res = [True, ]\n if res[0] == False:\n return False\n for k in right.keys():\n if (k in left):\n if (isinstance(left[k], dict) and isinstance(right[k], dict)):\n dict_match(left[k], right[k], res=res)\n else:\n res[0] = res[0] and left[k] == right[k]\n if res[0] == False:\n break\n return res[0]","def resolve(self, key: str) -> Optional[Any]:\n return self.dict.get(key)","def _find_closest_key(dictionary, target_key):\n out_key = None\n for key, value in dictionary.items():\n if target_key in key:\n out_key = key\n else:\n for key1, value1 in value.items():\n if target_key in key1:\n out_key = key1\n if out_key is None:\n raise Exception('Could not find a key in the dict which resembles \"{}\" which is needed for plotting'.format(target_key))\n\n return out_key","def find_value_for_nested_key(mapping, key_of_interest, tree=[]):\n original_mapping = mapping\n logger.debug(\"Looking for key %s\", key_of_interest)\n logging.debug(\"Looking in %s\", mapping)\n logger.debug(\"Using tree %s\", tree)\n if tree:\n for leaf in tree:\n mapping = mapping[leaf]\n else:\n tree = [None]\n for leaf in reversed(tree):\n logging.debug(\"Looking in bottommost leaf %s\", leaf)\n for key, value in six.iteritems(mapping):\n if key == key_of_interest:\n return value\n if leaf:\n find_value_in_nested_key(original_mapping, key_of_interest, tree[:-1])\n warnings.warn(\"Couldn't find value for key %s\" % key_of_interest)\n # raise KeyError(\"Couldn't find value for key %s\", key_of_interest)","def dict_item(dictionary, key):\n try:\n return dictionary.get(key, None)\n except AttributeError:\n # fail silently if something other than a dict is passed\n return None","def match_source_key(self, match):\n raise NotImplementedError","def search(self, key):\n \"\"\"\n\n if key in song_dict:\n # for obj in song_dict[dict_key]:\n # print(obj.song_name)\n return True\n else:\n # print(\"No such key exists in dictionary\")\n return False\n \"\"\"\n #dict.get(\"Katt\", None)\n return self.dictionary.get(key)","def validate_match(context):\n\n schema = isinstance(match_schema, ValidateViewHook) and match_schema(request) or match_schema\n\n state = Dummyobj()\n state.request = request\n state.context = context\n try:\n return schema.to_python(request.matchdict, state=state)\n except formencode.Invalid as exc:\n unpacked = exc.unpack_errors()\n request.set_property(lambda ctx: unpacked,\n invalid_match_attr, reify=True)\n if raise_exc is True:\n _raise(invalid_match_exc, unpacked)\n else:\n return {}","def lookup(self, key):\n n = self.find(key)\n if n:\n return n.value\n else:\n return False","def find(self, key):\n visitor = VisitorFind()\n\n self.visit(key, visitor)\n\n return visitor.result","async def call_find(\n self, peer: PeerID, keys: Collection[DHTID]\n ) -> Optional[\n Dict[\n DHTID, Tuple[Optional[ValueWithExpiration[Union[BinaryDHTValue, DictionaryDHTValue]]], Dict[DHTID, PeerID]]\n ]\n ]:\n keys = list(keys)\n find_request = dht_pb2.FindRequest(keys=list(map(DHTID.to_bytes, keys)), peer=self.node_info)\n try:\n async with self.rpc_semaphore:\n response = await self.get_stub(peer).rpc_find(find_request, timeout=self.wait_timeout)\n if response.peer and response.peer.node_id:\n peer_id = DHTID.from_bytes(response.peer.node_id)\n asyncio.create_task(self.update_routing_table(peer_id, peer, responded=True))\n assert len(keys) == len(response.results), \"DHTProtocol: response is not aligned with keys\"\n\n output = {} # unpack data depending on its type\n for key, result in zip(keys, response.results):\n key_bytes = DHTID.to_bytes(key)\n nearest = dict(\n zip(\n map(DHTID.from_bytes, result.nearest_node_ids),\n map(PeerID, result.nearest_peer_ids),\n )\n )\n\n if result.type == dht_pb2.NOT_FOUND:\n output[key] = None, nearest\n elif result.type == dht_pb2.FOUND_REGULAR:\n if not self._validate_record(\n key_bytes, self.IS_REGULAR_VALUE, result.value, result.expiration_time\n ):\n output[key] = None, nearest\n continue\n\n output[key] = ValueWithExpiration(result.value, result.expiration_time), nearest\n elif result.type == dht_pb2.FOUND_DICTIONARY:\n value_dictionary = self.serializer.loads(result.value)\n if not self._validate_dictionary(key_bytes, value_dictionary):\n output[key] = None, nearest\n continue\n\n output[key] = ValueWithExpiration(value_dictionary, result.expiration_time), nearest\n else:\n logger.error(f\"Unknown result type: {result.type}\")\n\n return output\n except Exception as e:\n logger.debug(f\"DHTProtocol failed to find at {peer}\", exc_info=True)\n asyncio.create_task(self.update_routing_table(self.routing_table.get(peer_id=peer), peer, responded=False))","def find_first_regex_match(key, regex_candidates):\n for cand in regex_candidates:\n try:\n pattern = re.compile(BaseInterface.cap_match_string(cand))\n if pattern.match(key):\n return cand\n except:\n logging.warn('[ros_interface] Ignoring invalid regex string \"{0!s}\"!'.format(cand))\n\n return None","def row_by_value(idl_, table, column, match, default=_NO_DEFAULT):\n tab = idl_.tables[table]\n for r in tab.rows.values():\n if getattr(r, column) == match:\n return r\n if default is not _NO_DEFAULT:\n return default\n raise None","def match(self, route):\n regexp = re.sub(r\"\\{([a-zA-Z][^\\}]*)\\}\", r\"(?P<\\1>([^}]+))\", route)\n r = re.match(regexp, self.path)\n if r is not None:\n self.matchdict = r.groupdict()","def search(self, string, match):\n\n if len(string) > 0:\n key = string[0]\n\n if key < self.ch:\n if self.left == 0:\n print \"No Match Found\"\n return\n self.left.search(string, match)\n\n elif key > self.ch:\n if self.right == 0:\n print(\"Not Match Found\")\n return\n self.right.search(string, match)\n\n else:\n if len(string) == 1:\n if self.flag == 1:\n print(\"Match \", match + self.ch)\n if self.center != 0:\n self.center.spdfs(match + self.ch + self.center.ch)\n return 1\n self.center.search(string[1:], match + key)\n\n else:\n print(\"Invalid String\")\n return","def find(self, key):\n curr_node = self.head\n\n while curr_node is not None: # a normal traversal and checking first match\n if curr_node.data == key:\n return curr_node\n curr_node = curr_node.next\n\n return None","def getMatchGroupDic(inputText, groupDict):\n\tfor key in groupDict.keys():\n\t\tif str(ord(inputText)) == str(key.unicode):\n\t\t\treturn groupDict\n\n\treturn None","def _find_equivalent(searched_dict, dicts_list):\n for id_key in ('id', 'uid', 'name'):\n # Recognize the ID key used, if any\n local_id = searched_dict.get(id_key)\n if local_id:\n # Found an ID\n for other_item in dicts_list:\n if other_item.get(id_key) == local_id:\n # Found an item with the same ID\n return other_item\n \n # Found nothings\n return None","def extract(dictionary: Any, key: Any) -> Union[Any, None]:\n if dictionary is None or not isinstance(dictionary, dict):\n return None\n return dictionary.get(key)","def find_demand_id(demand_dict, vn_id, fvr_id, svr, nbr):\n #print vn_id, fvr_id, svr, nbr\n for demand_id in demand_dict:\n if vn_id == demand_dict[demand_id]['vn_id'] and \\\n fvr_id == demand_dict[demand_id]['fnode_id'] and \\\n svr == demand_dict[demand_id]['svr'] and \\\n nbr == demand_dict[demand_id]['nbr_id']:\n return demand_id","def dict_find(in_dict, value):\n # Todo: make this robust to repeated values\n # Todo: make this robust to missing values\n return in_dict.keys()[in_dict.values().index(value)]","def get_latest_match(self, steam_id):\n try:\n req = self.steam_api.get_match_history(account_id=steam_id, matches_requested=1)\n result = req['result']\n except:\n return None\n\n if result['status'] == 15:\n return {}\n\n elif result['num_results'] == 0:\n return {}\n\n return result['matches'][0]","def fetch_next_match() -> Optional[MatchDict]:\n future_matches = Match.objects.filter(start_date_time__gt=timezone.now())\n\n if not any(future_matches):\n return None\n\n next_match = min(future_matches, key=lambda match: match.start_date_time)\n\n return {\n \"round_number\": next_match.round_number,\n \"season\": next_match.start_date_time.year,\n }","def get_from_dict(d, k):\n try:\n return reduce(dict.get, k, d)\n except TypeError:\n # Value not found.\n return None","def find_exact(self, **kwargs):\n results = list(self.find(**kwargs))\n if len(results) == 1:\n return results[0]\n return None","def find_match(aunts: list, mfcsam: dict, fn_dict: dict={}) -> int:\n for idx, aunt in enumerate(aunts):\n match = True\n for name, val in mfcsam.items():\n # Ignore missing properties, and make sure that the ones that do exist\n # have matching values\n if name in aunt and not (fn_dict.get(name, lambda a, b : a == b))(val, aunt[name]):\n match = False\n break\n if match:\n return idx + 1\n return None","def lookup(match):\n word = match.group(0)\n return symtab[unbase(word)] or word","def case_insensitive_lookup_1(dictionary: dict, term: str) -> Optional[str]:\n key = term.lower()\n try:\n return dictionary[key.lower()]\n except KeyError:\n return None","def find(self, target):\n try:\n if type(target) is int:\n for key, value in self.index.table.items():\n if value == target:\n return(key)\n elif type(target) is str:\n for key, value in self.index.table.items():\n if key == target:\n return(value)\n except Exception as error:\n print(f\"Error: self.find({target}) -> {error}\")","def get_match_details(self, match_id=None, **kwargs):\n if 'match_id' not in kwargs:\n kwargs['match_id'] = match_id\n url = self.__build_url(urls.GET_MATCH_DETAILS, **kwargs)\n req = self.executor(url)\n if self.logger:\n self.logger.info('URL: {0}'.format(url))\n if not self.__check_http_err(req.status_code):\n return response.build(req, url, self.raw_mode)","def _search(self, lookfor: typing.Any, stop_on_first: bool = False):\r\n\r\n # if the item is in the dictionary then just return it\r\n if self._dict_contains(lookfor):\r\n return True, lookfor, self._dict_getitem(lookfor), 1\r\n\r\n # set up the fuzzy matching tool\r\n ratio_calc = difflib.SequenceMatcher()\r\n ratio_calc.set_seq1(lookfor)\r\n\r\n # test each key in the dictionary\r\n best_ratio = 0\r\n best_match = None\r\n best_key = None\r\n for key in self:\r\n # if the current key is not a string\r\n # then we just skip it\r\n try:\r\n # set up the SequenceMatcher with other text\r\n ratio_calc.set_seq2(key)\r\n except TypeError:\r\n continue\r\n\r\n # we get an error here if the item to look for is not a\r\n # string - if it cannot be fuzzy matched and we are here\r\n # this it is definitely not in the dictionary\r\n try:\r\n # calculate the match value\r\n ratio = ratio_calc.ratio()\r\n except TypeError:\r\n break\r\n\r\n # if this is the best ratio so far - save it and the value\r\n if ratio > best_ratio:\r\n best_ratio = ratio\r\n best_key = key\r\n best_match = self._dict_getitem(key)\r\n\r\n if stop_on_first and ratio >= self.cutoff:\r\n break\r\n\r\n return best_ratio >= self.cutoff, best_key, best_match, best_ratio","def checkDict(words, given_dict):\n\tcount = 0\n\tfor word in words:\n\t\tif word in given_dict:\n\t\t\tgiven_dict = given_dict[word]\n\t\telse:\n\t\t\treturn None\n\n\tif '$value' in given_dict:\n\t\treturn given_dict['$value'][0]\n\n\treturn given_dict","def match(dictionary, query, policy='relaxed', matches=None):\n if query is None:\n return True\n assert policy in ['relaxed', 'strict'], \"\"\n\n for field, value in query.iteritems():\n if field not in dictionary:\n if policy == 'relaxed':\n continue\n else:\n return False\n if isinstance(value, list) or not isinstance(value, basestring):\n values = value if isinstance(value, list) else [value]\n if dictionary[field] not in values:\n return False\n if matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n else:\n if value == '':\n # Take special care if value is an empty string\n if value != dictionary[field]:\n return False\n elif matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n continue\n else:\n match = re.compile(value).match(dictionary[field])\n if not match:\n return False\n else:\n if matches is not None:\n matches['%s_0' % (field)] = dictionary[field]\n for index, group in enumerate(match.groups()):\n matches['%s_%d' % (field, index+1)] = group\n continue\n return True","def matches(self, request: ServeRequest) -> Optional[Match]:\n for tag_key, tag_value in self.tags.items():\n request_value = None\n if tag_key == TAG_SERVE_MATCH_PATH:\n request_value = request.url\n elif tag_key == TAG_SERVE_MATCH_PATH_RELATIVE:\n request_value = request.url[1:]\n elif tag_key == TAG_SERVE_MATCH_HOST:\n request_value = request.headers.get('Host', '')\n elif tag_key.startswith(TAG_SERVE_MATCH_META):\n meta_key = tag_key.replace(TAG_SERVE_MATCH_META, '')\n request_value = request.headers.get(meta_key, '')\n LOGGER.debug(\"Checking '%s' against '%s'\", request_value, tag_value)\n regex = re.compile(tag_value)\n match = regex.match(request_value)\n if match is None:\n LOGGER.debug(\" => Not matching\")\n return None\n LOGGER.debug(\" => Matching, checking next tag\")\n return match","def matches_dict(self, answer_dict):\n\n return self.matches(Answer(\n answer_dict['group_id'],\n answer_dict['block_id'],\n answer_dict['answer_id'],\n \"\",\n answer_dict['group_instance'],\n answer_dict['answer_instance'],\n ))","def match(self, _str: str):\n result = self._regex.match(_str)\n if result:\n return result.groupdict() or True","def find(self, value, key=\"name\", shallow=True):\n if key.lower() not in (\"name\", \"id\", \"path\"):\n raise ValueError()\n\n if not self.contents:\n self.get_contents()\n\n for content, level in self._iter_contents():\n if shallow and level != 0:\n continue\n if getattr(content, key, None) == value:\n return content\n\n self.project.app.logger.debug(\n \"{}: {} not found in '{}'\".format(key, value, self.name)\n )","def find(self, **opts):\n negate = opts.get('negate', False)\n match_any = opts.get('match_any', negate)\n match_all = opts.get('match_all', not match_any)\n case_matters = opts.get('case_matters', False)\n reverse = opts.get('reverse', False)\n mapper = opts.get('map', lambda t: t)\n\n if callable(mapper):\n do_map = mapper\n elif is_string(mapper):\n\n def do_map(value):\n return getattr(value, mapper, None)\n elif isinstance(mapper, (list, tuple, set)):\n\n def do_map(value):\n return type(mapper)(getattr(value, t, None) for t in mapper)\n elif isinstance(mapper, dict):\n\n def do_map(value):\n return type(mapper)(\n (t, getattr(value, t, None)) for t in mapper)\n else:\n raise TypeError(\"Invalid mapping rule: %r\" % mapper)\n\n def gsense(f):\n\n def w(value, exp):\n if negate: return not f(value, exp)\n else: return f(value, exp)\n\n return w\n\n def tsense(f):\n\n def w(candidate, test_name, test_value):\n if test_name.startswith('not_'):\n return not f(candidate, test_name[4:], test_value)\n else:\n return f(candidate, test_name, test_value)\n\n return w\n\n @gsense\n def do_match(value, exp):\n if is_string(exp):\n if case_matters:\n return value == exp\n else:\n return value.lower() == exp.lower()\n elif hasattr(exp, 'search') and callable(exp.search):\n return exp.search(value)\n elif callable(exp):\n return bool(exp(value))\n elif exp in (None, True):\n return True # the attribute exists\n elif exp is False:\n return False # no such attribute\n\n # If we get here, the only other allowable option is\n # for exp to be a collection of things to try. If that\n # fails, the TypeError is propagated back to the caller.\n for e in iter(exp):\n if do_match(value, e):\n return True\n else:\n return False\n\n all_tests = []\n # Order matters here...\n\n for key in ('type', 'name', 'hasattr', 'hasattrs', 'attr', 'source',\n 'csource', 'innersource', 'partner', 'parent', 'predicate',\n 'value'):\n for k in (key, 'not_' + key):\n if k in opts: all_tests.append((k, opts[k]))\n\n # Choose candidates to search\n lo_limit = 0 # Search no index before this.\n hi_limit = len(self.wrappers) # Search no index at or after this.\n if 'search_after' in opts:\n lo_limit = opts['search_after'].obj_id + 1\n if 'search_before' in opts:\n hi_limit = opts['search_before'].obj_id\n if 'search_inside' in opts:\n t = opts['search_inside']\n p = t.partner\n if p is None:\n lo_limit = hi_limit = t.obj_id\n else:\n lo, hi = sorted((t.obj_id, p.obj_id))\n lo_limit = max(lo_limit, lo)\n hi_limit = min(hi_limit, hi)\n\n candidates = list(self.wrappers[i] for i in range(lo_limit, hi_limit))\n if reverse:\n candidates.reverse()\n\n @tsense\n def t_property(candidate, test_name, test_value):\n return (hasattr(candidate, test_name)\n and do_match(getattr(candidate, test_name), test_value))\n\n @tsense\n def t_associate(candidate, test_name, test_value):\n return (hasattr(candidate, test_name)\n and test_value(getattr(candidate, test_name))\n if callable(test_value) else\n getattr(candidate, test_name) is test_value)\n\n @tsense\n def t_has_attr(candidate, test_name, test_value):\n if test_name == 'hasattr':\n test_value = [test_value]\n\n if not hasattr(candidate, 'keys'):\n return False\n\n for tv in test_value:\n for key in candidate.keys():\n if do_match(key, tv):\n break\n else:\n return False\n else:\n return True\n\n @tsense\n def t_attr_match(candidate, test_name, test_value):\n if not hasattr(candidate, 'getattr'):\n return False\n elif isinstance(test_value, tuple):\n tv = [test_value]\n elif isinstance(test_value, dict):\n tv = test_value.items()\n else:\n raise TypeError(\"invalid key for attribute match: %s\" %\n test_value)\n\n for a_name, a_exp in tv:\n try:\n if not do_match(candidate[a_name].value, a_exp):\n return False\n except KeyError:\n if a_exp is not False:\n return False\n else:\n return True\n\n @tsense\n def t_predicate(candidate, test_name, test_value):\n return test_value(candidate)\n\n def t_fail(candidate, test_name, test_value):\n return False\n\n test_map = dict(\n type=t_property,\n not_type=t_property,\n name=t_property,\n not_name=t_property,\n hasattr=t_has_attr,\n not_hasattr=t_has_attr,\n hasattrs=t_has_attr,\n not_hasattrs=t_has_attr,\n attr=t_attr_match,\n not_attr=t_attr_match,\n source=t_property,\n not_source=t_property,\n csource=t_property,\n not_csource=t_property,\n innersource=t_property,\n not_innersource=t_property,\n value=t_property,\n not_value=t_property,\n parent=t_associate,\n not_parent=t_associate,\n partner=t_associate,\n not_partner=t_associate,\n predicate=t_predicate,\n not_predicate=t_predicate,\n )\n for candidate in candidates:\n ok = match_all\n\n for test_name, test_value in all_tests:\n tfunc = test_map.get(test_name, t_fail)\n ok = tfunc(candidate, test_name, test_value)\n\n if not match_all and ok: break\n if match_all and not ok: break\n\n if ok:\n yield do_map(candidate)","def fromMatchId(cls, matchId):\n matchDict = CachedDB().getMatchById(matchId)\n if matchDict is None:\n return None\n return cls(matchDict)","def match_by_id(self, match_id):\n\n url = API_PATH[\"match_by_id\"].format(\n region_url=self.region_url, match_id=match_id)\n\n response = requests.get(url, headers=self.headers)\n\n return response.json()","def get_if_exist(self, data, key):\n if key in data:\n return data[key]\n return None","def _lookup_model(self, name, experiment_dict):\n if experiment_dict.get(name) is None:\n return None\n return self._lookups[name][experiment_dict[name]]","def _key_list_search(self, keys_list, lookup_dict):\n for index, key in enumerate(keys_list):\n result = nested_lookup(key, lookup_dict)\n try:\n value = nested_lookup(keys_list[index + 1], result)\n except IndexError:\n pass\n return value","def _find(self, hashV):\n return self.table.search(hashV)","def query_dict(dictionary: Mapping[Any, Any], keys: Sequence[Any]) -> Union[Any, None]:\n\n def extract(dictionary: Any, key: Any) -> Union[Any, None]:\n \"\"\"Get value associated with key, defaulting to None.\"\"\"\n if dictionary is None or not isinstance(dictionary, dict):\n return None\n return dictionary.get(key)\n\n return reduce(extract, keys, dictionary)","def _dict_lookup(typingctx, d, key, hashval):\n resty = types.Tuple([types.intp, types.Optional(d.value_type)])\n sig = resty(d, key, hashval)\n\n def codegen(context, builder, sig, args):\n fnty = ir.FunctionType(\n ll_ssize_t,\n [ll_dict_type, ll_bytes, ll_hash, ll_bytes],\n )\n [td, tkey, thashval] = sig.args\n [d, key, hashval] = args\n fn = cgutils.get_or_insert_function(builder.module, fnty,\n 'numba_dict_lookup')\n\n dm_key = context.data_model_manager[tkey]\n dm_val = context.data_model_manager[td.value_type]\n\n data_key = dm_key.as_data(builder, key)\n ptr_key = cgutils.alloca_once_value(builder, data_key)\n cgutils.memset_padding(builder, ptr_key)\n\n ll_val = context.get_data_type(td.value_type)\n ptr_val = cgutils.alloca_once(builder, ll_val)\n\n dp = _container_get_data(context, builder, td, d)\n ix = builder.call(\n fn,\n [\n dp,\n _as_bytes(builder, ptr_key),\n hashval,\n _as_bytes(builder, ptr_val),\n ],\n )\n # Load value if output is available\n found = builder.icmp_signed('>', ix, ix.type(int(DKIX.EMPTY)))\n\n out = context.make_optional_none(builder, td.value_type)\n pout = cgutils.alloca_once_value(builder, out)\n\n with builder.if_then(found):\n val = dm_val.load_from_data_pointer(builder, ptr_val)\n context.nrt.incref(builder, td.value_type, val)\n loaded = context.make_optional_value(builder, td.value_type, val)\n builder.store(loaded, pout)\n\n out = builder.load(pout)\n return context.make_tuple(builder, resty, [ix, out])\n\n return sig, codegen","def get_match_settings(\n key=None,\n ) -> MatchSettingsResponseBody:\n if config := AdditionalMatchSettingsConfig.get(str(key)):\n return MatchSettingsResponseBody(config)\n return bottle.abort(400, f\"No match_settings for pg_id {key} found\")","def get_matching_item(self, mapping: MutableMapping[str, Any],\n ns_prefix: str = 'xmlns',\n match_local_name: bool = False) -> Optional[Any]:\n if self.name is None:\n return None\n elif not self.target_namespace:\n return mapping.get(self.name)\n elif self.qualified_name in mapping:\n return mapping[cast(str, self.qualified_name)]\n elif self.prefixed_name in mapping:\n return mapping[cast(str, self.prefixed_name)]\n\n # Try a match with other prefixes\n target_namespace = self.target_namespace\n suffix = f':{self.local_name}'\n\n for k in filter(lambda x: x.endswith(suffix), mapping):\n prefix = k.split(':')[0]\n if self.namespaces.get(prefix) == target_namespace:\n return mapping[k]\n\n # Match namespace declaration within value\n ns_declaration = '{}:{}'.format(ns_prefix, prefix)\n try:\n if mapping[k][ns_declaration] == target_namespace:\n return mapping[k]\n except (KeyError, TypeError):\n pass\n else:\n if match_local_name:\n return mapping.get(self.local_name) # type: ignore[arg-type]\n return None","def find(self, seq):\n \n if not isinstance(seq, str):\n seqstr = ''\n # Concatenate list\n for s in seq:\n seqstr += self.prepseq(s.upper())\n else:\n seqstr = self.prepseq(seq.upper())\n \n searchstr = self.digest(seqstr)\n\n if searchstr in self.seqs:\n hits = self.seqs[searchstr]\n\n if seqstr in hits:\n return hits[seqstr]\n else:\n return None\n \n else:\n return None","def _match(self, filename: str) -> Optional[dict]:\n if not self.named_regexp:\n self.log.warning(\n \"Regular expression not provided for plugin. Run with \"\n \"`--help-all` flag for more information.\"\n )\n return None\n\n match = re.match(self.named_regexp, filename)\n if not match or not match.groups():\n self.log.warning(\n \"Regular expression '{}' did not match anything in: {}\"\n \"\".format(self.named_regexp, filename)\n )\n return None\n\n gd = match.groupdict()\n self.log.debug(\n \"Regular expression '{}' matched\\n'{}' in: {}\"\n \"\".format(self.named_regexp, gd, filename)\n )\n return gd","def find_match(people, STRs):\n for person in people:\n if compare_str(person, STRs):\n return person[\"name\"]\n return \"No match\"","def find(lst, key, value):\n\n for i, dic in enumerate(lst):\n if dic[key] == value:\n return i\n return None","def get_option(option_dict, option):\n if isinstance(option_dict, dict) and option in option_dict:\n return option_dict[option]\n elif not isinstance(option_dict, dict):\n return None\n else:\n for value in option_dict.values():\n result = SchedulePolicy.get_option(value, option)\n if result is not None:\n return result","def find_key(dic, val): \n return [k for k, v in dic.iteritems() if re.search(v, val)]","def search(self, key):\n if key in self.key_list:\n return (self.nodes)[key]\n return None","def find(key, condition):\n for i, line in enumerate(lines):\n if condition(line, key):\n return i\n return None","def get_from_dictionary(self,dictionary,key):\r\n try:\r\n return dictionary[key]\r\n except KeyError:\r\n raise RuntimeError(\"Dictionary does not contain key '%s'\" %key)","def find_by_exact_match(self):\n while True: \n self.task_name_search = input(\"What is the keyword/s you are looking\"\n \" for? Press Q to quit to the main screen: \").strip()\n if self.task_name_search.upper() in [\"Q\", \"QUIT\", \"EXIT\"]:\n x = self.dict_list\n return x\n self.find_by_exact_match_list = []\n count = 0\n for i in self.dict_list:\n for key, value in i.items():\n if re.search(self.task_name_search, value):\n self.find_by_exact_match_list.append(i)\n count+=1\n break\n if count == 0:\n print(\"There were no matches.\")\n else:\n self.display_style(self.find_by_exact_match_list)\n break\n self.del_or_edit()","def match_phrase(self, phrase):\n key = None\n match_phrase = None\n for key in self.get_key_list(phrase):\n if key in self.cls_phrases:\n match_phrase = key\n break\n \n if match_phrase == None:\n return None, key\n return self.get_most_common(self.cls_phrases[match_phrase]), key","def lookup(dic, key, *keys):\n if keys:\n return lookup(dic.get(key, {}), *keys)\n return dic.get(key)","def get(self, key, def_value=None):\n\n index = self._get_hash(key)\n\n if self.table[index] is not None:\n for pair in self.table[index]:\n if key == pair[0]:\n return pair[1]\n\n if def_value is not None:\n return def_value\n\n raise ValueError(f\"can't find value with given key {key}\")","def func(match, *args, **kwargs):\n\n data = match.group(0)\n return (resources[data], True) if data in resources else (data, False)","def search_key(cls, key, element):\n if isinstance(element, dict):\n for k, v in element.items():\n if k == key:\n return v\n elif isinstance(v, dict):\n cls.search_key(key, v)\n elif isinstance(v, list):\n cls.search_key(key, v)\n elif isinstance(element, list):\n for obj in element:\n v = cls.search_key(key, obj)\n if v:\n return v","def lookup(dic, key, *keys):\r\n if keys:\r\n return lookup(dic.get(key, {}), *keys)\r\n return dic.get(key)","def search_hash(word_input,hashtable):\n\n if word_input in hashtable:\n return hashtable[word_input]\n else:\n return None","def find(self, key):\n if self.head is None:\n return\n itr = self.head\n while itr:\n if itr.data == key:\n return itr.data\n itr = itr.next\n return None","def _match(self, document: dict, query: dict) -> bool:\n\n matches = [\n self._match(document.get(key), value)\n if isinstance(value, dict) and isinstance(document.get(key), dict)\n else document.get(key) == value\n for key, value in query.items()\n ]\n return all(matches)"],"string":"[\n \"def _find_match(needle: dict, haystack: list, keys: list):\\n for item in haystack:\\n for key in keys:\\n if item.get(key) != needle[key]:\\n break\\n else:\\n return item\\n return None\",\n \"def dict_match(d, key, default=None):\\n\\n if key in d and \\\"[\\\" not in key:\\n return d[key]\\n else:\\n for pattern, value in iteritems(d):\\n if fnmatchcase(key, pattern):\\n return value\\n return default\",\n \"def find_match(name, dictionary):\\n if name == '':\\n # raise \\\"Didn't find name\\\"\\n return False\\n search_name = (' ').join(name.split(' ')[:-1])\\n if search_name in dictionary:\\n return search_name\\n else:\\n return find_match(search_name, dictionary)\",\n \"async def get_match_from_id(match_id: int) -> Match or None:\\n if match_id is None:\\n return None\\n\\n if match_id in match_library:\\n return match_library[match_id]\\n\\n raw_data = await matchdb.get_raw_match_data(match_id)\\n if raw_data is not None:\\n return await make_match_from_raw_db_data(raw_data)\\n else:\\n return None\",\n \"def find(self, location, dictionary=None, key_index=1):\\n\\n # dictionary is self object if no dictionary is provided\\n if not dictionary:\\n dictionary = self\\n\\n # take first value field to be found\\n value = normalize_name(location[key_index])\\n\\n # extract matched value from\\n value_matched = process.extractOne(value, dictionary.keys())\\n\\n if value_matched and value_matched[1] > self.THRESHOLD_RATIO:\\n key = value_matched[0]\\n\\n # if there are more values to evaluate, call recursively\\n if len(location) > key_index + 1:\\n # print value_matched[1],\\n return self.find(location, dictionary[key], key_index + 1)\\n\\n else:\\n # print value_matched[1],\\n return dictionary[key]\\n\\n else:\\n return None\",\n \"def search(d, key, default=None):\\n stack = [iter(d.items())]\\n while stack:\\n for k, v in stack[-1]:\\n if isinstance(v, dict):\\n stack.append(iter(v.items()))\\n break\\n elif k == key:\\n return v\\n else:\\n stack.pop()\\n return default\",\n \"def get_match_result(self, variable):\\n try:\\n return self._match_result_dict[variable]\\n except KeyError:\\n return None\",\n \"def find(name, *dicts):\\n for d in dicts:\\n if type(d) == str:\\n return d\\n elif name in d and d[name] is not None:\\n return d[name]\\n\\n return None\",\n \"def find_in_dict(obj, key):\\n if key in obj:\\n return obj[key]\\n for k, v in obj.items():\\n if isinstance(v,dict):\\n item = find_in_dict(v, key)\\n if item is not None:\\n return item\",\n \"def _get_value(match_entry: Dict, path0: str) -> any:\\n if path0 is None:\\n current_el = match_entry\\n else:\\n path = path0.split('/')\\n current_el = match_entry\\n for p in path:\\n if current_el is None:\\n break\\n current_el = current_el.get(p)\\n return current_el\",\n \"def find(self, entry_id: str, match: callable = operator.contains) -> Any:\\n try:\\n return next(self.find_all(entry_id, match))\\n except StopIteration as error:\\n raise errors.NoEntryFound(f'No entries found which match {entry_id}') from error\",\n \"def find_value(dic, key):\\n return dic[key]\",\n \"def search_value(d, key, default=None):\\n stack = [iter(d.items())]\\n while stack:\\n for k, v in stack[-1]:\\n if isinstance(v, dict):\\n stack.append(iter(v.items()))\\n break\\n elif k == key:\\n return v\\n else:\\n stack.pop()\\n return default\",\n \"def get_match_hash_key(hashkey, table):\\n if hashkey in table:\\n # assume that this has at least one flow entry\\n b = convert_ip_to_int(table[hashkey][0].nw_src)\\n a = convert_ip_to_int(table[hashkey][0].nw_dst)\\n match_hash = (a * a + a + b) if a >= b else (a + b * b)\\n if match_hash in table:\\n return match_hash\\n else:\\n return None\\n else:\\n return None\",\n \"def dict_find_name(some_dict: Dict[str, Referent], path: List[str]) -> Result:\\n if path:\\n head, *tail = path\\n try:\\n return NameContainer.dict_find_name(\\n cast(Dict[str, Referent], some_dict[head]),\\n tail)\\n except KeyError:\\n NameContainer.logger.debug(f\\\"{head!r} not found in {some_dict.keys()}\\\")\\n raise NameContainer.NotFound(path)\\n else:\\n return cast(Result, some_dict)\",\n \"def _parse_line(line):\\n\\n for key, rx in rx_dict.items():\\n match = rx.search(line)\\n if match:\\n return key, match\\n # if there are no matches\\n return None, None\",\n \"def _parse_line(line):\\n\\n for key, rx in rx_dict.items():\\n match = rx.search(line)\\n if match:\\n return key, match\\n # if there are no matches\\n return None, None\",\n \"def _search_list_of_dictionaries(key, value, list_of_dictionaries):\\n\\n for element in list_of_dictionaries:\\n if element.get(key) == value:\\n return element\\n return None\",\n \"def findMatcher(self, ch):\\n for m in self.matchers:\\n if m.match(ch):\\n return m\\n return None\",\n \"def match(id=0):\\n match = Match.query.get(id)\\n if match is not None:\\n return render_template('match.html', match=Match.query.get(id))\\n abort(404)\",\n \"def _find_by_key(self, key, find):\\n index = hashId(key, self.capacity) # Get the index/ bucket based on hash code of the key\\n \\n hash_table_cell = self._entry[index]\\n found_item = None\\n for item in hash_table_cell: #Iterrate the entry array and check the key is matching and if key is same than get the value\\n if item[0] == key:\\n found_item = item\\n break\\n\\n return find(found_item, hash_table_cell)\",\n \"def lookup(my_dict, my_key, default_value=None):\\n if my_key in my_dict:\\n return my_dict[my_key]\\n else:\\n return default_value\",\n \"def find(self, answer):\\n self._validate(answer)\\n\\n for index, existing in enumerate(self.answers):\\n if answer.matches_dict(existing):\\n return index\\n\\n return None\",\n \"def parse_line(keyword_dict, line):\\n for key, rx in keyword_dict.items():\\n match = rx.search(line)\\n if match:\\n return key, match\\n\\n return None, None\",\n \"def get_match_by_id(self, match_id):\\n request = rq.get(\\n 'https://{region}.api.pvp.net/api/lol/{region}/v{version}/match/{id}?api_key={api_key}'.format(\\n region=self.region,\\n version=api_version['match'],\\n id=match_id,\\n api_key=API_KEY\\n )\\n )\\n print(self.region, request)\\n check_response(request)\\n return request.json()\",\n \"def findKey(value,dict):\\n for key, val in dict.iteritems():\\n if value in val:\\n return key\",\n \"def dict_search_recursive(d, k):\\n # FIXME: make it generic recursive search over nested graphs and move to smp_base\\n\\n # print \\\"#\\\" * 80\\n # print \\\"searching k = %s \\\" % (k,),\\n if k in d:\\n # print \\\"found k = %s, params = %s\\\" % (k, d[k]['params'].keys())\\n return d[k]\\n else:\\n # print \\\"d.keys()\\\", d.keys()\\n for k_, v_ in list(d.items()):\\n # if v_[\\n if 'graph' in v_['params']: # or v_['params'].has_key('subgraph'):\\n # print \\\"k_\\\", k_, \\\"v_\\\", v_['params'].keys()\\n return dict_search_recursive(v_['params']['graph'], k)\\n # None found\\n return None\",\n \"def find_item(hash_table_ref, key_sig):\\n if not hasattr(key_sig, '__iter___'):\\n key_sig = [key_sig]\\n\\n last_item = key_sig[len(key_sig) - 1]\\n for key in key_sig:\\n if key != last_item:\\n if hasattr(hash_table_ref, 'keys') and key in hash_table_ref:\\n hash_table_ref = hash_table_ref[key]\\n else:\\n # Item not found\\n return None\\n else:\\n if hasattr(hash_table_ref, 'keys') and \\\\\\n key in hash_table_ref:\\n return hash_table_ref[key]\\n # Item not found\\n return None\",\n \"def findItem(obj, key):\\n if key in obj:\\n return obj[key]\\n if type(obj) == str:\\n return None\\n for k, v in obj.items():\\n if isinstance(v, dict):\\n item = findItem(v, key)\\n if item is not None:\\n return item\\n elif isinstance(v, list):\\n for list_item in v:\\n item = findItem(list_item, key)\\n if item is not None:\\n return item\",\n \"def find_one_bykey(cls, keydict, defaultval = None):\\n return cls.dbm().modelclass_find_one_bykey(cls, keydict, defaultval)\",\n \"def lod_find(list_of_dict, key, val, return_val_if_false = False):\\n for d in list_of_dict:\\n if isinstance(d, dict) and d[key] == val: return d\\n return return_val_if_false\",\n \"def get(self, match_id):\\n try:\\n match_key = ndb.Key(urlsafe=match_id)\\n match = match_key.get()\\n json_result = {'id': match_id,\\n 'guest': match.guest.id(),\\n 'guestPoints': match.guest_points,\\n 'host': match.host.id(),\\n 'hostPoints': match.host_points,\\n 'timestamp': match.timestamp.isoformat()}\\n self.write_signed_message(200, 'match', json_result)\\n except (AttributeError, BadRequestError, ProtocolBufferDecodeError):\\n self.write_signed_error(400, 'Invalid match id')\",\n \"def depth_first_search(self, target: Dict) -> Optional[Node]:\\n\\n def search(current_node: Node):\\n flag = True\\n for k, v in target.items():\\n flag = flag and getattr(current_node, k) == v\\n if not flag:\\n break\\n if flag:\\n return current_node\\n for child in current_node.children:\\n ret = search(child)\\n if ret:\\n return ret\\n return search(self.root_node)\",\n \"def dict_match(left, right, res=None):\\n if res is None:\\n res = [True, ]\\n if res[0] == False:\\n return False\\n for k in right.keys():\\n if (k in left):\\n if (isinstance(left[k], dict) and isinstance(right[k], dict)):\\n dict_match(left[k], right[k], res=res)\\n else:\\n res[0] = res[0] and left[k] == right[k]\\n if res[0] == False:\\n break\\n return res[0]\",\n \"def resolve(self, key: str) -> Optional[Any]:\\n return self.dict.get(key)\",\n \"def _find_closest_key(dictionary, target_key):\\n out_key = None\\n for key, value in dictionary.items():\\n if target_key in key:\\n out_key = key\\n else:\\n for key1, value1 in value.items():\\n if target_key in key1:\\n out_key = key1\\n if out_key is None:\\n raise Exception('Could not find a key in the dict which resembles \\\"{}\\\" which is needed for plotting'.format(target_key))\\n\\n return out_key\",\n \"def find_value_for_nested_key(mapping, key_of_interest, tree=[]):\\n original_mapping = mapping\\n logger.debug(\\\"Looking for key %s\\\", key_of_interest)\\n logging.debug(\\\"Looking in %s\\\", mapping)\\n logger.debug(\\\"Using tree %s\\\", tree)\\n if tree:\\n for leaf in tree:\\n mapping = mapping[leaf]\\n else:\\n tree = [None]\\n for leaf in reversed(tree):\\n logging.debug(\\\"Looking in bottommost leaf %s\\\", leaf)\\n for key, value in six.iteritems(mapping):\\n if key == key_of_interest:\\n return value\\n if leaf:\\n find_value_in_nested_key(original_mapping, key_of_interest, tree[:-1])\\n warnings.warn(\\\"Couldn't find value for key %s\\\" % key_of_interest)\\n # raise KeyError(\\\"Couldn't find value for key %s\\\", key_of_interest)\",\n \"def dict_item(dictionary, key):\\n try:\\n return dictionary.get(key, None)\\n except AttributeError:\\n # fail silently if something other than a dict is passed\\n return None\",\n \"def match_source_key(self, match):\\n raise NotImplementedError\",\n \"def search(self, key):\\n \\\"\\\"\\\"\\n\\n if key in song_dict:\\n # for obj in song_dict[dict_key]:\\n # print(obj.song_name)\\n return True\\n else:\\n # print(\\\"No such key exists in dictionary\\\")\\n return False\\n \\\"\\\"\\\"\\n #dict.get(\\\"Katt\\\", None)\\n return self.dictionary.get(key)\",\n \"def validate_match(context):\\n\\n schema = isinstance(match_schema, ValidateViewHook) and match_schema(request) or match_schema\\n\\n state = Dummyobj()\\n state.request = request\\n state.context = context\\n try:\\n return schema.to_python(request.matchdict, state=state)\\n except formencode.Invalid as exc:\\n unpacked = exc.unpack_errors()\\n request.set_property(lambda ctx: unpacked,\\n invalid_match_attr, reify=True)\\n if raise_exc is True:\\n _raise(invalid_match_exc, unpacked)\\n else:\\n return {}\",\n \"def lookup(self, key):\\n n = self.find(key)\\n if n:\\n return n.value\\n else:\\n return False\",\n \"def find(self, key):\\n visitor = VisitorFind()\\n\\n self.visit(key, visitor)\\n\\n return visitor.result\",\n \"async def call_find(\\n self, peer: PeerID, keys: Collection[DHTID]\\n ) -> Optional[\\n Dict[\\n DHTID, Tuple[Optional[ValueWithExpiration[Union[BinaryDHTValue, DictionaryDHTValue]]], Dict[DHTID, PeerID]]\\n ]\\n ]:\\n keys = list(keys)\\n find_request = dht_pb2.FindRequest(keys=list(map(DHTID.to_bytes, keys)), peer=self.node_info)\\n try:\\n async with self.rpc_semaphore:\\n response = await self.get_stub(peer).rpc_find(find_request, timeout=self.wait_timeout)\\n if response.peer and response.peer.node_id:\\n peer_id = DHTID.from_bytes(response.peer.node_id)\\n asyncio.create_task(self.update_routing_table(peer_id, peer, responded=True))\\n assert len(keys) == len(response.results), \\\"DHTProtocol: response is not aligned with keys\\\"\\n\\n output = {} # unpack data depending on its type\\n for key, result in zip(keys, response.results):\\n key_bytes = DHTID.to_bytes(key)\\n nearest = dict(\\n zip(\\n map(DHTID.from_bytes, result.nearest_node_ids),\\n map(PeerID, result.nearest_peer_ids),\\n )\\n )\\n\\n if result.type == dht_pb2.NOT_FOUND:\\n output[key] = None, nearest\\n elif result.type == dht_pb2.FOUND_REGULAR:\\n if not self._validate_record(\\n key_bytes, self.IS_REGULAR_VALUE, result.value, result.expiration_time\\n ):\\n output[key] = None, nearest\\n continue\\n\\n output[key] = ValueWithExpiration(result.value, result.expiration_time), nearest\\n elif result.type == dht_pb2.FOUND_DICTIONARY:\\n value_dictionary = self.serializer.loads(result.value)\\n if not self._validate_dictionary(key_bytes, value_dictionary):\\n output[key] = None, nearest\\n continue\\n\\n output[key] = ValueWithExpiration(value_dictionary, result.expiration_time), nearest\\n else:\\n logger.error(f\\\"Unknown result type: {result.type}\\\")\\n\\n return output\\n except Exception as e:\\n logger.debug(f\\\"DHTProtocol failed to find at {peer}\\\", exc_info=True)\\n asyncio.create_task(self.update_routing_table(self.routing_table.get(peer_id=peer), peer, responded=False))\",\n \"def find_first_regex_match(key, regex_candidates):\\n for cand in regex_candidates:\\n try:\\n pattern = re.compile(BaseInterface.cap_match_string(cand))\\n if pattern.match(key):\\n return cand\\n except:\\n logging.warn('[ros_interface] Ignoring invalid regex string \\\"{0!s}\\\"!'.format(cand))\\n\\n return None\",\n \"def row_by_value(idl_, table, column, match, default=_NO_DEFAULT):\\n tab = idl_.tables[table]\\n for r in tab.rows.values():\\n if getattr(r, column) == match:\\n return r\\n if default is not _NO_DEFAULT:\\n return default\\n raise None\",\n \"def match(self, route):\\n regexp = re.sub(r\\\"\\\\{([a-zA-Z][^\\\\}]*)\\\\}\\\", r\\\"(?P<\\\\1>([^}]+))\\\", route)\\n r = re.match(regexp, self.path)\\n if r is not None:\\n self.matchdict = r.groupdict()\",\n \"def search(self, string, match):\\n\\n if len(string) > 0:\\n key = string[0]\\n\\n if key < self.ch:\\n if self.left == 0:\\n print \\\"No Match Found\\\"\\n return\\n self.left.search(string, match)\\n\\n elif key > self.ch:\\n if self.right == 0:\\n print(\\\"Not Match Found\\\")\\n return\\n self.right.search(string, match)\\n\\n else:\\n if len(string) == 1:\\n if self.flag == 1:\\n print(\\\"Match \\\", match + self.ch)\\n if self.center != 0:\\n self.center.spdfs(match + self.ch + self.center.ch)\\n return 1\\n self.center.search(string[1:], match + key)\\n\\n else:\\n print(\\\"Invalid String\\\")\\n return\",\n \"def find(self, key):\\n curr_node = self.head\\n\\n while curr_node is not None: # a normal traversal and checking first match\\n if curr_node.data == key:\\n return curr_node\\n curr_node = curr_node.next\\n\\n return None\",\n \"def getMatchGroupDic(inputText, groupDict):\\n\\tfor key in groupDict.keys():\\n\\t\\tif str(ord(inputText)) == str(key.unicode):\\n\\t\\t\\treturn groupDict\\n\\n\\treturn None\",\n \"def _find_equivalent(searched_dict, dicts_list):\\n for id_key in ('id', 'uid', 'name'):\\n # Recognize the ID key used, if any\\n local_id = searched_dict.get(id_key)\\n if local_id:\\n # Found an ID\\n for other_item in dicts_list:\\n if other_item.get(id_key) == local_id:\\n # Found an item with the same ID\\n return other_item\\n \\n # Found nothings\\n return None\",\n \"def extract(dictionary: Any, key: Any) -> Union[Any, None]:\\n if dictionary is None or not isinstance(dictionary, dict):\\n return None\\n return dictionary.get(key)\",\n \"def find_demand_id(demand_dict, vn_id, fvr_id, svr, nbr):\\n #print vn_id, fvr_id, svr, nbr\\n for demand_id in demand_dict:\\n if vn_id == demand_dict[demand_id]['vn_id'] and \\\\\\n fvr_id == demand_dict[demand_id]['fnode_id'] and \\\\\\n svr == demand_dict[demand_id]['svr'] and \\\\\\n nbr == demand_dict[demand_id]['nbr_id']:\\n return demand_id\",\n \"def dict_find(in_dict, value):\\n # Todo: make this robust to repeated values\\n # Todo: make this robust to missing values\\n return in_dict.keys()[in_dict.values().index(value)]\",\n \"def get_latest_match(self, steam_id):\\n try:\\n req = self.steam_api.get_match_history(account_id=steam_id, matches_requested=1)\\n result = req['result']\\n except:\\n return None\\n\\n if result['status'] == 15:\\n return {}\\n\\n elif result['num_results'] == 0:\\n return {}\\n\\n return result['matches'][0]\",\n \"def fetch_next_match() -> Optional[MatchDict]:\\n future_matches = Match.objects.filter(start_date_time__gt=timezone.now())\\n\\n if not any(future_matches):\\n return None\\n\\n next_match = min(future_matches, key=lambda match: match.start_date_time)\\n\\n return {\\n \\\"round_number\\\": next_match.round_number,\\n \\\"season\\\": next_match.start_date_time.year,\\n }\",\n \"def get_from_dict(d, k):\\n try:\\n return reduce(dict.get, k, d)\\n except TypeError:\\n # Value not found.\\n return None\",\n \"def find_exact(self, **kwargs):\\n results = list(self.find(**kwargs))\\n if len(results) == 1:\\n return results[0]\\n return None\",\n \"def find_match(aunts: list, mfcsam: dict, fn_dict: dict={}) -> int:\\n for idx, aunt in enumerate(aunts):\\n match = True\\n for name, val in mfcsam.items():\\n # Ignore missing properties, and make sure that the ones that do exist\\n # have matching values\\n if name in aunt and not (fn_dict.get(name, lambda a, b : a == b))(val, aunt[name]):\\n match = False\\n break\\n if match:\\n return idx + 1\\n return None\",\n \"def lookup(match):\\n word = match.group(0)\\n return symtab[unbase(word)] or word\",\n \"def case_insensitive_lookup_1(dictionary: dict, term: str) -> Optional[str]:\\n key = term.lower()\\n try:\\n return dictionary[key.lower()]\\n except KeyError:\\n return None\",\n \"def find(self, target):\\n try:\\n if type(target) is int:\\n for key, value in self.index.table.items():\\n if value == target:\\n return(key)\\n elif type(target) is str:\\n for key, value in self.index.table.items():\\n if key == target:\\n return(value)\\n except Exception as error:\\n print(f\\\"Error: self.find({target}) -> {error}\\\")\",\n \"def get_match_details(self, match_id=None, **kwargs):\\n if 'match_id' not in kwargs:\\n kwargs['match_id'] = match_id\\n url = self.__build_url(urls.GET_MATCH_DETAILS, **kwargs)\\n req = self.executor(url)\\n if self.logger:\\n self.logger.info('URL: {0}'.format(url))\\n if not self.__check_http_err(req.status_code):\\n return response.build(req, url, self.raw_mode)\",\n \"def _search(self, lookfor: typing.Any, stop_on_first: bool = False):\\r\\n\\r\\n # if the item is in the dictionary then just return it\\r\\n if self._dict_contains(lookfor):\\r\\n return True, lookfor, self._dict_getitem(lookfor), 1\\r\\n\\r\\n # set up the fuzzy matching tool\\r\\n ratio_calc = difflib.SequenceMatcher()\\r\\n ratio_calc.set_seq1(lookfor)\\r\\n\\r\\n # test each key in the dictionary\\r\\n best_ratio = 0\\r\\n best_match = None\\r\\n best_key = None\\r\\n for key in self:\\r\\n # if the current key is not a string\\r\\n # then we just skip it\\r\\n try:\\r\\n # set up the SequenceMatcher with other text\\r\\n ratio_calc.set_seq2(key)\\r\\n except TypeError:\\r\\n continue\\r\\n\\r\\n # we get an error here if the item to look for is not a\\r\\n # string - if it cannot be fuzzy matched and we are here\\r\\n # this it is definitely not in the dictionary\\r\\n try:\\r\\n # calculate the match value\\r\\n ratio = ratio_calc.ratio()\\r\\n except TypeError:\\r\\n break\\r\\n\\r\\n # if this is the best ratio so far - save it and the value\\r\\n if ratio > best_ratio:\\r\\n best_ratio = ratio\\r\\n best_key = key\\r\\n best_match = self._dict_getitem(key)\\r\\n\\r\\n if stop_on_first and ratio >= self.cutoff:\\r\\n break\\r\\n\\r\\n return best_ratio >= self.cutoff, best_key, best_match, best_ratio\",\n \"def checkDict(words, given_dict):\\n\\tcount = 0\\n\\tfor word in words:\\n\\t\\tif word in given_dict:\\n\\t\\t\\tgiven_dict = given_dict[word]\\n\\t\\telse:\\n\\t\\t\\treturn None\\n\\n\\tif '$value' in given_dict:\\n\\t\\treturn given_dict['$value'][0]\\n\\n\\treturn given_dict\",\n \"def match(dictionary, query, policy='relaxed', matches=None):\\n if query is None:\\n return True\\n assert policy in ['relaxed', 'strict'], \\\"\\\"\\n\\n for field, value in query.iteritems():\\n if field not in dictionary:\\n if policy == 'relaxed':\\n continue\\n else:\\n return False\\n if isinstance(value, list) or not isinstance(value, basestring):\\n values = value if isinstance(value, list) else [value]\\n if dictionary[field] not in values:\\n return False\\n if matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n else:\\n if value == '':\\n # Take special care if value is an empty string\\n if value != dictionary[field]:\\n return False\\n elif matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n continue\\n else:\\n match = re.compile(value).match(dictionary[field])\\n if not match:\\n return False\\n else:\\n if matches is not None:\\n matches['%s_0' % (field)] = dictionary[field]\\n for index, group in enumerate(match.groups()):\\n matches['%s_%d' % (field, index+1)] = group\\n continue\\n return True\",\n \"def matches(self, request: ServeRequest) -> Optional[Match]:\\n for tag_key, tag_value in self.tags.items():\\n request_value = None\\n if tag_key == TAG_SERVE_MATCH_PATH:\\n request_value = request.url\\n elif tag_key == TAG_SERVE_MATCH_PATH_RELATIVE:\\n request_value = request.url[1:]\\n elif tag_key == TAG_SERVE_MATCH_HOST:\\n request_value = request.headers.get('Host', '')\\n elif tag_key.startswith(TAG_SERVE_MATCH_META):\\n meta_key = tag_key.replace(TAG_SERVE_MATCH_META, '')\\n request_value = request.headers.get(meta_key, '')\\n LOGGER.debug(\\\"Checking '%s' against '%s'\\\", request_value, tag_value)\\n regex = re.compile(tag_value)\\n match = regex.match(request_value)\\n if match is None:\\n LOGGER.debug(\\\" => Not matching\\\")\\n return None\\n LOGGER.debug(\\\" => Matching, checking next tag\\\")\\n return match\",\n \"def matches_dict(self, answer_dict):\\n\\n return self.matches(Answer(\\n answer_dict['group_id'],\\n answer_dict['block_id'],\\n answer_dict['answer_id'],\\n \\\"\\\",\\n answer_dict['group_instance'],\\n answer_dict['answer_instance'],\\n ))\",\n \"def match(self, _str: str):\\n result = self._regex.match(_str)\\n if result:\\n return result.groupdict() or True\",\n \"def find(self, value, key=\\\"name\\\", shallow=True):\\n if key.lower() not in (\\\"name\\\", \\\"id\\\", \\\"path\\\"):\\n raise ValueError()\\n\\n if not self.contents:\\n self.get_contents()\\n\\n for content, level in self._iter_contents():\\n if shallow and level != 0:\\n continue\\n if getattr(content, key, None) == value:\\n return content\\n\\n self.project.app.logger.debug(\\n \\\"{}: {} not found in '{}'\\\".format(key, value, self.name)\\n )\",\n \"def find(self, **opts):\\n negate = opts.get('negate', False)\\n match_any = opts.get('match_any', negate)\\n match_all = opts.get('match_all', not match_any)\\n case_matters = opts.get('case_matters', False)\\n reverse = opts.get('reverse', False)\\n mapper = opts.get('map', lambda t: t)\\n\\n if callable(mapper):\\n do_map = mapper\\n elif is_string(mapper):\\n\\n def do_map(value):\\n return getattr(value, mapper, None)\\n elif isinstance(mapper, (list, tuple, set)):\\n\\n def do_map(value):\\n return type(mapper)(getattr(value, t, None) for t in mapper)\\n elif isinstance(mapper, dict):\\n\\n def do_map(value):\\n return type(mapper)(\\n (t, getattr(value, t, None)) for t in mapper)\\n else:\\n raise TypeError(\\\"Invalid mapping rule: %r\\\" % mapper)\\n\\n def gsense(f):\\n\\n def w(value, exp):\\n if negate: return not f(value, exp)\\n else: return f(value, exp)\\n\\n return w\\n\\n def tsense(f):\\n\\n def w(candidate, test_name, test_value):\\n if test_name.startswith('not_'):\\n return not f(candidate, test_name[4:], test_value)\\n else:\\n return f(candidate, test_name, test_value)\\n\\n return w\\n\\n @gsense\\n def do_match(value, exp):\\n if is_string(exp):\\n if case_matters:\\n return value == exp\\n else:\\n return value.lower() == exp.lower()\\n elif hasattr(exp, 'search') and callable(exp.search):\\n return exp.search(value)\\n elif callable(exp):\\n return bool(exp(value))\\n elif exp in (None, True):\\n return True # the attribute exists\\n elif exp is False:\\n return False # no such attribute\\n\\n # If we get here, the only other allowable option is\\n # for exp to be a collection of things to try. If that\\n # fails, the TypeError is propagated back to the caller.\\n for e in iter(exp):\\n if do_match(value, e):\\n return True\\n else:\\n return False\\n\\n all_tests = []\\n # Order matters here...\\n\\n for key in ('type', 'name', 'hasattr', 'hasattrs', 'attr', 'source',\\n 'csource', 'innersource', 'partner', 'parent', 'predicate',\\n 'value'):\\n for k in (key, 'not_' + key):\\n if k in opts: all_tests.append((k, opts[k]))\\n\\n # Choose candidates to search\\n lo_limit = 0 # Search no index before this.\\n hi_limit = len(self.wrappers) # Search no index at or after this.\\n if 'search_after' in opts:\\n lo_limit = opts['search_after'].obj_id + 1\\n if 'search_before' in opts:\\n hi_limit = opts['search_before'].obj_id\\n if 'search_inside' in opts:\\n t = opts['search_inside']\\n p = t.partner\\n if p is None:\\n lo_limit = hi_limit = t.obj_id\\n else:\\n lo, hi = sorted((t.obj_id, p.obj_id))\\n lo_limit = max(lo_limit, lo)\\n hi_limit = min(hi_limit, hi)\\n\\n candidates = list(self.wrappers[i] for i in range(lo_limit, hi_limit))\\n if reverse:\\n candidates.reverse()\\n\\n @tsense\\n def t_property(candidate, test_name, test_value):\\n return (hasattr(candidate, test_name)\\n and do_match(getattr(candidate, test_name), test_value))\\n\\n @tsense\\n def t_associate(candidate, test_name, test_value):\\n return (hasattr(candidate, test_name)\\n and test_value(getattr(candidate, test_name))\\n if callable(test_value) else\\n getattr(candidate, test_name) is test_value)\\n\\n @tsense\\n def t_has_attr(candidate, test_name, test_value):\\n if test_name == 'hasattr':\\n test_value = [test_value]\\n\\n if not hasattr(candidate, 'keys'):\\n return False\\n\\n for tv in test_value:\\n for key in candidate.keys():\\n if do_match(key, tv):\\n break\\n else:\\n return False\\n else:\\n return True\\n\\n @tsense\\n def t_attr_match(candidate, test_name, test_value):\\n if not hasattr(candidate, 'getattr'):\\n return False\\n elif isinstance(test_value, tuple):\\n tv = [test_value]\\n elif isinstance(test_value, dict):\\n tv = test_value.items()\\n else:\\n raise TypeError(\\\"invalid key for attribute match: %s\\\" %\\n test_value)\\n\\n for a_name, a_exp in tv:\\n try:\\n if not do_match(candidate[a_name].value, a_exp):\\n return False\\n except KeyError:\\n if a_exp is not False:\\n return False\\n else:\\n return True\\n\\n @tsense\\n def t_predicate(candidate, test_name, test_value):\\n return test_value(candidate)\\n\\n def t_fail(candidate, test_name, test_value):\\n return False\\n\\n test_map = dict(\\n type=t_property,\\n not_type=t_property,\\n name=t_property,\\n not_name=t_property,\\n hasattr=t_has_attr,\\n not_hasattr=t_has_attr,\\n hasattrs=t_has_attr,\\n not_hasattrs=t_has_attr,\\n attr=t_attr_match,\\n not_attr=t_attr_match,\\n source=t_property,\\n not_source=t_property,\\n csource=t_property,\\n not_csource=t_property,\\n innersource=t_property,\\n not_innersource=t_property,\\n value=t_property,\\n not_value=t_property,\\n parent=t_associate,\\n not_parent=t_associate,\\n partner=t_associate,\\n not_partner=t_associate,\\n predicate=t_predicate,\\n not_predicate=t_predicate,\\n )\\n for candidate in candidates:\\n ok = match_all\\n\\n for test_name, test_value in all_tests:\\n tfunc = test_map.get(test_name, t_fail)\\n ok = tfunc(candidate, test_name, test_value)\\n\\n if not match_all and ok: break\\n if match_all and not ok: break\\n\\n if ok:\\n yield do_map(candidate)\",\n \"def fromMatchId(cls, matchId):\\n matchDict = CachedDB().getMatchById(matchId)\\n if matchDict is None:\\n return None\\n return cls(matchDict)\",\n \"def match_by_id(self, match_id):\\n\\n url = API_PATH[\\\"match_by_id\\\"].format(\\n region_url=self.region_url, match_id=match_id)\\n\\n response = requests.get(url, headers=self.headers)\\n\\n return response.json()\",\n \"def get_if_exist(self, data, key):\\n if key in data:\\n return data[key]\\n return None\",\n \"def _lookup_model(self, name, experiment_dict):\\n if experiment_dict.get(name) is None:\\n return None\\n return self._lookups[name][experiment_dict[name]]\",\n \"def _key_list_search(self, keys_list, lookup_dict):\\n for index, key in enumerate(keys_list):\\n result = nested_lookup(key, lookup_dict)\\n try:\\n value = nested_lookup(keys_list[index + 1], result)\\n except IndexError:\\n pass\\n return value\",\n \"def _find(self, hashV):\\n return self.table.search(hashV)\",\n \"def query_dict(dictionary: Mapping[Any, Any], keys: Sequence[Any]) -> Union[Any, None]:\\n\\n def extract(dictionary: Any, key: Any) -> Union[Any, None]:\\n \\\"\\\"\\\"Get value associated with key, defaulting to None.\\\"\\\"\\\"\\n if dictionary is None or not isinstance(dictionary, dict):\\n return None\\n return dictionary.get(key)\\n\\n return reduce(extract, keys, dictionary)\",\n \"def _dict_lookup(typingctx, d, key, hashval):\\n resty = types.Tuple([types.intp, types.Optional(d.value_type)])\\n sig = resty(d, key, hashval)\\n\\n def codegen(context, builder, sig, args):\\n fnty = ir.FunctionType(\\n ll_ssize_t,\\n [ll_dict_type, ll_bytes, ll_hash, ll_bytes],\\n )\\n [td, tkey, thashval] = sig.args\\n [d, key, hashval] = args\\n fn = cgutils.get_or_insert_function(builder.module, fnty,\\n 'numba_dict_lookup')\\n\\n dm_key = context.data_model_manager[tkey]\\n dm_val = context.data_model_manager[td.value_type]\\n\\n data_key = dm_key.as_data(builder, key)\\n ptr_key = cgutils.alloca_once_value(builder, data_key)\\n cgutils.memset_padding(builder, ptr_key)\\n\\n ll_val = context.get_data_type(td.value_type)\\n ptr_val = cgutils.alloca_once(builder, ll_val)\\n\\n dp = _container_get_data(context, builder, td, d)\\n ix = builder.call(\\n fn,\\n [\\n dp,\\n _as_bytes(builder, ptr_key),\\n hashval,\\n _as_bytes(builder, ptr_val),\\n ],\\n )\\n # Load value if output is available\\n found = builder.icmp_signed('>', ix, ix.type(int(DKIX.EMPTY)))\\n\\n out = context.make_optional_none(builder, td.value_type)\\n pout = cgutils.alloca_once_value(builder, out)\\n\\n with builder.if_then(found):\\n val = dm_val.load_from_data_pointer(builder, ptr_val)\\n context.nrt.incref(builder, td.value_type, val)\\n loaded = context.make_optional_value(builder, td.value_type, val)\\n builder.store(loaded, pout)\\n\\n out = builder.load(pout)\\n return context.make_tuple(builder, resty, [ix, out])\\n\\n return sig, codegen\",\n \"def get_match_settings(\\n key=None,\\n ) -> MatchSettingsResponseBody:\\n if config := AdditionalMatchSettingsConfig.get(str(key)):\\n return MatchSettingsResponseBody(config)\\n return bottle.abort(400, f\\\"No match_settings for pg_id {key} found\\\")\",\n \"def get_matching_item(self, mapping: MutableMapping[str, Any],\\n ns_prefix: str = 'xmlns',\\n match_local_name: bool = False) -> Optional[Any]:\\n if self.name is None:\\n return None\\n elif not self.target_namespace:\\n return mapping.get(self.name)\\n elif self.qualified_name in mapping:\\n return mapping[cast(str, self.qualified_name)]\\n elif self.prefixed_name in mapping:\\n return mapping[cast(str, self.prefixed_name)]\\n\\n # Try a match with other prefixes\\n target_namespace = self.target_namespace\\n suffix = f':{self.local_name}'\\n\\n for k in filter(lambda x: x.endswith(suffix), mapping):\\n prefix = k.split(':')[0]\\n if self.namespaces.get(prefix) == target_namespace:\\n return mapping[k]\\n\\n # Match namespace declaration within value\\n ns_declaration = '{}:{}'.format(ns_prefix, prefix)\\n try:\\n if mapping[k][ns_declaration] == target_namespace:\\n return mapping[k]\\n except (KeyError, TypeError):\\n pass\\n else:\\n if match_local_name:\\n return mapping.get(self.local_name) # type: ignore[arg-type]\\n return None\",\n \"def find(self, seq):\\n \\n if not isinstance(seq, str):\\n seqstr = ''\\n # Concatenate list\\n for s in seq:\\n seqstr += self.prepseq(s.upper())\\n else:\\n seqstr = self.prepseq(seq.upper())\\n \\n searchstr = self.digest(seqstr)\\n\\n if searchstr in self.seqs:\\n hits = self.seqs[searchstr]\\n\\n if seqstr in hits:\\n return hits[seqstr]\\n else:\\n return None\\n \\n else:\\n return None\",\n \"def _match(self, filename: str) -> Optional[dict]:\\n if not self.named_regexp:\\n self.log.warning(\\n \\\"Regular expression not provided for plugin. Run with \\\"\\n \\\"`--help-all` flag for more information.\\\"\\n )\\n return None\\n\\n match = re.match(self.named_regexp, filename)\\n if not match or not match.groups():\\n self.log.warning(\\n \\\"Regular expression '{}' did not match anything in: {}\\\"\\n \\\"\\\".format(self.named_regexp, filename)\\n )\\n return None\\n\\n gd = match.groupdict()\\n self.log.debug(\\n \\\"Regular expression '{}' matched\\\\n'{}' in: {}\\\"\\n \\\"\\\".format(self.named_regexp, gd, filename)\\n )\\n return gd\",\n \"def find_match(people, STRs):\\n for person in people:\\n if compare_str(person, STRs):\\n return person[\\\"name\\\"]\\n return \\\"No match\\\"\",\n \"def find(lst, key, value):\\n\\n for i, dic in enumerate(lst):\\n if dic[key] == value:\\n return i\\n return None\",\n \"def get_option(option_dict, option):\\n if isinstance(option_dict, dict) and option in option_dict:\\n return option_dict[option]\\n elif not isinstance(option_dict, dict):\\n return None\\n else:\\n for value in option_dict.values():\\n result = SchedulePolicy.get_option(value, option)\\n if result is not None:\\n return result\",\n \"def find_key(dic, val): \\n return [k for k, v in dic.iteritems() if re.search(v, val)]\",\n \"def search(self, key):\\n if key in self.key_list:\\n return (self.nodes)[key]\\n return None\",\n \"def find(key, condition):\\n for i, line in enumerate(lines):\\n if condition(line, key):\\n return i\\n return None\",\n \"def get_from_dictionary(self,dictionary,key):\\r\\n try:\\r\\n return dictionary[key]\\r\\n except KeyError:\\r\\n raise RuntimeError(\\\"Dictionary does not contain key '%s'\\\" %key)\",\n \"def find_by_exact_match(self):\\n while True: \\n self.task_name_search = input(\\\"What is the keyword/s you are looking\\\"\\n \\\" for? Press Q to quit to the main screen: \\\").strip()\\n if self.task_name_search.upper() in [\\\"Q\\\", \\\"QUIT\\\", \\\"EXIT\\\"]:\\n x = self.dict_list\\n return x\\n self.find_by_exact_match_list = []\\n count = 0\\n for i in self.dict_list:\\n for key, value in i.items():\\n if re.search(self.task_name_search, value):\\n self.find_by_exact_match_list.append(i)\\n count+=1\\n break\\n if count == 0:\\n print(\\\"There were no matches.\\\")\\n else:\\n self.display_style(self.find_by_exact_match_list)\\n break\\n self.del_or_edit()\",\n \"def match_phrase(self, phrase):\\n key = None\\n match_phrase = None\\n for key in self.get_key_list(phrase):\\n if key in self.cls_phrases:\\n match_phrase = key\\n break\\n \\n if match_phrase == None:\\n return None, key\\n return self.get_most_common(self.cls_phrases[match_phrase]), key\",\n \"def lookup(dic, key, *keys):\\n if keys:\\n return lookup(dic.get(key, {}), *keys)\\n return dic.get(key)\",\n \"def get(self, key, def_value=None):\\n\\n index = self._get_hash(key)\\n\\n if self.table[index] is not None:\\n for pair in self.table[index]:\\n if key == pair[0]:\\n return pair[1]\\n\\n if def_value is not None:\\n return def_value\\n\\n raise ValueError(f\\\"can't find value with given key {key}\\\")\",\n \"def func(match, *args, **kwargs):\\n\\n data = match.group(0)\\n return (resources[data], True) if data in resources else (data, False)\",\n \"def search_key(cls, key, element):\\n if isinstance(element, dict):\\n for k, v in element.items():\\n if k == key:\\n return v\\n elif isinstance(v, dict):\\n cls.search_key(key, v)\\n elif isinstance(v, list):\\n cls.search_key(key, v)\\n elif isinstance(element, list):\\n for obj in element:\\n v = cls.search_key(key, obj)\\n if v:\\n return v\",\n \"def lookup(dic, key, *keys):\\r\\n if keys:\\r\\n return lookup(dic.get(key, {}), *keys)\\r\\n return dic.get(key)\",\n \"def search_hash(word_input,hashtable):\\n\\n if word_input in hashtable:\\n return hashtable[word_input]\\n else:\\n return None\",\n \"def find(self, key):\\n if self.head is None:\\n return\\n itr = self.head\\n while itr:\\n if itr.data == key:\\n return itr.data\\n itr = itr.next\\n return None\",\n \"def _match(self, document: dict, query: dict) -> bool:\\n\\n matches = [\\n self._match(document.get(key), value)\\n if isinstance(value, dict) and isinstance(document.get(key), dict)\\n else document.get(key) == value\\n for key, value in query.items()\\n ]\\n return all(matches)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6650081","0.64368933","0.62785393","0.6271919","0.606207","0.60218126","0.6009384","0.59157956","0.5891576","0.586902","0.5831622","0.58111554","0.58071977","0.580484","0.57333195","0.5707258","0.5707258","0.57004094","0.5668807","0.561176","0.5579269","0.5545683","0.5541376","0.5524781","0.5491723","0.5485185","0.5477593","0.5477031","0.5449981","0.54199696","0.54196894","0.5405206","0.53847706","0.5381589","0.5362705","0.53377056","0.5336607","0.5320419","0.52796257","0.52756554","0.52414745","0.5233859","0.522122","0.5218139","0.5207426","0.5206905","0.52000886","0.51999754","0.5197119","0.5187457","0.5172239","0.515656","0.51530975","0.51509225","0.514524","0.5141991","0.5135422","0.5113002","0.510177","0.51001674","0.5098506","0.5090382","0.5090373","0.50745314","0.505291","0.50510097","0.50490904","0.50476694","0.50469816","0.5015526","0.5012335","0.49847344","0.4983519","0.4980216","0.49783805","0.49764523","0.49728903","0.4971967","0.49644974","0.4964117","0.4963304","0.49520665","0.4941253","0.493734","0.49341795","0.49310932","0.49291718","0.49206796","0.49047834","0.48943067","0.4889719","0.4886103","0.48855963","0.48844397","0.4881958","0.48805845","0.48762184","0.4874606","0.48691735","0.48661977"],"string":"[\n \"0.6650081\",\n \"0.64368933\",\n \"0.62785393\",\n \"0.6271919\",\n \"0.606207\",\n \"0.60218126\",\n \"0.6009384\",\n \"0.59157956\",\n \"0.5891576\",\n \"0.586902\",\n \"0.5831622\",\n \"0.58111554\",\n \"0.58071977\",\n \"0.580484\",\n \"0.57333195\",\n \"0.5707258\",\n \"0.5707258\",\n \"0.57004094\",\n \"0.5668807\",\n \"0.561176\",\n \"0.5579269\",\n \"0.5545683\",\n \"0.5541376\",\n \"0.5524781\",\n \"0.5491723\",\n \"0.5485185\",\n \"0.5477593\",\n \"0.5477031\",\n \"0.5449981\",\n \"0.54199696\",\n \"0.54196894\",\n \"0.5405206\",\n \"0.53847706\",\n \"0.5381589\",\n \"0.5362705\",\n \"0.53377056\",\n \"0.5336607\",\n \"0.5320419\",\n \"0.52796257\",\n \"0.52756554\",\n \"0.52414745\",\n \"0.5233859\",\n \"0.522122\",\n \"0.5218139\",\n \"0.5207426\",\n \"0.5206905\",\n \"0.52000886\",\n \"0.51999754\",\n \"0.5197119\",\n \"0.5187457\",\n \"0.5172239\",\n \"0.515656\",\n \"0.51530975\",\n \"0.51509225\",\n \"0.514524\",\n \"0.5141991\",\n \"0.5135422\",\n \"0.5113002\",\n \"0.510177\",\n \"0.51001674\",\n \"0.5098506\",\n \"0.5090382\",\n \"0.5090373\",\n \"0.50745314\",\n \"0.505291\",\n \"0.50510097\",\n \"0.50490904\",\n \"0.50476694\",\n \"0.50469816\",\n \"0.5015526\",\n \"0.5012335\",\n \"0.49847344\",\n \"0.4983519\",\n \"0.4980216\",\n \"0.49783805\",\n \"0.49764523\",\n \"0.49728903\",\n \"0.4971967\",\n \"0.49644974\",\n \"0.4964117\",\n \"0.4963304\",\n \"0.49520665\",\n \"0.4941253\",\n \"0.493734\",\n \"0.49341795\",\n \"0.49310932\",\n \"0.49291718\",\n \"0.49206796\",\n \"0.49047834\",\n \"0.48943067\",\n \"0.4889719\",\n \"0.4886103\",\n \"0.48855963\",\n \"0.48844397\",\n \"0.4881958\",\n \"0.48805845\",\n \"0.48762184\",\n \"0.4874606\",\n \"0.48691735\",\n \"0.48661977\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8009377"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":591,"cells":{"query":{"kind":"string","value":"Utility function to populate key_matcher from self.records."},"document":{"kind":"string","value":"def _add_matches(self):\r\n for record in self.records:\r\n match_dict={key_to_track: record.get(key_to_track)\r\n for key_to_track in self.key_matcher.keys()}\r\n self.key_matcher.add(obj=record,\r\n match_dict=match_dict)"},"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 match_source_key(self, match):\n raise NotImplementedError","def __init__(self):\n self.key_to_record = {}\n self.mutation_to_key = {}\n self._innovation_key_generator = count(0)","def test_toofewkeys(self):\n self.assertRaises(recordparser.KeyListMismatchError,\n recordparser.getfields, \"1234567890\", \"10s\", ())","def init_record_fields(self, run_record_key, record_fields):\n\n record_fields_grp = self.settings_grp[RECORD_FIELDS]\n\n # make a dataset for the sparse fields allowed. this requires\n # a 'special' datatype for variable length strings. This is\n # supported by HDF5 but not numpy.\n vlen_str_dt = h5py.special_dtype(vlen=str)\n\n # create the dataset with the strings of the fields which are records\n record_group_fields_ds = record_fields_grp.create_dataset(run_record_key,\n (len(record_fields),),\n dtype=vlen_str_dt,\n maxshape=(None,))\n\n # set the flags\n for i, record_field in enumerate(record_fields):\n record_group_fields_ds[i] = record_field","def initialize(self, keys: List[str]):","def _make_match_key(self, firstname, lastname):\n return \"{}::{}\".format(firstname.lower().strip(), lastname.lower().strip())","def test_toomanykeys(self):\n self.assertRaises(recordparser.KeyListMismatchError,\n recordparser.getfields, \"1234567890\", \"10s\", (\"key1\", \"key2\"))","def init_by_keys(cls, **query):\n raise NotImplementedError()","def gen_keys():","def __init__(self, matcher, generate):\n self.matcher = matcher\n self._generate = generate","def __init__(self, key):\n self.key = [int_mapping(k) for k in key]","def buildFromRecords(self, records):\n probes = {}\n for record in records:\n fields = {}\n for field in record.split(self.FIELD_DELIMITER):\n index = field.find(self.KEY_VALUE_DELIMITER)\n if index == -1 or len(field) < (index+1):\n raise InvariantViloation('detected invalid probe record in app info file - {}'.format(record))\n fields.update({field[:index]:field[index+1:]})\n if fields:\n try:\n fields[self.FIELD_FILE] = self.trimWorkspace(fields[self.FIELD_FILE], self.workspace)\n probes.update({\n fields[self.FIELD_RECORDER_RETURN_SITE] : AnchoredProbe(\n fields[self.FIELD_NAME], fields[self.FIELD_FILE], fields[self.FIELD_LINE],\n fields[self.FIELD_ATTRIBUTES], fields[self.FIELD_STATUS] == self.PROBE_STATUS_ENABLED,\n fields[self.FIELD_NAME]\n )\n })\n except KeyError as error:\n raise InvariantViloation('detected record missing field {} - \\n{}\\n{}'.format(error, record, fields))\n return probes","def train_test_split(record_dictionary, ratio=.5):\n\n num_training_records = int(len(record_dictionary) * ratio)\n\n keys = list(record_dictionary.keys())\n\n training_records = np.random.choice(\n keys, num_training_records, replace=False)\n testing_records = [key for key in keys if key not in training_records]\n\n training_dictionary = {\n record: record_dictionary[record]\n for record in training_records\n }\n testing_dictionary = {\n record: record_dictionary[record]\n for record in testing_records\n }\n\n return training_dictionary, testing_dictionary","def test_invalid_key_gen(self):\r\n expected = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\r\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\r\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\r\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\r\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'}}\r\n data = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\r\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\r\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\r\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\r\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'},\r\n 5: {'ID': 'A233', 'Ge1nder': 'F', 'Age': '62', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}}\r\n result = Validator.save_dict(data)\r\n self.assertDictEqual(expected, result)","def harmonize_keys(self):\n self._data.key_regex_replacements = _key_regex_replacements\n self._data.key_replacements = _key_replacements","def _make_key(self, record_dict: Dict[str, Any]) -> int:\n return self._keys.setdefault(frozenset(record_dict.keys()), len(self._keys))","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: \"Topology\",\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[\n Union[TopologyKey, LibraryChargeTopologyKey],\n PotentialKey,\n ] = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n topology_key = TopologyKey(atom_indices=key)\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n )\n self.key_map[topology_key] = potential_key\n\n if self.__class__.__name__ in [\n \"SMIRNOFFBondCollection\",\n \"SMIRNOFFAngleCollection\",\n ]:\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n assigned_terms=matches,\n topology=topology,\n valence_terms=valence_terms,\n )","def test_keys(self):\n storage = Storage()\n keys_to_set = {'1': 'hello',\n '2': 'bye',\n '3': [1, 2, 'three'],\n '4': {1: 'one', 2: 'two'},\n 'a': 1,\n 'aa': 2,\n 'abc':3,\n 'hello':4}\n for key in keys_to_set:\n storage.set(key, keys_to_set[key])\n\n pattern_answers = {'?': ['1','2','3','4','a'],\n '*': list(keys_to_set.keys()),\n '[13]': ['1', '3'],\n '[^a]': ['1','2','3','4'],\n '[1-3]': ['1','2','3'],\n '?[ae]*': ['aa', 'hello']}\n for pattern in pattern_answers:\n self.assertEqual(pattern_answers[pattern],\n storage.keys(pattern), f'For pattern \"{pattern}\" expected {pattern_answers[pattern]}.')","def __init__(self):\n self._keys = []\n self._sortKeys = []","def key_lookup_batch(self, batchiter):\n pass","def create_matcher(self):\n self.matcher = None\n if \"matcher\" in self.config:\n self.matcher = matcher.Matcher(self.config[\"matcher\"])\n else:\n self.matcher = matcher.TrueMatcher()\n \n self.use_fields_for_id = []\n if \"matcherfield\" in self.config:\n self.use_fields_for_id = self.config[\"matcherfield\"].split(\",\")\n \n if \"clear\" in self.config:\n self.clear_matcher = matcher.Matcher(self.config[\"clear\"])\n self.autoclear = self.auto_acknowledge\n else:\n self.clear_matcher = matcher.FalseMatcher()\n self.autoclear = False","def store_matches(\n self,\n parameter_handler: ParameterHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n # TODO: Should the key_map always be reset, or should we be able to partially\n # update it? Also Note the duplicated code in the child classes\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n param = val.parameter_type\n if param.k_bondorder or param.length_bondorder:\n bond = topology.get_bond_between(*key)\n fractional_bond_order = bond.fractional_bond_order\n if not fractional_bond_order:\n assert self._get_uses_interpolation(parameter_handler)\n raise RuntimeError(\n \"Bond orders should already be assigned at this point\",\n )\n else:\n fractional_bond_order = None\n topology_key = BondKey(\n atom_indices=key,\n bond_order=fractional_bond_order,\n )\n\n potential_key = PotentialKey(\n id=val.parameter_type.smirks,\n associated_handler=parameter_handler.TAGNAME,\n bond_order=fractional_bond_order,\n )\n self.key_map[topology_key] = potential_key\n\n valence_terms = self.valence_terms(topology)\n\n _check_all_valence_terms_assigned(\n handler=parameter_handler,\n topology=topology,\n assigned_terms=matches,\n valence_terms=valence_terms,\n )","def lookup(self, key):","def __init__(self):\n super(KeyIterator, self).__init__()\n self.iterator = self.ValueIterator()","def clean_up(self) -> None:\n self.single_device_matches = collections.defaultdict(\n lambda: collections.defaultdict(list)\n )","def __init__(self, compound_matcher):\n self._matcher = compound_matcher","def find_records(self, check, keys=None):\n matches = self._match(check)\n if keys:\n return [self._extract_subdict(rec, keys) for rec in matches]\n else:\n return matches","def __init__(self):\n # map of (key, index in list)\n self.map = dict()\n \n # list of keys for random selection\n self.keys = []","def test_keys_eq(self):\n self.assertListEqual(self.result, self.expected)","def _rebuild_comparedict(self,\n result,\n rewrapped_columns,\n columns,\n rewrapped_keys,\n keys,\n missing_col):\n normalize = lambda x: x if (isinstance(x, str) or not x) else tuple(x)\n rewrapped_columns = normalize(rewrapped_columns)\n rewrapped_keys = normalize(rewrapped_keys)\n columns = normalize(columns)\n keys = normalize(keys)\n\n if rewrapped_keys == keys and rewrapped_columns == columns:\n if isinstance(result, CompareDict):\n key_names = (keys,) if isinstance(keys, str) else keys\n result.key_names = key_names\n return result # <- EXIT!\n\n try:\n item_gen = iter(result.items())\n except AttributeError:\n item_gen = [(self._missing, result)]\n\n if rewrapped_keys != keys:\n def rebuild_keys(k, missing):\n if isinstance(keys, str):\n return k\n key_dict = dict(zip(rewrapped_keys, k))\n return tuple(key_dict.get(c, missing) for c in keys)\n missing_key = self._missing\n item_gen = ((rebuild_keys(k, missing_key), v) for k, v in item_gen)\n\n if rewrapped_columns != columns:\n def rebuild_values(v, missing):\n if isinstance(columns, str):\n return v\n if not nonstringiter(v):\n v = (v,)\n value_dict = dict(zip(rewrapped_columns, v))\n return tuple(value_dict.get(v, missing) for v in columns)\n item_gen = ((k, rebuild_values(v, missing_col)) for k, v in item_gen)\n\n return CompareDict(item_gen, key_names=keys)","def test_keys(self):\n obs = self.tester.keys()\n self.assertTrue(isinstance(obs, Iterable))\n self.assertEqual(set(obs), self.exp_sample_ids)","def test_keys(self):\n obs = self.tester.keys()\n self.assertTrue(isinstance(obs, Iterable))\n self.assertEqual(set(obs), self.exp_sample_ids)","def get_potential_matches_from_record(self, record):\n\n #Query against the con to the sqlite database\n def get_potential_matches(sub_tokens):\n\n search_tokens = \" \".join(sub_tokens)\n SQL = self.get_records_sql.format(search_tokens, self.max_results)\n df = pd.read_sql(SQL,self.target_con)\n return df\n\n tokens_orig = record.tokens_original_order\n tokens_ordered = record.tokens_specific_to_general_by_freq\n df_all = pd.DataFrame()\n\n\n for tokens in [tokens_orig, tokens_ordered]:\n for i in range(len(tokens)):\n\n sub_tokens = tokens[i:]\n if len(sub_tokens)<2:\n df= pd.DataFrame()\n break\n\n df = get_potential_matches(sub_tokens)\n\n if len(df)>0 and len(df)<self.max_results:\n df_all = pd.concat([df_all, df])\n break\n if len(df_all) > 0:\n df_all = df_all.drop_duplicates(\"auto_generated_row_id\")\n\n return self.df_to_record_objects(df_all)","def setUp(self):\n # $TODO - expand supported field types\n # NOTE: For the purposes of this test, don't expect to compare 'f'-type\n # floats! The precision conversion using struct.pack -> struct.unpack\n # is problematic! Use 'd' instead because Python floats are actually\n # C-doubles. Use '=d' if necessary.\n int1 = -10\n uint1 = 20\n string1 = \"This is a string\" # pack this as a 30-byte string\n char1 = \"J\"\n short1 = 0\n float1 = 5.23\n double1 = -256.3456789107\n ushort1 = 5\n string2 = \"This is another string\" # pack this as a 30-byte string\n long1 = 2147483647\n ulong1 = 3000000000\n\n # Use the fields above in this order.\n self.fieldmap = \"iI30schddH30slL\"\n self.sourcekeys = (\"int1\", \"uint1\", \"string1\", \"char1\", \"short1\",\n \"float1\", \"double1\", \"ushort1\", \"string2\", \"long1\", \"ulong1\")\n\n # Create the raw data that getfields will parse\n self.rawdata = struct.pack(self.fieldmap, int1, uint1, string1, char1,\n short1, float1, double1, ushort1, string2, long1, ulong1)\n\n # This is what getfields should return\n self.knownvalues = {\"char1\":char1, \"short1\":short1, \"ushort1\":ushort1,\n \"int1\":int1, \"uint1\":uint1, \"long1\":long1, \"ulong1\":ulong1,\n \"float1\":float1, \"double1\":double1, \"string1\":string1,\n \"string2\":string2}","def create_match(self, parser, fields):\n match = parser.OFPMatch()\n for (field, value) in fields.iteritems():\n match.append_field(field, value)\n return match","def __init__(self):\n self.key2value = {}\n self.key2time = {}","def secondary_keys_dicts(self):","def store_matches(\n self,\n parameter_handler: ImproperTorsionHandler,\n topology: Topology,\n ) -> None:\n if self.key_map:\n self.key_map = dict()\n matches = parameter_handler.find_matches(topology)\n for key, val in matches.items():\n parameter_handler._assert_correct_connectivity(\n val,\n [\n (0, 1),\n (1, 2),\n (1, 3),\n ],\n )\n n_terms = len(val.parameter_type.k)\n for n in range(n_terms):\n smirks = val.parameter_type.smirks\n non_central_indices = [key[0], key[2], key[3]]\n\n for permuted_key in [\n (\n non_central_indices[i],\n non_central_indices[j],\n non_central_indices[k],\n )\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\n ]:\n topology_key = ImproperTorsionKey(\n atom_indices=(key[1], *permuted_key),\n mult=n,\n )\n potential_key = PotentialKey(\n id=smirks,\n mult=n,\n associated_handler=\"ImproperTorsions\",\n )\n self.key_map[topology_key] = potential_key","def test_fromkeys(self):\n d = SplayDict.fromkeys(['a', 'b', 'c'], 1)\n self.assertIn('a' , d)\n self.assertIn('b' , d)\n self.assertIn('c' , d)\n self.assertEqual(d['a'] , 1)\n self.assertEqual(d['b'] , 1)\n self.assertEqual(d['c'] , 1)","def __init__(self, map):\n self.map = map\n self._map = _map = {}\n for key in map.keys():\n _map[key] = key\n self.fast_validate = (10, _map, self.validate)","def setup_known_fields(self):\n\n kfields = dict(self.known_fields)\n freg = re.compile(r\"(^.+)_\\d+$\")\n for field in self:\n if self[field].get(\"units\") is not None:\n continue\n\n if field in kfields:\n self[field][\"units\"] = kfields[field]\n continue\n\n fs = freg.search(field)\n if fs and fs.groups()[0] in kfields:\n self[field][\"units\"] = kfields[fs.groups()[0]]","def _match(self, check):\n matches = []\n tests = {}\n for k, v in check.items():\n if isinstance(v, dict):\n tests[k] = CompositeFilter(v)\n else:\n tests[k] = lambda o: _add_tz(o) == _add_tz(v)\n\n for rec in self._records.values():\n if self._match_one(rec, tests):\n matches.append(deepcopy(rec))\n return matches","def prepare_key (self, key, for_seq):\n r_key = \"%s:%d:%s\" % (self.classkey, for_seq, key)\n return r_key","def _init_run_records_field(self, run_idx, run_record_key,\n field_name, field_shape, field_dtype):\n\n record_grp = self.run(run_idx)[run_record_key]\n\n # check if it is variable length\n if field_shape is Ellipsis:\n # make a special dtype that allows it to be\n # variable length\n vlen_dt = h5py.special_dtype(vlen=field_dtype)\n\n # this is only allowed to be a single dimension\n # since no real shape was given\n dset = record_grp.create_dataset(field_name, (0,), dtype=vlen_dt,\n maxshape=(None,))\n\n # its not just make it normally\n else:\n # create the group\n dset = record_grp.create_dataset(field_name, (0, *field_shape), dtype=field_dtype,\n maxshape=(None, *field_shape))\n\n return dset","def construct_kv_dict(self):\r\n key1 = self.key_factory('existing_field')\r\n key2 = self.key_factory('other_existing_field')\r\n new_value = 'new value'\r\n newer_value = 'newer value'\r\n return {key1: new_value, key2: newer_value}","def __init_matcher(self):\n\t\tmatcher = Matcher()\n\t\tmatcher.set_mentors(self.mentors.find())\n\t\tmatcher.set_migrants(self.migrants.find())\n\t\tprint(matcher.migrants)\n\t\t\n\t\treturn matcher","def __init__(self):\n self.ds = set()\n self.keys = []","def _prepare_keys(self, keys):\n # sorting is guaranteed to enable comparisons throughout the class\n for key in keys:\n key.sort()\n\n # ensure no overlap with the primary key\n if self._primary_key in keys:\n keys.remove(self._primary_key)\n\n return keys","def __init__(self, *values):\n if (len(values) == 1) and (type(values[0]) in SequenceTypes):\n values = values[0]\n self.values = values[:]\n self.values_ = values_ = {}\n for key in values:\n values_[key] = key\n self.fast_validate = (10, values_, self.validate)","def __init__(self, *args, **kwargs):\n defaultdict.__init__(self)\n self.sortedkeys = None","def reinit (self):\n #for name, obj in inspect.getmembers (self):\n ## if isinstance (obj, RField):\n # self.keyvals[name] = obj.default\n inspect.getmembers (self)","def __init__(self, key):\n self.key = key","def from_items(cls, items):\n new_match = Match()\n new_match.fields = [None] * len(cls.indices)\n for key, val in items:\n try:\n idx = cls.name_to_idx[key]\n new_match.fields[idx] = cls.conversions_to_bin[idx](val)\n except:\n # unknown values\n pass\n return new_match","def _match(self) -> None:\n self.matched = [i for i in self.data if self.match(i)]\n self.unmatched = [i for i in self.data if not self.match(i)]","def __init__(self,\n allowRepetition):\n self.__fileName = \"\"\n self.__allowRepetition = allowRepetition\n self.__keyObjs = {}\n self.__keyList = []\n self.__keyCount = {}\n self.__trailer = []","async def build_key(self):\n self.key = self.update_key()\n search_key_result = await self.redis.keys(self.key)\n if len(search_key_result) == 1:\n self.key = search_key_result[0]\n if self.id == \"*\":\n self.id = self.key.split(':')[0]\n if self.value == \"*\":\n self.value = self.key.split(':')[-1]\n return True","def data_comparison(observations, records, record):\n for observation in observations:\n if observation != \"_id\":\n try:\n if re.search(observation, f\"{records[record]}\"):\n if not re.search(\n observations[observation], f\"{records[record]}\"\n ):\n records[record] = (\n f\"{records[record]}\"\n + \" --> \"\n + observations[observation]\n )\n except Exception as ex:\n Common.logger.warning(f\"Exception happened in data comparison {ex}\")\n return records","def _eq_key(self):\n return (\n self.message_type,\n self.topic,\n self.schema_id,\n self.payload,\n self.uuid,\n self.timestamp,\n self.upstream_position_info,\n self.kafka_position_info,\n self.dry_run,\n self.encryption_type\n )","def MakeKey(self, string, string_1, string_2):\n ...","def __init__ (self, id, finder, matches):\n\t\tself.id = id\n\t\t# self.inCitesName = fullname\n\t\tfor attr in ['fullname', 'firstName', 'middleName', 'lastName', 'note']:\n\t\t\tsetattr (self, attr, getattr (finder, attr))\n\t\tself.matches = matches\n\t\tself.numMatches = len(matches)","def __init__(self, replacer, lookup, field=1, skipper=None):\n if isinstance(replacer, str):\n replacer = re.compile(replacer)\n if isinstance(skipper, str):\n skipper = re.compile(skipper)\n\n if not replacer.groups:\n raise DictReplacerError(\"Invalid replacer pattern: no groups \"\n \"specified - '%s'\" % replacer.pattern)\n\n self._replacer = replacer\n self._lookup = lookup\n self._field = field\n self._skipper = skipper","def test_invalid_key_ID(self):\r\n expected = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\r\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\r\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\r\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\r\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'}}\r\n data = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\r\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\r\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\r\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\r\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'},\r\n 5: {'kjhID': 'A233', 'Gender': 'F', 'Age': '62', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\r\n 'Birthday': '24-06-1995'}}\r\n result = Validator.save_dict(data)\r\n self.assertDictEqual(expected, result)","def test_normal_fields_can_be_defined_between_primary_keys(self):","def process_data(self):\n num_records = len(self.records_data)\n for i in range(len(self.keys)):\n student_key = self.keys[i]\n if (i < num_records):\n self._load_student_record(student_key,\n self.records_data[i])","def set_keys(cls, val):\n keys = []\n check = lambda dict, key, default_val: dict[key] if key in dict.keys() else default_val\n for i in range(val['row_max']):\n keys.append([check(val, '{}_{}'.format(x, y), cls.NOTAVAILABLE) \\\n for x, y in list(product([i], list(range(val['col_max']))))])\n if not hasattr(cls, '_keys'):\n cls._keys = {val['name'] : keys}\n else:\n cls._keys[val['name']] = keys","def AddMapEntryMatcherFlagsToParser(parser):\n is_primary_flag = base.Argument(\n '--set-primary',\n help='The certificate will be used as the default cert if no other certificate in the map matches on SNI.',\n action='store_true')\n hostname_flag = base.Argument(\n '--hostname',\n help='A domain name (FQDN), which controls when list of certificates specified in the resource will be taken under consideration for certificate selection.'\n )\n group = base.ArgumentGroup(\n help='Arguments to configure matcher for the certificate map entry.',\n required=True,\n mutex=True,\n category=base.COMMONLY_USED_FLAGS)\n group.AddArgument(is_primary_flag)\n group.AddArgument(hostname_flag)\n group.AddToParser(parser)","def generate_from_keyed_source(self, keyed_source, key):\n\n for item in keyed_source:\n line = item[key]\n self.item_lookup[line] = item\n poem = self.add_line(line)\n if poem:\n yield tuple(self.item_lookup[k] for k in poem)","def __init__(self, *args):\n self.args = args\n self.matchers = []\n for a in args:\n if a is _:\n a = lambda k: True\n elif isinstance(a, basestring):\n a = a.__eq__\n elif isinstance(a, (list, tuple, set)):\n a = (lambda ary: (lambda k: k in ary))(a)\n elif hasattr(a, 'search'):\n a = a.search\n else:\n a = str(a).__eq__\n self.matchers.append(a)","def test_fields_to_dict(self):\r\n test_data = \\\r\n \"\"\"0\tR27DLI_4812\tR27DLI_600\tR27DLI_727\tU1PLI_403\tU1PLI_8969\tU1PLI_9080\tU1PLI_9526\tW3Cecum_6642\tW3Cecum_8992\r\n1\tU1PLI_7889\r\n2\tW3Cecum_4858\r\n3\tR27DLI_3243\tR27DLI_4562\tR27DLI_6828\tR27DLI_9097\tU1PLI_2780\tU1PLI_67\tU9PSI_10475\tU9PSI_4341\tW3Cecum_5191\"\"\".splitlines() # output from cd-hit\r\n obs = fields_to_dict(test_data)\r\n exp = {\r\n '0': ['R27DLI_4812', 'R27DLI_600', 'R27DLI_727', 'U1PLI_403',\r\n 'U1PLI_8969', 'U1PLI_9080', 'U1PLI_9526', 'W3Cecum_6642', 'W3Cecum_8992'],\r\n '1': ['U1PLI_7889'],\r\n '2': ['W3Cecum_4858'],\r\n '3': ['R27DLI_3243', 'R27DLI_4562', 'R27DLI_6828', 'R27DLI_9097', 'U1PLI_2780', 'U1PLI_67', 'U9PSI_10475', 'U9PSI_4341', 'W3Cecum_5191']}\r\n self.assertEqual(obs, exp)","def check_keys(self):","def test_init_hash(self):\n bill = Bill(self.input_hash)\n for key, value in self.input_hash.iteritems():\n self.assertEqual(value, bill.__dict__[key])","def parse_record(self, record):\n data = defaultdict(list)\n\n for trait, parser in self.parsers:\n for field_name in self.search_fields:\n field = record.get(field_name)\n if not field:\n continue\n parsed = parser.parse(field, field_name)\n if parsed:\n data[trait] += parsed\n\n return data","def __init__(self, **fields):\r\n \r\n self._by_number = []\r\n self._names = []\r\n self._by_name = {}\r\n self._numbers = {}\r\n \r\n for name in sorted(fields.keys()):\r\n self.add(name, fields[name])","def __init__(self, aKey):\n self.key = aKey\n\n # CRC can be used to validate a key (very roughly)\n # if you store the CRC from a previous keyword\n # and then compare with a newly generated one and\n # they are the same then chances are the keyword\n # is correct - only a single byte so not that reliable\n self.crc = 0 \n for x in self.key:\n intX = ord(x)\n self.crc = self.crc ^ intX","def test_initialize_log_data(self):\r\n\r\n ids_bcs_added_field = {('AAAA', ''): 's1', ('TTTT', ''): 's2'}\r\n actual_log_data = initialize_log_data(ids_bcs_added_field)\r\n\r\n expected_log_data = {'TTTT,s2': 0, 'AAAA,s1': 0}\r\n\r\n self.assertEqual(actual_log_data, expected_log_data)\r\n\r\n # Handles added demultiplex field data\r\n ids_bcs_added_field = {('AAAA', '1'): 's1', ('TTTT', '2'): 's2'}\r\n actual_log_data = initialize_log_data(ids_bcs_added_field)\r\n\r\n expected_log_data = {'TTTT,2,s2': 0, 'AAAA,1,s1': 0}\r\n\r\n self.assertEqual(actual_log_data, expected_log_data)","def _update_key(cls, spec):\n if cls.KEY is not None:\n cls._set_key(spec, spec[\"keys\"].popleft())\n elif cls.REF is not None:\n spec[\"ref\"] = cls.REF","def _make_key(self):\n all_position_values = (chromosome_sort_key(self.chromosome), self.min_position, self.max_position, \n self.strand, self.position_before, self.position_after)\n return all_position_values","def subStringMatchExact(target,key):\r\n index = find(target,key)\r\n #print 'here',target,key,index\r\n if index < 0 or len(key) <= 0 or len(target) <= 0:\r\n return ()\r\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\r\n offset = index + len(key)\r\n temp_matches = ()\r\n #print matches\r\n if matches:\r\n for x in range(0, len(matches)) :\r\n temp_matches += ((matches[x] + offset),)\r\n #matches.insert(0,index)\r\n temp_matches = (index,) + temp_matches\r\n return temp_matches","def test_build_similar_keys_list():\n from FindSimilarIncidentsV2 import build_incident_fields_query\n\n int_res = build_incident_fields_query({u'sla': 0})\n assert int_res == ['sla:=0']\n\n str_res = build_incident_fields_query({u'employeeid': u'1111'})\n assert str_res == [u'employeeid=\"1111\"']\n\n list_res = build_incident_fields_query({u'test': [u'name1', 0]})\n assert list_res == [u'test=\"name1\"', 'test:=0']\n\n list_res = build_incident_fields_query({u'test': []})\n assert list_res == ['test=[]']\n\n escape_res = build_incident_fields_query({u'test': u'\"C:\\\\test\\\\escape\\\\sequence\" test'})\n assert escape_res == [u'test=\"\\\\\"C:\\\\test\\\\escape\\\\sequence\\\\\" test\"']","def __init__(self, key):\n\n def keys(key, num_rounds):\n \"\"\"Yields the permuted key bitstring for i = 1..num_rounds\"\"\"\n C, D = key[:28], key[28:]\n # Rounds are 1-indexed, so shift array over by one\n left_shifts = [None, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]\n for i in range(1, num_rounds + 1):\n # Negate each rotation to rotate left.\n C, D = rotate(C, -left_shifts[i]), rotate(D, -left_shifts[i])\n yield self.permute(C + D, self._CD_permutation)\n\n self.key = list(bits_of(key, 64))\n # Permute the key. The permutation discards the parity bits...\n self.key = self.permute(self.key, self._key_permutation)\n self.number_of_rounds = 16\n # A list of the 16 keys K1 .. K16, shifted over by one to allow 1-indexing.\n self.keys = [None] + list(keys(self.key, self.number_of_rounds))","def keysWhichMatch(cls, *args):\n if len(cls.keys) < len(args) > 0:\n raise ValueError('Number of keys provided is too long.\\n'\n 'Len Class Keys: %s\\n'\n 'Len Provided Keys: %s\\n' % (len(cls.keys), len(args)))\n\n index = 0\n output = cls.db_key_tuples()\n\n for keyToCheck in args:\n temp = []\n for key in output:\n if key[index] == keyToCheck:\n temp.append(key)\n\n index += 1\n output = temp\n\n return output","def test_init_with_field_dict(self):\n fields = {\n 'Column 1': 'a=${aaa}',\n 'Column 2': 'b=${bbb}',\n 'Column 3': 'c=${ccc}',\n }\n csv_formatter = CSVFormatter(fields=fields)\n csv = csv_formatter.format_records(self.records)\n\n csv_expected = textwrap.dedent(\"\"\"\\\n #Column 1,Column 2,Column 3\n a=foobar_01,b=8,c=4898FE19\n a=foobar_02,b=160,c=5825D187\n a=foobar_03,b=99,c=3648A436\n \"\"\")\n\n assert csv == csv_expected","def current_source_key(self, match):\n raise NotImplementedError","def init(self, datasetInfo):\n #use user's dataset directory if not specified\n if datasetInfo is None: raise RecognizerError(\"No dataset file specified.\")\n \n if os.path.isfile(datasetInfo):\n datasetInfos = [datasetInfo]\n elif os.path.isdir(datasetInfo):\n datasetInfos = [os.path.join(datasetInfo, f) for f in os.listdir(datasetInfo) \\\n if f.endswith('.xml')]\n elif isinstance(datasetInfo, (types.ListType, types.TupleType)):\n datasetInfos = datasetInfo\n else: raise RecognizerError, \"Unknown datasetInfo type: %s\" % type(datasetInfo)\n \n patterns = {}; startsWiths = []; matchers = {}\n for f in datasetInfos:\n info, ns = getXmlEtree(f)\n if not ns.has_key('_'): ns['_'] = ns['_default']\n for dataset in info:\n \n #skip if comment\n if isinstance(dataset, lxml.etree._Comment): continue\n \n ipath = xpath(dataset, './/_:ipath/text()', ns)\n fileTemplate = xpath(dataset, './/_:fileTemplate/text()', ns)\n startsWith = fileTemplate[0:fileTemplate.index('$')]\n filePattern = xpath(dataset, './/_:filePattern/text()', ns)\n if matchers.has_key(startsWith):\n matchers[startsWith].append((re.compile(filePattern), ipath, dataset, ns))\n else: matchers[startsWith] = [(re.compile(filePattern), ipath, dataset, ns)]\n if startsWith != '': startsWiths.append(startsWith)\n startsWithPattern = r'(' + '|'.join(startsWiths) + ')'\n startsWithMatcher = re.compile(startsWithPattern)\n return startsWithMatcher, matchers","def __init__(__self__, *,\n key: pulumi.Input[str],\n values: pulumi.Input[Sequence[pulumi.Input[str]]]):\n pulumi.set(__self__, \"key\", key)\n pulumi.set(__self__, \"values\", values)","def create_mock_key_provider(key_list):\n public_keys = {}\n for k in key_list:\n public_keys[k] = {'Fingerprint': k,\n 'Value': 'ffaa00'}\n key_provider = mock.Mock()\n key_provider.get_public_keys.return_value = public_keys\n return key_provider","def filter_record_keys(record_list, whitelist_keys):\n\n filtered = [{k: v for k, v in [y for y in list(x.items()) if y[0] in whitelist_keys]} for x in record_list]\n return filtered","def __init__(self, key):\n Base.__init__(self, key)","def __init__(self, key):\n Base.__init__(self, key)","def test_mutate_field(self):\n # Test adding a field\n with self.assertRaises(ValueError):\n self.email.add_field('', '')\n\n self.email.add_field(self.key, self.regex)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertTrue(found_key)\n self.assertEqual(found_regex, self.regex)\n\n # Test getting a field\n with self.assertRaises(LookupError):\n self.email.get_field('')\n\n field = self.email.get_field(self.key)\n self.assertEqual(\n field, {'key': self.key, 'regex': self.regex, 'value': []})\n\n # Test removing a field\n with self.assertRaises(LookupError):\n self.email.remove_field('')\n\n self.email.remove_field(self.key)\n\n found_key = False\n found_regex = r''\n for field in self.email.fields:\n if field['key'] == self.key:\n found_key = True\n found_regex = field['regex']\n\n self.assertFalse(found_key)\n self.assertNotEqual(found_regex, self.regex)","def make_consistent(self):\r\n\r\n for key in self.get_keys():\r\n self.eliminate_key(key)\r\n\r\n for i_temp in self.indexes(): #i will be a note index\r\n for j_temp in self.get_keys_from_note(i_temp):\r\n if self.key_dict_contains(j_temp):\r\n self.add_key(j_temp,Index(i_temp))\r\n## self.key_dict[j_temp].add(str(Index(i_temp)))\r\n else:\r\n self.initiate_new_key(j_temp,Index(i_temp))","def make_fromkey(self, key):\n if key != '':\n def make_runable(match):\n return \"self.components['\" + match.group(0) + \"']\"\n\n runable = re.sub('[^\\(\\)|& ]+', make_runable, key)\n return eval(runable)\n else:\n return ~np.zeros(self.size, dtype=bool)","def build_match_clause(field, string):\r\n answer = {}\r\n tmp = {}\r\n tmp[field] = string\r\n answer['match'] = tmp\r\n return answer","def _newKey(self, key):\n pass","def __init__(self, keys_to_track):\r\n self.keys_to_track = keys_to_track\r\n self.tracker = {}\r\n for key_to_track in self.keys_to_track:\r\n self.tracker[key_to_track] = {}","def test_keyword_extractor(self):\n data = [{\"Header\": \"This is a Header\", \"Paragraph\": \"This is a Paragraph\", \"slide\": 10}]\n keywords = keyword_extractor(data)\n data[0][\"Header_keywords\"] = [\"header\"]\n data[0][\"Paragraph_keywords\"] = [\"paragraph\"]\n self.assertEqual(keywords, data)","def _build_mysql_dict(self, user_list):\n return_dict = {}\n for user in user_list:\n user_key = self._make_match_key(firstname=user['firstname'],\n lastname=user['lastname'])\n assert user_key not in return_dict\n return_dict[user_key] = {'mysql_user': user,\n 'friven_matched_users': []\n }\n return return_dict","def _convert(self, dictlike):\n for incoming_key, valuelist in util.dictlike_iteritems(dictlike):\n for value in valuelist:\n new_key = self.keyfunc(value)\n if incoming_key != new_key:\n raise TypeError(\n \"Found incompatible key %r for value %r; this \"\n \"collection's \"\n \"keying function requires a key of %r for this value.\" % (\n incoming_key, value, new_key))\n yield value","def key_by(self, field: str) -> B[B, E]:\n pass","def _initialize_parser_keys(self):\n self.parser.source_role_marker = TRANSFER_ROLES.SOURCE\n self.parser.target_role_marker = TRANSFER_ROLES.TARGET\n rack_shape_agg = get_root_aggregate(IRackShape)\n rack_shape_agg.filter = None\n self.parser.allowed_rack_dimensions = [(rs.number_rows,\n rs.number_columns)\n for rs in rack_shape_agg]"],"string":"[\n \"def match_source_key(self, match):\\n raise NotImplementedError\",\n \"def __init__(self):\\n self.key_to_record = {}\\n self.mutation_to_key = {}\\n self._innovation_key_generator = count(0)\",\n \"def test_toofewkeys(self):\\n self.assertRaises(recordparser.KeyListMismatchError,\\n recordparser.getfields, \\\"1234567890\\\", \\\"10s\\\", ())\",\n \"def init_record_fields(self, run_record_key, record_fields):\\n\\n record_fields_grp = self.settings_grp[RECORD_FIELDS]\\n\\n # make a dataset for the sparse fields allowed. this requires\\n # a 'special' datatype for variable length strings. This is\\n # supported by HDF5 but not numpy.\\n vlen_str_dt = h5py.special_dtype(vlen=str)\\n\\n # create the dataset with the strings of the fields which are records\\n record_group_fields_ds = record_fields_grp.create_dataset(run_record_key,\\n (len(record_fields),),\\n dtype=vlen_str_dt,\\n maxshape=(None,))\\n\\n # set the flags\\n for i, record_field in enumerate(record_fields):\\n record_group_fields_ds[i] = record_field\",\n \"def initialize(self, keys: List[str]):\",\n \"def _make_match_key(self, firstname, lastname):\\n return \\\"{}::{}\\\".format(firstname.lower().strip(), lastname.lower().strip())\",\n \"def test_toomanykeys(self):\\n self.assertRaises(recordparser.KeyListMismatchError,\\n recordparser.getfields, \\\"1234567890\\\", \\\"10s\\\", (\\\"key1\\\", \\\"key2\\\"))\",\n \"def init_by_keys(cls, **query):\\n raise NotImplementedError()\",\n \"def gen_keys():\",\n \"def __init__(self, matcher, generate):\\n self.matcher = matcher\\n self._generate = generate\",\n \"def __init__(self, key):\\n self.key = [int_mapping(k) for k in key]\",\n \"def buildFromRecords(self, records):\\n probes = {}\\n for record in records:\\n fields = {}\\n for field in record.split(self.FIELD_DELIMITER):\\n index = field.find(self.KEY_VALUE_DELIMITER)\\n if index == -1 or len(field) < (index+1):\\n raise InvariantViloation('detected invalid probe record in app info file - {}'.format(record))\\n fields.update({field[:index]:field[index+1:]})\\n if fields:\\n try:\\n fields[self.FIELD_FILE] = self.trimWorkspace(fields[self.FIELD_FILE], self.workspace)\\n probes.update({\\n fields[self.FIELD_RECORDER_RETURN_SITE] : AnchoredProbe(\\n fields[self.FIELD_NAME], fields[self.FIELD_FILE], fields[self.FIELD_LINE],\\n fields[self.FIELD_ATTRIBUTES], fields[self.FIELD_STATUS] == self.PROBE_STATUS_ENABLED,\\n fields[self.FIELD_NAME]\\n )\\n })\\n except KeyError as error:\\n raise InvariantViloation('detected record missing field {} - \\\\n{}\\\\n{}'.format(error, record, fields))\\n return probes\",\n \"def train_test_split(record_dictionary, ratio=.5):\\n\\n num_training_records = int(len(record_dictionary) * ratio)\\n\\n keys = list(record_dictionary.keys())\\n\\n training_records = np.random.choice(\\n keys, num_training_records, replace=False)\\n testing_records = [key for key in keys if key not in training_records]\\n\\n training_dictionary = {\\n record: record_dictionary[record]\\n for record in training_records\\n }\\n testing_dictionary = {\\n record: record_dictionary[record]\\n for record in testing_records\\n }\\n\\n return training_dictionary, testing_dictionary\",\n \"def test_invalid_key_gen(self):\\r\\n expected = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\\r\\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\\r\\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\\r\\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\\r\\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'}}\\r\\n data = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\\r\\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\\r\\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\\r\\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\\r\\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'},\\r\\n 5: {'ID': 'A233', 'Ge1nder': 'F', 'Age': '62', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}}\\r\\n result = Validator.save_dict(data)\\r\\n self.assertDictEqual(expected, result)\",\n \"def harmonize_keys(self):\\n self._data.key_regex_replacements = _key_regex_replacements\\n self._data.key_replacements = _key_replacements\",\n \"def _make_key(self, record_dict: Dict[str, Any]) -> int:\\n return self._keys.setdefault(frozenset(record_dict.keys()), len(self._keys))\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: \\\"Topology\\\",\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[\\n Union[TopologyKey, LibraryChargeTopologyKey],\\n PotentialKey,\\n ] = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n topology_key = TopologyKey(atom_indices=key)\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n if self.__class__.__name__ in [\\n \\\"SMIRNOFFBondCollection\\\",\\n \\\"SMIRNOFFAngleCollection\\\",\\n ]:\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n assigned_terms=matches,\\n topology=topology,\\n valence_terms=valence_terms,\\n )\",\n \"def test_keys(self):\\n storage = Storage()\\n keys_to_set = {'1': 'hello',\\n '2': 'bye',\\n '3': [1, 2, 'three'],\\n '4': {1: 'one', 2: 'two'},\\n 'a': 1,\\n 'aa': 2,\\n 'abc':3,\\n 'hello':4}\\n for key in keys_to_set:\\n storage.set(key, keys_to_set[key])\\n\\n pattern_answers = {'?': ['1','2','3','4','a'],\\n '*': list(keys_to_set.keys()),\\n '[13]': ['1', '3'],\\n '[^a]': ['1','2','3','4'],\\n '[1-3]': ['1','2','3'],\\n '?[ae]*': ['aa', 'hello']}\\n for pattern in pattern_answers:\\n self.assertEqual(pattern_answers[pattern],\\n storage.keys(pattern), f'For pattern \\\"{pattern}\\\" expected {pattern_answers[pattern]}.')\",\n \"def __init__(self):\\n self._keys = []\\n self._sortKeys = []\",\n \"def key_lookup_batch(self, batchiter):\\n pass\",\n \"def create_matcher(self):\\n self.matcher = None\\n if \\\"matcher\\\" in self.config:\\n self.matcher = matcher.Matcher(self.config[\\\"matcher\\\"])\\n else:\\n self.matcher = matcher.TrueMatcher()\\n \\n self.use_fields_for_id = []\\n if \\\"matcherfield\\\" in self.config:\\n self.use_fields_for_id = self.config[\\\"matcherfield\\\"].split(\\\",\\\")\\n \\n if \\\"clear\\\" in self.config:\\n self.clear_matcher = matcher.Matcher(self.config[\\\"clear\\\"])\\n self.autoclear = self.auto_acknowledge\\n else:\\n self.clear_matcher = matcher.FalseMatcher()\\n self.autoclear = False\",\n \"def store_matches(\\n self,\\n parameter_handler: ParameterHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n # TODO: Should the key_map always be reset, or should we be able to partially\\n # update it? Also Note the duplicated code in the child classes\\n self.key_map: dict[BondKey, PotentialKey] = dict() # type: ignore[assignment]\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n param = val.parameter_type\\n if param.k_bondorder or param.length_bondorder:\\n bond = topology.get_bond_between(*key)\\n fractional_bond_order = bond.fractional_bond_order\\n if not fractional_bond_order:\\n assert self._get_uses_interpolation(parameter_handler)\\n raise RuntimeError(\\n \\\"Bond orders should already be assigned at this point\\\",\\n )\\n else:\\n fractional_bond_order = None\\n topology_key = BondKey(\\n atom_indices=key,\\n bond_order=fractional_bond_order,\\n )\\n\\n potential_key = PotentialKey(\\n id=val.parameter_type.smirks,\\n associated_handler=parameter_handler.TAGNAME,\\n bond_order=fractional_bond_order,\\n )\\n self.key_map[topology_key] = potential_key\\n\\n valence_terms = self.valence_terms(topology)\\n\\n _check_all_valence_terms_assigned(\\n handler=parameter_handler,\\n topology=topology,\\n assigned_terms=matches,\\n valence_terms=valence_terms,\\n )\",\n \"def lookup(self, key):\",\n \"def __init__(self):\\n super(KeyIterator, self).__init__()\\n self.iterator = self.ValueIterator()\",\n \"def clean_up(self) -> None:\\n self.single_device_matches = collections.defaultdict(\\n lambda: collections.defaultdict(list)\\n )\",\n \"def __init__(self, compound_matcher):\\n self._matcher = compound_matcher\",\n \"def find_records(self, check, keys=None):\\n matches = self._match(check)\\n if keys:\\n return [self._extract_subdict(rec, keys) for rec in matches]\\n else:\\n return matches\",\n \"def __init__(self):\\n # map of (key, index in list)\\n self.map = dict()\\n \\n # list of keys for random selection\\n self.keys = []\",\n \"def test_keys_eq(self):\\n self.assertListEqual(self.result, self.expected)\",\n \"def _rebuild_comparedict(self,\\n result,\\n rewrapped_columns,\\n columns,\\n rewrapped_keys,\\n keys,\\n missing_col):\\n normalize = lambda x: x if (isinstance(x, str) or not x) else tuple(x)\\n rewrapped_columns = normalize(rewrapped_columns)\\n rewrapped_keys = normalize(rewrapped_keys)\\n columns = normalize(columns)\\n keys = normalize(keys)\\n\\n if rewrapped_keys == keys and rewrapped_columns == columns:\\n if isinstance(result, CompareDict):\\n key_names = (keys,) if isinstance(keys, str) else keys\\n result.key_names = key_names\\n return result # <- EXIT!\\n\\n try:\\n item_gen = iter(result.items())\\n except AttributeError:\\n item_gen = [(self._missing, result)]\\n\\n if rewrapped_keys != keys:\\n def rebuild_keys(k, missing):\\n if isinstance(keys, str):\\n return k\\n key_dict = dict(zip(rewrapped_keys, k))\\n return tuple(key_dict.get(c, missing) for c in keys)\\n missing_key = self._missing\\n item_gen = ((rebuild_keys(k, missing_key), v) for k, v in item_gen)\\n\\n if rewrapped_columns != columns:\\n def rebuild_values(v, missing):\\n if isinstance(columns, str):\\n return v\\n if not nonstringiter(v):\\n v = (v,)\\n value_dict = dict(zip(rewrapped_columns, v))\\n return tuple(value_dict.get(v, missing) for v in columns)\\n item_gen = ((k, rebuild_values(v, missing_col)) for k, v in item_gen)\\n\\n return CompareDict(item_gen, key_names=keys)\",\n \"def test_keys(self):\\n obs = self.tester.keys()\\n self.assertTrue(isinstance(obs, Iterable))\\n self.assertEqual(set(obs), self.exp_sample_ids)\",\n \"def test_keys(self):\\n obs = self.tester.keys()\\n self.assertTrue(isinstance(obs, Iterable))\\n self.assertEqual(set(obs), self.exp_sample_ids)\",\n \"def get_potential_matches_from_record(self, record):\\n\\n #Query against the con to the sqlite database\\n def get_potential_matches(sub_tokens):\\n\\n search_tokens = \\\" \\\".join(sub_tokens)\\n SQL = self.get_records_sql.format(search_tokens, self.max_results)\\n df = pd.read_sql(SQL,self.target_con)\\n return df\\n\\n tokens_orig = record.tokens_original_order\\n tokens_ordered = record.tokens_specific_to_general_by_freq\\n df_all = pd.DataFrame()\\n\\n\\n for tokens in [tokens_orig, tokens_ordered]:\\n for i in range(len(tokens)):\\n\\n sub_tokens = tokens[i:]\\n if len(sub_tokens)<2:\\n df= pd.DataFrame()\\n break\\n\\n df = get_potential_matches(sub_tokens)\\n\\n if len(df)>0 and len(df)<self.max_results:\\n df_all = pd.concat([df_all, df])\\n break\\n if len(df_all) > 0:\\n df_all = df_all.drop_duplicates(\\\"auto_generated_row_id\\\")\\n\\n return self.df_to_record_objects(df_all)\",\n \"def setUp(self):\\n # $TODO - expand supported field types\\n # NOTE: For the purposes of this test, don't expect to compare 'f'-type\\n # floats! The precision conversion using struct.pack -> struct.unpack\\n # is problematic! Use 'd' instead because Python floats are actually\\n # C-doubles. Use '=d' if necessary.\\n int1 = -10\\n uint1 = 20\\n string1 = \\\"This is a string\\\" # pack this as a 30-byte string\\n char1 = \\\"J\\\"\\n short1 = 0\\n float1 = 5.23\\n double1 = -256.3456789107\\n ushort1 = 5\\n string2 = \\\"This is another string\\\" # pack this as a 30-byte string\\n long1 = 2147483647\\n ulong1 = 3000000000\\n\\n # Use the fields above in this order.\\n self.fieldmap = \\\"iI30schddH30slL\\\"\\n self.sourcekeys = (\\\"int1\\\", \\\"uint1\\\", \\\"string1\\\", \\\"char1\\\", \\\"short1\\\",\\n \\\"float1\\\", \\\"double1\\\", \\\"ushort1\\\", \\\"string2\\\", \\\"long1\\\", \\\"ulong1\\\")\\n\\n # Create the raw data that getfields will parse\\n self.rawdata = struct.pack(self.fieldmap, int1, uint1, string1, char1,\\n short1, float1, double1, ushort1, string2, long1, ulong1)\\n\\n # This is what getfields should return\\n self.knownvalues = {\\\"char1\\\":char1, \\\"short1\\\":short1, \\\"ushort1\\\":ushort1,\\n \\\"int1\\\":int1, \\\"uint1\\\":uint1, \\\"long1\\\":long1, \\\"ulong1\\\":ulong1,\\n \\\"float1\\\":float1, \\\"double1\\\":double1, \\\"string1\\\":string1,\\n \\\"string2\\\":string2}\",\n \"def create_match(self, parser, fields):\\n match = parser.OFPMatch()\\n for (field, value) in fields.iteritems():\\n match.append_field(field, value)\\n return match\",\n \"def __init__(self):\\n self.key2value = {}\\n self.key2time = {}\",\n \"def secondary_keys_dicts(self):\",\n \"def store_matches(\\n self,\\n parameter_handler: ImproperTorsionHandler,\\n topology: Topology,\\n ) -> None:\\n if self.key_map:\\n self.key_map = dict()\\n matches = parameter_handler.find_matches(topology)\\n for key, val in matches.items():\\n parameter_handler._assert_correct_connectivity(\\n val,\\n [\\n (0, 1),\\n (1, 2),\\n (1, 3),\\n ],\\n )\\n n_terms = len(val.parameter_type.k)\\n for n in range(n_terms):\\n smirks = val.parameter_type.smirks\\n non_central_indices = [key[0], key[2], key[3]]\\n\\n for permuted_key in [\\n (\\n non_central_indices[i],\\n non_central_indices[j],\\n non_central_indices[k],\\n )\\n for (i, j, k) in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]\\n ]:\\n topology_key = ImproperTorsionKey(\\n atom_indices=(key[1], *permuted_key),\\n mult=n,\\n )\\n potential_key = PotentialKey(\\n id=smirks,\\n mult=n,\\n associated_handler=\\\"ImproperTorsions\\\",\\n )\\n self.key_map[topology_key] = potential_key\",\n \"def test_fromkeys(self):\\n d = SplayDict.fromkeys(['a', 'b', 'c'], 1)\\n self.assertIn('a' , d)\\n self.assertIn('b' , d)\\n self.assertIn('c' , d)\\n self.assertEqual(d['a'] , 1)\\n self.assertEqual(d['b'] , 1)\\n self.assertEqual(d['c'] , 1)\",\n \"def __init__(self, map):\\n self.map = map\\n self._map = _map = {}\\n for key in map.keys():\\n _map[key] = key\\n self.fast_validate = (10, _map, self.validate)\",\n \"def setup_known_fields(self):\\n\\n kfields = dict(self.known_fields)\\n freg = re.compile(r\\\"(^.+)_\\\\d+$\\\")\\n for field in self:\\n if self[field].get(\\\"units\\\") is not None:\\n continue\\n\\n if field in kfields:\\n self[field][\\\"units\\\"] = kfields[field]\\n continue\\n\\n fs = freg.search(field)\\n if fs and fs.groups()[0] in kfields:\\n self[field][\\\"units\\\"] = kfields[fs.groups()[0]]\",\n \"def _match(self, check):\\n matches = []\\n tests = {}\\n for k, v in check.items():\\n if isinstance(v, dict):\\n tests[k] = CompositeFilter(v)\\n else:\\n tests[k] = lambda o: _add_tz(o) == _add_tz(v)\\n\\n for rec in self._records.values():\\n if self._match_one(rec, tests):\\n matches.append(deepcopy(rec))\\n return matches\",\n \"def prepare_key (self, key, for_seq):\\n r_key = \\\"%s:%d:%s\\\" % (self.classkey, for_seq, key)\\n return r_key\",\n \"def _init_run_records_field(self, run_idx, run_record_key,\\n field_name, field_shape, field_dtype):\\n\\n record_grp = self.run(run_idx)[run_record_key]\\n\\n # check if it is variable length\\n if field_shape is Ellipsis:\\n # make a special dtype that allows it to be\\n # variable length\\n vlen_dt = h5py.special_dtype(vlen=field_dtype)\\n\\n # this is only allowed to be a single dimension\\n # since no real shape was given\\n dset = record_grp.create_dataset(field_name, (0,), dtype=vlen_dt,\\n maxshape=(None,))\\n\\n # its not just make it normally\\n else:\\n # create the group\\n dset = record_grp.create_dataset(field_name, (0, *field_shape), dtype=field_dtype,\\n maxshape=(None, *field_shape))\\n\\n return dset\",\n \"def construct_kv_dict(self):\\r\\n key1 = self.key_factory('existing_field')\\r\\n key2 = self.key_factory('other_existing_field')\\r\\n new_value = 'new value'\\r\\n newer_value = 'newer value'\\r\\n return {key1: new_value, key2: newer_value}\",\n \"def __init_matcher(self):\\n\\t\\tmatcher = Matcher()\\n\\t\\tmatcher.set_mentors(self.mentors.find())\\n\\t\\tmatcher.set_migrants(self.migrants.find())\\n\\t\\tprint(matcher.migrants)\\n\\t\\t\\n\\t\\treturn matcher\",\n \"def __init__(self):\\n self.ds = set()\\n self.keys = []\",\n \"def _prepare_keys(self, keys):\\n # sorting is guaranteed to enable comparisons throughout the class\\n for key in keys:\\n key.sort()\\n\\n # ensure no overlap with the primary key\\n if self._primary_key in keys:\\n keys.remove(self._primary_key)\\n\\n return keys\",\n \"def __init__(self, *values):\\n if (len(values) == 1) and (type(values[0]) in SequenceTypes):\\n values = values[0]\\n self.values = values[:]\\n self.values_ = values_ = {}\\n for key in values:\\n values_[key] = key\\n self.fast_validate = (10, values_, self.validate)\",\n \"def __init__(self, *args, **kwargs):\\n defaultdict.__init__(self)\\n self.sortedkeys = None\",\n \"def reinit (self):\\n #for name, obj in inspect.getmembers (self):\\n ## if isinstance (obj, RField):\\n # self.keyvals[name] = obj.default\\n inspect.getmembers (self)\",\n \"def __init__(self, key):\\n self.key = key\",\n \"def from_items(cls, items):\\n new_match = Match()\\n new_match.fields = [None] * len(cls.indices)\\n for key, val in items:\\n try:\\n idx = cls.name_to_idx[key]\\n new_match.fields[idx] = cls.conversions_to_bin[idx](val)\\n except:\\n # unknown values\\n pass\\n return new_match\",\n \"def _match(self) -> None:\\n self.matched = [i for i in self.data if self.match(i)]\\n self.unmatched = [i for i in self.data if not self.match(i)]\",\n \"def __init__(self,\\n allowRepetition):\\n self.__fileName = \\\"\\\"\\n self.__allowRepetition = allowRepetition\\n self.__keyObjs = {}\\n self.__keyList = []\\n self.__keyCount = {}\\n self.__trailer = []\",\n \"async def build_key(self):\\n self.key = self.update_key()\\n search_key_result = await self.redis.keys(self.key)\\n if len(search_key_result) == 1:\\n self.key = search_key_result[0]\\n if self.id == \\\"*\\\":\\n self.id = self.key.split(':')[0]\\n if self.value == \\\"*\\\":\\n self.value = self.key.split(':')[-1]\\n return True\",\n \"def data_comparison(observations, records, record):\\n for observation in observations:\\n if observation != \\\"_id\\\":\\n try:\\n if re.search(observation, f\\\"{records[record]}\\\"):\\n if not re.search(\\n observations[observation], f\\\"{records[record]}\\\"\\n ):\\n records[record] = (\\n f\\\"{records[record]}\\\"\\n + \\\" --> \\\"\\n + observations[observation]\\n )\\n except Exception as ex:\\n Common.logger.warning(f\\\"Exception happened in data comparison {ex}\\\")\\n return records\",\n \"def _eq_key(self):\\n return (\\n self.message_type,\\n self.topic,\\n self.schema_id,\\n self.payload,\\n self.uuid,\\n self.timestamp,\\n self.upstream_position_info,\\n self.kafka_position_info,\\n self.dry_run,\\n self.encryption_type\\n )\",\n \"def MakeKey(self, string, string_1, string_2):\\n ...\",\n \"def __init__ (self, id, finder, matches):\\n\\t\\tself.id = id\\n\\t\\t# self.inCitesName = fullname\\n\\t\\tfor attr in ['fullname', 'firstName', 'middleName', 'lastName', 'note']:\\n\\t\\t\\tsetattr (self, attr, getattr (finder, attr))\\n\\t\\tself.matches = matches\\n\\t\\tself.numMatches = len(matches)\",\n \"def __init__(self, replacer, lookup, field=1, skipper=None):\\n if isinstance(replacer, str):\\n replacer = re.compile(replacer)\\n if isinstance(skipper, str):\\n skipper = re.compile(skipper)\\n\\n if not replacer.groups:\\n raise DictReplacerError(\\\"Invalid replacer pattern: no groups \\\"\\n \\\"specified - '%s'\\\" % replacer.pattern)\\n\\n self._replacer = replacer\\n self._lookup = lookup\\n self._field = field\\n self._skipper = skipper\",\n \"def test_invalid_key_ID(self):\\r\\n expected = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\\r\\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\\r\\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\\r\\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\\r\\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'}}\\r\\n data = {1: {'ID': 'A233', 'Gender': 'M', 'Age': '22', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}, 2: {'ID': 'A244', 'Gender': 'M', 'Age': '30', 'Sales': '666',\\r\\n 'BMI': 'Underweight', 'Salary': '23', 'Birthday': '05-05-1988'},\\r\\n 3: {'ID': 'A253', 'Gender': 'M', 'Age': '35', 'Sales': '456', 'BMI': 'Obesity', 'Salary': '23',\\r\\n 'Birthday': '01-08-1983'}, 4: {'ID': 'A262', 'Gender': 'M', 'Age': '24', 'Sales': '999',\\r\\n 'BMI': 'Normal', 'Salary': '23', 'Birthday': '24-05-1993'},\\r\\n 5: {'kjhID': 'A233', 'Gender': 'F', 'Age': '62', 'Sales': '245', 'BMI': 'Normal', 'Salary': '23',\\r\\n 'Birthday': '24-06-1995'}}\\r\\n result = Validator.save_dict(data)\\r\\n self.assertDictEqual(expected, result)\",\n \"def test_normal_fields_can_be_defined_between_primary_keys(self):\",\n \"def process_data(self):\\n num_records = len(self.records_data)\\n for i in range(len(self.keys)):\\n student_key = self.keys[i]\\n if (i < num_records):\\n self._load_student_record(student_key,\\n self.records_data[i])\",\n \"def set_keys(cls, val):\\n keys = []\\n check = lambda dict, key, default_val: dict[key] if key in dict.keys() else default_val\\n for i in range(val['row_max']):\\n keys.append([check(val, '{}_{}'.format(x, y), cls.NOTAVAILABLE) \\\\\\n for x, y in list(product([i], list(range(val['col_max']))))])\\n if not hasattr(cls, '_keys'):\\n cls._keys = {val['name'] : keys}\\n else:\\n cls._keys[val['name']] = keys\",\n \"def AddMapEntryMatcherFlagsToParser(parser):\\n is_primary_flag = base.Argument(\\n '--set-primary',\\n help='The certificate will be used as the default cert if no other certificate in the map matches on SNI.',\\n action='store_true')\\n hostname_flag = base.Argument(\\n '--hostname',\\n help='A domain name (FQDN), which controls when list of certificates specified in the resource will be taken under consideration for certificate selection.'\\n )\\n group = base.ArgumentGroup(\\n help='Arguments to configure matcher for the certificate map entry.',\\n required=True,\\n mutex=True,\\n category=base.COMMONLY_USED_FLAGS)\\n group.AddArgument(is_primary_flag)\\n group.AddArgument(hostname_flag)\\n group.AddToParser(parser)\",\n \"def generate_from_keyed_source(self, keyed_source, key):\\n\\n for item in keyed_source:\\n line = item[key]\\n self.item_lookup[line] = item\\n poem = self.add_line(line)\\n if poem:\\n yield tuple(self.item_lookup[k] for k in poem)\",\n \"def __init__(self, *args):\\n self.args = args\\n self.matchers = []\\n for a in args:\\n if a is _:\\n a = lambda k: True\\n elif isinstance(a, basestring):\\n a = a.__eq__\\n elif isinstance(a, (list, tuple, set)):\\n a = (lambda ary: (lambda k: k in ary))(a)\\n elif hasattr(a, 'search'):\\n a = a.search\\n else:\\n a = str(a).__eq__\\n self.matchers.append(a)\",\n \"def test_fields_to_dict(self):\\r\\n test_data = \\\\\\r\\n \\\"\\\"\\\"0\\tR27DLI_4812\\tR27DLI_600\\tR27DLI_727\\tU1PLI_403\\tU1PLI_8969\\tU1PLI_9080\\tU1PLI_9526\\tW3Cecum_6642\\tW3Cecum_8992\\r\\n1\\tU1PLI_7889\\r\\n2\\tW3Cecum_4858\\r\\n3\\tR27DLI_3243\\tR27DLI_4562\\tR27DLI_6828\\tR27DLI_9097\\tU1PLI_2780\\tU1PLI_67\\tU9PSI_10475\\tU9PSI_4341\\tW3Cecum_5191\\\"\\\"\\\".splitlines() # output from cd-hit\\r\\n obs = fields_to_dict(test_data)\\r\\n exp = {\\r\\n '0': ['R27DLI_4812', 'R27DLI_600', 'R27DLI_727', 'U1PLI_403',\\r\\n 'U1PLI_8969', 'U1PLI_9080', 'U1PLI_9526', 'W3Cecum_6642', 'W3Cecum_8992'],\\r\\n '1': ['U1PLI_7889'],\\r\\n '2': ['W3Cecum_4858'],\\r\\n '3': ['R27DLI_3243', 'R27DLI_4562', 'R27DLI_6828', 'R27DLI_9097', 'U1PLI_2780', 'U1PLI_67', 'U9PSI_10475', 'U9PSI_4341', 'W3Cecum_5191']}\\r\\n self.assertEqual(obs, exp)\",\n \"def check_keys(self):\",\n \"def test_init_hash(self):\\n bill = Bill(self.input_hash)\\n for key, value in self.input_hash.iteritems():\\n self.assertEqual(value, bill.__dict__[key])\",\n \"def parse_record(self, record):\\n data = defaultdict(list)\\n\\n for trait, parser in self.parsers:\\n for field_name in self.search_fields:\\n field = record.get(field_name)\\n if not field:\\n continue\\n parsed = parser.parse(field, field_name)\\n if parsed:\\n data[trait] += parsed\\n\\n return data\",\n \"def __init__(self, **fields):\\r\\n \\r\\n self._by_number = []\\r\\n self._names = []\\r\\n self._by_name = {}\\r\\n self._numbers = {}\\r\\n \\r\\n for name in sorted(fields.keys()):\\r\\n self.add(name, fields[name])\",\n \"def __init__(self, aKey):\\n self.key = aKey\\n\\n # CRC can be used to validate a key (very roughly)\\n # if you store the CRC from a previous keyword\\n # and then compare with a newly generated one and\\n # they are the same then chances are the keyword\\n # is correct - only a single byte so not that reliable\\n self.crc = 0 \\n for x in self.key:\\n intX = ord(x)\\n self.crc = self.crc ^ intX\",\n \"def test_initialize_log_data(self):\\r\\n\\r\\n ids_bcs_added_field = {('AAAA', ''): 's1', ('TTTT', ''): 's2'}\\r\\n actual_log_data = initialize_log_data(ids_bcs_added_field)\\r\\n\\r\\n expected_log_data = {'TTTT,s2': 0, 'AAAA,s1': 0}\\r\\n\\r\\n self.assertEqual(actual_log_data, expected_log_data)\\r\\n\\r\\n # Handles added demultiplex field data\\r\\n ids_bcs_added_field = {('AAAA', '1'): 's1', ('TTTT', '2'): 's2'}\\r\\n actual_log_data = initialize_log_data(ids_bcs_added_field)\\r\\n\\r\\n expected_log_data = {'TTTT,2,s2': 0, 'AAAA,1,s1': 0}\\r\\n\\r\\n self.assertEqual(actual_log_data, expected_log_data)\",\n \"def _update_key(cls, spec):\\n if cls.KEY is not None:\\n cls._set_key(spec, spec[\\\"keys\\\"].popleft())\\n elif cls.REF is not None:\\n spec[\\\"ref\\\"] = cls.REF\",\n \"def _make_key(self):\\n all_position_values = (chromosome_sort_key(self.chromosome), self.min_position, self.max_position, \\n self.strand, self.position_before, self.position_after)\\n return all_position_values\",\n \"def subStringMatchExact(target,key):\\r\\n index = find(target,key)\\r\\n #print 'here',target,key,index\\r\\n if index < 0 or len(key) <= 0 or len(target) <= 0:\\r\\n return ()\\r\\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\\r\\n offset = index + len(key)\\r\\n temp_matches = ()\\r\\n #print matches\\r\\n if matches:\\r\\n for x in range(0, len(matches)) :\\r\\n temp_matches += ((matches[x] + offset),)\\r\\n #matches.insert(0,index)\\r\\n temp_matches = (index,) + temp_matches\\r\\n return temp_matches\",\n \"def test_build_similar_keys_list():\\n from FindSimilarIncidentsV2 import build_incident_fields_query\\n\\n int_res = build_incident_fields_query({u'sla': 0})\\n assert int_res == ['sla:=0']\\n\\n str_res = build_incident_fields_query({u'employeeid': u'1111'})\\n assert str_res == [u'employeeid=\\\"1111\\\"']\\n\\n list_res = build_incident_fields_query({u'test': [u'name1', 0]})\\n assert list_res == [u'test=\\\"name1\\\"', 'test:=0']\\n\\n list_res = build_incident_fields_query({u'test': []})\\n assert list_res == ['test=[]']\\n\\n escape_res = build_incident_fields_query({u'test': u'\\\"C:\\\\\\\\test\\\\\\\\escape\\\\\\\\sequence\\\" test'})\\n assert escape_res == [u'test=\\\"\\\\\\\\\\\"C:\\\\\\\\test\\\\\\\\escape\\\\\\\\sequence\\\\\\\\\\\" test\\\"']\",\n \"def __init__(self, key):\\n\\n def keys(key, num_rounds):\\n \\\"\\\"\\\"Yields the permuted key bitstring for i = 1..num_rounds\\\"\\\"\\\"\\n C, D = key[:28], key[28:]\\n # Rounds are 1-indexed, so shift array over by one\\n left_shifts = [None, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]\\n for i in range(1, num_rounds + 1):\\n # Negate each rotation to rotate left.\\n C, D = rotate(C, -left_shifts[i]), rotate(D, -left_shifts[i])\\n yield self.permute(C + D, self._CD_permutation)\\n\\n self.key = list(bits_of(key, 64))\\n # Permute the key. The permutation discards the parity bits...\\n self.key = self.permute(self.key, self._key_permutation)\\n self.number_of_rounds = 16\\n # A list of the 16 keys K1 .. K16, shifted over by one to allow 1-indexing.\\n self.keys = [None] + list(keys(self.key, self.number_of_rounds))\",\n \"def keysWhichMatch(cls, *args):\\n if len(cls.keys) < len(args) > 0:\\n raise ValueError('Number of keys provided is too long.\\\\n'\\n 'Len Class Keys: %s\\\\n'\\n 'Len Provided Keys: %s\\\\n' % (len(cls.keys), len(args)))\\n\\n index = 0\\n output = cls.db_key_tuples()\\n\\n for keyToCheck in args:\\n temp = []\\n for key in output:\\n if key[index] == keyToCheck:\\n temp.append(key)\\n\\n index += 1\\n output = temp\\n\\n return output\",\n \"def test_init_with_field_dict(self):\\n fields = {\\n 'Column 1': 'a=${aaa}',\\n 'Column 2': 'b=${bbb}',\\n 'Column 3': 'c=${ccc}',\\n }\\n csv_formatter = CSVFormatter(fields=fields)\\n csv = csv_formatter.format_records(self.records)\\n\\n csv_expected = textwrap.dedent(\\\"\\\"\\\"\\\\\\n #Column 1,Column 2,Column 3\\n a=foobar_01,b=8,c=4898FE19\\n a=foobar_02,b=160,c=5825D187\\n a=foobar_03,b=99,c=3648A436\\n \\\"\\\"\\\")\\n\\n assert csv == csv_expected\",\n \"def current_source_key(self, match):\\n raise NotImplementedError\",\n \"def init(self, datasetInfo):\\n #use user's dataset directory if not specified\\n if datasetInfo is None: raise RecognizerError(\\\"No dataset file specified.\\\")\\n \\n if os.path.isfile(datasetInfo):\\n datasetInfos = [datasetInfo]\\n elif os.path.isdir(datasetInfo):\\n datasetInfos = [os.path.join(datasetInfo, f) for f in os.listdir(datasetInfo) \\\\\\n if f.endswith('.xml')]\\n elif isinstance(datasetInfo, (types.ListType, types.TupleType)):\\n datasetInfos = datasetInfo\\n else: raise RecognizerError, \\\"Unknown datasetInfo type: %s\\\" % type(datasetInfo)\\n \\n patterns = {}; startsWiths = []; matchers = {}\\n for f in datasetInfos:\\n info, ns = getXmlEtree(f)\\n if not ns.has_key('_'): ns['_'] = ns['_default']\\n for dataset in info:\\n \\n #skip if comment\\n if isinstance(dataset, lxml.etree._Comment): continue\\n \\n ipath = xpath(dataset, './/_:ipath/text()', ns)\\n fileTemplate = xpath(dataset, './/_:fileTemplate/text()', ns)\\n startsWith = fileTemplate[0:fileTemplate.index('$')]\\n filePattern = xpath(dataset, './/_:filePattern/text()', ns)\\n if matchers.has_key(startsWith):\\n matchers[startsWith].append((re.compile(filePattern), ipath, dataset, ns))\\n else: matchers[startsWith] = [(re.compile(filePattern), ipath, dataset, ns)]\\n if startsWith != '': startsWiths.append(startsWith)\\n startsWithPattern = r'(' + '|'.join(startsWiths) + ')'\\n startsWithMatcher = re.compile(startsWithPattern)\\n return startsWithMatcher, matchers\",\n \"def __init__(__self__, *,\\n key: pulumi.Input[str],\\n values: pulumi.Input[Sequence[pulumi.Input[str]]]):\\n pulumi.set(__self__, \\\"key\\\", key)\\n pulumi.set(__self__, \\\"values\\\", values)\",\n \"def create_mock_key_provider(key_list):\\n public_keys = {}\\n for k in key_list:\\n public_keys[k] = {'Fingerprint': k,\\n 'Value': 'ffaa00'}\\n key_provider = mock.Mock()\\n key_provider.get_public_keys.return_value = public_keys\\n return key_provider\",\n \"def filter_record_keys(record_list, whitelist_keys):\\n\\n filtered = [{k: v for k, v in [y for y in list(x.items()) if y[0] in whitelist_keys]} for x in record_list]\\n return filtered\",\n \"def __init__(self, key):\\n Base.__init__(self, key)\",\n \"def __init__(self, key):\\n Base.__init__(self, key)\",\n \"def test_mutate_field(self):\\n # Test adding a field\\n with self.assertRaises(ValueError):\\n self.email.add_field('', '')\\n\\n self.email.add_field(self.key, self.regex)\\n\\n found_key = False\\n found_regex = r''\\n for field in self.email.fields:\\n if field['key'] == self.key:\\n found_key = True\\n found_regex = field['regex']\\n\\n self.assertTrue(found_key)\\n self.assertEqual(found_regex, self.regex)\\n\\n # Test getting a field\\n with self.assertRaises(LookupError):\\n self.email.get_field('')\\n\\n field = self.email.get_field(self.key)\\n self.assertEqual(\\n field, {'key': self.key, 'regex': self.regex, 'value': []})\\n\\n # Test removing a field\\n with self.assertRaises(LookupError):\\n self.email.remove_field('')\\n\\n self.email.remove_field(self.key)\\n\\n found_key = False\\n found_regex = r''\\n for field in self.email.fields:\\n if field['key'] == self.key:\\n found_key = True\\n found_regex = field['regex']\\n\\n self.assertFalse(found_key)\\n self.assertNotEqual(found_regex, self.regex)\",\n \"def make_consistent(self):\\r\\n\\r\\n for key in self.get_keys():\\r\\n self.eliminate_key(key)\\r\\n\\r\\n for i_temp in self.indexes(): #i will be a note index\\r\\n for j_temp in self.get_keys_from_note(i_temp):\\r\\n if self.key_dict_contains(j_temp):\\r\\n self.add_key(j_temp,Index(i_temp))\\r\\n## self.key_dict[j_temp].add(str(Index(i_temp)))\\r\\n else:\\r\\n self.initiate_new_key(j_temp,Index(i_temp))\",\n \"def make_fromkey(self, key):\\n if key != '':\\n def make_runable(match):\\n return \\\"self.components['\\\" + match.group(0) + \\\"']\\\"\\n\\n runable = re.sub('[^\\\\(\\\\)|& ]+', make_runable, key)\\n return eval(runable)\\n else:\\n return ~np.zeros(self.size, dtype=bool)\",\n \"def build_match_clause(field, string):\\r\\n answer = {}\\r\\n tmp = {}\\r\\n tmp[field] = string\\r\\n answer['match'] = tmp\\r\\n return answer\",\n \"def _newKey(self, key):\\n pass\",\n \"def __init__(self, keys_to_track):\\r\\n self.keys_to_track = keys_to_track\\r\\n self.tracker = {}\\r\\n for key_to_track in self.keys_to_track:\\r\\n self.tracker[key_to_track] = {}\",\n \"def test_keyword_extractor(self):\\n data = [{\\\"Header\\\": \\\"This is a Header\\\", \\\"Paragraph\\\": \\\"This is a Paragraph\\\", \\\"slide\\\": 10}]\\n keywords = keyword_extractor(data)\\n data[0][\\\"Header_keywords\\\"] = [\\\"header\\\"]\\n data[0][\\\"Paragraph_keywords\\\"] = [\\\"paragraph\\\"]\\n self.assertEqual(keywords, data)\",\n \"def _build_mysql_dict(self, user_list):\\n return_dict = {}\\n for user in user_list:\\n user_key = self._make_match_key(firstname=user['firstname'],\\n lastname=user['lastname'])\\n assert user_key not in return_dict\\n return_dict[user_key] = {'mysql_user': user,\\n 'friven_matched_users': []\\n }\\n return return_dict\",\n \"def _convert(self, dictlike):\\n for incoming_key, valuelist in util.dictlike_iteritems(dictlike):\\n for value in valuelist:\\n new_key = self.keyfunc(value)\\n if incoming_key != new_key:\\n raise TypeError(\\n \\\"Found incompatible key %r for value %r; this \\\"\\n \\\"collection's \\\"\\n \\\"keying function requires a key of %r for this value.\\\" % (\\n incoming_key, value, new_key))\\n yield value\",\n \"def key_by(self, field: str) -> B[B, E]:\\n pass\",\n \"def _initialize_parser_keys(self):\\n self.parser.source_role_marker = TRANSFER_ROLES.SOURCE\\n self.parser.target_role_marker = TRANSFER_ROLES.TARGET\\n rack_shape_agg = get_root_aggregate(IRackShape)\\n rack_shape_agg.filter = None\\n self.parser.allowed_rack_dimensions = [(rs.number_rows,\\n rs.number_columns)\\n for rs in rack_shape_agg]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5777237","0.5721886","0.5531455","0.548444","0.54103255","0.54072803","0.5384197","0.53711194","0.5370351","0.53101146","0.5296817","0.52691966","0.5252932","0.5242916","0.5215903","0.52110225","0.5207979","0.5202271","0.5188836","0.5164202","0.51598597","0.5157279","0.5147622","0.51181424","0.510944","0.5092469","0.50793564","0.50649875","0.5019659","0.5011922","0.5005509","0.5005509","0.4994515","0.49610457","0.49519533","0.4945018","0.4940992","0.49165928","0.49037254","0.48960716","0.48906964","0.48875195","0.48806816","0.48740357","0.4865057","0.48603588","0.48464397","0.48437712","0.48321792","0.482676","0.48220468","0.4817586","0.48161396","0.4800049","0.47986498","0.47886783","0.478852","0.47819808","0.47798026","0.47790894","0.4775895","0.47650188","0.4763051","0.47599944","0.47488913","0.4743635","0.4742833","0.47421935","0.47321174","0.47289124","0.47262996","0.4719688","0.4718317","0.47132707","0.47089222","0.47053817","0.4702147","0.4701925","0.47011286","0.46795857","0.46774808","0.4675527","0.4672947","0.46729293","0.4672556","0.4667284","0.46642166","0.46601832","0.46601832","0.46546543","0.46529356","0.4647483","0.46435666","0.46431467","0.46392596","0.46281937","0.46236205","0.46202135","0.4619189","0.46188742"],"string":"[\n \"0.5777237\",\n \"0.5721886\",\n \"0.5531455\",\n \"0.548444\",\n \"0.54103255\",\n \"0.54072803\",\n \"0.5384197\",\n \"0.53711194\",\n \"0.5370351\",\n \"0.53101146\",\n \"0.5296817\",\n \"0.52691966\",\n \"0.5252932\",\n \"0.5242916\",\n \"0.5215903\",\n \"0.52110225\",\n \"0.5207979\",\n \"0.5202271\",\n \"0.5188836\",\n \"0.5164202\",\n \"0.51598597\",\n \"0.5157279\",\n \"0.5147622\",\n \"0.51181424\",\n \"0.510944\",\n \"0.5092469\",\n \"0.50793564\",\n \"0.50649875\",\n \"0.5019659\",\n \"0.5011922\",\n \"0.5005509\",\n \"0.5005509\",\n \"0.4994515\",\n \"0.49610457\",\n \"0.49519533\",\n \"0.4945018\",\n \"0.4940992\",\n \"0.49165928\",\n \"0.49037254\",\n \"0.48960716\",\n \"0.48906964\",\n \"0.48875195\",\n \"0.48806816\",\n \"0.48740357\",\n \"0.4865057\",\n \"0.48603588\",\n \"0.48464397\",\n \"0.48437712\",\n \"0.48321792\",\n \"0.482676\",\n \"0.48220468\",\n \"0.4817586\",\n \"0.48161396\",\n \"0.4800049\",\n \"0.47986498\",\n \"0.47886783\",\n \"0.478852\",\n \"0.47819808\",\n \"0.47798026\",\n \"0.47790894\",\n \"0.4775895\",\n \"0.47650188\",\n \"0.4763051\",\n \"0.47599944\",\n \"0.47488913\",\n \"0.4743635\",\n \"0.4742833\",\n \"0.47421935\",\n \"0.47321174\",\n \"0.47289124\",\n \"0.47262996\",\n \"0.4719688\",\n \"0.4718317\",\n \"0.47132707\",\n \"0.47089222\",\n \"0.47053817\",\n \"0.4702147\",\n \"0.4701925\",\n \"0.47011286\",\n \"0.46795857\",\n \"0.46774808\",\n \"0.4675527\",\n \"0.4672947\",\n \"0.46729293\",\n \"0.4672556\",\n \"0.4667284\",\n \"0.46642166\",\n \"0.46601832\",\n \"0.46601832\",\n \"0.46546543\",\n \"0.46529356\",\n \"0.4647483\",\n \"0.46435666\",\n \"0.46431467\",\n \"0.46392596\",\n \"0.46281937\",\n \"0.46236205\",\n \"0.46202135\",\n \"0.4619189\",\n \"0.46188742\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7259984"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":592,"cells":{"query":{"kind":"string","value":"Check if the origin_imgs are flipped correctly."},"document":{"kind":"string","value":"def _check_flip(origin_imgs, result_imgs):\n h, w, c = origin_imgs.shape\n for i in range(h):\n for j in range(w):\n for k in range(c):\n if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:\n return False\n return True"},"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 check_flip(origin_imgs, result_imgs, flip_type):\n n, _, _, _ = np.shape(origin_imgs)\n if flip_type == 'horizontal':\n for i in range(n):\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\n return False\n else:\n # yapf: disable\n for i in range(n):\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\n return False\n # yapf: enable\n return True","def reversible(self) -> bool:\n xy_row = np.column_stack(\n (\n np.linspace(\n -self.imgsz[0] / (2 * self.f[0]),\n self.imgsz[0] / (2 * self.f[0]),\n int(self.imgsz[0]),\n ),\n np.zeros(int(self.imgsz[0])),\n )\n )\n dxy = self._distort(xy_row)\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\n xy_col = np.column_stack(\n (\n np.zeros(int(self.imgsz[1])),\n np.linspace(\n -self.imgsz[1] / (2 * self.f[1]),\n self.imgsz[1] / (2 * self.f[1]),\n int(self.imgsz[1]),\n ),\n )\n )\n dxy = self._distort(xy_col)\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\n return continuous_row and continuous_col","def test_flip_vertical() -> None:\n original = create_image(3, 2)\n set_color(original, 0, 0, create_color(0, 0, 0))\n set_color(original, 1, 0, create_color(90, 90, 90))\n set_color(original, 2, 0, create_color(255, 255, 255))\n set_color(original, 0, 1, create_color(10, 10, 10))\n set_color(original, 1, 1, create_color(0, 0, 0))\n set_color(original, 2, 1, create_color(90, 90, 90))\n \n expected = create_image(3, 2)\n set_color(expected, 0, 0, create_color(10, 10, 10))\n set_color(expected, 1, 0, create_color(0, 0, 0))\n set_color(expected, 2, 0, create_color(90, 90, 90))\n set_color(expected, 0, 1, create_color(0, 0, 0))\n set_color(expected, 1, 1, create_color(90, 90, 90))\n set_color(expected, 2, 1, create_color(255, 255, 255))\n \n flipped_vertical = flip_vertical(original)\n \n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))","def verify_legal_rotation(self, direction):\n test_figure = None\n if direction == \"CW\":\n test_figure = self.get_block_positions(self.active_piece.get_cw_rotation())\n elif direction == \"CCW\":\n test_figure = self.get_block_positions(self.active_piece.get_ccw_rotation())\n\n for b_x, b_y in test_figure:\n if b_x < 0 or b_x >= self.WIDTH:\n return False\n\n if b_y < 0 or b_y >= self.HEIGHT:\n return False\n\n if self.board[b_y][b_x] != 0:\n return False\n return True","def drone_has_flipped(self, current_orientation):\n has_flipped = True\n\n self.max_roll = rospy.get_param(\"/drone/max_roll\")\n self.max_pitch = rospy.get_param(\"/drone/max_pitch\")\n\n rospy.logwarn(\"#### HAS FLIPPED? ########\")\n rospy.logwarn(\"RPY current_orientation\"+str(current_orientation))\n rospy.logwarn(\"max_roll\"+str(self.max_roll) +\n \",min_roll=\"+str(-1*self.max_roll))\n rospy.logwarn(\"max_pitch\"+str(self.max_pitch) +\n \",min_pitch=\"+str(-1*self.max_pitch))\n rospy.logwarn(\"############\")\n\n if current_orientation.x > -1*self.max_roll and current_orientation.x <= self.max_roll:\n if current_orientation.y > -1*self.max_pitch and current_orientation.y <= self.max_pitch:\n has_flipped = False\n\n return has_flipped","def checkImages(self):\r\n\r\n self.leftImage, self.rightImage, res = self.receiver.getImageData()\r\n\r\n return res","def image_comparison(self):\n for result in self.cards:\n if result.image_status:\n return True\n return False","def _compare_jpg_decode_with_pil(test_case, images, print_debug_info=False):\n of_decoded_images = _of_image_decode(images)\n pil_images = [Image.open(image) for image in images]\n # convert image to BGR\n pil_decoded_images = [np.array(image)[:, :, ::-1] for image in pil_images]\n\n for of_decoded_image, pil_decoded_image in zip(\n of_decoded_images, pil_decoded_images\n ):\n of_decoded_image = of_decoded_image.squeeze()\n test_case.assertTrue(len(of_decoded_image.shape) == 3)\n test_case.assertTrue(len(pil_decoded_image.shape) == 3)\n\n diff = of_decoded_image - pil_decoded_image\n diff_index = np.where(diff != 0)\n diff_abs_values = diff[diff_index]\n\n if print_debug_info:\n print(\"of_decoded_image:\\n\", of_decoded_image, of_decoded_image.shape)\n print(\"pil_decoded_image:\\n\", pil_decoded_image, pil_decoded_image.shape)\n print(\"diff_index:\\n\", diff_index)\n print(\"diff_abs_values:\\n\", diff_abs_values)\n print(\n \"of_decoded_image diff:\\n\",\n of_decoded_image[diff_index[0], diff_index[1]],\n )\n print(\n \"pil_decoded_image diff:\\n\",\n pil_decoded_image[diff_index[0], diff_index[1]],\n )\n\n # only green channel has difference of 1\n test_case.assertTrue(np.all(diff_index[-1] == 1))\n test_case.assertTrue(np.all(diff_abs_values == 1))","def are_compatible_imgs(one_img, another_img):\n return have_same_shapes(one_img, another_img)","def checkForced(self, source, forced):\n self.assertEqual(source.get(\"flux.naive\"),\n self.image.get(self.x, self.y) if forced else self.image.get(self.xcen, self.ycen))","def _check_same_fov(*args, **kwargs):\n raise_error = kwargs.pop(\"raise_error\", False)\n for i, arg in enumerate(args):\n kwargs[f\"img_#{i}\"] = arg\n errors = []\n for (a_name, a_img), (b_name, b_img) in itertools.combinations(\n kwargs.items(), 2\n ):\n if not a_img.shape[:3] == b_img.shape[:3]:\n errors.append((a_name, b_name, \"shape\"))\n if not np.allclose(a_img.affine, b_img.affine):\n errors.append((a_name, b_name, \"affine\"))\n if len(errors) > 0 and raise_error:\n raise ValueError(\n \"Following field of view errors were detected:\\n\"\n + \"\\n\".join(\n [\n f\"- {e[0]} and {e[1]} do not have the same {e[2]}\"\n for e in errors\n ]\n )\n )\n return len(errors) == 0","def readout_flipped(self, iamp):\n flipped = ct.c_int()\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\n ct.pointer(flipped))\n return bool(flipped.value)","def ff_correct_image(image):\n pass","def ff_correct_image(image):\n pass","def invertible(self):\n a = self._data\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]","def __check_type__(im, ft_axes, orig, name, real_axis=0, shift_axes=[]):\n if type(orig) == image.image:\n im = im.view(image.image) # note: view casting -> this is not the viewer!\n if type(orig.name) is str:\n im.name = name + ' of ' + orig.name\n im.info = orig.info\n pxs = []\n\n for a in ft_axes:\n if a not in orig.spectral_axes:\n im.spectral_axes += [a]\n im.shift_axes = shift_axes\n if type(orig.unit) is str:\n im.unit = ''\n for i in range(im.ndim):\n if i in ft_axes:\n if name == 'IRFT' and real_axis == i:\n pxs += [1 / (orig.pixelsize[i] * 2 * (orig.shape[i] - 1))]\n else:\n pxs += [1 / (orig.pixelsize[i] * orig.shape[i])]\n if type(orig.unit) is str:\n im.unit += orig.unit + '^-1 '\n else:\n try: # TODO: FIX THIS!!!\n pxs += [orig.pixelsize[i]]\n except:\n print('Error in setting pixel size')\n if type(orig.unit) is str:\n im.unit += orig.unit + ' '\n im.pixelsize = pxs\n return (im)\n else:\n return (im)\n\n # ifft shift","def __compareImage(self, file1, file2):\n # arg=self.__validateString(str_arg)\n # file1, file2=arg.split(' ', 1)\n try:\n img1 = Image.open(file1)\n img2 = Image.open(file2)\n if img1.size != img2.size:\n return False\n by1 = img1.tobytes()\n by2 = img2.tobytes()\n # format r,g,b,255,r,g,b,255, 3 bytes = 1 point, 255=separator, total 4 bytes\n l = len(by1) / 4\n # total points and same points\n tp = 0\n sp = 0\n for j in range(l):\n i = j * 4\n tp += 1\n if by1[i] == by2[i] and by1[i + 1] == by2[i + 1] and by1[i + 2] == by2[i + 2]:\n sp += 1\n # max to 2% diff allowed\n if tp * 0.98 > sp:\n return False\n else:\n return True\n except Exception, e:\n printLog(self.threadName + \"Exception in __compareImage: %s\" % e.message, logging.ERROR)\n traceback.print_exc()\n return False\n finally:\n img1 = None\n img2 = None","def _check_consistency_between_imaging_extractors(self):\n return True","def compare_images(img1_path, img2_path):\n img1 = Image.open(img1_path)\n img2 = Image.open(img2_path)\n try:\n diff = ImageChops.difference(img1, img2)\n except ValueError:\n return False\n return diff.getbbox() is None","def _check_fov(img, affine, shape):\n img = check_niimg(img)\n return img.shape[:3] == shape and np.allclose(img.affine, affine)","def is_orientation_ok(image,k=2,is_first=True):\n\n mid_x, mid_y = int(0.5*image.shape[1]), int(0.5*image.shape[0])\n\n # Get moment for first body half \n image_0 = np.array(image)\n image_0[:,:int(mid_x)] = 0\n image_0 = image_0[:,int(mid_x):]\n moment_0 = get_moment(image_0,k)\n\n # Get moment for second body half\n image_1 = np.array(image)\n image_1[:,int(mid_x):] = 0\n image_1 = np.fliplr(image_1)\n image_1 = image_1[:,int(mid_x):]\n moment_1 = get_moment(image_1,k)\n\n # Compute descriminant and flip flag\n discrim = (moment_0 - moment_1)/(moment_0 + moment_1)\n if discrim < 0:\n ok = False\n else:\n ok = True \n return ok, discrim","def check_conv_transpose(extract):\n call = extract\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n elif call.op.name == \"nn.relu\":\n call = call.args[0]\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n elif call.op.name == \"clip\":\n if call.attrs[\"a_min\"] != 0.0 or call.attrs[\"a_max\"] != 6.0:\n return False\n call = call.args[0]\n if isinstance(call, tvm.relay.expr.TupleGetItem):\n call = call.tuple_value\n\n while call.op.name != \"nn.conv2d_transpose\":\n call = call.args[0]\n\n attrs = call.attrs\n if attrs.data_layout != \"NCHW\":\n return False\n\n return True","def check_image_invert(image_data, border_width = 30):\n \n _, avg_intensity_borders, avg_intensity_inside = \\\n _auto_threshold_borders(image_data,border_width = border_width);\n \n # if image borders are darker than the mean image, it's a surface tension\n # image:\n if(avg_intensity_inside > avg_intensity_borders):\n return False;\n # else, it's a shadowgraph image:\n else:\n return True;","def _check_origin(self, origin):\n try:\n cachevol_props = self.zfssa.get_volume(origin)\n except exception.VolumeNotFound:\n LOG.debug('Origin %s does not exist', origin)\n return\n\n numclones = cachevol_props['numclones']\n LOG.debug('Number of clones: %d', numclones)\n if numclones <= 1:\n # This cache vol does not have any other clone\n self.zfssa.delete_file(origin)\n else:\n cachevol_props = {'numclones': six.text_type(numclones - 1)}\n self.zfssa.set_file_props(origin, cachevol_props)","def _check_inverse_transform(self, Z):\n Z_round_trip = self.inverse_func(self.func(Z))\n if not np.allclose(Z_round_trip, Z, equal_nan=True):\n raise UserWarning(\n \"The provided functions are not strictly\"\n \" inverse of each other. If you are sure you\"\n \" want to proceed regardless, set\"\n \" 'check_inverse=False'.\"\n )","def problem1():\n\n img = load_image(\"data/a1p1.png\")\n display_image(img)\n\n save_as_npy(\"a1p1.npy\", img)\n\n img1 = load_npy(\"a1p1.npy\")\n display_image(img1)\n\n img2 = mirror_horizontal(img1)\n display_image(img2)\n\n display_images(img1, img2)","def assert_data_correct(self) -> bool:\n if not self.training_folder.exists():\n return False\n # 27: number of characters\n # 27*2: 27 original font characters and 27 folders with morphed version\n if len(list(self.training_folder.iterdir())) not in [27, 27 * 2]:\n return False\n # assert that each character folder has the expected number of images inside\n # expected number is repetitions + original, or just original if no morphing\n # took place\n for directory in self.training_folder.iterdir():\n img_count = len(list(directory.iterdir()))\n if img_count != self.repetitions + 1 and img_count != 1:\n return False\n return True","def verifyShiftFile(self):\n if self['refimage'] and fu.findFile(self['refimage']):\n return True\n else: return False","def _correct_images(images):\n # From the MNIST website: \"Pixels are organized row-wise. Pixel values are 0 to 255. 0 means\n # background (white), 255 means foreground (black).\"\n # The dataset does not transform the image such that 255 is black, so do that here.\n dtype = _assert_dtype(images)\n max_val = 255 if dtype == dtypes.uint8 else 1.0\n return max_val - images","def check_origin(self, origin):\n return True","def check_origin(self, origin):\n return True","def check_origin(self, origin):\n return True","def check_origin(self, origin):\n return True","def flip(imgs):\n x = random.choice([-1, 0, 1, 2])\n if x == 2:\n return imgs\n else:\n return [cv2.flip(img, x) for img in imgs]","def mirrorImage(self):\n\n im = Image.open(self.ActivePhoto)\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n out.save(self.ActivePhoto)\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\n print (\"Flipped image\")","def _is_mapping_correct(self):\n for i in range(self.mapping_size):\n target = self.mapping[i]\n if target < 0:\n continue\n if target == i // 2:\n continue\n return False\n return True","def testInverted(self):\n invertedClass = xyTransformRegistry[\"inverted\"]\n invertedConfig = invertedClass.ConfigClass()\n affineClass = xyTransformRegistry[\"affine\"]\n invertedConfig.transform.retarget(affineClass)\n affineConfig = invertedConfig.transform\n affineConfig.translation = (1.2, -3.4)\n with lsst.utils.tests.getTempFilePath(\".py\") as filePath:\n self.checkConfig(invertedClass, invertedConfig, filePath)\n inverted = invertedClass(invertedConfig)\n self.checkBasics(inverted)\n for fromPoint in self.fromIter():\n toPoint = inverted.forwardTransform(fromPoint)\n predToPoint = fromPoint - \\\n Extent2D(*invertedConfig.transform.translation)\n for i in range(2):\n self.assertAlmostEqual(toPoint[i], predToPoint[i])","def flip_images(x, y):\n flip_i = random.sample(range(x.shape[0]), int(x.shape[0] / 2))\n x[flip_i] = x[flip_i, :, ::-1, :]\n y[flip_i] = -y[flip_i]\n\n return x, y","def compare(actor, frame):\n urlretrieve(actor, 'actor.jpg')\n\n with open(\"frame_image.jpg\", 'wb') as frame_image:\n frame_image.write(base64.b64decode(frame[23:]))\n\n actor_encoding = face_encodings(load_image_file('actor.jpg'))[0]\n frame_encoding = face_encodings(load_image_file('frame_image.jpg'))\n\n os.remove('actor.jpg')\n os.remove('frame_image.jpg')\n for encoding in frame_encoding:\n if compare_faces([actor_encoding], encoding):\n return True\n return False","def assert_orientation_landscape_image_is_correct(self, rendition):\n\n from willow.plugins.pillow import PillowImage\n\n with rendition.get_willow_image() as willow_image:\n image = PillowImage.open(willow_image)\n # Check that the image is the correct size (and not rotated)\n self.assertEqual(image.get_size(), (600, 450))\n # Check that the red flower is in the bottom left\n # The JPEGs have compressed slightly differently so the colours won't be spot on\n colour = image.image.convert(\"RGB\").getpixel((155, 282))\n self.assertAlmostEqual(colour[0], 217, delta=25)\n self.assertAlmostEqual(colour[1], 38, delta=25)\n self.assertAlmostEqual(colour[2], 46, delta=25)\n\n # Check that the water is at the bottom\n colour = image.image.convert(\"RGB\").getpixel((377, 434))\n self.assertAlmostEqual(colour[0], 85, delta=25)\n self.assertAlmostEqual(colour[1], 93, delta=25)\n self.assertAlmostEqual(colour[2], 65, delta=25)","def is_origin(self) -> bool:\n return self.x == 0 and self.y == 0","def hasMoved(self):\r\n if BLENDER_MODE == 'BGE':\r\n world_tranform = self.obj.worldTransform.copy()\r\n elif BLENDER_MODE == 'BPY':\r\n world_tranform = self.obj.matrix_world.copy()\r\n\r\n # if objed has not yet been checked\r\n if not self.old_worldTransform:\r\n self.old_worldTransform = world_tranform\r\n return True\r\n\r\n elif self._areDifferent_Mat44(world_tranform, self.old_worldTransform, self.moveThresholdLoc, self.moveThresholdRot):\r\n # moved since last check\r\n self.old_worldTransform = world_tranform\r\n return True\r\n else:\r\n # did not move since last check\r\n return False","def check_improvement_direction(self): # pragma: no cover\n good = self.good_rev.mean_value\n bad = self.bad_rev.mean_value\n\n if self.is_return_code_mode():\n if good == 1 or bad == 0:\n self._set_failed_return_code_direction_results()\n return False\n return True\n\n direction = self.improvement_direction\n if direction is None:\n return True\n if (bad > good and direction > 0) or (bad < good and direction < 0):\n self._set_failed_direction_results()\n return False\n return True","def _array_is_aligned(self):\n rot_matrix = self.axes_wcs.wcs.pc\n return np.allclose(rot_matrix, np.eye(self.axes_wcs.wcs.naxis))","def test_on_skimage_png(self):\n from_skimage = diffread(TEST_PNG)\n\n self.assertTupleEqual(from_skimage.shape, (256, 256))\n self.assertTrue(np.allclose(from_skimage, np.ones_like(from_skimage)))","def __lt__(self, img):\r\n ordering = self.config['algorithm_ordering']\r\n ordering = ordering[1:] if ordering.startswith('-') else ordering\r\n\r\n if ordering == \"filename\":\r\n return sorted([self.filename, img.filename])[0] == img.filename\r\n if ordering == 'width':\r\n return self.absolute_width <= img.absolute_width\r\n elif ordering == 'height':\r\n return self.absolute_height <= img.absolute_height\r\n elif ordering == 'area':\r\n return self.absolute_width * self.absolute_height <= img.absolute_width * img.absolute_height\r\n else:\r\n return max(self.absolute_width, self.absolute_height) <= max(img.absolute_width, img.absolute_height)","def flipped_dimensions(transformation, size):\n dim = len(size)\n # transform start point\n start = [0.0] * dim\n transformed_start = transformation.TransformPoint(start)\n flipped = [False] * dim\n for i in range(dim):\n # set current end point and transform it\n end = [0.0] * dim\n end[i] = size[i]\n transformed_end = transformation.TransformPoint(end)\n # check, if transformed_start and transformed_end changed position\n flipped[i] = transformed_start[i] > transformed_end[i]\n return flipped","def assert_data_fragments_correct(self) -> bool:\n read_path = Path(os.environ[\"DATA_PATH\"]) / \"fragments\"\n if not read_path.exists():\n return False\n bin_images = [img for img in read_path.iterdir() if \"binarized\" in img.name]\n if len(bin_images) == 0:\n return False\n return True","def assert_image_equal(path1, path2):\n test_im = np.asarray(Image.open(path1))\n ref_im = np.asarray(Image.open(path2))\n npt.assert_array_equal(test_im, ref_im)","def reverseCurves(self):\n self.data.reverse()\n return True","def is_non_inverting(self):\n\n return False","def _infer_direction(self):\n data = self.get_data(None)\n if data is not None:\n # Infer the direction from the data\n if data._size > 1:\n data = data[0:2].array\n return bool(\n data.item(\n 0,\n )\n < data.item(\n 1,\n )\n )\n # --- End: if\n\n # Still here?\n data = self.get_bounds_data(None)\n if data is not None:\n # Infer the direction from the bounds\n b = data[(0,) * (data.ndim - 1)].array\n return bool(\n b.item(\n 0,\n )\n < b.item(\n 1,\n )\n )\n\n # Still here? Then infer the direction from the units.\n return not self.Units.ispressure","def victory_checker() -> bool:\r\n conflict_check()\r\n for x in range(shape):\r\n for y in range(shape):\r\n if conflict_space[x, y] != 0:\r\n return False\r\n if separation_crawler(False):\r\n return False\r\n return True","def check_if_mirror_extended(self, lqs):\n if lqs.size(1) % 2 == 0:\n lqs_1, lqs_2 = torch.chunk(lqs, 2, dim=1)\n if torch.norm(lqs_1 - lqs_2.flip(1)) == 0:\n self.is_mirror_extended = True","def check_if_original(article):\n num_img = len(article.find_all(\"img\"))\n return num_img < 2","def test_inverse_transform(self):","def testDegenerate(self):\n srt = asarray(self.copy())\n srt.sort(axis=1)\n return (srt[:,:-1] == srt[:,1:]).any(axis=1)","def equals(self, image: 'BaseImage') -> bool:\n assert isinstance(image, BaseImage)\n im1 = pygame.image.tostring(self._surface, 'RGBA')\n im2 = pygame.image.tostring(image._surface, 'RGBA')\n return im1 == im2","def check_angle(self):\n self.find_pixels()\n alpha_theta=np.deg2rad(70)\n alpha_phi=np.deg2rad(70)\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\n phi_0=20\n phi_0=np.deg2rad(phi_0)\n j, diff=self.compute_phi(\"find_orient.png\")\n print \"j=\", j\n print \"diff=\", diff","def is_different(image1, image2):\n gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)\n gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)\n\n (score, diff) = compare_ssim(gray1, gray2, full=True)\n diff = (diff * 255).astype(\"uint8\")\n\n thresh = cv2.threshold(diff, 0, 255,\n cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL,\n cv2.CHAIN_APPROX_SIMPLE)\n cnts = cnts[0] if imutils.is_cv2() else cnts[1]\n\n return bool(cnts)","def test__inverse_transform_continuous(self):","def _check_integrity(self):\n\n count = 0\n for (x, y) in self.__players[ChessGame.BLACK].union(\n self.__players[ChessGame.WHITE]):\n assert (x, y) in self.__board\n count += 1\n\n assert count == len(self.__board)","def is_solved(self):\n colors = ['green', 'blue', 'red', 'orange', 'white', 'yellow']\n for row in range(3):\n for column in range(3):\n if self.front[row][column] != colors[0]:\n return False\n for row in range(3):\n for column in range(3):\n if self.back[row][column] != colors[1]:\n return False\n for row in range(3):\n for column in range(3):\n if self.right[row][column] != colors[2]:\n return False\n for row in range(3):\n for column in range(3):\n if self.left[row][column] != colors[3]:\n return False\n for row in range(3):\n for column in range(3):\n if self.up[row][column] != colors[4]:\n return False\n for row in range(3):\n for column in range(3):\n if self.down[row][column] != colors[5]:\n return False\n return True","def save(self, data, filename, tporigin=None):\n if self.save_as is not None:\n ending = self.save_as\n else:\n try:\n ending = os.path.splitext(self.maskfiles[0])[-1]\n except Exception as e:\n ending = os.path.splitext(self.featurefiles[0])[-1]\n # if ending in ['.mhd']:\n # skio.imsave(filename + ending, data, plugin='simpleitk')\n if ending in ['.raw']:\n data.astype('int16').tofile(filename + ending)\n elif ending in ['.png', '.jpeg', '.png', '.pgm', '.pnm', '.gif', '.tif', '.tiff']:\n if np.max(data) <= 1.0 and np.min(data) >= 0:\n np.int8(np.clip(data * 256, 0, 255))\n imsave(filename + ending, data.squeeze())\n else:\n # ending in ['.nii', '.hdr', '.nii.gz', '.gz', '.dcm'] or len(data.squeeze().shape) > 2:\n if self.correct_orientation and tporigin is not None:\n # we corrected the orientation and we have the information to undo our wrongs, lets go:\n aligned_data = Volume(data, np.eye(4), \"RAS\") # dummy initialisation if everything else fails\n try:\n tporigin_vol = ni.open_image(os.path.join(tporigin, self.maskfiles[0]), verbose=False)\n except:\n try:\n tporigin_vol = ni.open_image(os.path.join(tporigin, self.featurefiles[0]), verbose=False)\n except Exception as e:\n logging.getLogger('data').warning('could not correct orientation for file {} from {}'\n .format(filename, tporigin))\n logging.getLogger('data').debug('because {}'.format(e))\n try:\n aligned_vol = Volume(data, tporigin_vol.aligned_transformation, tporigin_vol.system)\n aligned_data = aligned_vol.copy_like(tporigin_vol)\n except Exception as e:\n logging.getLogger('data').warning('could not correct orientation for file {} from {}'\n .format(filename, tporigin))\n logging.getLogger('data').debug('because {}'.format(e))\n\n finally:\n ni.save_volume(filename + \".nii.gz\", aligned_data, True)\n else:\n if self.correct_orientation:\n logging.getLogger('data').warning(\n 'could not correct orientation for file {} since tporigin is None: {}'\n .format(filename, tporigin))\n nib.save(nib.Nifti1Image(data, self.affine), filename + \".nii.gz\")","def check_for_inversion(cxr_img_norm):\n\n # Define image rim\n rim_thickness = max(np.shape(cxr_img_norm)) // 20\n rim_array = [\n list(cxr_img_norm[:rim_thickness, :].flatten()),\n list(cxr_img_norm[:, :rim_thickness].flatten()),\n list(cxr_img_norm[-rim_thickness:, :].flatten()),\n list(cxr_img_norm[:, -rim_thickness:].flatten())]\n\n rim_list = [pixel for rim in rim_array for pixel in rim]\n\n # Compare mean of rim to mean of whole image\n img_mean = np.mean(cxr_img_norm)\n rim_mean = np.mean(np.array(rim_list))\n\n inversion_check = (rim_mean > img_mean)\n\n return inversion_check","def test_array_orientation_consistency_tilt():\n samples = 128\n p = FringeZernike(Z2=1000, samples=samples)\n ps = PSF.from_pupil(p, 1)\n idx_y, idx_x = np.unravel_index(ps.data.argmax(), ps.data.shape) # row-major y, x\n assert idx_x == ps.center_x\n assert idx_y > ps.center_y","def correct(img_src, shift, destfile, crop=None):\n (y0, y1, x0, x1) = crop\n (shift_y, shift_x) = shift\n tf_shift = transform.SimilarityTransform(translation=[shift_x, shift_y])\n img = transform.warp(img_src, tf_shift)\n res = img[-y0:-y1, -x0:-x1, :]\n io.imsave(destfile, res)\n return destfile","def _correct_image(self, image):\n return Image(image.data, self._rotation_offset, self._dx, self._dy, self._timestamp).data","def testTranslate(self):\n (w,h) = self.im8_1.getSize()\n \n self.im8_1.reset()\n self.im8_1.setPixel(128, (w//2,h//2))\n \n for i in range(10):\n xi = random.randint(-w//4,w//4)\n yi = random.randint(-h//4,h//4)\n translate(self.im8_1, self.im8_2, xi, yi, 0)\n self.im8_3.reset()\n self.im8_3.setPixel(128, (w//2+xi,h//2+yi))\n (x,y) = compare(self.im8_2, self.im8_3, self.im8_2)\n self.assertTrue(x<0)\n translate(self.im8_1, self.im8_2, -xi, -yi, 0)\n self.im8_3.reset()\n self.im8_3.setPixel(128, (w//2-xi,h//2-yi))\n (x,y) = compare(self.im8_2, self.im8_3, self.im8_2)\n self.assertTrue(x<0)","def rotated(self):\n return self.pol_lat != 90.","def test_random_vertical_flip(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = RandomVerticalFlip(prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()\n \n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = RandomVerticalFlip(prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()","def collate_fn_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n flip = random.randint(1, 10000)%2\n # Do flipping\n # 0 = left, 1 = right\n hand_side = 1\n if flip:\n hand_side = 0 \n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if flip:\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd, hand_side","def equals(self, other: InputTransform) -> bool:\n return super().equals(other=other) and (self.reverse == other.reverse)","def isinvertible(self):\n if np.all(np.abs(self.maroots) > 1):\n return True\n else:\n return False","def diff_image(images):\n prev_image = cv2.absdiff(images[0], images[1])\n cur_image = cv2.absdiff(images[1], images[2])\n return cv2.bitwise_and(prev_image, cur_image)","def _hasChangedDirection(motionPts: list) -> tuple:\n dispPts = Ball._getDisplacements(motionPts)\n xDir = yDir = None\n xChange = yChange = False\n for dispPt in dispPts:\n # Compute differences\n xDirNow = RIGHT if dispPt[0] > 0 else LEFT\n yDirNow = DOWN if dispPt[1] > 0 else UP\n # Look for x changes\n if xDir is None:\n xDir = xDirNow\n elif xDirNow != xDir:\n xChange = True\n # Look for y changes\n if yDir is None:\n yDir = yDirNow\n elif yDirNow != yDir:\n yChange = True\n return xChange, yChange","def is_new_based_on_imgs(soup):\n\n \n \n prev_hashes = get_prev_img_hashes()\n temp_hashes = get_temp_img_hashes(soup)\n\n if len(temp_hashes.difference(prev_hashes))>0:\n print(\"new, based on images\")\n return True\n else:\n return False","def _check_normalization(self):\n lastDistance = None\n distance = None\n for idx in xrange(len(self) - 1):\n distance = self[idx+1][0] - self[idx][0]\n\n # first run\n if lastDistance is None:\n lastDistance = distance\n continue\n\n if lastDistance != distance:\n return False\n\n lastDistance = distance\n\n return True","def _check_orig(self):\n if self.is_dir():\n self._orig = False\n return\n\n parts = self._path.split('.')\n try:\n if parts[-1] == 'tgz':\n self._orig = True\n elif parts[-2] == 'tar':\n if (parts[-1] in Compressor.Opts or\n parts[-1] in Compressor.Aliases):\n self._orig = True\n except IndexError:\n self._orig = False","def is_inverse(self, other):\n return (self * other).is_identity() and (other * self).is_identity()","def img_compare(file1, file2):\n # read image\n img1 = Image.open(file1)\n img2 = Image.open(file2)\n\n # resize \n size = 128, 128\n img1_res = img_resize(img1, size)\n img2_res = img_resize(img2, size)\n\n img1_res.save(\"img_1.thumbnail\", \"JPEG\")\n img2_res.save(\"img_2.thumbnail\", \"JPEG\")\n\n # convert to gray scale\n img1_grayscale = img1_res.convert('LA')\n img1_grayscale.save(\"img_1_grayscale.png\")\n\n img2_grayscale = img2_res.convert('LA')\n img2_grayscale.save(\"img_2_grayscale.png\")\n\n # normalise\n img1_norm = normalize(np.array(img1_grayscale.getdata()).astype(float))\n img2_norm = normalize(np.array(img2_grayscale.getdata()).astype(float))\n\n try:\n # compare two images\n diff = img1_norm - img2_norm\n m_norm = sum(abs(diff)) # Manhattan norm\n z_norm = norm(diff.ravel(), 0) # Zero norm\n\n # print(\"Manhattan norm:\", m_norm, \"/ per pixel:\", m_norm/img1_norm.size)\n # print(\"Zero norm:\", z_norm, \"/ per pixel:\", z_norm*1.0/img1_norm.size)\n\n return m_norm/img1_norm.size, float(z_norm) / img1_norm.size\n except:\n return 100, 100","def can_rotate(self, current_piece):\n rotated_shape = current_piece.template[current_piece.next_rotation()] \n for x in range(pieces.Piece.TEMPLATE_WIDTH):\n for y in range(pieces.Piece.TEMPLATE_HEIGHT):\n board_x = current_piece.get_pos_x() + x\n board_y = current_piece.get_pos_y() + y \n if board_x < 0 and rotated_shape[y][x]:\n return False\n if board_y < 0 and rotated_shape[y][x]:\n return False\n if board_x >= game_config.BOARD_BOX_COUNT_X:\n return False\n if board_y >= game_config.BOARD_BOX_COUNT_Y:\n return False\n if self.board.get_cell(board_x, board_y) and rotated_shape[y][x]:\n return False\n return True","def _diff_images(img_before, img_after):\n width_before, height_before = img_before.size\n width_after, height_after = img_after.size\n data_before = img_before.getdata()\n data_after = img_after.getdata()\n\n width, height = max(width_before, width_after), max(height_before, height_after)\n offset_ax = (width - width_before) // 2\n offset_ay = (height - height_before) // 2\n offset_bx = (width - width_after) // 2\n offset_by = (height - height_after) // 2\n\n diff = 0\n for y in range(height):\n for x in range(width):\n ax, ay = x - offset_ax, y - offset_ay\n bx, by = x - offset_bx, y - offset_by\n if (ax < 0 or bx < 0 or ax >= width_before or bx >= width_after or\n ay < 0 or by < 0 or ay >= height_before or by >= height_after):\n diff += 1\n else:\n if data_before[ax + ay *width_before] != data_after[bx + by * width_after]:\n diff += 1\n try:\n return round(diff / float(width * height), 4)\n except ZeroDivisionError:\n return 0.0","def is_symetric(self):\n for x, y in _triangle_range(self.size):\n\n if self.read(x, y) != self.read(y, x):\n return False\n\n return True","def __flip(self, image, landmarks, run_prob=0.5):\n if np.random.rand() < run_prob:\n return image, landmarks\n image = np.fliplr(image)\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\n return image, landmarks","def check_2x2_solved(self):\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)","def is_versor(self) -> bool:\n return np.isclose(np.linalg.norm(self.A), 1.0)","def mirror(img):\n return img[:, ::-1]","def is_versor(self) -> np.ndarray:\n return np.isclose(np.linalg.norm(self.array, axis=1), 1.0)","def assert_data_correct(self) -> bool:\n corr_char = self.assert_data_characters_correct()\n print(\"Character data correct?\", corr_char)\n corr_font = FontImages().assert_data_correct()\n print(\"Font data correct?\", corr_font)\n corr_frag = self.assert_data_fragments_correct()\n print(\"Fragment data correct?\", corr_frag)\n corr_train_aug = self.assert_train_augmented()\n print(\"Train data augmented?\", corr_train_aug)\n truth_agree = corr_char and corr_font and corr_frag\n return True if truth_agree else False","def verify(self):\n if not self.verify_succ_pred_fingers():\n return False\n\n return True","def compare_faces(encodings, encoding_to_check):\n\n return list(np.linalg.norm(encodings - encoding_to_check, axis = 1))","def test_flip():\n template_r = np.array([\n [0.5, 0],\n [0.7, 0],\n ])\n template_g = np.array([\n [0.9, 0],\n [0.2, 0],\n ])\n template_b = np.array([\n [0.1, 0],\n [0.4, 0],\n ])\n template = np.dstack([template_r, template_g, template_b])\n return template, np.flipud(np.fliplr(template))","def collate_fn_no_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if self.pred_img_side == 'left':\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd","def _compositions_swapped(self, thermo):\n assert self._ref_indicators is not None\n\n indicators = self._singlet_comparison(thermo)\n\n for list1, list2 in zip(indicators, self._ref_indicators):\n comp_swapped = True\n for ind1, ind2 in zip(list1, list2):\n if ind1 == ind2:\n comp_swapped = False\n if comp_swapped:\n return True\n return False","def assertWarp(self):\n if self.rect.size.height != 256 or self.rect.width != 128:\n raise ValueError(\"Bad image size for body warped image\")\n if self.format != self.format.R8G8B8:\n raise ValueError(\"Bad image format for warped image, must be R8G8B8\")","def test_inverse_order_true(self):\n percentiles_cube = self.test_cube.copy(\n data=np.flipud(self.test_cube.data))\n plugin_instance = ProbabilitiesFromPercentiles2D(\n percentiles_cube, 'new_name')\n self.assertTrue(plugin_instance.inverse_ordering)","def check_scaled_shape(orig: torch.Tensor, scaled: torch.Tensor, scale_factor: float) -> bool:\n N, C, H, W = orig.shape\n Hc = int(scale_factor * H)\n Wc = int(scale_factor * W)\n\n return scaled.shape == (N, C, Hc, Wc)","def chk_vert_sym(self):\n for j in xrange(self.width):\n for i in xrange(int(round(self.height/2))):\n if self.rows[i][j] == self.rows[self.height - (i + 1)][j]:\n continue\n else:\n return False\n return True","def is3DImage(self):\n\t\treturn self.is3D"],"string":"[\n \"def check_flip(origin_imgs, result_imgs, flip_type):\\n n, _, _, _ = np.shape(origin_imgs)\\n if flip_type == 'horizontal':\\n for i in range(n):\\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\\n return False\\n else:\\n # yapf: disable\\n for i in range(n):\\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\\n return False\\n # yapf: enable\\n return True\",\n \"def reversible(self) -> bool:\\n xy_row = np.column_stack(\\n (\\n np.linspace(\\n -self.imgsz[0] / (2 * self.f[0]),\\n self.imgsz[0] / (2 * self.f[0]),\\n int(self.imgsz[0]),\\n ),\\n np.zeros(int(self.imgsz[0])),\\n )\\n )\\n dxy = self._distort(xy_row)\\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\\n xy_col = np.column_stack(\\n (\\n np.zeros(int(self.imgsz[1])),\\n np.linspace(\\n -self.imgsz[1] / (2 * self.f[1]),\\n self.imgsz[1] / (2 * self.f[1]),\\n int(self.imgsz[1]),\\n ),\\n )\\n )\\n dxy = self._distort(xy_col)\\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\\n return continuous_row and continuous_col\",\n \"def test_flip_vertical() -> None:\\n original = create_image(3, 2)\\n set_color(original, 0, 0, create_color(0, 0, 0))\\n set_color(original, 1, 0, create_color(90, 90, 90))\\n set_color(original, 2, 0, create_color(255, 255, 255))\\n set_color(original, 0, 1, create_color(10, 10, 10))\\n set_color(original, 1, 1, create_color(0, 0, 0))\\n set_color(original, 2, 1, create_color(90, 90, 90))\\n \\n expected = create_image(3, 2)\\n set_color(expected, 0, 0, create_color(10, 10, 10))\\n set_color(expected, 1, 0, create_color(0, 0, 0))\\n set_color(expected, 2, 0, create_color(90, 90, 90))\\n set_color(expected, 0, 1, create_color(0, 0, 0))\\n set_color(expected, 1, 1, create_color(90, 90, 90))\\n set_color(expected, 2, 1, create_color(255, 255, 255))\\n \\n flipped_vertical = flip_vertical(original)\\n \\n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))\",\n \"def verify_legal_rotation(self, direction):\\n test_figure = None\\n if direction == \\\"CW\\\":\\n test_figure = self.get_block_positions(self.active_piece.get_cw_rotation())\\n elif direction == \\\"CCW\\\":\\n test_figure = self.get_block_positions(self.active_piece.get_ccw_rotation())\\n\\n for b_x, b_y in test_figure:\\n if b_x < 0 or b_x >= self.WIDTH:\\n return False\\n\\n if b_y < 0 or b_y >= self.HEIGHT:\\n return False\\n\\n if self.board[b_y][b_x] != 0:\\n return False\\n return True\",\n \"def drone_has_flipped(self, current_orientation):\\n has_flipped = True\\n\\n self.max_roll = rospy.get_param(\\\"/drone/max_roll\\\")\\n self.max_pitch = rospy.get_param(\\\"/drone/max_pitch\\\")\\n\\n rospy.logwarn(\\\"#### HAS FLIPPED? ########\\\")\\n rospy.logwarn(\\\"RPY current_orientation\\\"+str(current_orientation))\\n rospy.logwarn(\\\"max_roll\\\"+str(self.max_roll) +\\n \\\",min_roll=\\\"+str(-1*self.max_roll))\\n rospy.logwarn(\\\"max_pitch\\\"+str(self.max_pitch) +\\n \\\",min_pitch=\\\"+str(-1*self.max_pitch))\\n rospy.logwarn(\\\"############\\\")\\n\\n if current_orientation.x > -1*self.max_roll and current_orientation.x <= self.max_roll:\\n if current_orientation.y > -1*self.max_pitch and current_orientation.y <= self.max_pitch:\\n has_flipped = False\\n\\n return has_flipped\",\n \"def checkImages(self):\\r\\n\\r\\n self.leftImage, self.rightImage, res = self.receiver.getImageData()\\r\\n\\r\\n return res\",\n \"def image_comparison(self):\\n for result in self.cards:\\n if result.image_status:\\n return True\\n return False\",\n \"def _compare_jpg_decode_with_pil(test_case, images, print_debug_info=False):\\n of_decoded_images = _of_image_decode(images)\\n pil_images = [Image.open(image) for image in images]\\n # convert image to BGR\\n pil_decoded_images = [np.array(image)[:, :, ::-1] for image in pil_images]\\n\\n for of_decoded_image, pil_decoded_image in zip(\\n of_decoded_images, pil_decoded_images\\n ):\\n of_decoded_image = of_decoded_image.squeeze()\\n test_case.assertTrue(len(of_decoded_image.shape) == 3)\\n test_case.assertTrue(len(pil_decoded_image.shape) == 3)\\n\\n diff = of_decoded_image - pil_decoded_image\\n diff_index = np.where(diff != 0)\\n diff_abs_values = diff[diff_index]\\n\\n if print_debug_info:\\n print(\\\"of_decoded_image:\\\\n\\\", of_decoded_image, of_decoded_image.shape)\\n print(\\\"pil_decoded_image:\\\\n\\\", pil_decoded_image, pil_decoded_image.shape)\\n print(\\\"diff_index:\\\\n\\\", diff_index)\\n print(\\\"diff_abs_values:\\\\n\\\", diff_abs_values)\\n print(\\n \\\"of_decoded_image diff:\\\\n\\\",\\n of_decoded_image[diff_index[0], diff_index[1]],\\n )\\n print(\\n \\\"pil_decoded_image diff:\\\\n\\\",\\n pil_decoded_image[diff_index[0], diff_index[1]],\\n )\\n\\n # only green channel has difference of 1\\n test_case.assertTrue(np.all(diff_index[-1] == 1))\\n test_case.assertTrue(np.all(diff_abs_values == 1))\",\n \"def are_compatible_imgs(one_img, another_img):\\n return have_same_shapes(one_img, another_img)\",\n \"def checkForced(self, source, forced):\\n self.assertEqual(source.get(\\\"flux.naive\\\"),\\n self.image.get(self.x, self.y) if forced else self.image.get(self.xcen, self.ycen))\",\n \"def _check_same_fov(*args, **kwargs):\\n raise_error = kwargs.pop(\\\"raise_error\\\", False)\\n for i, arg in enumerate(args):\\n kwargs[f\\\"img_#{i}\\\"] = arg\\n errors = []\\n for (a_name, a_img), (b_name, b_img) in itertools.combinations(\\n kwargs.items(), 2\\n ):\\n if not a_img.shape[:3] == b_img.shape[:3]:\\n errors.append((a_name, b_name, \\\"shape\\\"))\\n if not np.allclose(a_img.affine, b_img.affine):\\n errors.append((a_name, b_name, \\\"affine\\\"))\\n if len(errors) > 0 and raise_error:\\n raise ValueError(\\n \\\"Following field of view errors were detected:\\\\n\\\"\\n + \\\"\\\\n\\\".join(\\n [\\n f\\\"- {e[0]} and {e[1]} do not have the same {e[2]}\\\"\\n for e in errors\\n ]\\n )\\n )\\n return len(errors) == 0\",\n \"def readout_flipped(self, iamp):\\n flipped = ct.c_int()\\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\\n ct.pointer(flipped))\\n return bool(flipped.value)\",\n \"def ff_correct_image(image):\\n pass\",\n \"def ff_correct_image(image):\\n pass\",\n \"def invertible(self):\\n a = self._data\\n return a.shape[0] == a.shape[1] and np.linalg.matrix_rank(a) == a.shape[0]\",\n \"def __check_type__(im, ft_axes, orig, name, real_axis=0, shift_axes=[]):\\n if type(orig) == image.image:\\n im = im.view(image.image) # note: view casting -> this is not the viewer!\\n if type(orig.name) is str:\\n im.name = name + ' of ' + orig.name\\n im.info = orig.info\\n pxs = []\\n\\n for a in ft_axes:\\n if a not in orig.spectral_axes:\\n im.spectral_axes += [a]\\n im.shift_axes = shift_axes\\n if type(orig.unit) is str:\\n im.unit = ''\\n for i in range(im.ndim):\\n if i in ft_axes:\\n if name == 'IRFT' and real_axis == i:\\n pxs += [1 / (orig.pixelsize[i] * 2 * (orig.shape[i] - 1))]\\n else:\\n pxs += [1 / (orig.pixelsize[i] * orig.shape[i])]\\n if type(orig.unit) is str:\\n im.unit += orig.unit + '^-1 '\\n else:\\n try: # TODO: FIX THIS!!!\\n pxs += [orig.pixelsize[i]]\\n except:\\n print('Error in setting pixel size')\\n if type(orig.unit) is str:\\n im.unit += orig.unit + ' '\\n im.pixelsize = pxs\\n return (im)\\n else:\\n return (im)\\n\\n # ifft shift\",\n \"def __compareImage(self, file1, file2):\\n # arg=self.__validateString(str_arg)\\n # file1, file2=arg.split(' ', 1)\\n try:\\n img1 = Image.open(file1)\\n img2 = Image.open(file2)\\n if img1.size != img2.size:\\n return False\\n by1 = img1.tobytes()\\n by2 = img2.tobytes()\\n # format r,g,b,255,r,g,b,255, 3 bytes = 1 point, 255=separator, total 4 bytes\\n l = len(by1) / 4\\n # total points and same points\\n tp = 0\\n sp = 0\\n for j in range(l):\\n i = j * 4\\n tp += 1\\n if by1[i] == by2[i] and by1[i + 1] == by2[i + 1] and by1[i + 2] == by2[i + 2]:\\n sp += 1\\n # max to 2% diff allowed\\n if tp * 0.98 > sp:\\n return False\\n else:\\n return True\\n except Exception, e:\\n printLog(self.threadName + \\\"Exception in __compareImage: %s\\\" % e.message, logging.ERROR)\\n traceback.print_exc()\\n return False\\n finally:\\n img1 = None\\n img2 = None\",\n \"def _check_consistency_between_imaging_extractors(self):\\n return True\",\n \"def compare_images(img1_path, img2_path):\\n img1 = Image.open(img1_path)\\n img2 = Image.open(img2_path)\\n try:\\n diff = ImageChops.difference(img1, img2)\\n except ValueError:\\n return False\\n return diff.getbbox() is None\",\n \"def _check_fov(img, affine, shape):\\n img = check_niimg(img)\\n return img.shape[:3] == shape and np.allclose(img.affine, affine)\",\n \"def is_orientation_ok(image,k=2,is_first=True):\\n\\n mid_x, mid_y = int(0.5*image.shape[1]), int(0.5*image.shape[0])\\n\\n # Get moment for first body half \\n image_0 = np.array(image)\\n image_0[:,:int(mid_x)] = 0\\n image_0 = image_0[:,int(mid_x):]\\n moment_0 = get_moment(image_0,k)\\n\\n # Get moment for second body half\\n image_1 = np.array(image)\\n image_1[:,int(mid_x):] = 0\\n image_1 = np.fliplr(image_1)\\n image_1 = image_1[:,int(mid_x):]\\n moment_1 = get_moment(image_1,k)\\n\\n # Compute descriminant and flip flag\\n discrim = (moment_0 - moment_1)/(moment_0 + moment_1)\\n if discrim < 0:\\n ok = False\\n else:\\n ok = True \\n return ok, discrim\",\n \"def check_conv_transpose(extract):\\n call = extract\\n if isinstance(call, tvm.relay.expr.TupleGetItem):\\n call = call.tuple_value\\n elif call.op.name == \\\"nn.relu\\\":\\n call = call.args[0]\\n if isinstance(call, tvm.relay.expr.TupleGetItem):\\n call = call.tuple_value\\n elif call.op.name == \\\"clip\\\":\\n if call.attrs[\\\"a_min\\\"] != 0.0 or call.attrs[\\\"a_max\\\"] != 6.0:\\n return False\\n call = call.args[0]\\n if isinstance(call, tvm.relay.expr.TupleGetItem):\\n call = call.tuple_value\\n\\n while call.op.name != \\\"nn.conv2d_transpose\\\":\\n call = call.args[0]\\n\\n attrs = call.attrs\\n if attrs.data_layout != \\\"NCHW\\\":\\n return False\\n\\n return True\",\n \"def check_image_invert(image_data, border_width = 30):\\n \\n _, avg_intensity_borders, avg_intensity_inside = \\\\\\n _auto_threshold_borders(image_data,border_width = border_width);\\n \\n # if image borders are darker than the mean image, it's a surface tension\\n # image:\\n if(avg_intensity_inside > avg_intensity_borders):\\n return False;\\n # else, it's a shadowgraph image:\\n else:\\n return True;\",\n \"def _check_origin(self, origin):\\n try:\\n cachevol_props = self.zfssa.get_volume(origin)\\n except exception.VolumeNotFound:\\n LOG.debug('Origin %s does not exist', origin)\\n return\\n\\n numclones = cachevol_props['numclones']\\n LOG.debug('Number of clones: %d', numclones)\\n if numclones <= 1:\\n # This cache vol does not have any other clone\\n self.zfssa.delete_file(origin)\\n else:\\n cachevol_props = {'numclones': six.text_type(numclones - 1)}\\n self.zfssa.set_file_props(origin, cachevol_props)\",\n \"def _check_inverse_transform(self, Z):\\n Z_round_trip = self.inverse_func(self.func(Z))\\n if not np.allclose(Z_round_trip, Z, equal_nan=True):\\n raise UserWarning(\\n \\\"The provided functions are not strictly\\\"\\n \\\" inverse of each other. If you are sure you\\\"\\n \\\" want to proceed regardless, set\\\"\\n \\\" 'check_inverse=False'.\\\"\\n )\",\n \"def problem1():\\n\\n img = load_image(\\\"data/a1p1.png\\\")\\n display_image(img)\\n\\n save_as_npy(\\\"a1p1.npy\\\", img)\\n\\n img1 = load_npy(\\\"a1p1.npy\\\")\\n display_image(img1)\\n\\n img2 = mirror_horizontal(img1)\\n display_image(img2)\\n\\n display_images(img1, img2)\",\n \"def assert_data_correct(self) -> bool:\\n if not self.training_folder.exists():\\n return False\\n # 27: number of characters\\n # 27*2: 27 original font characters and 27 folders with morphed version\\n if len(list(self.training_folder.iterdir())) not in [27, 27 * 2]:\\n return False\\n # assert that each character folder has the expected number of images inside\\n # expected number is repetitions + original, or just original if no morphing\\n # took place\\n for directory in self.training_folder.iterdir():\\n img_count = len(list(directory.iterdir()))\\n if img_count != self.repetitions + 1 and img_count != 1:\\n return False\\n return True\",\n \"def verifyShiftFile(self):\\n if self['refimage'] and fu.findFile(self['refimage']):\\n return True\\n else: return False\",\n \"def _correct_images(images):\\n # From the MNIST website: \\\"Pixels are organized row-wise. Pixel values are 0 to 255. 0 means\\n # background (white), 255 means foreground (black).\\\"\\n # The dataset does not transform the image such that 255 is black, so do that here.\\n dtype = _assert_dtype(images)\\n max_val = 255 if dtype == dtypes.uint8 else 1.0\\n return max_val - images\",\n \"def check_origin(self, origin):\\n return True\",\n \"def check_origin(self, origin):\\n return True\",\n \"def check_origin(self, origin):\\n return True\",\n \"def check_origin(self, origin):\\n return True\",\n \"def flip(imgs):\\n x = random.choice([-1, 0, 1, 2])\\n if x == 2:\\n return imgs\\n else:\\n return [cv2.flip(img, x) for img in imgs]\",\n \"def mirrorImage(self):\\n\\n im = Image.open(self.ActivePhoto)\\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n out.save(self.ActivePhoto)\\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\\n print (\\\"Flipped image\\\")\",\n \"def _is_mapping_correct(self):\\n for i in range(self.mapping_size):\\n target = self.mapping[i]\\n if target < 0:\\n continue\\n if target == i // 2:\\n continue\\n return False\\n return True\",\n \"def testInverted(self):\\n invertedClass = xyTransformRegistry[\\\"inverted\\\"]\\n invertedConfig = invertedClass.ConfigClass()\\n affineClass = xyTransformRegistry[\\\"affine\\\"]\\n invertedConfig.transform.retarget(affineClass)\\n affineConfig = invertedConfig.transform\\n affineConfig.translation = (1.2, -3.4)\\n with lsst.utils.tests.getTempFilePath(\\\".py\\\") as filePath:\\n self.checkConfig(invertedClass, invertedConfig, filePath)\\n inverted = invertedClass(invertedConfig)\\n self.checkBasics(inverted)\\n for fromPoint in self.fromIter():\\n toPoint = inverted.forwardTransform(fromPoint)\\n predToPoint = fromPoint - \\\\\\n Extent2D(*invertedConfig.transform.translation)\\n for i in range(2):\\n self.assertAlmostEqual(toPoint[i], predToPoint[i])\",\n \"def flip_images(x, y):\\n flip_i = random.sample(range(x.shape[0]), int(x.shape[0] / 2))\\n x[flip_i] = x[flip_i, :, ::-1, :]\\n y[flip_i] = -y[flip_i]\\n\\n return x, y\",\n \"def compare(actor, frame):\\n urlretrieve(actor, 'actor.jpg')\\n\\n with open(\\\"frame_image.jpg\\\", 'wb') as frame_image:\\n frame_image.write(base64.b64decode(frame[23:]))\\n\\n actor_encoding = face_encodings(load_image_file('actor.jpg'))[0]\\n frame_encoding = face_encodings(load_image_file('frame_image.jpg'))\\n\\n os.remove('actor.jpg')\\n os.remove('frame_image.jpg')\\n for encoding in frame_encoding:\\n if compare_faces([actor_encoding], encoding):\\n return True\\n return False\",\n \"def assert_orientation_landscape_image_is_correct(self, rendition):\\n\\n from willow.plugins.pillow import PillowImage\\n\\n with rendition.get_willow_image() as willow_image:\\n image = PillowImage.open(willow_image)\\n # Check that the image is the correct size (and not rotated)\\n self.assertEqual(image.get_size(), (600, 450))\\n # Check that the red flower is in the bottom left\\n # The JPEGs have compressed slightly differently so the colours won't be spot on\\n colour = image.image.convert(\\\"RGB\\\").getpixel((155, 282))\\n self.assertAlmostEqual(colour[0], 217, delta=25)\\n self.assertAlmostEqual(colour[1], 38, delta=25)\\n self.assertAlmostEqual(colour[2], 46, delta=25)\\n\\n # Check that the water is at the bottom\\n colour = image.image.convert(\\\"RGB\\\").getpixel((377, 434))\\n self.assertAlmostEqual(colour[0], 85, delta=25)\\n self.assertAlmostEqual(colour[1], 93, delta=25)\\n self.assertAlmostEqual(colour[2], 65, delta=25)\",\n \"def is_origin(self) -> bool:\\n return self.x == 0 and self.y == 0\",\n \"def hasMoved(self):\\r\\n if BLENDER_MODE == 'BGE':\\r\\n world_tranform = self.obj.worldTransform.copy()\\r\\n elif BLENDER_MODE == 'BPY':\\r\\n world_tranform = self.obj.matrix_world.copy()\\r\\n\\r\\n # if objed has not yet been checked\\r\\n if not self.old_worldTransform:\\r\\n self.old_worldTransform = world_tranform\\r\\n return True\\r\\n\\r\\n elif self._areDifferent_Mat44(world_tranform, self.old_worldTransform, self.moveThresholdLoc, self.moveThresholdRot):\\r\\n # moved since last check\\r\\n self.old_worldTransform = world_tranform\\r\\n return True\\r\\n else:\\r\\n # did not move since last check\\r\\n return False\",\n \"def check_improvement_direction(self): # pragma: no cover\\n good = self.good_rev.mean_value\\n bad = self.bad_rev.mean_value\\n\\n if self.is_return_code_mode():\\n if good == 1 or bad == 0:\\n self._set_failed_return_code_direction_results()\\n return False\\n return True\\n\\n direction = self.improvement_direction\\n if direction is None:\\n return True\\n if (bad > good and direction > 0) or (bad < good and direction < 0):\\n self._set_failed_direction_results()\\n return False\\n return True\",\n \"def _array_is_aligned(self):\\n rot_matrix = self.axes_wcs.wcs.pc\\n return np.allclose(rot_matrix, np.eye(self.axes_wcs.wcs.naxis))\",\n \"def test_on_skimage_png(self):\\n from_skimage = diffread(TEST_PNG)\\n\\n self.assertTupleEqual(from_skimage.shape, (256, 256))\\n self.assertTrue(np.allclose(from_skimage, np.ones_like(from_skimage)))\",\n \"def __lt__(self, img):\\r\\n ordering = self.config['algorithm_ordering']\\r\\n ordering = ordering[1:] if ordering.startswith('-') else ordering\\r\\n\\r\\n if ordering == \\\"filename\\\":\\r\\n return sorted([self.filename, img.filename])[0] == img.filename\\r\\n if ordering == 'width':\\r\\n return self.absolute_width <= img.absolute_width\\r\\n elif ordering == 'height':\\r\\n return self.absolute_height <= img.absolute_height\\r\\n elif ordering == 'area':\\r\\n return self.absolute_width * self.absolute_height <= img.absolute_width * img.absolute_height\\r\\n else:\\r\\n return max(self.absolute_width, self.absolute_height) <= max(img.absolute_width, img.absolute_height)\",\n \"def flipped_dimensions(transformation, size):\\n dim = len(size)\\n # transform start point\\n start = [0.0] * dim\\n transformed_start = transformation.TransformPoint(start)\\n flipped = [False] * dim\\n for i in range(dim):\\n # set current end point and transform it\\n end = [0.0] * dim\\n end[i] = size[i]\\n transformed_end = transformation.TransformPoint(end)\\n # check, if transformed_start and transformed_end changed position\\n flipped[i] = transformed_start[i] > transformed_end[i]\\n return flipped\",\n \"def assert_data_fragments_correct(self) -> bool:\\n read_path = Path(os.environ[\\\"DATA_PATH\\\"]) / \\\"fragments\\\"\\n if not read_path.exists():\\n return False\\n bin_images = [img for img in read_path.iterdir() if \\\"binarized\\\" in img.name]\\n if len(bin_images) == 0:\\n return False\\n return True\",\n \"def assert_image_equal(path1, path2):\\n test_im = np.asarray(Image.open(path1))\\n ref_im = np.asarray(Image.open(path2))\\n npt.assert_array_equal(test_im, ref_im)\",\n \"def reverseCurves(self):\\n self.data.reverse()\\n return True\",\n \"def is_non_inverting(self):\\n\\n return False\",\n \"def _infer_direction(self):\\n data = self.get_data(None)\\n if data is not None:\\n # Infer the direction from the data\\n if data._size > 1:\\n data = data[0:2].array\\n return bool(\\n data.item(\\n 0,\\n )\\n < data.item(\\n 1,\\n )\\n )\\n # --- End: if\\n\\n # Still here?\\n data = self.get_bounds_data(None)\\n if data is not None:\\n # Infer the direction from the bounds\\n b = data[(0,) * (data.ndim - 1)].array\\n return bool(\\n b.item(\\n 0,\\n )\\n < b.item(\\n 1,\\n )\\n )\\n\\n # Still here? Then infer the direction from the units.\\n return not self.Units.ispressure\",\n \"def victory_checker() -> bool:\\r\\n conflict_check()\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n return False\\r\\n if separation_crawler(False):\\r\\n return False\\r\\n return True\",\n \"def check_if_mirror_extended(self, lqs):\\n if lqs.size(1) % 2 == 0:\\n lqs_1, lqs_2 = torch.chunk(lqs, 2, dim=1)\\n if torch.norm(lqs_1 - lqs_2.flip(1)) == 0:\\n self.is_mirror_extended = True\",\n \"def check_if_original(article):\\n num_img = len(article.find_all(\\\"img\\\"))\\n return num_img < 2\",\n \"def test_inverse_transform(self):\",\n \"def testDegenerate(self):\\n srt = asarray(self.copy())\\n srt.sort(axis=1)\\n return (srt[:,:-1] == srt[:,1:]).any(axis=1)\",\n \"def equals(self, image: 'BaseImage') -> bool:\\n assert isinstance(image, BaseImage)\\n im1 = pygame.image.tostring(self._surface, 'RGBA')\\n im2 = pygame.image.tostring(image._surface, 'RGBA')\\n return im1 == im2\",\n \"def check_angle(self):\\n self.find_pixels()\\n alpha_theta=np.deg2rad(70)\\n alpha_phi=np.deg2rad(70)\\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\\n phi_0=20\\n phi_0=np.deg2rad(phi_0)\\n j, diff=self.compute_phi(\\\"find_orient.png\\\")\\n print \\\"j=\\\", j\\n print \\\"diff=\\\", diff\",\n \"def is_different(image1, image2):\\n gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)\\n gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)\\n\\n (score, diff) = compare_ssim(gray1, gray2, full=True)\\n diff = (diff * 255).astype(\\\"uint8\\\")\\n\\n thresh = cv2.threshold(diff, 0, 255,\\n cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\\n cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL,\\n cv2.CHAIN_APPROX_SIMPLE)\\n cnts = cnts[0] if imutils.is_cv2() else cnts[1]\\n\\n return bool(cnts)\",\n \"def test__inverse_transform_continuous(self):\",\n \"def _check_integrity(self):\\n\\n count = 0\\n for (x, y) in self.__players[ChessGame.BLACK].union(\\n self.__players[ChessGame.WHITE]):\\n assert (x, y) in self.__board\\n count += 1\\n\\n assert count == len(self.__board)\",\n \"def is_solved(self):\\n colors = ['green', 'blue', 'red', 'orange', 'white', 'yellow']\\n for row in range(3):\\n for column in range(3):\\n if self.front[row][column] != colors[0]:\\n return False\\n for row in range(3):\\n for column in range(3):\\n if self.back[row][column] != colors[1]:\\n return False\\n for row in range(3):\\n for column in range(3):\\n if self.right[row][column] != colors[2]:\\n return False\\n for row in range(3):\\n for column in range(3):\\n if self.left[row][column] != colors[3]:\\n return False\\n for row in range(3):\\n for column in range(3):\\n if self.up[row][column] != colors[4]:\\n return False\\n for row in range(3):\\n for column in range(3):\\n if self.down[row][column] != colors[5]:\\n return False\\n return True\",\n \"def save(self, data, filename, tporigin=None):\\n if self.save_as is not None:\\n ending = self.save_as\\n else:\\n try:\\n ending = os.path.splitext(self.maskfiles[0])[-1]\\n except Exception as e:\\n ending = os.path.splitext(self.featurefiles[0])[-1]\\n # if ending in ['.mhd']:\\n # skio.imsave(filename + ending, data, plugin='simpleitk')\\n if ending in ['.raw']:\\n data.astype('int16').tofile(filename + ending)\\n elif ending in ['.png', '.jpeg', '.png', '.pgm', '.pnm', '.gif', '.tif', '.tiff']:\\n if np.max(data) <= 1.0 and np.min(data) >= 0:\\n np.int8(np.clip(data * 256, 0, 255))\\n imsave(filename + ending, data.squeeze())\\n else:\\n # ending in ['.nii', '.hdr', '.nii.gz', '.gz', '.dcm'] or len(data.squeeze().shape) > 2:\\n if self.correct_orientation and tporigin is not None:\\n # we corrected the orientation and we have the information to undo our wrongs, lets go:\\n aligned_data = Volume(data, np.eye(4), \\\"RAS\\\") # dummy initialisation if everything else fails\\n try:\\n tporigin_vol = ni.open_image(os.path.join(tporigin, self.maskfiles[0]), verbose=False)\\n except:\\n try:\\n tporigin_vol = ni.open_image(os.path.join(tporigin, self.featurefiles[0]), verbose=False)\\n except Exception as e:\\n logging.getLogger('data').warning('could not correct orientation for file {} from {}'\\n .format(filename, tporigin))\\n logging.getLogger('data').debug('because {}'.format(e))\\n try:\\n aligned_vol = Volume(data, tporigin_vol.aligned_transformation, tporigin_vol.system)\\n aligned_data = aligned_vol.copy_like(tporigin_vol)\\n except Exception as e:\\n logging.getLogger('data').warning('could not correct orientation for file {} from {}'\\n .format(filename, tporigin))\\n logging.getLogger('data').debug('because {}'.format(e))\\n\\n finally:\\n ni.save_volume(filename + \\\".nii.gz\\\", aligned_data, True)\\n else:\\n if self.correct_orientation:\\n logging.getLogger('data').warning(\\n 'could not correct orientation for file {} since tporigin is None: {}'\\n .format(filename, tporigin))\\n nib.save(nib.Nifti1Image(data, self.affine), filename + \\\".nii.gz\\\")\",\n \"def check_for_inversion(cxr_img_norm):\\n\\n # Define image rim\\n rim_thickness = max(np.shape(cxr_img_norm)) // 20\\n rim_array = [\\n list(cxr_img_norm[:rim_thickness, :].flatten()),\\n list(cxr_img_norm[:, :rim_thickness].flatten()),\\n list(cxr_img_norm[-rim_thickness:, :].flatten()),\\n list(cxr_img_norm[:, -rim_thickness:].flatten())]\\n\\n rim_list = [pixel for rim in rim_array for pixel in rim]\\n\\n # Compare mean of rim to mean of whole image\\n img_mean = np.mean(cxr_img_norm)\\n rim_mean = np.mean(np.array(rim_list))\\n\\n inversion_check = (rim_mean > img_mean)\\n\\n return inversion_check\",\n \"def test_array_orientation_consistency_tilt():\\n samples = 128\\n p = FringeZernike(Z2=1000, samples=samples)\\n ps = PSF.from_pupil(p, 1)\\n idx_y, idx_x = np.unravel_index(ps.data.argmax(), ps.data.shape) # row-major y, x\\n assert idx_x == ps.center_x\\n assert idx_y > ps.center_y\",\n \"def correct(img_src, shift, destfile, crop=None):\\n (y0, y1, x0, x1) = crop\\n (shift_y, shift_x) = shift\\n tf_shift = transform.SimilarityTransform(translation=[shift_x, shift_y])\\n img = transform.warp(img_src, tf_shift)\\n res = img[-y0:-y1, -x0:-x1, :]\\n io.imsave(destfile, res)\\n return destfile\",\n \"def _correct_image(self, image):\\n return Image(image.data, self._rotation_offset, self._dx, self._dy, self._timestamp).data\",\n \"def testTranslate(self):\\n (w,h) = self.im8_1.getSize()\\n \\n self.im8_1.reset()\\n self.im8_1.setPixel(128, (w//2,h//2))\\n \\n for i in range(10):\\n xi = random.randint(-w//4,w//4)\\n yi = random.randint(-h//4,h//4)\\n translate(self.im8_1, self.im8_2, xi, yi, 0)\\n self.im8_3.reset()\\n self.im8_3.setPixel(128, (w//2+xi,h//2+yi))\\n (x,y) = compare(self.im8_2, self.im8_3, self.im8_2)\\n self.assertTrue(x<0)\\n translate(self.im8_1, self.im8_2, -xi, -yi, 0)\\n self.im8_3.reset()\\n self.im8_3.setPixel(128, (w//2-xi,h//2-yi))\\n (x,y) = compare(self.im8_2, self.im8_3, self.im8_2)\\n self.assertTrue(x<0)\",\n \"def rotated(self):\\n return self.pol_lat != 90.\",\n \"def test_random_vertical_flip(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = RandomVerticalFlip(prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\\n \\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = RandomVerticalFlip(prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\",\n \"def collate_fn_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n flip = random.randint(1, 10000)%2\\n # Do flipping\\n # 0 = left, 1 = right\\n hand_side = 1\\n if flip:\\n hand_side = 0 \\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if flip:\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd, hand_side\",\n \"def equals(self, other: InputTransform) -> bool:\\n return super().equals(other=other) and (self.reverse == other.reverse)\",\n \"def isinvertible(self):\\n if np.all(np.abs(self.maroots) > 1):\\n return True\\n else:\\n return False\",\n \"def diff_image(images):\\n prev_image = cv2.absdiff(images[0], images[1])\\n cur_image = cv2.absdiff(images[1], images[2])\\n return cv2.bitwise_and(prev_image, cur_image)\",\n \"def _hasChangedDirection(motionPts: list) -> tuple:\\n dispPts = Ball._getDisplacements(motionPts)\\n xDir = yDir = None\\n xChange = yChange = False\\n for dispPt in dispPts:\\n # Compute differences\\n xDirNow = RIGHT if dispPt[0] > 0 else LEFT\\n yDirNow = DOWN if dispPt[1] > 0 else UP\\n # Look for x changes\\n if xDir is None:\\n xDir = xDirNow\\n elif xDirNow != xDir:\\n xChange = True\\n # Look for y changes\\n if yDir is None:\\n yDir = yDirNow\\n elif yDirNow != yDir:\\n yChange = True\\n return xChange, yChange\",\n \"def is_new_based_on_imgs(soup):\\n\\n \\n \\n prev_hashes = get_prev_img_hashes()\\n temp_hashes = get_temp_img_hashes(soup)\\n\\n if len(temp_hashes.difference(prev_hashes))>0:\\n print(\\\"new, based on images\\\")\\n return True\\n else:\\n return False\",\n \"def _check_normalization(self):\\n lastDistance = None\\n distance = None\\n for idx in xrange(len(self) - 1):\\n distance = self[idx+1][0] - self[idx][0]\\n\\n # first run\\n if lastDistance is None:\\n lastDistance = distance\\n continue\\n\\n if lastDistance != distance:\\n return False\\n\\n lastDistance = distance\\n\\n return True\",\n \"def _check_orig(self):\\n if self.is_dir():\\n self._orig = False\\n return\\n\\n parts = self._path.split('.')\\n try:\\n if parts[-1] == 'tgz':\\n self._orig = True\\n elif parts[-2] == 'tar':\\n if (parts[-1] in Compressor.Opts or\\n parts[-1] in Compressor.Aliases):\\n self._orig = True\\n except IndexError:\\n self._orig = False\",\n \"def is_inverse(self, other):\\n return (self * other).is_identity() and (other * self).is_identity()\",\n \"def img_compare(file1, file2):\\n # read image\\n img1 = Image.open(file1)\\n img2 = Image.open(file2)\\n\\n # resize \\n size = 128, 128\\n img1_res = img_resize(img1, size)\\n img2_res = img_resize(img2, size)\\n\\n img1_res.save(\\\"img_1.thumbnail\\\", \\\"JPEG\\\")\\n img2_res.save(\\\"img_2.thumbnail\\\", \\\"JPEG\\\")\\n\\n # convert to gray scale\\n img1_grayscale = img1_res.convert('LA')\\n img1_grayscale.save(\\\"img_1_grayscale.png\\\")\\n\\n img2_grayscale = img2_res.convert('LA')\\n img2_grayscale.save(\\\"img_2_grayscale.png\\\")\\n\\n # normalise\\n img1_norm = normalize(np.array(img1_grayscale.getdata()).astype(float))\\n img2_norm = normalize(np.array(img2_grayscale.getdata()).astype(float))\\n\\n try:\\n # compare two images\\n diff = img1_norm - img2_norm\\n m_norm = sum(abs(diff)) # Manhattan norm\\n z_norm = norm(diff.ravel(), 0) # Zero norm\\n\\n # print(\\\"Manhattan norm:\\\", m_norm, \\\"/ per pixel:\\\", m_norm/img1_norm.size)\\n # print(\\\"Zero norm:\\\", z_norm, \\\"/ per pixel:\\\", z_norm*1.0/img1_norm.size)\\n\\n return m_norm/img1_norm.size, float(z_norm) / img1_norm.size\\n except:\\n return 100, 100\",\n \"def can_rotate(self, current_piece):\\n rotated_shape = current_piece.template[current_piece.next_rotation()] \\n for x in range(pieces.Piece.TEMPLATE_WIDTH):\\n for y in range(pieces.Piece.TEMPLATE_HEIGHT):\\n board_x = current_piece.get_pos_x() + x\\n board_y = current_piece.get_pos_y() + y \\n if board_x < 0 and rotated_shape[y][x]:\\n return False\\n if board_y < 0 and rotated_shape[y][x]:\\n return False\\n if board_x >= game_config.BOARD_BOX_COUNT_X:\\n return False\\n if board_y >= game_config.BOARD_BOX_COUNT_Y:\\n return False\\n if self.board.get_cell(board_x, board_y) and rotated_shape[y][x]:\\n return False\\n return True\",\n \"def _diff_images(img_before, img_after):\\n width_before, height_before = img_before.size\\n width_after, height_after = img_after.size\\n data_before = img_before.getdata()\\n data_after = img_after.getdata()\\n\\n width, height = max(width_before, width_after), max(height_before, height_after)\\n offset_ax = (width - width_before) // 2\\n offset_ay = (height - height_before) // 2\\n offset_bx = (width - width_after) // 2\\n offset_by = (height - height_after) // 2\\n\\n diff = 0\\n for y in range(height):\\n for x in range(width):\\n ax, ay = x - offset_ax, y - offset_ay\\n bx, by = x - offset_bx, y - offset_by\\n if (ax < 0 or bx < 0 or ax >= width_before or bx >= width_after or\\n ay < 0 or by < 0 or ay >= height_before or by >= height_after):\\n diff += 1\\n else:\\n if data_before[ax + ay *width_before] != data_after[bx + by * width_after]:\\n diff += 1\\n try:\\n return round(diff / float(width * height), 4)\\n except ZeroDivisionError:\\n return 0.0\",\n \"def is_symetric(self):\\n for x, y in _triangle_range(self.size):\\n\\n if self.read(x, y) != self.read(y, x):\\n return False\\n\\n return True\",\n \"def __flip(self, image, landmarks, run_prob=0.5):\\n if np.random.rand() < run_prob:\\n return image, landmarks\\n image = np.fliplr(image)\\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\\n return image, landmarks\",\n \"def check_2x2_solved(self):\\n return self._grid[0][0] == 0 and self._grid[0][1] == 1 \\\\\\n and self._grid[1][0] == self._width*1 and self._grid[1][1] == (1 + self._width * 1)\",\n \"def is_versor(self) -> bool:\\n return np.isclose(np.linalg.norm(self.A), 1.0)\",\n \"def mirror(img):\\n return img[:, ::-1]\",\n \"def is_versor(self) -> np.ndarray:\\n return np.isclose(np.linalg.norm(self.array, axis=1), 1.0)\",\n \"def assert_data_correct(self) -> bool:\\n corr_char = self.assert_data_characters_correct()\\n print(\\\"Character data correct?\\\", corr_char)\\n corr_font = FontImages().assert_data_correct()\\n print(\\\"Font data correct?\\\", corr_font)\\n corr_frag = self.assert_data_fragments_correct()\\n print(\\\"Fragment data correct?\\\", corr_frag)\\n corr_train_aug = self.assert_train_augmented()\\n print(\\\"Train data augmented?\\\", corr_train_aug)\\n truth_agree = corr_char and corr_font and corr_frag\\n return True if truth_agree else False\",\n \"def verify(self):\\n if not self.verify_succ_pred_fingers():\\n return False\\n\\n return True\",\n \"def compare_faces(encodings, encoding_to_check):\\n\\n return list(np.linalg.norm(encodings - encoding_to_check, axis = 1))\",\n \"def test_flip():\\n template_r = np.array([\\n [0.5, 0],\\n [0.7, 0],\\n ])\\n template_g = np.array([\\n [0.9, 0],\\n [0.2, 0],\\n ])\\n template_b = np.array([\\n [0.1, 0],\\n [0.4, 0],\\n ])\\n template = np.dstack([template_r, template_g, template_b])\\n return template, np.flipud(np.fliplr(template))\",\n \"def collate_fn_no_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if self.pred_img_side == 'left':\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd\",\n \"def _compositions_swapped(self, thermo):\\n assert self._ref_indicators is not None\\n\\n indicators = self._singlet_comparison(thermo)\\n\\n for list1, list2 in zip(indicators, self._ref_indicators):\\n comp_swapped = True\\n for ind1, ind2 in zip(list1, list2):\\n if ind1 == ind2:\\n comp_swapped = False\\n if comp_swapped:\\n return True\\n return False\",\n \"def assertWarp(self):\\n if self.rect.size.height != 256 or self.rect.width != 128:\\n raise ValueError(\\\"Bad image size for body warped image\\\")\\n if self.format != self.format.R8G8B8:\\n raise ValueError(\\\"Bad image format for warped image, must be R8G8B8\\\")\",\n \"def test_inverse_order_true(self):\\n percentiles_cube = self.test_cube.copy(\\n data=np.flipud(self.test_cube.data))\\n plugin_instance = ProbabilitiesFromPercentiles2D(\\n percentiles_cube, 'new_name')\\n self.assertTrue(plugin_instance.inverse_ordering)\",\n \"def check_scaled_shape(orig: torch.Tensor, scaled: torch.Tensor, scale_factor: float) -> bool:\\n N, C, H, W = orig.shape\\n Hc = int(scale_factor * H)\\n Wc = int(scale_factor * W)\\n\\n return scaled.shape == (N, C, Hc, Wc)\",\n \"def chk_vert_sym(self):\\n for j in xrange(self.width):\\n for i in xrange(int(round(self.height/2))):\\n if self.rows[i][j] == self.rows[self.height - (i + 1)][j]:\\n continue\\n else:\\n return False\\n return True\",\n \"def is3DImage(self):\\n\\t\\treturn self.is3D\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7891626","0.7111249","0.588529","0.5814684","0.579397","0.5752564","0.5637771","0.5609224","0.5603559","0.5602122","0.55922","0.5581342","0.5511366","0.5511366","0.5508238","0.54916257","0.545488","0.54529166","0.5440112","0.5437185","0.5426509","0.54239786","0.5414612","0.5376516","0.5331621","0.53161705","0.5309192","0.52966225","0.52963984","0.52750075","0.52750075","0.52750075","0.52750075","0.52602804","0.5240879","0.524012","0.52373064","0.5233345","0.52282894","0.52218115","0.519064","0.5178225","0.5173376","0.5146969","0.51421416","0.5132427","0.51225","0.51012844","0.51010126","0.5099131","0.50921935","0.5085102","0.50791585","0.5065076","0.5050663","0.5047774","0.50467736","0.50412893","0.5039912","0.5038952","0.5030319","0.50274986","0.500612","0.50050855","0.5003157","0.50024796","0.49795097","0.4968203","0.4960242","0.4941347","0.4935197","0.49313053","0.49295717","0.4925282","0.492485","0.49214888","0.49187547","0.49164483","0.49148148","0.49083102","0.49029592","0.4902518","0.48959774","0.4893855","0.48931098","0.48925936","0.48831174","0.4882616","0.48801786","0.48767793","0.48751163","0.48717496","0.48689964","0.48672983","0.48390704","0.48387656","0.48381668","0.48371324","0.48324543","0.4831778"],"string":"[\n \"0.7891626\",\n \"0.7111249\",\n \"0.588529\",\n \"0.5814684\",\n \"0.579397\",\n \"0.5752564\",\n \"0.5637771\",\n \"0.5609224\",\n \"0.5603559\",\n \"0.5602122\",\n \"0.55922\",\n \"0.5581342\",\n \"0.5511366\",\n \"0.5511366\",\n \"0.5508238\",\n \"0.54916257\",\n \"0.545488\",\n \"0.54529166\",\n \"0.5440112\",\n \"0.5437185\",\n \"0.5426509\",\n \"0.54239786\",\n \"0.5414612\",\n \"0.5376516\",\n \"0.5331621\",\n \"0.53161705\",\n \"0.5309192\",\n \"0.52966225\",\n \"0.52963984\",\n \"0.52750075\",\n \"0.52750075\",\n \"0.52750075\",\n \"0.52750075\",\n \"0.52602804\",\n \"0.5240879\",\n \"0.524012\",\n \"0.52373064\",\n \"0.5233345\",\n \"0.52282894\",\n \"0.52218115\",\n \"0.519064\",\n \"0.5178225\",\n \"0.5173376\",\n \"0.5146969\",\n \"0.51421416\",\n \"0.5132427\",\n \"0.51225\",\n \"0.51012844\",\n \"0.51010126\",\n \"0.5099131\",\n \"0.50921935\",\n \"0.5085102\",\n \"0.50791585\",\n \"0.5065076\",\n \"0.5050663\",\n \"0.5047774\",\n \"0.50467736\",\n \"0.50412893\",\n \"0.5039912\",\n \"0.5038952\",\n \"0.5030319\",\n \"0.50274986\",\n \"0.500612\",\n \"0.50050855\",\n \"0.5003157\",\n \"0.50024796\",\n \"0.49795097\",\n \"0.4968203\",\n \"0.4960242\",\n \"0.4941347\",\n \"0.4935197\",\n \"0.49313053\",\n \"0.49295717\",\n \"0.4925282\",\n \"0.492485\",\n \"0.49214888\",\n \"0.49187547\",\n \"0.49164483\",\n \"0.49148148\",\n \"0.49083102\",\n \"0.49029592\",\n \"0.4902518\",\n \"0.48959774\",\n \"0.4893855\",\n \"0.48931098\",\n \"0.48925936\",\n \"0.48831174\",\n \"0.4882616\",\n \"0.48801786\",\n \"0.48767793\",\n \"0.48751163\",\n \"0.48717496\",\n \"0.48689964\",\n \"0.48672983\",\n \"0.48390704\",\n \"0.48387656\",\n \"0.48381668\",\n \"0.48371324\",\n \"0.48324543\",\n \"0.4831778\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8528314"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":593,"cells":{"query":{"kind":"string","value":"make request to subredit and return numbers of subscribers"},"document":{"kind":"string","value":"def recurse(subreddit, hot_list=[]):\n headers = {'User-Agent': 'Mauricio'}\n\n url = 'http://www.reddit.com/r/' + subreddit + '/hot/.json'\n r = requests.get(url, headers=headers, params=parameters)\n if r.status_code == 200:\n answer_list_10 = r.json().get('data').get('children')\n for top in range(len(answer_list_10)):\n hot_list.append((answer_list_10[top].get('data').get('title')))\n if len(answer_list_10) >= 100:\n parameters['after'] = r.json().get('data').get('after')\n recurse(subreddit, hot_list)\n return(hot_list)\n else:\n return(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 number_of_subscribers(subreddit):\n\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n headers = {\"User-Agent\": \"my-integration/1.2.3\"}\n\n response = get(url=url, headers=headers)\n\n if response.status_code == 200:\n # print(response.json())\n\n response_json = response.json()\n data = response_json.get('data')\n subscribers = data.get(\"subscribers\")\n\n return subscribers\n\n return 0","def number_of_subscribers(subreddit):\n url = \"https://api.reddit.com/r/{}/about\".format(subreddit)\n header = {'User-Agent': 'CustomClient/1.0'}\n request = requests.get(url, headers=header, allow_redirects=False)\n\n if request.status_code != 200:\n return 0\n jreq = request.json()\n\n if 'data' in jreq:\n return jreq.get(\"data\").get(\"subscribers\")\n else:\n return 0","def number_of_subscribers(subreddit):\n\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n headers = {'user-agent': 'request'}\n response = requests.get(url, headers=headers, allow_redirects=False)\n if str(response) != '<Response [200]>':\n return 0\n response_json = response.json()\n subs = response_json.get('data').get('subscribers')\n return subs","def number_of_subscribers(subreddit):\n\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\n\n headers = {'User-Agent': 'My User Agent 1.0'}\n\n request = requests.get(url, headers=headers)\n req = request.json()\n\n if request.status_code == 404:\n return 0\n\n subs = req.get('data').get('subscribers')\n return subs","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}/about.json\"\n headers = {\n 'User-Agent': 'My User Agent 1.0',\n 'From': 'youremail@domain.com'\n }\n r_subs = requests.get(url.format(subreddit), headers=headers)\n if r_subs.status_code == 200:\n data = r_subs.json()['data']\n subscribers = data.get('subscribers')\n if subscribers is not None:\n return subscribers\n return 0","def number_of_subscribers(subreddit):\n h = {'user-agent': 'GEEK1050'}\n link = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n req = requests.get(link, headers=h)\n\n req_data = req.json().get(\"data\").get(\"subscribers\")\n for element in req_data['children']:\n print(element['children']['title'])","def number_of_subscribers(subreddit):\n header = {'User-Agent': 'Chrome/90.0.4430.212 Safari/537.36'}\n req = requests.get('https://www.reddit.com/r/{}/about.json'\n .format(subreddit), allow_redirects=False,\n headers=header)\n if req.status_code == 200:\n subscribers = req.json().get('data').get('subscribers')\n return subscribers\n else:\n return 0","def number_of_subscribers(subreddit):\n header = {\"User-agent\": \"darth\"}\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n response = (requests.get(url, headers=header))\n if response.status_code != 200:\n return 0\n return response.json().get('data').get('subscribers')","def number_of_subscribers(subreddit):\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\n response = requests.get(url,\n allow_redirects=False,\n headers={'User-Agent': 'MyChromeBook'})\n if response:\n suscribers_number = response.json().get('data').get('subscribers')\n return suscribers_number\n else:\n return 0","def number_of_subscribers(subreddit):\n URL = 'https://api.reddit.com/r/{}/about'.format(subreddit)\n header = {'User-Agent': 'Custom-User'}\n\n resp = requests.get(URL, headers=header).json()\n try:\n return resp['data']['subscribers']\n except Exception:\n return 0","def count_subscribers(self):\n return self.request(\"count:Contact\", [ None ])","def number_of_subscribers(subreddit):\n url = requests.get(\"https://www.reddit.com/r/{}/about.json\"\n .format(subreddit), headers={\"User-Agent\": \"kalkidan\"})\n if url.status_code == 200:\n return url.json().get(\"data\").get(\"subscribers\")\n else:\n return 0","def number_of_subscribers(subreddit):\n link = 'http://www.reddit.com/r/{}/about.json'.format(subreddit)\n red = requests.get(link, headers={'User-Agent': 'tope628'}).json()\n try:\n subs = red.get('data').get('subscribers')\n except:\n return 0\n if red is None:\n return 0\n return subs","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n header = {\"Content-Type\": \"application/json\",\n \"User-Agent\": \"Mozilla/5.0\"}\n request = requests.get(\n url,\n headers=header,\n allow_redirects=False)\n if request.status_code >= 300:\n return 0\n return json.loads(request.content.decode(\"utf-8\"))[\"data\"][\"subscribers\"]","def number_of_subscribers(subreddit):\n r = requests.get('https://api.reddit.com/r/{}/about.json'\n .format(subreddit),\n headers={'user-agent': 'ianscustomthing'},\n allow_redirects=False)\n rj = r.json()\n if rj.get('message') == 'Not Found':\n return 0\n s = rj.get('data').get('subscribers')\n return s","def number_of_subscribers(subreddit):\n\n import requests\n\n resInf = requests.get(\"https://www.reddit.com/r/{}/about.json\"\n .format(subreddit),\n headers={\"User-Agent\": \"My-User-Agent\"},\n allow_redirects=False)\n if resInf.status_code >= 300:\n return 0\n\n return resInf.json().get(\"data\").get(\"subscribers\")","def number_of_subscribers(subreddit):\n import requests\n headers = {'User-Agent': 'Godfather'}\n about = requests.get(\n 'https://www.reddit.com/r/{}/about.json'.format(\n subreddit), headers=headers).json()\n try:\n subscribers = about.get('data').get('subscribers')\n if subscribers is None:\n raise TypeError\n return subscribers\n except:\n return 0","def number_of_subscribers(subreddit):\n url = 'https://www.reddit.com/r/{}/about.json'\n headers = {'user-agent': 'X-Modhash'}\n url_format = requests.get(url.format(subreddit), headers=headers).json()\n try:\n name = url_format['data']['subscribers']\n return name\n except:\n return 0","def number_of_subscribers(subreddit):\n url_rsubs = \"https://api.reddit.com/r/{}/about\".format(subreddit)\n headers = {'User-Agent': 'Python3'}\n response = requests.get(url_rsubs, headers=headers,\n allow_redirects=False)\n if str(response) != \"<Response [200]>\":\n return 0\n r_json = response.json()\n subs_count = r_json.get('data').get('subscribers')\n return subs_count","def number_of_subscribers(subreddit):\n response = requests.get('https://www.reddit.com/r/{}/about.json'\n .format(subreddit),\n headers={'User-Agent': 'Camilo@holberton'},\n allow_redirects=False)\n if response.status_code == 200:\n response = response.json()\n data = response.get('data')\n subs_count = data.get('subscribers')\n if data and subs_count:\n return subs_count\n return 0","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}.json\".format(subreddit)\n r = requests.get(url, headers={'User-agent': 'shoji'},\n allow_redirects=False)\n data = r.json()\n if not r.status_code == 200:\n return 0\n try:\n sub = data.get(\"data\")\n children = sub.get(\"children\")\n subreddit = children[0].get(\"data\")\n subscriber_count = subreddit.get(\"subreddit_subscribers\")\n except Exception as e:\n print(\"Something went wrong\\n {}\".format(e))\n return 0\n\n return subscriber_count","def number_of_subscribers(subreddit):\n if subreddit is None or type(subreddit) is not str:\n return 0\n BASE_URL = 'http://www.reddit.com/r/{}/about.json'\n head = {'User-Agent': 'Mozilla/5.0'}\n r = requests.get(BASE_URL.format(subreddit), headers=head)\n return r.json().get('data', {}).get('subscribers', 0)","def number_of_subscribers(subreddit):\n # Set the Default URL strings\n base_url = 'https://www.reddit.com'\n api_uri = '{base}/r/{subreddit}/about.json'.format(base=base_url,\n subreddit=subreddit)\n\n # Set an User-Agent\n user_agent = {'User-Agent': 'Python/requests'}\n\n # Get the Response of the Reddit API\n res = requests.get(api_uri, headers=user_agent,\n allow_redirects=False)\n\n # Checks if the subreddit is invalid\n if res.status_code in [302, 404]:\n return 0\n\n # Returns the total subscribers of the subreddit\n return res.json().get('data').get('subscribers')","def test_json_get_subscribers(self) -> None:\n stream_name = gather_subscriptions(self.user_profile)[0][0][\"name\"]\n stream_id = get_stream(stream_name, self.user_profile.realm).id\n expected_subscribers = gather_subscriptions(self.user_profile, include_subscribers=True)[0][\n 0\n ][\"subscribers\"]\n result = self.client_get(f\"/json/streams/{stream_id}/members\")\n result_dict = self.assert_json_success(result)\n self.assertIn(\"subscribers\", result_dict)\n self.assertIsInstance(result_dict[\"subscribers\"], list)\n subscribers: List[int] = []\n for subscriber in result_dict[\"subscribers\"]:\n self.assertIsInstance(subscriber, int)\n subscribers.append(subscriber)\n self.assertEqual(set(subscribers), set(expected_subscribers))","def test_get_subscriptions_auth(self):\n url = reverse('xds_api:interest-list-subscriptions')\n _, token = AuthToken.objects.create(self.user_1)\n # subscribe user 1 to interest list 3\n self.list_3.subscribers.add(self.user_1)\n self.list_3.save()\n response = self.client \\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\n responseDict = json.loads(response.content)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(self.list_3.subscribers.all()),\n len(responseDict))","def test_get_subscriptions(self):\n pass","def test_successful_subscriptions_list_subscribers(self) -> None:\n result = self.api_get(\n self.test_user,\n \"/api/v1/users/me/subscriptions\",\n {\"include_subscribers\": \"true\"},\n )\n json = self.assert_json_success(result)\n self.assertIn(\"subscriptions\", json)\n for stream in json[\"subscriptions\"]:\n self.assertIsInstance(stream[\"name\"], str)\n self.assertIsInstance(stream[\"color\"], str)\n self.assertIsInstance(stream[\"invite_only\"], bool)\n # check that the stream name corresponds to an actual\n # stream; will throw Stream.DoesNotExist if it doesn't\n get_stream(stream[\"name\"], self.test_realm)\n list_streams = [stream[\"name\"] for stream in json[\"subscriptions\"]]\n # also check that this matches the list of your subscriptions\n self.assertEqual(sorted(list_streams), sorted(self.streams))","def test_subscriber(self) -> None:\n stream_name = gather_subscriptions(self.user_profile)[0][0][\"name\"]\n self.make_successful_subscriber_request(stream_name)","def get_subscribed_users(self, obj):\n return obj.subscribed_users.count()","def main():\n credentials = get_credentials()\n http = credentials.authorize(httplib2.Http())\n service = discovery.build('reseller', 'v1', http=http)\n\n results = service.subscriptions().list(maxResults=10).execute()\n subscriptions = results.get('subscriptions', [])\n if not subscriptions:\n print('No subscriptions found.')\n else:\n print('Subscriptions:')\n for subscription in subscriptions:\n print('{0} ({1}, {2})'.format(subscription['customerId'],\n subscription['skuId'], subscription['plan']['planName']))","def _count_subscriptions(self):\n for partner in self:\n subscriptions = self.env['subscription.subscription']\n count = subscriptions.sudo().search_count([('partner_id', '=', partner.id)])\n for child in partner.child_ids:\n count += subscriptions.sudo().search_count([('partner_id', '=', child.id)])\n partner.subscriptions_count = count","def get_subscriber_count(self, response):\n return response.css('.yt-subscriber-count')\\\n .extract_first(default='')","def get_subscriber(self, subscriber_id):\n req_data = [ str(subscriber_id) ]\n return self.request(\"find:Contact.stats\", req_data)","def subscribers(id):\n return core.query(schema.streamBySubscribers, id)","def test_get_subscription(self):\n pass","def get_freq(urn, top=50, cutoff=3):\n r = requests.get(\"https://api.nb.no/ngram/urnfreq\", json={'urn':urn, 'top':top, 'cutoff':cutoff})\n return Counter(dict(r.json()))","def all_client_number():\n\n url = CMX_URL + '/api/location/v2/clients/count'\n header = {'content-type': 'application/json', 'accept': 'application/json'}\n response = requests.get(url, headers=header, auth=CMX_AUTH, verify=False)\n response_json = response.json()\n clients_number = response_json['count']\n return clients_number","def get_subscriptions(self):\n url = '{}/v2/subscriptions'.format(self.url)\n r = requests.get(url, headers=self.headers_v2)\n return r.json()","def test_interest_list_subscribe(self):\n list_id = self.list_2.pk\n url = reverse('xds_api:interest-list-subscribe', args=(list_id,))\n _, token = AuthToken.objects.create(self.user_1)\n response = self.client \\\n .patch(url, HTTP_AUTHORIZATION='Token {}'.format(token))\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(self.list_2.subscribers.all()), 1)","def invitation_received_no(request):\n if request.user.is_authenticated:\n profile_obj = CustomUser.objects.get(id__exact=request.user.id)\n qs_count = Relationship.objects.invitation_received(profile_obj).count()\n return {'invites_num': qs_count}\n return {}","def buildSubscriptionList(self):\r\n self._clearLists()\r\n unreadById = {}\r\n\r\n if not self.userId:\r\n self.getUserInfo()\r\n\r\n unreadJson = self.httpGet(ReaderUrl.UNREAD_COUNT_URL, { 'output': 'json', })\r\n unreadCounts = json.loads(unreadJson, strict=False)['unreadcounts']\r\n for unread in unreadCounts:\r\n unreadById[unread['id']] = unread['count']\r\n\r\n feedsJson = self.httpGet(ReaderUrl.SUBSCRIPTION_LIST_URL, { 'output': 'json', })\r\n subscriptions = json.loads(feedsJson, strict=False)['subscriptions']\r\n\r\n for sub in subscriptions:\r\n categories = []\r\n if 'categories' in sub:\r\n for hCategory in sub['categories']:\r\n cId = hCategory['id']\r\n if not cId in self.categoriesById:\r\n category = Category(self, hCategory['label'], cId)\r\n self._addCategory(category)\r\n categories.append(self.categoriesById[cId])\r\n\r\n try:\r\n feed = self.getFeed(sub['id'])\r\n if not feed:\r\n raise\r\n if not feed.title:\r\n feed.title = sub['title']\r\n for category in categories:\r\n feed.addCategory(category)\r\n feed.unread = unreadById.get(sub['id'], 0)\r\n except:\r\n feed = Feed(self,\r\n sub['title'],\r\n sub['id'],\r\n sub.get('htmlUrl', None),\r\n unreadById.get(sub['id'], 0),\r\n categories)\r\n if not categories:\r\n self.orphanFeeds.append(feed)\r\n self._addFeed(feed)\r\n\r\n specialUnreads = [id for id in unreadById\r\n if id.find('user/%s/state/com.google/' % self.userId) != -1]\r\n for type in self.specialFeeds:\r\n feed = self.specialFeeds[type]\r\n feed.unread = 0\r\n for id in specialUnreads:\r\n if id.endswith('/%s' % type):\r\n feed.unread = unreadById.get(id, 0)\r\n break\r\n\r\n return True","def subscriptions(id='None'):\n\trows = mongo_data({}, [\"publisher_id\",\"dt_hour\", \"new_subs\"],\"subscribers\")\n\t#returns [{_id:...,field1:...,field2:...}]\n\n\n\tCOLS = [\"publisher_id\", \"dt_hour\", \"new subs\"]\n\tROWS = [[y[\"publisher_id\"],y[\"dt_hour\"],y[\"new_subs\"]] for y in rows]\n\n\tTITLE = 'SUBSCRIPTIONS'\n\n\treturn render_template(\"simple_tester_report.html\", cols=COLS, rows=ROWS, report_title=TITLE);","def test_listuser():\n url = baseUrl + userurl + listurl\n logging.info(\"List users\")\n r = requests.get(url, headers=header)\n assert r.status_code == 200\n resp = r.json()\n global user_ids\n user_ids = []\n if resp is None:\n pass\n else:\n user_num = len(resp)\n for k in range(0, user_num):\n assert resp[k]['subscriptionIds'][0] == subscriptionid\n if resp[k][\"isActive\"] is True:\n user_ids.append(resp[k][\"id\"])\n print (user_ids)\n assert user_id in user_ids","def get_subscribers(cls, topic, count, starting_at_callback=None):\n\t\tquery = cls.all()\n\t\tquery.filter('topic_hash =', utils.sha1_hash(topic))\n\t\tquery.filter('subscription_state = ', cls.STATE_VERIFIED)\n\t\tif starting_at_callback:\n\t\t\tquery.filter('callback_hash >=', utils.sha1_hash(starting_at_callback))\n\t\tquery.order('callback_hash')\n\n\t\treturn query.fetch(count)","def fetchTAC(self):\n\n last_hour = datetime.datetime.now().date() - datetime.timedelta(hours = 1)\n last_hour = \"{}{}{}\".format(\"'\", last_hour, \"'\")\n last_hour = datetime.date(2011, 4, 5)\n\n self.hlr_cur.execute(\"SELECT id FROM Subscriber WHERE updated >= {date};\".format(date = last_hour))\n subscribers = self.hlr_cur.fetchall()\n\n parsed_data = {}\n unique_imei = {}\n #uid_count = 0\n\n for subscriber in subscribers:\n self.hlr_cur.execute(\"SELECT IMEI FROM Equipment WHERE id = (SELECT equipment_id FROM EquipmentWatch WHERE subscriber_id = {s_id});\".format(s_id = subscriber[0]))\n parsed_imei = self.hlr_cur.fetchall()\n\n if len(parsed_imei) > 0:\n for imei in parsed_imei:\n imei_number = imei[0] \n\n if imei_number not in unique_imei:\n unique_imei[imei_number] = subscriber[0]\n\n uid = unique_imei[imei_number]\n parsed_data.setdefault((uid), str(imei_number)[:8])\n\n self.saveRecords(parsed_data)","def list_subscriptions(self):\n return {'abonnementen': self.customer.abonnementen}","def test_json_get_subscribers_for_guest_user(self) -> None:\n guest_user = self.example_user(\"polonius\")\n never_subscribed = gather_subscriptions_helper(guest_user, True).never_subscribed\n\n # A guest user can only see never subscribed streams that are web-public.\n # For Polonius, the only web-public stream that he is not subscribed at\n # this point is Rome.\n self.assert_length(never_subscribed, 1)\n\n web_public_stream_id = never_subscribed[0][\"stream_id\"]\n result = self.client_get(f\"/json/streams/{web_public_stream_id}/members\")\n result_dict = self.assert_json_success(result)\n self.assertIn(\"subscribers\", result_dict)\n self.assertIsInstance(result_dict[\"subscribers\"], list)\n self.assertGreater(len(result_dict[\"subscribers\"]), 0)","def get_count(username):\n return get_contributor(username)[\"count\"]","def count(cls, client) :\n try :\n obj = nshttpprofile()\n option_ = options()\n option_.count = True\n response = obj.get_resources(client, option_)\n if response :\n return response[0].__dict__['___count']\n return 0\n except Exception as e :\n raise e","def count(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'count')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def client_count(request):\n return request.param","def test_get_total_users_get(self):\n pass","def test_is_ims_sub_activities(self):\r\n emaSession = ema_functions.emaLogin()\r\n session = {}\r\n session['emaSession'] = emaSession\r\n sub1 = class_ims_ema.sub('+353760000001')\r\n #test1 = sub1.subscriberCreate(session)\r\n test2 = sub1.subscriberGet(session)\r\n #test3 = sub1.subscriberDelete(session)\r\n test4 = sub1.subscriberGet(session)\r\n #self.assertTrue(test1.status_code == 200 and test2.status_code == 200 and test3.status_code == 200 and test4.status_code == 500)\r\n self.assertTrue(test2.status_code == 200 and test4.status_code == 500)","def count(cls, client) :\n\t\ttry :\n\t\t\tobj = lsntransportprofile()\n\t\t\toption_ = options()\n\t\t\toption_.count = True\n\t\t\tresponse = obj.get_resources(client, option_)\n\t\t\tif response :\n\t\t\t\treturn response[0].__dict__['___count']\n\t\t\treturn 0\n\t\texcept Exception as e :\n\t\t\traise e","def get_total_users(request):\n number_of_users = User.objects.count()\n res = {\n 'total_users': number_of_users,\n }\n return Response(res, status=status.HTTP_200_OK)","def get_count(type,baseurl,user,password):\n payload = {'request': 'count', 'type': type}\n r = requests.get(baseurl, params=payload, auth=HTTPBasicAuth(user, password), verify=False)\n return int(r.text)","def message_nums(request):\n if request.user.is_authenticated:\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\n else:\n return {}","def n_subimissions_per_day( url, headers ):","def get_members(base_url, end_url):\n reps, content_len, bill_info, votes = get_next_page(base_url, end_url, 1)\n return reps","def subscribers_by_id(self, repository_id, access_token=None):\n return self._complete_request_by_id(\n repository_id, \"subscribers\", access_token)","def test_getting_segment_subscribers(self):\n pass","def get_subscribers(self, \n order=\"created_at desc\",\n offset=None,\n count=None):\n req_data = [ None, order, fmt_paging(offset, count)]\n return self.request(\"query:Contact.stats\", req_data)","def test_search_regons(client):\n subjects, request_id = client.search_regons([\"755016841\", \"216973362\", \"862391869\"])\n\n assert len(subjects) == 3","def get_subscription(self):\n return self.request({\n 'path': '/' + UUID + '/subscription'})","def test_admin_sms_subscriber_view_list(self):\n response = self.client.get('/admin/sms_module/smscampaignsubscriber/')\n self.failUnlessEqual(response.status_code, 200)","async def get_subscriptions(\n self,\n\t\tfields: Optional[List[BaseUserGroupFields]] = None,\n\t\toffset: Optional[int] = None,\n\t\tcount: Optional[int] = None,\n\t\t**kwargs\n ) -> donut.GetSubscriptionsResponseModel:\n\n params = self.get_set_params(locals())\n response = await self.api.request(\"donut.getSubscriptions\", params)\n model = donut.GetSubscriptionsResponse\n return model(**response).response","def subscribers_by_name(self, username, repository_name, access_token=None):\n return self._complete_request_by_name(\n username, repository_name, \"subscribers\", access_token)","def subscribed(cls, team):\n return cls.query(\n cls.status == 'subscribe',\n cls.team == team.lower()\n ).fetch(100)","def test_process_subscriptions(self):\n pass","def test_import_subscribers(dbsession, registry, mailgun, populated_mailing_list):\n paginator = mailgun.list_members(populated_mailing_list)\n items = paginator[\"items\"]\n assert len(items) == 1\n assert items[0][\"address\"] == \"example@example.com\"","def get_subscribers(self) -> Iterator[Any]:\n for subscription in self._subscriptions[self.id]:\n yield subscription.subscriber","def countAndGetCallInvoice(self,id,start,finish):\n self.calls = 0\n return self.getNumOfInvoice(id,start,finish)","def count(request):\r\n n = request.user.profile.unread_message_count()\r\n data = {\r\n 'count': n,\r\n }\r\n return HttpResponse(json.dumps(data), mimetype='application/json')","def combined_inbox_count(request):\r\n count = 0\r\n for func in inbox_count_sources():\r\n counts = func(request)\r\n if counts:\r\n for value in counts.itervalues():\r\n try:\r\n count = count + int(value)\r\n except (TypeError, ValueError):\r\n pass\r\n return {'combined_inbox_count': count,}","def subscribers(self) -> pulumi.Output[Sequence['outputs.BudgetActionSubscriber']]:\n return pulumi.get(self, \"subscribers\")","def GET(self):\n web.header(\"Content-Type\",\"application/json; charset=utf-8\")\n data = web.input(module=\"module\")\n module = data[\"module\"]\n count = db_module.get_module_newsNum(module)\n result = json.dumps({\"count\": count})\n return result","def test_successful_subscriptions_list(self) -> None:\n result = self.api_get(self.test_user, \"/api/v1/users/me/subscriptions\")\n json = self.assert_json_success(result)\n self.assertIn(\"subscriptions\", json)\n for stream in json[\"subscriptions\"]:\n self.assertIsInstance(stream[\"name\"], str)\n self.assertIsInstance(stream[\"color\"], str)\n self.assertIsInstance(stream[\"invite_only\"], bool)\n # check that the stream name corresponds to an actual\n # stream; will throw Stream.DoesNotExist if it doesn't\n get_stream(stream[\"name\"], self.test_realm)\n list_streams = [stream[\"name\"] for stream in json[\"subscriptions\"]]\n # also check that this matches the list of your subscriptions\n self.assertEqual(sorted(list_streams), sorted(self.streams))","def do_GET(self):\n # Check that basic auth is used.\n authorization = self.headers.get(\"Authorization\")\n if authorization == \"\" or authorization is None:\n self.send_response(400)\n self.end_headers()\n return\n\n if \"/subscriptions\" in self.path:\n self.send_response(200)\n self.end_headers()\n self.wfile.write(json.dumps(sample_client_subscription).encode())\n else:\n self.send_response(200)\n self.end_headers()\n self.wfile.write(json.dumps(sample_client_list_response).encode())","def _get_notifications(self):\r\n student = self._student('GET')\r\n if student is None:\r\n self._error_response()\r\n\r\n else:\r\n self._success_response({\r\n 'student_sub_count': self.server.DUMMY_DATA['student_sub_count'],\r\n 'count_required': student.num_required,\r\n 'count_graded': student.num_graded,\r\n 'count_available': student.num_pending\r\n })","def count(self, sub, start=0, end=None):\n return count(self, sub, start, end)","def on_subscribe(self, request, ssn):\n if 'hub.challenge' not in request.GET:\n logger.error(f'Missing hub.challenge in subscription verification {ssn.pk}!')\n tasks.save.delay(\n pk = ssn.pk,\n subscribe_status = 'verifyerror',\n verifyerror_count = ssn.verifyerror_count + 1\n )\n return Response('Missing hub.challenge', status=HTTP_400_BAD_REQUEST)\n\n if not request.GET.get('hub.lease_seconds', '').isdigit():\n logger.error(f'Missing integer hub.lease_seconds in subscription verification {ssn.pk}!')\n tasks.save.delay(\n pk = ssn.pk,\n subscribe_status = 'verifyerror',\n verifyerror_count = ssn.verifyerror_count + 1\n )\n return Response('hub.lease_seconds required and must be integer', status=HTTP_400_BAD_REQUEST)\n\n if ssn.unsubscribe_status is not None:\n logger.error(f'Subscription {ssn.pk} received subscription verification request,'\n f' but its was explicitly unsubscribed before.')\n return Response('Unsubscribed')\n\n tasks.save.delay(\n pk = ssn.pk,\n subscribe_status = 'verified',\n lease_expiration_time = now() + timedelta(seconds=int(request.GET['hub.lease_seconds'])),\n connerror_count = 0,\n huberror_count = 0,\n verifyerror_count = 0,\n verifytimeout_count = 0\n )\n logger.info(f'Got {ssn.pk} subscribe confirmation from hub.')\n return HttpResponse(request.GET['hub.challenge'])","def update_db_and_get_subs(mail, login_info):\n subscribers = check_for_subscribers(mail, login_info)\n\n db_subs = []\n if 'subscribers' in db.keys():\n db_subs = db['subscribers']\n\n for sub in subscribers:\n if sub not in db_subs:\n print(f'New subscriber added: {sub}')\n db_subs.append(sub)\n subject = \"Welcome to F1 Digest!\"\n send_email(subject, subscribe_body, sub, login_info)\n\n db['subscribers'] = db_subs\n\n return db_subs","def getAllSubscriptions(self):\n return self.request(\n \"getAllSubscriptions\",\n )","def subscribe(self, request: Request) -> Response:\n ids = request.data.get(\"ids\", None)\n session_id = request.data.get(\"session_id\")\n content_type = ContentType.objects.get_for_model(self.get_queryset().model)\n user = request.user if request.user.is_authenticated else get_anonymous_user()\n subscription = Subscription.objects.create(user=user, session_id=session_id)\n\n if ids is None:\n # Subscribe to the whole table.\n subscription.subscribe(\n content_type, [Observer.ALL_IDS], (ChangeType.CREATE, ChangeType.DELETE)\n )\n else:\n # Verify all ids exists and user has permissions to view them.\n for id in ids:\n if not self.user_has_permission(id, request.user):\n raise NotFound(f\"Item {id} does not exist\")\n\n change_types = (ChangeType.UPDATE, ChangeType.DELETE, ChangeType.CREATE)\n subscription.subscribe(content_type, ids, change_types)\n\n resp = {\"subscription_id\": subscription.subscription_id}\n return Response(resp)","def return_count(self, number, request, environ, start_response,\n response_headers):\n response_type = self.content_negotiation(\n request, environ, self.DereferenceTypes)\n if response_type is None:\n return self.odata_error(\n request, environ, start_response, \"Not Acceptable\",\n '$count requires plain text or octet-stream formats', 406)\n data = str(number).encode('utf-8')\n response_headers.append((\"Content-Type\", str(response_type)))\n response_headers.append((\"Content-Length\", str(len(data))))\n start_response(\"%i %s\" % (200, \"Success\"), response_headers)\n return [data]","def listSubscriptions() -> object:\n\n db = Db()\n return db.Subscriptions.objects().to_json()","def get_usage_count(request, user_id):\n board_count = Member.objects.filter(user_id=user_id, is_creator=True).count()\n return Response({\"board_count\": board_count})","def check_for_subscribers(mail, login_info):\n ADDRESS, PASSWORD = login_info\n\n try:\n mail.select('inbox')\n data = mail.search(None, 'ALL') \n except:\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\n mail.login(ADDRESS, PASSWORD)\n mail.select('inbox')\n data = mail.search(None, 'ALL')\n \n mail_ids = data[1]\n id_list = mail_ids[0].split() \n\n if not id_list:\n return []\n\n first_email_id = int(id_list[0])\n latest_email_id = int(id_list[-1])\n\n subscribers = []\n\n for i in range(latest_email_id, first_email_id-1, -1):\n data = mail.fetch(str(i), '(RFC822)')\n for response_part in data:\n arr = response_part[0]\n if isinstance(arr, tuple):\n msg = email.message_from_string(str(arr[1],'utf-8'))\n email_from = msg['from']\n subscribers.append(email_from)\n\n return subscribers","def _count(self):\n if self._count_valid:\n return self._total_results\n\n result = self._cb.get_object(self._doc_class.urlobject.format(self._cb.credentials.org_key))\n results = result.get(\"results\", [])\n\n self._total_results = len(results)\n self._count_valid = True\n\n return self._total_results","def get(self, orgname):\n permission = AdministerOrganizationPermission(orgname)\n if permission.can():\n organization = model.organization.get_organization(orgname)\n query = model.organization_skus.get_org_subscriptions(organization.id)\n\n if query:\n subscriptions = list(query.dicts())\n for subscription in subscriptions:\n subscription[\"sku\"] = marketplace_subscriptions.get_subscription_sku(\n subscription[\"subscription_id\"]\n )\n return subscriptions\n else:\n return []\n abort(401)","def subscribers(self) -> pulumi.Input[Sequence[pulumi.Input['BudgetActionSubscriberArgs']]]:\n return pulumi.get(self, \"subscribers\")","def task2(self, doc) -> dict:\n country_count = {}\n match_records = []\n for entry in self.records:\n if (entry['event_type'] =='read'):\n if entry['subject_doc_id'] == doc:\n match_records.append(entry)\n for rec in match_records:\n if (rec['visitor_country'] in country_count):\n country_count[rec['visitor_country']] += 1\n else:\n country_count[rec['visitor_country']] = 1\n print(country_count)\n return country_count","def make_requests_with_n_recipients(num, url):\n recipients = [str(x) for x in xrange(num)]\n\n data = create_request('TEST MESSAGE!', recipients)\n return call_api_endpoint(url, data)","def count(self, index):\n if isinstance(index, list):\n index = ','.join(index)\n req = requests.get(\n urljoin(self.base_url, '{0}/_count'.format(index)),\n verify=self.verify_certs)\n return req.json()['count']","def test_subscribe(mocker, api: API, account: Account, order, sku_id, activation):\n api.regnum.order.return_value = order\n api.activation.activate.return_value = activation\n assert account.subscribe(sku_id) == activation[\"id\"]\n api.regnum.order.assert_called_with(\n \"USERNAME\", sku_id, 1, date.today(), timedelta(days=365)\n )\n api.activation.activate.assert_called_with(\"USERNAME\", 5678, mocker.ANY, date.today())\n assert order in account.orders\n assert activation in account.activations","def subscribe(receiver):","def subscribe(receiver):","def subscribe(receiver):","def test_search_accounts(client):\n subjects, request_id = client.search_accounts(\n [\n \"70506405335016096312945164\",\n \"20028681823250598006154766\",\n \"31872831997646186715413833\",\n ]\n )\n\n assert len(subjects) == 3","def get_user_count_registered_against_business_and_survey(business_id: str, survey_id: str, is_transfer) -> int:\n logger.info(\"Attempting to get user count\", business_ids=business_id, survey_id=survey_id)\n url = f'{app.config[\"PARTY_URL\"]}/party-api/v1/pending-survey-users-count'\n data = {\"business_id\": business_id, \"survey_id\": survey_id, \"is_transfer\": is_transfer}\n response = requests.get(url, params=data, auth=app.config[\"BASIC_AUTH\"])\n try:\n response.raise_for_status()\n except requests.exceptions.HTTPError:\n raise ApiError(logger, response)\n return response.json()","def get_num_of_sales_per_customer_ids():\n\n # your code"],"string":"[\n \"def number_of_subscribers(subreddit):\\n\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n headers = {\\\"User-Agent\\\": \\\"my-integration/1.2.3\\\"}\\n\\n response = get(url=url, headers=headers)\\n\\n if response.status_code == 200:\\n # print(response.json())\\n\\n response_json = response.json()\\n data = response_json.get('data')\\n subscribers = data.get(\\\"subscribers\\\")\\n\\n return subscribers\\n\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://api.reddit.com/r/{}/about\\\".format(subreddit)\\n header = {'User-Agent': 'CustomClient/1.0'}\\n request = requests.get(url, headers=header, allow_redirects=False)\\n\\n if request.status_code != 200:\\n return 0\\n jreq = request.json()\\n\\n if 'data' in jreq:\\n return jreq.get(\\\"data\\\").get(\\\"subscribers\\\")\\n else:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n headers = {'user-agent': 'request'}\\n response = requests.get(url, headers=headers, allow_redirects=False)\\n if str(response) != '<Response [200]>':\\n return 0\\n response_json = response.json()\\n subs = response_json.get('data').get('subscribers')\\n return subs\",\n \"def number_of_subscribers(subreddit):\\n\\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\\n\\n headers = {'User-Agent': 'My User Agent 1.0'}\\n\\n request = requests.get(url, headers=headers)\\n req = request.json()\\n\\n if request.status_code == 404:\\n return 0\\n\\n subs = req.get('data').get('subscribers')\\n return subs\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\"\\n headers = {\\n 'User-Agent': 'My User Agent 1.0',\\n 'From': 'youremail@domain.com'\\n }\\n r_subs = requests.get(url.format(subreddit), headers=headers)\\n if r_subs.status_code == 200:\\n data = r_subs.json()['data']\\n subscribers = data.get('subscribers')\\n if subscribers is not None:\\n return subscribers\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n h = {'user-agent': 'GEEK1050'}\\n link = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n req = requests.get(link, headers=h)\\n\\n req_data = req.json().get(\\\"data\\\").get(\\\"subscribers\\\")\\n for element in req_data['children']:\\n print(element['children']['title'])\",\n \"def number_of_subscribers(subreddit):\\n header = {'User-Agent': 'Chrome/90.0.4430.212 Safari/537.36'}\\n req = requests.get('https://www.reddit.com/r/{}/about.json'\\n .format(subreddit), allow_redirects=False,\\n headers=header)\\n if req.status_code == 200:\\n subscribers = req.json().get('data').get('subscribers')\\n return subscribers\\n else:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n header = {\\\"User-agent\\\": \\\"darth\\\"}\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n response = (requests.get(url, headers=header))\\n if response.status_code != 200:\\n return 0\\n return response.json().get('data').get('subscribers')\",\n \"def number_of_subscribers(subreddit):\\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\\n response = requests.get(url,\\n allow_redirects=False,\\n headers={'User-Agent': 'MyChromeBook'})\\n if response:\\n suscribers_number = response.json().get('data').get('subscribers')\\n return suscribers_number\\n else:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n URL = 'https://api.reddit.com/r/{}/about'.format(subreddit)\\n header = {'User-Agent': 'Custom-User'}\\n\\n resp = requests.get(URL, headers=header).json()\\n try:\\n return resp['data']['subscribers']\\n except Exception:\\n return 0\",\n \"def count_subscribers(self):\\n return self.request(\\\"count:Contact\\\", [ None ])\",\n \"def number_of_subscribers(subreddit):\\n url = requests.get(\\\"https://www.reddit.com/r/{}/about.json\\\"\\n .format(subreddit), headers={\\\"User-Agent\\\": \\\"kalkidan\\\"})\\n if url.status_code == 200:\\n return url.json().get(\\\"data\\\").get(\\\"subscribers\\\")\\n else:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n link = 'http://www.reddit.com/r/{}/about.json'.format(subreddit)\\n red = requests.get(link, headers={'User-Agent': 'tope628'}).json()\\n try:\\n subs = red.get('data').get('subscribers')\\n except:\\n return 0\\n if red is None:\\n return 0\\n return subs\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n header = {\\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"User-Agent\\\": \\\"Mozilla/5.0\\\"}\\n request = requests.get(\\n url,\\n headers=header,\\n allow_redirects=False)\\n if request.status_code >= 300:\\n return 0\\n return json.loads(request.content.decode(\\\"utf-8\\\"))[\\\"data\\\"][\\\"subscribers\\\"]\",\n \"def number_of_subscribers(subreddit):\\n r = requests.get('https://api.reddit.com/r/{}/about.json'\\n .format(subreddit),\\n headers={'user-agent': 'ianscustomthing'},\\n allow_redirects=False)\\n rj = r.json()\\n if rj.get('message') == 'Not Found':\\n return 0\\n s = rj.get('data').get('subscribers')\\n return s\",\n \"def number_of_subscribers(subreddit):\\n\\n import requests\\n\\n resInf = requests.get(\\\"https://www.reddit.com/r/{}/about.json\\\"\\n .format(subreddit),\\n headers={\\\"User-Agent\\\": \\\"My-User-Agent\\\"},\\n allow_redirects=False)\\n if resInf.status_code >= 300:\\n return 0\\n\\n return resInf.json().get(\\\"data\\\").get(\\\"subscribers\\\")\",\n \"def number_of_subscribers(subreddit):\\n import requests\\n headers = {'User-Agent': 'Godfather'}\\n about = requests.get(\\n 'https://www.reddit.com/r/{}/about.json'.format(\\n subreddit), headers=headers).json()\\n try:\\n subscribers = about.get('data').get('subscribers')\\n if subscribers is None:\\n raise TypeError\\n return subscribers\\n except:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n url = 'https://www.reddit.com/r/{}/about.json'\\n headers = {'user-agent': 'X-Modhash'}\\n url_format = requests.get(url.format(subreddit), headers=headers).json()\\n try:\\n name = url_format['data']['subscribers']\\n return name\\n except:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n url_rsubs = \\\"https://api.reddit.com/r/{}/about\\\".format(subreddit)\\n headers = {'User-Agent': 'Python3'}\\n response = requests.get(url_rsubs, headers=headers,\\n allow_redirects=False)\\n if str(response) != \\\"<Response [200]>\\\":\\n return 0\\n r_json = response.json()\\n subs_count = r_json.get('data').get('subscribers')\\n return subs_count\",\n \"def number_of_subscribers(subreddit):\\n response = requests.get('https://www.reddit.com/r/{}/about.json'\\n .format(subreddit),\\n headers={'User-Agent': 'Camilo@holberton'},\\n allow_redirects=False)\\n if response.status_code == 200:\\n response = response.json()\\n data = response.get('data')\\n subs_count = data.get('subscribers')\\n if data and subs_count:\\n return subs_count\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}.json\\\".format(subreddit)\\n r = requests.get(url, headers={'User-agent': 'shoji'},\\n allow_redirects=False)\\n data = r.json()\\n if not r.status_code == 200:\\n return 0\\n try:\\n sub = data.get(\\\"data\\\")\\n children = sub.get(\\\"children\\\")\\n subreddit = children[0].get(\\\"data\\\")\\n subscriber_count = subreddit.get(\\\"subreddit_subscribers\\\")\\n except Exception as e:\\n print(\\\"Something went wrong\\\\n {}\\\".format(e))\\n return 0\\n\\n return subscriber_count\",\n \"def number_of_subscribers(subreddit):\\n if subreddit is None or type(subreddit) is not str:\\n return 0\\n BASE_URL = 'http://www.reddit.com/r/{}/about.json'\\n head = {'User-Agent': 'Mozilla/5.0'}\\n r = requests.get(BASE_URL.format(subreddit), headers=head)\\n return r.json().get('data', {}).get('subscribers', 0)\",\n \"def number_of_subscribers(subreddit):\\n # Set the Default URL strings\\n base_url = 'https://www.reddit.com'\\n api_uri = '{base}/r/{subreddit}/about.json'.format(base=base_url,\\n subreddit=subreddit)\\n\\n # Set an User-Agent\\n user_agent = {'User-Agent': 'Python/requests'}\\n\\n # Get the Response of the Reddit API\\n res = requests.get(api_uri, headers=user_agent,\\n allow_redirects=False)\\n\\n # Checks if the subreddit is invalid\\n if res.status_code in [302, 404]:\\n return 0\\n\\n # Returns the total subscribers of the subreddit\\n return res.json().get('data').get('subscribers')\",\n \"def test_json_get_subscribers(self) -> None:\\n stream_name = gather_subscriptions(self.user_profile)[0][0][\\\"name\\\"]\\n stream_id = get_stream(stream_name, self.user_profile.realm).id\\n expected_subscribers = gather_subscriptions(self.user_profile, include_subscribers=True)[0][\\n 0\\n ][\\\"subscribers\\\"]\\n result = self.client_get(f\\\"/json/streams/{stream_id}/members\\\")\\n result_dict = self.assert_json_success(result)\\n self.assertIn(\\\"subscribers\\\", result_dict)\\n self.assertIsInstance(result_dict[\\\"subscribers\\\"], list)\\n subscribers: List[int] = []\\n for subscriber in result_dict[\\\"subscribers\\\"]:\\n self.assertIsInstance(subscriber, int)\\n subscribers.append(subscriber)\\n self.assertEqual(set(subscribers), set(expected_subscribers))\",\n \"def test_get_subscriptions_auth(self):\\n url = reverse('xds_api:interest-list-subscriptions')\\n _, token = AuthToken.objects.create(self.user_1)\\n # subscribe user 1 to interest list 3\\n self.list_3.subscribers.add(self.user_1)\\n self.list_3.save()\\n response = self.client \\\\\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\\n responseDict = json.loads(response.content)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(self.list_3.subscribers.all()),\\n len(responseDict))\",\n \"def test_get_subscriptions(self):\\n pass\",\n \"def test_successful_subscriptions_list_subscribers(self) -> None:\\n result = self.api_get(\\n self.test_user,\\n \\\"/api/v1/users/me/subscriptions\\\",\\n {\\\"include_subscribers\\\": \\\"true\\\"},\\n )\\n json = self.assert_json_success(result)\\n self.assertIn(\\\"subscriptions\\\", json)\\n for stream in json[\\\"subscriptions\\\"]:\\n self.assertIsInstance(stream[\\\"name\\\"], str)\\n self.assertIsInstance(stream[\\\"color\\\"], str)\\n self.assertIsInstance(stream[\\\"invite_only\\\"], bool)\\n # check that the stream name corresponds to an actual\\n # stream; will throw Stream.DoesNotExist if it doesn't\\n get_stream(stream[\\\"name\\\"], self.test_realm)\\n list_streams = [stream[\\\"name\\\"] for stream in json[\\\"subscriptions\\\"]]\\n # also check that this matches the list of your subscriptions\\n self.assertEqual(sorted(list_streams), sorted(self.streams))\",\n \"def test_subscriber(self) -> None:\\n stream_name = gather_subscriptions(self.user_profile)[0][0][\\\"name\\\"]\\n self.make_successful_subscriber_request(stream_name)\",\n \"def get_subscribed_users(self, obj):\\n return obj.subscribed_users.count()\",\n \"def main():\\n credentials = get_credentials()\\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('reseller', 'v1', http=http)\\n\\n results = service.subscriptions().list(maxResults=10).execute()\\n subscriptions = results.get('subscriptions', [])\\n if not subscriptions:\\n print('No subscriptions found.')\\n else:\\n print('Subscriptions:')\\n for subscription in subscriptions:\\n print('{0} ({1}, {2})'.format(subscription['customerId'],\\n subscription['skuId'], subscription['plan']['planName']))\",\n \"def _count_subscriptions(self):\\n for partner in self:\\n subscriptions = self.env['subscription.subscription']\\n count = subscriptions.sudo().search_count([('partner_id', '=', partner.id)])\\n for child in partner.child_ids:\\n count += subscriptions.sudo().search_count([('partner_id', '=', child.id)])\\n partner.subscriptions_count = count\",\n \"def get_subscriber_count(self, response):\\n return response.css('.yt-subscriber-count')\\\\\\n .extract_first(default='')\",\n \"def get_subscriber(self, subscriber_id):\\n req_data = [ str(subscriber_id) ]\\n return self.request(\\\"find:Contact.stats\\\", req_data)\",\n \"def subscribers(id):\\n return core.query(schema.streamBySubscribers, id)\",\n \"def test_get_subscription(self):\\n pass\",\n \"def get_freq(urn, top=50, cutoff=3):\\n r = requests.get(\\\"https://api.nb.no/ngram/urnfreq\\\", json={'urn':urn, 'top':top, 'cutoff':cutoff})\\n return Counter(dict(r.json()))\",\n \"def all_client_number():\\n\\n url = CMX_URL + '/api/location/v2/clients/count'\\n header = {'content-type': 'application/json', 'accept': 'application/json'}\\n response = requests.get(url, headers=header, auth=CMX_AUTH, verify=False)\\n response_json = response.json()\\n clients_number = response_json['count']\\n return clients_number\",\n \"def get_subscriptions(self):\\n url = '{}/v2/subscriptions'.format(self.url)\\n r = requests.get(url, headers=self.headers_v2)\\n return r.json()\",\n \"def test_interest_list_subscribe(self):\\n list_id = self.list_2.pk\\n url = reverse('xds_api:interest-list-subscribe', args=(list_id,))\\n _, token = AuthToken.objects.create(self.user_1)\\n response = self.client \\\\\\n .patch(url, HTTP_AUTHORIZATION='Token {}'.format(token))\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(self.list_2.subscribers.all()), 1)\",\n \"def invitation_received_no(request):\\n if request.user.is_authenticated:\\n profile_obj = CustomUser.objects.get(id__exact=request.user.id)\\n qs_count = Relationship.objects.invitation_received(profile_obj).count()\\n return {'invites_num': qs_count}\\n return {}\",\n \"def buildSubscriptionList(self):\\r\\n self._clearLists()\\r\\n unreadById = {}\\r\\n\\r\\n if not self.userId:\\r\\n self.getUserInfo()\\r\\n\\r\\n unreadJson = self.httpGet(ReaderUrl.UNREAD_COUNT_URL, { 'output': 'json', })\\r\\n unreadCounts = json.loads(unreadJson, strict=False)['unreadcounts']\\r\\n for unread in unreadCounts:\\r\\n unreadById[unread['id']] = unread['count']\\r\\n\\r\\n feedsJson = self.httpGet(ReaderUrl.SUBSCRIPTION_LIST_URL, { 'output': 'json', })\\r\\n subscriptions = json.loads(feedsJson, strict=False)['subscriptions']\\r\\n\\r\\n for sub in subscriptions:\\r\\n categories = []\\r\\n if 'categories' in sub:\\r\\n for hCategory in sub['categories']:\\r\\n cId = hCategory['id']\\r\\n if not cId in self.categoriesById:\\r\\n category = Category(self, hCategory['label'], cId)\\r\\n self._addCategory(category)\\r\\n categories.append(self.categoriesById[cId])\\r\\n\\r\\n try:\\r\\n feed = self.getFeed(sub['id'])\\r\\n if not feed:\\r\\n raise\\r\\n if not feed.title:\\r\\n feed.title = sub['title']\\r\\n for category in categories:\\r\\n feed.addCategory(category)\\r\\n feed.unread = unreadById.get(sub['id'], 0)\\r\\n except:\\r\\n feed = Feed(self,\\r\\n sub['title'],\\r\\n sub['id'],\\r\\n sub.get('htmlUrl', None),\\r\\n unreadById.get(sub['id'], 0),\\r\\n categories)\\r\\n if not categories:\\r\\n self.orphanFeeds.append(feed)\\r\\n self._addFeed(feed)\\r\\n\\r\\n specialUnreads = [id for id in unreadById\\r\\n if id.find('user/%s/state/com.google/' % self.userId) != -1]\\r\\n for type in self.specialFeeds:\\r\\n feed = self.specialFeeds[type]\\r\\n feed.unread = 0\\r\\n for id in specialUnreads:\\r\\n if id.endswith('/%s' % type):\\r\\n feed.unread = unreadById.get(id, 0)\\r\\n break\\r\\n\\r\\n return True\",\n \"def subscriptions(id='None'):\\n\\trows = mongo_data({}, [\\\"publisher_id\\\",\\\"dt_hour\\\", \\\"new_subs\\\"],\\\"subscribers\\\")\\n\\t#returns [{_id:...,field1:...,field2:...}]\\n\\n\\n\\tCOLS = [\\\"publisher_id\\\", \\\"dt_hour\\\", \\\"new subs\\\"]\\n\\tROWS = [[y[\\\"publisher_id\\\"],y[\\\"dt_hour\\\"],y[\\\"new_subs\\\"]] for y in rows]\\n\\n\\tTITLE = 'SUBSCRIPTIONS'\\n\\n\\treturn render_template(\\\"simple_tester_report.html\\\", cols=COLS, rows=ROWS, report_title=TITLE);\",\n \"def test_listuser():\\n url = baseUrl + userurl + listurl\\n logging.info(\\\"List users\\\")\\n r = requests.get(url, headers=header)\\n assert r.status_code == 200\\n resp = r.json()\\n global user_ids\\n user_ids = []\\n if resp is None:\\n pass\\n else:\\n user_num = len(resp)\\n for k in range(0, user_num):\\n assert resp[k]['subscriptionIds'][0] == subscriptionid\\n if resp[k][\\\"isActive\\\"] is True:\\n user_ids.append(resp[k][\\\"id\\\"])\\n print (user_ids)\\n assert user_id in user_ids\",\n \"def get_subscribers(cls, topic, count, starting_at_callback=None):\\n\\t\\tquery = cls.all()\\n\\t\\tquery.filter('topic_hash =', utils.sha1_hash(topic))\\n\\t\\tquery.filter('subscription_state = ', cls.STATE_VERIFIED)\\n\\t\\tif starting_at_callback:\\n\\t\\t\\tquery.filter('callback_hash >=', utils.sha1_hash(starting_at_callback))\\n\\t\\tquery.order('callback_hash')\\n\\n\\t\\treturn query.fetch(count)\",\n \"def fetchTAC(self):\\n\\n last_hour = datetime.datetime.now().date() - datetime.timedelta(hours = 1)\\n last_hour = \\\"{}{}{}\\\".format(\\\"'\\\", last_hour, \\\"'\\\")\\n last_hour = datetime.date(2011, 4, 5)\\n\\n self.hlr_cur.execute(\\\"SELECT id FROM Subscriber WHERE updated >= {date};\\\".format(date = last_hour))\\n subscribers = self.hlr_cur.fetchall()\\n\\n parsed_data = {}\\n unique_imei = {}\\n #uid_count = 0\\n\\n for subscriber in subscribers:\\n self.hlr_cur.execute(\\\"SELECT IMEI FROM Equipment WHERE id = (SELECT equipment_id FROM EquipmentWatch WHERE subscriber_id = {s_id});\\\".format(s_id = subscriber[0]))\\n parsed_imei = self.hlr_cur.fetchall()\\n\\n if len(parsed_imei) > 0:\\n for imei in parsed_imei:\\n imei_number = imei[0] \\n\\n if imei_number not in unique_imei:\\n unique_imei[imei_number] = subscriber[0]\\n\\n uid = unique_imei[imei_number]\\n parsed_data.setdefault((uid), str(imei_number)[:8])\\n\\n self.saveRecords(parsed_data)\",\n \"def list_subscriptions(self):\\n return {'abonnementen': self.customer.abonnementen}\",\n \"def test_json_get_subscribers_for_guest_user(self) -> None:\\n guest_user = self.example_user(\\\"polonius\\\")\\n never_subscribed = gather_subscriptions_helper(guest_user, True).never_subscribed\\n\\n # A guest user can only see never subscribed streams that are web-public.\\n # For Polonius, the only web-public stream that he is not subscribed at\\n # this point is Rome.\\n self.assert_length(never_subscribed, 1)\\n\\n web_public_stream_id = never_subscribed[0][\\\"stream_id\\\"]\\n result = self.client_get(f\\\"/json/streams/{web_public_stream_id}/members\\\")\\n result_dict = self.assert_json_success(result)\\n self.assertIn(\\\"subscribers\\\", result_dict)\\n self.assertIsInstance(result_dict[\\\"subscribers\\\"], list)\\n self.assertGreater(len(result_dict[\\\"subscribers\\\"]), 0)\",\n \"def get_count(username):\\n return get_contributor(username)[\\\"count\\\"]\",\n \"def count(cls, client) :\\n try :\\n obj = nshttpprofile()\\n option_ = options()\\n option_.count = True\\n response = obj.get_resources(client, option_)\\n if response :\\n return response[0].__dict__['___count']\\n return 0\\n except Exception as e :\\n raise e\",\n \"def count(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'count')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def client_count(request):\\n return request.param\",\n \"def test_get_total_users_get(self):\\n pass\",\n \"def test_is_ims_sub_activities(self):\\r\\n emaSession = ema_functions.emaLogin()\\r\\n session = {}\\r\\n session['emaSession'] = emaSession\\r\\n sub1 = class_ims_ema.sub('+353760000001')\\r\\n #test1 = sub1.subscriberCreate(session)\\r\\n test2 = sub1.subscriberGet(session)\\r\\n #test3 = sub1.subscriberDelete(session)\\r\\n test4 = sub1.subscriberGet(session)\\r\\n #self.assertTrue(test1.status_code == 200 and test2.status_code == 200 and test3.status_code == 200 and test4.status_code == 500)\\r\\n self.assertTrue(test2.status_code == 200 and test4.status_code == 500)\",\n \"def count(cls, client) :\\n\\t\\ttry :\\n\\t\\t\\tobj = lsntransportprofile()\\n\\t\\t\\toption_ = options()\\n\\t\\t\\toption_.count = True\\n\\t\\t\\tresponse = obj.get_resources(client, option_)\\n\\t\\t\\tif response :\\n\\t\\t\\t\\treturn response[0].__dict__['___count']\\n\\t\\t\\treturn 0\\n\\t\\texcept Exception as e :\\n\\t\\t\\traise e\",\n \"def get_total_users(request):\\n number_of_users = User.objects.count()\\n res = {\\n 'total_users': number_of_users,\\n }\\n return Response(res, status=status.HTTP_200_OK)\",\n \"def get_count(type,baseurl,user,password):\\n payload = {'request': 'count', 'type': type}\\n r = requests.get(baseurl, params=payload, auth=HTTPBasicAuth(user, password), verify=False)\\n return int(r.text)\",\n \"def message_nums(request):\\n if request.user.is_authenticated:\\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\\n else:\\n return {}\",\n \"def n_subimissions_per_day( url, headers ):\",\n \"def get_members(base_url, end_url):\\n reps, content_len, bill_info, votes = get_next_page(base_url, end_url, 1)\\n return reps\",\n \"def subscribers_by_id(self, repository_id, access_token=None):\\n return self._complete_request_by_id(\\n repository_id, \\\"subscribers\\\", access_token)\",\n \"def test_getting_segment_subscribers(self):\\n pass\",\n \"def get_subscribers(self, \\n order=\\\"created_at desc\\\",\\n offset=None,\\n count=None):\\n req_data = [ None, order, fmt_paging(offset, count)]\\n return self.request(\\\"query:Contact.stats\\\", req_data)\",\n \"def test_search_regons(client):\\n subjects, request_id = client.search_regons([\\\"755016841\\\", \\\"216973362\\\", \\\"862391869\\\"])\\n\\n assert len(subjects) == 3\",\n \"def get_subscription(self):\\n return self.request({\\n 'path': '/' + UUID + '/subscription'})\",\n \"def test_admin_sms_subscriber_view_list(self):\\n response = self.client.get('/admin/sms_module/smscampaignsubscriber/')\\n self.failUnlessEqual(response.status_code, 200)\",\n \"async def get_subscriptions(\\n self,\\n\\t\\tfields: Optional[List[BaseUserGroupFields]] = None,\\n\\t\\toffset: Optional[int] = None,\\n\\t\\tcount: Optional[int] = None,\\n\\t\\t**kwargs\\n ) -> donut.GetSubscriptionsResponseModel:\\n\\n params = self.get_set_params(locals())\\n response = await self.api.request(\\\"donut.getSubscriptions\\\", params)\\n model = donut.GetSubscriptionsResponse\\n return model(**response).response\",\n \"def subscribers_by_name(self, username, repository_name, access_token=None):\\n return self._complete_request_by_name(\\n username, repository_name, \\\"subscribers\\\", access_token)\",\n \"def subscribed(cls, team):\\n return cls.query(\\n cls.status == 'subscribe',\\n cls.team == team.lower()\\n ).fetch(100)\",\n \"def test_process_subscriptions(self):\\n pass\",\n \"def test_import_subscribers(dbsession, registry, mailgun, populated_mailing_list):\\n paginator = mailgun.list_members(populated_mailing_list)\\n items = paginator[\\\"items\\\"]\\n assert len(items) == 1\\n assert items[0][\\\"address\\\"] == \\\"example@example.com\\\"\",\n \"def get_subscribers(self) -> Iterator[Any]:\\n for subscription in self._subscriptions[self.id]:\\n yield subscription.subscriber\",\n \"def countAndGetCallInvoice(self,id,start,finish):\\n self.calls = 0\\n return self.getNumOfInvoice(id,start,finish)\",\n \"def count(request):\\r\\n n = request.user.profile.unread_message_count()\\r\\n data = {\\r\\n 'count': n,\\r\\n }\\r\\n return HttpResponse(json.dumps(data), mimetype='application/json')\",\n \"def combined_inbox_count(request):\\r\\n count = 0\\r\\n for func in inbox_count_sources():\\r\\n counts = func(request)\\r\\n if counts:\\r\\n for value in counts.itervalues():\\r\\n try:\\r\\n count = count + int(value)\\r\\n except (TypeError, ValueError):\\r\\n pass\\r\\n return {'combined_inbox_count': count,}\",\n \"def subscribers(self) -> pulumi.Output[Sequence['outputs.BudgetActionSubscriber']]:\\n return pulumi.get(self, \\\"subscribers\\\")\",\n \"def GET(self):\\n web.header(\\\"Content-Type\\\",\\\"application/json; charset=utf-8\\\")\\n data = web.input(module=\\\"module\\\")\\n module = data[\\\"module\\\"]\\n count = db_module.get_module_newsNum(module)\\n result = json.dumps({\\\"count\\\": count})\\n return result\",\n \"def test_successful_subscriptions_list(self) -> None:\\n result = self.api_get(self.test_user, \\\"/api/v1/users/me/subscriptions\\\")\\n json = self.assert_json_success(result)\\n self.assertIn(\\\"subscriptions\\\", json)\\n for stream in json[\\\"subscriptions\\\"]:\\n self.assertIsInstance(stream[\\\"name\\\"], str)\\n self.assertIsInstance(stream[\\\"color\\\"], str)\\n self.assertIsInstance(stream[\\\"invite_only\\\"], bool)\\n # check that the stream name corresponds to an actual\\n # stream; will throw Stream.DoesNotExist if it doesn't\\n get_stream(stream[\\\"name\\\"], self.test_realm)\\n list_streams = [stream[\\\"name\\\"] for stream in json[\\\"subscriptions\\\"]]\\n # also check that this matches the list of your subscriptions\\n self.assertEqual(sorted(list_streams), sorted(self.streams))\",\n \"def do_GET(self):\\n # Check that basic auth is used.\\n authorization = self.headers.get(\\\"Authorization\\\")\\n if authorization == \\\"\\\" or authorization is None:\\n self.send_response(400)\\n self.end_headers()\\n return\\n\\n if \\\"/subscriptions\\\" in self.path:\\n self.send_response(200)\\n self.end_headers()\\n self.wfile.write(json.dumps(sample_client_subscription).encode())\\n else:\\n self.send_response(200)\\n self.end_headers()\\n self.wfile.write(json.dumps(sample_client_list_response).encode())\",\n \"def _get_notifications(self):\\r\\n student = self._student('GET')\\r\\n if student is None:\\r\\n self._error_response()\\r\\n\\r\\n else:\\r\\n self._success_response({\\r\\n 'student_sub_count': self.server.DUMMY_DATA['student_sub_count'],\\r\\n 'count_required': student.num_required,\\r\\n 'count_graded': student.num_graded,\\r\\n 'count_available': student.num_pending\\r\\n })\",\n \"def count(self, sub, start=0, end=None):\\n return count(self, sub, start, end)\",\n \"def on_subscribe(self, request, ssn):\\n if 'hub.challenge' not in request.GET:\\n logger.error(f'Missing hub.challenge in subscription verification {ssn.pk}!')\\n tasks.save.delay(\\n pk = ssn.pk,\\n subscribe_status = 'verifyerror',\\n verifyerror_count = ssn.verifyerror_count + 1\\n )\\n return Response('Missing hub.challenge', status=HTTP_400_BAD_REQUEST)\\n\\n if not request.GET.get('hub.lease_seconds', '').isdigit():\\n logger.error(f'Missing integer hub.lease_seconds in subscription verification {ssn.pk}!')\\n tasks.save.delay(\\n pk = ssn.pk,\\n subscribe_status = 'verifyerror',\\n verifyerror_count = ssn.verifyerror_count + 1\\n )\\n return Response('hub.lease_seconds required and must be integer', status=HTTP_400_BAD_REQUEST)\\n\\n if ssn.unsubscribe_status is not None:\\n logger.error(f'Subscription {ssn.pk} received subscription verification request,'\\n f' but its was explicitly unsubscribed before.')\\n return Response('Unsubscribed')\\n\\n tasks.save.delay(\\n pk = ssn.pk,\\n subscribe_status = 'verified',\\n lease_expiration_time = now() + timedelta(seconds=int(request.GET['hub.lease_seconds'])),\\n connerror_count = 0,\\n huberror_count = 0,\\n verifyerror_count = 0,\\n verifytimeout_count = 0\\n )\\n logger.info(f'Got {ssn.pk} subscribe confirmation from hub.')\\n return HttpResponse(request.GET['hub.challenge'])\",\n \"def update_db_and_get_subs(mail, login_info):\\n subscribers = check_for_subscribers(mail, login_info)\\n\\n db_subs = []\\n if 'subscribers' in db.keys():\\n db_subs = db['subscribers']\\n\\n for sub in subscribers:\\n if sub not in db_subs:\\n print(f'New subscriber added: {sub}')\\n db_subs.append(sub)\\n subject = \\\"Welcome to F1 Digest!\\\"\\n send_email(subject, subscribe_body, sub, login_info)\\n\\n db['subscribers'] = db_subs\\n\\n return db_subs\",\n \"def getAllSubscriptions(self):\\n return self.request(\\n \\\"getAllSubscriptions\\\",\\n )\",\n \"def subscribe(self, request: Request) -> Response:\\n ids = request.data.get(\\\"ids\\\", None)\\n session_id = request.data.get(\\\"session_id\\\")\\n content_type = ContentType.objects.get_for_model(self.get_queryset().model)\\n user = request.user if request.user.is_authenticated else get_anonymous_user()\\n subscription = Subscription.objects.create(user=user, session_id=session_id)\\n\\n if ids is None:\\n # Subscribe to the whole table.\\n subscription.subscribe(\\n content_type, [Observer.ALL_IDS], (ChangeType.CREATE, ChangeType.DELETE)\\n )\\n else:\\n # Verify all ids exists and user has permissions to view them.\\n for id in ids:\\n if not self.user_has_permission(id, request.user):\\n raise NotFound(f\\\"Item {id} does not exist\\\")\\n\\n change_types = (ChangeType.UPDATE, ChangeType.DELETE, ChangeType.CREATE)\\n subscription.subscribe(content_type, ids, change_types)\\n\\n resp = {\\\"subscription_id\\\": subscription.subscription_id}\\n return Response(resp)\",\n \"def return_count(self, number, request, environ, start_response,\\n response_headers):\\n response_type = self.content_negotiation(\\n request, environ, self.DereferenceTypes)\\n if response_type is None:\\n return self.odata_error(\\n request, environ, start_response, \\\"Not Acceptable\\\",\\n '$count requires plain text or octet-stream formats', 406)\\n data = str(number).encode('utf-8')\\n response_headers.append((\\\"Content-Type\\\", str(response_type)))\\n response_headers.append((\\\"Content-Length\\\", str(len(data))))\\n start_response(\\\"%i %s\\\" % (200, \\\"Success\\\"), response_headers)\\n return [data]\",\n \"def listSubscriptions() -> object:\\n\\n db = Db()\\n return db.Subscriptions.objects().to_json()\",\n \"def get_usage_count(request, user_id):\\n board_count = Member.objects.filter(user_id=user_id, is_creator=True).count()\\n return Response({\\\"board_count\\\": board_count})\",\n \"def check_for_subscribers(mail, login_info):\\n ADDRESS, PASSWORD = login_info\\n\\n try:\\n mail.select('inbox')\\n data = mail.search(None, 'ALL') \\n except:\\n mail = imaplib.IMAP4_SSL('imap.gmail.com')\\n mail.login(ADDRESS, PASSWORD)\\n mail.select('inbox')\\n data = mail.search(None, 'ALL')\\n \\n mail_ids = data[1]\\n id_list = mail_ids[0].split() \\n\\n if not id_list:\\n return []\\n\\n first_email_id = int(id_list[0])\\n latest_email_id = int(id_list[-1])\\n\\n subscribers = []\\n\\n for i in range(latest_email_id, first_email_id-1, -1):\\n data = mail.fetch(str(i), '(RFC822)')\\n for response_part in data:\\n arr = response_part[0]\\n if isinstance(arr, tuple):\\n msg = email.message_from_string(str(arr[1],'utf-8'))\\n email_from = msg['from']\\n subscribers.append(email_from)\\n\\n return subscribers\",\n \"def _count(self):\\n if self._count_valid:\\n return self._total_results\\n\\n result = self._cb.get_object(self._doc_class.urlobject.format(self._cb.credentials.org_key))\\n results = result.get(\\\"results\\\", [])\\n\\n self._total_results = len(results)\\n self._count_valid = True\\n\\n return self._total_results\",\n \"def get(self, orgname):\\n permission = AdministerOrganizationPermission(orgname)\\n if permission.can():\\n organization = model.organization.get_organization(orgname)\\n query = model.organization_skus.get_org_subscriptions(organization.id)\\n\\n if query:\\n subscriptions = list(query.dicts())\\n for subscription in subscriptions:\\n subscription[\\\"sku\\\"] = marketplace_subscriptions.get_subscription_sku(\\n subscription[\\\"subscription_id\\\"]\\n )\\n return subscriptions\\n else:\\n return []\\n abort(401)\",\n \"def subscribers(self) -> pulumi.Input[Sequence[pulumi.Input['BudgetActionSubscriberArgs']]]:\\n return pulumi.get(self, \\\"subscribers\\\")\",\n \"def task2(self, doc) -> dict:\\n country_count = {}\\n match_records = []\\n for entry in self.records:\\n if (entry['event_type'] =='read'):\\n if entry['subject_doc_id'] == doc:\\n match_records.append(entry)\\n for rec in match_records:\\n if (rec['visitor_country'] in country_count):\\n country_count[rec['visitor_country']] += 1\\n else:\\n country_count[rec['visitor_country']] = 1\\n print(country_count)\\n return country_count\",\n \"def make_requests_with_n_recipients(num, url):\\n recipients = [str(x) for x in xrange(num)]\\n\\n data = create_request('TEST MESSAGE!', recipients)\\n return call_api_endpoint(url, data)\",\n \"def count(self, index):\\n if isinstance(index, list):\\n index = ','.join(index)\\n req = requests.get(\\n urljoin(self.base_url, '{0}/_count'.format(index)),\\n verify=self.verify_certs)\\n return req.json()['count']\",\n \"def test_subscribe(mocker, api: API, account: Account, order, sku_id, activation):\\n api.regnum.order.return_value = order\\n api.activation.activate.return_value = activation\\n assert account.subscribe(sku_id) == activation[\\\"id\\\"]\\n api.regnum.order.assert_called_with(\\n \\\"USERNAME\\\", sku_id, 1, date.today(), timedelta(days=365)\\n )\\n api.activation.activate.assert_called_with(\\\"USERNAME\\\", 5678, mocker.ANY, date.today())\\n assert order in account.orders\\n assert activation in account.activations\",\n \"def subscribe(receiver):\",\n \"def subscribe(receiver):\",\n \"def subscribe(receiver):\",\n \"def test_search_accounts(client):\\n subjects, request_id = client.search_accounts(\\n [\\n \\\"70506405335016096312945164\\\",\\n \\\"20028681823250598006154766\\\",\\n \\\"31872831997646186715413833\\\",\\n ]\\n )\\n\\n assert len(subjects) == 3\",\n \"def get_user_count_registered_against_business_and_survey(business_id: str, survey_id: str, is_transfer) -> int:\\n logger.info(\\\"Attempting to get user count\\\", business_ids=business_id, survey_id=survey_id)\\n url = f'{app.config[\\\"PARTY_URL\\\"]}/party-api/v1/pending-survey-users-count'\\n data = {\\\"business_id\\\": business_id, \\\"survey_id\\\": survey_id, \\\"is_transfer\\\": is_transfer}\\n response = requests.get(url, params=data, auth=app.config[\\\"BASIC_AUTH\\\"])\\n try:\\n response.raise_for_status()\\n except requests.exceptions.HTTPError:\\n raise ApiError(logger, response)\\n return response.json()\",\n \"def get_num_of_sales_per_customer_ids():\\n\\n # your code\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76823676","0.7451481","0.7448277","0.73799473","0.72858876","0.7222261","0.71943074","0.7162595","0.7158168","0.7157379","0.71367633","0.71244204","0.71223074","0.71045095","0.7061548","0.70038885","0.6953015","0.6951698","0.6925322","0.69033","0.68208605","0.6781992","0.6664515","0.6480759","0.63943744","0.6179491","0.5926989","0.5910972","0.584116","0.5834524","0.5819679","0.57960165","0.57633096","0.57536143","0.5733111","0.5712486","0.5692815","0.5686368","0.56734544","0.5670715","0.56250316","0.5598913","0.5594021","0.5578406","0.5570526","0.55686647","0.55599535","0.5537437","0.5516226","0.55025864","0.5496542","0.54861593","0.54860896","0.5475061","0.5442715","0.5441692","0.5429206","0.5424884","0.54176426","0.5417051","0.5409801","0.54016","0.5401264","0.5386065","0.5384175","0.53769654","0.5362586","0.5356682","0.5355129","0.5348996","0.5344721","0.5340788","0.5339492","0.53357875","0.5331334","0.5328251","0.53182834","0.5311812","0.5309014","0.5301066","0.5296513","0.52914953","0.5291231","0.52804106","0.52612185","0.52530265","0.52508956","0.5249992","0.52470446","0.5243257","0.52417016","0.5240664","0.523488","0.523282","0.52315754","0.5230689","0.5230689","0.5230689","0.52213705","0.5215978","0.5214212"],"string":"[\n \"0.76823676\",\n \"0.7451481\",\n \"0.7448277\",\n \"0.73799473\",\n \"0.72858876\",\n \"0.7222261\",\n \"0.71943074\",\n \"0.7162595\",\n \"0.7158168\",\n \"0.7157379\",\n \"0.71367633\",\n \"0.71244204\",\n \"0.71223074\",\n \"0.71045095\",\n \"0.7061548\",\n \"0.70038885\",\n \"0.6953015\",\n \"0.6951698\",\n \"0.6925322\",\n \"0.69033\",\n \"0.68208605\",\n \"0.6781992\",\n \"0.6664515\",\n \"0.6480759\",\n \"0.63943744\",\n \"0.6179491\",\n \"0.5926989\",\n \"0.5910972\",\n \"0.584116\",\n \"0.5834524\",\n \"0.5819679\",\n \"0.57960165\",\n \"0.57633096\",\n \"0.57536143\",\n \"0.5733111\",\n \"0.5712486\",\n \"0.5692815\",\n \"0.5686368\",\n \"0.56734544\",\n \"0.5670715\",\n \"0.56250316\",\n \"0.5598913\",\n \"0.5594021\",\n \"0.5578406\",\n \"0.5570526\",\n \"0.55686647\",\n \"0.55599535\",\n \"0.5537437\",\n \"0.5516226\",\n \"0.55025864\",\n \"0.5496542\",\n \"0.54861593\",\n \"0.54860896\",\n \"0.5475061\",\n \"0.5442715\",\n \"0.5441692\",\n \"0.5429206\",\n \"0.5424884\",\n \"0.54176426\",\n \"0.5417051\",\n \"0.5409801\",\n \"0.54016\",\n \"0.5401264\",\n \"0.5386065\",\n \"0.5384175\",\n \"0.53769654\",\n \"0.5362586\",\n \"0.5356682\",\n \"0.5355129\",\n \"0.5348996\",\n \"0.5344721\",\n \"0.5340788\",\n \"0.5339492\",\n \"0.53357875\",\n \"0.5331334\",\n \"0.5328251\",\n \"0.53182834\",\n \"0.5311812\",\n \"0.5309014\",\n \"0.5301066\",\n \"0.5296513\",\n \"0.52914953\",\n \"0.5291231\",\n \"0.52804106\",\n \"0.52612185\",\n \"0.52530265\",\n \"0.52508956\",\n \"0.5249992\",\n \"0.52470446\",\n \"0.5243257\",\n \"0.52417016\",\n \"0.5240664\",\n \"0.523488\",\n \"0.523282\",\n \"0.52315754\",\n \"0.5230689\",\n \"0.5230689\",\n \"0.5230689\",\n \"0.52213705\",\n \"0.5215978\",\n \"0.5214212\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":594,"cells":{"query":{"kind":"string","value":"A cumulative metric is one that needs a prior value to calculate the next value. i.e. only the deltas for the current observed values are reported. A noncumulative metric is one where the absolute observed value is reported every time."},"document":{"kind":"string","value":"def is_cumulative(self):\n return self.name in (\n \"app.cpu\",\n \"app.uptime\",\n \"app.disk.bytes\",\n \"app.disk.requests\",\n \"app.mem.majflt\",\n \"app.io.wait\",\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 cumulative_returns(self):\n return (1 + self.pct_change).cumprod()","def get_cumulative_model(self):\n cm = None\n for ac in self.ac:\n if ac[0] is None:\n continue\n m = self.get_model(last=False, a=ac[0], c=ac[1])\n cm = m if cm is None else cm+m\n return cm","def cumulative_distribution(self, X):\n raise NotImplementedError","def cummulative_return(df):\n cumm_daily_return=(df[-1]/df[0])-1\n \n return cumm_daily_return","def cumulate(self):\n name = self.getName() + '_Cumulated'\n c_names = self.getColumnNames()\n # create the new table an add the first column to it\n t_cumulate = DataTable(name)\n time = self.getColumn(0)\n t_cumulate.addColumn(c_names[0],time)\n # for each other column, cumulate values \n for i in range(1,self.getNbColumns()):\n c = self.getColumn(i)\n N = [0]\n for j in range(1,len(c)):\n n = (c[j]+c[j-1])/2*(time[j]-time[j-1]) + N[-1]\n N.append(n)\n pass\n t_cumulate.addColumn(c_names[i],N)\n pass\n \n return t_cumulate","def cumulate(self, value):\n last = 0 if len(self) == 0 else self[-1]\n if value is None:\n self.append(last)\n else:\n self.append(last + value)","def calculate_cumulative_reward(self, gamma: float = 1.0):\n num_transitions = len(self)\n assert num_transitions > 0, \"called on empty trajectory\"\n rewards = self.reward\n discounts = [gamma**i for i in range(num_transitions)]\n return sum(reward * discount for reward, discount in zip(rewards, discounts))","def cumulate(tobject):\n # forward suffix\n return asrootpy(tobject.GetCumulative(True, uuid.uuid4().get_hex()))","def from_cumulative(self, cumulative):\n return self._dist_cls.from_cumulative(self._edges, cumulative)","def get_bprop_cumsum(self):\n cumsum = P.CumSum(exclusive=self.exclusive, reverse=not self.reverse)\n\n def bprop(x, axis, out, dout):\n return cumsum(dout, axis), zeros_like(axis)\n return bprop","def cumprob(self):\r\n return self.probabilities.cumsum(-1)","def show_cumulative_mig(model):\r\n return sum(cumulative_mig_list)","def calculate_cumulative_returns(returns, starting_value=0, out=None):\n if len(returns) < 1:\n return returns.copy()\n\n nanmask = np.isnan(returns)\n if np.any(nanmask):\n returns = returns.copy()\n returns[nanmask] = 0\n\n allocated_output = out is None\n if allocated_output:\n out = np.empty_like(returns)\n\n np.add(returns, 1, out=out)\n out.cumprod(axis=0, out=out)\n\n if starting_value == 0:\n np.subtract(out, 1, out=out)\n else:\n np.multiply(out, starting_value, out=out)\n\n if allocated_output:\n if returns.ndim == 1 and isinstance(returns, pd.Series):\n out = pd.Series(out, index=returns.index)\n elif isinstance(returns, pd.DataFrame):\n out = pd.DataFrame(\n out, index=returns.index, columns=returns.columns,\n )\n\n return out","def get_cumulative_rewards(rewards, # rewards at each step\n gamma=0.99 # discount for reward\n ):\n\n cumulative_rewards = np.empty_like(rewards)\n cumulative_rewards = cumulative_rewards.astype(float)\n cumulative_rewards[-1] = rewards[-1]\n\n for index in range(len(rewards) - 2, -1, -1):\n discount = cumulative_rewards[index + 1] * gamma\n reward = rewards[index]\n cumulative_rewards[index] = discount + reward\n\n return cumulative_rewards # <array of cumulative rewards>","def cum_sum(self):\n\n # create cdo command and runit\n cdo_command = \"cdo -timcumsum\"\n run_this(cdo_command, self, output=\"ensemble\")","def _cumulative_diff(item, key):\n global _prev_values\n if key in _prev_values:\n # Subsequent item, return difference from previous\n prev = _prev_values[key]\n _prev_values[key] = item\n\n result = copy.deepcopy(item)\n for fname in result[\"fields\"]:\n result[\"fields\"][fname] -= prev[\"fields\"][fname]\n\n return result\n else:\n # First item, no difference, return zeros.\n _prev_values[key] = item\n result = copy.deepcopy(item)\n fields = result[\"fields\"]\n for fname in fields:\n fields[fname] = 0\n return result","def get_cumulative_distribution(self):\n srt_dists = np.sort(self._distances)\n tol = 1E-3\n for i in range(1, len(srt_dists)):\n while srt_dists[i] - srt_dists[i-1] < tol:\n srt_dists[i] += tol\n return {\"x\": srt_dists-srt_dists[0], \n \"P\": np.linspace(0.0, 1.0, len(self._distances), endpoint=False)}","def __get_cumulative (self, event_df, inputon, inputoff, num_bins = 10):\r\n \r\n input_mark = lambda x, inputon, inputoff: 1 if x == inputon else -1 if x == inputoff else 0\r\n \r\n if len(event_df) == 0:\r\n pass\r\n else:\r\n df = event_df.copy()\r\n df[inputon] = df['Events'].apply(lambda x: input_mark(x, inputon, inputoff))\r\n start_cum = df[df['Events']== inputon][['Time',inputon]] #defaults is input state\r\n start_cum[self.subject+'_cum'] = start_cum[inputon].cumsum()\r\n #start_cum[self.subject+'_cumP'] = 100*start_cum[self.subject+'_cum']/start_cum[inputon].sum()\r\n start_cum.reset_index(inplace=True)\r\n start_cum.drop(columns = inputon,inplace = True)\r\n start_cum.drop(columns = 'index',inplace = True)\r\n return start_cum","def cumsum(self):\n return self._lift(lambda c: c.cumsum)","def get_cum_returns(self,df, init_inv = 1):\n return ((1 + df).cumprod()) * init_inv","def get_cumulative_rewards(rewards, # rewards at each step\r\n gamma=0.99 # discount for reward\r\n ):\r\n cumulative_rewards = []\r\n prev = 0\r\n\r\n for r in reversed(rewards):\r\n prev = r + gamma * prev\r\n cumulative_rewards.append(prev)\r\n cumulative_rewards.reverse()\r\n return cumulative_rewards","def cumulative_left (self):\n # TODO: include proper errors\n return Line (self.bins,\n self.values[::-1].cumsum ()[::-1])\n #return Line (self.bins, self.sum - self.values.cumsum ())","def cumulative_correlation(self) -> int:\n return self._cumulative_correlation","def cumulative_distribution(self, dist='current'):\n \n dictDist = {'current': np.cumsum(self.current),\n 'prior': np.cumsum(self.prior),\n 'posterior': np.cumsum(self.posterior, axis=1)\n }\n \n cdf = dictDist[dist]\n \n return cdf","def cumulative_distribution(self):\n\n cum_dd = []\n sum_p = 0\n for k, p in reversed(self.dd):\n sum_p += p\n cum_dd.append((k, sum_p))\n return list(reversed(cum_dd))","def test_kde_cumulative(limits):\n data = np.random.normal(0, 1, 1000)\n density = _kde(data, custom_lims=limits, cumulative=True)[1]\n np.testing.assert_almost_equal(round(density[-1], 3), 1)","def office_calculate_cumulative_misfit(parser, args, params):\n local_args = parser.parse_known_args(args)\n control.calculate_cumulative_misfit(params)","def calculate_cumulative_returns_by_group(quantile_ret_ts: pd.DataFrame):\n # 1_period_return 5_period_return 10_period_return\n # factor_quantile Date\n # 1 2010-06-17 0.002230 0.021172 -0.014775\n # 2010-06-18 0.036203 0.017436 -0.016843\n # 2010-06-21 -0.004873 -0.017346 -0.035416\n # 2010-06-22 -0.000315 -0.036443 -0.046313\n # 2010-06-23 -0.010813 -0.039430 -0.039475\n # ... ... ... ...\n quantile_ret_ts_ = quantile_ret_ts.copy().add(1) # type: pd.DataFrame\n # todo period larger than 1 is not right cumulative return\n cumulative_ret_by_group = quantile_ret_ts_.groupby(level=0).cumprod()\n cumulative_ret_by_group.dropna(inplace=True)\n cumulative_ret_by_group.sort_index(level=1, inplace=True)\n return cumulative_ret_by_group","def getCummulativeValues(self):\n self.cumulativePhaseHeightInRing1 = np.cumsum(self.phaseHeightInRing1)\n self.cumulativePhaseHeightInRing2 = np.cumsum(self.phaseHeightInRing2)\n self.cumulativeLeftCriticalPointsRing1 = np.cumsum(self.leftCriticalPointsRing1)\n self.cumulativeRightCriticalPointsRing1 = np.cumsum(self.rightCriticalPointsRing1)\n self.cumulativeLeftCriticalPointsRing2 = np.cumsum(self.leftCriticalPointsRing2)\n self.cumulativeRightCriticalPointsRing2 = np.cumsum(self.rightCriticalPointsRing2)\n\n if(self.init1 > 0):\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing1):\n self.cumulativeLeftCriticalPointsRing1[index] = value + self.init1\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing1):\n self.cumulativeRightCriticalPointsRing1[index] = value + self.init1\n\n if(self.init2 > 0):\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing2):\n self.cumulativeLeftCriticalPointsRing2[index] = value + self.init2\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing2):\n self.cumulativeRightCriticalPointsRing2[index] = value + self.init2\n\n self.cumulativePhaseHeightInRing1 = np.insert(self.cumulativePhaseHeightInRing1, 0, 0.0)\n self.cumulativePhaseHeightInRing2 = np.insert(self.cumulativePhaseHeightInRing2, 0, 0.0)\n self.cumulativeLeftCriticalPointsRing1 = np.insert(self.cumulativeLeftCriticalPointsRing1, 0, 0.0)\n self.cumulativeRightCriticalPointsRing1 = np.insert(self.cumulativeRightCriticalPointsRing1, 0, 0.0)\n self.cumulativeLeftCriticalPointsRing2 = np.insert(self.cumulativeLeftCriticalPointsRing2, 0, 0.0)\n self.cumulativeRightCriticalPointsRing2 = np.insert(self.cumulativeRightCriticalPointsRing2, 0, 0.0)","def _reset_absolute_metrics(self):\n\n for pid, process_metrics in self.__metrics_history.items():\n for _metric, _metric_values in process_metrics.items():\n if not _metric.is_cumulative:\n self.__aggregated_metrics[_metric] = 0","def get_cumgain(df, outcome_col='y', treatment_col='w', treatment_effect_col='tau',\n steps=100, normalize=False, random_seed=42):\n\n cumlift = get_cumlift(df, outcome_col, treatment_col, treatment_effect_col, steps, random_seed)\n\n # cumulative gain = cumulative lift x (# of population)\n cumgain = cumlift.mul(cumlift.index.values, axis=0) / 100 * df.shape[0]\n\n if normalize:\n cumgain = cumgain.div(cumgain.iloc[-1, :], axis=1)\n\n return cumgain","def test_cumulative_distribution_fit_call_pd(self):\n # Setup\n copula = GaussianMultivariate(GaussianUnivariate)\n copula.fit(self.data.to_numpy())\n X = np.array([2000., 200., 1.])\n expected_result = 0.4550595153746892\n\n # Run\n result = copula.cumulative_distribution(X)\n\n # Check\n assert np.isclose(result, expected_result, atol=1e-5).all().all()","def cum_returns(returns, starting_value=None):\n\n # df_price.pct_change() adds a nan in first position, we can use\n # that to have cum_returns start at the origin so that\n # df_cum.iloc[0] == starting_value\n # Note that we can't add that ourselves as we don't know which dt\n # to use.\n if pd.isnull(returns.iloc[0]):\n returns.iloc[0] = 0.\n\n df_cum = np.exp(np.log(1 + returns).cumsum())\n\n if starting_value is None:\n return df_cum - 1\n else:\n return df_cum * starting_value","def cumulative_sum(self, lis):\n new_list = []\n for i in range(len(lis)):\n if i == 0:\n new_list.append(lis[i])\n else:\n new_list.append(new_list[i-1] + lis[i])\n return new_list","def cdf(self,x):\n sortedMapping = sorted(self.mapping.items(), key=operator.itemgetter(0))\n if x == sortedMapping[-1][0]:\n return 1.0\n if x in self.values:\n cumulative=0.0\n for element in sortedMapping:\n cumulative += element[1]\n if x == ( float(element[0]) if self.isFloat else element[0] ):\n return cumulative\n else:\n if self.isFloat:\n cumulative=0.0\n for element in sortedMapping:\n cumulative += element[1]\n if x >= element[0]:\n return cumulative\n # if we reach this point we must error out\n self.raiseAnError(IOError,'Categorical distribution cannot calculate cdf for ' + str(x))","def cumulative_probability_distribution(self):\n return list(accumulate(self.probability_distribution()))","def _cumulative_sum(xs):\r\n cumsum = 0\r\n for x in xs:\r\n cumsum += x\r\n yield cumsum","def _cumsum(self) -> np.ndarray:\n\n if not hasattr(self, \"__cumsum\"):\n self.__cumsum = np.insert(np.cumsum(self.sizes), 0, 0)\n return self.__cumsum","def calculate_delta(self, name, previous, count):\n if count < previous:\n logger.error(\n \"Saw a non-monotonically increasing value for \"\n \"metric {name}\".format(name=name))\n return 0\n return count - previous","def processed_cum_overall(self):\n self.processed_cum_overall = (\n self.cumulative_stats_for_team_each_year\n [['Season','TeamID','win_rate','total_score','total_opponent_score','fgp','fg3p','ftp', 'total_rebounds','total_off_rebounds','total_def_rebounds',\n 'total_off_rebounds_percent','total_def_rebounds_percent','total_rebound_possession_percent','total_rebound_possessiongain_percent','total_blocks',\n 'total_assists','total_steals','total_turnover','total_personalfoul','total_block_opp_FGA_percent','total_assist_per_fgm','total_assist_turnover_ratio',\n 'expectation_per_game','avg_lose_score_by','avg_win_score_by']]\n )","def _discounted_cumsum(self, rewards, rate=None):\n # HINT1: note that each entry of the output should now be unique,\n # because the summation happens over [t, T] instead of [0, T]\n # HINT2: it is possible to write a vectorized solution, but a solution\n # using a for loop is also fine\n rate = self.gamma if rate is None else rate\n\n rewards = np.array(rewards)\n disounted_return = list(\n accumulate(rewards[::-1], lambda ret, rew: rate * ret + rew))\n disounted_return = np.array(disounted_return)[::-1]\n return disounted_return","def cdf(self, value):\n cdf = torch.where(\n value < 1., \n self.base.cdf(value), \n torch.ones_like(value) # all of the mass\n )\n cdf = torch.where(value < 0., torch.zeros_like(cdf), cdf)\n return cdf","def cum_distance(self, cum_distance):\n\n self._cum_distance = cum_distance","def cumulative_right (self):\n # TODO: include proper errors\n return Line (self.bins, self.values.cumsum ())","def _additive_estimate(events, timeline, _additive_f, _additive_var, reverse):\n if reverse:\n events = events.sort_index(ascending=False)\n population = events['entrance'].sum() - events['removed'].cumsum().shift(1).fillna(0)\n deaths = events['observed'].shift(1).fillna(0)\n estimate_ = np.cumsum(_additive_f(population, deaths)).ffill().sort_index()\n var_ = np.cumsum(_additive_var(population, deaths)).ffill().sort_index()\n else:\n deaths = events['observed']\n population = events['entrance'].cumsum() - events['removed'].cumsum().shift(1).fillna(0) #slowest line here.\n estimate_ = np.cumsum(_additive_f(population, deaths))\n var_ = np.cumsum(_additive_var(population, deaths))\n\n estimate_ = estimate_.reindex(timeline, method='pad').fillna(0)\n var_ = var_.reindex(timeline, method='pad')\n var_.index.name = 'timeline'\n estimate_.index.name = 'timeline'\n\n return estimate_, var_","def value(self):\n current_value = self.initial_value * self.schedule(self.step / self.nvalues)\n self.step += 1.\n return current_value","def cumulative_capacity_rule(_m, g, y):\r\n\r\n return sum(m.x_c[g, j] for j in m.Y if j <= y)","def exclusive_cumsum(x):\n return torch.cumsum(torch.cat([x.new_zeros(x.size(0), x.size(1), x.size(2), 1), x[:, :, :, :-1]], dim=-1), dim=-1)","def _add_if_observed(Idx, cumsum):\n \n with tf.name_scope(\"add_if_observed\"):\n cumsum = tf.cond(tf.equal(self.O[Idx], 1), \n lambda: _add_to_cumSum(Idx, cumsum),\n lambda: tf.cast(cumsum, tf.float32)) \n \n Idx = tf.cast(tf.add(Idx, 1), tf.int32)\n \n return Idx, cumsum","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def cumulative(requestContext, seriesList, consolidationFunc='sum'):\n return consolidateBy(requestContext, seriesList, 'sum')","def setEnableCumulative(self, value):\n return self._set(enableCumulative=value)","def get_cumulative_reward_spec(self) -> Tuple[Optional[float], Optional[float]]:\n if self == RewardType.EVERY_STEP_ZERO_SUM:\n return 0., 1.\n elif self == RewardType.EVERY_STEP_LENGTH:\n return 0., 1.\n elif self == RewardType.ON_EAT_AND_ON_DEATH:\n return -1., 1.\n elif self == RewardType.RANK_ON_DEATH:\n return -1., 1.\n else:\n raise ValueError(f'RewardType not yet implemented: {self.name}')","def cumsum(x, axis=None):\r\n return CumsumOp(axis=axis)(x)","def accumulate(self, value):\n inc_counter_op = smart_assign(self._counter, 1.0, assign_fn=tf.assign_add)\n acc_op = smart_assign(self._acc_var, value, assign_fn=tf.assign_add)\n return tf.group(inc_counter_op, acc_op)","def augmented_value(self, c):\n\t\t#test to make sure this division isnt just 0\n\t\treturn self.value + c/self.visited","def EvaluateCumulativeGaussian(self, *args):\n return _ITKCostFunctionsPython.itkCumulativeGaussianCostFunction_EvaluateCumulativeGaussian(self, *args)","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n numeric_only=True,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n numeric_only=True,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n numeric_only=True,\n keep_attrs=keep_attrs,\n **kwargs,\n )","def accumulate(values):\n # TODO: replace usage with numpy.cumsum(values) after adding numpy\n accumulation = 0\n for value in values:\n accumulation += value\n yield accumulation","def update(self, current, values=None, finalize=None):\n if finalize is None:\n if self.target is None:\n finalize = False\n else:\n finalize = current >= self.target\n\n values = values or []\n for k, v in values:\n if k not in self._values_order:\n self._values_order.append(k)\n if k not in self.stateful_metrics:\n # In the case that progress bar doesn't have a target value in the first\n # epoch, both on_batch_end and on_epoch_end will be called, which will\n # cause 'current' and 'self._seen_so_far' to have the same value. Force\n # the minimal value to 1 here, otherwise stateful_metric will be 0s.\n value_base = max(current - self._seen_so_far, 1)\n if k not in self._values:\n self._values[k] = [v * value_base, value_base]\n else:\n self._values[k][0] += v * value_base\n self._values[k][1] += value_base\n else:\n # Stateful metrics output a numeric value. This representation\n # means \"take an average from a single value\" but keeps the\n # numeric formatting.\n self._values[k] = [v, 1]\n self._seen_so_far = current\n\n now = time.time()\n info = ' - %.0fs' % (now - self._start)\n if self.verbose == 1:\n if now - self._last_update < self.interval and not finalize:\n return\n\n prev_total_width = self._total_width\n if self._dynamic_display:\n sys.stdout.write('\\b' * prev_total_width)\n sys.stdout.write('\\r')\n else:\n sys.stdout.write('\\n')\n\n if self.target is not None:\n numdigits = int(np.log10(self.target)) + 1\n bar = ('%' + str(numdigits) + 'd/%d [') % (current, self.target)\n prog = float(current) / self.target\n prog_width = int(self.width * prog)\n if prog_width > 0:\n bar += ('=' * (prog_width - 1))\n if current < self.target:\n bar += '>'\n else:\n bar += '='\n bar += ('.' * (self.width - prog_width))\n bar += ']'\n else:\n bar = '%7d/Unknown' % current\n\n self._total_width = len(bar)\n sys.stdout.write(bar)\n\n if current:\n time_per_unit = (now - self._start) / current\n else:\n time_per_unit = 0\n\n if self.target is None or finalize:\n if time_per_unit >= 1 or time_per_unit == 0:\n info += ' %.0fs/%s' % (time_per_unit, self.unit_name)\n elif time_per_unit >= 1e-3:\n info += ' %.0fms/%s' % (time_per_unit * 1e3, self.unit_name)\n else:\n info += ' %.0fus/%s' % (time_per_unit * 1e6, self.unit_name)\n else:\n eta = time_per_unit * (self.target - current)\n if eta > 3600:\n eta_format = '%d:%02d:%02d' % (eta // 3600,\n (eta % 3600) // 60, eta % 60)\n elif eta > 60:\n eta_format = '%d:%02d' % (eta // 60, eta % 60)\n else:\n eta_format = '%ds' % eta\n\n info = ' - ETA: %s' % eta_format\n\n for k in self._values_order:\n info += ' - %s:' % k\n if isinstance(self._values[k], list):\n avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))\n if abs(avg) > 1e-3:\n info += ' %.4f' % avg\n else:\n info += ' %.4e' % avg\n else:\n info += ' %s' % self._values[k]\n\n self._total_width += len(info)\n if prev_total_width > self._total_width:\n info += (' ' * (prev_total_width - self._total_width))\n\n if finalize:\n info += '\\n'\n\n sys.stdout.write(info)\n sys.stdout.flush()\n\n elif self.verbose == 2:\n if finalize:\n numdigits = int(np.log10(self.target)) + 1\n count = ('%' + str(numdigits) + 'd/%d') % (current, self.target)\n info = count + info\n for k in self._values_order:\n info += ' - %s:' % k\n avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))\n if avg > 1e-3:\n info += ' %.4f' % avg\n else:\n info += ' %.4e' % avg\n info += '\\n'\n\n sys.stdout.write(info)\n sys.stdout.flush()\n\n self._last_update = now","def cumulativeMovingAverage(self, x: list) -> list:\n N = len(x)\n C = [0] * (N + 1)\n \n for n in range(len(x)):\n C[n + 1] = C[n] + (x[n] - C[n])/(n + 1)\n \n C.pop(0) # remove leading 0\n \n return C","def drawdown(returns):\n val = returns.cumsum()\n running_max = val.expanding().max()\n drawdown_series = val - running_max\n return drawdown_series","def cumulative_energy_vertical(img):\n e = energy_map(img) # Total energy \n M = np.zeros((e.shape[0], e.shape[1]), dtype=type(e)) #To store cumulative minimum energy\n row,col = e.shape\n M[0] = e[0] #First row is same as energy_map first row\n for i in range(1,row):\n for j in range(0,col):\n if j == 0:\n M[i,j] = e[i,j] + min(M[i-1,j],M[i-1,j+1])\n elif j == col-1:\n M[i,j] = e[i,j] + min(M[i-1,j-1],M[i-1,j])\n else:\n M[i,j] = e[i,j] + min(M[i-1,j-1],M[i-1,j],M[i-1,j+1]) \n return M","def estimate(values, target):\n\n # next time\n # diff(values)\n\n\n return 1.","def reward_mean_100_running(self, cumreward, episode):\r\n if episode == 0:\r\n cumreward_mean100 = cumreward[0]\r\n elif episode <= 100 and episode > 0:\r\n cumreward_mean100 = np.mean(cumreward[:episode+1])\r\n else:\r\n cumreward_mean100 = np.mean(cumreward[episode - 100:episode])\r\n return cumreward_mean100","def test_cumulative_distribution_fit_call_np_array(self):\n # Setup\n copula = GaussianMultivariate(GaussianUnivariate)\n copula.fit(self.data.to_numpy())\n X = np.array([2000., 200., 1.])\n expected_result = 0.4550595153746892\n\n # Run\n result = copula.cumulative_distribution(X)\n\n # Check\n assert np.isclose(result, expected_result, atol=1e-5).all().all()","def cummax(self):\n return self._lift(lambda c: c.cummax)","def make_cumulative_distr_plot(data):\n x = data.index\n y = data[\"cumprop\"]\n plot = go.Bar(x=x, y=y, showlegend=False)\n\n return plot","def _calculate_aggregated_metrics(self):\n\n # using the historical values, calculate the aggregate\n # there are two kinds of metrics:\n # a) cumulative metrics - only the delta of the last 2 recorded values is used (eg cpu cycles)\n # b) absolute metrics - the last absolute value is used\n\n running_pids_set = set(self.__pids)\n\n for pid, process_metrics in self.__metrics_history.items():\n for _metric, _metric_values in process_metrics.items():\n if not self.__aggregated_metrics.get(_metric):\n self.__aggregated_metrics[_metric] = 0\n if _metric.is_cumulative:\n if pid in running_pids_set:\n if len(_metric_values) > 1:\n # only report the cumulative metrics for more than one sample\n self.__aggregated_metrics[_metric] += (\n _metric_values[-1] - _metric_values[-2]\n )\n else:\n if pid in running_pids_set:\n # absolute metric - accumulate the last reported value\n self.__aggregated_metrics[_metric] += _metric_values[-1]","def test_cumulative_distribution_fit_df_call_np_array(self):\n # Setup\n copula = GaussianMultivariate(GaussianUnivariate)\n copula.fit(self.data)\n X = np.array([2000., 200., 1.])\n expected_result = 0.4550595153746892\n\n # Run\n result = copula.cumulative_distribution(X)\n\n # Check\n assert np.isclose(result, expected_result, atol=1e-5).all().all()","def cumulative_sum(some_list):\n #This function will return new list that every element is the sum of the element before.\n for i in range(len(some_list)):\n new_list = some_list\n if i > 0: #if it's not the first element in list so it can be sum by element before.\n new_list[i] += new_list[i-1]\n else:\n pass #don't do anything with the first element of the list.\n return new_list","def get_cumulative(self, search_items, csv=False, output_dir=None, extra_param=None):\n\n # Get data from api and create objects\n api_datas = self.call_api(search_items, \"probability\", \"cumulative\", \"property\", extra_param=extra_param)\n product = [ProbabilityCumulative(api_data) for api_data in api_datas]\n\n if csv:\n csv_format.to_csv(product, \"probability\", \"cumulative\", output_dir=output_dir)\n\n logging.info(\"Probability Cumulative Data Ready.\")\n\n return product","def to_cumret(self, div_by_first: bool = True, logret: bool = False):\n if not any([True if x == 'Return(Total)' else False for x in self.tsdf.columns.get_level_values(1).values]):\n self.value_to_ret(logret=logret)\n self.tsdf = self.tsdf.add(1.0)\n self.tsdf = self.tsdf.cumprod(axis=0)\n if div_by_first:\n self.tsdf = self.tsdf / self.tsdf.iloc[0]\n self.valuetype = 'Price(Close)'\n self.tsdf.columns = pd.MultiIndex.from_product([[self.label], [self.valuetype]])\n return self","def __calc_cum_mean_reward(self, token_to_move, next_states):\r\n min_val = -1\r\n max_val = 99\r\n\r\n next_state_sum = np.mean(np.sum(next_states[token_to_move][0]))\r\n \r\n # Get the opponent who is most ahead by finding sum of the state\r\n opponents_next_state_sum = np.sum(next_states[token_to_move][1:])\r\n opponents_mean = np.mean(np.mean(opponents_next_state_sum))\r\n\r\n diff_state_sum = next_state_sum - opponents_mean\r\n\r\n return (diff_state_sum - min_val)/(max_val - min_val)","def _diff_cdf_at_time_i(pmf: Tensor, y: Tensor) -> Tensor:\n n = pmf.shape[0]\n ones = torch.ones((n, 1), device=pmf.device)\n r = pmf.cumsum(1).matmul(y.transpose(0, 1))\n diag_r = r.diag().view(1, -1)\n r = ones.matmul(diag_r) - r\n return r.transpose(0, 1)","def compute_cumulants(self, force=False):\n self._cumulant_computer.compute_cumulants(verbose=self.verbose,\n force=force)","def cumulative_sum(array):\n res = []\n val = 0\n for elem in array:\n val += elem\n res.append(val)\n return res","def cumsumr(x, axis=0):\n cums = x.cumsum(axis=axis)\n return cums - np.maximum.accumulate(cums*(x == 0), axis=axis)","def cum_dist_func(self, chi_square_stat):\n # use 1 degree of freedom given df = (R-1) * (C-1); df == (2-1) * (2-1) == 1\n p_value = 1.0 - float(stats.chi2.cdf(chi_square_stat, 1))\n return p_value","def reverse_CDF(self):\n self.series_y = 1. - self.series_y\n self.quantile_series_y_lower = 1. - self.quantile_series_y_lower\n self.quantile_series_y_upper = 1. - self.quantile_series_y_upper","def cummulativeCompare(values, pos, diff, offset) :\n\tnewvalues, newpos = hopMax(diff, offset)\n\tvalues, pos = mergeHopMax(values, pos, newvalues, newpos)\n\treturn values, pos","def cumulative_gamma(self, state: EnvState, params: EnvParams) -> float:\n return params.gamma**state.step","def compute_cdf(ordered_weights):\n return numpy.cumsum(ordered_weights) - 0.5 * ordered_weights","def cumulative_cm(locations, recombination_data):\n np_locations = np.array(locations, dtype = np.uint32, copy = False)\n base_ends = recombination_data.bases\n assert np.all(np_locations <= base_ends[-1])\n end_index = np.searchsorted(base_ends, np_locations, side = \"left\")\n \n cm_ends = recombination_data.cm\n cm_distance = cm_ends[end_index]\n \n bp_difference = base_ends[end_index] - locations\n rates = recombination_data.rates\n cm_difference = bp_difference * rates[end_index - 1]\n cm_difference[end_index == 0] = 0\n\n adjusted_cm_distance = cm_distance - cm_difference\n assert np.all(0 <= adjusted_cm_distance) , \"Expected positive cM distances, got {}\".format(adjusted_cm_distance[adjusted_cm_distance < 0])\n assert np.all(adjusted_cm_distance <= cm_ends[-1])\n return adjusted_cm_distance","def impute_cumulative_array(array):\n array = np.array(array).copy()\n array = convert_non_monotonic_to_nan(array)\n array = log_interpolate(array)\n return array","def daily_rolling_drawdown(cumulative_returns, rolling_max):\n\n return (cumulative_returns / rolling_max) - 1","def criticalvalue(tail, alpha):\n cumtail = np.cumsum(tail[::-1])\n # Valor crítico. Atenção! Não é a mesma convenção do aft-test...\n # este valor crítico ainda pertence à região crítica!\n critvalue = next(i for i, p in enumerate(cumtail[::-1]) if p < alpha)\n return critvalue","def impute_cumulative_df(df, src_col, dst_col, groupby_col):\n if src_col not in df.columns:\n raise ValueError(f\"'{src_col}' not found\")\n\n if dst_col not in df.columns:\n df[dst_col] = -1\n\n for adm_name in df[groupby_col].unique():\n sub = df.loc[df[groupby_col] == adm_name].copy()\n sub[dst_col] = impute_cumulative_array(sub[src_col])\n\n # Replace non-monotonic values in original `cum_confirmed_cases` column with nulls\n raw_cum_col = \"cum_confirmed_cases\"\n sub.loc[sub[raw_cum_col].notnull(), raw_cum_col] = convert_non_monotonic_to_nan(\n np.array(sub.loc[sub[raw_cum_col].notnull(), raw_cum_col])\n )\n\n df.loc[df[groupby_col] == adm_name] = sub\n\n return df","def value_to_cumulative_prob(value, hp):\n if isinstance(hp, Fixed):\n return 0.5\n if isinstance(hp, Boolean):\n # Center the value in its probability bucket.\n if value:\n return 0.75\n return 0.25\n elif isinstance(hp, Choice):\n ele_prob = 1 / len(hp.values)\n index = hp.values.index(value)\n # Center the value in its probability bucket.\n return (index + 0.5) * ele_prob\n elif isinstance(hp, (Int, Float)):\n sampling = hp.sampling or 'linear'\n if sampling == 'linear':\n return (value - hp.min_value) / (hp.max_value - hp.min_value)\n elif sampling == 'log':\n return (math.log(value / hp.min_value) /\n math.log(hp.max_value / hp.min_value))\n elif sampling == 'reverse_log':\n return (\n 1. - math.log((hp.max_value + hp.min_value - value) / hp.min_value) /\n math.log(hp.max_value / hp.min_value))\n else:\n raise ValueError('Unrecognized sampling value: {}'.format(sampling))\n else:\n raise ValueError('Unrecognized HyperParameter type: {}'.format(hp))","def _get_cum_variance(self) -> np.ndarray:\n return np.cumsum(self.pca.explained_variance_ratio_)","def cdf(self, value=None):\n if value is None:\n value = self.value\n return self.rv.cdf(\n value, *self._pymc_dists_to_value(self.args), **self.kwds\n )","def get_price_0_cumulative_last(self, pair):\n pair_contract = self.conn.eth.contract(\n address=Web3.toChecksumAddress(pair), abi=SushiswapClient.PAIR_ABI)\n return pair_contract.functions.price0CumulativeLast().call()","def cumsum(L):\n for i in range(1, len(L)):\n L[i] += L[i-1]\n return L","def controlDelta(self, prev_delta, acc_rate):\n if (acc_rate > .6):\n return prev_delta * 1.1\n elif (acc_rate < .4):\n return prev_delta / 1.1\n else:\n return prev_delta","def get_cumulative_value(self, header:TimeSeriesHeaderTypes, timespan:timedelta):\n\n if header not in self._series_data:\n return None\n\n data_series = self._series_data[header]\n\n #All times below are converted to seconds from unix epoch\n start_date = self._series_data[header][0, 0]\n\n start_index = np.argmax(data_series[:,0] > (start_date + timespan.total_seconds()))#Get index of first element after start_time\n stop_index = np.argmax(data_series[:,0] > start_date + timespan.total_seconds() + timespan.total_seconds())\n\n if stop_index == 0:#start_time + timespan > last data date\n stop_index = len(data_series[0])\n\n return np.sum(data_series[start_index:stop_index, 1])","def get_percdone(self, current_acq=0):\n if current_acq == np.nan:\n # np.nan indicates that progress reporting is in principle\n # supported, but failed. This will be treated like no progress.\n percdone = np.nan\n else:\n percdone = (self.total_nr_acquired_values + current_acq) / (\n np.shape(self.get_sweep_points())[0] * self.soft_avg()) * 100\n try:\n now = time.time()\n if percdone != np.nan and percdone != self._last_percdone_value:\n # progress was made\n self._last_percdone_value = percdone\n self._last_percdone_change_time = now\n log.debug(f'MC: percdone = {self._last_percdone_value} at '\n f'{self._last_percdone_change_time}')\n elif self._last_percdone_change_time == 0:\n # first progress check: initialize _last_percdone_change_time\n self._last_percdone_change_time = now\n self._last_percdone_log_time = self._last_percdone_change_time\n else: # no progress was made\n no_prog_inter = self.no_progress_interval()\n no_prog_inter2 = self.no_progress_kill_interval()\n no_prog_min = (now - self._last_percdone_change_time) / 60\n log.debug(f'MC: no_prog_min = {no_prog_min}, '\n f'percdone = {percdone}')\n msg = f'The current measurement has not made any progress ' \\\n f'for {no_prog_min: .01f} minutes.'\n if now - self._last_percdone_change_time > no_prog_inter \\\n and now - self._last_percdone_log_time > no_prog_inter:\n log.warning(msg)\n self.log_to_slack(msg)\n self._last_percdone_log_time = now\n if now - self._last_percdone_change_time > no_prog_inter2:\n log.debug(f'MC: raising NoProgressError')\n raise NoProgressError(msg)\n except NoProgressError:\n raise\n except Exception as e:\n log.debug(f'MC: error while checking progress: {repr(e)}')\n return percdone"],"string":"[\n \"def cumulative_returns(self):\\n return (1 + self.pct_change).cumprod()\",\n \"def get_cumulative_model(self):\\n cm = None\\n for ac in self.ac:\\n if ac[0] is None:\\n continue\\n m = self.get_model(last=False, a=ac[0], c=ac[1])\\n cm = m if cm is None else cm+m\\n return cm\",\n \"def cumulative_distribution(self, X):\\n raise NotImplementedError\",\n \"def cummulative_return(df):\\n cumm_daily_return=(df[-1]/df[0])-1\\n \\n return cumm_daily_return\",\n \"def cumulate(self):\\n name = self.getName() + '_Cumulated'\\n c_names = self.getColumnNames()\\n # create the new table an add the first column to it\\n t_cumulate = DataTable(name)\\n time = self.getColumn(0)\\n t_cumulate.addColumn(c_names[0],time)\\n # for each other column, cumulate values \\n for i in range(1,self.getNbColumns()):\\n c = self.getColumn(i)\\n N = [0]\\n for j in range(1,len(c)):\\n n = (c[j]+c[j-1])/2*(time[j]-time[j-1]) + N[-1]\\n N.append(n)\\n pass\\n t_cumulate.addColumn(c_names[i],N)\\n pass\\n \\n return t_cumulate\",\n \"def cumulate(self, value):\\n last = 0 if len(self) == 0 else self[-1]\\n if value is None:\\n self.append(last)\\n else:\\n self.append(last + value)\",\n \"def calculate_cumulative_reward(self, gamma: float = 1.0):\\n num_transitions = len(self)\\n assert num_transitions > 0, \\\"called on empty trajectory\\\"\\n rewards = self.reward\\n discounts = [gamma**i for i in range(num_transitions)]\\n return sum(reward * discount for reward, discount in zip(rewards, discounts))\",\n \"def cumulate(tobject):\\n # forward suffix\\n return asrootpy(tobject.GetCumulative(True, uuid.uuid4().get_hex()))\",\n \"def from_cumulative(self, cumulative):\\n return self._dist_cls.from_cumulative(self._edges, cumulative)\",\n \"def get_bprop_cumsum(self):\\n cumsum = P.CumSum(exclusive=self.exclusive, reverse=not self.reverse)\\n\\n def bprop(x, axis, out, dout):\\n return cumsum(dout, axis), zeros_like(axis)\\n return bprop\",\n \"def cumprob(self):\\r\\n return self.probabilities.cumsum(-1)\",\n \"def show_cumulative_mig(model):\\r\\n return sum(cumulative_mig_list)\",\n \"def calculate_cumulative_returns(returns, starting_value=0, out=None):\\n if len(returns) < 1:\\n return returns.copy()\\n\\n nanmask = np.isnan(returns)\\n if np.any(nanmask):\\n returns = returns.copy()\\n returns[nanmask] = 0\\n\\n allocated_output = out is None\\n if allocated_output:\\n out = np.empty_like(returns)\\n\\n np.add(returns, 1, out=out)\\n out.cumprod(axis=0, out=out)\\n\\n if starting_value == 0:\\n np.subtract(out, 1, out=out)\\n else:\\n np.multiply(out, starting_value, out=out)\\n\\n if allocated_output:\\n if returns.ndim == 1 and isinstance(returns, pd.Series):\\n out = pd.Series(out, index=returns.index)\\n elif isinstance(returns, pd.DataFrame):\\n out = pd.DataFrame(\\n out, index=returns.index, columns=returns.columns,\\n )\\n\\n return out\",\n \"def get_cumulative_rewards(rewards, # rewards at each step\\n gamma=0.99 # discount for reward\\n ):\\n\\n cumulative_rewards = np.empty_like(rewards)\\n cumulative_rewards = cumulative_rewards.astype(float)\\n cumulative_rewards[-1] = rewards[-1]\\n\\n for index in range(len(rewards) - 2, -1, -1):\\n discount = cumulative_rewards[index + 1] * gamma\\n reward = rewards[index]\\n cumulative_rewards[index] = discount + reward\\n\\n return cumulative_rewards # <array of cumulative rewards>\",\n \"def cum_sum(self):\\n\\n # create cdo command and runit\\n cdo_command = \\\"cdo -timcumsum\\\"\\n run_this(cdo_command, self, output=\\\"ensemble\\\")\",\n \"def _cumulative_diff(item, key):\\n global _prev_values\\n if key in _prev_values:\\n # Subsequent item, return difference from previous\\n prev = _prev_values[key]\\n _prev_values[key] = item\\n\\n result = copy.deepcopy(item)\\n for fname in result[\\\"fields\\\"]:\\n result[\\\"fields\\\"][fname] -= prev[\\\"fields\\\"][fname]\\n\\n return result\\n else:\\n # First item, no difference, return zeros.\\n _prev_values[key] = item\\n result = copy.deepcopy(item)\\n fields = result[\\\"fields\\\"]\\n for fname in fields:\\n fields[fname] = 0\\n return result\",\n \"def get_cumulative_distribution(self):\\n srt_dists = np.sort(self._distances)\\n tol = 1E-3\\n for i in range(1, len(srt_dists)):\\n while srt_dists[i] - srt_dists[i-1] < tol:\\n srt_dists[i] += tol\\n return {\\\"x\\\": srt_dists-srt_dists[0], \\n \\\"P\\\": np.linspace(0.0, 1.0, len(self._distances), endpoint=False)}\",\n \"def __get_cumulative (self, event_df, inputon, inputoff, num_bins = 10):\\r\\n \\r\\n input_mark = lambda x, inputon, inputoff: 1 if x == inputon else -1 if x == inputoff else 0\\r\\n \\r\\n if len(event_df) == 0:\\r\\n pass\\r\\n else:\\r\\n df = event_df.copy()\\r\\n df[inputon] = df['Events'].apply(lambda x: input_mark(x, inputon, inputoff))\\r\\n start_cum = df[df['Events']== inputon][['Time',inputon]] #defaults is input state\\r\\n start_cum[self.subject+'_cum'] = start_cum[inputon].cumsum()\\r\\n #start_cum[self.subject+'_cumP'] = 100*start_cum[self.subject+'_cum']/start_cum[inputon].sum()\\r\\n start_cum.reset_index(inplace=True)\\r\\n start_cum.drop(columns = inputon,inplace = True)\\r\\n start_cum.drop(columns = 'index',inplace = True)\\r\\n return start_cum\",\n \"def cumsum(self):\\n return self._lift(lambda c: c.cumsum)\",\n \"def get_cum_returns(self,df, init_inv = 1):\\n return ((1 + df).cumprod()) * init_inv\",\n \"def get_cumulative_rewards(rewards, # rewards at each step\\r\\n gamma=0.99 # discount for reward\\r\\n ):\\r\\n cumulative_rewards = []\\r\\n prev = 0\\r\\n\\r\\n for r in reversed(rewards):\\r\\n prev = r + gamma * prev\\r\\n cumulative_rewards.append(prev)\\r\\n cumulative_rewards.reverse()\\r\\n return cumulative_rewards\",\n \"def cumulative_left (self):\\n # TODO: include proper errors\\n return Line (self.bins,\\n self.values[::-1].cumsum ()[::-1])\\n #return Line (self.bins, self.sum - self.values.cumsum ())\",\n \"def cumulative_correlation(self) -> int:\\n return self._cumulative_correlation\",\n \"def cumulative_distribution(self, dist='current'):\\n \\n dictDist = {'current': np.cumsum(self.current),\\n 'prior': np.cumsum(self.prior),\\n 'posterior': np.cumsum(self.posterior, axis=1)\\n }\\n \\n cdf = dictDist[dist]\\n \\n return cdf\",\n \"def cumulative_distribution(self):\\n\\n cum_dd = []\\n sum_p = 0\\n for k, p in reversed(self.dd):\\n sum_p += p\\n cum_dd.append((k, sum_p))\\n return list(reversed(cum_dd))\",\n \"def test_kde_cumulative(limits):\\n data = np.random.normal(0, 1, 1000)\\n density = _kde(data, custom_lims=limits, cumulative=True)[1]\\n np.testing.assert_almost_equal(round(density[-1], 3), 1)\",\n \"def office_calculate_cumulative_misfit(parser, args, params):\\n local_args = parser.parse_known_args(args)\\n control.calculate_cumulative_misfit(params)\",\n \"def calculate_cumulative_returns_by_group(quantile_ret_ts: pd.DataFrame):\\n # 1_period_return 5_period_return 10_period_return\\n # factor_quantile Date\\n # 1 2010-06-17 0.002230 0.021172 -0.014775\\n # 2010-06-18 0.036203 0.017436 -0.016843\\n # 2010-06-21 -0.004873 -0.017346 -0.035416\\n # 2010-06-22 -0.000315 -0.036443 -0.046313\\n # 2010-06-23 -0.010813 -0.039430 -0.039475\\n # ... ... ... ...\\n quantile_ret_ts_ = quantile_ret_ts.copy().add(1) # type: pd.DataFrame\\n # todo period larger than 1 is not right cumulative return\\n cumulative_ret_by_group = quantile_ret_ts_.groupby(level=0).cumprod()\\n cumulative_ret_by_group.dropna(inplace=True)\\n cumulative_ret_by_group.sort_index(level=1, inplace=True)\\n return cumulative_ret_by_group\",\n \"def getCummulativeValues(self):\\n self.cumulativePhaseHeightInRing1 = np.cumsum(self.phaseHeightInRing1)\\n self.cumulativePhaseHeightInRing2 = np.cumsum(self.phaseHeightInRing2)\\n self.cumulativeLeftCriticalPointsRing1 = np.cumsum(self.leftCriticalPointsRing1)\\n self.cumulativeRightCriticalPointsRing1 = np.cumsum(self.rightCriticalPointsRing1)\\n self.cumulativeLeftCriticalPointsRing2 = np.cumsum(self.leftCriticalPointsRing2)\\n self.cumulativeRightCriticalPointsRing2 = np.cumsum(self.rightCriticalPointsRing2)\\n\\n if(self.init1 > 0):\\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing1):\\n self.cumulativeLeftCriticalPointsRing1[index] = value + self.init1\\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing1):\\n self.cumulativeRightCriticalPointsRing1[index] = value + self.init1\\n\\n if(self.init2 > 0):\\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing2):\\n self.cumulativeLeftCriticalPointsRing2[index] = value + self.init2\\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing2):\\n self.cumulativeRightCriticalPointsRing2[index] = value + self.init2\\n\\n self.cumulativePhaseHeightInRing1 = np.insert(self.cumulativePhaseHeightInRing1, 0, 0.0)\\n self.cumulativePhaseHeightInRing2 = np.insert(self.cumulativePhaseHeightInRing2, 0, 0.0)\\n self.cumulativeLeftCriticalPointsRing1 = np.insert(self.cumulativeLeftCriticalPointsRing1, 0, 0.0)\\n self.cumulativeRightCriticalPointsRing1 = np.insert(self.cumulativeRightCriticalPointsRing1, 0, 0.0)\\n self.cumulativeLeftCriticalPointsRing2 = np.insert(self.cumulativeLeftCriticalPointsRing2, 0, 0.0)\\n self.cumulativeRightCriticalPointsRing2 = np.insert(self.cumulativeRightCriticalPointsRing2, 0, 0.0)\",\n \"def _reset_absolute_metrics(self):\\n\\n for pid, process_metrics in self.__metrics_history.items():\\n for _metric, _metric_values in process_metrics.items():\\n if not _metric.is_cumulative:\\n self.__aggregated_metrics[_metric] = 0\",\n \"def get_cumgain(df, outcome_col='y', treatment_col='w', treatment_effect_col='tau',\\n steps=100, normalize=False, random_seed=42):\\n\\n cumlift = get_cumlift(df, outcome_col, treatment_col, treatment_effect_col, steps, random_seed)\\n\\n # cumulative gain = cumulative lift x (# of population)\\n cumgain = cumlift.mul(cumlift.index.values, axis=0) / 100 * df.shape[0]\\n\\n if normalize:\\n cumgain = cumgain.div(cumgain.iloc[-1, :], axis=1)\\n\\n return cumgain\",\n \"def test_cumulative_distribution_fit_call_pd(self):\\n # Setup\\n copula = GaussianMultivariate(GaussianUnivariate)\\n copula.fit(self.data.to_numpy())\\n X = np.array([2000., 200., 1.])\\n expected_result = 0.4550595153746892\\n\\n # Run\\n result = copula.cumulative_distribution(X)\\n\\n # Check\\n assert np.isclose(result, expected_result, atol=1e-5).all().all()\",\n \"def cum_returns(returns, starting_value=None):\\n\\n # df_price.pct_change() adds a nan in first position, we can use\\n # that to have cum_returns start at the origin so that\\n # df_cum.iloc[0] == starting_value\\n # Note that we can't add that ourselves as we don't know which dt\\n # to use.\\n if pd.isnull(returns.iloc[0]):\\n returns.iloc[0] = 0.\\n\\n df_cum = np.exp(np.log(1 + returns).cumsum())\\n\\n if starting_value is None:\\n return df_cum - 1\\n else:\\n return df_cum * starting_value\",\n \"def cumulative_sum(self, lis):\\n new_list = []\\n for i in range(len(lis)):\\n if i == 0:\\n new_list.append(lis[i])\\n else:\\n new_list.append(new_list[i-1] + lis[i])\\n return new_list\",\n \"def cdf(self,x):\\n sortedMapping = sorted(self.mapping.items(), key=operator.itemgetter(0))\\n if x == sortedMapping[-1][0]:\\n return 1.0\\n if x in self.values:\\n cumulative=0.0\\n for element in sortedMapping:\\n cumulative += element[1]\\n if x == ( float(element[0]) if self.isFloat else element[0] ):\\n return cumulative\\n else:\\n if self.isFloat:\\n cumulative=0.0\\n for element in sortedMapping:\\n cumulative += element[1]\\n if x >= element[0]:\\n return cumulative\\n # if we reach this point we must error out\\n self.raiseAnError(IOError,'Categorical distribution cannot calculate cdf for ' + str(x))\",\n \"def cumulative_probability_distribution(self):\\n return list(accumulate(self.probability_distribution()))\",\n \"def _cumulative_sum(xs):\\r\\n cumsum = 0\\r\\n for x in xs:\\r\\n cumsum += x\\r\\n yield cumsum\",\n \"def _cumsum(self) -> np.ndarray:\\n\\n if not hasattr(self, \\\"__cumsum\\\"):\\n self.__cumsum = np.insert(np.cumsum(self.sizes), 0, 0)\\n return self.__cumsum\",\n \"def calculate_delta(self, name, previous, count):\\n if count < previous:\\n logger.error(\\n \\\"Saw a non-monotonically increasing value for \\\"\\n \\\"metric {name}\\\".format(name=name))\\n return 0\\n return count - previous\",\n \"def processed_cum_overall(self):\\n self.processed_cum_overall = (\\n self.cumulative_stats_for_team_each_year\\n [['Season','TeamID','win_rate','total_score','total_opponent_score','fgp','fg3p','ftp', 'total_rebounds','total_off_rebounds','total_def_rebounds',\\n 'total_off_rebounds_percent','total_def_rebounds_percent','total_rebound_possession_percent','total_rebound_possessiongain_percent','total_blocks',\\n 'total_assists','total_steals','total_turnover','total_personalfoul','total_block_opp_FGA_percent','total_assist_per_fgm','total_assist_turnover_ratio',\\n 'expectation_per_game','avg_lose_score_by','avg_win_score_by']]\\n )\",\n \"def _discounted_cumsum(self, rewards, rate=None):\\n # HINT1: note that each entry of the output should now be unique,\\n # because the summation happens over [t, T] instead of [0, T]\\n # HINT2: it is possible to write a vectorized solution, but a solution\\n # using a for loop is also fine\\n rate = self.gamma if rate is None else rate\\n\\n rewards = np.array(rewards)\\n disounted_return = list(\\n accumulate(rewards[::-1], lambda ret, rew: rate * ret + rew))\\n disounted_return = np.array(disounted_return)[::-1]\\n return disounted_return\",\n \"def cdf(self, value):\\n cdf = torch.where(\\n value < 1., \\n self.base.cdf(value), \\n torch.ones_like(value) # all of the mass\\n )\\n cdf = torch.where(value < 0., torch.zeros_like(cdf), cdf)\\n return cdf\",\n \"def cum_distance(self, cum_distance):\\n\\n self._cum_distance = cum_distance\",\n \"def cumulative_right (self):\\n # TODO: include proper errors\\n return Line (self.bins, self.values.cumsum ())\",\n \"def _additive_estimate(events, timeline, _additive_f, _additive_var, reverse):\\n if reverse:\\n events = events.sort_index(ascending=False)\\n population = events['entrance'].sum() - events['removed'].cumsum().shift(1).fillna(0)\\n deaths = events['observed'].shift(1).fillna(0)\\n estimate_ = np.cumsum(_additive_f(population, deaths)).ffill().sort_index()\\n var_ = np.cumsum(_additive_var(population, deaths)).ffill().sort_index()\\n else:\\n deaths = events['observed']\\n population = events['entrance'].cumsum() - events['removed'].cumsum().shift(1).fillna(0) #slowest line here.\\n estimate_ = np.cumsum(_additive_f(population, deaths))\\n var_ = np.cumsum(_additive_var(population, deaths))\\n\\n estimate_ = estimate_.reindex(timeline, method='pad').fillna(0)\\n var_ = var_.reindex(timeline, method='pad')\\n var_.index.name = 'timeline'\\n estimate_.index.name = 'timeline'\\n\\n return estimate_, var_\",\n \"def value(self):\\n current_value = self.initial_value * self.schedule(self.step / self.nvalues)\\n self.step += 1.\\n return current_value\",\n \"def cumulative_capacity_rule(_m, g, y):\\r\\n\\r\\n return sum(m.x_c[g, j] for j in m.Y if j <= y)\",\n \"def exclusive_cumsum(x):\\n return torch.cumsum(torch.cat([x.new_zeros(x.size(0), x.size(1), x.size(2), 1), x[:, :, :, :-1]], dim=-1), dim=-1)\",\n \"def _add_if_observed(Idx, cumsum):\\n \\n with tf.name_scope(\\\"add_if_observed\\\"):\\n cumsum = tf.cond(tf.equal(self.O[Idx], 1), \\n lambda: _add_to_cumSum(Idx, cumsum),\\n lambda: tf.cast(cumsum, tf.float32)) \\n \\n Idx = tf.cast(tf.add(Idx, 1), tf.int32)\\n \\n return Idx, cumsum\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> DataArray:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> DataArray:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> DataArray:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def cumulative(requestContext, seriesList, consolidationFunc='sum'):\\n return consolidateBy(requestContext, seriesList, 'sum')\",\n \"def setEnableCumulative(self, value):\\n return self._set(enableCumulative=value)\",\n \"def get_cumulative_reward_spec(self) -> Tuple[Optional[float], Optional[float]]:\\n if self == RewardType.EVERY_STEP_ZERO_SUM:\\n return 0., 1.\\n elif self == RewardType.EVERY_STEP_LENGTH:\\n return 0., 1.\\n elif self == RewardType.ON_EAT_AND_ON_DEATH:\\n return -1., 1.\\n elif self == RewardType.RANK_ON_DEATH:\\n return -1., 1.\\n else:\\n raise ValueError(f'RewardType not yet implemented: {self.name}')\",\n \"def cumsum(x, axis=None):\\r\\n return CumsumOp(axis=axis)(x)\",\n \"def accumulate(self, value):\\n inc_counter_op = smart_assign(self._counter, 1.0, assign_fn=tf.assign_add)\\n acc_op = smart_assign(self._acc_var, value, assign_fn=tf.assign_add)\\n return tf.group(inc_counter_op, acc_op)\",\n \"def augmented_value(self, c):\\n\\t\\t#test to make sure this division isnt just 0\\n\\t\\treturn self.value + c/self.visited\",\n \"def EvaluateCumulativeGaussian(self, *args):\\n return _ITKCostFunctionsPython.itkCumulativeGaussianCostFunction_EvaluateCumulativeGaussian(self, *args)\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> Dataset:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n numeric_only=True,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> Dataset:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n numeric_only=True,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def cumsum(\\n self,\\n dim: Dims = None,\\n *,\\n skipna: bool | None = None,\\n keep_attrs: bool | None = None,\\n **kwargs: Any,\\n ) -> Dataset:\\n return self.reduce(\\n duck_array_ops.cumsum,\\n dim=dim,\\n skipna=skipna,\\n numeric_only=True,\\n keep_attrs=keep_attrs,\\n **kwargs,\\n )\",\n \"def accumulate(values):\\n # TODO: replace usage with numpy.cumsum(values) after adding numpy\\n accumulation = 0\\n for value in values:\\n accumulation += value\\n yield accumulation\",\n \"def update(self, current, values=None, finalize=None):\\n if finalize is None:\\n if self.target is None:\\n finalize = False\\n else:\\n finalize = current >= self.target\\n\\n values = values or []\\n for k, v in values:\\n if k not in self._values_order:\\n self._values_order.append(k)\\n if k not in self.stateful_metrics:\\n # In the case that progress bar doesn't have a target value in the first\\n # epoch, both on_batch_end and on_epoch_end will be called, which will\\n # cause 'current' and 'self._seen_so_far' to have the same value. Force\\n # the minimal value to 1 here, otherwise stateful_metric will be 0s.\\n value_base = max(current - self._seen_so_far, 1)\\n if k not in self._values:\\n self._values[k] = [v * value_base, value_base]\\n else:\\n self._values[k][0] += v * value_base\\n self._values[k][1] += value_base\\n else:\\n # Stateful metrics output a numeric value. This representation\\n # means \\\"take an average from a single value\\\" but keeps the\\n # numeric formatting.\\n self._values[k] = [v, 1]\\n self._seen_so_far = current\\n\\n now = time.time()\\n info = ' - %.0fs' % (now - self._start)\\n if self.verbose == 1:\\n if now - self._last_update < self.interval and not finalize:\\n return\\n\\n prev_total_width = self._total_width\\n if self._dynamic_display:\\n sys.stdout.write('\\\\b' * prev_total_width)\\n sys.stdout.write('\\\\r')\\n else:\\n sys.stdout.write('\\\\n')\\n\\n if self.target is not None:\\n numdigits = int(np.log10(self.target)) + 1\\n bar = ('%' + str(numdigits) + 'd/%d [') % (current, self.target)\\n prog = float(current) / self.target\\n prog_width = int(self.width * prog)\\n if prog_width > 0:\\n bar += ('=' * (prog_width - 1))\\n if current < self.target:\\n bar += '>'\\n else:\\n bar += '='\\n bar += ('.' * (self.width - prog_width))\\n bar += ']'\\n else:\\n bar = '%7d/Unknown' % current\\n\\n self._total_width = len(bar)\\n sys.stdout.write(bar)\\n\\n if current:\\n time_per_unit = (now - self._start) / current\\n else:\\n time_per_unit = 0\\n\\n if self.target is None or finalize:\\n if time_per_unit >= 1 or time_per_unit == 0:\\n info += ' %.0fs/%s' % (time_per_unit, self.unit_name)\\n elif time_per_unit >= 1e-3:\\n info += ' %.0fms/%s' % (time_per_unit * 1e3, self.unit_name)\\n else:\\n info += ' %.0fus/%s' % (time_per_unit * 1e6, self.unit_name)\\n else:\\n eta = time_per_unit * (self.target - current)\\n if eta > 3600:\\n eta_format = '%d:%02d:%02d' % (eta // 3600,\\n (eta % 3600) // 60, eta % 60)\\n elif eta > 60:\\n eta_format = '%d:%02d' % (eta // 60, eta % 60)\\n else:\\n eta_format = '%ds' % eta\\n\\n info = ' - ETA: %s' % eta_format\\n\\n for k in self._values_order:\\n info += ' - %s:' % k\\n if isinstance(self._values[k], list):\\n avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))\\n if abs(avg) > 1e-3:\\n info += ' %.4f' % avg\\n else:\\n info += ' %.4e' % avg\\n else:\\n info += ' %s' % self._values[k]\\n\\n self._total_width += len(info)\\n if prev_total_width > self._total_width:\\n info += (' ' * (prev_total_width - self._total_width))\\n\\n if finalize:\\n info += '\\\\n'\\n\\n sys.stdout.write(info)\\n sys.stdout.flush()\\n\\n elif self.verbose == 2:\\n if finalize:\\n numdigits = int(np.log10(self.target)) + 1\\n count = ('%' + str(numdigits) + 'd/%d') % (current, self.target)\\n info = count + info\\n for k in self._values_order:\\n info += ' - %s:' % k\\n avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))\\n if avg > 1e-3:\\n info += ' %.4f' % avg\\n else:\\n info += ' %.4e' % avg\\n info += '\\\\n'\\n\\n sys.stdout.write(info)\\n sys.stdout.flush()\\n\\n self._last_update = now\",\n \"def cumulativeMovingAverage(self, x: list) -> list:\\n N = len(x)\\n C = [0] * (N + 1)\\n \\n for n in range(len(x)):\\n C[n + 1] = C[n] + (x[n] - C[n])/(n + 1)\\n \\n C.pop(0) # remove leading 0\\n \\n return C\",\n \"def drawdown(returns):\\n val = returns.cumsum()\\n running_max = val.expanding().max()\\n drawdown_series = val - running_max\\n return drawdown_series\",\n \"def cumulative_energy_vertical(img):\\n e = energy_map(img) # Total energy \\n M = np.zeros((e.shape[0], e.shape[1]), dtype=type(e)) #To store cumulative minimum energy\\n row,col = e.shape\\n M[0] = e[0] #First row is same as energy_map first row\\n for i in range(1,row):\\n for j in range(0,col):\\n if j == 0:\\n M[i,j] = e[i,j] + min(M[i-1,j],M[i-1,j+1])\\n elif j == col-1:\\n M[i,j] = e[i,j] + min(M[i-1,j-1],M[i-1,j])\\n else:\\n M[i,j] = e[i,j] + min(M[i-1,j-1],M[i-1,j],M[i-1,j+1]) \\n return M\",\n \"def estimate(values, target):\\n\\n # next time\\n # diff(values)\\n\\n\\n return 1.\",\n \"def reward_mean_100_running(self, cumreward, episode):\\r\\n if episode == 0:\\r\\n cumreward_mean100 = cumreward[0]\\r\\n elif episode <= 100 and episode > 0:\\r\\n cumreward_mean100 = np.mean(cumreward[:episode+1])\\r\\n else:\\r\\n cumreward_mean100 = np.mean(cumreward[episode - 100:episode])\\r\\n return cumreward_mean100\",\n \"def test_cumulative_distribution_fit_call_np_array(self):\\n # Setup\\n copula = GaussianMultivariate(GaussianUnivariate)\\n copula.fit(self.data.to_numpy())\\n X = np.array([2000., 200., 1.])\\n expected_result = 0.4550595153746892\\n\\n # Run\\n result = copula.cumulative_distribution(X)\\n\\n # Check\\n assert np.isclose(result, expected_result, atol=1e-5).all().all()\",\n \"def cummax(self):\\n return self._lift(lambda c: c.cummax)\",\n \"def make_cumulative_distr_plot(data):\\n x = data.index\\n y = data[\\\"cumprop\\\"]\\n plot = go.Bar(x=x, y=y, showlegend=False)\\n\\n return plot\",\n \"def _calculate_aggregated_metrics(self):\\n\\n # using the historical values, calculate the aggregate\\n # there are two kinds of metrics:\\n # a) cumulative metrics - only the delta of the last 2 recorded values is used (eg cpu cycles)\\n # b) absolute metrics - the last absolute value is used\\n\\n running_pids_set = set(self.__pids)\\n\\n for pid, process_metrics in self.__metrics_history.items():\\n for _metric, _metric_values in process_metrics.items():\\n if not self.__aggregated_metrics.get(_metric):\\n self.__aggregated_metrics[_metric] = 0\\n if _metric.is_cumulative:\\n if pid in running_pids_set:\\n if len(_metric_values) > 1:\\n # only report the cumulative metrics for more than one sample\\n self.__aggregated_metrics[_metric] += (\\n _metric_values[-1] - _metric_values[-2]\\n )\\n else:\\n if pid in running_pids_set:\\n # absolute metric - accumulate the last reported value\\n self.__aggregated_metrics[_metric] += _metric_values[-1]\",\n \"def test_cumulative_distribution_fit_df_call_np_array(self):\\n # Setup\\n copula = GaussianMultivariate(GaussianUnivariate)\\n copula.fit(self.data)\\n X = np.array([2000., 200., 1.])\\n expected_result = 0.4550595153746892\\n\\n # Run\\n result = copula.cumulative_distribution(X)\\n\\n # Check\\n assert np.isclose(result, expected_result, atol=1e-5).all().all()\",\n \"def cumulative_sum(some_list):\\n #This function will return new list that every element is the sum of the element before.\\n for i in range(len(some_list)):\\n new_list = some_list\\n if i > 0: #if it's not the first element in list so it can be sum by element before.\\n new_list[i] += new_list[i-1]\\n else:\\n pass #don't do anything with the first element of the list.\\n return new_list\",\n \"def get_cumulative(self, search_items, csv=False, output_dir=None, extra_param=None):\\n\\n # Get data from api and create objects\\n api_datas = self.call_api(search_items, \\\"probability\\\", \\\"cumulative\\\", \\\"property\\\", extra_param=extra_param)\\n product = [ProbabilityCumulative(api_data) for api_data in api_datas]\\n\\n if csv:\\n csv_format.to_csv(product, \\\"probability\\\", \\\"cumulative\\\", output_dir=output_dir)\\n\\n logging.info(\\\"Probability Cumulative Data Ready.\\\")\\n\\n return product\",\n \"def to_cumret(self, div_by_first: bool = True, logret: bool = False):\\n if not any([True if x == 'Return(Total)' else False for x in self.tsdf.columns.get_level_values(1).values]):\\n self.value_to_ret(logret=logret)\\n self.tsdf = self.tsdf.add(1.0)\\n self.tsdf = self.tsdf.cumprod(axis=0)\\n if div_by_first:\\n self.tsdf = self.tsdf / self.tsdf.iloc[0]\\n self.valuetype = 'Price(Close)'\\n self.tsdf.columns = pd.MultiIndex.from_product([[self.label], [self.valuetype]])\\n return self\",\n \"def __calc_cum_mean_reward(self, token_to_move, next_states):\\r\\n min_val = -1\\r\\n max_val = 99\\r\\n\\r\\n next_state_sum = np.mean(np.sum(next_states[token_to_move][0]))\\r\\n \\r\\n # Get the opponent who is most ahead by finding sum of the state\\r\\n opponents_next_state_sum = np.sum(next_states[token_to_move][1:])\\r\\n opponents_mean = np.mean(np.mean(opponents_next_state_sum))\\r\\n\\r\\n diff_state_sum = next_state_sum - opponents_mean\\r\\n\\r\\n return (diff_state_sum - min_val)/(max_val - min_val)\",\n \"def _diff_cdf_at_time_i(pmf: Tensor, y: Tensor) -> Tensor:\\n n = pmf.shape[0]\\n ones = torch.ones((n, 1), device=pmf.device)\\n r = pmf.cumsum(1).matmul(y.transpose(0, 1))\\n diag_r = r.diag().view(1, -1)\\n r = ones.matmul(diag_r) - r\\n return r.transpose(0, 1)\",\n \"def compute_cumulants(self, force=False):\\n self._cumulant_computer.compute_cumulants(verbose=self.verbose,\\n force=force)\",\n \"def cumulative_sum(array):\\n res = []\\n val = 0\\n for elem in array:\\n val += elem\\n res.append(val)\\n return res\",\n \"def cumsumr(x, axis=0):\\n cums = x.cumsum(axis=axis)\\n return cums - np.maximum.accumulate(cums*(x == 0), axis=axis)\",\n \"def cum_dist_func(self, chi_square_stat):\\n # use 1 degree of freedom given df = (R-1) * (C-1); df == (2-1) * (2-1) == 1\\n p_value = 1.0 - float(stats.chi2.cdf(chi_square_stat, 1))\\n return p_value\",\n \"def reverse_CDF(self):\\n self.series_y = 1. - self.series_y\\n self.quantile_series_y_lower = 1. - self.quantile_series_y_lower\\n self.quantile_series_y_upper = 1. - self.quantile_series_y_upper\",\n \"def cummulativeCompare(values, pos, diff, offset) :\\n\\tnewvalues, newpos = hopMax(diff, offset)\\n\\tvalues, pos = mergeHopMax(values, pos, newvalues, newpos)\\n\\treturn values, pos\",\n \"def cumulative_gamma(self, state: EnvState, params: EnvParams) -> float:\\n return params.gamma**state.step\",\n \"def compute_cdf(ordered_weights):\\n return numpy.cumsum(ordered_weights) - 0.5 * ordered_weights\",\n \"def cumulative_cm(locations, recombination_data):\\n np_locations = np.array(locations, dtype = np.uint32, copy = False)\\n base_ends = recombination_data.bases\\n assert np.all(np_locations <= base_ends[-1])\\n end_index = np.searchsorted(base_ends, np_locations, side = \\\"left\\\")\\n \\n cm_ends = recombination_data.cm\\n cm_distance = cm_ends[end_index]\\n \\n bp_difference = base_ends[end_index] - locations\\n rates = recombination_data.rates\\n cm_difference = bp_difference * rates[end_index - 1]\\n cm_difference[end_index == 0] = 0\\n\\n adjusted_cm_distance = cm_distance - cm_difference\\n assert np.all(0 <= adjusted_cm_distance) , \\\"Expected positive cM distances, got {}\\\".format(adjusted_cm_distance[adjusted_cm_distance < 0])\\n assert np.all(adjusted_cm_distance <= cm_ends[-1])\\n return adjusted_cm_distance\",\n \"def impute_cumulative_array(array):\\n array = np.array(array).copy()\\n array = convert_non_monotonic_to_nan(array)\\n array = log_interpolate(array)\\n return array\",\n \"def daily_rolling_drawdown(cumulative_returns, rolling_max):\\n\\n return (cumulative_returns / rolling_max) - 1\",\n \"def criticalvalue(tail, alpha):\\n cumtail = np.cumsum(tail[::-1])\\n # Valor crítico. Atenção! Não é a mesma convenção do aft-test...\\n # este valor crítico ainda pertence à região crítica!\\n critvalue = next(i for i, p in enumerate(cumtail[::-1]) if p < alpha)\\n return critvalue\",\n \"def impute_cumulative_df(df, src_col, dst_col, groupby_col):\\n if src_col not in df.columns:\\n raise ValueError(f\\\"'{src_col}' not found\\\")\\n\\n if dst_col not in df.columns:\\n df[dst_col] = -1\\n\\n for adm_name in df[groupby_col].unique():\\n sub = df.loc[df[groupby_col] == adm_name].copy()\\n sub[dst_col] = impute_cumulative_array(sub[src_col])\\n\\n # Replace non-monotonic values in original `cum_confirmed_cases` column with nulls\\n raw_cum_col = \\\"cum_confirmed_cases\\\"\\n sub.loc[sub[raw_cum_col].notnull(), raw_cum_col] = convert_non_monotonic_to_nan(\\n np.array(sub.loc[sub[raw_cum_col].notnull(), raw_cum_col])\\n )\\n\\n df.loc[df[groupby_col] == adm_name] = sub\\n\\n return df\",\n \"def value_to_cumulative_prob(value, hp):\\n if isinstance(hp, Fixed):\\n return 0.5\\n if isinstance(hp, Boolean):\\n # Center the value in its probability bucket.\\n if value:\\n return 0.75\\n return 0.25\\n elif isinstance(hp, Choice):\\n ele_prob = 1 / len(hp.values)\\n index = hp.values.index(value)\\n # Center the value in its probability bucket.\\n return (index + 0.5) * ele_prob\\n elif isinstance(hp, (Int, Float)):\\n sampling = hp.sampling or 'linear'\\n if sampling == 'linear':\\n return (value - hp.min_value) / (hp.max_value - hp.min_value)\\n elif sampling == 'log':\\n return (math.log(value / hp.min_value) /\\n math.log(hp.max_value / hp.min_value))\\n elif sampling == 'reverse_log':\\n return (\\n 1. - math.log((hp.max_value + hp.min_value - value) / hp.min_value) /\\n math.log(hp.max_value / hp.min_value))\\n else:\\n raise ValueError('Unrecognized sampling value: {}'.format(sampling))\\n else:\\n raise ValueError('Unrecognized HyperParameter type: {}'.format(hp))\",\n \"def _get_cum_variance(self) -> np.ndarray:\\n return np.cumsum(self.pca.explained_variance_ratio_)\",\n \"def cdf(self, value=None):\\n if value is None:\\n value = self.value\\n return self.rv.cdf(\\n value, *self._pymc_dists_to_value(self.args), **self.kwds\\n )\",\n \"def get_price_0_cumulative_last(self, pair):\\n pair_contract = self.conn.eth.contract(\\n address=Web3.toChecksumAddress(pair), abi=SushiswapClient.PAIR_ABI)\\n return pair_contract.functions.price0CumulativeLast().call()\",\n \"def cumsum(L):\\n for i in range(1, len(L)):\\n L[i] += L[i-1]\\n return L\",\n \"def controlDelta(self, prev_delta, acc_rate):\\n if (acc_rate > .6):\\n return prev_delta * 1.1\\n elif (acc_rate < .4):\\n return prev_delta / 1.1\\n else:\\n return prev_delta\",\n \"def get_cumulative_value(self, header:TimeSeriesHeaderTypes, timespan:timedelta):\\n\\n if header not in self._series_data:\\n return None\\n\\n data_series = self._series_data[header]\\n\\n #All times below are converted to seconds from unix epoch\\n start_date = self._series_data[header][0, 0]\\n\\n start_index = np.argmax(data_series[:,0] > (start_date + timespan.total_seconds()))#Get index of first element after start_time\\n stop_index = np.argmax(data_series[:,0] > start_date + timespan.total_seconds() + timespan.total_seconds())\\n\\n if stop_index == 0:#start_time + timespan > last data date\\n stop_index = len(data_series[0])\\n\\n return np.sum(data_series[start_index:stop_index, 1])\",\n \"def get_percdone(self, current_acq=0):\\n if current_acq == np.nan:\\n # np.nan indicates that progress reporting is in principle\\n # supported, but failed. This will be treated like no progress.\\n percdone = np.nan\\n else:\\n percdone = (self.total_nr_acquired_values + current_acq) / (\\n np.shape(self.get_sweep_points())[0] * self.soft_avg()) * 100\\n try:\\n now = time.time()\\n if percdone != np.nan and percdone != self._last_percdone_value:\\n # progress was made\\n self._last_percdone_value = percdone\\n self._last_percdone_change_time = now\\n log.debug(f'MC: percdone = {self._last_percdone_value} at '\\n f'{self._last_percdone_change_time}')\\n elif self._last_percdone_change_time == 0:\\n # first progress check: initialize _last_percdone_change_time\\n self._last_percdone_change_time = now\\n self._last_percdone_log_time = self._last_percdone_change_time\\n else: # no progress was made\\n no_prog_inter = self.no_progress_interval()\\n no_prog_inter2 = self.no_progress_kill_interval()\\n no_prog_min = (now - self._last_percdone_change_time) / 60\\n log.debug(f'MC: no_prog_min = {no_prog_min}, '\\n f'percdone = {percdone}')\\n msg = f'The current measurement has not made any progress ' \\\\\\n f'for {no_prog_min: .01f} minutes.'\\n if now - self._last_percdone_change_time > no_prog_inter \\\\\\n and now - self._last_percdone_log_time > no_prog_inter:\\n log.warning(msg)\\n self.log_to_slack(msg)\\n self._last_percdone_log_time = now\\n if now - self._last_percdone_change_time > no_prog_inter2:\\n log.debug(f'MC: raising NoProgressError')\\n raise NoProgressError(msg)\\n except NoProgressError:\\n raise\\n except Exception as e:\\n log.debug(f'MC: error while checking progress: {repr(e)}')\\n return percdone\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6869948","0.67523324","0.64255375","0.6341759","0.63019013","0.6291231","0.62111056","0.6121284","0.61202884","0.60518414","0.6049944","0.60443413","0.59521824","0.5944532","0.594417","0.5942714","0.5922843","0.5915984","0.58872694","0.58869976","0.5872482","0.5866635","0.58590853","0.5854164","0.58457065","0.5811522","0.58053577","0.57482207","0.5712693","0.57055557","0.5665141","0.56650275","0.5643591","0.56377167","0.56340325","0.5595871","0.5592033","0.5549193","0.55397725","0.5529288","0.5520458","0.55155593","0.55124503","0.55000055","0.5491555","0.5469163","0.54505116","0.5446451","0.5427348","0.54132915","0.54132915","0.54132915","0.5412161","0.54065585","0.5404756","0.5393836","0.5390323","0.5390246","0.53828627","0.537371","0.537371","0.537371","0.5350099","0.5338303","0.5337798","0.5326048","0.53101426","0.53047144","0.5289364","0.52883685","0.5286726","0.5282776","0.527209","0.5271674","0.52606064","0.5250006","0.52483493","0.524777","0.5246461","0.52440727","0.5195446","0.5195251","0.51918715","0.5179096","0.5177464","0.5167736","0.51659024","0.5165122","0.51642525","0.5162558","0.51587385","0.5156577","0.5147527","0.51464087","0.5144609","0.5128608","0.5119063","0.5112591","0.5108265","0.5103322"],"string":"[\n \"0.6869948\",\n \"0.67523324\",\n \"0.64255375\",\n \"0.6341759\",\n \"0.63019013\",\n \"0.6291231\",\n \"0.62111056\",\n \"0.6121284\",\n \"0.61202884\",\n \"0.60518414\",\n \"0.6049944\",\n \"0.60443413\",\n \"0.59521824\",\n \"0.5944532\",\n \"0.594417\",\n \"0.5942714\",\n \"0.5922843\",\n \"0.5915984\",\n \"0.58872694\",\n \"0.58869976\",\n \"0.5872482\",\n \"0.5866635\",\n \"0.58590853\",\n \"0.5854164\",\n \"0.58457065\",\n \"0.5811522\",\n \"0.58053577\",\n \"0.57482207\",\n \"0.5712693\",\n \"0.57055557\",\n \"0.5665141\",\n \"0.56650275\",\n \"0.5643591\",\n \"0.56377167\",\n \"0.56340325\",\n \"0.5595871\",\n \"0.5592033\",\n \"0.5549193\",\n \"0.55397725\",\n \"0.5529288\",\n \"0.5520458\",\n \"0.55155593\",\n \"0.55124503\",\n \"0.55000055\",\n \"0.5491555\",\n \"0.5469163\",\n \"0.54505116\",\n \"0.5446451\",\n \"0.5427348\",\n \"0.54132915\",\n \"0.54132915\",\n \"0.54132915\",\n \"0.5412161\",\n \"0.54065585\",\n \"0.5404756\",\n \"0.5393836\",\n \"0.5390323\",\n \"0.5390246\",\n \"0.53828627\",\n \"0.537371\",\n \"0.537371\",\n \"0.537371\",\n \"0.5350099\",\n \"0.5338303\",\n \"0.5337798\",\n \"0.5326048\",\n \"0.53101426\",\n \"0.53047144\",\n \"0.5289364\",\n \"0.52883685\",\n \"0.5286726\",\n \"0.5282776\",\n \"0.527209\",\n \"0.5271674\",\n \"0.52606064\",\n \"0.5250006\",\n \"0.52483493\",\n \"0.524777\",\n \"0.5246461\",\n \"0.52440727\",\n \"0.5195446\",\n \"0.5195251\",\n \"0.51918715\",\n \"0.5179096\",\n \"0.5177464\",\n \"0.5167736\",\n \"0.51659024\",\n \"0.5165122\",\n \"0.51642525\",\n \"0.5162558\",\n \"0.51587385\",\n \"0.5156577\",\n \"0.5147527\",\n \"0.51464087\",\n \"0.5144609\",\n \"0.5128608\",\n \"0.5119063\",\n \"0.5112591\",\n \"0.5108265\",\n \"0.5103322\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5677045"},"document_rank":{"kind":"string","value":"30"}}},{"rowIdx":595,"cells":{"query":{"kind":"string","value":"Initializes the base class."},"document":{"kind":"string","value":"def __init__(self, pid, monitor_id, logger, file_pattern):\n self._pid = pid\n self._id = monitor_id\n self._file_pattern = file_pattern\n # The file object to be read. We always keep this open and just seek to zero when we need to\n # re-read it. Some of the /proc files do better with this approach.\n self._file = None\n # The time we last collected the metrics.\n self._timestamp = None\n # True if the reader failed for some unrecoverable error.\n self._failed = False\n self._logger = logger\n self._metric_printer = MetricPrinter(logger, monitor_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 initialize(cls):","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def initialize(self):\n\t\tpass","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def _init(self):\n pass","def initialize(self) -> None:\n pass","def init(self) -> None:\n ...","def _init(self):\n raise NotImplementedError","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def initialize(self): \r\n pass","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def __init__(self):\n superClass.__init__(self)\n # TODO Your initialization stuff here","def initialize(self):\n pass # pragma: no cover","def __init__(self, base, **kwargs):\n self.base = base","def init(self) -> None:","def __init__ (self):\n pass","def initialize(self, *args, **kwargs):\n pass","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self, **kwargs):","def __init__(self):\n\t\tsuper().__init__()","def __init__(self):\n\t\tsuper().__init__()","def _init(self):","def initialize(self):\n return","def init(self):","def init(self):","def initialize(self, **kwargs):\n raise NotImplementedError()","def initialize(self, **kwargs: Any) -> None:\n pass","def __init__(self):\n super()","def __init__(self) -> None:\n super().__init__()","def __init__(self) -> None:\n super().__init__()","def __init__():","def initialize(self):\n pass","def initialise(self):","def initialize(self, *args, **kwargs):","def _real_initialize(self):\n pass","def do_init(self):\n\n pass","def __init__(self, *, base=None):\n self._base = base\n\n self._map = {}","def init(self, *args, **kwds):\n pass","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n print(\"Initializing\")","def __init__(self):\n print(\"Initializing\")","def __init__(self):\n super().__init__()\n pass","def __init__(self):\n raise NoInitiation","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def initialize(self):\n\n # --------- BEGIN YOUR CODE ----------\n\n # This is exactly the same as Human.initialize, just copy the code over\n\n # --------- END YOUR CODE ----------\n pass","def __init__(self):\n self._initialized = False\n self.init()","def __init__(self):\n self._initialized = False\n self.init()","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(self):\r\n\t\tpass","def __init__(self, base):\r\n\r\n self.base = base","def _initialize(self, **kwargs):\n return None","def __init__(self):\r\n super().__init__()","def __init__(self, **kwds):\n raise NotImplementedError"],"string":"[\n \"def initialize(cls):\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _init(self):\\n pass\",\n \"def initialize(self) -> None:\\n pass\",\n \"def init(self) -> None:\\n ...\",\n \"def _init(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def initialize(self): \\r\\n pass\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n superClass.__init__(self)\\n # TODO Your initialization stuff here\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def __init__(self, base, **kwargs):\\n self.base = base\",\n \"def init(self) -> None:\",\n \"def __init__ (self):\\n pass\",\n \"def initialize(self, *args, **kwargs):\\n pass\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self, **kwargs):\",\n \"def __init__(self):\\n\\t\\tsuper().__init__()\",\n \"def __init__(self):\\n\\t\\tsuper().__init__()\",\n \"def _init(self):\",\n \"def initialize(self):\\n return\",\n \"def init(self):\",\n \"def init(self):\",\n \"def initialize(self, **kwargs):\\n raise NotImplementedError()\",\n \"def initialize(self, **kwargs: Any) -> None:\\n pass\",\n \"def __init__(self):\\n super()\",\n \"def __init__(self) -> None:\\n super().__init__()\",\n \"def __init__(self) -> None:\\n super().__init__()\",\n \"def __init__():\",\n \"def initialize(self):\\n pass\",\n \"def initialise(self):\",\n \"def initialize(self, *args, **kwargs):\",\n \"def _real_initialize(self):\\n pass\",\n \"def do_init(self):\\n\\n pass\",\n \"def __init__(self, *, base=None):\\n self._base = base\\n\\n self._map = {}\",\n \"def init(self, *args, **kwds):\\n pass\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n print(\\\"Initializing\\\")\",\n \"def __init__(self):\\n print(\\\"Initializing\\\")\",\n \"def __init__(self):\\n super().__init__()\\n pass\",\n \"def __init__(self):\\n raise NoInitiation\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def initialize(self):\\n\\n # --------- BEGIN YOUR CODE ----------\\n\\n # This is exactly the same as Human.initialize, just copy the code over\\n\\n # --------- END YOUR CODE ----------\\n pass\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(self):\\r\\n\\t\\tpass\",\n \"def __init__(self, base):\\r\\n\\r\\n self.base = base\",\n \"def _initialize(self, **kwargs):\\n return None\",\n \"def __init__(self):\\r\\n super().__init__()\",\n \"def __init__(self, **kwds):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8141555","0.78926814","0.78926814","0.7889723","0.78779274","0.78779274","0.78618664","0.78618664","0.78618664","0.78496444","0.7829186","0.78273886","0.78159505","0.7813773","0.7813773","0.7813773","0.7813773","0.7813773","0.7808769","0.7808769","0.7808769","0.7808769","0.7808769","0.7808769","0.7808769","0.7808769","0.77624005","0.775657","0.775657","0.775657","0.7689748","0.7686944","0.7686428","0.7676449","0.7632513","0.75291556","0.74872667","0.7477308","0.7477308","0.7477308","0.7477308","0.74570495","0.7413796","0.7413796","0.74035144","0.73987603","0.73931956","0.73931956","0.7378744","0.735866","0.73370427","0.73124045","0.73124045","0.728544","0.72721875","0.72709405","0.7269531","0.72679335","0.7242781","0.72341484","0.72292006","0.7228974","0.7228974","0.7228974","0.7228974","0.71966517","0.71966517","0.7195791","0.7179966","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71784896","0.71773344","0.71631265","0.71631265","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7148675","0.7141238","0.71382123","0.71337515","0.7130035","0.7129101"],"string":"[\n \"0.8141555\",\n \"0.78926814\",\n \"0.78926814\",\n \"0.7889723\",\n \"0.78779274\",\n \"0.78779274\",\n \"0.78618664\",\n \"0.78618664\",\n \"0.78618664\",\n \"0.78496444\",\n \"0.7829186\",\n \"0.78273886\",\n \"0.78159505\",\n \"0.7813773\",\n \"0.7813773\",\n \"0.7813773\",\n \"0.7813773\",\n \"0.7813773\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.7808769\",\n \"0.77624005\",\n \"0.775657\",\n \"0.775657\",\n \"0.775657\",\n \"0.7689748\",\n \"0.7686944\",\n \"0.7686428\",\n \"0.7676449\",\n \"0.7632513\",\n \"0.75291556\",\n \"0.74872667\",\n \"0.7477308\",\n \"0.7477308\",\n \"0.7477308\",\n \"0.7477308\",\n \"0.74570495\",\n \"0.7413796\",\n \"0.7413796\",\n \"0.74035144\",\n \"0.73987603\",\n \"0.73931956\",\n \"0.73931956\",\n \"0.7378744\",\n \"0.735866\",\n \"0.73370427\",\n \"0.73124045\",\n \"0.73124045\",\n \"0.728544\",\n \"0.72721875\",\n \"0.72709405\",\n \"0.7269531\",\n \"0.72679335\",\n \"0.7242781\",\n \"0.72341484\",\n \"0.72292006\",\n \"0.7228974\",\n \"0.7228974\",\n \"0.7228974\",\n \"0.7228974\",\n \"0.71966517\",\n \"0.71966517\",\n \"0.7195791\",\n \"0.7179966\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71784896\",\n \"0.71773344\",\n \"0.71631265\",\n \"0.71631265\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7148675\",\n \"0.7141238\",\n \"0.71382123\",\n \"0.71337515\",\n \"0.7130035\",\n \"0.7129101\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":596,"cells":{"query":{"kind":"string","value":"Runs a single cycle of the sample collection. It should read the monitored file and extract all metrics."},"document":{"kind":"string","value":"def run_single_cycle(self, collector=None):\n\n self._timestamp = int(time.time())\n\n # There are certain error conditions, such as the system not supporting\n # a particular proc file type, that we will never recover from. So,\n # just always early exit.\n if self._failed:\n return {}\n\n filename = self._file_pattern % self._pid\n\n if not collector:\n collector = {}\n if self._file is None:\n try:\n self._file = open(filename, \"r\")\n except IOError as e:\n # We take a simple approach. If we don't find the file or\n # don't have permissions for it, then just don't collect this\n # stat from now on. If the user changes the configuration file\n # we will try again to read the file then.\n self._failed = True\n if e.errno == errno.EACCES:\n self._logger.error(\n \"The agent does not have permission to read %s. \"\n \"Maybe you should run it as root.\",\n filename,\n )\n elif e.errno == errno.ENOENT:\n self._logger.error(\n (\n \"The agent cannot read %s. Your system may not support that proc file \"\n 'type or the process with pid \"%s\" doesn\\'t exist'\n ),\n filename,\n self._pid,\n )\n # Ignore 'process not found' errors (likely caused because the process exited\n # but re-raise the exception for all other errors\n elif e.errno != errno.ESRCH:\n raise e\n\n if self._file is not None:\n try:\n self._file.seek(0)\n\n return self.gather_sample(self._file, collector=collector)\n\n except IOError as e:\n # log the error if the errno isn't 'process not found'. Process not found likely means the\n # process exited, so we ignore that because it's within the realm of expected behaviour\n if e.errno != errno.ESRCH:\n self._logger.error(\n \"Error gathering sample for file: '%s'\\n\\t%s\"\n % (filename, six.text_type(e))\n )\n\n # close the file. This will cause the file to be reopened next call to run_single_cycle\n self.close()\n return collector"},"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(self):\r\n self.collect_data()","def gather_sample(self, my_file, collector=None):\n\n pass","def collect_samples(self):\n self.__running = True\n with open(self.__filename, 'a') as output:\n next_sample_time = time.time()\n while self.__running:\n sensor_name = self.__sensor.get_sensor_type_name()\n sensor_id = self.__sensor.get_sensor_id()\n data = self.__sensor.retrieve_data_string() \n if DEBUG:\n print('data: \"{}\"'.format(data),\n file = sys.stderr, flush=True)\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\n result = OUTPUT_FORMAT.format(when,\n sensor_name, \n sensor_id, \n data)\n output.write(result)\n output.flush()\n \n next_sample_time = next_sample_time + self.__interval\n delay_time = next_sample_time - time.time()\n if DEBUG:\n print('delay_time = {}'.format(delay_time),\n file=sys.stderr, flush=True)\n \n if 0 < delay_time: # don't sleep if already next sample time\n time.sleep(delay_time)","def run(self):\n self.logger.info(f'Running {self.__class__.__name__}')\n while True:\n last_check = time.time()\n self.collect_new_events()\n while time.time() - last_check < self._check_for_new_events_interval:\n self.logger.debug('Waiting for new events collection: new collection in {}s'.format(\n self._check_for_new_events_interval - (time.time() - last_check)))\n time.sleep(1)","def start_monitor_loop(self):\n read_file = read_config_file.ConfigFileReader()\n\n communication_time = read_file.get_send_communication_time()\n metrics_array = read_file.get_metrics()\n\n self.add_metrics_to_monitor_object(communication_time, metrics_array)","def run_resample(self):\n\n self.in_data.open()\n self.out_data.open()\n\n try:\n # Get the fields from the input file and set them/write headers in output:\n self.all_fields = self.in_data.fields\n\n self.out_data.set_fields(self.all_fields)\n self.out_data.write_headers()\n\n # Set up the sensor fields by removing non-sensor fields:\n self.set_sensor_only_fields()\n\n # Read the first event from the input file:\n self.get_next_input_event()\n\n # Warn and exit if we have no input data to read:\n if self.next_input_event is None:\n msg = f\"The input file {self.in_file} did not have any data rows\"\n warn(msg)\n\n return\n\n self.first_event_stamp = self.next_input_event[self.stamp_field]\n\n # Set up the sample tracking (here mostly to set the start of the first interval):\n self.reset_sample_tracking()\n\n # Now iterate through the output intervals:\n while True:\n self.process_next_interval()\n except EOFError: # catch when we are at the end of the file\n pass\n finally:\n self.in_data.close()\n self.out_data.close()\n\n print() # make sure we go to a new output line","def run(self, repetitions, **kwargs):\n\t\tself.sampler.sample(repetitions, **kwargs)","def start(self):\n while True:\n LogService.log_info(\"aggregator\", \"Creating statistics\")\n self.create_statistics()\n LogService.log_info(\"aggregator\", \"Cleaning up\")\n self.cleanup_measurements()\n LogService.log_info(\"aggregator\", \"Sleeping for 60 minutes\")\n time.sleep(60*60)","def gather_sample(self):\n\n for _pid in self._select_processes():\n if not self.__trackers.get(_pid):\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\n\n self._reset_absolute_metrics()\n\n for _tracker in self.__trackers.values():\n _metrics = _tracker.collect()\n self.record_metrics(_tracker.pid, _metrics)\n\n self._calculate_aggregated_metrics()\n self._remove_dead_processes()\n\n self.print_metrics()","def run(self):\n operation_manager = self._core.get_operation_manager()\n while True:\n while operation_manager.process_next():\n pass\n sleep(2)","def run(self):\n while True:\n try:\n sleep(influx_settings.write_freq)\n self._redis2influx()\n except InterruptExceptions as ex:\n raise ex","def run_sample(smp: sample.Sample,\n run_dir: Text,\n summary_file: Optional[Text] = None,\n generate_sample_ns: Optional[int] = None):\n start = time.time()\n # Create a script named 'run.sh' for rerunning the sample.\n args = [\n SAMPLE_RUNNER_MAIN_PATH,\n '--logtostderr',\n '--input_file=sample.x',\n '--options_file=options.pbtxt',\n ]\n\n _write_to_file(run_dir, 'sample.x', smp.input_text)\n _write_to_file(run_dir, 'options.pbtxt', smp.options.to_pbtxt())\n args_filename = 'args.txt'\n _write_to_file(\n run_dir, args_filename, sample.args_batch_to_text(smp.args_batch)\n )\n args.append('--args_file=args.txt')\n ir_channel_names_filename = None\n if smp.ir_channel_names is not None:\n ir_channel_names_filename = 'ir_channel_names.txt'\n _write_to_file(run_dir, ir_channel_names_filename,\n sample.ir_channel_names_to_text(smp.ir_channel_names))\n args.append('--ir_channel_names_file=ir_channel_names.txt')\n args.append(run_dir)\n _write_to_file(\n run_dir,\n 'run.sh',\n f'#!/bin/sh\\n\\n{subprocess.list2cmdline(args)}\\n',\n executable=True)\n logging.vlog(1, 'Starting to run sample')\n logging.vlog(2, smp.input_text)\n runner = sample_runner.SampleRunner(run_dir)\n runner.run_from_files(\n 'sample.x', 'options.pbtxt', args_filename, ir_channel_names_filename\n )\n timing = runner.timing\n\n timing.total_ns = int((time.time() - start) * 1e9)\n if generate_sample_ns:\n # The sample generation time, if given, is not part of the measured total\n # time, so add it in.\n timing.total_ns += generate_sample_ns\n timing.generate_sample_ns = generate_sample_ns\n\n logging.vlog(1, 'Completed running sample, elapsed: %0.2fs',\n time.time() - start)\n\n if summary_file:\n _write_ir_summaries(run_dir, timing, summary_file)","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n for key in value_dict.keys():\n value_dict[key] *= self.coverage\n value_dict['coverage'] = self.coverage\n logging.info(\"coverage:{0}\".format(self.coverage))\n for key, value in value_dict.items():\n logging.info(\"{0}:{1}\".format(key,value))\n self.add_records(self.main_loop.log, value_dict.items())\n self.check_stop(value_dict)\n logger.info(\"Monitoring on auxiliary data finished\")","def run_sample(smp: sample.Sample,\n run_dir: Text,\n summary_file: Optional[Text] = None,\n generate_sample_ns: Optional[int] = None):\n start = time.time()\n\n _write_to_file(run_dir, 'sample.x', smp.input_text)\n _write_to_file(run_dir, 'options.json', smp.options.to_json())\n if smp.args_batch:\n _write_to_file(run_dir, 'args.txt',\n sample.args_batch_to_text(smp.args_batch))\n\n # Create a script named 'run.sh' for rerunning the sample.\n args = [\n SAMPLE_RUNNER_MAIN_PATH, '--logtostderr', '--input_file=sample.x',\n '--options_file=options.json'\n ]\n if smp.args_batch:\n args.append('--args_file=args.txt')\n args.append(run_dir)\n _write_to_file(\n run_dir,\n 'run.sh',\n f'#!/bin/sh\\n\\n{subprocess.list2cmdline(args)}\\n',\n executable=True)\n logging.vlog(1, 'Starting to run sample')\n logging.vlog(2, smp.input_text)\n runner = sample_runner.SampleRunner(run_dir)\n runner.run_from_files('sample.x', 'options.json', 'args.txt')\n timing = runner.timing\n\n timing.total_ns = int((time.time() - start) * 1e9)\n if generate_sample_ns:\n # The sample generation time, if given, is not part of the measured total\n # time, so add it in.\n timing.total_ns += generate_sample_ns\n timing.generate_sample_ns = generate_sample_ns\n\n logging.vlog(1, 'Completed running sample, elapsed: %0.2fs',\n time.time() - start)\n\n if summary_file:\n _write_ir_summaries(run_dir, timing, summary_file)","def run(self):\n\n # How to retrieve your input data.\n input_1_data = self.in_data['input_1']\n\n # How to retrieve your params value.\n param_1 = self.param['param_1']\n\n # How to process data.\n # Just write any number of methods you want and use them here.\n sample_out_data = self.sample_method(input_1_data, param_1)\n\n # Go to the definition of this method to see how to log.\n self.demo_log()\n\n # This is how to set output data.\n self.out_data['output_1'] = sample_out_data","def run(self):\n\n step = self.steps['diagnostics_files']\n step.cores = self.config.getint('make_diagnostics_files', 'cores')\n\n # run the step\n super().run()","def run():\n logger.info(f\"Process started:\")\n logger.info(f\"Converting Glove file to Word2Vec format\")\n convert_to_word2vec.convert(\n \"./data/source/glove.6B.50d.txt\", \"./data/source/glove.6B.50d.w2vformat.txt\"\n )\n\n logger.info(f\"Extracting Click Stream data\")\n extract_click_stream_data()\n\n logger.info(\"Extracting Wiki articles\")\n extract_wiki_articles()\n\n logger.info(f\"Generating Clickstream dataset\")\n generate_datasets()\n\n logger.info(\"Tokenizing articles\")\n WikiArticlesTokenizer().process()\n\n logger.info(\"Creating dataset with Wiki Articles\")\n create_wiki_articles_dataset()","def test_continuous_bulk_parsing(self, aggregator):\n test_data = ensure_bytes(open(NAGIOS_TEST_LOG).read())\n ITERATIONS = 10\n log_file = tempfile.NamedTemporaryFile(mode=\"a+b\")\n\n # Get the config\n config, nagios_cfg = get_config(\"log_file={}\\n\".format(log_file.name), events=True)\n\n # Set up the check\n nagios = NagiosCheck(CHECK_NAME, {}, config['instances'])\n\n for _ in range(ITERATIONS):\n log_file.write(test_data)\n log_file.flush()\n nagios.check(config['instances'][0])\n\n log_file.close()\n assert len(aggregator.events) == ITERATIONS * 503","def run(self):\n print(\"%s starting up\" % self.getName())\n for count in range(self.accessCount):\n time.sleep(random.randint(1, self.sleepMax))\n value = self.cell.read(lambda counter: self.cell.data.count)\n print(\"%s is done getting %s\" % (self.getName(), str(value)))","def run(self):\n\n while self.source.SAMPLING:\n wx.CallAfter(self.target, self)\n sleep(0.75)\n\n self.Terminate()","def gather_sample(self, stat_file, collector=None):\n if not collector:\n collector = {}\n # The file format is just a single line of all the fields.\n line = stat_file.readlines()[0]\n # Chop off first part which is the pid and executable file. The\n # executable file is terminated with a paren so just search for that.\n line = line[(line.find(\") \") + 2) :]\n fields = line.split()\n # Then the fields we want are just at fixed field positions in the\n # string. Just grab them.\n\n # See http://man7.org/linux/man-pages/man5/proc.5.html for reference on field numbers\n # Keep in mind that we chop first 3 values away (pid, command line, state), so you need to\n # subtract 3 from the field numbers from the man page (e.g. on the man page nice is number\n # 19, but in our case it's 16 aka 19 - 3)\n process_uptime = self.__get_uptime_ms() - self.calculate_time_ms(\n int(fields[19])\n )\n\n collector.update(\n {\n Metric(\"app.cpu\", \"user\"): self.__calculate_time_cs(int(fields[11])),\n Metric(\"app.cpu\", \"system\"): self.__calculate_time_cs(int(fields[12])),\n Metric(\"app.uptime\", None): process_uptime,\n Metric(\"app.nice\", None): float(fields[16]),\n Metric(\"app.threads\", None): int(fields[17]),\n Metric(\"app.mem.majflt\", None): int(fields[9]),\n Metric(\"app.io.wait\", None): int(fields[39])\n if len(fields) >= 39\n else 0,\n }\n )\n return collector","def run(self):\n\t\tself.data_source.connect()\n\t\twhile self.running:\n\t\t\tself.data_source.read()","def start_collector(self, callback=None):\n self.log.info(\"starting-pm-collection\", device_name=self.name)\n if callback is None:\n callback = self.perform_test_omci\n\n if self.lc is None:\n self.lc = LoopingCall(callback)\n\n if self.default_freq > 0:\n self.lc.start(interval=self.default_freq / 10)","def _proc_collect(self) -> None:\n while True:\n self.process_num_threads.set(self._process.num_threads())\n self.process_memory_bytes.set(self._process.memory_info().rss)\n self.process_cpu_percent.set(self._process.cpu_percent())\n\n sleep(self.process_scrape_interval)","def run(self):\n self.speed_test.start()","def loop(self):\n pass","def run(self):\n print(\"%s starting up\" % self.getName())\n for count in range(self.accessCount):\n time.sleep(random.randint(1, self.sleepMax))\n value = self.cell.write(lambda counter: counter.increment())\n print(\"%s is done incrementing to %s\" % (self.getName(), str(value)))","def _run(self):\n while(self._loop):\n pass","def run(self):\n self._setupLogger()\n self.setup()\n\n self.logger.info(self.moduleName + \" starting run loop.\")\n\n while True:\n self.loop()","def load_sample(self):\n\n self.load_images(self.folder + \"/sampleSet.txt\")\n self.load_traces(self.folder + \"/sampleLabel.txt\")","def run(self):\n while True:\n try:\n self.check_value()\n except Exception as e:\n print(f\"[ERROR]: Error running the continuous run loop on sample_module: {e}\")\n continue","def _run_cycle(self):\n pass","def run(self):\n logger.info(\"Running...\")\n self._child = Process(target=self.collect, args=())\n self._child.start()","def test_continuous_bulk_parsing(self, aggregator):\n test_data = open(NAGIOS_TEST_LOG).read()\n events = []\n ITERATIONS = 10\n log_file = tempfile.NamedTemporaryFile(mode=\"a+b\")\n log_file.write(test_data.encode('utf-8'))\n log_file.flush()\n\n # Get the config\n config, nagios_cfg = get_config('\\n'.join([\"log_file={0}\".format(log_file.name)]), events=True)\n\n # Set up the check\n nagios = NagiosCheck(CHECK_NAME, {}, {}, instances=config['instances'])\n nagios.get_topology = mocked_topology\n\n for i in range(ITERATIONS):\n log_file.write(test_data.encode('utf-8'))\n log_file.flush()\n nagios.check(config['instances'][0])\n events.extend(events)\n\n log_file.close()\n assert len(aggregator.events) == ITERATIONS * 505","def test_runner_full_loop(caplog, dataset):\n caplog.set_level(logging.DEBUG)\n\n session = dataset\n\n start_date = datetime.datetime(2020, 5, 17, 13, 0, 0)\n end_date = datetime.datetime(2020, 5, 17, 13, 0, 5)\n replay_rate = 1 \n \n db_connector_test = DataBaseConnector(session=session, \n table_name='timeseries_dataset', \n time_column='timestamp', \n start_date=start_date,\n end_date=end_date)\n\n test_publisher = ConsolePublisher()\n\n runner = CentralRunner(db_connection=db_connector_test, \n output_system=test_publisher, \n start_time=start_date, \n end_time=end_date,\n replay_rate=replay_rate )\n\n start = time.perf_counter()\n \n runner.run()\n\n end = time.perf_counter()\n\n code_time = end - start\n \n print(code_time)\n \n assert int(code_time) == 4","async def test_all_samples(self):\n response = await self.collect(get_request_json_return_value=self.JMETER_JSON)\n self.assert_measurement(response, value=\"248\", entities=[])","def run_inner(self):\n for event in self.inotify.event_gen():\n self.process_inotify_event(event)","def run(self,mc_sample=None):\n if mc_sample:\n self.mc_sample = mc_sample\n\n total_scores = 0.0\n total_scores_square = 0.0\n self.scores_list =[]\n \n for i in range(self.num_runs): #runs the specified number of Monte Carlo samples\n score = next(self.mc_sample) #next score\n self.scores_list.append(score) \n total_scores += score\n total_scores_square += score**2\n\n self.xhat = total_scores / self.num_runs #mean of score\n self.x2hat = total_scores_square / self.num_runs #mean of score^2\n\n self.sample_variance = (self.num_runs / (self.num_runs - 1.0)) * (self.x2hat - (self.xhat**2))\n self.sample_stddev = np.sqrt(self.sample_variance)\n self.mean_variance = self.sample_variance / (self.num_runs - 1.0)\n self.mean_stddev = np.sqrt(self.mean_variance)","def test_runner_full_loop_big(caplog, big_dataset):\n caplog.set_level(logging.INFO)\n\n session = big_dataset\n\n start_date = datetime.datetime(2020, 5, 17, 13, 0, 3)\n end_date = datetime.datetime(2020, 5, 17, 13, 0, 6)\n replay_rate = 1 \n\n db_connector_test = DataBaseConnector(session=session, \n table_name='timeseries_dataset', \n time_column='timestamp', \n start_date=start_date,\n end_date=end_date)\n\n debug_publisher = FilePublisher()\n\n runner = CentralRunner(db_connection=db_connector_test, \n output_system=debug_publisher, \n start_time=start_date, \n end_time=end_date,\n replay_rate=replay_rate )\n\n start = time.perf_counter()\n \n runner.run()\n\n end = time.perf_counter()\n\n code_time = end - start\n assert int(code_time) == 2\n\n ## Test results\n assert os.path.exists('test_tmp/17-05-2020_13-00-03')\n assert os.path.exists('test_tmp/17-05-2020_13-00-05')\n\n assert len(os.listdir('test_tmp/17-05-2020_13-00-03')) == 9\n assert len(os.listdir('test_tmp/17-05-2020_13-00-05')) == 2","def run_main():\n # Matching lines against a matcher function.\n matched_lines = match_file(file_names, matcher)\n\n # Will contain data sorted by file.\n binned_data = {}\n\n # Looking through the lines that were inserted into the metrics file via the metrics component.\n for key in matched_lines:\n\n # Grabbing matched lines by the file or orgination.\n buffer = matched_lines[key]\n\n # This will contain dictionaries converted from JSON.\n data = []\n\n # Loop through the collection, appending data converted from JSON entries.\n for line in buffer:\n data.append(extract_data(line))\n\n # Sort the data by file.\n binned_data[key] = sort_data(data)\n\n # Output the final results.\n generate_statistics(binned_data)\n return 0","def run_sample(self):\n # there will be validation failures for sample data\n self.validate_req(ignore_failure=True)\n runner_fn = self.model_runner.execute_model_for_sample_data\n return self.do_handle_request(runner_fn)","def run(self):\n while True:\n # Do something\n print('Doing something imporant in the background')\n\n self.loadData()\n time.sleep(self.interval)","def run(self):\n\n self.create_trials() # create them *before* running!\n self.start_experiment()\n\n for trail in self.trials:\n trial.run()\n\n self.close()","def run(self):\n t = Ticker(self.freq)\n while True: \n t.tick()\n #Name, used to identify the observation in memory:\n Operators = self.Operators\n if Operators:\n self.add_property('name', 'HumanDetector')\n self.add_property('Operators', Operators)\n self.store_observation()\n\n self.update()","def sample(self):\n logger.info(\"%s: collect sensor data\", self.__class__.__name__)\n samples = []\n self._fetch_data(samples)\n return samples","def test_scan_file(self):\n self.run_scan(self.filename, 1)","def run(self):\n\n self.load_file()\n self.cat_to_num()\n self.split()","def run(self):\n self.monitor.start()","def run(self):\n logging.info(\"Running...\\n\")\n self._child = Process(target=self.collect, args=())\n self._child.start()","def run(self):\n logging.info(\"Running...\\n\")\n self._child = Process(target=self.collect, args=())\n self._child.start()","def run(self):\n self.evaluate()\n self.accumulate()\n self.summarize()","def run_one_test_cycle(self):\n logging.info(\n \"{0} operations remaining: {1}\".format(\n self.args.pm_operation, self.args.repetitions\n )\n )\n\n self.check_last_cycle_duration()\n if self.args.repetitions > 0:\n self.run_pm_command()\n else:\n self.summary()","def run(self):\n LOG.debug(\"ReaderThread up and running\")\n\n lastevictTime = 0\n while ALIVE:\n for col in allLivingCollectors():\n for line in col.collect():\n self.processLine(col, line)\n now = int(time.time())\n if now - lastevictTime > self.evictinterval:\n lastevictTime = now\n now -= self.evictinterval\n for col in allCollectors():\n col.evictOldkeys(now)\n # BUGBUG : not good\n time.sleep(1)","def run(self):\n\n self.preprocess()\n self.restore_ratings()\n self.prepare_UI()\n self.loop_through_units()\n self.cleanup()\n\n print('\\nAll Done - results are available in:\\n\\t{}'.format(self.out_dir))","def do_cycle(self):\n c.check_running()\n online_models = self.get_online_models()\n if len(online_models) > 0:\n self.process_models(online_models)\n self.print_recording()","def step(self):\r\n self.datacollector.collect(self)\r\n self.datacollector2.collect(self)\r\n self.datacollector3.collect(self)\r\n self.datacollector4.collect(self)\r\n self.datacollector5.collect(self)\r\n self.datacollector6.collect(self)\r\n self.datacollector7.collect(self)\r\n self.datacollector8.collect(self)\r\n self.datacollector9.collect(self)\r\n self.datacollector10.collect(self)\r\n self.datacollector11.collect(self)\r\n self.datacollector12.collect(self)\r\n self.datacollector13.collect(self)\r\n\r\n self.datacollector14.collect(self)\r\n self.datacollector15.collect(self)\r\n self.datacollector16.collect(self)\r\n self.datacollector17.collect(self)\r\n self.datacollector18.collect(self)\r\n self.datacollector19.collect(self)\r\n self.datacollector20.collect(self)\r\n self.datacollector21.collect(self)\r\n self.datacollector22.collect(self)\r\n self.datacollector23.collect(self)\r\n self.datacollector24.collect(self)\r\n self.datacollector25.collect(self)\r\n self.datacollector26.collect(self)\r\n self.schedule.step()","def _counter(self):\n while True:\n # ensure counter interval is up to date\n self._read_interval_time()\n\n log.debug(\"SFlowManager._counter: sleeping for %s\", self._counter_interval)\n\n time.sleep(self._counter_interval)\n\n # get a cpu times sample\n res = resource.getrusage(resource.RUSAGE_SELF)\n\n # build and send counter structure\n csample = { 'counter_sample': {\n 'app_name': get_sys_name(),\n 'app_resources': {\n 'user_time': int(res.ru_utime * 1000),\n 'system_time': int(res.ru_stime * 1000),\n 'mem_used': 0, # @TODO\n 'mem_max': res.ru_maxrss * 1024,\n 'fd_open': 0, # @TODO do we care?\n 'fd_max': 0, # @TODO \"\"\n 'conn_open': 0, # @TODO couch/rabbit connection summary somehow\n 'conn_max': 0\n },\n 'app_workers':{\n 'workers_active': len(self._container.proc_manager.proc_sup.children),\n 'workers_idle': 0,\n 'workers_max': 1024,\n 'req_delayed': 0,\n 'req_dropped': 0\n }\n }\n }\n\n log.debug(\"Publishing counter stats: %s\" % csample)\n\n self._publish(csample)","def test_run(self):\n engine = Engine(self.config_file, self.api_token, 23)\n engine.msg_wait_iterations = 0\n\n # Put some stuff on the task queue\n self.setup_helper.add_volumetric_tasks(self.aws_creds[\"access_key\"],\n self.aws_creds['secret_key'],\n self.upload_queue_url, engine.backend)\n\n engine.join()\n engine.run()\n\n # Check for tile to exist\n s3 = boto3.resource('s3')\n ingest_bucket = s3.Bucket(self.ingest_bucket_name)\n\n with tempfile.NamedTemporaryFile() as test_file:\n with open(test_file.name, 'wb') as raw_data:\n ingest_bucket.download_fileobj(VOLUMETRIC_CUBOID_KEY, raw_data)\n with open(test_file.name, 'rb') as raw_data:\n # Using an empty CloudVolume dataset so all values should be 0.\n # dtype set in boss-v0.2-test.json under chunk_processor.params.info.data_type\n cuboid = self.s3_object_to_cuboid(raw_data.read(), 'uint8')\n unique_vals = np.unique(cuboid)\n assert 1 == len(unique_vals)\n assert 0 == unique_vals[0]","def run(self):\n\n while not self.__done:\n self.single_cycle()\n\n \"\"\"\n while not self.__done:\n self.step()\n self.debug()\n \"\"\"","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n for line in stat_file:\n # Each line has a format of:\n # Tag: Value\n #\n # We parse out all lines looking like that and match the stats we care about.\n m = re.search(r\"^(\\w+):\\s*(\\d+)\", line)\n if m is None:\n continue\n\n field_name = m.group(1)\n int_value = int(m.group(2))\n # FDSize is not the same as the number of open file descriptors. Disable\n # for now.\n # if field_name == \"FDSize\":\n # self.print_sample(\"app.fd\", int_value)\n if field_name == \"VmSize\":\n collector.update({Metric(\"app.mem.bytes\", \"vmsize\"): int_value * 1024})\n elif field_name == \"VmPeak\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_vmsize\"): int_value * 1024}\n )\n elif field_name == \"VmRSS\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"resident\"): int_value * 1024}\n )\n elif field_name == \"VmHWM\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_resident\"): int_value * 1024}\n )\n return collector","def run(self, stream: np.ndarray) -> None:\n for index, event in enumerate(stream):\n self.event_index = index\n case_id, activity_name, activity_timestamp = (event[0], event[1], event[2])\n if index == 0:\n self.check_point = activity_timestamp\n self.process_event(case_id, activity_name, activity_timestamp)\n\n self.drift_indexes = list(np.unique(self.drift_indexes))\n print(\"Total number of drifts:\", len(self.drift_indexes))\n print(\"Drift points:\", self.drift_indexes)\n cumulative_stream_drifts(len(stream), self.drift_indexes, f'visualization/drifts/{self.name}.pdf')","def process(self, args):\n for benchmark_file in args.benchmark_files:\n self.process_individual_file(benchmark_file)\n self.total_files += 1","def test_1000_populations_with_activity_one_per_cycle():\n\n with path.tempdir() as log_parent_folder:\n log_folder = os.path.join(log_parent_folder, \"logs\")\n\n run_test_scenario_1(clock_step=\"15 min\",\n simulation_duration=\"10days\",\n n_stories=1,\n per=pd.Timedelta(\"1 day\"),\n log_folder=log_folder)\n\n logging.info(\"loading produced logs\")\n logs = load_all_logs(log_folder)[\"the_logs\"]\n\n logging.info(\"number of produced logs: {} logs\".format(logs.shape[0]))\n\n # 10 days of simulation should produce 1000 * 1 * 10 == 10000 logs\n assert 9500 <= logs.shape[0] <= 10500","def run( self, cycles=-1 ):","def run_single(self):\n self.run_sim_time(1)","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n self.add_records(self.main_loop.log, value_dict.items())\n logger.info(\"Monitoring on auxiliary data finished\")","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n self.add_records(self.main_loop.log, value_dict.items())\n logger.info(\"Monitoring on auxiliary data finished\")","def main():\n stats.set_time_start()\n\n if config.options.show_progress:\n stats.start_monitor()\n\n recorders = Recorder.launch(config.options.recorders)\n\n try:\n for filename in config.filenames:\n parser.parse(filename)\n\n Recorder.wait_empty()\n except KeyboardInterrupt:\n pass\n\n stats.set_time_stop()\n\n if config.options.show_progress:\n stats.stop_monitor()\n\n stats.print_summary()","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n self.add_records(self.main_loop.log, value_dict.items())\n self.check_stop(value_dict)\n logger.info(\"Monitoring on auxiliary data finished\")","def main():\n logging.basicConfig() # create a baseconfiguration s.t. we cann now log \n cycle = 0\n while True:\n\n logging.info(f\"{time.now()} - Start cycle {cycle}\") # changed from print to info \n do_unstable_magick(cycle)\n logging.info(f\"{time.nos()} - Finished cycle {cycle}\")","def _collect_data(endless=True):\r\n conf = Config.Config().get_config()\r\n\r\n Collector.DataCollector(conf.get('db', 'path'), 'config')\r\n\r\n if endless:\r\n try:\r\n while True:\r\n time.sleep(0.5)\r\n except KeyboardInterrupt:\r\n click.echo(\"Process terminated\")\r\n exit(0)","def run(self):\n while True:\n self.logger.info(\"Scraping...\")\n print('scraping...')\n decks = []\n try:\n decks.extend(scrape_decks())\n except Exception as e:\n print('scraping exception' + str(e))\n self.logger.exception(\n 'Scraper for TappedOut raised an exception'\n )\n\n self.insert_decks(decks)\n\n self.logger.info(\n \"Done scraping, sleeping for {} days\".format(self.interval)\n )\n time.sleep(self.interval * (60 * 60 * 24))","def run(self):\n\n sample_counter = 0\n self.started = True\n\n data_queue = Queue()\n with Producer(data_queue, generator=self.generator,\n freq=1 / self.sample_hz):\n while self.running():\n sample_counter += 1\n try:\n sample = data_queue.get(True, 2)\n self.outlet.push_sample(sample)\n if self.add_markers and sample_counter % 1000 == 0:\n self.markers_outlet.push_sample([\"1\"])\n except (Empty, AttributeError):\n # outlet.push_sample(sample) may cause an error after\n # the server has been stopped since the attribute is\n # deleted in another thread.\n break\n\n log.debug(\"[*] No longer pushing data\")","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 run_once(self):\n # Track some statistics about artifacts in a summary object.\n summary = collections.Counter()\n\n for source in self.sources:\n # Run the source to collect artifacts.\n self.logger.info(f\"Running source '{source}'\")\n try:\n # get the generator of onions\n onions = self.sources[source].run()\n except Exception as e:\n self.logger.error(e)\n self.logger.error(traceback.print_exc())\n continue\n\n # Process onions with each operator.\n for operator in self.operators:\n self.logger.info(f\"Processing found onions with operator '{operator}'\")\n try:\n self.operators[operator].process(onions)\n # Save the source onion with collected data\n except Exception as e:\n self.logger.error(e)\n self.logger.error(traceback.print_exc())\n continue\n\n\n\n# # Record stats and update the summary.\n# types = artifact_types(doc.get('interestingKeywords'))\n# summary.update(types)\n# for artifact_type in types:\n# self.logger.info(f'types[artifact_type]')\n\n # Log the summary.\n self.logger.info(f\"New artifacts: {dict(summary)}\")","def run(self, input_time_series=None, num_iter=None, record=False,\n output=False):\n pass","def loop_forever(self):\n while True:\n if self.get_parameter_value(\"publishing_mode\") == \"continuous\":\n self.publishMeasure()","def run(self):\n self.log.overall('Starting run')\n run_start = time()\n for epoch in xrange(self.n_epochs):\n self.agent.reset()\n self.n_epoch = epoch\n self._run_epoch()\n self.log.overall('End of run ({:.2f} s)'.format(time() - run_start))","def _start_proc_collector(self) -> None:\n thread = threading.Thread(target=self._proc_collect, name=\"ProcessMetricsCollector\", daemon=True)\n thread.start()","def run(self):\n self._logger.info(\"Locator started main loop\")\n self._running = True\n while self._running:\n self._update_locations()\n time.sleep(self.interval)","def Run(benchmark_spec: bm_spec.BenchmarkSpec) -> List[sample.Sample]:\n discovery_duration = benchmark_spec.data_discovery_service.DiscoverData()\n return [\n sample.Sample('data_discovery_duration', discovery_duration, 'seconds',\n benchmark_spec.data_discovery_service.GetMetadata())]","def run(self):\n while True:\n time.sleep(RTM_READ_DELAY)\n for event in self._slack_client.rtm_read():\n self.handle_event(event)","def run_measurement(self, probe_name: str) -> None:\n logging.info(f\"Running run {self._measurement_iteration_number}\")\n probe = self._config.probes[probe_name]\n if isinstance(probe, RunnableProbe) and self._ivis_server_available:\n state = self._send_request(Request.STATE, probe=probe)\n else:\n state = None\n self.run_probe(probe_name, f\"run{self._measurement_iteration_number}\", json.dumps(state))\n while self._current_process is not None:\n time.sleep(.01)\n self._measurement_iteration_number += 1","def run(self):\n print('Starting CloudWatchLogsMonitor.')\n\n # Initialize pool for multithreading.\n # Use ThreadPool for shared memory (used for keeping track of last polled timestamp)\n pool = ThreadPool()\n\n while True:\n\n # Check for new LogGroups and LogStreams.\n self.update()\n\n for log_group in self.log_groups:\n # For every log group get and append log events to log file.\n # This is run in parallel and is non-blocking.\n pool.map_async(LogStream.get_and_append_log_events, log_group.log_streams)\n\n # These lines run the agent synchronously.\n # You need to comment out the pool.map_async line above if using synchronous loop.\n # for log_stream in log_group.log_streams:\n # LogStream.get_and_append_log_events(log_stream)\n\n # Sleep for the polling interval.\n time.sleep(self.default_polling_interval)","def run(self):\n while True:\n try:\n if not self._read_new_entries(False):\n time.sleep(0.1)\n self._update_all_tasks()\n except KeyboardInterrupt:\n break","def run(self):\n\t\tfor source in self.sources:\n\t\t\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\n\t\t\tfor r in source.get_elements():\n\t\t\t\tr.set_source(source)\n\t\t\t\tself._queue.put(r)\n\n\t\t\t\t# Extra tracking stuff below:\n\t\t\t\twith self._c_lock:\n\t\t\t\t\tself._total_count+= 1\n\t\t\t\tif self._testing_cache is not None:\n\t\t\t\t\tself._testing_cache.append(r)\n\t\t#print(\"Element loading complete.\\n\")\n\t\tself._running = False","def main():\n run_test_summary1a()\n run_test_summary1c()\n run_test_summary1c()","def _inst_run(self):\r\n self._inst_get_img_info_from_db()\r\n print(\"run method: \", time.ctime())\r\n th = threading.Timer(\r\n 10,\r\n self._inst_run\r\n )\r\n th.start()","def run(self):\n logging.info('running experiment...')\n self._prepare()\n self._load_data()\n self._run()\n self._evaluate()\n self._summarise()\n return True","def run(self):\n rate = rospy.Rate(self._run_rate)\n while not rospy.is_shutdown():\n try:\n rate.sleep()\n except:\n break","def run_extraction(self):\n self.background_estimator = ReflectedRegionsBackgroundEstimator(\n observations=self.observations, **self.config[\"background\"]\n )\n self.background_estimator.run()\n\n self.extraction = SpectrumExtraction(\n observations=self.observations,\n bkg_estimate=self.background_estimator.result,\n **self.config[\"extraction\"]\n )\n\n self.extraction.run()","def run(self, item_callback=None):\n self.item_callback = item_callback\n logger.info('Starting consumer. Use CTRL+C to stop.')\n while self.shards:\n # time.sleep(0.5)\n for shard in self.shards:\n shard_id = shard['ShardId']\n shard_iterator = self.get_iterator(shard)\n self.process_records(shard_iterator, shard_id)","def get_next_sample(self):","def run_test_suite(self, test_config):\n # Folder to store suite results\n test_config['test_suite_start_time'] = datetime.datetime.now().strftime(\n '%Y%m%dT%H%M%S')\n\n instance = cluster_local.UseLocalInstances()\n for i in range(test_config['repeat']):\n self.run_benchmark(test_config, instance, copy=i)\n\n suite_dir_name = '{}_{}'.format(test_config['test_suite_start_time'],\n test_config['test_id'])\n reporting.process_folder(\n os.path.join(self.workspace, 'results', suite_dir_name),\n report_config=self.auto_test_config)","def start(self):\n for trial in self._trials:\n self._run(trial)","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def run(self) -> None:\n\n # Track the last timestamp we see. When we fetch_stream() again on the\n # next iteration, we'll start from that timestamp onwards to avoid\n # fetching every single page again. The last event or two will be\n # still be in the response, but our de-duping will ignore those.\n last_timestamp = None\n\n # Keep track of what log entries we've consumed so that we suppress\n # duplicates. Duplicates will arise in our stream due to the way we\n # watch for new entries.\n consumed = set() # type: MutableSet\n\n # How many successful vs failed fetch_stream calls. If we consistently see\n # failures but we never see a successful attempt, we should raise an exception\n # and stop.\n success_count = 0\n failure_count = 0\n\n while not self.stopped.wait(0.2):\n try:\n for entry in fetch_stream(self.stream, start_time = last_timestamp):\n if entry[\"eventId\"] not in consumed:\n consumed.add(entry[\"eventId\"])\n\n last_timestamp = entry[\"timestamp\"]\n\n self.consumer(entry)\n except (ClientError, BotocoreConnectionError):\n failure_count += 1\n if failure_count > MAX_FAILURES and not success_count:\n raise\n else:\n success_count += 1","def loop(self):\n raise NotImplementedError()","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n # File format is single value per line with \"fieldname:\" prefix.\n for x in stat_file:\n fields = x.split()\n if len(fields) == 0:\n continue\n if not collector:\n collector = {}\n if fields[0] == \"rchar:\":\n collector.update({Metric(\"app.disk.bytes\", \"read\"): int(fields[1])})\n elif fields[0] == \"syscr:\":\n collector.update({Metric(\"app.disk.requests\", \"read\"): int(fields[1])})\n elif fields[0] == \"wchar:\":\n collector.update({Metric(\"app.disk.bytes\", \"write\"): int(fields[1])})\n elif fields[0] == \"syscw:\":\n collector.update({Metric(\"app.disk.requests\", \"write\"): int(fields[1])})\n return collector"],"string":"[\n \"def run(self):\\r\\n self.collect_data()\",\n \"def gather_sample(self, my_file, collector=None):\\n\\n pass\",\n \"def collect_samples(self):\\n self.__running = True\\n with open(self.__filename, 'a') as output:\\n next_sample_time = time.time()\\n while self.__running:\\n sensor_name = self.__sensor.get_sensor_type_name()\\n sensor_id = self.__sensor.get_sensor_id()\\n data = self.__sensor.retrieve_data_string() \\n if DEBUG:\\n print('data: \\\"{}\\\"'.format(data),\\n file = sys.stderr, flush=True)\\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\\n result = OUTPUT_FORMAT.format(when,\\n sensor_name, \\n sensor_id, \\n data)\\n output.write(result)\\n output.flush()\\n \\n next_sample_time = next_sample_time + self.__interval\\n delay_time = next_sample_time - time.time()\\n if DEBUG:\\n print('delay_time = {}'.format(delay_time),\\n file=sys.stderr, flush=True)\\n \\n if 0 < delay_time: # don't sleep if already next sample time\\n time.sleep(delay_time)\",\n \"def run(self):\\n self.logger.info(f'Running {self.__class__.__name__}')\\n while True:\\n last_check = time.time()\\n self.collect_new_events()\\n while time.time() - last_check < self._check_for_new_events_interval:\\n self.logger.debug('Waiting for new events collection: new collection in {}s'.format(\\n self._check_for_new_events_interval - (time.time() - last_check)))\\n time.sleep(1)\",\n \"def start_monitor_loop(self):\\n read_file = read_config_file.ConfigFileReader()\\n\\n communication_time = read_file.get_send_communication_time()\\n metrics_array = read_file.get_metrics()\\n\\n self.add_metrics_to_monitor_object(communication_time, metrics_array)\",\n \"def run_resample(self):\\n\\n self.in_data.open()\\n self.out_data.open()\\n\\n try:\\n # Get the fields from the input file and set them/write headers in output:\\n self.all_fields = self.in_data.fields\\n\\n self.out_data.set_fields(self.all_fields)\\n self.out_data.write_headers()\\n\\n # Set up the sensor fields by removing non-sensor fields:\\n self.set_sensor_only_fields()\\n\\n # Read the first event from the input file:\\n self.get_next_input_event()\\n\\n # Warn and exit if we have no input data to read:\\n if self.next_input_event is None:\\n msg = f\\\"The input file {self.in_file} did not have any data rows\\\"\\n warn(msg)\\n\\n return\\n\\n self.first_event_stamp = self.next_input_event[self.stamp_field]\\n\\n # Set up the sample tracking (here mostly to set the start of the first interval):\\n self.reset_sample_tracking()\\n\\n # Now iterate through the output intervals:\\n while True:\\n self.process_next_interval()\\n except EOFError: # catch when we are at the end of the file\\n pass\\n finally:\\n self.in_data.close()\\n self.out_data.close()\\n\\n print() # make sure we go to a new output line\",\n \"def run(self, repetitions, **kwargs):\\n\\t\\tself.sampler.sample(repetitions, **kwargs)\",\n \"def start(self):\\n while True:\\n LogService.log_info(\\\"aggregator\\\", \\\"Creating statistics\\\")\\n self.create_statistics()\\n LogService.log_info(\\\"aggregator\\\", \\\"Cleaning up\\\")\\n self.cleanup_measurements()\\n LogService.log_info(\\\"aggregator\\\", \\\"Sleeping for 60 minutes\\\")\\n time.sleep(60*60)\",\n \"def gather_sample(self):\\n\\n for _pid in self._select_processes():\\n if not self.__trackers.get(_pid):\\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\\n\\n self._reset_absolute_metrics()\\n\\n for _tracker in self.__trackers.values():\\n _metrics = _tracker.collect()\\n self.record_metrics(_tracker.pid, _metrics)\\n\\n self._calculate_aggregated_metrics()\\n self._remove_dead_processes()\\n\\n self.print_metrics()\",\n \"def run(self):\\n operation_manager = self._core.get_operation_manager()\\n while True:\\n while operation_manager.process_next():\\n pass\\n sleep(2)\",\n \"def run(self):\\n while True:\\n try:\\n sleep(influx_settings.write_freq)\\n self._redis2influx()\\n except InterruptExceptions as ex:\\n raise ex\",\n \"def run_sample(smp: sample.Sample,\\n run_dir: Text,\\n summary_file: Optional[Text] = None,\\n generate_sample_ns: Optional[int] = None):\\n start = time.time()\\n # Create a script named 'run.sh' for rerunning the sample.\\n args = [\\n SAMPLE_RUNNER_MAIN_PATH,\\n '--logtostderr',\\n '--input_file=sample.x',\\n '--options_file=options.pbtxt',\\n ]\\n\\n _write_to_file(run_dir, 'sample.x', smp.input_text)\\n _write_to_file(run_dir, 'options.pbtxt', smp.options.to_pbtxt())\\n args_filename = 'args.txt'\\n _write_to_file(\\n run_dir, args_filename, sample.args_batch_to_text(smp.args_batch)\\n )\\n args.append('--args_file=args.txt')\\n ir_channel_names_filename = None\\n if smp.ir_channel_names is not None:\\n ir_channel_names_filename = 'ir_channel_names.txt'\\n _write_to_file(run_dir, ir_channel_names_filename,\\n sample.ir_channel_names_to_text(smp.ir_channel_names))\\n args.append('--ir_channel_names_file=ir_channel_names.txt')\\n args.append(run_dir)\\n _write_to_file(\\n run_dir,\\n 'run.sh',\\n f'#!/bin/sh\\\\n\\\\n{subprocess.list2cmdline(args)}\\\\n',\\n executable=True)\\n logging.vlog(1, 'Starting to run sample')\\n logging.vlog(2, smp.input_text)\\n runner = sample_runner.SampleRunner(run_dir)\\n runner.run_from_files(\\n 'sample.x', 'options.pbtxt', args_filename, ir_channel_names_filename\\n )\\n timing = runner.timing\\n\\n timing.total_ns = int((time.time() - start) * 1e9)\\n if generate_sample_ns:\\n # The sample generation time, if given, is not part of the measured total\\n # time, so add it in.\\n timing.total_ns += generate_sample_ns\\n timing.generate_sample_ns = generate_sample_ns\\n\\n logging.vlog(1, 'Completed running sample, elapsed: %0.2fs',\\n time.time() - start)\\n\\n if summary_file:\\n _write_ir_summaries(run_dir, timing, summary_file)\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n for key in value_dict.keys():\\n value_dict[key] *= self.coverage\\n value_dict['coverage'] = self.coverage\\n logging.info(\\\"coverage:{0}\\\".format(self.coverage))\\n for key, value in value_dict.items():\\n logging.info(\\\"{0}:{1}\\\".format(key,value))\\n self.add_records(self.main_loop.log, value_dict.items())\\n self.check_stop(value_dict)\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def run_sample(smp: sample.Sample,\\n run_dir: Text,\\n summary_file: Optional[Text] = None,\\n generate_sample_ns: Optional[int] = None):\\n start = time.time()\\n\\n _write_to_file(run_dir, 'sample.x', smp.input_text)\\n _write_to_file(run_dir, 'options.json', smp.options.to_json())\\n if smp.args_batch:\\n _write_to_file(run_dir, 'args.txt',\\n sample.args_batch_to_text(smp.args_batch))\\n\\n # Create a script named 'run.sh' for rerunning the sample.\\n args = [\\n SAMPLE_RUNNER_MAIN_PATH, '--logtostderr', '--input_file=sample.x',\\n '--options_file=options.json'\\n ]\\n if smp.args_batch:\\n args.append('--args_file=args.txt')\\n args.append(run_dir)\\n _write_to_file(\\n run_dir,\\n 'run.sh',\\n f'#!/bin/sh\\\\n\\\\n{subprocess.list2cmdline(args)}\\\\n',\\n executable=True)\\n logging.vlog(1, 'Starting to run sample')\\n logging.vlog(2, smp.input_text)\\n runner = sample_runner.SampleRunner(run_dir)\\n runner.run_from_files('sample.x', 'options.json', 'args.txt')\\n timing = runner.timing\\n\\n timing.total_ns = int((time.time() - start) * 1e9)\\n if generate_sample_ns:\\n # The sample generation time, if given, is not part of the measured total\\n # time, so add it in.\\n timing.total_ns += generate_sample_ns\\n timing.generate_sample_ns = generate_sample_ns\\n\\n logging.vlog(1, 'Completed running sample, elapsed: %0.2fs',\\n time.time() - start)\\n\\n if summary_file:\\n _write_ir_summaries(run_dir, timing, summary_file)\",\n \"def run(self):\\n\\n # How to retrieve your input data.\\n input_1_data = self.in_data['input_1']\\n\\n # How to retrieve your params value.\\n param_1 = self.param['param_1']\\n\\n # How to process data.\\n # Just write any number of methods you want and use them here.\\n sample_out_data = self.sample_method(input_1_data, param_1)\\n\\n # Go to the definition of this method to see how to log.\\n self.demo_log()\\n\\n # This is how to set output data.\\n self.out_data['output_1'] = sample_out_data\",\n \"def run(self):\\n\\n step = self.steps['diagnostics_files']\\n step.cores = self.config.getint('make_diagnostics_files', 'cores')\\n\\n # run the step\\n super().run()\",\n \"def run():\\n logger.info(f\\\"Process started:\\\")\\n logger.info(f\\\"Converting Glove file to Word2Vec format\\\")\\n convert_to_word2vec.convert(\\n \\\"./data/source/glove.6B.50d.txt\\\", \\\"./data/source/glove.6B.50d.w2vformat.txt\\\"\\n )\\n\\n logger.info(f\\\"Extracting Click Stream data\\\")\\n extract_click_stream_data()\\n\\n logger.info(\\\"Extracting Wiki articles\\\")\\n extract_wiki_articles()\\n\\n logger.info(f\\\"Generating Clickstream dataset\\\")\\n generate_datasets()\\n\\n logger.info(\\\"Tokenizing articles\\\")\\n WikiArticlesTokenizer().process()\\n\\n logger.info(\\\"Creating dataset with Wiki Articles\\\")\\n create_wiki_articles_dataset()\",\n \"def test_continuous_bulk_parsing(self, aggregator):\\n test_data = ensure_bytes(open(NAGIOS_TEST_LOG).read())\\n ITERATIONS = 10\\n log_file = tempfile.NamedTemporaryFile(mode=\\\"a+b\\\")\\n\\n # Get the config\\n config, nagios_cfg = get_config(\\\"log_file={}\\\\n\\\".format(log_file.name), events=True)\\n\\n # Set up the check\\n nagios = NagiosCheck(CHECK_NAME, {}, config['instances'])\\n\\n for _ in range(ITERATIONS):\\n log_file.write(test_data)\\n log_file.flush()\\n nagios.check(config['instances'][0])\\n\\n log_file.close()\\n assert len(aggregator.events) == ITERATIONS * 503\",\n \"def run(self):\\n print(\\\"%s starting up\\\" % self.getName())\\n for count in range(self.accessCount):\\n time.sleep(random.randint(1, self.sleepMax))\\n value = self.cell.read(lambda counter: self.cell.data.count)\\n print(\\\"%s is done getting %s\\\" % (self.getName(), str(value)))\",\n \"def run(self):\\n\\n while self.source.SAMPLING:\\n wx.CallAfter(self.target, self)\\n sleep(0.75)\\n\\n self.Terminate()\",\n \"def gather_sample(self, stat_file, collector=None):\\n if not collector:\\n collector = {}\\n # The file format is just a single line of all the fields.\\n line = stat_file.readlines()[0]\\n # Chop off first part which is the pid and executable file. The\\n # executable file is terminated with a paren so just search for that.\\n line = line[(line.find(\\\") \\\") + 2) :]\\n fields = line.split()\\n # Then the fields we want are just at fixed field positions in the\\n # string. Just grab them.\\n\\n # See http://man7.org/linux/man-pages/man5/proc.5.html for reference on field numbers\\n # Keep in mind that we chop first 3 values away (pid, command line, state), so you need to\\n # subtract 3 from the field numbers from the man page (e.g. on the man page nice is number\\n # 19, but in our case it's 16 aka 19 - 3)\\n process_uptime = self.__get_uptime_ms() - self.calculate_time_ms(\\n int(fields[19])\\n )\\n\\n collector.update(\\n {\\n Metric(\\\"app.cpu\\\", \\\"user\\\"): self.__calculate_time_cs(int(fields[11])),\\n Metric(\\\"app.cpu\\\", \\\"system\\\"): self.__calculate_time_cs(int(fields[12])),\\n Metric(\\\"app.uptime\\\", None): process_uptime,\\n Metric(\\\"app.nice\\\", None): float(fields[16]),\\n Metric(\\\"app.threads\\\", None): int(fields[17]),\\n Metric(\\\"app.mem.majflt\\\", None): int(fields[9]),\\n Metric(\\\"app.io.wait\\\", None): int(fields[39])\\n if len(fields) >= 39\\n else 0,\\n }\\n )\\n return collector\",\n \"def run(self):\\n\\t\\tself.data_source.connect()\\n\\t\\twhile self.running:\\n\\t\\t\\tself.data_source.read()\",\n \"def start_collector(self, callback=None):\\n self.log.info(\\\"starting-pm-collection\\\", device_name=self.name)\\n if callback is None:\\n callback = self.perform_test_omci\\n\\n if self.lc is None:\\n self.lc = LoopingCall(callback)\\n\\n if self.default_freq > 0:\\n self.lc.start(interval=self.default_freq / 10)\",\n \"def _proc_collect(self) -> None:\\n while True:\\n self.process_num_threads.set(self._process.num_threads())\\n self.process_memory_bytes.set(self._process.memory_info().rss)\\n self.process_cpu_percent.set(self._process.cpu_percent())\\n\\n sleep(self.process_scrape_interval)\",\n \"def run(self):\\n self.speed_test.start()\",\n \"def loop(self):\\n pass\",\n \"def run(self):\\n print(\\\"%s starting up\\\" % self.getName())\\n for count in range(self.accessCount):\\n time.sleep(random.randint(1, self.sleepMax))\\n value = self.cell.write(lambda counter: counter.increment())\\n print(\\\"%s is done incrementing to %s\\\" % (self.getName(), str(value)))\",\n \"def _run(self):\\n while(self._loop):\\n pass\",\n \"def run(self):\\n self._setupLogger()\\n self.setup()\\n\\n self.logger.info(self.moduleName + \\\" starting run loop.\\\")\\n\\n while True:\\n self.loop()\",\n \"def load_sample(self):\\n\\n self.load_images(self.folder + \\\"/sampleSet.txt\\\")\\n self.load_traces(self.folder + \\\"/sampleLabel.txt\\\")\",\n \"def run(self):\\n while True:\\n try:\\n self.check_value()\\n except Exception as e:\\n print(f\\\"[ERROR]: Error running the continuous run loop on sample_module: {e}\\\")\\n continue\",\n \"def _run_cycle(self):\\n pass\",\n \"def run(self):\\n logger.info(\\\"Running...\\\")\\n self._child = Process(target=self.collect, args=())\\n self._child.start()\",\n \"def test_continuous_bulk_parsing(self, aggregator):\\n test_data = open(NAGIOS_TEST_LOG).read()\\n events = []\\n ITERATIONS = 10\\n log_file = tempfile.NamedTemporaryFile(mode=\\\"a+b\\\")\\n log_file.write(test_data.encode('utf-8'))\\n log_file.flush()\\n\\n # Get the config\\n config, nagios_cfg = get_config('\\\\n'.join([\\\"log_file={0}\\\".format(log_file.name)]), events=True)\\n\\n # Set up the check\\n nagios = NagiosCheck(CHECK_NAME, {}, {}, instances=config['instances'])\\n nagios.get_topology = mocked_topology\\n\\n for i in range(ITERATIONS):\\n log_file.write(test_data.encode('utf-8'))\\n log_file.flush()\\n nagios.check(config['instances'][0])\\n events.extend(events)\\n\\n log_file.close()\\n assert len(aggregator.events) == ITERATIONS * 505\",\n \"def test_runner_full_loop(caplog, dataset):\\n caplog.set_level(logging.DEBUG)\\n\\n session = dataset\\n\\n start_date = datetime.datetime(2020, 5, 17, 13, 0, 0)\\n end_date = datetime.datetime(2020, 5, 17, 13, 0, 5)\\n replay_rate = 1 \\n \\n db_connector_test = DataBaseConnector(session=session, \\n table_name='timeseries_dataset', \\n time_column='timestamp', \\n start_date=start_date,\\n end_date=end_date)\\n\\n test_publisher = ConsolePublisher()\\n\\n runner = CentralRunner(db_connection=db_connector_test, \\n output_system=test_publisher, \\n start_time=start_date, \\n end_time=end_date,\\n replay_rate=replay_rate )\\n\\n start = time.perf_counter()\\n \\n runner.run()\\n\\n end = time.perf_counter()\\n\\n code_time = end - start\\n \\n print(code_time)\\n \\n assert int(code_time) == 4\",\n \"async def test_all_samples(self):\\n response = await self.collect(get_request_json_return_value=self.JMETER_JSON)\\n self.assert_measurement(response, value=\\\"248\\\", entities=[])\",\n \"def run_inner(self):\\n for event in self.inotify.event_gen():\\n self.process_inotify_event(event)\",\n \"def run(self,mc_sample=None):\\n if mc_sample:\\n self.mc_sample = mc_sample\\n\\n total_scores = 0.0\\n total_scores_square = 0.0\\n self.scores_list =[]\\n \\n for i in range(self.num_runs): #runs the specified number of Monte Carlo samples\\n score = next(self.mc_sample) #next score\\n self.scores_list.append(score) \\n total_scores += score\\n total_scores_square += score**2\\n\\n self.xhat = total_scores / self.num_runs #mean of score\\n self.x2hat = total_scores_square / self.num_runs #mean of score^2\\n\\n self.sample_variance = (self.num_runs / (self.num_runs - 1.0)) * (self.x2hat - (self.xhat**2))\\n self.sample_stddev = np.sqrt(self.sample_variance)\\n self.mean_variance = self.sample_variance / (self.num_runs - 1.0)\\n self.mean_stddev = np.sqrt(self.mean_variance)\",\n \"def test_runner_full_loop_big(caplog, big_dataset):\\n caplog.set_level(logging.INFO)\\n\\n session = big_dataset\\n\\n start_date = datetime.datetime(2020, 5, 17, 13, 0, 3)\\n end_date = datetime.datetime(2020, 5, 17, 13, 0, 6)\\n replay_rate = 1 \\n\\n db_connector_test = DataBaseConnector(session=session, \\n table_name='timeseries_dataset', \\n time_column='timestamp', \\n start_date=start_date,\\n end_date=end_date)\\n\\n debug_publisher = FilePublisher()\\n\\n runner = CentralRunner(db_connection=db_connector_test, \\n output_system=debug_publisher, \\n start_time=start_date, \\n end_time=end_date,\\n replay_rate=replay_rate )\\n\\n start = time.perf_counter()\\n \\n runner.run()\\n\\n end = time.perf_counter()\\n\\n code_time = end - start\\n assert int(code_time) == 2\\n\\n ## Test results\\n assert os.path.exists('test_tmp/17-05-2020_13-00-03')\\n assert os.path.exists('test_tmp/17-05-2020_13-00-05')\\n\\n assert len(os.listdir('test_tmp/17-05-2020_13-00-03')) == 9\\n assert len(os.listdir('test_tmp/17-05-2020_13-00-05')) == 2\",\n \"def run_main():\\n # Matching lines against a matcher function.\\n matched_lines = match_file(file_names, matcher)\\n\\n # Will contain data sorted by file.\\n binned_data = {}\\n\\n # Looking through the lines that were inserted into the metrics file via the metrics component.\\n for key in matched_lines:\\n\\n # Grabbing matched lines by the file or orgination.\\n buffer = matched_lines[key]\\n\\n # This will contain dictionaries converted from JSON.\\n data = []\\n\\n # Loop through the collection, appending data converted from JSON entries.\\n for line in buffer:\\n data.append(extract_data(line))\\n\\n # Sort the data by file.\\n binned_data[key] = sort_data(data)\\n\\n # Output the final results.\\n generate_statistics(binned_data)\\n return 0\",\n \"def run_sample(self):\\n # there will be validation failures for sample data\\n self.validate_req(ignore_failure=True)\\n runner_fn = self.model_runner.execute_model_for_sample_data\\n return self.do_handle_request(runner_fn)\",\n \"def run(self):\\n while True:\\n # Do something\\n print('Doing something imporant in the background')\\n\\n self.loadData()\\n time.sleep(self.interval)\",\n \"def run(self):\\n\\n self.create_trials() # create them *before* running!\\n self.start_experiment()\\n\\n for trail in self.trials:\\n trial.run()\\n\\n self.close()\",\n \"def run(self):\\n t = Ticker(self.freq)\\n while True: \\n t.tick()\\n #Name, used to identify the observation in memory:\\n Operators = self.Operators\\n if Operators:\\n self.add_property('name', 'HumanDetector')\\n self.add_property('Operators', Operators)\\n self.store_observation()\\n\\n self.update()\",\n \"def sample(self):\\n logger.info(\\\"%s: collect sensor data\\\", self.__class__.__name__)\\n samples = []\\n self._fetch_data(samples)\\n return samples\",\n \"def test_scan_file(self):\\n self.run_scan(self.filename, 1)\",\n \"def run(self):\\n\\n self.load_file()\\n self.cat_to_num()\\n self.split()\",\n \"def run(self):\\n self.monitor.start()\",\n \"def run(self):\\n logging.info(\\\"Running...\\\\n\\\")\\n self._child = Process(target=self.collect, args=())\\n self._child.start()\",\n \"def run(self):\\n logging.info(\\\"Running...\\\\n\\\")\\n self._child = Process(target=self.collect, args=())\\n self._child.start()\",\n \"def run(self):\\n self.evaluate()\\n self.accumulate()\\n self.summarize()\",\n \"def run_one_test_cycle(self):\\n logging.info(\\n \\\"{0} operations remaining: {1}\\\".format(\\n self.args.pm_operation, self.args.repetitions\\n )\\n )\\n\\n self.check_last_cycle_duration()\\n if self.args.repetitions > 0:\\n self.run_pm_command()\\n else:\\n self.summary()\",\n \"def run(self):\\n LOG.debug(\\\"ReaderThread up and running\\\")\\n\\n lastevictTime = 0\\n while ALIVE:\\n for col in allLivingCollectors():\\n for line in col.collect():\\n self.processLine(col, line)\\n now = int(time.time())\\n if now - lastevictTime > self.evictinterval:\\n lastevictTime = now\\n now -= self.evictinterval\\n for col in allCollectors():\\n col.evictOldkeys(now)\\n # BUGBUG : not good\\n time.sleep(1)\",\n \"def run(self):\\n\\n self.preprocess()\\n self.restore_ratings()\\n self.prepare_UI()\\n self.loop_through_units()\\n self.cleanup()\\n\\n print('\\\\nAll Done - results are available in:\\\\n\\\\t{}'.format(self.out_dir))\",\n \"def do_cycle(self):\\n c.check_running()\\n online_models = self.get_online_models()\\n if len(online_models) > 0:\\n self.process_models(online_models)\\n self.print_recording()\",\n \"def step(self):\\r\\n self.datacollector.collect(self)\\r\\n self.datacollector2.collect(self)\\r\\n self.datacollector3.collect(self)\\r\\n self.datacollector4.collect(self)\\r\\n self.datacollector5.collect(self)\\r\\n self.datacollector6.collect(self)\\r\\n self.datacollector7.collect(self)\\r\\n self.datacollector8.collect(self)\\r\\n self.datacollector9.collect(self)\\r\\n self.datacollector10.collect(self)\\r\\n self.datacollector11.collect(self)\\r\\n self.datacollector12.collect(self)\\r\\n self.datacollector13.collect(self)\\r\\n\\r\\n self.datacollector14.collect(self)\\r\\n self.datacollector15.collect(self)\\r\\n self.datacollector16.collect(self)\\r\\n self.datacollector17.collect(self)\\r\\n self.datacollector18.collect(self)\\r\\n self.datacollector19.collect(self)\\r\\n self.datacollector20.collect(self)\\r\\n self.datacollector21.collect(self)\\r\\n self.datacollector22.collect(self)\\r\\n self.datacollector23.collect(self)\\r\\n self.datacollector24.collect(self)\\r\\n self.datacollector25.collect(self)\\r\\n self.datacollector26.collect(self)\\r\\n self.schedule.step()\",\n \"def _counter(self):\\n while True:\\n # ensure counter interval is up to date\\n self._read_interval_time()\\n\\n log.debug(\\\"SFlowManager._counter: sleeping for %s\\\", self._counter_interval)\\n\\n time.sleep(self._counter_interval)\\n\\n # get a cpu times sample\\n res = resource.getrusage(resource.RUSAGE_SELF)\\n\\n # build and send counter structure\\n csample = { 'counter_sample': {\\n 'app_name': get_sys_name(),\\n 'app_resources': {\\n 'user_time': int(res.ru_utime * 1000),\\n 'system_time': int(res.ru_stime * 1000),\\n 'mem_used': 0, # @TODO\\n 'mem_max': res.ru_maxrss * 1024,\\n 'fd_open': 0, # @TODO do we care?\\n 'fd_max': 0, # @TODO \\\"\\\"\\n 'conn_open': 0, # @TODO couch/rabbit connection summary somehow\\n 'conn_max': 0\\n },\\n 'app_workers':{\\n 'workers_active': len(self._container.proc_manager.proc_sup.children),\\n 'workers_idle': 0,\\n 'workers_max': 1024,\\n 'req_delayed': 0,\\n 'req_dropped': 0\\n }\\n }\\n }\\n\\n log.debug(\\\"Publishing counter stats: %s\\\" % csample)\\n\\n self._publish(csample)\",\n \"def test_run(self):\\n engine = Engine(self.config_file, self.api_token, 23)\\n engine.msg_wait_iterations = 0\\n\\n # Put some stuff on the task queue\\n self.setup_helper.add_volumetric_tasks(self.aws_creds[\\\"access_key\\\"],\\n self.aws_creds['secret_key'],\\n self.upload_queue_url, engine.backend)\\n\\n engine.join()\\n engine.run()\\n\\n # Check for tile to exist\\n s3 = boto3.resource('s3')\\n ingest_bucket = s3.Bucket(self.ingest_bucket_name)\\n\\n with tempfile.NamedTemporaryFile() as test_file:\\n with open(test_file.name, 'wb') as raw_data:\\n ingest_bucket.download_fileobj(VOLUMETRIC_CUBOID_KEY, raw_data)\\n with open(test_file.name, 'rb') as raw_data:\\n # Using an empty CloudVolume dataset so all values should be 0.\\n # dtype set in boss-v0.2-test.json under chunk_processor.params.info.data_type\\n cuboid = self.s3_object_to_cuboid(raw_data.read(), 'uint8')\\n unique_vals = np.unique(cuboid)\\n assert 1 == len(unique_vals)\\n assert 0 == unique_vals[0]\",\n \"def run(self):\\n\\n while not self.__done:\\n self.single_cycle()\\n\\n \\\"\\\"\\\"\\n while not self.__done:\\n self.step()\\n self.debug()\\n \\\"\\\"\\\"\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n for line in stat_file:\\n # Each line has a format of:\\n # Tag: Value\\n #\\n # We parse out all lines looking like that and match the stats we care about.\\n m = re.search(r\\\"^(\\\\w+):\\\\s*(\\\\d+)\\\", line)\\n if m is None:\\n continue\\n\\n field_name = m.group(1)\\n int_value = int(m.group(2))\\n # FDSize is not the same as the number of open file descriptors. Disable\\n # for now.\\n # if field_name == \\\"FDSize\\\":\\n # self.print_sample(\\\"app.fd\\\", int_value)\\n if field_name == \\\"VmSize\\\":\\n collector.update({Metric(\\\"app.mem.bytes\\\", \\\"vmsize\\\"): int_value * 1024})\\n elif field_name == \\\"VmPeak\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_vmsize\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmRSS\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"resident\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmHWM\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_resident\\\"): int_value * 1024}\\n )\\n return collector\",\n \"def run(self, stream: np.ndarray) -> None:\\n for index, event in enumerate(stream):\\n self.event_index = index\\n case_id, activity_name, activity_timestamp = (event[0], event[1], event[2])\\n if index == 0:\\n self.check_point = activity_timestamp\\n self.process_event(case_id, activity_name, activity_timestamp)\\n\\n self.drift_indexes = list(np.unique(self.drift_indexes))\\n print(\\\"Total number of drifts:\\\", len(self.drift_indexes))\\n print(\\\"Drift points:\\\", self.drift_indexes)\\n cumulative_stream_drifts(len(stream), self.drift_indexes, f'visualization/drifts/{self.name}.pdf')\",\n \"def process(self, args):\\n for benchmark_file in args.benchmark_files:\\n self.process_individual_file(benchmark_file)\\n self.total_files += 1\",\n \"def test_1000_populations_with_activity_one_per_cycle():\\n\\n with path.tempdir() as log_parent_folder:\\n log_folder = os.path.join(log_parent_folder, \\\"logs\\\")\\n\\n run_test_scenario_1(clock_step=\\\"15 min\\\",\\n simulation_duration=\\\"10days\\\",\\n n_stories=1,\\n per=pd.Timedelta(\\\"1 day\\\"),\\n log_folder=log_folder)\\n\\n logging.info(\\\"loading produced logs\\\")\\n logs = load_all_logs(log_folder)[\\\"the_logs\\\"]\\n\\n logging.info(\\\"number of produced logs: {} logs\\\".format(logs.shape[0]))\\n\\n # 10 days of simulation should produce 1000 * 1 * 10 == 10000 logs\\n assert 9500 <= logs.shape[0] <= 10500\",\n \"def run( self, cycles=-1 ):\",\n \"def run_single(self):\\n self.run_sim_time(1)\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n self.add_records(self.main_loop.log, value_dict.items())\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n self.add_records(self.main_loop.log, value_dict.items())\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def main():\\n stats.set_time_start()\\n\\n if config.options.show_progress:\\n stats.start_monitor()\\n\\n recorders = Recorder.launch(config.options.recorders)\\n\\n try:\\n for filename in config.filenames:\\n parser.parse(filename)\\n\\n Recorder.wait_empty()\\n except KeyboardInterrupt:\\n pass\\n\\n stats.set_time_stop()\\n\\n if config.options.show_progress:\\n stats.stop_monitor()\\n\\n stats.print_summary()\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n self.add_records(self.main_loop.log, value_dict.items())\\n self.check_stop(value_dict)\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def main():\\n logging.basicConfig() # create a baseconfiguration s.t. we cann now log \\n cycle = 0\\n while True:\\n\\n logging.info(f\\\"{time.now()} - Start cycle {cycle}\\\") # changed from print to info \\n do_unstable_magick(cycle)\\n logging.info(f\\\"{time.nos()} - Finished cycle {cycle}\\\")\",\n \"def _collect_data(endless=True):\\r\\n conf = Config.Config().get_config()\\r\\n\\r\\n Collector.DataCollector(conf.get('db', 'path'), 'config')\\r\\n\\r\\n if endless:\\r\\n try:\\r\\n while True:\\r\\n time.sleep(0.5)\\r\\n except KeyboardInterrupt:\\r\\n click.echo(\\\"Process terminated\\\")\\r\\n exit(0)\",\n \"def run(self):\\n while True:\\n self.logger.info(\\\"Scraping...\\\")\\n print('scraping...')\\n decks = []\\n try:\\n decks.extend(scrape_decks())\\n except Exception as e:\\n print('scraping exception' + str(e))\\n self.logger.exception(\\n 'Scraper for TappedOut raised an exception'\\n )\\n\\n self.insert_decks(decks)\\n\\n self.logger.info(\\n \\\"Done scraping, sleeping for {} days\\\".format(self.interval)\\n )\\n time.sleep(self.interval * (60 * 60 * 24))\",\n \"def run(self):\\n\\n sample_counter = 0\\n self.started = True\\n\\n data_queue = Queue()\\n with Producer(data_queue, generator=self.generator,\\n freq=1 / self.sample_hz):\\n while self.running():\\n sample_counter += 1\\n try:\\n sample = data_queue.get(True, 2)\\n self.outlet.push_sample(sample)\\n if self.add_markers and sample_counter % 1000 == 0:\\n self.markers_outlet.push_sample([\\\"1\\\"])\\n except (Empty, AttributeError):\\n # outlet.push_sample(sample) may cause an error after\\n # the server has been stopped since the attribute is\\n # deleted in another thread.\\n break\\n\\n log.debug(\\\"[*] No longer pushing data\\\")\",\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 run_once(self):\\n # Track some statistics about artifacts in a summary object.\\n summary = collections.Counter()\\n\\n for source in self.sources:\\n # Run the source to collect artifacts.\\n self.logger.info(f\\\"Running source '{source}'\\\")\\n try:\\n # get the generator of onions\\n onions = self.sources[source].run()\\n except Exception as e:\\n self.logger.error(e)\\n self.logger.error(traceback.print_exc())\\n continue\\n\\n # Process onions with each operator.\\n for operator in self.operators:\\n self.logger.info(f\\\"Processing found onions with operator '{operator}'\\\")\\n try:\\n self.operators[operator].process(onions)\\n # Save the source onion with collected data\\n except Exception as e:\\n self.logger.error(e)\\n self.logger.error(traceback.print_exc())\\n continue\\n\\n\\n\\n# # Record stats and update the summary.\\n# types = artifact_types(doc.get('interestingKeywords'))\\n# summary.update(types)\\n# for artifact_type in types:\\n# self.logger.info(f'types[artifact_type]')\\n\\n # Log the summary.\\n self.logger.info(f\\\"New artifacts: {dict(summary)}\\\")\",\n \"def run(self, input_time_series=None, num_iter=None, record=False,\\n output=False):\\n pass\",\n \"def loop_forever(self):\\n while True:\\n if self.get_parameter_value(\\\"publishing_mode\\\") == \\\"continuous\\\":\\n self.publishMeasure()\",\n \"def run(self):\\n self.log.overall('Starting run')\\n run_start = time()\\n for epoch in xrange(self.n_epochs):\\n self.agent.reset()\\n self.n_epoch = epoch\\n self._run_epoch()\\n self.log.overall('End of run ({:.2f} s)'.format(time() - run_start))\",\n \"def _start_proc_collector(self) -> None:\\n thread = threading.Thread(target=self._proc_collect, name=\\\"ProcessMetricsCollector\\\", daemon=True)\\n thread.start()\",\n \"def run(self):\\n self._logger.info(\\\"Locator started main loop\\\")\\n self._running = True\\n while self._running:\\n self._update_locations()\\n time.sleep(self.interval)\",\n \"def Run(benchmark_spec: bm_spec.BenchmarkSpec) -> List[sample.Sample]:\\n discovery_duration = benchmark_spec.data_discovery_service.DiscoverData()\\n return [\\n sample.Sample('data_discovery_duration', discovery_duration, 'seconds',\\n benchmark_spec.data_discovery_service.GetMetadata())]\",\n \"def run(self):\\n while True:\\n time.sleep(RTM_READ_DELAY)\\n for event in self._slack_client.rtm_read():\\n self.handle_event(event)\",\n \"def run_measurement(self, probe_name: str) -> None:\\n logging.info(f\\\"Running run {self._measurement_iteration_number}\\\")\\n probe = self._config.probes[probe_name]\\n if isinstance(probe, RunnableProbe) and self._ivis_server_available:\\n state = self._send_request(Request.STATE, probe=probe)\\n else:\\n state = None\\n self.run_probe(probe_name, f\\\"run{self._measurement_iteration_number}\\\", json.dumps(state))\\n while self._current_process is not None:\\n time.sleep(.01)\\n self._measurement_iteration_number += 1\",\n \"def run(self):\\n print('Starting CloudWatchLogsMonitor.')\\n\\n # Initialize pool for multithreading.\\n # Use ThreadPool for shared memory (used for keeping track of last polled timestamp)\\n pool = ThreadPool()\\n\\n while True:\\n\\n # Check for new LogGroups and LogStreams.\\n self.update()\\n\\n for log_group in self.log_groups:\\n # For every log group get and append log events to log file.\\n # This is run in parallel and is non-blocking.\\n pool.map_async(LogStream.get_and_append_log_events, log_group.log_streams)\\n\\n # These lines run the agent synchronously.\\n # You need to comment out the pool.map_async line above if using synchronous loop.\\n # for log_stream in log_group.log_streams:\\n # LogStream.get_and_append_log_events(log_stream)\\n\\n # Sleep for the polling interval.\\n time.sleep(self.default_polling_interval)\",\n \"def run(self):\\n while True:\\n try:\\n if not self._read_new_entries(False):\\n time.sleep(0.1)\\n self._update_all_tasks()\\n except KeyboardInterrupt:\\n break\",\n \"def run(self):\\n\\t\\tfor source in self.sources:\\n\\t\\t\\tstringutil.print_color(Fore.GREEN, 'Downloading from Source: %s' % source.get_alias())\\n\\t\\t\\tfor r in source.get_elements():\\n\\t\\t\\t\\tr.set_source(source)\\n\\t\\t\\t\\tself._queue.put(r)\\n\\n\\t\\t\\t\\t# Extra tracking stuff below:\\n\\t\\t\\t\\twith self._c_lock:\\n\\t\\t\\t\\t\\tself._total_count+= 1\\n\\t\\t\\t\\tif self._testing_cache is not None:\\n\\t\\t\\t\\t\\tself._testing_cache.append(r)\\n\\t\\t#print(\\\"Element loading complete.\\\\n\\\")\\n\\t\\tself._running = False\",\n \"def main():\\n run_test_summary1a()\\n run_test_summary1c()\\n run_test_summary1c()\",\n \"def _inst_run(self):\\r\\n self._inst_get_img_info_from_db()\\r\\n print(\\\"run method: \\\", time.ctime())\\r\\n th = threading.Timer(\\r\\n 10,\\r\\n self._inst_run\\r\\n )\\r\\n th.start()\",\n \"def run(self):\\n logging.info('running experiment...')\\n self._prepare()\\n self._load_data()\\n self._run()\\n self._evaluate()\\n self._summarise()\\n return True\",\n \"def run(self):\\n rate = rospy.Rate(self._run_rate)\\n while not rospy.is_shutdown():\\n try:\\n rate.sleep()\\n except:\\n break\",\n \"def run_extraction(self):\\n self.background_estimator = ReflectedRegionsBackgroundEstimator(\\n observations=self.observations, **self.config[\\\"background\\\"]\\n )\\n self.background_estimator.run()\\n\\n self.extraction = SpectrumExtraction(\\n observations=self.observations,\\n bkg_estimate=self.background_estimator.result,\\n **self.config[\\\"extraction\\\"]\\n )\\n\\n self.extraction.run()\",\n \"def run(self, item_callback=None):\\n self.item_callback = item_callback\\n logger.info('Starting consumer. Use CTRL+C to stop.')\\n while self.shards:\\n # time.sleep(0.5)\\n for shard in self.shards:\\n shard_id = shard['ShardId']\\n shard_iterator = self.get_iterator(shard)\\n self.process_records(shard_iterator, shard_id)\",\n \"def get_next_sample(self):\",\n \"def run_test_suite(self, test_config):\\n # Folder to store suite results\\n test_config['test_suite_start_time'] = datetime.datetime.now().strftime(\\n '%Y%m%dT%H%M%S')\\n\\n instance = cluster_local.UseLocalInstances()\\n for i in range(test_config['repeat']):\\n self.run_benchmark(test_config, instance, copy=i)\\n\\n suite_dir_name = '{}_{}'.format(test_config['test_suite_start_time'],\\n test_config['test_id'])\\n reporting.process_folder(\\n os.path.join(self.workspace, 'results', suite_dir_name),\\n report_config=self.auto_test_config)\",\n \"def start(self):\\n for trial in self._trials:\\n self._run(trial)\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def run(self) -> None:\\n\\n # Track the last timestamp we see. When we fetch_stream() again on the\\n # next iteration, we'll start from that timestamp onwards to avoid\\n # fetching every single page again. The last event or two will be\\n # still be in the response, but our de-duping will ignore those.\\n last_timestamp = None\\n\\n # Keep track of what log entries we've consumed so that we suppress\\n # duplicates. Duplicates will arise in our stream due to the way we\\n # watch for new entries.\\n consumed = set() # type: MutableSet\\n\\n # How many successful vs failed fetch_stream calls. If we consistently see\\n # failures but we never see a successful attempt, we should raise an exception\\n # and stop.\\n success_count = 0\\n failure_count = 0\\n\\n while not self.stopped.wait(0.2):\\n try:\\n for entry in fetch_stream(self.stream, start_time = last_timestamp):\\n if entry[\\\"eventId\\\"] not in consumed:\\n consumed.add(entry[\\\"eventId\\\"])\\n\\n last_timestamp = entry[\\\"timestamp\\\"]\\n\\n self.consumer(entry)\\n except (ClientError, BotocoreConnectionError):\\n failure_count += 1\\n if failure_count > MAX_FAILURES and not success_count:\\n raise\\n else:\\n success_count += 1\",\n \"def loop(self):\\n raise NotImplementedError()\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n # File format is single value per line with \\\"fieldname:\\\" prefix.\\n for x in stat_file:\\n fields = x.split()\\n if len(fields) == 0:\\n continue\\n if not collector:\\n collector = {}\\n if fields[0] == \\\"rchar:\\\":\\n collector.update({Metric(\\\"app.disk.bytes\\\", \\\"read\\\"): int(fields[1])})\\n elif fields[0] == \\\"syscr:\\\":\\n collector.update({Metric(\\\"app.disk.requests\\\", \\\"read\\\"): int(fields[1])})\\n elif fields[0] == \\\"wchar:\\\":\\n collector.update({Metric(\\\"app.disk.bytes\\\", \\\"write\\\"): int(fields[1])})\\n elif fields[0] == \\\"syscw:\\\":\\n collector.update({Metric(\\\"app.disk.requests\\\", \\\"write\\\"): int(fields[1])})\\n return collector\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6506419","0.64478827","0.6249575","0.6136713","0.6083549","0.60691047","0.5937353","0.5804329","0.5789543","0.5710799","0.5666293","0.56556666","0.5654352","0.5652799","0.5633741","0.5620311","0.5596868","0.55945826","0.5588704","0.5581774","0.5576543","0.55601287","0.55353713","0.5495253","0.54940134","0.5493805","0.5488754","0.54880697","0.5482203","0.5480609","0.5476581","0.54706526","0.54665756","0.5457175","0.54500777","0.5447955","0.54458994","0.5442869","0.5442835","0.54400146","0.54327804","0.54314846","0.543115","0.5418899","0.5393865","0.53914666","0.53805864","0.5379573","0.53787696","0.53787696","0.53763103","0.536841","0.5364883","0.53533584","0.5349396","0.53475714","0.53432274","0.53356504","0.53340316","0.533204","0.5329578","0.5322579","0.53221947","0.53221524","0.5320747","0.5315338","0.5315338","0.5313349","0.5312985","0.5309891","0.53010255","0.5293643","0.5279935","0.5277328","0.52767044","0.52741086","0.5267802","0.5258659","0.5256706","0.52564234","0.52531135","0.5243247","0.5241283","0.52326834","0.5231363","0.5230186","0.5226842","0.5226019","0.52216184","0.5221095","0.5212687","0.5212504","0.52097464","0.5200658","0.51927185","0.51906025","0.51906025","0.5189189","0.5186495","0.5176474"],"string":"[\n \"0.6506419\",\n \"0.64478827\",\n \"0.6249575\",\n \"0.6136713\",\n \"0.6083549\",\n \"0.60691047\",\n \"0.5937353\",\n \"0.5804329\",\n \"0.5789543\",\n \"0.5710799\",\n \"0.5666293\",\n \"0.56556666\",\n \"0.5654352\",\n \"0.5652799\",\n \"0.5633741\",\n \"0.5620311\",\n \"0.5596868\",\n \"0.55945826\",\n \"0.5588704\",\n \"0.5581774\",\n \"0.5576543\",\n \"0.55601287\",\n \"0.55353713\",\n \"0.5495253\",\n \"0.54940134\",\n \"0.5493805\",\n \"0.5488754\",\n \"0.54880697\",\n \"0.5482203\",\n \"0.5480609\",\n \"0.5476581\",\n \"0.54706526\",\n \"0.54665756\",\n \"0.5457175\",\n \"0.54500777\",\n \"0.5447955\",\n \"0.54458994\",\n \"0.5442869\",\n \"0.5442835\",\n \"0.54400146\",\n \"0.54327804\",\n \"0.54314846\",\n \"0.543115\",\n \"0.5418899\",\n \"0.5393865\",\n \"0.53914666\",\n \"0.53805864\",\n \"0.5379573\",\n \"0.53787696\",\n \"0.53787696\",\n \"0.53763103\",\n \"0.536841\",\n \"0.5364883\",\n \"0.53533584\",\n \"0.5349396\",\n \"0.53475714\",\n \"0.53432274\",\n \"0.53356504\",\n \"0.53340316\",\n \"0.533204\",\n \"0.5329578\",\n \"0.5322579\",\n \"0.53221947\",\n \"0.53221524\",\n \"0.5320747\",\n \"0.5315338\",\n \"0.5315338\",\n \"0.5313349\",\n \"0.5312985\",\n \"0.5309891\",\n \"0.53010255\",\n \"0.5293643\",\n \"0.5279935\",\n \"0.5277328\",\n \"0.52767044\",\n \"0.52741086\",\n \"0.5267802\",\n \"0.5258659\",\n \"0.5256706\",\n \"0.52564234\",\n \"0.52531135\",\n \"0.5243247\",\n \"0.5241283\",\n \"0.52326834\",\n \"0.5231363\",\n \"0.5230186\",\n \"0.5226842\",\n \"0.5226019\",\n \"0.52216184\",\n \"0.5221095\",\n \"0.5212687\",\n \"0.5212504\",\n \"0.52097464\",\n \"0.5200658\",\n \"0.51927185\",\n \"0.51906025\",\n \"0.51906025\",\n \"0.5189189\",\n \"0.5186495\",\n \"0.5176474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71581453"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":597,"cells":{"query":{"kind":"string","value":"Reads the metrics from the file and records them. Derived classes must override this method to perform the actual work of collecting their specific samples."},"document":{"kind":"string","value":"def gather_sample(self, my_file, collector=None):\n\n pass"},"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 read_metrics(self):\n raise NotImplementedError()","def setup_metrics_file(self):\n\n with open(self.metrics_path, \"w+\") as f_metrics:\n\n f_metrics.write(get_metrics_file_form())","def walk(self):\n data = open(self.data_file_path, 'rb')\n read_metric = globals()[\"ProtoDefinition\"].Payload()\n read_metric.ParseFromString(data.read())\n\n # One record for the whole file\n self.payload_metadata = read_metric.payloadMetadata\n self.device = read_metric.device\n\n # Get list of all *repeated* field types\n field_names = []\n for field_desc in read_metric.DESCRIPTOR.fields:\n field_name = field_desc.name\n\n if field_desc.label == field_desc.LABEL_REPEATED:\n field_names.append(field_name)\n\n # For each repeated field type, get the data and yield one item at a time\n for field_name in field_names:\n stream_samples = getattr(read_metric, field_name)\n for sample in stream_samples:\n yield self.device, sample","def gather_sample(self, stat_file, collector=None):\n\n # This file format is weird. Each set of stats is outputted in two\n # lines. First, a header line that list the field names. Then a\n # a value line where each value is specified in the appropriate column.\n # You have to match the column name from the header line to determine\n # what that column's value is. Also, each pair of lines is prefixed\n # with the same name to make it clear they are tied together.\n all_lines = stat_file.readlines()\n # We will create an array of all of the column names in field_names\n # and all of the corresponding values in field_values.\n field_names = []\n field_values = []\n\n # To simplify the stats, we add together the two forms of retransmit\n # I could find in the netstats. Those to fast retransmit Reno and those\n # to selective Ack.\n retransmits = 0\n found_retransmit_metric = False\n\n # Read over lines, looking at adjacent lines. If their row names match,\n # then append their column names and values to field_names\n # and field_values. This will break if the two rows are not adjacent\n # but I do not think that happens in practice. If it does, we just\n # won't report the stats.\n for i in range(0, len(all_lines) - 1):\n names_split = all_lines[i].split()\n values_split = all_lines[i + 1].split()\n # Check the row names are the same.\n if names_split[0] == values_split[0] and len(names_split) == len(\n values_split\n ):\n field_names.extend(names_split)\n field_values.extend(values_split)\n\n if not collector:\n collector = {}\n\n # Now go back and look for the actual stats we care about.\n for i in range(0, len(field_names)):\n if field_names[i] == \"InOctets\":\n collector.update({Metric(\"app.net.bytes\", \"in\"): field_values[i]})\n elif field_names[i] == \"OutOctets\":\n collector.update({Metric(\"app.net.bytes\", \"out\"): field_values[i]})\n elif field_names[i] == \"TCPRenoRecovery\":\n retransmits += int(field_values[i])\n found_retransmit_metric = True\n elif field_names[i] == \"TCPSackRecovery\":\n retransmits += int(field_values[i])\n found_retransmit_metric = True\n\n # If we found both forms of retransmit, add them up.\n if found_retransmit_metric:\n collector.update({Metric(\"app.net.tcp_retransmits\", None): retransmits})\n return collector","def gather_sample(self, stat_file, collector=None):\n if not collector:\n collector = {}\n # The file format is just a single line of all the fields.\n line = stat_file.readlines()[0]\n # Chop off first part which is the pid and executable file. The\n # executable file is terminated with a paren so just search for that.\n line = line[(line.find(\") \") + 2) :]\n fields = line.split()\n # Then the fields we want are just at fixed field positions in the\n # string. Just grab them.\n\n # See http://man7.org/linux/man-pages/man5/proc.5.html for reference on field numbers\n # Keep in mind that we chop first 3 values away (pid, command line, state), so you need to\n # subtract 3 from the field numbers from the man page (e.g. on the man page nice is number\n # 19, but in our case it's 16 aka 19 - 3)\n process_uptime = self.__get_uptime_ms() - self.calculate_time_ms(\n int(fields[19])\n )\n\n collector.update(\n {\n Metric(\"app.cpu\", \"user\"): self.__calculate_time_cs(int(fields[11])),\n Metric(\"app.cpu\", \"system\"): self.__calculate_time_cs(int(fields[12])),\n Metric(\"app.uptime\", None): process_uptime,\n Metric(\"app.nice\", None): float(fields[16]),\n Metric(\"app.threads\", None): int(fields[17]),\n Metric(\"app.mem.majflt\", None): int(fields[9]),\n Metric(\"app.io.wait\", None): int(fields[39])\n if len(fields) >= 39\n else 0,\n }\n )\n return collector","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n # File format is single value per line with \"fieldname:\" prefix.\n for x in stat_file:\n fields = x.split()\n if len(fields) == 0:\n continue\n if not collector:\n collector = {}\n if fields[0] == \"rchar:\":\n collector.update({Metric(\"app.disk.bytes\", \"read\"): int(fields[1])})\n elif fields[0] == \"syscr:\":\n collector.update({Metric(\"app.disk.requests\", \"read\"): int(fields[1])})\n elif fields[0] == \"wchar:\":\n collector.update({Metric(\"app.disk.bytes\", \"write\"): int(fields[1])})\n elif fields[0] == \"syscw:\":\n collector.update({Metric(\"app.disk.requests\", \"write\"): int(fields[1])})\n return collector","def gather_sample(self):\n\n for _pid in self._select_processes():\n if not self.__trackers.get(_pid):\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\n\n self._reset_absolute_metrics()\n\n for _tracker in self.__trackers.values():\n _metrics = _tracker.collect()\n self.record_metrics(_tracker.pid, _metrics)\n\n self._calculate_aggregated_metrics()\n self._remove_dead_processes()\n\n self.print_metrics()","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n for line in stat_file:\n # Each line has a format of:\n # Tag: Value\n #\n # We parse out all lines looking like that and match the stats we care about.\n m = re.search(r\"^(\\w+):\\s*(\\d+)\", line)\n if m is None:\n continue\n\n field_name = m.group(1)\n int_value = int(m.group(2))\n # FDSize is not the same as the number of open file descriptors. Disable\n # for now.\n # if field_name == \"FDSize\":\n # self.print_sample(\"app.fd\", int_value)\n if field_name == \"VmSize\":\n collector.update({Metric(\"app.mem.bytes\", \"vmsize\"): int_value * 1024})\n elif field_name == \"VmPeak\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_vmsize\"): int_value * 1024}\n )\n elif field_name == \"VmRSS\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"resident\"): int_value * 1024}\n )\n elif field_name == \"VmHWM\":\n collector.update(\n {Metric(\"app.mem.bytes\", \"peak_resident\"): int_value * 1024}\n )\n return collector","def collect_samples(self):\n self.__running = True\n with open(self.__filename, 'a') as output:\n next_sample_time = time.time()\n while self.__running:\n sensor_name = self.__sensor.get_sensor_type_name()\n sensor_id = self.__sensor.get_sensor_id()\n data = self.__sensor.retrieve_data_string() \n if DEBUG:\n print('data: \"{}\"'.format(data),\n file = sys.stderr, flush=True)\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\n result = OUTPUT_FORMAT.format(when,\n sensor_name, \n sensor_id, \n data)\n output.write(result)\n output.flush()\n \n next_sample_time = next_sample_time + self.__interval\n delay_time = next_sample_time - time.time()\n if DEBUG:\n print('delay_time = {}'.format(delay_time),\n file=sys.stderr, flush=True)\n \n if 0 < delay_time: # don't sleep if already next sample time\n time.sleep(delay_time)","def read(self):\n self.record_d = {}\n if self.__read_file():\n self.__print_report()","def gather_sample(self, stat_file, collector=None):\n\n if not collector:\n collector = {}\n\n for line in stat_file:\n # We just look for the different \"inuse\" lines and output their\n # socket type along with the count.\n m = re.search(r\"(\\w+): inuse (\\d+)\", line)\n if m is not None:\n collector.update(\n {\n Metric(\"app.net.sockets_in_use\", m.group(1).lower()): int(\n m.group(2)\n )\n }\n )\n return collector","def add_stats(self):\n units = self.get_unit_map()\n for metric in self.raw_metrics:\n unit, metric_type = units.get(metric, (DEFAULT_UNIT, DEFAULT_TYPE))\n if metric_type == \"counter\":\n # Unit/Second\n unit = \"/\".join((unit, \"Second\"))\n self.add_derive_value(metric, unit, self.raw_metrics[metric], rate=True)\n else:\n self.add_gauge_value(metric, unit, self.raw_metrics[metric])","def record_metrics(metrics, args):\n with open('interpretation_metrics/model_metrics_{}'.format(args.file_num), 'a') as f:\n f.write(\"META DATA\\n\")\n f.write(\"---------\\n\")\n f.write(\"Model Name: {}\\n\".format(args.model_name))\n f.write(\"Attack Target: {}\\n\".format(args.attack_target))\n f.write(\"Gradient Model File: {}\\n\".format(args.gradient_model_file))\n f.write(\"Predictive Model File: {}\\n\".format(args.predictive_model_file))\n f.write(\"Cuda: {}\\n\".format(args.cuda))\n\n f.write(\"\\nSIMPLE GRADIENT COMBINED MODEL METRICS\\n\")\n f.write(\"----------------------------------------\\n\")\n for key, val in metrics['simple_gradient_combined'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))\n\n f.write(\"\\nSIMPLE GRADIENT BASELINE MODEL METRICS\\n\")\n f.write(\"----------------------------------------\\n\")\n for key, val in metrics['simple_gradient_baseline'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))\n\n f.write(\"\\nSMOOTH GRADIENT COMBINED MODEL METRICS\\n\")\n f.write(\"----------------------------------------\\n\")\n for key, val in metrics['smooth_gradient_combined'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))\n\n f.write(\"\\nSMOOTH GRADIENT BASELINE MODEL METRICS\\n\")\n f.write(\"----------------------------------------\\n\")\n for key, val in metrics['smooth_gradient_baseline'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))\n\n f.write(\"\\nINTEGRATED GRADIENT COMBINED MODEL METRICS\\n\")\n f.write(\"--------------------------------------------\\n\")\n for key, val in metrics['integr_gradient_combined'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))\n\n f.write(\"\\nINTEGRATED GRADIENT BASELINE MODEL METRICS\\n\")\n f.write(\"--------------------------------------------\\n\")\n for key, val in metrics['integr_gradient_baseline'].items():\n f.write(\"{}: {:.3f}\\n\".format(key, val))","def load_data(self, f): \n self.sampling = True\n self.reads = np.load(f)\n self.total = self.reads.shape[0]","def record_custom_metrics(self, metrics):\n\n if not self.__settings:\n return\n\n for name, value in metrics:\n self.record_custom_metric(name, value)","def run_resample(self):\n\n self.in_data.open()\n self.out_data.open()\n\n try:\n # Get the fields from the input file and set them/write headers in output:\n self.all_fields = self.in_data.fields\n\n self.out_data.set_fields(self.all_fields)\n self.out_data.write_headers()\n\n # Set up the sensor fields by removing non-sensor fields:\n self.set_sensor_only_fields()\n\n # Read the first event from the input file:\n self.get_next_input_event()\n\n # Warn and exit if we have no input data to read:\n if self.next_input_event is None:\n msg = f\"The input file {self.in_file} did not have any data rows\"\n warn(msg)\n\n return\n\n self.first_event_stamp = self.next_input_event[self.stamp_field]\n\n # Set up the sample tracking (here mostly to set the start of the first interval):\n self.reset_sample_tracking()\n\n # Now iterate through the output intervals:\n while True:\n self.process_next_interval()\n except EOFError: # catch when we are at the end of the file\n pass\n finally:\n self.in_data.close()\n self.out_data.close()\n\n print() # make sure we go to a new output line","def send_metrics(self):\n metrics = self.get_metrics()\n if not metrics:\n return\n\n for mkey, metric in metrics.items():\n for mname, mval in metric.items():\n try:\n self.agent.record_custom_metric(self.convert_metric_name(mkey, mname), mval, None)\n except Exception as e:\n print_(e)","def metrics(self):\n raise NotImplementedError(\"metrics\")","def parse_metrics_file(self) -> Dict[int, dict]:\n LOG.info(\"Parsing Dragen demultiplexing adapter metrics file %s\", self.adapter_metrics_path)\n parsed_metrics = {}\n\n with self.adapter_metrics_path.open(\"r\") as metrics_file:\n metrics_reader = csv.DictReader(metrics_file)\n for row in metrics_reader:\n lane = int(row[\"Lane\"])\n read_number = row[\"ReadNumber\"]\n sample_id = row[\"Sample_ID\"]\n parsed_metrics[lane] = parsed_metrics.get(lane, {})\n parsed_metrics[lane][(read_number, sample_id)] = row\n\n return self.summerize_adapter_metrics(parsed_metrics=parsed_metrics)","def parse_file(self):\n # the header was already read in the init, start at the first sample line\n\n for line in self._stream_handle:\n\n # create the dictionary of key/value pairs composed of the labels and the values from the\n # record being parsed\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\n data_dict = self._read_data(line)\n\n if GliderParser._has_science_data(data_dict, self._particle_class):\n # create the timestamp\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\n # create the particle\n self._record_buffer.append(self._extract_sample(\n self._particle_class, None, data_dict, internal_timestamp=timestamp))","def __init__(self, metrics_to_record):\n self.tape = {}\n\n for metric_name in metrics_to_record:\n self.tape[metric_name] = []","def sample(self):\n logger.info(\"%s: collect sensor data\", self.__class__.__name__)\n samples = []\n self._fetch_data(samples)\n return samples","def read_data(self):\n self.data = reduce_spectrum(self.filename)","def collect_metrics(grouped_samples, projroot, tgtdir, ext, grouping=\"sample\"):\n metrics = []\n for item_id, itemlist in grouped_samples.items():\n item = itemlist[0]\n # FIXME: tgtdir should be docroot!\n pfx = os.path.relpath(itemlist[0].prefix(grouping), os.path.dirname(tgtdir))\n mfile = glob.glob(pfx + \".*\" + ext)\n if mfile:\n metrics.append((item_id, mfile[0]))\n return PicardMetricsCollection(metrics)","def train(self, counts_file):\n for l in read_counts(counts_file):\n n, count_type, args = int(l[0]), l[1], l[2:]\n if count_type == 'WORDTAG': # emission counts\n self.emission_counts[tuple(args)] = n\n else: # ngram counts\n self.ngram_counts[len(args) - 1][tuple(args)] = n","def compute_metrics(self):\n pass","def readFile(self, fname):\r\n self.scores = []\r\n self.fname = fname\r\n try:\r\n with open(fname, 'r') as f:\r\n for line in f:\r\n self.appendScore(line.split(' '))\r\n except:\r\n pass","def read(self, filename):\n with RavenFileReader(filename) as f:\n line = f.nexttag()\n while line:\n # Begin data type checks\n if self.cleantag(line) == 'Gauge':\n self.read_metgauge(line, f)\n elif self.cleantag(line) == 'ObservationData':\n self.read_obsgauge(line, f)\n # Next line\n line = f.nexttag()","def load_sample(self):\n\n self.load_images(self.folder + \"/sampleSet.txt\")\n self.load_traces(self.folder + \"/sampleLabel.txt\")","def __init_metrics(self):\n\n batch = {}\n # split data into batches of size batch_size or less\n for metric_name, metric_pattern in self.metrics.items():\n # get the batch list for that metric\n batch_list = []\n for s in range(1, self.schema + 1):\n for t in range(1, self.table + 1):\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\n batch[k] = 0\n # if the batch has batch_size items or at the end of iteration,\n # append the batch to list of that metric and create a new empty batch\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\n batch_list.append(batch)\n batch = {}\n\n # parse metric patterns\n l = metric_pattern.split()\n if l[0] == '(>':\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\n batch_list)\n else:\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)","def metrics(self, metrics):\n\n self._metrics = metrics","def parse_file(self):\n # read the first line in the file\n line = self._stream_handle.readline()\n\n while line:\n # check for a data line or a dcl logger line we specifically ignore\n data_match = DATA_LINE_MATCHER.match(line)\n ignore_match = IGNORE_LINE_MATCHER.match(line)\n\n if data_match:\n # found a data line, extract this particle\n # DCL controller timestamp is the port_timestamp\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\n\n particle = self._extract_sample(self.particle_class,\n None,\n data_match,\n port_timestamp=port_timestamp,\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\n\n self._record_buffer.append(particle)\n\n elif not ignore_match:\n # we found a line with an unknown format, call an exception\n error_message = 'Found line with unknown format %s' % line\n log.warn(error_message)\n self._exception_callback(SampleException(error_message))\n\n # read the next line\n line = self._stream_handle.readline()","def __init__(self, file_name: str):\n self.case_metrics = []\n self.cluster_metrics = []\n self.file_name = file_name\n\n self.path_to_pmg_metrics = f'metrics/{file_name}_process_model_graphs'\n self.path_to_pmg_vis = f'visualization/{file_name}_process_model_graphs'\n self.path_to_drifts = 'visualization/drifts'\n self.path_to_case_metrics = 'metrics/case_metrics'\n self.path_to_cluster_metrics = 'metrics/cluster_metrics'\n try:\n makedirs(self.path_to_pmg_metrics, exist_ok=True)\n makedirs(self.path_to_pmg_vis, exist_ok=True)\n makedirs(self.path_to_drifts, exist_ok=True)\n makedirs(self.path_to_case_metrics, exist_ok=True)\n makedirs(self.path_to_cluster_metrics, exist_ok=True)\n\n pd.DataFrame(columns=['stream_index', 'timestamp', 'check point', 'case',\n 'graph distance', 'time distance', 'label']) \\\n .to_csv(f'{self.path_to_case_metrics}/{file_name}.csv', index=False)\n pd.DataFrame(columns=['stream_index', 'timestamp', 'check point', 'cluster id',\n 'x', 'y', 'radius', 'weight', 'cluster type']) \\\n .to_csv(f'{self.path_to_cluster_metrics}/{file_name}.csv', index=False)\n except Exception as e:\n print(e)","def possible_metrics(filename):\n\n metrics = {}\n\n raw_data = parse_config(filename)\n\n for graph in raw_data:\n for metric in graph['metrics']:\n metrics.update({metric['label']: [(metric['x_stream'], metric['y_stream'], metric['z_stream']), metric['func']]})\n\n return metrics","def collect_stats(self, cursor):\n metrics = self.config.get('metrics', DEFAULT_METRICS)\n if isinstance(metrics, str):\n if metrics == \"all\":\n # puffer_pool_status is only for 5.5, so we ignore that by default\n metrics = CATEGORIES.keys()\n metrics.remove('buffer_pool_stats')\n else:\n # support comma-separated list\n metrics = re.split(\"\\s*,\\s*\", metrics)\n\n self.logger.debug(\"metrics to collect: %s\" % \", \".join(metrics))\n for cat in metrics:\n if cat in CATEGORIES:\n self.add_category_stats(cat, cursor)\n else:\n self.logger.warning(\"%s is not a valid metric category\" % cat)\n\n if 'newrelic' in metrics:\n self.derive_newrelic_stats()","def populate_list(self, input_filename):\r\n f = open(input_filename, 'r')\r\n\r\n for line in f:\r\n # Process the input line\r\n line_split = line.strip().split('(')\r\n line_split[-1] = line_split[-1][:-1] # Removes the extra bracket at the end\r\n\r\n class_name = line_split[0]\r\n parameters = line_split[1].split(',')\r\n self.metrics.append(self.instantiate_class(class_name, *parameters))\r\n\r\n f.close()","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 = FILE_NAME_MATCHER.match(input_file_name)\n\n if match:\n file_time = match.group(1)\n else:\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\n % input_file_name\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the first line in the file\n line = self._stream_handle.readline()\n\n # loop over all lines in the data file\n while line:\n\n if EMPTY_LINE_MATCHER.match(line):\n # ignore blank lines, do nothing\n pass\n\n elif HEADER_MATCHER.match(line):\n\n # we need header records to extract useful information\n for matcher in HEADER_MATCHER_LIST:\n header_match = matcher.match(line)\n\n if header_match is not None:\n\n # Look for specific header lines and extract header fields\n if matcher is DIR_FREQ_MATCHER:\n num_dir = int(header_match.group(1))\n num_freq = int(header_match.group(2))\n\n elif matcher is FREQ_BAND_MATCHER:\n freq_w_band = header_match.group(1)\n freq_0 = header_match.group(2)\n\n elif matcher is START_DIR_MATCHER:\n start_dir = header_match.group(1)\n\n else:\n #ignore\n pass\n\n elif DSPEC_DATA_MATCHER.match(line):\n\n # Extract a row of the Directional Surface Spectrum matrix\n sensor_match = DSPEC_DATA_MATCHER.match(line)\n data = sensor_match.group(1)\n values = [int(x) for x in data.split()]\n\n num_values = len(values)\n\n # If the number of values in a line of data doesn't match num_dir,\n # Drop the record, throw a recoverable exception and continue parsing\n if num_values != num_dir:\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\n % (num_dir, num_values)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n else:\n # Add the row to the dspec matrix\n dspec_matrix.append(values)\n\n else:\n # Generate a warning for unknown data\n error_message = 'Unexpected data found in line %s' % line\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the next line in the file\n line = self._stream_handle.readline()\n\n # Check to see if the specified number of frequencies were retrieved from the data\n dspec_matrix_length = len(dspec_matrix)\n if dspec_matrix_length != num_freq:\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\n % (num_freq, dspec_matrix_length)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\n parsed_data = [\n file_time, # ('file_time', 0, str),\n num_dir, # ('num_dir', 1, int),\n num_freq, # ('num_freq', 2, int),\n freq_w_band, # ('freq_w_band', 3, float),\n freq_0, # ('freq_0', 4, float),\n start_dir, # ('start_dir', 5, float),\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\n ]\n\n # Extract a particle and append it to the record buffer\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\n self._record_buffer.append(particle)","def collect(self):\n if not self._btime:\n return\n\n try:\n with open(\"/proc/self/stat\", 'rb') as stat:\n parts = (stat.read().split(b')')[-1].split())\n\n self.process_metrics[\"vmem\"].set(\"\", float(parts[20]))\n self.process_metrics[\"rss\"].set(\"\", float(parts[21]) * _PAGESIZE)\n start_time_secs = float(parts[19]) / self._ticks\n self.process_metrics[\"start_time\"].set(\n \"\", start_time_secs + self._btime\n )\n utime = float(parts[11]) / self._ticks\n stime = float(parts[12]) / self._ticks\n self.process_metrics[\"cpu\"].set(\"\", utime + stime)\n except IOError:\n pass\n\n try:\n with open(\"/proc/self/limits\", 'rb') as limits:\n for line in limits:\n if line.startswith(b'Max open file'):\n self.process_metrics[\"max_fds\"].set(\n \"\", float(line.split()[3])\n )\n break\n\n self.process_metrics[\"open_fds\"].set(\n \"\", float(len(os.listdir(\"/proc/self/fd\")))\n )\n except (IOError, OSError):\n pass\n\n # Update gc metrics if enabled.\n if \"collected\" in self.process_metrics:\n for generation, stat in enumerate(gc.get_stats()):\n generation = {\"generation\": str(generation)}\n self.process_metrics[\"collected\"].set(\n generation, stat[\"collected\"]\n )\n self.process_metrics[\"uncollectable\"].set(\n generation, stat[\"uncollectable\"]\n )\n self.process_metrics[\"collections\"].set(\n generation, stat[\"collections\"]\n )","def record_apdex_metrics(self, metrics):\n\n if not self.__settings:\n return\n\n for metric in metrics:\n self.record_apdex_metric(metric)","def get_data():\n \n data = {\n 'loadAvg1Min': 0, #load average 1 min\n 'loadAvg5Min': 0, #load average 5 min\n 'loadAvg15Min': 0, #load average 15 min\n 'cpuUsage': [], #usage distribution for each cpu\n 'memUsage': {}, #memory usage \n 'networkReads': [], #network reads per second for each interface\n 'networkWrites': [], #network writes per second for each interface\n 'diskReads': [], #disk reads per second for each disk\n 'diskWrites': [] #disk writes per second for each disk\n }\n \n #metrics that doesnt need sampling\n data['loadAvg1Min'], data['loadAvg5Min'], data['loadAvg15Min'] = get_load_avg() #get load avg\n data['memUsage'].update(get_mem_usage()) #memory usage\n \n #metrics that needs sampling\n #they are written as a generator so that we can sleep before collection again\n sampling_duration = 1\n cpu_usage_gen = get_cpu_usage(sampling_duration) #generator for cpu usage\n net_rw_gen = get_net_rw(sampling_duration) #generator for network read write\n disk_rw_gen = get_disk_rw(sampling_duration) #generator for disk read write\n \n while 1: #now start sampling, whenever we have walid data, we can exit the loop\n cpu_usage = next(cpu_usage_gen)\n net_rw = next(net_rw_gen)\n disk_rw = next(disk_rw_gen)\n \n if cpu_usage or net_rw or disk_rw: #we have valid data\n break\n \n time.sleep(sampling_duration)\n \n #append cpu usage for each cpu core\n for cpu, usage in cpu_usage.items():\n data['cpuUsage'].append({'name': cpu, 'value': usage})\n \n #append network read and write for each interface\n for interface, rw in net_rw.items():\n data['networkReads'].append({'name': interface, 'value': rw['reads']})\n data['networkWrites'].append({'name': interface, 'value': rw['writes']}) \n \n #append disk read and write for each logical disk\n for device, rw in disk_rw.items():\n data['diskReads'].append({'name': device, 'value': rw['reads']})\n data['diskWrites'].append({'name': device, 'value': rw['writes']})\n \n return data","def _load(self):\n op_type_file_path = os.path.join(\n self._profiling_dir,\n self._csv_file_to_analyse.format(self._device_id)\n )\n op_type_file_path = validate_and_normalize_path(\n op_type_file_path, raise_key=\"Invalid op_type_file_path\")\n if not os.path.isfile(op_type_file_path):\n log.warning('The file <%s> does not exist.', op_type_file_path)\n return\n\n with open(op_type_file_path, 'r') as file:\n csv_reader = csv.reader(file)\n _ = next(csv_reader)\n for info in csv_reader:\n self._data.append(self._convert_field_type(info))","def samples(self):\n pass","def calculate_batch_metrics(self):\n pass","def make_metrics(self):\n num_batches = self.data_loader.number_of_batches()\n dose_score_vec = np.zeros(num_batches)\n\n # Only make calculations if data_loader is not empty\n if not self.data_loader.file_paths_list:\n print('No patient information was given to calculate metrics')\n else:\n # Change batch size to 1\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\n if self.dose_loader is not None:\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\n\n for idx in tqdm.tqdm(range(num_batches)):\n # Get roi masks for patient\n self.get_constant_patient_features(idx)\n # Get dose tensors for reference dose and evaluate criteria\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\n if reference_dose is not None:\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\n # If a dose loader was provided, calculate the score\n if self.dose_loader is not None:\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\n # Make metric data frames\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\n # Evaluate mean absolute error of 3D dose\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\n # their files\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\n\n if self.dose_loader is not None:\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\n dose_score = dose_score_vec.mean()\n return dvh_score, dose_score\n else:\n print('No new dose provided. Metrics were only calculated for the provided dose.')","def set_metrics(self):","def start_monitor_loop(self):\n read_file = read_config_file.ConfigFileReader()\n\n communication_time = read_file.get_send_communication_time()\n metrics_array = read_file.get_metrics()\n\n self.add_metrics_to_monitor_object(communication_time, metrics_array)","def calculate_dataset_metrics(self):\n pass","def metrics(self):\n\n data = requests.get(\n f\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\"\n ).content.decode()\n lines = [line for line in data.split(\"\\n\") if not line.startswith(\"#\")]\n metrics = {}\n for line in lines:\n if not line:\n continue\n\n name, value = line.split(\" \")\n\n try:\n value = int(value) # type: ignore\n except ValueError:\n value = float(value) # type: ignore\n\n if \"{\" in name and \"}\" in name:\n base = name[: name.index(\"{\")]\n tags = name[name.index(\"{\") + 1 : -1]\n tags = [tag.split(\"=\") for tag in tags.split(\",\")]\n tags = [(key, val.replace('\"', \"\")) for key, val in tags]\n\n name = base + \"#\" + \",\".join(f\"{k}:{v}\" for k, v in sorted(tags))\n\n metrics[name] = value\n\n return metrics","def _read_samples(self):\n\n logging.debug(\"Start file parsing.\")\n data = pd.read_csv(self._source_file, header=None)\n \n data = pd.read_csv(self._source_file, header=None)\n header = pd.read_csv(self._header_file, delimiter=':', skiprows=1, header=None)\n header.columns = ['column', 'column_type']\n\n data.columns = header.column.tolist() + ['attack']\n data['attack'] = data['attack'].str.replace('.', '')\n data['label'] = 1\n data.loc[data['attack'] == 'normal', 'label'] = 0\n\n symbolic_columns = header.loc[header.column_type == ' symbolic.'].column.tolist()\n # print(symbolic_columns)\n\n for scol in symbolic_columns:\n data[scol] = pd.Categorical(data[scol])\n one_hot_cols = pd.get_dummies(data[scol], prefix=scol)\n data = pd.concat([data, one_hot_cols], axis=1)\n\n data = data.drop(columns=symbolic_columns)\n data = data.drop(columns=['attack'])\n\n # data.loc[data.attack != 'normal' , ['attack', 'label']].head(20)\n\n data_normal = data.loc[data['label'] == 0]\n data_abnormal = data.loc[data['label'] == 1]\n\n data_normal_train = data_normal.sample(frac=0.7)\n data_normal_test = data_normal.loc[~data_normal.index.isin(data_normal_train.index)]\n\n data_normal_train = data_normal_train.drop(columns=['label']).values\n data_normal_test = data_normal_test.drop(columns=['label']).values\n data_abnormal = data_abnormal.drop(columns=['label']).values\n \n scaler = MinMaxScaler()\n _ = scaler.fit(data_normal_train)\n data_normal_train = scaler.transform(data_normal_train)\n data_normal_test = scaler.transform(data_normal_test)\n data_abnormal = scaler.transform(data_abnormal)\n \n logging.debug('Normal {}; Train {}; Test{}'.format(data_normal.shape, data_normal_train.shape, data_normal_test.shape))\n logging.debug('Abnormal {}'.format(data_abnormal.shape))\n\n samples = {}\n samples['NORMAL'] = data_normal_train\n samples['NORMAL_TEST'] = data_normal_test\n samples['ABNORMAL_TEST'] = data_abnormal\n\n logging.debug(\"End file parsing.\")\n\n return samples","def dataStats(self):\n print (\"Performing statistical analysis of the data\")\n # stuff to do","def __parse(self):\n lines = self.file.readlines()\n for i in range(0, len(lines)):\n line = lines[i]\n tokens = line.split()\n if tokens[0] == \"#start\":\n trial_name = tokens[1]\n trial = Trial(trial_name)\n self.trials[trial_name] = trial\n elif tokens[0] == \"#end\":\n continue\n else:\n date_str = tokens[0] + \" \" + tokens[1]\n date = datetime.strptime(date_str, \"%m/%d/%y %H:%M:%S\")\n sound_file = line[18:-1].strip()\n event = Event(date, sound_file, 0)\n trial.addevent(event)","def add_metrics(self, metrics):\n for i, metric in enumerate(self.config.metrics):\n tf.summary.scalar(metric, metrics[i])","def load_data(self):\n logging.debug('Loading data from file ({})...'.format(self.file_name))\n parsed_data = list()\n with open(self.file_name) as file_data:\n for line in file_data.readlines():\n temp = dict()\n if 'JD' in line:\n continue\n line = line.split()\n temp['ts'], temp['mag'], temp['dif'] = float(line[0][:14]), float(line[1]), float(line[2])\n temp['f_mag'] = self.kalman_filter(temp['mag'])\n temp['dt'] = self.jd_to_datetime(temp['ts'])\n temp['dt_cor'] = self.jd_to_datetime(temp['ts'] - TIME_CRT)\n parsed_data.append(temp)\n logging.debug(' {} records loaded.'.format(len(parsed_data)))\n logging.debug(parsed_data[0])\n self.data_stream = parsed_data","def _read_log(self):\n\n line_regex = compile(r\"\\[I\\]\\s*\\(\\d+ms\\)[^\\d]+(?P<counter>\\d+)\"\n r\"[^\\d]+(?P<timestamp>\\d+(\\.\\d+)?)[^\\d]+\"\n r\"(?P<acceleration>\\d+);\")\n values = []\n with open(self.filepath) as file:\n for line in file:\n match = line_regex.match(line)\n if match:\n values.append({\n 'counter':\n int(match['counter']),\n 'timestamp':\n int(float(match['timestamp']) * 1000),\n 'acceleration':\n int(match['acceleration'])\n })\n\n self.values = values","def write_training_metrics(self) -> None:\n self.trainer_metrics.write_training_metrics()","def getUnscaledSamples(self, **kwargs) -> TimeData:\n # initialise chans, startSample and endSample with the whole dataset\n options = self.parseGetDataKeywords(kwargs)\n\n # get the files to read and the samples to take from them, in the correct order\n dataFilesToRead, samplesToRead, scalings = self.getDataFilesForSamples(\n options[\"startSample\"], options[\"endSample\"]\n )\n numSamples = options[\"endSample\"] - options[\"startSample\"] + 1\n # set up the dictionary to hold the data\n data = {}\n for chan in options[\"chans\"]:\n data[chan] = np.zeros(shape=(numSamples), dtype=self.dtype)\n\n # loop through chans and get data\n sampleCounter = 0\n for dFile, sToRead, scalar in zip(dataFilesToRead, samplesToRead, scalings):\n # get samples - this is inclusive\n dSamples = sToRead[1] - sToRead[0] + 1\n # spam files always record 5 channels\n dSamplesRead = dSamples * self.recChannels[dFile]\n # read the data\n byteOff = (\n self.dataByteOffset[dFile]\n + sToRead[0] * self.recChannels[dFile] * self.dataByteSize\n )\n dFilePath = os.path.join(self.dataPath, dFile)\n dataRead = np.memmap(\n dFilePath,\n dtype=self.dtype,\n mode=\"r\",\n offset=byteOff,\n shape=(dSamplesRead),\n )\n # now need to unpack this\n for chan in options[\"chans\"]:\n # check to make sure channel exists\n self.checkChan(chan)\n # get the channel index - the chanIndex should give the right order in the data file\n # as it is the same order as in the header file\n chanIndex = self.chanMap[chan]\n # use the range sampleCounter -> sampleCounter + dSamples, because this actually means sampleCounter + dSamples - 1 as python ranges are not inclusive of the end value\n # scale by the lsb scalar here - note that these can be different for each file in the run\n data[chan][sampleCounter : sampleCounter + dSamples] = (\n dataRead[chanIndex : dSamplesRead : self.recChannels[dFile]]\n * scalar[chan]\n )\n # increment sample counter\n sampleCounter = sampleCounter + dSamples # get ready for the next data read\n\n # return data\n startTime, stopTime = self.sample2time(\n options[\"startSample\"], options[\"endSample\"]\n )\n comments = []\n comments.append(\n \"Unscaled data {} to {} read in from measurement {}, samples {} to {}\".format(\n startTime,\n stopTime,\n self.dataPath,\n options[\"startSample\"],\n options[\"endSample\"],\n )\n )\n comments.append(\"Data read from {} files in total\".format(len(dataFilesToRead)))\n comments.append(\n \"Data scaled to mV for all channels using scalings in header files\"\n )\n comments.append(\"Sampling frequency {}\".format(self.getSampleFreq()))\n return TimeData(\n sampleFreq=self.getSampleFreq(),\n startTime=startTime,\n stopTime=stopTime,\n data=data,\n comments=comments,\n )","def save_case_metrics_on_check_point(self) -> None:\n pd.read_csv(f'{self.path_to_case_metrics}/{self.file_name}.csv')\\\n .append(pd.DataFrame(self.case_metrics,\n columns=['stream_index', 'timestamp', 'check point', 'case',\n 'graph distance', 'time distance', 'label']))\\\n .to_csv(f'{self.path_to_case_metrics}/{self.file_name}.csv', index=False)\n self.case_metrics = []","def read_file(self):\n # This is quite ugly but works for now.\n self.header = read_csv(self.file_name, delim_whitespace=True,\n header=TrackData.header_line,\n nrows=1).to_dict(orient='index')[0]\n self.data = read_csv(self.file_name, delim_whitespace=True, \n header=TrackData.data_line)","def qc_metrics(self, files_in, qc_files):\n self.cmd(\"{samtools} index {bam_in}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in=files_in[0],\n ),\n shell=True)\n self.cmd(\"{samtools} idxstats {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[0],\n ),\n shell=True,\n log_output=True)\n self.cmd(\"{samtools} flagstat {bam_in} | tee {qc_file}\"\n .format(\n samtools=self.cmds[\"samtools\"],\n bam_in = files_in[0],\n qc_file = qc_files[1],\n ),\n shell=True,\n log_output=True)\n \n self.checkpoint(qc_files[0])\n self.checkpoint(qc_files[1])\n self.checkpoint(qc_files[2])","def process_file(self, file_path: str) -> None:\n signal = self._loader(file_path)\n if self._is_padding_necessary(signal):\n signal = self._apply_padding(signal)\n feature = self._logspectogramextractor(signal)\n norm_feature = self._normalize(feature)\n if self._no_nan(norm_feature):\n file_name = self._save_feature(norm_feature, file_path)\n self._store_min_max_value(file_name, feature.min(), feature.max())","def metrics(self):\n self.metrics = []\n \n self.clients()\n\n if len(self.metrics) > 0:\n return self.metrics\n else:\n return []","def read_metric_values(self):\n inv_objs = self._inventory_mgr.current_inventory()\n monitored_metrics = self._metric_mgr.get_monitored_metrics()\n perf_manager = self._si.RetrieveServiceContent().perfManager\n for mor in inv_objs.keys():\n for inv_obj in inv_objs[mor]:\n inv_obj_metrics = inv_obj.metric_id_map\n desired_keys = list(set(inv_obj_metrics.keys()) & set(monitored_metrics[mor].keys()))\n if not len(desired_keys) == 0:\n metric_id_objs = [inv_obj_metrics[key] for key in desired_keys]\n query_spec = vim.PerformanceManager.QuerySpec(\n entity=inv_obj.mor, metricId=metric_id_objs,\n intervalId=inv_obj.INSTANT_INTERVAL,\n maxSample=1, format='normal'\n )\n try:\n results = perf_manager.QueryPerf(querySpec=[query_spec])\n except Exception as e:\n self._logger.error(\"Exception while making performance query : {0}\".format(e))\n if results:\n dps = self._parse_query(inv_obj, results, monitored_metrics[mor])\n payload = self._build_payload(dps)\n self._dispatch_metrics(payload)\n else:\n self._logger.warning(\"Empty result from query : {0}\".format(query_spec))","def read_callback(data=None):\n\n hits_by_domain = get_hits_by_domain()\n\n if not hits_by_domain:\n collectd.info('hits_by_domain not collected successfully')\n pass\n else:\n for key in hits_by_domain:\n metric = collectd.Values()\n metric.plugin = 'hits_by_domain'\n metric.type = 'count'\n metric.type_instance = key\n metric.values = [hits_by_domain[key]]\n metric.dispatch()","def emit_metrics(self):\n parse_time = time.perf_counter() - self._parsing_start_time\n Stats.gauge(\"dag_processing.total_parse_time\", parse_time)\n Stats.gauge(\"dagbag_size\", sum(stat.num_dags for stat in self._file_stats.values()))\n Stats.gauge(\n \"dag_processing.import_errors\", sum(stat.import_errors for stat in self._file_stats.values())\n )","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n for key in value_dict.keys():\n value_dict[key] *= self.coverage\n value_dict['coverage'] = self.coverage\n logging.info(\"coverage:{0}\".format(self.coverage))\n for key, value in value_dict.items():\n logging.info(\"{0}:{1}\".format(key,value))\n self.add_records(self.main_loop.log, value_dict.items())\n self.check_stop(value_dict)\n logger.info(\"Monitoring on auxiliary data finished\")","def test_get_all_derived_metrics(self):\n pass","def read_experiment_metrics(TRAIN_CONFIGS):\n metric_dir = TRAIN_CONFIGS.get(\"metrics_dir\")\n mpre = _metric_file_prefixes(TRAIN_CONFIGS)\n\n mtrain = pd.concat([read_metric_frame(f, train=True, metric_dir=metric_dir) for f in mpre],axis=1)\n mval = pd.concat([read_metric_frame(f, train=False, metric_dir=metric_dir) for f in mpre],axis=1)\n\n mtrain = mtrain.sort_index(axis=1,level=0)\n mval = mval.sort_index(axis=1,level=0)\n\n return mtrain, mval","def read_file(self,fname):\n try:\n self.raw=spiketrain.read_file(fname)\n except Exception:\n self.raw=None\n raise","def run_main():\n # Matching lines against a matcher function.\n matched_lines = match_file(file_names, matcher)\n\n # Will contain data sorted by file.\n binned_data = {}\n\n # Looking through the lines that were inserted into the metrics file via the metrics component.\n for key in matched_lines:\n\n # Grabbing matched lines by the file or orgination.\n buffer = matched_lines[key]\n\n # This will contain dictionaries converted from JSON.\n data = []\n\n # Loop through the collection, appending data converted from JSON entries.\n for line in buffer:\n data.append(extract_data(line))\n\n # Sort the data by file.\n binned_data[key] = sort_data(data)\n\n # Output the final results.\n generate_statistics(binned_data)\n return 0","def save_data(self, f): \n if not self.sampling:\n self.convert_to_array()\n np.save(f, self.reads)","def run(self):\r\n self.collect_data()","def list_metrics(self):\n pass","def _AddMetric(self, metric):\n machine = metric.machine_id\n time = metric.timestamp\n payload = DotDict(json.loads(metric.payload)).flatten()\n\n self.machines.add(machine)\n self.timestamps.add(time)\n for k in payload:\n if k not in self.counter_data:\n continue\n val = payload.get(k, None)\n if val is not None:\n self.counter_data[k].AddSample(machine, time, val)","def parse(self):\n\n # if data has already been parsed, do nothing\n if self._data:\n return\n\n stats = {\n \"genres\": {},\n \"artists\": {},\n \"global_stats\": {\n \"songs\": 0,\n \"lines\": 0,\n \"words\": 0\n }\n }\n try:\n with open(self._filename) as file:\n objects = ijson.items(file, \"item\")\n\n # compute metrics\n for object in objects:\n\n lines = len(object[\"lyrics\"])\n words = sum([len(line.split()) for line in object[\"lyrics\"]])\n\n genre = object[\"genre\"]\n stats[\"genres\"][genre] = stats[\"genres\"].get(genre, {\"artists\": {}})\n genre_obj = stats[\"genres\"][genre]\n genre_obj[\"songs\"] = genre_obj.get(\"songs\", 0) + 1\n genre_obj[\"lines\"] = genre_obj.get(\"lines\", 0) + lines\n genre_obj[\"words\"] = genre_obj.get(\"words\", 0) + words\n genre_obj[\"is_music\"] = genre_obj.get(\"is_music\", 0)\n if object[\"is_music\"] != \"false\":\n genre_obj[\"is_music\"] += 1\n\n artist = object[\"artist\"]\n stats[\"artists\"][artist] = stats[\"artists\"].get(artist, 0) + 1\n stats[\"genres\"][genre][\"artists\"][artist] = stats[\"genres\"][genre][\"artists\"].get(artist, 0) + 1\n\n # update global stats\n stats[\"global_stats\"][\"songs\"] += 1\n stats[\"global_stats\"][\"lines\"] += lines\n stats[\"global_stats\"][\"words\"] += words\n\n # calculate averages for each genre\n for genre, genre_stats in stats[\"genres\"].items():\n genre_stats[\"avg_line_length\"] = genre_stats[\"words\"] / genre_stats[\"lines\"]\n genre_stats[\"avg_lines\"] = genre_stats[\"lines\"] / genre_stats[\"songs\"]\n genre_stats[\"avg_words\"] = genre_stats[\"words\"] / genre_stats[\"songs\"]\n\n # calculate global averages\n stats[\"global_stats\"][\"avg_line_length\"] = stats[\"global_stats\"][\"words\"] / stats[\"global_stats\"][\"lines\"]\n stats[\"global_stats\"][\"avg_lines\"] = stats[\"global_stats\"][\"lines\"] / stats[\"global_stats\"][\"songs\"]\n stats[\"global_stats\"][\"avg_words\"] = stats[\"global_stats\"][\"words\"] / stats[\"global_stats\"][\"songs\"]\n\n self._data = stats\n\n except IOError as e:\n print(\"Exception occurred: \", e)","def __read(self, filename):\n f = open(filename)\n\n self.startDate = self.__parseDate(f.readline())\n (nRows, nCols) = [int(s) for s in f.readline().split() ]\n\n dataArray = self.__readData(f, nRows, nCols)\n self.__storeDataDict(dataArray)\n self.__appendMetaData(filename)\n self._appendDerivedQuantities()","def record_time_metrics(self, metrics):\n\n if not self.__settings:\n return\n\n for metric in metrics:\n self.record_time_metric(metric)","def collect(self): # pylint: disable=no-self-use\n start = time.time()\n\n if \"jobs\" in PLUGIN_SETTINGS and PLUGIN_SETTINGS[\"jobs\"]:\n for metric in metric_jobs():\n yield metric\n\n if \"models\" in PLUGIN_SETTINGS:\n for metric in metric_models(PLUGIN_SETTINGS[\"models\"]):\n yield metric\n\n # --------------------------------------------------------------\n # Extras Function defined in configuration.py or the Regristry\n # # --------------------------------------------------------------\n if \"extras\" in PLUGIN_SETTINGS:\n for metric in collect_extras_metric(PLUGIN_SETTINGS[\"extras\"]):\n yield metric\n\n for metric in collect_extras_metric(__REGISTRY__):\n yield metric\n\n gauge = GaugeMetricFamily(\n \"nautobot_app_metrics_processing_ms\", \"Time in ms to generate the app metrics endpoint\"\n )\n duration = time.time() - start\n gauge.add_metric([], format(duration * 1000, \".5f\"))\n yield gauge","def metrics(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def __init__(self, in_file: str, out_file: str, sample_rate: float,\n max_time_gap: timedelta):\n\n self.in_file = in_file\n self.out_file = out_file\n\n # Set up the input/output file objects:\n self.in_data = MobileData(in_file, 'r')\n self.out_data = MobileData(out_file, 'w')\n\n # Hold information about the different fields to use:\n # All fields in the input file:\n self.all_fields = None # type: Optional[Dict[str, str]]\n\n # Stamp field name:\n self.stamp_field = default_stamp_field\n\n # Only sensor fields:\n self.sensor_fields = None # type: Optional[Dict[str, str]]\n\n # List of label fields:\n self.label_fields = default_label_fields\n\n # Determine the output sample interval in seconds:\n self.sample_interval = timedelta(seconds=1.0 / sample_rate)\n\n # Maximum gap between input events - longer than this and we will restart resampling:\n self.max_time_gap = max_time_gap\n\n # The previous and next output stamps to use:\n self.prev_out_stamp = None # type: Optional[datetime]\n self.next_out_stamp = None # type: Optional[datetime]\n\n # The next event from the input file:\n self.next_input_event = None # type: Optional[Dict[str, Union[float, str, datetime, None]]]\n\n # The last-seen input event:\n self.last_seen_input_event = None # type: Optional[Dict[str, Union[float, str, datetime, None]]]\n\n # Information about input events seen in a sample interval:\n self.num_events_in_interval = 0\n self.interval_sensor_values = None # type: Optional[Dict[str, List[float, str]]]\n self.interval_labels = None # type: Optional[Dict[str, List[str]]]\n\n # Status update info:\n self.status_num_events_interval = status_num_events_interval\n self.num_input_events_processed = 0\n self.num_events_since_last_status = 0\n self.first_event_stamp = None # type: Optional[datetime]","def __init__(self, filepath):\n\n self.filepath = Path(filepath)\n\n # Store log data in line based format\n self.values = None\n self._read_log()\n\n # Store log data in row based format\n self.counters = []\n self.timestamps = []\n self.acceleration = []\n self._store_rows()","def compute_metrics(self, results: list) -> dict:\n dump(results, self.out_file_path)\n print_log(\n f'Results has been saved to {self.out_file_path}.',\n logger='current')\n return {}","def run_single_cycle(self, collector=None):\n\n self._timestamp = int(time.time())\n\n # There are certain error conditions, such as the system not supporting\n # a particular proc file type, that we will never recover from. So,\n # just always early exit.\n if self._failed:\n return {}\n\n filename = self._file_pattern % self._pid\n\n if not collector:\n collector = {}\n if self._file is None:\n try:\n self._file = open(filename, \"r\")\n except IOError as e:\n # We take a simple approach. If we don't find the file or\n # don't have permissions for it, then just don't collect this\n # stat from now on. If the user changes the configuration file\n # we will try again to read the file then.\n self._failed = True\n if e.errno == errno.EACCES:\n self._logger.error(\n \"The agent does not have permission to read %s. \"\n \"Maybe you should run it as root.\",\n filename,\n )\n elif e.errno == errno.ENOENT:\n self._logger.error(\n (\n \"The agent cannot read %s. Your system may not support that proc file \"\n 'type or the process with pid \"%s\" doesn\\'t exist'\n ),\n filename,\n self._pid,\n )\n # Ignore 'process not found' errors (likely caused because the process exited\n # but re-raise the exception for all other errors\n elif e.errno != errno.ESRCH:\n raise e\n\n if self._file is not None:\n try:\n self._file.seek(0)\n\n return self.gather_sample(self._file, collector=collector)\n\n except IOError as e:\n # log the error if the errno isn't 'process not found'. Process not found likely means the\n # process exited, so we ignore that because it's within the realm of expected behaviour\n if e.errno != errno.ESRCH:\n self._logger.error(\n \"Error gathering sample for file: '%s'\\n\\t%s\"\n % (filename, six.text_type(e))\n )\n\n # close the file. This will cause the file to be reopened next call to run_single_cycle\n self.close()\n return collector","def __init__(self, count_metrics=None, time_metrics=None, gauge_metrics=None, max_call_count=-1,\n max_time_between_calls=-1):\n super(InMemoryMetrics, self).__init__()\n self._count_metrics = count_metrics if count_metrics is not None else defaultdict(int)\n self._time_metrics = time_metrics if time_metrics is not None \\\n else defaultdict(LatencyTracker)\n self._gauge_metrics = gauge_metrics if gauge_metrics is not None else defaultdict(float)\n self._max_call_count = max_call_count\n self._max_time_between_calls = max_time_between_calls\n\n utcnow_timestamp = arrow.utcnow().timestamp\n\n self._count_call_count = 0\n self._count_last_call_time = utcnow_timestamp\n self._time_call_count = 0\n self._time_last_call_time = utcnow_timestamp\n self._gauge_call_count = 0\n self._gauge_last_call_time = utcnow_timestamp\n self._count_rlock = RLock()\n self._time_rlock = RLock()\n self._gauge_rlock = RLock()\n self._ignore_metrics = False","def _log_metrics(self, logs, prefix, step):\r\n if logs is None:\r\n logs = {}\r\n\r\n # Group metrics by the name of their associated file writer. Values\r\n # are lists of metrics, as (name, scalar_value) pairs.\r\n logs_by_writer = {\r\n self._train_run_name: [],\r\n self._validation_run_name: [],\r\n }\r\n validation_prefix = 'val_'\r\n for (name, value) in logs.items():\r\n if name in ('batch', 'size', 'num_steps'):\r\n # Scrub non-metric items.\r\n continue\r\n if name.startswith(validation_prefix):\r\n name = name[len(validation_prefix):]\r\n writer_name = self._validation_run_name\r\n else:\r\n writer_name = self._train_run_name\r\n name = prefix + name # assign batch or epoch prefix\r\n logs_by_writer[writer_name].append((name, value))\r\n\r\n with context.eager_mode():\r\n with summary_ops_v2.always_record_summaries():\r\n for writer_name in logs_by_writer:\r\n these_logs = logs_by_writer[writer_name]\r\n if not these_logs:\r\n # Don't create a \"validation\" events file if we don't\r\n # actually have any validation data.\r\n continue\r\n writer = self._get_writer(writer_name)\r\n with writer.as_default():\r\n for (name, value) in these_logs:\r\n summary_ops_v2.scalar(name, value, step=step)","def loadFeeds(self):\n\n metrics = self.config['metrics']\n for metric in metrics:\n metricConf = self.config['metrics'][metric]\n metricConf['name'] = metric\n source = metricConf['source']['driver']\n if 'metrics' not in self.sources[source['name']]:\n self.sources[source['name']]['metrics'] = []\n\n self.sources[source['name']]['metrics'].append(metricConf)","def __getitem__(self, idx):\n if (idx >= len(self)) or (idx < 0):\n raise IndexError(f\"Index {idx} if out of dataset range with {len(self)} samples\")\n\n # Identify the file containing the record\n file_id = np.digitize(idx, self.midx_bins, right=False)\n base_idx = self.midx_bins[file_id - 1] if file_id > 0 else 0\n file_idx = idx - base_idx + self._header_lines\n mdata, midx = self.mdata_midx_list[file_id]\n # load sample\n if file_idx == 0:\n i = 0\n j = midx[0]\n else:\n i = midx[file_idx - 1] + 1 # ignore newline\n j = midx[file_idx]\n\n # fetch sample from memmap\n\n try:\n sample = self._fetch_sample_from_memmap(mdata, i, j)\n except Exception as e:\n logging.error(f\"Error while fetching sample from memmap: {e}\")\n logging.error(f\"file_id: {file_id}, file_idx: {file_idx}, i: {i}, j: {j}\")\n raise e\n\n # parse raw text (e.g., tokenize)\n try:\n data = self._build_data_from_text(sample)\n except Exception as e:\n logging.error(\n f\"Error while building data from text, possible issue with sample expected format (see offending sample below): {e}\"\n )\n logging.error(f\"sample: {sample}, file_id: {file_id}, file_idx: {file_idx}, i: {i}, j: {j}\")\n raise e\n\n return data","def metrics_group():","def __init__(self, included_metrics: List[str]):\n self.included_metrics = included_metrics\n self.metrics = self._initialize_metrics()","def readData(self):\n f = open(self.filename)\n self.time = []\n self.data = []\n for line in f:\n if line.find('BAD FLAG') > 0:\n self.badValue = float(line.split(':')[1].strip())\n if line.find('LONGITUDE') > 0:\n self.lon = line.split(':')[1].strip()\n if line.find('LATITUDE') > 0:\n self.lat = line.split(':')[1].strip()\n if len(line) > 6 and line[2] == '-' and line[6] == '-':\n parts = line.rsplit(None, 1)\n # data line\n timeStamp = datetime.datetime.strptime(parts[0], '%d-%b-%Y %H')\n t = timeArray.datetimeToEpochTime(timeStamp)\n self.time.append(t)\n val = float(parts[1])\n self.data.append(val)\n\n self.time = np.array(self.time)\n self.data = np.array(self.data)\n # remove bad values\n if self.badValue:\n goodIx = self.data != self.badValue\n self.time = self.time[goodIx]\n self.data = self.data[goodIx]\n self.fileIsRead = True","def collect_data(base='.'):\n files = glob(join(base, 'accuracy_*.json'))\n data = {}\n for file in files:\n fields = basename(file).split('_')\n fields = fields[1:-2]\n accuracy = load(open(file))\n weights = load(open(file.replace('accuracy', 'weights')))\n for model in accuracy.keys():\n # add both accuracy and weights\n key = tuple(fields + [model])\n value = accuracy[model] + weights[model]\n data[key] = value\n return data","def read_raw_data(self):\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(dat_file))\n time = []\n voltage1 = []\n voltage2 = []\n with open(dat_file, 'r') as fd:\n for line in fd:\n line = line.split()\n time.append(line[0])\n voltage1.append(float(line[1]))\n voltage2.append(float(line[2]))\n\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(tags_file))\n tags_time = []\n tags = []\n r_peaks_indexes = []\n with open(tags_file, 'r') as fd:\n for line in fd:\n line = line.split()\n tags_time.append(line[0])\n tags.append(line[2])\n r_peaks_indexes.append(int(line[1]))\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes","def __init__(self):\n\n # sample must be between 0 and 1\n if self.sample <= 0 or self.sample > 1:\n raise Exception('sample {} should be > 0 and <= 1'.format(self.sample))\n\n # sample RDD if sample is specified AND rdd has not been pre-sampled\n if self.sample < 1 and not self.pre_sampled:\n self.rdd = self.rdd.sample(False, self.sample, self.seed)\n\n # Assign each RDD with counter. Reduce and collect.\n collectedCounts = self.rdd.reduceByKey(lambda x,y: x+y) \\\n .collect() # (id, count), number of times that count appears)\n\n # function that re-calculates coverage based on sampling\n approximateCounts = lambda counts, sample: int(counts * 1.0/sample)\n\n # restructure each record so record structure is (key: sampleId, value: (coverage, count))\n x = list(map(lambda x: (x[0][0], (x[0][1], approximateCounts(x[1], self.sample))), collectedCounts))\n\n # create dictionary where keys are the sampleId\n self.collectedCounts = collections.defaultdict(set)\n for k, v in x:\n self.collectedCounts[k].add(v)","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n self.add_records(self.main_loop.log, value_dict.items())\n logger.info(\"Monitoring on auxiliary data finished\")","def do(self, callback_name, *args):\n logger.info(\"Monitoring on auxiliary data started\")\n value_dict = self._evaluator.evaluate(self.data_stream)\n self.add_records(self.main_loop.log, value_dict.items())\n logger.info(\"Monitoring on auxiliary data finished\")","def get_accumulated_data(self, topic, start_time, end_time, units):\n ignore_start_time = self._get_value('ignore_start_time', topic)\n ignore_end_time = self._get_value('ignore_end_time', topic)\n adjust_start_time = self._get_value('adjust_start_time', topic)\n adjust_end_time = self._get_value('adjust_end_time', topic)\n\n if ignore_start_time:\n self.logger.debug(\"Service ignoring start time.\")\n start_ts = self.peek_datetime(topic) - adjust_start_time\n else:\n start_ts = start_time - adjust_start_time\n\n if ignore_end_time:\n self.logger.debug(\"Service ignoring end time.\")\n end_ts = self.peek_last_datetime(topic) + adjust_end_time\n else:\n end_ts = end_time + adjust_end_time\n\n self.logger.debug(\"Service processing interval: %f %f\" %(start_ts, end_ts))\n accumulator = weewx.accum.Accum(weeutil.weeutil.TimeSpan(start_ts, end_ts))\n\n for data in self.get_data(topic, end_ts):\n if data:\n try:\n self.logger.debug(\"Service data to accumulate: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(data['dateTime']), to_sorted_string(data)))\n accumulator.addRecord(data)\n except weewx.accum.OutOfSpan:\n self.logger.info(\"Service ignoring record outside of interval %f %f %f %s\"\n %(start_ts, end_ts, data['dateTime'], (to_sorted_string(data))))\n else:\n break\n\n target_data = {}\n if not accumulator.isEmpty:\n aggregate_data = accumulator.getRecord()\n self.logger.debug(\"Service data prior to conversion is: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(aggregate_data['dateTime']), to_sorted_string(aggregate_data)))\n target_data = weewx.units.to_std_system(aggregate_data, units)\n self.logger.debug(\"Service data after to conversion is: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(target_data['dateTime']), to_sorted_string(target_data)))\n else:\n self.logger.debug(\"Dervice queue was empty\")\n\n # Force dateTime to packet's datetime so that the packet datetime is not updated to the MQTT datetime\n if ignore_end_time:\n target_data['dateTime'] = end_time\n\n return target_data","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 data_for_file (self):\n rowdata = np.array([self.Train_Time_min,self.Train_Time_max,self.Train_Time_avg,\n self.Loss_Value_min,self.Loss_Value_max,self.Loss_Value_avg,\n self.Iterations_min,self.Iterations_max,self.Iterations_avg,\n self.precision_avg,self.recall_avg])\n return rowdata\n\n\n \n\n\n #### FUNCTION DEFINTIIONS ####","def metadata_reporter(self):\n logging.info('Creating summary report')\n header = '{}\\n'.format(','.join(self.headers))\n # Create a string to store all the results\n data = str()\n for sample in self.metadata:\n # Add the value of the appropriate attribute to the results string\n data += GenObject.returnattr(sample, 'name')\n # SampleName\n data += GenObject.returnattr(sample.run, 'SamplePlate')\n # Genus\n data += GenObject.returnattr(sample.general, 'closestrefseqgenus')\n # SamplePurity\n data += GenObject.returnattr(sample.confindr, 'num_contaminated_snvs')\n # N50\n n50 = GenObject.returnattr(sample.quast, 'N50',\n number=True)\n if n50 != '-,':\n data += n50\n else:\n data += '0,'\n # NumContigs\n data += GenObject.returnattr(sample.quast, 'num_contigs',\n number=True)\n # TotalLength\n data += GenObject.returnattr(sample.quast, 'Total_length',\n number=True)\n # MeanInsertSize\n data += GenObject.returnattr(sample.quast, 'mean_insert',\n number=True)\n # InsertSizeSTD\n data += GenObject.returnattr(sample.quast, 'std_insert',\n number=True)\n # AverageCoverageDepth\n data += GenObject.returnattr(sample.qualimap, 'MeanCoveragedata',\n number=True)\n # CoverageDepthSTD\n data += GenObject.returnattr(sample.qualimap, 'StdCoveragedata',\n number=True)\n # PercentGC\n data += GenObject.returnattr(sample.quast, 'GC',\n number=True)\n # MASH_ReferenceGenome\n data += GenObject.returnattr(sample.mash, 'closestrefseq')\n # MASH_NumMatchingHashes\n data += GenObject.returnattr(sample.mash, 'nummatches')\n # 16S_result\n data += GenObject.returnattr(sample.sixteens_full, 'sixteens_match')\n # 16S PercentID\n data += GenObject.returnattr(sample.sixteens_full, 'percent_id')\n # CoreGenesPresent\n data += GenObject.returnattr(sample.gdcs, 'coreresults')\n # rMLST_Result\n try:\n # If the number of matches to the closest reference profile is 53, return the profile number\n if sample.rmlst.matches == 53:\n if type(sample.rmlst.sequencetype) is list:\n rmlst_seq_type = ';'.join(sorted(sample.rmlst.sequencetype)).rstrip(';') + ','\n else:\n rmlst_seq_type = GenObject.returnattr(sample.rmlst, 'sequencetype')\n rmlst_seq_type = rmlst_seq_type if rmlst_seq_type != 'ND,' else 'new,'\n data += rmlst_seq_type\n else:\n # Otherwise the profile is set to new\n data += 'new,'\n except AttributeError:\n data += 'new,'\n # MLST_Result\n try:\n if sample.mlst.matches == 7:\n if type(sample.mlst.sequencetype) is list:\n mlst_seq_type = ';'.join(sorted(sample.mlst.sequencetype)).rstrip(';') + ','\n else:\n mlst_seq_type = GenObject.returnattr(sample.mlst, 'sequencetype')\n mlst_seq_type = mlst_seq_type if mlst_seq_type != 'ND,' else 'new,'\n data += mlst_seq_type\n else:\n data += 'new,'\n except AttributeError:\n data += 'new,'\n # MLST_gene_X_alleles\n try:\n # Create a set of all the genes present in the results (gene name split from allele)\n gene_set = {gene.split('_')[0] for gene in sample.mlst.combined_metadata_results}\n for gene in sorted(gene_set):\n allele_list = list()\n # Determine all the alleles that are present for each gene\n for allele in sample.mlst.combined_metadata_results:\n if gene in allele:\n allele_list.append(allele.replace(' ', '_'))\n # If there is more than one allele in the sample, add both to the string separated by a ';'\n if len(allele_list) > 1:\n data += '{},'.format(';'.join(allele_list))\n # Otherwise add the only allele\n else:\n data += allele_list[0] + ','\n # If there are fewer than seven matching alleles, add a ND for each missing result\n if len(gene_set) < 7:\n data += (7 - len(gene_set)) * 'ND,'\n except AttributeError:\n # data += '-,-,-,-,-,-,-,'\n data += 'ND,ND,ND,ND,ND,ND,ND,'\n # E_coli_Serotype\n try:\n # If no O-type was found, set the output to be O-untypeable\n if ';'.join(sample.ectyper.o_type) == '-':\n otype = 'O-untypeable'\n else:\n otype = sample.ectyper.o_type\n # Same as above for the H-type\n if ';'.join(sample.ectyper.h_type) == '-':\n htype = 'H-untypeable'\n\n else:\n htype = sample.ectyper.h_type\n serotype = '{otype}:{htype},'.format(otype=otype,\n htype=htype)\n # Add the serotype to the data string unless neither O-type not H-type were found; add ND instead\n data += serotype if serotype != 'O-untypeable:H-untypeable,' else 'ND,'\n except AttributeError:\n data += 'ND,'\n # SISTR_serovar_antigen\n data += GenObject.returnattr(sample.sistr, 'serovar_antigen').rstrip(';')\n # SISTR_serovar_cgMLST\n data += GenObject.returnattr(sample.sistr, 'serovar_cgmlst')\n # SISTR_serogroup\n data += GenObject.returnattr(sample.sistr, 'serogroup')\n # SISTR_h1\n data += GenObject.returnattr(sample.sistr, 'h1').rstrip(';')\n # SISTR_h2\n data += GenObject.returnattr(sample.sistr, 'h2').rstrip(';')\n # SISTR_serovar\n data += GenObject.returnattr(sample.sistr, 'serovar')\n # GeneSeekr_Profile\n try:\n if sample.genesippr.report_output:\n data += ';'.join(sample.genesippr.report_output) + ','\n else:\n data += 'ND,'\n except AttributeError:\n data += 'ND,'\n # Vtyper_Profile\n data += GenObject.returnattr(sample.verotoxin, 'verotoxin_subtypes_set')\n # AMR_Profile and resistant/sensitive status\n if sample.resfinder_assembled.pipelineresults:\n # Profile\n for resistance, resistance_set in sorted(sample.resfinder_assembled.pipelineresults.items()):\n data += '{res}({r_set});'.format(res=resistance.replace(',', ';'),\n r_set=';'.join(sorted(list(resistance_set))))\n data += ','\n # Resistant/Sensitive\n data += 'Resistant,'\n else:\n # Profile\n data += 'ND,'\n # Resistant/Sensitive\n data += 'Sensitive,'\n # Plasmid Result'\n if sample.mobrecon.pipelineresults:\n for plasmid, details in sorted(sample.mobrecon.pipelineresults.items()):\n data += '{plasmid}({details});'.format(plasmid=plasmid,\n details=details)\n data += ','\n else:\n data += 'ND,'\n # TotalPredictedGenes\n data += GenObject.returnattr(sample.prodigal, 'predictedgenestotal',\n number=True)\n # PredictedGenesOver3000bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover3000bp',\n number=True)\n # PredictedGenesOver1000bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover1000bp',\n number=True)\n # PredictedGenesOver500bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover500bp',\n number=True)\n # PredictedGenesUnder500bp\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesunder500bp',\n number=True)\n # AssemblyDate\n data += datetime.now().strftime('%Y-%m-%d') + ','\n # PipelineVersion\n data += self.commit + ','\n # Name of the database used in the analyses\n data += os.path.split(self.reffilepath)[-1] + ','\n # Database download date\n data += self.download_date\n # Append a new line to the end of the results for this sample\n data += '\\n'\n # Replace any NA values with ND\n cleandata = data.replace('NA', 'ND')\n with open(os.path.join(self.reportpath, 'combinedMetadata.csv'), 'w') as metadatareport:\n metadatareport.write(header)\n metadatareport.write(cleandata)","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def save_metrics(self):\n self.data_stats.write.format(\"org.apache.spark.sql.cassandra\").mode(\"append\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\n print (\"Saved data successfully\")"],"string":"[\n \"def read_metrics(self):\\n raise NotImplementedError()\",\n \"def setup_metrics_file(self):\\n\\n with open(self.metrics_path, \\\"w+\\\") as f_metrics:\\n\\n f_metrics.write(get_metrics_file_form())\",\n \"def walk(self):\\n data = open(self.data_file_path, 'rb')\\n read_metric = globals()[\\\"ProtoDefinition\\\"].Payload()\\n read_metric.ParseFromString(data.read())\\n\\n # One record for the whole file\\n self.payload_metadata = read_metric.payloadMetadata\\n self.device = read_metric.device\\n\\n # Get list of all *repeated* field types\\n field_names = []\\n for field_desc in read_metric.DESCRIPTOR.fields:\\n field_name = field_desc.name\\n\\n if field_desc.label == field_desc.LABEL_REPEATED:\\n field_names.append(field_name)\\n\\n # For each repeated field type, get the data and yield one item at a time\\n for field_name in field_names:\\n stream_samples = getattr(read_metric, field_name)\\n for sample in stream_samples:\\n yield self.device, sample\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n # This file format is weird. Each set of stats is outputted in two\\n # lines. First, a header line that list the field names. Then a\\n # a value line where each value is specified in the appropriate column.\\n # You have to match the column name from the header line to determine\\n # what that column's value is. Also, each pair of lines is prefixed\\n # with the same name to make it clear they are tied together.\\n all_lines = stat_file.readlines()\\n # We will create an array of all of the column names in field_names\\n # and all of the corresponding values in field_values.\\n field_names = []\\n field_values = []\\n\\n # To simplify the stats, we add together the two forms of retransmit\\n # I could find in the netstats. Those to fast retransmit Reno and those\\n # to selective Ack.\\n retransmits = 0\\n found_retransmit_metric = False\\n\\n # Read over lines, looking at adjacent lines. If their row names match,\\n # then append their column names and values to field_names\\n # and field_values. This will break if the two rows are not adjacent\\n # but I do not think that happens in practice. If it does, we just\\n # won't report the stats.\\n for i in range(0, len(all_lines) - 1):\\n names_split = all_lines[i].split()\\n values_split = all_lines[i + 1].split()\\n # Check the row names are the same.\\n if names_split[0] == values_split[0] and len(names_split) == len(\\n values_split\\n ):\\n field_names.extend(names_split)\\n field_values.extend(values_split)\\n\\n if not collector:\\n collector = {}\\n\\n # Now go back and look for the actual stats we care about.\\n for i in range(0, len(field_names)):\\n if field_names[i] == \\\"InOctets\\\":\\n collector.update({Metric(\\\"app.net.bytes\\\", \\\"in\\\"): field_values[i]})\\n elif field_names[i] == \\\"OutOctets\\\":\\n collector.update({Metric(\\\"app.net.bytes\\\", \\\"out\\\"): field_values[i]})\\n elif field_names[i] == \\\"TCPRenoRecovery\\\":\\n retransmits += int(field_values[i])\\n found_retransmit_metric = True\\n elif field_names[i] == \\\"TCPSackRecovery\\\":\\n retransmits += int(field_values[i])\\n found_retransmit_metric = True\\n\\n # If we found both forms of retransmit, add them up.\\n if found_retransmit_metric:\\n collector.update({Metric(\\\"app.net.tcp_retransmits\\\", None): retransmits})\\n return collector\",\n \"def gather_sample(self, stat_file, collector=None):\\n if not collector:\\n collector = {}\\n # The file format is just a single line of all the fields.\\n line = stat_file.readlines()[0]\\n # Chop off first part which is the pid and executable file. The\\n # executable file is terminated with a paren so just search for that.\\n line = line[(line.find(\\\") \\\") + 2) :]\\n fields = line.split()\\n # Then the fields we want are just at fixed field positions in the\\n # string. Just grab them.\\n\\n # See http://man7.org/linux/man-pages/man5/proc.5.html for reference on field numbers\\n # Keep in mind that we chop first 3 values away (pid, command line, state), so you need to\\n # subtract 3 from the field numbers from the man page (e.g. on the man page nice is number\\n # 19, but in our case it's 16 aka 19 - 3)\\n process_uptime = self.__get_uptime_ms() - self.calculate_time_ms(\\n int(fields[19])\\n )\\n\\n collector.update(\\n {\\n Metric(\\\"app.cpu\\\", \\\"user\\\"): self.__calculate_time_cs(int(fields[11])),\\n Metric(\\\"app.cpu\\\", \\\"system\\\"): self.__calculate_time_cs(int(fields[12])),\\n Metric(\\\"app.uptime\\\", None): process_uptime,\\n Metric(\\\"app.nice\\\", None): float(fields[16]),\\n Metric(\\\"app.threads\\\", None): int(fields[17]),\\n Metric(\\\"app.mem.majflt\\\", None): int(fields[9]),\\n Metric(\\\"app.io.wait\\\", None): int(fields[39])\\n if len(fields) >= 39\\n else 0,\\n }\\n )\\n return collector\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n # File format is single value per line with \\\"fieldname:\\\" prefix.\\n for x in stat_file:\\n fields = x.split()\\n if len(fields) == 0:\\n continue\\n if not collector:\\n collector = {}\\n if fields[0] == \\\"rchar:\\\":\\n collector.update({Metric(\\\"app.disk.bytes\\\", \\\"read\\\"): int(fields[1])})\\n elif fields[0] == \\\"syscr:\\\":\\n collector.update({Metric(\\\"app.disk.requests\\\", \\\"read\\\"): int(fields[1])})\\n elif fields[0] == \\\"wchar:\\\":\\n collector.update({Metric(\\\"app.disk.bytes\\\", \\\"write\\\"): int(fields[1])})\\n elif fields[0] == \\\"syscw:\\\":\\n collector.update({Metric(\\\"app.disk.requests\\\", \\\"write\\\"): int(fields[1])})\\n return collector\",\n \"def gather_sample(self):\\n\\n for _pid in self._select_processes():\\n if not self.__trackers.get(_pid):\\n self.__trackers[_pid] = ProcessTracker(_pid, self._logger, self.__id)\\n\\n self._reset_absolute_metrics()\\n\\n for _tracker in self.__trackers.values():\\n _metrics = _tracker.collect()\\n self.record_metrics(_tracker.pid, _metrics)\\n\\n self._calculate_aggregated_metrics()\\n self._remove_dead_processes()\\n\\n self.print_metrics()\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n for line in stat_file:\\n # Each line has a format of:\\n # Tag: Value\\n #\\n # We parse out all lines looking like that and match the stats we care about.\\n m = re.search(r\\\"^(\\\\w+):\\\\s*(\\\\d+)\\\", line)\\n if m is None:\\n continue\\n\\n field_name = m.group(1)\\n int_value = int(m.group(2))\\n # FDSize is not the same as the number of open file descriptors. Disable\\n # for now.\\n # if field_name == \\\"FDSize\\\":\\n # self.print_sample(\\\"app.fd\\\", int_value)\\n if field_name == \\\"VmSize\\\":\\n collector.update({Metric(\\\"app.mem.bytes\\\", \\\"vmsize\\\"): int_value * 1024})\\n elif field_name == \\\"VmPeak\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_vmsize\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmRSS\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"resident\\\"): int_value * 1024}\\n )\\n elif field_name == \\\"VmHWM\\\":\\n collector.update(\\n {Metric(\\\"app.mem.bytes\\\", \\\"peak_resident\\\"): int_value * 1024}\\n )\\n return collector\",\n \"def collect_samples(self):\\n self.__running = True\\n with open(self.__filename, 'a') as output:\\n next_sample_time = time.time()\\n while self.__running:\\n sensor_name = self.__sensor.get_sensor_type_name()\\n sensor_id = self.__sensor.get_sensor_id()\\n data = self.__sensor.retrieve_data_string() \\n if DEBUG:\\n print('data: \\\"{}\\\"'.format(data),\\n file = sys.stderr, flush=True)\\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\\n result = OUTPUT_FORMAT.format(when,\\n sensor_name, \\n sensor_id, \\n data)\\n output.write(result)\\n output.flush()\\n \\n next_sample_time = next_sample_time + self.__interval\\n delay_time = next_sample_time - time.time()\\n if DEBUG:\\n print('delay_time = {}'.format(delay_time),\\n file=sys.stderr, flush=True)\\n \\n if 0 < delay_time: # don't sleep if already next sample time\\n time.sleep(delay_time)\",\n \"def read(self):\\n self.record_d = {}\\n if self.__read_file():\\n self.__print_report()\",\n \"def gather_sample(self, stat_file, collector=None):\\n\\n if not collector:\\n collector = {}\\n\\n for line in stat_file:\\n # We just look for the different \\\"inuse\\\" lines and output their\\n # socket type along with the count.\\n m = re.search(r\\\"(\\\\w+): inuse (\\\\d+)\\\", line)\\n if m is not None:\\n collector.update(\\n {\\n Metric(\\\"app.net.sockets_in_use\\\", m.group(1).lower()): int(\\n m.group(2)\\n )\\n }\\n )\\n return collector\",\n \"def add_stats(self):\\n units = self.get_unit_map()\\n for metric in self.raw_metrics:\\n unit, metric_type = units.get(metric, (DEFAULT_UNIT, DEFAULT_TYPE))\\n if metric_type == \\\"counter\\\":\\n # Unit/Second\\n unit = \\\"/\\\".join((unit, \\\"Second\\\"))\\n self.add_derive_value(metric, unit, self.raw_metrics[metric], rate=True)\\n else:\\n self.add_gauge_value(metric, unit, self.raw_metrics[metric])\",\n \"def record_metrics(metrics, args):\\n with open('interpretation_metrics/model_metrics_{}'.format(args.file_num), 'a') as f:\\n f.write(\\\"META DATA\\\\n\\\")\\n f.write(\\\"---------\\\\n\\\")\\n f.write(\\\"Model Name: {}\\\\n\\\".format(args.model_name))\\n f.write(\\\"Attack Target: {}\\\\n\\\".format(args.attack_target))\\n f.write(\\\"Gradient Model File: {}\\\\n\\\".format(args.gradient_model_file))\\n f.write(\\\"Predictive Model File: {}\\\\n\\\".format(args.predictive_model_file))\\n f.write(\\\"Cuda: {}\\\\n\\\".format(args.cuda))\\n\\n f.write(\\\"\\\\nSIMPLE GRADIENT COMBINED MODEL METRICS\\\\n\\\")\\n f.write(\\\"----------------------------------------\\\\n\\\")\\n for key, val in metrics['simple_gradient_combined'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\\n\\n f.write(\\\"\\\\nSIMPLE GRADIENT BASELINE MODEL METRICS\\\\n\\\")\\n f.write(\\\"----------------------------------------\\\\n\\\")\\n for key, val in metrics['simple_gradient_baseline'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\\n\\n f.write(\\\"\\\\nSMOOTH GRADIENT COMBINED MODEL METRICS\\\\n\\\")\\n f.write(\\\"----------------------------------------\\\\n\\\")\\n for key, val in metrics['smooth_gradient_combined'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\\n\\n f.write(\\\"\\\\nSMOOTH GRADIENT BASELINE MODEL METRICS\\\\n\\\")\\n f.write(\\\"----------------------------------------\\\\n\\\")\\n for key, val in metrics['smooth_gradient_baseline'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\\n\\n f.write(\\\"\\\\nINTEGRATED GRADIENT COMBINED MODEL METRICS\\\\n\\\")\\n f.write(\\\"--------------------------------------------\\\\n\\\")\\n for key, val in metrics['integr_gradient_combined'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\\n\\n f.write(\\\"\\\\nINTEGRATED GRADIENT BASELINE MODEL METRICS\\\\n\\\")\\n f.write(\\\"--------------------------------------------\\\\n\\\")\\n for key, val in metrics['integr_gradient_baseline'].items():\\n f.write(\\\"{}: {:.3f}\\\\n\\\".format(key, val))\",\n \"def load_data(self, f): \\n self.sampling = True\\n self.reads = np.load(f)\\n self.total = self.reads.shape[0]\",\n \"def record_custom_metrics(self, metrics):\\n\\n if not self.__settings:\\n return\\n\\n for name, value in metrics:\\n self.record_custom_metric(name, value)\",\n \"def run_resample(self):\\n\\n self.in_data.open()\\n self.out_data.open()\\n\\n try:\\n # Get the fields from the input file and set them/write headers in output:\\n self.all_fields = self.in_data.fields\\n\\n self.out_data.set_fields(self.all_fields)\\n self.out_data.write_headers()\\n\\n # Set up the sensor fields by removing non-sensor fields:\\n self.set_sensor_only_fields()\\n\\n # Read the first event from the input file:\\n self.get_next_input_event()\\n\\n # Warn and exit if we have no input data to read:\\n if self.next_input_event is None:\\n msg = f\\\"The input file {self.in_file} did not have any data rows\\\"\\n warn(msg)\\n\\n return\\n\\n self.first_event_stamp = self.next_input_event[self.stamp_field]\\n\\n # Set up the sample tracking (here mostly to set the start of the first interval):\\n self.reset_sample_tracking()\\n\\n # Now iterate through the output intervals:\\n while True:\\n self.process_next_interval()\\n except EOFError: # catch when we are at the end of the file\\n pass\\n finally:\\n self.in_data.close()\\n self.out_data.close()\\n\\n print() # make sure we go to a new output line\",\n \"def send_metrics(self):\\n metrics = self.get_metrics()\\n if not metrics:\\n return\\n\\n for mkey, metric in metrics.items():\\n for mname, mval in metric.items():\\n try:\\n self.agent.record_custom_metric(self.convert_metric_name(mkey, mname), mval, None)\\n except Exception as e:\\n print_(e)\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def parse_metrics_file(self) -> Dict[int, dict]:\\n LOG.info(\\\"Parsing Dragen demultiplexing adapter metrics file %s\\\", self.adapter_metrics_path)\\n parsed_metrics = {}\\n\\n with self.adapter_metrics_path.open(\\\"r\\\") as metrics_file:\\n metrics_reader = csv.DictReader(metrics_file)\\n for row in metrics_reader:\\n lane = int(row[\\\"Lane\\\"])\\n read_number = row[\\\"ReadNumber\\\"]\\n sample_id = row[\\\"Sample_ID\\\"]\\n parsed_metrics[lane] = parsed_metrics.get(lane, {})\\n parsed_metrics[lane][(read_number, sample_id)] = row\\n\\n return self.summerize_adapter_metrics(parsed_metrics=parsed_metrics)\",\n \"def parse_file(self):\\n # the header was already read in the init, start at the first sample line\\n\\n for line in self._stream_handle:\\n\\n # create the dictionary of key/value pairs composed of the labels and the values from the\\n # record being parsed\\n # ex: data_dict = {'sci_bsipar_temp':10.67, n1, n2, nn}\\n data_dict = self._read_data(line)\\n\\n if GliderParser._has_science_data(data_dict, self._particle_class):\\n # create the timestamp\\n timestamp = ntplib.system_to_ntp_time(float(data_dict[GliderParticleKey.M_PRESENT_TIME]))\\n # create the particle\\n self._record_buffer.append(self._extract_sample(\\n self._particle_class, None, data_dict, internal_timestamp=timestamp))\",\n \"def __init__(self, metrics_to_record):\\n self.tape = {}\\n\\n for metric_name in metrics_to_record:\\n self.tape[metric_name] = []\",\n \"def sample(self):\\n logger.info(\\\"%s: collect sensor data\\\", self.__class__.__name__)\\n samples = []\\n self._fetch_data(samples)\\n return samples\",\n \"def read_data(self):\\n self.data = reduce_spectrum(self.filename)\",\n \"def collect_metrics(grouped_samples, projroot, tgtdir, ext, grouping=\\\"sample\\\"):\\n metrics = []\\n for item_id, itemlist in grouped_samples.items():\\n item = itemlist[0]\\n # FIXME: tgtdir should be docroot!\\n pfx = os.path.relpath(itemlist[0].prefix(grouping), os.path.dirname(tgtdir))\\n mfile = glob.glob(pfx + \\\".*\\\" + ext)\\n if mfile:\\n metrics.append((item_id, mfile[0]))\\n return PicardMetricsCollection(metrics)\",\n \"def train(self, counts_file):\\n for l in read_counts(counts_file):\\n n, count_type, args = int(l[0]), l[1], l[2:]\\n if count_type == 'WORDTAG': # emission counts\\n self.emission_counts[tuple(args)] = n\\n else: # ngram counts\\n self.ngram_counts[len(args) - 1][tuple(args)] = n\",\n \"def compute_metrics(self):\\n pass\",\n \"def readFile(self, fname):\\r\\n self.scores = []\\r\\n self.fname = fname\\r\\n try:\\r\\n with open(fname, 'r') as f:\\r\\n for line in f:\\r\\n self.appendScore(line.split(' '))\\r\\n except:\\r\\n pass\",\n \"def read(self, filename):\\n with RavenFileReader(filename) as f:\\n line = f.nexttag()\\n while line:\\n # Begin data type checks\\n if self.cleantag(line) == 'Gauge':\\n self.read_metgauge(line, f)\\n elif self.cleantag(line) == 'ObservationData':\\n self.read_obsgauge(line, f)\\n # Next line\\n line = f.nexttag()\",\n \"def load_sample(self):\\n\\n self.load_images(self.folder + \\\"/sampleSet.txt\\\")\\n self.load_traces(self.folder + \\\"/sampleLabel.txt\\\")\",\n \"def __init_metrics(self):\\n\\n batch = {}\\n # split data into batches of size batch_size or less\\n for metric_name, metric_pattern in self.metrics.items():\\n # get the batch list for that metric\\n batch_list = []\\n for s in range(1, self.schema + 1):\\n for t in range(1, self.table + 1):\\n k = '/metrics/type=IndexTable/keyspace={}/scope={}/name={}/mean'.format(s, t, metric_name)\\n # from Python 3.6 onwards, the standard dict type maintains insertion order by default\\n batch[k] = 0\\n # if the batch has batch_size items or at the end of iteration,\\n # append the batch to list of that metric and create a new empty batch\\n if len(batch) == self.batch_size or (s == self.schema and t == self.table):\\n batch_list.append(batch)\\n batch = {}\\n\\n # parse metric patterns\\n l = metric_pattern.split()\\n if l[0] == '(>':\\n self.metrics[metric_name] = IncMetricStruct(float(int(l[1])), float(l[2][1:]), float(l[4][:-2]),\\n batch_list)\\n else:\\n self.metrics[metric_name] = RandMetricStruct(float(l[0][1:]), float(l[-1][:-1]), batch_list)\",\n \"def metrics(self, metrics):\\n\\n self._metrics = metrics\",\n \"def parse_file(self):\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n while line:\\n # check for a data line or a dcl logger line we specifically ignore\\n data_match = DATA_LINE_MATCHER.match(line)\\n ignore_match = IGNORE_LINE_MATCHER.match(line)\\n\\n if data_match:\\n # found a data line, extract this particle\\n # DCL controller timestamp is the port_timestamp\\n dcl_controller_timestamp = data_match.groups()[DCL_TIMESTAMP_GROUP]\\n port_timestamp = dcl_time_to_ntp(dcl_controller_timestamp)\\n\\n particle = self._extract_sample(self.particle_class,\\n None,\\n data_match,\\n port_timestamp=port_timestamp,\\n preferred_ts=DataParticleKey.PORT_TIMESTAMP)\\n\\n self._record_buffer.append(particle)\\n\\n elif not ignore_match:\\n # we found a line with an unknown format, call an exception\\n error_message = 'Found line with unknown format %s' % line\\n log.warn(error_message)\\n self._exception_callback(SampleException(error_message))\\n\\n # read the next line\\n line = self._stream_handle.readline()\",\n \"def __init__(self, file_name: str):\\n self.case_metrics = []\\n self.cluster_metrics = []\\n self.file_name = file_name\\n\\n self.path_to_pmg_metrics = f'metrics/{file_name}_process_model_graphs'\\n self.path_to_pmg_vis = f'visualization/{file_name}_process_model_graphs'\\n self.path_to_drifts = 'visualization/drifts'\\n self.path_to_case_metrics = 'metrics/case_metrics'\\n self.path_to_cluster_metrics = 'metrics/cluster_metrics'\\n try:\\n makedirs(self.path_to_pmg_metrics, exist_ok=True)\\n makedirs(self.path_to_pmg_vis, exist_ok=True)\\n makedirs(self.path_to_drifts, exist_ok=True)\\n makedirs(self.path_to_case_metrics, exist_ok=True)\\n makedirs(self.path_to_cluster_metrics, exist_ok=True)\\n\\n pd.DataFrame(columns=['stream_index', 'timestamp', 'check point', 'case',\\n 'graph distance', 'time distance', 'label']) \\\\\\n .to_csv(f'{self.path_to_case_metrics}/{file_name}.csv', index=False)\\n pd.DataFrame(columns=['stream_index', 'timestamp', 'check point', 'cluster id',\\n 'x', 'y', 'radius', 'weight', 'cluster type']) \\\\\\n .to_csv(f'{self.path_to_cluster_metrics}/{file_name}.csv', index=False)\\n except Exception as e:\\n print(e)\",\n \"def possible_metrics(filename):\\n\\n metrics = {}\\n\\n raw_data = parse_config(filename)\\n\\n for graph in raw_data:\\n for metric in graph['metrics']:\\n metrics.update({metric['label']: [(metric['x_stream'], metric['y_stream'], metric['z_stream']), metric['func']]})\\n\\n return metrics\",\n \"def collect_stats(self, cursor):\\n metrics = self.config.get('metrics', DEFAULT_METRICS)\\n if isinstance(metrics, str):\\n if metrics == \\\"all\\\":\\n # puffer_pool_status is only for 5.5, so we ignore that by default\\n metrics = CATEGORIES.keys()\\n metrics.remove('buffer_pool_stats')\\n else:\\n # support comma-separated list\\n metrics = re.split(\\\"\\\\s*,\\\\s*\\\", metrics)\\n\\n self.logger.debug(\\\"metrics to collect: %s\\\" % \\\", \\\".join(metrics))\\n for cat in metrics:\\n if cat in CATEGORIES:\\n self.add_category_stats(cat, cursor)\\n else:\\n self.logger.warning(\\\"%s is not a valid metric category\\\" % cat)\\n\\n if 'newrelic' in metrics:\\n self.derive_newrelic_stats()\",\n \"def populate_list(self, input_filename):\\r\\n f = open(input_filename, 'r')\\r\\n\\r\\n for line in f:\\r\\n # Process the input line\\r\\n line_split = line.strip().split('(')\\r\\n line_split[-1] = line_split[-1][:-1] # Removes the extra bracket at the end\\r\\n\\r\\n class_name = line_split[0]\\r\\n parameters = line_split[1].split(',')\\r\\n self.metrics.append(self.instantiate_class(class_name, *parameters))\\r\\n\\r\\n f.close()\",\n \"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 = FILE_NAME_MATCHER.match(input_file_name)\\n\\n if match:\\n file_time = match.group(1)\\n else:\\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\\\\n % input_file_name\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n # loop over all lines in the data file\\n while line:\\n\\n if EMPTY_LINE_MATCHER.match(line):\\n # ignore blank lines, do nothing\\n pass\\n\\n elif HEADER_MATCHER.match(line):\\n\\n # we need header records to extract useful information\\n for matcher in HEADER_MATCHER_LIST:\\n header_match = matcher.match(line)\\n\\n if header_match is not None:\\n\\n # Look for specific header lines and extract header fields\\n if matcher is DIR_FREQ_MATCHER:\\n num_dir = int(header_match.group(1))\\n num_freq = int(header_match.group(2))\\n\\n elif matcher is FREQ_BAND_MATCHER:\\n freq_w_band = header_match.group(1)\\n freq_0 = header_match.group(2)\\n\\n elif matcher is START_DIR_MATCHER:\\n start_dir = header_match.group(1)\\n\\n else:\\n #ignore\\n pass\\n\\n elif DSPEC_DATA_MATCHER.match(line):\\n\\n # Extract a row of the Directional Surface Spectrum matrix\\n sensor_match = DSPEC_DATA_MATCHER.match(line)\\n data = sensor_match.group(1)\\n values = [int(x) for x in data.split()]\\n\\n num_values = len(values)\\n\\n # If the number of values in a line of data doesn't match num_dir,\\n # Drop the record, throw a recoverable exception and continue parsing\\n if num_values != num_dir:\\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\\\\n % (num_dir, num_values)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n else:\\n # Add the row to the dspec matrix\\n dspec_matrix.append(values)\\n\\n else:\\n # Generate a warning for unknown data\\n error_message = 'Unexpected data found in line %s' % line\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the next line in the file\\n line = self._stream_handle.readline()\\n\\n # Check to see if the specified number of frequencies were retrieved from the data\\n dspec_matrix_length = len(dspec_matrix)\\n if dspec_matrix_length != num_freq:\\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\\\\n % (num_freq, dspec_matrix_length)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\\n parsed_data = [\\n file_time, # ('file_time', 0, str),\\n num_dir, # ('num_dir', 1, int),\\n num_freq, # ('num_freq', 2, int),\\n freq_w_band, # ('freq_w_band', 3, float),\\n freq_0, # ('freq_0', 4, float),\\n start_dir, # ('start_dir', 5, float),\\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\\n ]\\n\\n # Extract a particle and append it to the record buffer\\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\\n self._record_buffer.append(particle)\",\n \"def collect(self):\\n if not self._btime:\\n return\\n\\n try:\\n with open(\\\"/proc/self/stat\\\", 'rb') as stat:\\n parts = (stat.read().split(b')')[-1].split())\\n\\n self.process_metrics[\\\"vmem\\\"].set(\\\"\\\", float(parts[20]))\\n self.process_metrics[\\\"rss\\\"].set(\\\"\\\", float(parts[21]) * _PAGESIZE)\\n start_time_secs = float(parts[19]) / self._ticks\\n self.process_metrics[\\\"start_time\\\"].set(\\n \\\"\\\", start_time_secs + self._btime\\n )\\n utime = float(parts[11]) / self._ticks\\n stime = float(parts[12]) / self._ticks\\n self.process_metrics[\\\"cpu\\\"].set(\\\"\\\", utime + stime)\\n except IOError:\\n pass\\n\\n try:\\n with open(\\\"/proc/self/limits\\\", 'rb') as limits:\\n for line in limits:\\n if line.startswith(b'Max open file'):\\n self.process_metrics[\\\"max_fds\\\"].set(\\n \\\"\\\", float(line.split()[3])\\n )\\n break\\n\\n self.process_metrics[\\\"open_fds\\\"].set(\\n \\\"\\\", float(len(os.listdir(\\\"/proc/self/fd\\\")))\\n )\\n except (IOError, OSError):\\n pass\\n\\n # Update gc metrics if enabled.\\n if \\\"collected\\\" in self.process_metrics:\\n for generation, stat in enumerate(gc.get_stats()):\\n generation = {\\\"generation\\\": str(generation)}\\n self.process_metrics[\\\"collected\\\"].set(\\n generation, stat[\\\"collected\\\"]\\n )\\n self.process_metrics[\\\"uncollectable\\\"].set(\\n generation, stat[\\\"uncollectable\\\"]\\n )\\n self.process_metrics[\\\"collections\\\"].set(\\n generation, stat[\\\"collections\\\"]\\n )\",\n \"def record_apdex_metrics(self, metrics):\\n\\n if not self.__settings:\\n return\\n\\n for metric in metrics:\\n self.record_apdex_metric(metric)\",\n \"def get_data():\\n \\n data = {\\n 'loadAvg1Min': 0, #load average 1 min\\n 'loadAvg5Min': 0, #load average 5 min\\n 'loadAvg15Min': 0, #load average 15 min\\n 'cpuUsage': [], #usage distribution for each cpu\\n 'memUsage': {}, #memory usage \\n 'networkReads': [], #network reads per second for each interface\\n 'networkWrites': [], #network writes per second for each interface\\n 'diskReads': [], #disk reads per second for each disk\\n 'diskWrites': [] #disk writes per second for each disk\\n }\\n \\n #metrics that doesnt need sampling\\n data['loadAvg1Min'], data['loadAvg5Min'], data['loadAvg15Min'] = get_load_avg() #get load avg\\n data['memUsage'].update(get_mem_usage()) #memory usage\\n \\n #metrics that needs sampling\\n #they are written as a generator so that we can sleep before collection again\\n sampling_duration = 1\\n cpu_usage_gen = get_cpu_usage(sampling_duration) #generator for cpu usage\\n net_rw_gen = get_net_rw(sampling_duration) #generator for network read write\\n disk_rw_gen = get_disk_rw(sampling_duration) #generator for disk read write\\n \\n while 1: #now start sampling, whenever we have walid data, we can exit the loop\\n cpu_usage = next(cpu_usage_gen)\\n net_rw = next(net_rw_gen)\\n disk_rw = next(disk_rw_gen)\\n \\n if cpu_usage or net_rw or disk_rw: #we have valid data\\n break\\n \\n time.sleep(sampling_duration)\\n \\n #append cpu usage for each cpu core\\n for cpu, usage in cpu_usage.items():\\n data['cpuUsage'].append({'name': cpu, 'value': usage})\\n \\n #append network read and write for each interface\\n for interface, rw in net_rw.items():\\n data['networkReads'].append({'name': interface, 'value': rw['reads']})\\n data['networkWrites'].append({'name': interface, 'value': rw['writes']}) \\n \\n #append disk read and write for each logical disk\\n for device, rw in disk_rw.items():\\n data['diskReads'].append({'name': device, 'value': rw['reads']})\\n data['diskWrites'].append({'name': device, 'value': rw['writes']})\\n \\n return data\",\n \"def _load(self):\\n op_type_file_path = os.path.join(\\n self._profiling_dir,\\n self._csv_file_to_analyse.format(self._device_id)\\n )\\n op_type_file_path = validate_and_normalize_path(\\n op_type_file_path, raise_key=\\\"Invalid op_type_file_path\\\")\\n if not os.path.isfile(op_type_file_path):\\n log.warning('The file <%s> does not exist.', op_type_file_path)\\n return\\n\\n with open(op_type_file_path, 'r') as file:\\n csv_reader = csv.reader(file)\\n _ = next(csv_reader)\\n for info in csv_reader:\\n self._data.append(self._convert_field_type(info))\",\n \"def samples(self):\\n pass\",\n \"def calculate_batch_metrics(self):\\n pass\",\n \"def make_metrics(self):\\n num_batches = self.data_loader.number_of_batches()\\n dose_score_vec = np.zeros(num_batches)\\n\\n # Only make calculations if data_loader is not empty\\n if not self.data_loader.file_paths_list:\\n print('No patient information was given to calculate metrics')\\n else:\\n # Change batch size to 1\\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\\n if self.dose_loader is not None:\\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\\n\\n for idx in tqdm.tqdm(range(num_batches)):\\n # Get roi masks for patient\\n self.get_constant_patient_features(idx)\\n # Get dose tensors for reference dose and evaluate criteria\\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\\n if reference_dose is not None:\\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\\n # If a dose loader was provided, calculate the score\\n if self.dose_loader is not None:\\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\\n # Make metric data frames\\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\\n # Evaluate mean absolute error of 3D dose\\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\\n # their files\\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\\n\\n if self.dose_loader is not None:\\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\\n dose_score = dose_score_vec.mean()\\n return dvh_score, dose_score\\n else:\\n print('No new dose provided. Metrics were only calculated for the provided dose.')\",\n \"def set_metrics(self):\",\n \"def start_monitor_loop(self):\\n read_file = read_config_file.ConfigFileReader()\\n\\n communication_time = read_file.get_send_communication_time()\\n metrics_array = read_file.get_metrics()\\n\\n self.add_metrics_to_monitor_object(communication_time, metrics_array)\",\n \"def calculate_dataset_metrics(self):\\n pass\",\n \"def metrics(self):\\n\\n data = requests.get(\\n f\\\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\\\"\\n ).content.decode()\\n lines = [line for line in data.split(\\\"\\\\n\\\") if not line.startswith(\\\"#\\\")]\\n metrics = {}\\n for line in lines:\\n if not line:\\n continue\\n\\n name, value = line.split(\\\" \\\")\\n\\n try:\\n value = int(value) # type: ignore\\n except ValueError:\\n value = float(value) # type: ignore\\n\\n if \\\"{\\\" in name and \\\"}\\\" in name:\\n base = name[: name.index(\\\"{\\\")]\\n tags = name[name.index(\\\"{\\\") + 1 : -1]\\n tags = [tag.split(\\\"=\\\") for tag in tags.split(\\\",\\\")]\\n tags = [(key, val.replace('\\\"', \\\"\\\")) for key, val in tags]\\n\\n name = base + \\\"#\\\" + \\\",\\\".join(f\\\"{k}:{v}\\\" for k, v in sorted(tags))\\n\\n metrics[name] = value\\n\\n return metrics\",\n \"def _read_samples(self):\\n\\n logging.debug(\\\"Start file parsing.\\\")\\n data = pd.read_csv(self._source_file, header=None)\\n \\n data = pd.read_csv(self._source_file, header=None)\\n header = pd.read_csv(self._header_file, delimiter=':', skiprows=1, header=None)\\n header.columns = ['column', 'column_type']\\n\\n data.columns = header.column.tolist() + ['attack']\\n data['attack'] = data['attack'].str.replace('.', '')\\n data['label'] = 1\\n data.loc[data['attack'] == 'normal', 'label'] = 0\\n\\n symbolic_columns = header.loc[header.column_type == ' symbolic.'].column.tolist()\\n # print(symbolic_columns)\\n\\n for scol in symbolic_columns:\\n data[scol] = pd.Categorical(data[scol])\\n one_hot_cols = pd.get_dummies(data[scol], prefix=scol)\\n data = pd.concat([data, one_hot_cols], axis=1)\\n\\n data = data.drop(columns=symbolic_columns)\\n data = data.drop(columns=['attack'])\\n\\n # data.loc[data.attack != 'normal' , ['attack', 'label']].head(20)\\n\\n data_normal = data.loc[data['label'] == 0]\\n data_abnormal = data.loc[data['label'] == 1]\\n\\n data_normal_train = data_normal.sample(frac=0.7)\\n data_normal_test = data_normal.loc[~data_normal.index.isin(data_normal_train.index)]\\n\\n data_normal_train = data_normal_train.drop(columns=['label']).values\\n data_normal_test = data_normal_test.drop(columns=['label']).values\\n data_abnormal = data_abnormal.drop(columns=['label']).values\\n \\n scaler = MinMaxScaler()\\n _ = scaler.fit(data_normal_train)\\n data_normal_train = scaler.transform(data_normal_train)\\n data_normal_test = scaler.transform(data_normal_test)\\n data_abnormal = scaler.transform(data_abnormal)\\n \\n logging.debug('Normal {}; Train {}; Test{}'.format(data_normal.shape, data_normal_train.shape, data_normal_test.shape))\\n logging.debug('Abnormal {}'.format(data_abnormal.shape))\\n\\n samples = {}\\n samples['NORMAL'] = data_normal_train\\n samples['NORMAL_TEST'] = data_normal_test\\n samples['ABNORMAL_TEST'] = data_abnormal\\n\\n logging.debug(\\\"End file parsing.\\\")\\n\\n return samples\",\n \"def dataStats(self):\\n print (\\\"Performing statistical analysis of the data\\\")\\n # stuff to do\",\n \"def __parse(self):\\n lines = self.file.readlines()\\n for i in range(0, len(lines)):\\n line = lines[i]\\n tokens = line.split()\\n if tokens[0] == \\\"#start\\\":\\n trial_name = tokens[1]\\n trial = Trial(trial_name)\\n self.trials[trial_name] = trial\\n elif tokens[0] == \\\"#end\\\":\\n continue\\n else:\\n date_str = tokens[0] + \\\" \\\" + tokens[1]\\n date = datetime.strptime(date_str, \\\"%m/%d/%y %H:%M:%S\\\")\\n sound_file = line[18:-1].strip()\\n event = Event(date, sound_file, 0)\\n trial.addevent(event)\",\n \"def add_metrics(self, metrics):\\n for i, metric in enumerate(self.config.metrics):\\n tf.summary.scalar(metric, metrics[i])\",\n \"def load_data(self):\\n logging.debug('Loading data from file ({})...'.format(self.file_name))\\n parsed_data = list()\\n with open(self.file_name) as file_data:\\n for line in file_data.readlines():\\n temp = dict()\\n if 'JD' in line:\\n continue\\n line = line.split()\\n temp['ts'], temp['mag'], temp['dif'] = float(line[0][:14]), float(line[1]), float(line[2])\\n temp['f_mag'] = self.kalman_filter(temp['mag'])\\n temp['dt'] = self.jd_to_datetime(temp['ts'])\\n temp['dt_cor'] = self.jd_to_datetime(temp['ts'] - TIME_CRT)\\n parsed_data.append(temp)\\n logging.debug(' {} records loaded.'.format(len(parsed_data)))\\n logging.debug(parsed_data[0])\\n self.data_stream = parsed_data\",\n \"def _read_log(self):\\n\\n line_regex = compile(r\\\"\\\\[I\\\\]\\\\s*\\\\(\\\\d+ms\\\\)[^\\\\d]+(?P<counter>\\\\d+)\\\"\\n r\\\"[^\\\\d]+(?P<timestamp>\\\\d+(\\\\.\\\\d+)?)[^\\\\d]+\\\"\\n r\\\"(?P<acceleration>\\\\d+);\\\")\\n values = []\\n with open(self.filepath) as file:\\n for line in file:\\n match = line_regex.match(line)\\n if match:\\n values.append({\\n 'counter':\\n int(match['counter']),\\n 'timestamp':\\n int(float(match['timestamp']) * 1000),\\n 'acceleration':\\n int(match['acceleration'])\\n })\\n\\n self.values = values\",\n \"def write_training_metrics(self) -> None:\\n self.trainer_metrics.write_training_metrics()\",\n \"def getUnscaledSamples(self, **kwargs) -> TimeData:\\n # initialise chans, startSample and endSample with the whole dataset\\n options = self.parseGetDataKeywords(kwargs)\\n\\n # get the files to read and the samples to take from them, in the correct order\\n dataFilesToRead, samplesToRead, scalings = self.getDataFilesForSamples(\\n options[\\\"startSample\\\"], options[\\\"endSample\\\"]\\n )\\n numSamples = options[\\\"endSample\\\"] - options[\\\"startSample\\\"] + 1\\n # set up the dictionary to hold the data\\n data = {}\\n for chan in options[\\\"chans\\\"]:\\n data[chan] = np.zeros(shape=(numSamples), dtype=self.dtype)\\n\\n # loop through chans and get data\\n sampleCounter = 0\\n for dFile, sToRead, scalar in zip(dataFilesToRead, samplesToRead, scalings):\\n # get samples - this is inclusive\\n dSamples = sToRead[1] - sToRead[0] + 1\\n # spam files always record 5 channels\\n dSamplesRead = dSamples * self.recChannels[dFile]\\n # read the data\\n byteOff = (\\n self.dataByteOffset[dFile]\\n + sToRead[0] * self.recChannels[dFile] * self.dataByteSize\\n )\\n dFilePath = os.path.join(self.dataPath, dFile)\\n dataRead = np.memmap(\\n dFilePath,\\n dtype=self.dtype,\\n mode=\\\"r\\\",\\n offset=byteOff,\\n shape=(dSamplesRead),\\n )\\n # now need to unpack this\\n for chan in options[\\\"chans\\\"]:\\n # check to make sure channel exists\\n self.checkChan(chan)\\n # get the channel index - the chanIndex should give the right order in the data file\\n # as it is the same order as in the header file\\n chanIndex = self.chanMap[chan]\\n # use the range sampleCounter -> sampleCounter + dSamples, because this actually means sampleCounter + dSamples - 1 as python ranges are not inclusive of the end value\\n # scale by the lsb scalar here - note that these can be different for each file in the run\\n data[chan][sampleCounter : sampleCounter + dSamples] = (\\n dataRead[chanIndex : dSamplesRead : self.recChannels[dFile]]\\n * scalar[chan]\\n )\\n # increment sample counter\\n sampleCounter = sampleCounter + dSamples # get ready for the next data read\\n\\n # return data\\n startTime, stopTime = self.sample2time(\\n options[\\\"startSample\\\"], options[\\\"endSample\\\"]\\n )\\n comments = []\\n comments.append(\\n \\\"Unscaled data {} to {} read in from measurement {}, samples {} to {}\\\".format(\\n startTime,\\n stopTime,\\n self.dataPath,\\n options[\\\"startSample\\\"],\\n options[\\\"endSample\\\"],\\n )\\n )\\n comments.append(\\\"Data read from {} files in total\\\".format(len(dataFilesToRead)))\\n comments.append(\\n \\\"Data scaled to mV for all channels using scalings in header files\\\"\\n )\\n comments.append(\\\"Sampling frequency {}\\\".format(self.getSampleFreq()))\\n return TimeData(\\n sampleFreq=self.getSampleFreq(),\\n startTime=startTime,\\n stopTime=stopTime,\\n data=data,\\n comments=comments,\\n )\",\n \"def save_case_metrics_on_check_point(self) -> None:\\n pd.read_csv(f'{self.path_to_case_metrics}/{self.file_name}.csv')\\\\\\n .append(pd.DataFrame(self.case_metrics,\\n columns=['stream_index', 'timestamp', 'check point', 'case',\\n 'graph distance', 'time distance', 'label']))\\\\\\n .to_csv(f'{self.path_to_case_metrics}/{self.file_name}.csv', index=False)\\n self.case_metrics = []\",\n \"def read_file(self):\\n # This is quite ugly but works for now.\\n self.header = read_csv(self.file_name, delim_whitespace=True,\\n header=TrackData.header_line,\\n nrows=1).to_dict(orient='index')[0]\\n self.data = read_csv(self.file_name, delim_whitespace=True, \\n header=TrackData.data_line)\",\n \"def qc_metrics(self, files_in, qc_files):\\n self.cmd(\\\"{samtools} index {bam_in}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in=files_in[0],\\n ),\\n shell=True)\\n self.cmd(\\\"{samtools} idxstats {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[0],\\n ),\\n shell=True,\\n log_output=True)\\n self.cmd(\\\"{samtools} flagstat {bam_in} | tee {qc_file}\\\"\\n .format(\\n samtools=self.cmds[\\\"samtools\\\"],\\n bam_in = files_in[0],\\n qc_file = qc_files[1],\\n ),\\n shell=True,\\n log_output=True)\\n \\n self.checkpoint(qc_files[0])\\n self.checkpoint(qc_files[1])\\n self.checkpoint(qc_files[2])\",\n \"def process_file(self, file_path: str) -> None:\\n signal = self._loader(file_path)\\n if self._is_padding_necessary(signal):\\n signal = self._apply_padding(signal)\\n feature = self._logspectogramextractor(signal)\\n norm_feature = self._normalize(feature)\\n if self._no_nan(norm_feature):\\n file_name = self._save_feature(norm_feature, file_path)\\n self._store_min_max_value(file_name, feature.min(), feature.max())\",\n \"def metrics(self):\\n self.metrics = []\\n \\n self.clients()\\n\\n if len(self.metrics) > 0:\\n return self.metrics\\n else:\\n return []\",\n \"def read_metric_values(self):\\n inv_objs = self._inventory_mgr.current_inventory()\\n monitored_metrics = self._metric_mgr.get_monitored_metrics()\\n perf_manager = self._si.RetrieveServiceContent().perfManager\\n for mor in inv_objs.keys():\\n for inv_obj in inv_objs[mor]:\\n inv_obj_metrics = inv_obj.metric_id_map\\n desired_keys = list(set(inv_obj_metrics.keys()) & set(monitored_metrics[mor].keys()))\\n if not len(desired_keys) == 0:\\n metric_id_objs = [inv_obj_metrics[key] for key in desired_keys]\\n query_spec = vim.PerformanceManager.QuerySpec(\\n entity=inv_obj.mor, metricId=metric_id_objs,\\n intervalId=inv_obj.INSTANT_INTERVAL,\\n maxSample=1, format='normal'\\n )\\n try:\\n results = perf_manager.QueryPerf(querySpec=[query_spec])\\n except Exception as e:\\n self._logger.error(\\\"Exception while making performance query : {0}\\\".format(e))\\n if results:\\n dps = self._parse_query(inv_obj, results, monitored_metrics[mor])\\n payload = self._build_payload(dps)\\n self._dispatch_metrics(payload)\\n else:\\n self._logger.warning(\\\"Empty result from query : {0}\\\".format(query_spec))\",\n \"def read_callback(data=None):\\n\\n hits_by_domain = get_hits_by_domain()\\n\\n if not hits_by_domain:\\n collectd.info('hits_by_domain not collected successfully')\\n pass\\n else:\\n for key in hits_by_domain:\\n metric = collectd.Values()\\n metric.plugin = 'hits_by_domain'\\n metric.type = 'count'\\n metric.type_instance = key\\n metric.values = [hits_by_domain[key]]\\n metric.dispatch()\",\n \"def emit_metrics(self):\\n parse_time = time.perf_counter() - self._parsing_start_time\\n Stats.gauge(\\\"dag_processing.total_parse_time\\\", parse_time)\\n Stats.gauge(\\\"dagbag_size\\\", sum(stat.num_dags for stat in self._file_stats.values()))\\n Stats.gauge(\\n \\\"dag_processing.import_errors\\\", sum(stat.import_errors for stat in self._file_stats.values())\\n )\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n for key in value_dict.keys():\\n value_dict[key] *= self.coverage\\n value_dict['coverage'] = self.coverage\\n logging.info(\\\"coverage:{0}\\\".format(self.coverage))\\n for key, value in value_dict.items():\\n logging.info(\\\"{0}:{1}\\\".format(key,value))\\n self.add_records(self.main_loop.log, value_dict.items())\\n self.check_stop(value_dict)\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def test_get_all_derived_metrics(self):\\n pass\",\n \"def read_experiment_metrics(TRAIN_CONFIGS):\\n metric_dir = TRAIN_CONFIGS.get(\\\"metrics_dir\\\")\\n mpre = _metric_file_prefixes(TRAIN_CONFIGS)\\n\\n mtrain = pd.concat([read_metric_frame(f, train=True, metric_dir=metric_dir) for f in mpre],axis=1)\\n mval = pd.concat([read_metric_frame(f, train=False, metric_dir=metric_dir) for f in mpre],axis=1)\\n\\n mtrain = mtrain.sort_index(axis=1,level=0)\\n mval = mval.sort_index(axis=1,level=0)\\n\\n return mtrain, mval\",\n \"def read_file(self,fname):\\n try:\\n self.raw=spiketrain.read_file(fname)\\n except Exception:\\n self.raw=None\\n raise\",\n \"def run_main():\\n # Matching lines against a matcher function.\\n matched_lines = match_file(file_names, matcher)\\n\\n # Will contain data sorted by file.\\n binned_data = {}\\n\\n # Looking through the lines that were inserted into the metrics file via the metrics component.\\n for key in matched_lines:\\n\\n # Grabbing matched lines by the file or orgination.\\n buffer = matched_lines[key]\\n\\n # This will contain dictionaries converted from JSON.\\n data = []\\n\\n # Loop through the collection, appending data converted from JSON entries.\\n for line in buffer:\\n data.append(extract_data(line))\\n\\n # Sort the data by file.\\n binned_data[key] = sort_data(data)\\n\\n # Output the final results.\\n generate_statistics(binned_data)\\n return 0\",\n \"def save_data(self, f): \\n if not self.sampling:\\n self.convert_to_array()\\n np.save(f, self.reads)\",\n \"def run(self):\\r\\n self.collect_data()\",\n \"def list_metrics(self):\\n pass\",\n \"def _AddMetric(self, metric):\\n machine = metric.machine_id\\n time = metric.timestamp\\n payload = DotDict(json.loads(metric.payload)).flatten()\\n\\n self.machines.add(machine)\\n self.timestamps.add(time)\\n for k in payload:\\n if k not in self.counter_data:\\n continue\\n val = payload.get(k, None)\\n if val is not None:\\n self.counter_data[k].AddSample(machine, time, val)\",\n \"def parse(self):\\n\\n # if data has already been parsed, do nothing\\n if self._data:\\n return\\n\\n stats = {\\n \\\"genres\\\": {},\\n \\\"artists\\\": {},\\n \\\"global_stats\\\": {\\n \\\"songs\\\": 0,\\n \\\"lines\\\": 0,\\n \\\"words\\\": 0\\n }\\n }\\n try:\\n with open(self._filename) as file:\\n objects = ijson.items(file, \\\"item\\\")\\n\\n # compute metrics\\n for object in objects:\\n\\n lines = len(object[\\\"lyrics\\\"])\\n words = sum([len(line.split()) for line in object[\\\"lyrics\\\"]])\\n\\n genre = object[\\\"genre\\\"]\\n stats[\\\"genres\\\"][genre] = stats[\\\"genres\\\"].get(genre, {\\\"artists\\\": {}})\\n genre_obj = stats[\\\"genres\\\"][genre]\\n genre_obj[\\\"songs\\\"] = genre_obj.get(\\\"songs\\\", 0) + 1\\n genre_obj[\\\"lines\\\"] = genre_obj.get(\\\"lines\\\", 0) + lines\\n genre_obj[\\\"words\\\"] = genre_obj.get(\\\"words\\\", 0) + words\\n genre_obj[\\\"is_music\\\"] = genre_obj.get(\\\"is_music\\\", 0)\\n if object[\\\"is_music\\\"] != \\\"false\\\":\\n genre_obj[\\\"is_music\\\"] += 1\\n\\n artist = object[\\\"artist\\\"]\\n stats[\\\"artists\\\"][artist] = stats[\\\"artists\\\"].get(artist, 0) + 1\\n stats[\\\"genres\\\"][genre][\\\"artists\\\"][artist] = stats[\\\"genres\\\"][genre][\\\"artists\\\"].get(artist, 0) + 1\\n\\n # update global stats\\n stats[\\\"global_stats\\\"][\\\"songs\\\"] += 1\\n stats[\\\"global_stats\\\"][\\\"lines\\\"] += lines\\n stats[\\\"global_stats\\\"][\\\"words\\\"] += words\\n\\n # calculate averages for each genre\\n for genre, genre_stats in stats[\\\"genres\\\"].items():\\n genre_stats[\\\"avg_line_length\\\"] = genre_stats[\\\"words\\\"] / genre_stats[\\\"lines\\\"]\\n genre_stats[\\\"avg_lines\\\"] = genre_stats[\\\"lines\\\"] / genre_stats[\\\"songs\\\"]\\n genre_stats[\\\"avg_words\\\"] = genre_stats[\\\"words\\\"] / genre_stats[\\\"songs\\\"]\\n\\n # calculate global averages\\n stats[\\\"global_stats\\\"][\\\"avg_line_length\\\"] = stats[\\\"global_stats\\\"][\\\"words\\\"] / stats[\\\"global_stats\\\"][\\\"lines\\\"]\\n stats[\\\"global_stats\\\"][\\\"avg_lines\\\"] = stats[\\\"global_stats\\\"][\\\"lines\\\"] / stats[\\\"global_stats\\\"][\\\"songs\\\"]\\n stats[\\\"global_stats\\\"][\\\"avg_words\\\"] = stats[\\\"global_stats\\\"][\\\"words\\\"] / stats[\\\"global_stats\\\"][\\\"songs\\\"]\\n\\n self._data = stats\\n\\n except IOError as e:\\n print(\\\"Exception occurred: \\\", e)\",\n \"def __read(self, filename):\\n f = open(filename)\\n\\n self.startDate = self.__parseDate(f.readline())\\n (nRows, nCols) = [int(s) for s in f.readline().split() ]\\n\\n dataArray = self.__readData(f, nRows, nCols)\\n self.__storeDataDict(dataArray)\\n self.__appendMetaData(filename)\\n self._appendDerivedQuantities()\",\n \"def record_time_metrics(self, metrics):\\n\\n if not self.__settings:\\n return\\n\\n for metric in metrics:\\n self.record_time_metric(metric)\",\n \"def collect(self): # pylint: disable=no-self-use\\n start = time.time()\\n\\n if \\\"jobs\\\" in PLUGIN_SETTINGS and PLUGIN_SETTINGS[\\\"jobs\\\"]:\\n for metric in metric_jobs():\\n yield metric\\n\\n if \\\"models\\\" in PLUGIN_SETTINGS:\\n for metric in metric_models(PLUGIN_SETTINGS[\\\"models\\\"]):\\n yield metric\\n\\n # --------------------------------------------------------------\\n # Extras Function defined in configuration.py or the Regristry\\n # # --------------------------------------------------------------\\n if \\\"extras\\\" in PLUGIN_SETTINGS:\\n for metric in collect_extras_metric(PLUGIN_SETTINGS[\\\"extras\\\"]):\\n yield metric\\n\\n for metric in collect_extras_metric(__REGISTRY__):\\n yield metric\\n\\n gauge = GaugeMetricFamily(\\n \\\"nautobot_app_metrics_processing_ms\\\", \\\"Time in ms to generate the app metrics endpoint\\\"\\n )\\n duration = time.time() - start\\n gauge.add_metric([], format(duration * 1000, \\\".5f\\\"))\\n yield gauge\",\n \"def metrics(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def __init__(self, in_file: str, out_file: str, sample_rate: float,\\n max_time_gap: timedelta):\\n\\n self.in_file = in_file\\n self.out_file = out_file\\n\\n # Set up the input/output file objects:\\n self.in_data = MobileData(in_file, 'r')\\n self.out_data = MobileData(out_file, 'w')\\n\\n # Hold information about the different fields to use:\\n # All fields in the input file:\\n self.all_fields = None # type: Optional[Dict[str, str]]\\n\\n # Stamp field name:\\n self.stamp_field = default_stamp_field\\n\\n # Only sensor fields:\\n self.sensor_fields = None # type: Optional[Dict[str, str]]\\n\\n # List of label fields:\\n self.label_fields = default_label_fields\\n\\n # Determine the output sample interval in seconds:\\n self.sample_interval = timedelta(seconds=1.0 / sample_rate)\\n\\n # Maximum gap between input events - longer than this and we will restart resampling:\\n self.max_time_gap = max_time_gap\\n\\n # The previous and next output stamps to use:\\n self.prev_out_stamp = None # type: Optional[datetime]\\n self.next_out_stamp = None # type: Optional[datetime]\\n\\n # The next event from the input file:\\n self.next_input_event = None # type: Optional[Dict[str, Union[float, str, datetime, None]]]\\n\\n # The last-seen input event:\\n self.last_seen_input_event = None # type: Optional[Dict[str, Union[float, str, datetime, None]]]\\n\\n # Information about input events seen in a sample interval:\\n self.num_events_in_interval = 0\\n self.interval_sensor_values = None # type: Optional[Dict[str, List[float, str]]]\\n self.interval_labels = None # type: Optional[Dict[str, List[str]]]\\n\\n # Status update info:\\n self.status_num_events_interval = status_num_events_interval\\n self.num_input_events_processed = 0\\n self.num_events_since_last_status = 0\\n self.first_event_stamp = None # type: Optional[datetime]\",\n \"def __init__(self, filepath):\\n\\n self.filepath = Path(filepath)\\n\\n # Store log data in line based format\\n self.values = None\\n self._read_log()\\n\\n # Store log data in row based format\\n self.counters = []\\n self.timestamps = []\\n self.acceleration = []\\n self._store_rows()\",\n \"def compute_metrics(self, results: list) -> dict:\\n dump(results, self.out_file_path)\\n print_log(\\n f'Results has been saved to {self.out_file_path}.',\\n logger='current')\\n return {}\",\n \"def run_single_cycle(self, collector=None):\\n\\n self._timestamp = int(time.time())\\n\\n # There are certain error conditions, such as the system not supporting\\n # a particular proc file type, that we will never recover from. So,\\n # just always early exit.\\n if self._failed:\\n return {}\\n\\n filename = self._file_pattern % self._pid\\n\\n if not collector:\\n collector = {}\\n if self._file is None:\\n try:\\n self._file = open(filename, \\\"r\\\")\\n except IOError as e:\\n # We take a simple approach. If we don't find the file or\\n # don't have permissions for it, then just don't collect this\\n # stat from now on. If the user changes the configuration file\\n # we will try again to read the file then.\\n self._failed = True\\n if e.errno == errno.EACCES:\\n self._logger.error(\\n \\\"The agent does not have permission to read %s. \\\"\\n \\\"Maybe you should run it as root.\\\",\\n filename,\\n )\\n elif e.errno == errno.ENOENT:\\n self._logger.error(\\n (\\n \\\"The agent cannot read %s. Your system may not support that proc file \\\"\\n 'type or the process with pid \\\"%s\\\" doesn\\\\'t exist'\\n ),\\n filename,\\n self._pid,\\n )\\n # Ignore 'process not found' errors (likely caused because the process exited\\n # but re-raise the exception for all other errors\\n elif e.errno != errno.ESRCH:\\n raise e\\n\\n if self._file is not None:\\n try:\\n self._file.seek(0)\\n\\n return self.gather_sample(self._file, collector=collector)\\n\\n except IOError as e:\\n # log the error if the errno isn't 'process not found'. Process not found likely means the\\n # process exited, so we ignore that because it's within the realm of expected behaviour\\n if e.errno != errno.ESRCH:\\n self._logger.error(\\n \\\"Error gathering sample for file: '%s'\\\\n\\\\t%s\\\"\\n % (filename, six.text_type(e))\\n )\\n\\n # close the file. This will cause the file to be reopened next call to run_single_cycle\\n self.close()\\n return collector\",\n \"def __init__(self, count_metrics=None, time_metrics=None, gauge_metrics=None, max_call_count=-1,\\n max_time_between_calls=-1):\\n super(InMemoryMetrics, self).__init__()\\n self._count_metrics = count_metrics if count_metrics is not None else defaultdict(int)\\n self._time_metrics = time_metrics if time_metrics is not None \\\\\\n else defaultdict(LatencyTracker)\\n self._gauge_metrics = gauge_metrics if gauge_metrics is not None else defaultdict(float)\\n self._max_call_count = max_call_count\\n self._max_time_between_calls = max_time_between_calls\\n\\n utcnow_timestamp = arrow.utcnow().timestamp\\n\\n self._count_call_count = 0\\n self._count_last_call_time = utcnow_timestamp\\n self._time_call_count = 0\\n self._time_last_call_time = utcnow_timestamp\\n self._gauge_call_count = 0\\n self._gauge_last_call_time = utcnow_timestamp\\n self._count_rlock = RLock()\\n self._time_rlock = RLock()\\n self._gauge_rlock = RLock()\\n self._ignore_metrics = False\",\n \"def _log_metrics(self, logs, prefix, step):\\r\\n if logs is None:\\r\\n logs = {}\\r\\n\\r\\n # Group metrics by the name of their associated file writer. Values\\r\\n # are lists of metrics, as (name, scalar_value) pairs.\\r\\n logs_by_writer = {\\r\\n self._train_run_name: [],\\r\\n self._validation_run_name: [],\\r\\n }\\r\\n validation_prefix = 'val_'\\r\\n for (name, value) in logs.items():\\r\\n if name in ('batch', 'size', 'num_steps'):\\r\\n # Scrub non-metric items.\\r\\n continue\\r\\n if name.startswith(validation_prefix):\\r\\n name = name[len(validation_prefix):]\\r\\n writer_name = self._validation_run_name\\r\\n else:\\r\\n writer_name = self._train_run_name\\r\\n name = prefix + name # assign batch or epoch prefix\\r\\n logs_by_writer[writer_name].append((name, value))\\r\\n\\r\\n with context.eager_mode():\\r\\n with summary_ops_v2.always_record_summaries():\\r\\n for writer_name in logs_by_writer:\\r\\n these_logs = logs_by_writer[writer_name]\\r\\n if not these_logs:\\r\\n # Don't create a \\\"validation\\\" events file if we don't\\r\\n # actually have any validation data.\\r\\n continue\\r\\n writer = self._get_writer(writer_name)\\r\\n with writer.as_default():\\r\\n for (name, value) in these_logs:\\r\\n summary_ops_v2.scalar(name, value, step=step)\",\n \"def loadFeeds(self):\\n\\n metrics = self.config['metrics']\\n for metric in metrics:\\n metricConf = self.config['metrics'][metric]\\n metricConf['name'] = metric\\n source = metricConf['source']['driver']\\n if 'metrics' not in self.sources[source['name']]:\\n self.sources[source['name']]['metrics'] = []\\n\\n self.sources[source['name']]['metrics'].append(metricConf)\",\n \"def __getitem__(self, idx):\\n if (idx >= len(self)) or (idx < 0):\\n raise IndexError(f\\\"Index {idx} if out of dataset range with {len(self)} samples\\\")\\n\\n # Identify the file containing the record\\n file_id = np.digitize(idx, self.midx_bins, right=False)\\n base_idx = self.midx_bins[file_id - 1] if file_id > 0 else 0\\n file_idx = idx - base_idx + self._header_lines\\n mdata, midx = self.mdata_midx_list[file_id]\\n # load sample\\n if file_idx == 0:\\n i = 0\\n j = midx[0]\\n else:\\n i = midx[file_idx - 1] + 1 # ignore newline\\n j = midx[file_idx]\\n\\n # fetch sample from memmap\\n\\n try:\\n sample = self._fetch_sample_from_memmap(mdata, i, j)\\n except Exception as e:\\n logging.error(f\\\"Error while fetching sample from memmap: {e}\\\")\\n logging.error(f\\\"file_id: {file_id}, file_idx: {file_idx}, i: {i}, j: {j}\\\")\\n raise e\\n\\n # parse raw text (e.g., tokenize)\\n try:\\n data = self._build_data_from_text(sample)\\n except Exception as e:\\n logging.error(\\n f\\\"Error while building data from text, possible issue with sample expected format (see offending sample below): {e}\\\"\\n )\\n logging.error(f\\\"sample: {sample}, file_id: {file_id}, file_idx: {file_idx}, i: {i}, j: {j}\\\")\\n raise e\\n\\n return data\",\n \"def metrics_group():\",\n \"def __init__(self, included_metrics: List[str]):\\n self.included_metrics = included_metrics\\n self.metrics = self._initialize_metrics()\",\n \"def readData(self):\\n f = open(self.filename)\\n self.time = []\\n self.data = []\\n for line in f:\\n if line.find('BAD FLAG') > 0:\\n self.badValue = float(line.split(':')[1].strip())\\n if line.find('LONGITUDE') > 0:\\n self.lon = line.split(':')[1].strip()\\n if line.find('LATITUDE') > 0:\\n self.lat = line.split(':')[1].strip()\\n if len(line) > 6 and line[2] == '-' and line[6] == '-':\\n parts = line.rsplit(None, 1)\\n # data line\\n timeStamp = datetime.datetime.strptime(parts[0], '%d-%b-%Y %H')\\n t = timeArray.datetimeToEpochTime(timeStamp)\\n self.time.append(t)\\n val = float(parts[1])\\n self.data.append(val)\\n\\n self.time = np.array(self.time)\\n self.data = np.array(self.data)\\n # remove bad values\\n if self.badValue:\\n goodIx = self.data != self.badValue\\n self.time = self.time[goodIx]\\n self.data = self.data[goodIx]\\n self.fileIsRead = True\",\n \"def collect_data(base='.'):\\n files = glob(join(base, 'accuracy_*.json'))\\n data = {}\\n for file in files:\\n fields = basename(file).split('_')\\n fields = fields[1:-2]\\n accuracy = load(open(file))\\n weights = load(open(file.replace('accuracy', 'weights')))\\n for model in accuracy.keys():\\n # add both accuracy and weights\\n key = tuple(fields + [model])\\n value = accuracy[model] + weights[model]\\n data[key] = value\\n return data\",\n \"def read_raw_data(self):\\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(dat_file))\\n time = []\\n voltage1 = []\\n voltage2 = []\\n with open(dat_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n time.append(line[0])\\n voltage1.append(float(line[1]))\\n voltage2.append(float(line[2]))\\n\\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(tags_file))\\n tags_time = []\\n tags = []\\n r_peaks_indexes = []\\n with open(tags_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n tags_time.append(line[0])\\n tags.append(line[2])\\n r_peaks_indexes.append(int(line[1]))\\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes\",\n \"def __init__(self):\\n\\n # sample must be between 0 and 1\\n if self.sample <= 0 or self.sample > 1:\\n raise Exception('sample {} should be > 0 and <= 1'.format(self.sample))\\n\\n # sample RDD if sample is specified AND rdd has not been pre-sampled\\n if self.sample < 1 and not self.pre_sampled:\\n self.rdd = self.rdd.sample(False, self.sample, self.seed)\\n\\n # Assign each RDD with counter. Reduce and collect.\\n collectedCounts = self.rdd.reduceByKey(lambda x,y: x+y) \\\\\\n .collect() # (id, count), number of times that count appears)\\n\\n # function that re-calculates coverage based on sampling\\n approximateCounts = lambda counts, sample: int(counts * 1.0/sample)\\n\\n # restructure each record so record structure is (key: sampleId, value: (coverage, count))\\n x = list(map(lambda x: (x[0][0], (x[0][1], approximateCounts(x[1], self.sample))), collectedCounts))\\n\\n # create dictionary where keys are the sampleId\\n self.collectedCounts = collections.defaultdict(set)\\n for k, v in x:\\n self.collectedCounts[k].add(v)\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n self.add_records(self.main_loop.log, value_dict.items())\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def do(self, callback_name, *args):\\n logger.info(\\\"Monitoring on auxiliary data started\\\")\\n value_dict = self._evaluator.evaluate(self.data_stream)\\n self.add_records(self.main_loop.log, value_dict.items())\\n logger.info(\\\"Monitoring on auxiliary data finished\\\")\",\n \"def get_accumulated_data(self, topic, start_time, end_time, units):\\n ignore_start_time = self._get_value('ignore_start_time', topic)\\n ignore_end_time = self._get_value('ignore_end_time', topic)\\n adjust_start_time = self._get_value('adjust_start_time', topic)\\n adjust_end_time = self._get_value('adjust_end_time', topic)\\n\\n if ignore_start_time:\\n self.logger.debug(\\\"Service ignoring start time.\\\")\\n start_ts = self.peek_datetime(topic) - adjust_start_time\\n else:\\n start_ts = start_time - adjust_start_time\\n\\n if ignore_end_time:\\n self.logger.debug(\\\"Service ignoring end time.\\\")\\n end_ts = self.peek_last_datetime(topic) + adjust_end_time\\n else:\\n end_ts = end_time + adjust_end_time\\n\\n self.logger.debug(\\\"Service processing interval: %f %f\\\" %(start_ts, end_ts))\\n accumulator = weewx.accum.Accum(weeutil.weeutil.TimeSpan(start_ts, end_ts))\\n\\n for data in self.get_data(topic, end_ts):\\n if data:\\n try:\\n self.logger.debug(\\\"Service data to accumulate: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(data['dateTime']), to_sorted_string(data)))\\n accumulator.addRecord(data)\\n except weewx.accum.OutOfSpan:\\n self.logger.info(\\\"Service ignoring record outside of interval %f %f %f %s\\\"\\n %(start_ts, end_ts, data['dateTime'], (to_sorted_string(data))))\\n else:\\n break\\n\\n target_data = {}\\n if not accumulator.isEmpty:\\n aggregate_data = accumulator.getRecord()\\n self.logger.debug(\\\"Service data prior to conversion is: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(aggregate_data['dateTime']), to_sorted_string(aggregate_data)))\\n target_data = weewx.units.to_std_system(aggregate_data, units)\\n self.logger.debug(\\\"Service data after to conversion is: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(target_data['dateTime']), to_sorted_string(target_data)))\\n else:\\n self.logger.debug(\\\"Dervice queue was empty\\\")\\n\\n # Force dateTime to packet's datetime so that the packet datetime is not updated to the MQTT datetime\\n if ignore_end_time:\\n target_data['dateTime'] = end_time\\n\\n return target_data\",\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 data_for_file (self):\\n rowdata = np.array([self.Train_Time_min,self.Train_Time_max,self.Train_Time_avg,\\n self.Loss_Value_min,self.Loss_Value_max,self.Loss_Value_avg,\\n self.Iterations_min,self.Iterations_max,self.Iterations_avg,\\n self.precision_avg,self.recall_avg])\\n return rowdata\\n\\n\\n \\n\\n\\n #### FUNCTION DEFINTIIONS ####\",\n \"def metadata_reporter(self):\\n logging.info('Creating summary report')\\n header = '{}\\\\n'.format(','.join(self.headers))\\n # Create a string to store all the results\\n data = str()\\n for sample in self.metadata:\\n # Add the value of the appropriate attribute to the results string\\n data += GenObject.returnattr(sample, 'name')\\n # SampleName\\n data += GenObject.returnattr(sample.run, 'SamplePlate')\\n # Genus\\n data += GenObject.returnattr(sample.general, 'closestrefseqgenus')\\n # SamplePurity\\n data += GenObject.returnattr(sample.confindr, 'num_contaminated_snvs')\\n # N50\\n n50 = GenObject.returnattr(sample.quast, 'N50',\\n number=True)\\n if n50 != '-,':\\n data += n50\\n else:\\n data += '0,'\\n # NumContigs\\n data += GenObject.returnattr(sample.quast, 'num_contigs',\\n number=True)\\n # TotalLength\\n data += GenObject.returnattr(sample.quast, 'Total_length',\\n number=True)\\n # MeanInsertSize\\n data += GenObject.returnattr(sample.quast, 'mean_insert',\\n number=True)\\n # InsertSizeSTD\\n data += GenObject.returnattr(sample.quast, 'std_insert',\\n number=True)\\n # AverageCoverageDepth\\n data += GenObject.returnattr(sample.qualimap, 'MeanCoveragedata',\\n number=True)\\n # CoverageDepthSTD\\n data += GenObject.returnattr(sample.qualimap, 'StdCoveragedata',\\n number=True)\\n # PercentGC\\n data += GenObject.returnattr(sample.quast, 'GC',\\n number=True)\\n # MASH_ReferenceGenome\\n data += GenObject.returnattr(sample.mash, 'closestrefseq')\\n # MASH_NumMatchingHashes\\n data += GenObject.returnattr(sample.mash, 'nummatches')\\n # 16S_result\\n data += GenObject.returnattr(sample.sixteens_full, 'sixteens_match')\\n # 16S PercentID\\n data += GenObject.returnattr(sample.sixteens_full, 'percent_id')\\n # CoreGenesPresent\\n data += GenObject.returnattr(sample.gdcs, 'coreresults')\\n # rMLST_Result\\n try:\\n # If the number of matches to the closest reference profile is 53, return the profile number\\n if sample.rmlst.matches == 53:\\n if type(sample.rmlst.sequencetype) is list:\\n rmlst_seq_type = ';'.join(sorted(sample.rmlst.sequencetype)).rstrip(';') + ','\\n else:\\n rmlst_seq_type = GenObject.returnattr(sample.rmlst, 'sequencetype')\\n rmlst_seq_type = rmlst_seq_type if rmlst_seq_type != 'ND,' else 'new,'\\n data += rmlst_seq_type\\n else:\\n # Otherwise the profile is set to new\\n data += 'new,'\\n except AttributeError:\\n data += 'new,'\\n # MLST_Result\\n try:\\n if sample.mlst.matches == 7:\\n if type(sample.mlst.sequencetype) is list:\\n mlst_seq_type = ';'.join(sorted(sample.mlst.sequencetype)).rstrip(';') + ','\\n else:\\n mlst_seq_type = GenObject.returnattr(sample.mlst, 'sequencetype')\\n mlst_seq_type = mlst_seq_type if mlst_seq_type != 'ND,' else 'new,'\\n data += mlst_seq_type\\n else:\\n data += 'new,'\\n except AttributeError:\\n data += 'new,'\\n # MLST_gene_X_alleles\\n try:\\n # Create a set of all the genes present in the results (gene name split from allele)\\n gene_set = {gene.split('_')[0] for gene in sample.mlst.combined_metadata_results}\\n for gene in sorted(gene_set):\\n allele_list = list()\\n # Determine all the alleles that are present for each gene\\n for allele in sample.mlst.combined_metadata_results:\\n if gene in allele:\\n allele_list.append(allele.replace(' ', '_'))\\n # If there is more than one allele in the sample, add both to the string separated by a ';'\\n if len(allele_list) > 1:\\n data += '{},'.format(';'.join(allele_list))\\n # Otherwise add the only allele\\n else:\\n data += allele_list[0] + ','\\n # If there are fewer than seven matching alleles, add a ND for each missing result\\n if len(gene_set) < 7:\\n data += (7 - len(gene_set)) * 'ND,'\\n except AttributeError:\\n # data += '-,-,-,-,-,-,-,'\\n data += 'ND,ND,ND,ND,ND,ND,ND,'\\n # E_coli_Serotype\\n try:\\n # If no O-type was found, set the output to be O-untypeable\\n if ';'.join(sample.ectyper.o_type) == '-':\\n otype = 'O-untypeable'\\n else:\\n otype = sample.ectyper.o_type\\n # Same as above for the H-type\\n if ';'.join(sample.ectyper.h_type) == '-':\\n htype = 'H-untypeable'\\n\\n else:\\n htype = sample.ectyper.h_type\\n serotype = '{otype}:{htype},'.format(otype=otype,\\n htype=htype)\\n # Add the serotype to the data string unless neither O-type not H-type were found; add ND instead\\n data += serotype if serotype != 'O-untypeable:H-untypeable,' else 'ND,'\\n except AttributeError:\\n data += 'ND,'\\n # SISTR_serovar_antigen\\n data += GenObject.returnattr(sample.sistr, 'serovar_antigen').rstrip(';')\\n # SISTR_serovar_cgMLST\\n data += GenObject.returnattr(sample.sistr, 'serovar_cgmlst')\\n # SISTR_serogroup\\n data += GenObject.returnattr(sample.sistr, 'serogroup')\\n # SISTR_h1\\n data += GenObject.returnattr(sample.sistr, 'h1').rstrip(';')\\n # SISTR_h2\\n data += GenObject.returnattr(sample.sistr, 'h2').rstrip(';')\\n # SISTR_serovar\\n data += GenObject.returnattr(sample.sistr, 'serovar')\\n # GeneSeekr_Profile\\n try:\\n if sample.genesippr.report_output:\\n data += ';'.join(sample.genesippr.report_output) + ','\\n else:\\n data += 'ND,'\\n except AttributeError:\\n data += 'ND,'\\n # Vtyper_Profile\\n data += GenObject.returnattr(sample.verotoxin, 'verotoxin_subtypes_set')\\n # AMR_Profile and resistant/sensitive status\\n if sample.resfinder_assembled.pipelineresults:\\n # Profile\\n for resistance, resistance_set in sorted(sample.resfinder_assembled.pipelineresults.items()):\\n data += '{res}({r_set});'.format(res=resistance.replace(',', ';'),\\n r_set=';'.join(sorted(list(resistance_set))))\\n data += ','\\n # Resistant/Sensitive\\n data += 'Resistant,'\\n else:\\n # Profile\\n data += 'ND,'\\n # Resistant/Sensitive\\n data += 'Sensitive,'\\n # Plasmid Result'\\n if sample.mobrecon.pipelineresults:\\n for plasmid, details in sorted(sample.mobrecon.pipelineresults.items()):\\n data += '{plasmid}({details});'.format(plasmid=plasmid,\\n details=details)\\n data += ','\\n else:\\n data += 'ND,'\\n # TotalPredictedGenes\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenestotal',\\n number=True)\\n # PredictedGenesOver3000bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover3000bp',\\n number=True)\\n # PredictedGenesOver1000bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover1000bp',\\n number=True)\\n # PredictedGenesOver500bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesover500bp',\\n number=True)\\n # PredictedGenesUnder500bp\\n data += GenObject.returnattr(sample.prodigal, 'predictedgenesunder500bp',\\n number=True)\\n # AssemblyDate\\n data += datetime.now().strftime('%Y-%m-%d') + ','\\n # PipelineVersion\\n data += self.commit + ','\\n # Name of the database used in the analyses\\n data += os.path.split(self.reffilepath)[-1] + ','\\n # Database download date\\n data += self.download_date\\n # Append a new line to the end of the results for this sample\\n data += '\\\\n'\\n # Replace any NA values with ND\\n cleandata = data.replace('NA', 'ND')\\n with open(os.path.join(self.reportpath, 'combinedMetadata.csv'), 'w') as metadatareport:\\n metadatareport.write(header)\\n metadatareport.write(cleandata)\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def save_metrics(self):\\n self.data_stats.write.format(\\\"org.apache.spark.sql.cassandra\\\").mode(\\\"append\\\").options(table=self.cassandra_stats_table, keyspace=self.cassandra_keyspace).save()\\n print (\\\"Saved data successfully\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6955891","0.69391584","0.6471244","0.63956815","0.6393039","0.63644856","0.6352858","0.6334597","0.6094666","0.6007557","0.5965609","0.59264725","0.58482134","0.5830391","0.58277","0.5824727","0.58074886","0.57781744","0.57719123","0.5734532","0.5728365","0.5672178","0.5573934","0.55538625","0.5544432","0.54948115","0.54931366","0.5488283","0.5481665","0.5479812","0.54754204","0.54436594","0.5442437","0.54304355","0.54052466","0.5394483","0.53756493","0.53573525","0.5347062","0.5342278","0.5322698","0.5318811","0.53180283","0.5297558","0.527176","0.5263396","0.52632946","0.52606744","0.52580595","0.52515453","0.52507085","0.5238428","0.5232012","0.5229966","0.52241856","0.52235484","0.5213215","0.5210929","0.52013975","0.5198738","0.51982284","0.5197051","0.51916635","0.51876044","0.51874673","0.518478","0.5171812","0.5161165","0.51554507","0.5144027","0.51420844","0.5137179","0.51362914","0.51350194","0.5134247","0.5122583","0.51123804","0.5111448","0.51091516","0.50986826","0.5095876","0.5095317","0.5093547","0.5092727","0.5083694","0.50817716","0.50790346","0.50777644","0.50709176","0.50638574","0.5061821","0.5059077","0.5053847","0.5053847","0.50531137","0.50491977","0.50474477","0.5045176","0.5041334","0.50402117"],"string":"[\n \"0.6955891\",\n \"0.69391584\",\n \"0.6471244\",\n \"0.63956815\",\n \"0.6393039\",\n \"0.63644856\",\n \"0.6352858\",\n \"0.6334597\",\n \"0.6094666\",\n \"0.6007557\",\n \"0.5965609\",\n \"0.59264725\",\n \"0.58482134\",\n \"0.5830391\",\n \"0.58277\",\n \"0.5824727\",\n \"0.58074886\",\n \"0.57781744\",\n \"0.57719123\",\n \"0.5734532\",\n \"0.5728365\",\n \"0.5672178\",\n \"0.5573934\",\n \"0.55538625\",\n \"0.5544432\",\n \"0.54948115\",\n \"0.54931366\",\n \"0.5488283\",\n \"0.5481665\",\n \"0.5479812\",\n \"0.54754204\",\n \"0.54436594\",\n \"0.5442437\",\n \"0.54304355\",\n \"0.54052466\",\n \"0.5394483\",\n \"0.53756493\",\n \"0.53573525\",\n \"0.5347062\",\n \"0.5342278\",\n \"0.5322698\",\n \"0.5318811\",\n \"0.53180283\",\n \"0.5297558\",\n \"0.527176\",\n \"0.5263396\",\n \"0.52632946\",\n \"0.52606744\",\n \"0.52580595\",\n \"0.52515453\",\n \"0.52507085\",\n \"0.5238428\",\n \"0.5232012\",\n \"0.5229966\",\n \"0.52241856\",\n \"0.52235484\",\n \"0.5213215\",\n \"0.5210929\",\n \"0.52013975\",\n \"0.5198738\",\n \"0.51982284\",\n \"0.5197051\",\n \"0.51916635\",\n \"0.51876044\",\n \"0.51874673\",\n \"0.518478\",\n \"0.5171812\",\n \"0.5161165\",\n \"0.51554507\",\n \"0.5144027\",\n \"0.51420844\",\n \"0.5137179\",\n \"0.51362914\",\n \"0.51350194\",\n \"0.5134247\",\n \"0.5122583\",\n \"0.51123804\",\n \"0.5111448\",\n \"0.51091516\",\n \"0.50986826\",\n \"0.5095876\",\n \"0.5095317\",\n \"0.5093547\",\n \"0.5092727\",\n \"0.5083694\",\n \"0.50817716\",\n \"0.50790346\",\n \"0.50777644\",\n \"0.50709176\",\n \"0.50638574\",\n \"0.5061821\",\n \"0.5059077\",\n \"0.5053847\",\n \"0.5053847\",\n \"0.50531137\",\n \"0.50491977\",\n \"0.50474477\",\n \"0.5045176\",\n \"0.5041334\",\n \"0.50402117\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65097046"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":598,"cells":{"query":{"kind":"string","value":"Closes any files held open by this reader."},"document":{"kind":"string","value":"def close(self):\n try:\n self._failed = True\n if self._file is not None:\n self._file.close()\n self._failed = False\n finally:\n self._file = 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 close( self ):\n \n for file in self._files:\n ir.file_hub.close( file )","def close_all_files(self):\r\n while self.close_file():\r\n pass","def close(self):\n if self.current_file_number is not None:\n self.fh_raw.close()\n self.current_file_number = None","def close(self):\r\n self._report_file.close()\r\n # Make sure everything's closed.\r\n for files in self._output_files.values():\r\n for f in files.values():\r\n f.close()","def close_all_file_handles(self):\n\n if isinstance(getattr(self, \"_file_handles\", None), dict):\n for fh in self._file_handles.values():\n fh.close()\n self._file_handles.clear()","def close_files(self):\n self.wb_alm.close()\n self.wb_defect.close()\n self.wb_enhancement.close()\n self.wb_incident.close()\n self.wb_destination.close()","def __del__(self):\n for f in self._files:\n f.close()","def __del__(self):\n for file in list(self.mFiles.values()):\n file.close()","def close_file_readers(file_reader_last_read_list):\n for file_reader in file_reader_last_read_list:\n file_reader[\"file_reader\"].close()","def _close(self):\n self.fh.close()","def close(self):\n self.__file_object.close()","def __del__(self):\n for handle in self._filehandles:\n handle.close()","def close(self):\n self.file.close()\n self.file = None","def close(self):\n if callable(getattr(self._file, 'close', None)):\n self._iterator.close()\n self._iterator = None\n self._unconsumed = None\n self.closed = True","def _close(self):\n for fd in self._fds:\n try:\n os.close(fd)\n except:\n pass","def close(self):\n self.__file.close()","def close(self):\n if not self.file.closed:\n self.file.close()","def _CloseOutputFiles(self):\n self.gfile.close()\n self.efile.close()","def close(self):\n if self._open:\n self.grp.file.close()\n self._open = False","def close(self):\r\n self._fp.close()","def close(self):\n self.closed = True\n for stream in self.streams:\n stream.close()","def Close(self):\n super(CPIOArchiveFile, self).Close()\n self._file_entries = None","def close(self):\n if self.file is not None:\n self.file.close()\n self.file = None","def __del__(self):\n self.close_files()","def close(self):\n self.file.close()","def close(self):\n self.file.close()","def close(self):\r\n if self._filename and self._fh:\r\n self._fh.close()\r\n self._fh = None","def close(self):\n if not self.__closed:\n self.counters = { \"error\": 0, \"warning\": 0, \"success\": 0, \"failure\": 0 }\n\n try:\n self.__flush_count = 0\n for handler in self.__filehandlers:\n handler.flush()\n self.__logger.removeHandler(handler)\n handler.close()\n except:\n # do nothing\n pass\n self.__closed = True","def close(self):\n self._file.close()","def close(self):\n self._file.close()","def close_file(self):\n self.root_group.close()","def close_file(self):\r\n self.file.close()","def close(self):\n self.f.close()","def close(self):\n self.f.close()","def close(self):\n self._fp.close()","def close(self):\n\t\tself.filep.close()","def close(self) -> None:\n self.f.close()","def close(self):\n self.flush()\n self.file.close()\n self.file = None","def close(self) -> None:\n if self.file_handler:\n self.file_handler.close()","def close(self):\n self.file_out.close()","def close_file(self):\n self.file.close()","def close_file(self):\n self.file.close()","def close(self):\n self.fout.close()","def __del__(self):\n for component_name, file in self._file_list.items():\n file.close()","def close(self):\r\n if self._session:\r\n self._session.close()\r\n self._session = None\r\n try:\r\n self._writer.remove_file()\r\n self._reader.remove_file()\r\n except Oct2PyError:\r\n pass","def close(self):\n if self.mode == \"w\":\n # Write the content index\n self.cnt.write(self.file)\n\n self.file.close()","def close(self):\n self.fileobj.close()","def close(self):\n self.fileobj.close()","def close_file_handle(self):\n if self.file_handle and self.output_file:\n self.file_handle.close()","def close(self):\n os.close(self._fd)\n self._fd = None","def _close( self ):\n for sji in self._sji_data:\n sji.close()","def close(self):\r\n self.rfile.close()\r\n self.sock_chan.close()","def close(self):\n self.out_file.close()","def close(self):\n self._progress.close()\n self._fd.close()","def close(self):\n file = self.file\n self.file = None\n self.filename = None\n self.current_line = None\n file.close()","def close(self):\r\n self._fd.close()","def Close(self):\n if not self._is_open:\n raise IOError('Not opened.')\n\n if self._exe_section:\n self._wrc_stream.close()\n\n self._exe_file.close()\n self._file_object = None\n self._is_open = False","def close(self) -> None:\n os.remove(self.FILE_NAME)","def close(self):\n if not self._f:\n return\n\n logger.info(\"Closed {} ({})\".format(self.name, self.num))\n\n self._f.close()\n self._f = None","def close(self):\n if self._open:\n self._open = False","def close(self):\n os.close(self.fd)","def file_close(self):\n if self.on_disk:\n self._subarray.close()","def close(self) -> None:\n self.pages = []\n for fo, _reader in self.inputs:\n fo.close()\n\n self.inputs = []\n self.output = None","def Close(self): \n posix.close(self.File)","def close_links(self):\n for uri, cf in self._cfs.items():\n cf.close_link()\n\n self._is_open = False","def close(self):\n self.closed = True\n for cursor in self.cursors:\n try:\n cursor.close()\n except exceptions.Error:\n pass # already closed","def close(self):\n\n self.r.close()","def close(self, **kw) -> None:\n super().close(**kw)\n self._file.close()","def close(self):\n if self._fd_out is not None:\n os.close(self._fd_out)\n self._fd_out = None\n if self._fd_in is not None:\n os.close(self._fd_in)\n self._fd_in = None","def close(self) -> None:\n self._data_read_thread_exit.set()\n self._plc_raw_reader.close()","def close(self):\n if self._writable and not self._closed:\n self._closed = True\n with self._seek_lock:\n self._flush_raw_or_buffered()\n if self._seek:\n with handle_os_exceptions():\n self._close_writable()","def close(self):\n self.hdfile.close()","def close(self):\n self.hdfile.close()","def close(self):\n\n\t\tfd = self._fd\n\t\tif fd is not None:\n\t\t\tself._fd = None\n\t\t\tos.close(fd)","def Close(self):\n if not self._is_open:\n raise IOError('Storage file already closed.')\n\n if not self._read_only:\n self.Flush()\n\n if self._serializers_profiler:\n self._serializers_profiler.Write()\n\n # Make sure to flush the caches so that zipfile can be closed and freed.\n # Otherwise on Windows the ZIP file remains locked and cannot be renamed.\n\n self._offset_tables = {}\n self._offset_tables_lfu = []\n\n self._open_streams = {}\n self._streams_lfu = []\n\n self._event_timestamp_tables = {}\n self._event_timestamp_tables_lfu = []\n\n self._zipfile.close()\n self._zipfile = None\n self._is_open = False\n\n file_renamed = False\n if self._path != self._zipfile_path and os.path.exists(self._zipfile_path):\n # On Windows the file can sometimes be still in use and we have to wait.\n for attempt in range(1, self._MAXIMUM_NUMBER_OF_LOCKED_FILE_ATTEMPTS):\n try:\n os.rename(self._zipfile_path, self._path)\n file_renamed = True\n break\n\n except OSError:\n if attempt == self._MAXIMUM_NUMBER_OF_LOCKED_FILE_ATTEMPTS:\n raise\n time.sleep(self._LOCKED_FILE_SLEEP_TIME)\n\n self._path = None\n self._zipfile_path = None\n\n if self._path != self._zipfile_path and not file_renamed:\n raise IOError('Unable to close storage file.')","def close(self, close_file=True):\n if self.__ref is not None:\n self.__lib.flush()\n if close_file == True:\n self.__ref.close()\n self.__ref = None\n self.__lib = None","def close(self):\n self.ref_as_count_h5.close()\n self.alt_as_count_h5.close()\n self.read_count_h5.close()","def __del__(self):\n\n if self._is_open:\n self.close()","def close(self):\n\n try:\n self.test.close()\n except Exception as e:\n pass\n\n try:\n self.valid.close()\n except Exception as e:\n pass\n\n for f in self.train:\n try:\n f.close()\n except Exception as e:\n pass","def Close(self):\n self._RaiseIfNotWritable()\n\n self._storage_file.Close()\n self._storage_file = None","def release(self, path, fh, *args, **pargs):\n with(self.rwlock):\n # If we're closing a FLACCue file...\n if(path in self._open_subtracks):\n # Delete the file handle from the stored list.\n del self._open_subtracks[path]['Positions'][fh]\n # Close the OS reference to the file.\n return os.close(fh)","def close():\n # self.consumer.close()\n # close file handler\n LOGGER.info(\"consumer is closed!!\")","def close(self):\n for lrms in self.resources.itervalues():\n lrms.close()","async def close(self):\n self.writer.close()\n await self.writer.wait_closed()\n self.reader = None\n self.writer = None\n self.ref = Ref()","def close(self):\n if not self._open:\n return\n\n # Close out the flush thread, if necessary.\n self._wait_for_flush(interrupt=True)\n\n if self._shelf is not None:\n self._shelf.close()\n self._shelf = None\n\n if self._dir is not None:\n shutil.rmtree(self._dir)\n self._dir = None\n\n if self._cache is not None:\n self._cache.clear()\n self._cache = None\n\n if self._recency is not None:\n self._recency.clear()\n self._recency = None\n\n self._open = False","def close(self):\n self.extractor.close()","def close(self):\n self._stream.close()\n self._arch.close()","def close(self):\n self.read1_batch = None\n self.read2_batch = None\n self.writer.close()","def close(self):\n if hasattr(self, '_fd'):\n if self._fd is not None:\n os.close(self._fd)\n self._fd = None\n self._name = None","def close_file(file):\n file.close()","def close(self):\r\n if not self.closed:\r\n for result in self._decrefAsync():\r\n pass","def close(self):\n self.is_open = False","def unload(self):\n for f in self.logs.values():\n f.close()","def finalize(self):\n self.ratings.close()\n self.users.close()\n self.movies.close()","def _safe_close(self, fds):\n for fd in fds:\n try:\n os.close(fd)\n except OSError as err:\n if err.errno != errno.EBADF:\n raise\n # TODO(kota_): fd might be closed already, so if already\n # closed, OSError will be raised. we need more refactor to\n # keep clean the file discriptors.\n pass","def __del__(self):\n self.file.close()","def __del__(self):\n self.f.close()","def Close(self):\n self._task_storage_reader.Close()\n self._task_storage_reader = None","def close(self):\n self.handle.close()","def _close_writers(self):\r\n with context.eager_mode():\r\n for writer in six.itervalues(self._writers):\r\n writer.close()\r\n self._writers.clear()"],"string":"[\n \"def close( self ):\\n \\n for file in self._files:\\n ir.file_hub.close( file )\",\n \"def close_all_files(self):\\r\\n while self.close_file():\\r\\n pass\",\n \"def close(self):\\n if self.current_file_number is not None:\\n self.fh_raw.close()\\n self.current_file_number = None\",\n \"def close(self):\\r\\n self._report_file.close()\\r\\n # Make sure everything's closed.\\r\\n for files in self._output_files.values():\\r\\n for f in files.values():\\r\\n f.close()\",\n \"def close_all_file_handles(self):\\n\\n if isinstance(getattr(self, \\\"_file_handles\\\", None), dict):\\n for fh in self._file_handles.values():\\n fh.close()\\n self._file_handles.clear()\",\n \"def close_files(self):\\n self.wb_alm.close()\\n self.wb_defect.close()\\n self.wb_enhancement.close()\\n self.wb_incident.close()\\n self.wb_destination.close()\",\n \"def __del__(self):\\n for f in self._files:\\n f.close()\",\n \"def __del__(self):\\n for file in list(self.mFiles.values()):\\n file.close()\",\n \"def close_file_readers(file_reader_last_read_list):\\n for file_reader in file_reader_last_read_list:\\n file_reader[\\\"file_reader\\\"].close()\",\n \"def _close(self):\\n self.fh.close()\",\n \"def close(self):\\n self.__file_object.close()\",\n \"def __del__(self):\\n for handle in self._filehandles:\\n handle.close()\",\n \"def close(self):\\n self.file.close()\\n self.file = None\",\n \"def close(self):\\n if callable(getattr(self._file, 'close', None)):\\n self._iterator.close()\\n self._iterator = None\\n self._unconsumed = None\\n self.closed = True\",\n \"def _close(self):\\n for fd in self._fds:\\n try:\\n os.close(fd)\\n except:\\n pass\",\n \"def close(self):\\n self.__file.close()\",\n \"def close(self):\\n if not self.file.closed:\\n self.file.close()\",\n \"def _CloseOutputFiles(self):\\n self.gfile.close()\\n self.efile.close()\",\n \"def close(self):\\n if self._open:\\n self.grp.file.close()\\n self._open = False\",\n \"def close(self):\\r\\n self._fp.close()\",\n \"def close(self):\\n self.closed = True\\n for stream in self.streams:\\n stream.close()\",\n \"def Close(self):\\n super(CPIOArchiveFile, self).Close()\\n self._file_entries = None\",\n \"def close(self):\\n if self.file is not None:\\n self.file.close()\\n self.file = None\",\n \"def __del__(self):\\n self.close_files()\",\n \"def close(self):\\n self.file.close()\",\n \"def close(self):\\n self.file.close()\",\n \"def close(self):\\r\\n if self._filename and self._fh:\\r\\n self._fh.close()\\r\\n self._fh = None\",\n \"def close(self):\\n if not self.__closed:\\n self.counters = { \\\"error\\\": 0, \\\"warning\\\": 0, \\\"success\\\": 0, \\\"failure\\\": 0 }\\n\\n try:\\n self.__flush_count = 0\\n for handler in self.__filehandlers:\\n handler.flush()\\n self.__logger.removeHandler(handler)\\n handler.close()\\n except:\\n # do nothing\\n pass\\n self.__closed = True\",\n \"def close(self):\\n self._file.close()\",\n \"def close(self):\\n self._file.close()\",\n \"def close_file(self):\\n self.root_group.close()\",\n \"def close_file(self):\\r\\n self.file.close()\",\n \"def close(self):\\n self.f.close()\",\n \"def close(self):\\n self.f.close()\",\n \"def close(self):\\n self._fp.close()\",\n \"def close(self):\\n\\t\\tself.filep.close()\",\n \"def close(self) -> None:\\n self.f.close()\",\n \"def close(self):\\n self.flush()\\n self.file.close()\\n self.file = None\",\n \"def close(self) -> None:\\n if self.file_handler:\\n self.file_handler.close()\",\n \"def close(self):\\n self.file_out.close()\",\n \"def close_file(self):\\n self.file.close()\",\n \"def close_file(self):\\n self.file.close()\",\n \"def close(self):\\n self.fout.close()\",\n \"def __del__(self):\\n for component_name, file in self._file_list.items():\\n file.close()\",\n \"def close(self):\\r\\n if self._session:\\r\\n self._session.close()\\r\\n self._session = None\\r\\n try:\\r\\n self._writer.remove_file()\\r\\n self._reader.remove_file()\\r\\n except Oct2PyError:\\r\\n pass\",\n \"def close(self):\\n if self.mode == \\\"w\\\":\\n # Write the content index\\n self.cnt.write(self.file)\\n\\n self.file.close()\",\n \"def close(self):\\n self.fileobj.close()\",\n \"def close(self):\\n self.fileobj.close()\",\n \"def close_file_handle(self):\\n if self.file_handle and self.output_file:\\n self.file_handle.close()\",\n \"def close(self):\\n os.close(self._fd)\\n self._fd = None\",\n \"def _close( self ):\\n for sji in self._sji_data:\\n sji.close()\",\n \"def close(self):\\r\\n self.rfile.close()\\r\\n self.sock_chan.close()\",\n \"def close(self):\\n self.out_file.close()\",\n \"def close(self):\\n self._progress.close()\\n self._fd.close()\",\n \"def close(self):\\n file = self.file\\n self.file = None\\n self.filename = None\\n self.current_line = None\\n file.close()\",\n \"def close(self):\\r\\n self._fd.close()\",\n \"def Close(self):\\n if not self._is_open:\\n raise IOError('Not opened.')\\n\\n if self._exe_section:\\n self._wrc_stream.close()\\n\\n self._exe_file.close()\\n self._file_object = None\\n self._is_open = False\",\n \"def close(self) -> None:\\n os.remove(self.FILE_NAME)\",\n \"def close(self):\\n if not self._f:\\n return\\n\\n logger.info(\\\"Closed {} ({})\\\".format(self.name, self.num))\\n\\n self._f.close()\\n self._f = None\",\n \"def close(self):\\n if self._open:\\n self._open = False\",\n \"def close(self):\\n os.close(self.fd)\",\n \"def file_close(self):\\n if self.on_disk:\\n self._subarray.close()\",\n \"def close(self) -> None:\\n self.pages = []\\n for fo, _reader in self.inputs:\\n fo.close()\\n\\n self.inputs = []\\n self.output = None\",\n \"def Close(self): \\n posix.close(self.File)\",\n \"def close_links(self):\\n for uri, cf in self._cfs.items():\\n cf.close_link()\\n\\n self._is_open = False\",\n \"def close(self):\\n self.closed = True\\n for cursor in self.cursors:\\n try:\\n cursor.close()\\n except exceptions.Error:\\n pass # already closed\",\n \"def close(self):\\n\\n self.r.close()\",\n \"def close(self, **kw) -> None:\\n super().close(**kw)\\n self._file.close()\",\n \"def close(self):\\n if self._fd_out is not None:\\n os.close(self._fd_out)\\n self._fd_out = None\\n if self._fd_in is not None:\\n os.close(self._fd_in)\\n self._fd_in = None\",\n \"def close(self) -> None:\\n self._data_read_thread_exit.set()\\n self._plc_raw_reader.close()\",\n \"def close(self):\\n if self._writable and not self._closed:\\n self._closed = True\\n with self._seek_lock:\\n self._flush_raw_or_buffered()\\n if self._seek:\\n with handle_os_exceptions():\\n self._close_writable()\",\n \"def close(self):\\n self.hdfile.close()\",\n \"def close(self):\\n self.hdfile.close()\",\n \"def close(self):\\n\\n\\t\\tfd = self._fd\\n\\t\\tif fd is not None:\\n\\t\\t\\tself._fd = None\\n\\t\\t\\tos.close(fd)\",\n \"def Close(self):\\n if not self._is_open:\\n raise IOError('Storage file already closed.')\\n\\n if not self._read_only:\\n self.Flush()\\n\\n if self._serializers_profiler:\\n self._serializers_profiler.Write()\\n\\n # Make sure to flush the caches so that zipfile can be closed and freed.\\n # Otherwise on Windows the ZIP file remains locked and cannot be renamed.\\n\\n self._offset_tables = {}\\n self._offset_tables_lfu = []\\n\\n self._open_streams = {}\\n self._streams_lfu = []\\n\\n self._event_timestamp_tables = {}\\n self._event_timestamp_tables_lfu = []\\n\\n self._zipfile.close()\\n self._zipfile = None\\n self._is_open = False\\n\\n file_renamed = False\\n if self._path != self._zipfile_path and os.path.exists(self._zipfile_path):\\n # On Windows the file can sometimes be still in use and we have to wait.\\n for attempt in range(1, self._MAXIMUM_NUMBER_OF_LOCKED_FILE_ATTEMPTS):\\n try:\\n os.rename(self._zipfile_path, self._path)\\n file_renamed = True\\n break\\n\\n except OSError:\\n if attempt == self._MAXIMUM_NUMBER_OF_LOCKED_FILE_ATTEMPTS:\\n raise\\n time.sleep(self._LOCKED_FILE_SLEEP_TIME)\\n\\n self._path = None\\n self._zipfile_path = None\\n\\n if self._path != self._zipfile_path and not file_renamed:\\n raise IOError('Unable to close storage file.')\",\n \"def close(self, close_file=True):\\n if self.__ref is not None:\\n self.__lib.flush()\\n if close_file == True:\\n self.__ref.close()\\n self.__ref = None\\n self.__lib = None\",\n \"def close(self):\\n self.ref_as_count_h5.close()\\n self.alt_as_count_h5.close()\\n self.read_count_h5.close()\",\n \"def __del__(self):\\n\\n if self._is_open:\\n self.close()\",\n \"def close(self):\\n\\n try:\\n self.test.close()\\n except Exception as e:\\n pass\\n\\n try:\\n self.valid.close()\\n except Exception as e:\\n pass\\n\\n for f in self.train:\\n try:\\n f.close()\\n except Exception as e:\\n pass\",\n \"def Close(self):\\n self._RaiseIfNotWritable()\\n\\n self._storage_file.Close()\\n self._storage_file = None\",\n \"def release(self, path, fh, *args, **pargs):\\n with(self.rwlock):\\n # If we're closing a FLACCue file...\\n if(path in self._open_subtracks):\\n # Delete the file handle from the stored list.\\n del self._open_subtracks[path]['Positions'][fh]\\n # Close the OS reference to the file.\\n return os.close(fh)\",\n \"def close():\\n # self.consumer.close()\\n # close file handler\\n LOGGER.info(\\\"consumer is closed!!\\\")\",\n \"def close(self):\\n for lrms in self.resources.itervalues():\\n lrms.close()\",\n \"async def close(self):\\n self.writer.close()\\n await self.writer.wait_closed()\\n self.reader = None\\n self.writer = None\\n self.ref = Ref()\",\n \"def close(self):\\n if not self._open:\\n return\\n\\n # Close out the flush thread, if necessary.\\n self._wait_for_flush(interrupt=True)\\n\\n if self._shelf is not None:\\n self._shelf.close()\\n self._shelf = None\\n\\n if self._dir is not None:\\n shutil.rmtree(self._dir)\\n self._dir = None\\n\\n if self._cache is not None:\\n self._cache.clear()\\n self._cache = None\\n\\n if self._recency is not None:\\n self._recency.clear()\\n self._recency = None\\n\\n self._open = False\",\n \"def close(self):\\n self.extractor.close()\",\n \"def close(self):\\n self._stream.close()\\n self._arch.close()\",\n \"def close(self):\\n self.read1_batch = None\\n self.read2_batch = None\\n self.writer.close()\",\n \"def close(self):\\n if hasattr(self, '_fd'):\\n if self._fd is not None:\\n os.close(self._fd)\\n self._fd = None\\n self._name = None\",\n \"def close_file(file):\\n file.close()\",\n \"def close(self):\\r\\n if not self.closed:\\r\\n for result in self._decrefAsync():\\r\\n pass\",\n \"def close(self):\\n self.is_open = False\",\n \"def unload(self):\\n for f in self.logs.values():\\n f.close()\",\n \"def finalize(self):\\n self.ratings.close()\\n self.users.close()\\n self.movies.close()\",\n \"def _safe_close(self, fds):\\n for fd in fds:\\n try:\\n os.close(fd)\\n except OSError as err:\\n if err.errno != errno.EBADF:\\n raise\\n # TODO(kota_): fd might be closed already, so if already\\n # closed, OSError will be raised. we need more refactor to\\n # keep clean the file discriptors.\\n pass\",\n \"def __del__(self):\\n self.file.close()\",\n \"def __del__(self):\\n self.f.close()\",\n \"def Close(self):\\n self._task_storage_reader.Close()\\n self._task_storage_reader = None\",\n \"def close(self):\\n self.handle.close()\",\n \"def _close_writers(self):\\r\\n with context.eager_mode():\\r\\n for writer in six.itervalues(self._writers):\\r\\n writer.close()\\r\\n self._writers.clear()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7826722","0.77460366","0.7503366","0.72826236","0.72478783","0.7243321","0.7204818","0.7204593","0.7146203","0.7134031","0.7112463","0.71020526","0.70459485","0.7036263","0.70164305","0.7010969","0.6980717","0.6947164","0.6919161","0.68919945","0.6887085","0.68868184","0.6877383","0.6867741","0.6864131","0.6864131","0.685468","0.6841972","0.6820519","0.6820519","0.6812216","0.67919236","0.6785009","0.6785009","0.6784231","0.6756157","0.6723754","0.6718719","0.67129797","0.6705118","0.66987896","0.66987896","0.66895354","0.66576064","0.66409343","0.6634567","0.6630885","0.6630885","0.6616791","0.6607254","0.6607219","0.6594297","0.6589888","0.6580542","0.6561231","0.6556022","0.65507317","0.6540388","0.65108746","0.65092653","0.6507087","0.6498388","0.6496773","0.649256","0.64918256","0.64800406","0.6459277","0.6446404","0.6443788","0.64366686","0.6435256","0.64265054","0.64265054","0.6419693","0.64104664","0.6376057","0.6364515","0.6345504","0.63419175","0.6335406","0.63319385","0.632894","0.63281256","0.6322816","0.6321847","0.6315202","0.63033295","0.62970215","0.6295853","0.6272278","0.625856","0.62504214","0.62483484","0.6246879","0.6243328","0.6233657","0.62234163","0.621895","0.6216547","0.6210955"],"string":"[\n \"0.7826722\",\n \"0.77460366\",\n \"0.7503366\",\n \"0.72826236\",\n \"0.72478783\",\n \"0.7243321\",\n \"0.7204818\",\n \"0.7204593\",\n \"0.7146203\",\n \"0.7134031\",\n \"0.7112463\",\n \"0.71020526\",\n \"0.70459485\",\n \"0.7036263\",\n \"0.70164305\",\n \"0.7010969\",\n \"0.6980717\",\n \"0.6947164\",\n \"0.6919161\",\n \"0.68919945\",\n \"0.6887085\",\n \"0.68868184\",\n \"0.6877383\",\n \"0.6867741\",\n \"0.6864131\",\n \"0.6864131\",\n \"0.685468\",\n \"0.6841972\",\n \"0.6820519\",\n \"0.6820519\",\n \"0.6812216\",\n \"0.67919236\",\n \"0.6785009\",\n \"0.6785009\",\n \"0.6784231\",\n \"0.6756157\",\n \"0.6723754\",\n \"0.6718719\",\n \"0.67129797\",\n \"0.6705118\",\n \"0.66987896\",\n \"0.66987896\",\n \"0.66895354\",\n \"0.66576064\",\n \"0.66409343\",\n \"0.6634567\",\n \"0.6630885\",\n \"0.6630885\",\n \"0.6616791\",\n \"0.6607254\",\n \"0.6607219\",\n \"0.6594297\",\n \"0.6589888\",\n \"0.6580542\",\n \"0.6561231\",\n \"0.6556022\",\n \"0.65507317\",\n \"0.6540388\",\n \"0.65108746\",\n \"0.65092653\",\n \"0.6507087\",\n \"0.6498388\",\n \"0.6496773\",\n \"0.649256\",\n \"0.64918256\",\n \"0.64800406\",\n \"0.6459277\",\n \"0.6446404\",\n \"0.6443788\",\n \"0.64366686\",\n \"0.6435256\",\n \"0.64265054\",\n \"0.64265054\",\n \"0.6419693\",\n \"0.64104664\",\n \"0.6376057\",\n \"0.6364515\",\n \"0.6345504\",\n \"0.63419175\",\n \"0.6335406\",\n \"0.63319385\",\n \"0.632894\",\n \"0.63281256\",\n \"0.6322816\",\n \"0.6321847\",\n \"0.6315202\",\n \"0.63033295\",\n \"0.62970215\",\n \"0.6295853\",\n \"0.6272278\",\n \"0.625856\",\n \"0.62504214\",\n \"0.62483484\",\n \"0.6246879\",\n \"0.6243328\",\n \"0.6233657\",\n \"0.62234163\",\n \"0.621895\",\n \"0.6216547\",\n \"0.6210955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6589813"},"document_rank":{"kind":"string","value":"53"}}},{"rowIdx":599,"cells":{"query":{"kind":"string","value":"Returns the number of centiseconds (1/100ths secs) for the given number of jiffies (a weird timing unit used the kernel)."},"document":{"kind":"string","value":"def __calculate_time_cs(self, jiffies):\n\n return int((jiffies * 100.0) / self._jiffies_per_sec)"},"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_time_ms(self, jiffies):\n\n return int((jiffies * 1000.0) / self._jiffies_per_sec)","def jiffies(_load_time=time.time()):\n return int(100*(time.time()-_load_time))","def _nsec_to_usec_round(nsec):\n return (nsec + 500) // 10 ** 3","def millis(): \n return int(round(monotonic.monotonic() * C.MILLISECONDS))","def millis(): \r\n return int(round(monotonic.monotonic() * C.MILLISECONDS))","def jiffies(_proc_pid_stat = '/proc/%s/stat'%(os.getpid()),\n _load_time=time.time()):\n try:\n f=open(_proc_pid_stat,'r')\n l = f.readline().split(' ')\n f.close()\n return int(l[13])\n except:\n return int(100*(time.time()-_load_time))","def elapsed_micros(start: int, /) -> int:","def _probe_wait_time(self):\n r = self.probe_cycle_time / float(len(self.servers)) #self.probe_cycle_time=5\n r = max(.25, r) # Cap it at four per second\n return r","def get_total_cpu_clock_cycles():\n try:\n with open(LINUX_STAT_LOCATION, 'r') as f:\n cpu_entries = f.readline().split(' ')\n except IOError:\n return None\n\n cpu_cycles = 0\n for entry in cpu_entries:\n try:\n cpu_cycles += int(entry)\n except ValueError:\n pass\n return cpu_cycles","def _get_cpu_interval(self):\n self._polling_execute_frequency = int(self._plugin_conf[u'main'][u'polling_frequency'])\n\n if 5 <= self._polling_execute_frequency < 60:\n return cpmCPUTotalMonIntervalValue # replaces cpmCPUTotal5SecRev\n elif 60 <= self._polling_execute_frequency < 300:\n return cpmCPUTotal1minRev\n elif 300 <= self._polling_execute_frequency:\n return cpmCPUTotal5minRev\n else:\n return cpmCPUTotal1minRev","def ticks_per_second(self):\n return self._ticks_per_second","def millis(start_time):\n dt = datetime.now() - start_time\n ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0\n return ms","def curTimeMs():\n\treturn int((datetime.utcnow() - datetime(1970,1,1)).total_seconds() * 1000)","def getTime():\n\n return float(time.perf_counter()*1000)","def tick(self):\n prev_last_tick = self.last_tick_\n self.last_tick_ = timeit.default_timer()\n latest_tick_period = self.last_tick_ - prev_last_tick\n return latest_tick_period","def millis() -> int:","def millis():\n return int(round(time() * 1000))","def get_clock_divisor(self):\n return self.o.read_register(self.dev_id, CLOCK_DIVISOR)","def getTime():\n return float(time.perf_counter()*1000)","def getTime():\n return float(time.perf_counter()*1000)","def getTime():\n return float(time.perf_counter()*1000)","def getTime():\n return float(time.perf_counter()*1000)","def getTime():\n return float(time.perf_counter()*1000)","def getTime():\n return float(time.perf_counter()*1000)","def _unit_sec(self):\n return self.time_base / 60.0","def _get_milleseconds(self):\n return int(round(time.time() * 1000))","def _time_ms(dt):\n epoch = datetime.datetime.utcfromtimestamp(0)\n diff = dt - epoch\n return diff.total_seconds() * 1000","def _unit_ms(self):\n return (self.time_base / 1000.0) / 60.0","def __micros():\n return round(time.time() * 1000000)","def _STEPS2TIME(step):\n return step/1000.","def _current_epoch_secs():\n now = datetime.datetime.utcnow()\n epoch = datetime.datetime(1970, 1, 1)\n return (now - epoch).total_seconds()","def n_elements(x, dist, var=None):\n n = dist/mdiff(x)\n if var == 'time':\n n = n/60\n return int(np.round(n))","def np_dt_epoch_msec(value):\n return value.astype(long) / 1000","def num_microseconds(self, td):\n return float(td.microseconds + 1000000 * (td.seconds + 86400 * td.days))","def get_timebase(self,dt):\r\n\r\n if dt < 1E-9:\r\n dt = 1E-9\r\n\r\n if dt > 4E-9:\r\n n = int(dt*125E6 + 2)\r\n else:\r\n dt *= 1E9\r\n n = round(log(dt,2))\r\n return n","def calculer_energie_cinetique_tnt(energie_cinetique):\n return energie_cinetique / 4184","def unit_ms(self):\n return (self.time_base / 1000.0) / 60.0","def unit_sec(self):\n return self.time_base / 60.0","def sequenceTime_sec(cmds):\n cycles = sum(MemorySequence.cmdTime_cycles(c) for c in cmds)\n return cycles * 40e-9 # assume 25 MHz clock -> 40 ns per cycle","def timefactor(self, period):\n\t\tdays = period.size() * self.daysinunit(period.unit)\n\t\treturn float(days)/self.daysinbase","def transmission_time_us(self, num_bytes):\n bits_to_transmit = num_bytes * 8\n transmission_time_us = (bits_to_transmit / self.megabits_per_second)\n return transmission_time_us","def cpu_times(percpu=False):\r\n if not percpu:\r\n return _get_sys_cpu_times()\r\n else:\r\n return _get_sys_per_cpu_times()","def __timedelta_millis(td):\n return int(round(td.total_seconds(), 3) * 1000)","def getNowMilliseconds():\n return (datetime.datetime.utcnow() - Common.epoch_).total_seconds() * 1000.0","def cputime(conn):\n c = conn.cursor()\n r = c.execute(\"SELECT SUM(length) as total_bin_time FROM event WHERE bin_id not null\").fetchall()\n total_bin_time = r[0]['total_bin_time'];\n last_time = maxtime(conn)\n\n cputime = 0\n if total_bin_time and last_time:\n cpu_time = total_bin_time / last_time\n\n return {\n \"cpu_time\":cpu_time\n }","def calculate_seconds_in_days(days):\n return int(days * 86400)","def cpu_percent(interval=0.1, percpu=False):\r\n global _last_cpu_times\r\n global _last_per_cpu_times\r\n blocking = interval is not None and interval > 0.0\r\n\r\n def calculate(t1, t2):\r\n t1_all = sum(t1)\r\n t1_busy = t1_all - t1.idle\r\n\r\n t2_all = sum(t2)\r\n t2_busy = t2_all - t2.idle\r\n\r\n # this usually indicates a float precision issue\r\n if t2_busy <= t1_busy:\r\n return 0.0\r\n\r\n busy_delta = t2_busy - t1_busy\r\n all_delta = t2_all - t1_all\r\n busy_perc = (busy_delta / all_delta) * 100\r\n return round(busy_perc, 1)\r\n\r\n # system-wide usage\r\n if not percpu:\r\n if blocking:\r\n t1 = cpu_times()\r\n time.sleep(interval)\r\n else:\r\n t1 = _last_cpu_times\r\n _last_cpu_times = cpu_times()\r\n return calculate(t1, _last_cpu_times)\r\n # per-cpu usage\r\n else:\r\n ret = []\r\n if blocking:\r\n tot1 = cpu_times(percpu=True)\r\n time.sleep(interval)\r\n else:\r\n tot1 = _last_per_cpu_times\r\n _last_per_cpu_times = cpu_times(percpu=True)\r\n for t1, t2 in zip(tot1, _last_per_cpu_times):\r\n ret.append(calculate(t1, t2))\r\n return ret","def cps(self):\n return self.datacounts / self.exptime","def now():\n\n return rospy.Time.now().to_nsec()","def get_millis(seconds):\n return seconds * 10 ** 3","def microseconds_since_epoch(date_time, epoch=None):\n if not epoch:\n epoch = datetime.datetime.utcfromtimestamp(0)\n\n delta = date_time - epoch\n\n # 86400 is 24 * 60 * 60 e.g. total seconds in a day\n return delta.microseconds + (delta.seconds + delta.days * 86400) * 10**6","def time(n):\n steps = 3 + math.ceil(n/5.0)*2\n return steps","def unix_time_nanos(dt):\n return timedelta_to_micros(dt - epoch)","def millisecond():\n return int(round(time.time() * 1000))","def dt_epoch_msecs(value):\n return long(calendar.timegm(value.timetuple())) * 1000","def EpochNano():\n return int(time.time() * 1000000000)","def ms(self):\n # my clock uses seconds internally\n return 1000 * self.read()","def timeScale(self) -> int:\n return int(1 / (1 - self.momentum))","def _time_ms(self, dt):\n if dt.tzinfo is None:\n dt = dt.replace(tzinfo=pytz.utc)\n return int((dt - self._EPOCH).total_seconds() * 1000)","def time(self) -> float:\n return self.state.game_loop / 22.4 # / (1/1.4) * (1/16)","def measure_time(n: int, max_delay: int) -> float:\n start_time = time.time()\n asyncio.run(wait_n(n, max_delay))\n return (time.time() - start_time) / n","def get_time_ms():\n return int(round(time.time() * 1000))","def measure_time(n: int, max_delay: int) -> float:\n t0 = time.time()\n asyncio.run(wait_n(n, max_delay))\n t1 = time.time()\n total_time = t1 - t0\n return total_time / n","def elapsed_millis(start: int, /) -> int:","def unix_time_millisecond(date):\r\n return unix_time(date, float=True) * 1e3","def _nowms():\n return int(time.time() * 1000)","def _calc_time_precision(sampling_rate):\n\n # convert sampling rate to int\n sampling_rate = int(sampling_rate)\n\n # calculate the first remainder\n remainder = 1 % sampling_rate\n\n # list for holding all remainders that have been calculated\n seen_remainders = []\n\n # calculate all other remainders until the modulo operation yields either zero or the remainder has already appeared\n # before (this is when the periodicity starts)\n while (remainder != 0) and (remainder not in seen_remainders):\n # append the current remainder to the seen remainder list\n seen_remainders.append(remainder)\n\n # multiply the remainder by ten (this is basically the process of converting a fraction to a decimal number\n # using long division\n remainder = remainder * 10\n\n # calculate the next remainder\n remainder = remainder % sampling_rate\n\n return len(seen_remainders) + 1","def get_cpu_clock_cycles_of_pid(pid):\n try:\n with open(LINUX_PROCESS_STAT_LOCATION % pid, 'r') as f:\n pid_entries = f.read().split(' ')\n except IOError:\n return None\n\n pid_cycles = 0\n if len(pid_entries) > 14:\n pid_cycles = int(pid_entries[13]) + int(pid_entries[14])\n return pid_cycles","def part1() -> int:\n longest_sleeper = max(sleep_times, key=lambda g: len(sleep_times[g]))\n sleepiest_minute = max(\n sleep_times[longest_sleeper], key=sleep_times[longest_sleeper].count)\n\n return longest_sleeper * sleepiest_minute","def _GetSecsUntilNextPass(self):\n op = util.CheckedOp('retrieving last GC pass time',\n self.engine.Get,\n KEY_LAST_PASS_TIME)\n\n if not op.success:\n return None\n\n last_compute = float(op.response_value) if op.response_value else 0\n return last_compute + self.gc_frequency - time.time()","def hz2cents(pitchInHz, tonic=261.626):\n cents = 1200*np.log2(1.0*pitchInHz/tonic)\n return cents","def time(self):\n return sum(self._interval) * .5","def seconds_since_epoch(date_time, epoch=None):\n return microseconds_since_epoch(date_time) / 10.0**6","def _calibrate_time(self):\n time_overhead = 0\n for i in range(1000):\n start = self._adjusted_time()\n end = self._adjusted_time()\n time_overhead += end - start\n return time_overhead / 1000","def curr_time_millis():\n return 1000 * timeit.default_timer()","def millis(self):\n return self._micros // 1000","def units_to_msec(units, resolution):\n time_ms = units * float(resolution) / 1000\n return time_ms","def MillisToSec(self):\n self.Millis = [item / 1000 for item in self.Millis]\n return self.Millis","def period_cntfrac_sqrt(num):\r\n r = limit = int(sqrt(num))\r\n if limit * limit == num:\r\n return 0\r\n k, period = 1, 0\r\n while k != 1 or period == 0:\r\n k = (num - r * r) / k\r\n r = ((limit + r) / k) * k - r\r\n period += 1\r\n return period","def frequency(self):\n return self.reference_clock_speed / 4096 / self.prescale_reg","def tick(self):\n self.delta = self.clock.tick(50) / 1000.0","def tick(self):\n self.delta = self.clock.tick(50) / 1000.0","def get_total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6","def get_cpu_clock(verbose=False):\n\n fn = '/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq'\n output = run(\"cat \" + fn, quiet=True)\n # This file apparently only exists if the kernel's power saving module is\n # configured a certain way. I have so far only seen it on cn10 and cn11.\n # It looks like the units are kHz.\n\n clock_in_GHz = None\n\n try:\n clock_in_kHz = int(output)\n clock_in_GHz = float(clock_in_kHz) / (10**6)\n return clock_in_GHz\n except ValueError:\n if verbose:\n print(\"Error: On host = {Host}, unable to get cpu clock in string\\n{Output}\"\n .format(Host=env.host, Output=output))\n\n # The cpuinfo_max_freq file approach didn't work, so get current clock\n # from /proc/cpuinfo\n output = run(\"cat /proc/cpuinfo | grep MHz | uniq\", quiet=True)\n\n regex = re.compile(\n \"\"\"\n .*cpu\\sMHz # any chars before \"cpu MHz\"\n \\s*:\\s* # any amount of whitespace, colon, any amount of whitespace\n (\\d*.?\\d*) # any digits, <= 1 period, any digits (i.e. any positive float)\n \\s* # any amount of whitespace\n \"\"\", re.VERBOSE)\n\n matches = regex.findall(output)\n\n if (len(matches) == 1):\n clock_in_GHz = float(matches[0]) / (10**3) # MHz to GHz\n else:\n print(\"Error: On host = {Host}, unable to determine cpu frequency in string\\n{Output}\"\n .format(Host = env.host, Output = output))\n\n if verbose:\n print(\"{Host:4} | CPU clock: {Clock:4.2f} GHz\".format(Host=env.host, Clock=clock_in_GHz))\n\n return clock_in_GHz","def time_ms():\n return int(1000 * time.time())","def clock_helper(total_seconds):\n seconds_in_minute = total_seconds % 60","def num_ticks(self, start, end, desired_ticks=None):\n if self.resolution is None or self.resolution == 0.0:\n return 0\n else:\n return (end - start) / self.resolution","def cpu_time(self):","def __get_uptime_ms(self):\n\n if self._boot_time_ms is None:\n # We read /proc/uptime once to get the current boot time.\n uptime_file = None\n try:\n uptime_file = open(\"/proc/uptime\", \"r\")\n # The first number in the file is the number of seconds since\n # boot time. So, we just use that to calculate the milliseconds\n # past epoch.\n self._boot_time_ms = int(time.time()) * 1000 - int(\n float(uptime_file.readline().split()[0]) * 1000.0\n )\n finally:\n if uptime_file is not None:\n uptime_file.close()\n\n # Calculate the uptime by just taking current time and subtracting out\n # the boot time.\n return int(time.time()) * 1000 - self._boot_time_ms","def calculate_days(time):\n return int(time / 86400)","def __current_milli_time(self):\n\n return int(round(time.time() * 1000))","def proc_start():\n\n fd = open(\"/proc/self/stat\")\n start_clk = int(fd.readline().split()[21])\n start_sec = start_clk // os.sysconf(\"SC_CLK_TCK\")\n fd.close()\n\n fd = open(\"/proc/stat\")\n boot_sec = None\n for line in fd:\n if line.startswith(\"btime\"):\n boot_sec = int(line.split()[1])\n assert boot_sec is not None\n fd.close()\n\n return boot_sec + start_sec","def sys_up_time():\n\n with open('/proc/uptime', 'r') as f:\n uptime_seconds = float(f.readline().split()[0])\n return int(uptime_seconds)","def clock_speed(self):\n return self._clock_speed","def get_elapsed_seconds():\n\tutcnow = datetime.utcnow()\n\tmidnight_utc = datetime.combine(utcnow.date(), time(0))\n\tdelta = utcnow - midnight_utc\n\treturn delta.total_seconds()","def current_milli_time(self):\n return int(round(time.time() * 1000))","def calc_delta_c(c200):\n top = (200. / 3.) * c200**3.\n bottom = np.log(1. + c200) - (c200 / (1. + c200))\n return (top / bottom)","def time_millis():\n\n return int(time.time() * 1000)","def startup_time_delta(self):\n return int((time.time() - self.startup_timestamp) * 1000.0)","def cumulcoolingtime(self, interval):\n return self._getcumultime(interval, self.cooling_times)"],"string":"[\n \"def calculate_time_ms(self, jiffies):\\n\\n return int((jiffies * 1000.0) / self._jiffies_per_sec)\",\n \"def jiffies(_load_time=time.time()):\\n return int(100*(time.time()-_load_time))\",\n \"def _nsec_to_usec_round(nsec):\\n return (nsec + 500) // 10 ** 3\",\n \"def millis(): \\n return int(round(monotonic.monotonic() * C.MILLISECONDS))\",\n \"def millis(): \\r\\n return int(round(monotonic.monotonic() * C.MILLISECONDS))\",\n \"def jiffies(_proc_pid_stat = '/proc/%s/stat'%(os.getpid()),\\n _load_time=time.time()):\\n try:\\n f=open(_proc_pid_stat,'r')\\n l = f.readline().split(' ')\\n f.close()\\n return int(l[13])\\n except:\\n return int(100*(time.time()-_load_time))\",\n \"def elapsed_micros(start: int, /) -> int:\",\n \"def _probe_wait_time(self):\\n r = self.probe_cycle_time / float(len(self.servers)) #self.probe_cycle_time=5\\n r = max(.25, r) # Cap it at four per second\\n return r\",\n \"def get_total_cpu_clock_cycles():\\n try:\\n with open(LINUX_STAT_LOCATION, 'r') as f:\\n cpu_entries = f.readline().split(' ')\\n except IOError:\\n return None\\n\\n cpu_cycles = 0\\n for entry in cpu_entries:\\n try:\\n cpu_cycles += int(entry)\\n except ValueError:\\n pass\\n return cpu_cycles\",\n \"def _get_cpu_interval(self):\\n self._polling_execute_frequency = int(self._plugin_conf[u'main'][u'polling_frequency'])\\n\\n if 5 <= self._polling_execute_frequency < 60:\\n return cpmCPUTotalMonIntervalValue # replaces cpmCPUTotal5SecRev\\n elif 60 <= self._polling_execute_frequency < 300:\\n return cpmCPUTotal1minRev\\n elif 300 <= self._polling_execute_frequency:\\n return cpmCPUTotal5minRev\\n else:\\n return cpmCPUTotal1minRev\",\n \"def ticks_per_second(self):\\n return self._ticks_per_second\",\n \"def millis(start_time):\\n dt = datetime.now() - start_time\\n ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0\\n return ms\",\n \"def curTimeMs():\\n\\treturn int((datetime.utcnow() - datetime(1970,1,1)).total_seconds() * 1000)\",\n \"def getTime():\\n\\n return float(time.perf_counter()*1000)\",\n \"def tick(self):\\n prev_last_tick = self.last_tick_\\n self.last_tick_ = timeit.default_timer()\\n latest_tick_period = self.last_tick_ - prev_last_tick\\n return latest_tick_period\",\n \"def millis() -> int:\",\n \"def millis():\\n return int(round(time() * 1000))\",\n \"def get_clock_divisor(self):\\n return self.o.read_register(self.dev_id, CLOCK_DIVISOR)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def getTime():\\n return float(time.perf_counter()*1000)\",\n \"def _unit_sec(self):\\n return self.time_base / 60.0\",\n \"def _get_milleseconds(self):\\n return int(round(time.time() * 1000))\",\n \"def _time_ms(dt):\\n epoch = datetime.datetime.utcfromtimestamp(0)\\n diff = dt - epoch\\n return diff.total_seconds() * 1000\",\n \"def _unit_ms(self):\\n return (self.time_base / 1000.0) / 60.0\",\n \"def __micros():\\n return round(time.time() * 1000000)\",\n \"def _STEPS2TIME(step):\\n return step/1000.\",\n \"def _current_epoch_secs():\\n now = datetime.datetime.utcnow()\\n epoch = datetime.datetime(1970, 1, 1)\\n return (now - epoch).total_seconds()\",\n \"def n_elements(x, dist, var=None):\\n n = dist/mdiff(x)\\n if var == 'time':\\n n = n/60\\n return int(np.round(n))\",\n \"def np_dt_epoch_msec(value):\\n return value.astype(long) / 1000\",\n \"def num_microseconds(self, td):\\n return float(td.microseconds + 1000000 * (td.seconds + 86400 * td.days))\",\n \"def get_timebase(self,dt):\\r\\n\\r\\n if dt < 1E-9:\\r\\n dt = 1E-9\\r\\n\\r\\n if dt > 4E-9:\\r\\n n = int(dt*125E6 + 2)\\r\\n else:\\r\\n dt *= 1E9\\r\\n n = round(log(dt,2))\\r\\n return n\",\n \"def calculer_energie_cinetique_tnt(energie_cinetique):\\n return energie_cinetique / 4184\",\n \"def unit_ms(self):\\n return (self.time_base / 1000.0) / 60.0\",\n \"def unit_sec(self):\\n return self.time_base / 60.0\",\n \"def sequenceTime_sec(cmds):\\n cycles = sum(MemorySequence.cmdTime_cycles(c) for c in cmds)\\n return cycles * 40e-9 # assume 25 MHz clock -> 40 ns per cycle\",\n \"def timefactor(self, period):\\n\\t\\tdays = period.size() * self.daysinunit(period.unit)\\n\\t\\treturn float(days)/self.daysinbase\",\n \"def transmission_time_us(self, num_bytes):\\n bits_to_transmit = num_bytes * 8\\n transmission_time_us = (bits_to_transmit / self.megabits_per_second)\\n return transmission_time_us\",\n \"def cpu_times(percpu=False):\\r\\n if not percpu:\\r\\n return _get_sys_cpu_times()\\r\\n else:\\r\\n return _get_sys_per_cpu_times()\",\n \"def __timedelta_millis(td):\\n return int(round(td.total_seconds(), 3) * 1000)\",\n \"def getNowMilliseconds():\\n return (datetime.datetime.utcnow() - Common.epoch_).total_seconds() * 1000.0\",\n \"def cputime(conn):\\n c = conn.cursor()\\n r = c.execute(\\\"SELECT SUM(length) as total_bin_time FROM event WHERE bin_id not null\\\").fetchall()\\n total_bin_time = r[0]['total_bin_time'];\\n last_time = maxtime(conn)\\n\\n cputime = 0\\n if total_bin_time and last_time:\\n cpu_time = total_bin_time / last_time\\n\\n return {\\n \\\"cpu_time\\\":cpu_time\\n }\",\n \"def calculate_seconds_in_days(days):\\n return int(days * 86400)\",\n \"def cpu_percent(interval=0.1, percpu=False):\\r\\n global _last_cpu_times\\r\\n global _last_per_cpu_times\\r\\n blocking = interval is not None and interval > 0.0\\r\\n\\r\\n def calculate(t1, t2):\\r\\n t1_all = sum(t1)\\r\\n t1_busy = t1_all - t1.idle\\r\\n\\r\\n t2_all = sum(t2)\\r\\n t2_busy = t2_all - t2.idle\\r\\n\\r\\n # this usually indicates a float precision issue\\r\\n if t2_busy <= t1_busy:\\r\\n return 0.0\\r\\n\\r\\n busy_delta = t2_busy - t1_busy\\r\\n all_delta = t2_all - t1_all\\r\\n busy_perc = (busy_delta / all_delta) * 100\\r\\n return round(busy_perc, 1)\\r\\n\\r\\n # system-wide usage\\r\\n if not percpu:\\r\\n if blocking:\\r\\n t1 = cpu_times()\\r\\n time.sleep(interval)\\r\\n else:\\r\\n t1 = _last_cpu_times\\r\\n _last_cpu_times = cpu_times()\\r\\n return calculate(t1, _last_cpu_times)\\r\\n # per-cpu usage\\r\\n else:\\r\\n ret = []\\r\\n if blocking:\\r\\n tot1 = cpu_times(percpu=True)\\r\\n time.sleep(interval)\\r\\n else:\\r\\n tot1 = _last_per_cpu_times\\r\\n _last_per_cpu_times = cpu_times(percpu=True)\\r\\n for t1, t2 in zip(tot1, _last_per_cpu_times):\\r\\n ret.append(calculate(t1, t2))\\r\\n return ret\",\n \"def cps(self):\\n return self.datacounts / self.exptime\",\n \"def now():\\n\\n return rospy.Time.now().to_nsec()\",\n \"def get_millis(seconds):\\n return seconds * 10 ** 3\",\n \"def microseconds_since_epoch(date_time, epoch=None):\\n if not epoch:\\n epoch = datetime.datetime.utcfromtimestamp(0)\\n\\n delta = date_time - epoch\\n\\n # 86400 is 24 * 60 * 60 e.g. total seconds in a day\\n return delta.microseconds + (delta.seconds + delta.days * 86400) * 10**6\",\n \"def time(n):\\n steps = 3 + math.ceil(n/5.0)*2\\n return steps\",\n \"def unix_time_nanos(dt):\\n return timedelta_to_micros(dt - epoch)\",\n \"def millisecond():\\n return int(round(time.time() * 1000))\",\n \"def dt_epoch_msecs(value):\\n return long(calendar.timegm(value.timetuple())) * 1000\",\n \"def EpochNano():\\n return int(time.time() * 1000000000)\",\n \"def ms(self):\\n # my clock uses seconds internally\\n return 1000 * self.read()\",\n \"def timeScale(self) -> int:\\n return int(1 / (1 - self.momentum))\",\n \"def _time_ms(self, dt):\\n if dt.tzinfo is None:\\n dt = dt.replace(tzinfo=pytz.utc)\\n return int((dt - self._EPOCH).total_seconds() * 1000)\",\n \"def time(self) -> float:\\n return self.state.game_loop / 22.4 # / (1/1.4) * (1/16)\",\n \"def measure_time(n: int, max_delay: int) -> float:\\n start_time = time.time()\\n asyncio.run(wait_n(n, max_delay))\\n return (time.time() - start_time) / n\",\n \"def get_time_ms():\\n return int(round(time.time() * 1000))\",\n \"def measure_time(n: int, max_delay: int) -> float:\\n t0 = time.time()\\n asyncio.run(wait_n(n, max_delay))\\n t1 = time.time()\\n total_time = t1 - t0\\n return total_time / n\",\n \"def elapsed_millis(start: int, /) -> int:\",\n \"def unix_time_millisecond(date):\\r\\n return unix_time(date, float=True) * 1e3\",\n \"def _nowms():\\n return int(time.time() * 1000)\",\n \"def _calc_time_precision(sampling_rate):\\n\\n # convert sampling rate to int\\n sampling_rate = int(sampling_rate)\\n\\n # calculate the first remainder\\n remainder = 1 % sampling_rate\\n\\n # list for holding all remainders that have been calculated\\n seen_remainders = []\\n\\n # calculate all other remainders until the modulo operation yields either zero or the remainder has already appeared\\n # before (this is when the periodicity starts)\\n while (remainder != 0) and (remainder not in seen_remainders):\\n # append the current remainder to the seen remainder list\\n seen_remainders.append(remainder)\\n\\n # multiply the remainder by ten (this is basically the process of converting a fraction to a decimal number\\n # using long division\\n remainder = remainder * 10\\n\\n # calculate the next remainder\\n remainder = remainder % sampling_rate\\n\\n return len(seen_remainders) + 1\",\n \"def get_cpu_clock_cycles_of_pid(pid):\\n try:\\n with open(LINUX_PROCESS_STAT_LOCATION % pid, 'r') as f:\\n pid_entries = f.read().split(' ')\\n except IOError:\\n return None\\n\\n pid_cycles = 0\\n if len(pid_entries) > 14:\\n pid_cycles = int(pid_entries[13]) + int(pid_entries[14])\\n return pid_cycles\",\n \"def part1() -> int:\\n longest_sleeper = max(sleep_times, key=lambda g: len(sleep_times[g]))\\n sleepiest_minute = max(\\n sleep_times[longest_sleeper], key=sleep_times[longest_sleeper].count)\\n\\n return longest_sleeper * sleepiest_minute\",\n \"def _GetSecsUntilNextPass(self):\\n op = util.CheckedOp('retrieving last GC pass time',\\n self.engine.Get,\\n KEY_LAST_PASS_TIME)\\n\\n if not op.success:\\n return None\\n\\n last_compute = float(op.response_value) if op.response_value else 0\\n return last_compute + self.gc_frequency - time.time()\",\n \"def hz2cents(pitchInHz, tonic=261.626):\\n cents = 1200*np.log2(1.0*pitchInHz/tonic)\\n return cents\",\n \"def time(self):\\n return sum(self._interval) * .5\",\n \"def seconds_since_epoch(date_time, epoch=None):\\n return microseconds_since_epoch(date_time) / 10.0**6\",\n \"def _calibrate_time(self):\\n time_overhead = 0\\n for i in range(1000):\\n start = self._adjusted_time()\\n end = self._adjusted_time()\\n time_overhead += end - start\\n return time_overhead / 1000\",\n \"def curr_time_millis():\\n return 1000 * timeit.default_timer()\",\n \"def millis(self):\\n return self._micros // 1000\",\n \"def units_to_msec(units, resolution):\\n time_ms = units * float(resolution) / 1000\\n return time_ms\",\n \"def MillisToSec(self):\\n self.Millis = [item / 1000 for item in self.Millis]\\n return self.Millis\",\n \"def period_cntfrac_sqrt(num):\\r\\n r = limit = int(sqrt(num))\\r\\n if limit * limit == num:\\r\\n return 0\\r\\n k, period = 1, 0\\r\\n while k != 1 or period == 0:\\r\\n k = (num - r * r) / k\\r\\n r = ((limit + r) / k) * k - r\\r\\n period += 1\\r\\n return period\",\n \"def frequency(self):\\n return self.reference_clock_speed / 4096 / self.prescale_reg\",\n \"def tick(self):\\n self.delta = self.clock.tick(50) / 1000.0\",\n \"def tick(self):\\n self.delta = self.clock.tick(50) / 1000.0\",\n \"def get_total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6\",\n \"def get_cpu_clock(verbose=False):\\n\\n fn = '/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq'\\n output = run(\\\"cat \\\" + fn, quiet=True)\\n # This file apparently only exists if the kernel's power saving module is\\n # configured a certain way. I have so far only seen it on cn10 and cn11.\\n # It looks like the units are kHz.\\n\\n clock_in_GHz = None\\n\\n try:\\n clock_in_kHz = int(output)\\n clock_in_GHz = float(clock_in_kHz) / (10**6)\\n return clock_in_GHz\\n except ValueError:\\n if verbose:\\n print(\\\"Error: On host = {Host}, unable to get cpu clock in string\\\\n{Output}\\\"\\n .format(Host=env.host, Output=output))\\n\\n # The cpuinfo_max_freq file approach didn't work, so get current clock\\n # from /proc/cpuinfo\\n output = run(\\\"cat /proc/cpuinfo | grep MHz | uniq\\\", quiet=True)\\n\\n regex = re.compile(\\n \\\"\\\"\\\"\\n .*cpu\\\\sMHz # any chars before \\\"cpu MHz\\\"\\n \\\\s*:\\\\s* # any amount of whitespace, colon, any amount of whitespace\\n (\\\\d*.?\\\\d*) # any digits, <= 1 period, any digits (i.e. any positive float)\\n \\\\s* # any amount of whitespace\\n \\\"\\\"\\\", re.VERBOSE)\\n\\n matches = regex.findall(output)\\n\\n if (len(matches) == 1):\\n clock_in_GHz = float(matches[0]) / (10**3) # MHz to GHz\\n else:\\n print(\\\"Error: On host = {Host}, unable to determine cpu frequency in string\\\\n{Output}\\\"\\n .format(Host = env.host, Output = output))\\n\\n if verbose:\\n print(\\\"{Host:4} | CPU clock: {Clock:4.2f} GHz\\\".format(Host=env.host, Clock=clock_in_GHz))\\n\\n return clock_in_GHz\",\n \"def time_ms():\\n return int(1000 * time.time())\",\n \"def clock_helper(total_seconds):\\n seconds_in_minute = total_seconds % 60\",\n \"def num_ticks(self, start, end, desired_ticks=None):\\n if self.resolution is None or self.resolution == 0.0:\\n return 0\\n else:\\n return (end - start) / self.resolution\",\n \"def cpu_time(self):\",\n \"def __get_uptime_ms(self):\\n\\n if self._boot_time_ms is None:\\n # We read /proc/uptime once to get the current boot time.\\n uptime_file = None\\n try:\\n uptime_file = open(\\\"/proc/uptime\\\", \\\"r\\\")\\n # The first number in the file is the number of seconds since\\n # boot time. So, we just use that to calculate the milliseconds\\n # past epoch.\\n self._boot_time_ms = int(time.time()) * 1000 - int(\\n float(uptime_file.readline().split()[0]) * 1000.0\\n )\\n finally:\\n if uptime_file is not None:\\n uptime_file.close()\\n\\n # Calculate the uptime by just taking current time and subtracting out\\n # the boot time.\\n return int(time.time()) * 1000 - self._boot_time_ms\",\n \"def calculate_days(time):\\n return int(time / 86400)\",\n \"def __current_milli_time(self):\\n\\n return int(round(time.time() * 1000))\",\n \"def proc_start():\\n\\n fd = open(\\\"/proc/self/stat\\\")\\n start_clk = int(fd.readline().split()[21])\\n start_sec = start_clk // os.sysconf(\\\"SC_CLK_TCK\\\")\\n fd.close()\\n\\n fd = open(\\\"/proc/stat\\\")\\n boot_sec = None\\n for line in fd:\\n if line.startswith(\\\"btime\\\"):\\n boot_sec = int(line.split()[1])\\n assert boot_sec is not None\\n fd.close()\\n\\n return boot_sec + start_sec\",\n \"def sys_up_time():\\n\\n with open('/proc/uptime', 'r') as f:\\n uptime_seconds = float(f.readline().split()[0])\\n return int(uptime_seconds)\",\n \"def clock_speed(self):\\n return self._clock_speed\",\n \"def get_elapsed_seconds():\\n\\tutcnow = datetime.utcnow()\\n\\tmidnight_utc = datetime.combine(utcnow.date(), time(0))\\n\\tdelta = utcnow - midnight_utc\\n\\treturn delta.total_seconds()\",\n \"def current_milli_time(self):\\n return int(round(time.time() * 1000))\",\n \"def calc_delta_c(c200):\\n top = (200. / 3.) * c200**3.\\n bottom = np.log(1. + c200) - (c200 / (1. + c200))\\n return (top / bottom)\",\n \"def time_millis():\\n\\n return int(time.time() * 1000)\",\n \"def startup_time_delta(self):\\n return int((time.time() - self.startup_timestamp) * 1000.0)\",\n \"def cumulcoolingtime(self, interval):\\n return self._getcumultime(interval, self.cooling_times)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7653799","0.652349","0.6424848","0.6171948","0.6161103","0.6105997","0.5744971","0.56402147","0.5638903","0.5606995","0.5588372","0.5540272","0.5520585","0.5486425","0.54827213","0.5427575","0.5426606","0.5411524","0.54085886","0.54085886","0.54085886","0.54085886","0.54085886","0.54085886","0.53986","0.5370979","0.5370503","0.5370475","0.5364911","0.536195","0.53587836","0.5351028","0.53441715","0.53379315","0.53326714","0.53294146","0.53270894","0.53163946","0.53105134","0.53103775","0.53040475","0.52996546","0.52967894","0.52888703","0.52816117","0.5278208","0.52589846","0.5255259","0.5253289","0.5236489","0.5232979","0.5219614","0.52138215","0.5203136","0.519974","0.51875097","0.51853716","0.5183313","0.51727295","0.51643234","0.5153411","0.5152877","0.51493096","0.5140954","0.51248205","0.5123222","0.5122819","0.51215124","0.5120848","0.5120689","0.5120453","0.5118943","0.51183826","0.5118254","0.5117916","0.5107305","0.5105741","0.5097183","0.50926906","0.50898635","0.5087706","0.5087706","0.5078092","0.50707245","0.50701797","0.5068228","0.5066959","0.5064344","0.5061869","0.50523967","0.5033879","0.5030043","0.50286853","0.5028655","0.5025476","0.5024317","0.5019504","0.50168395","0.5015332","0.50078374"],"string":"[\n \"0.7653799\",\n \"0.652349\",\n \"0.6424848\",\n \"0.6171948\",\n \"0.6161103\",\n \"0.6105997\",\n \"0.5744971\",\n \"0.56402147\",\n \"0.5638903\",\n \"0.5606995\",\n \"0.5588372\",\n \"0.5540272\",\n \"0.5520585\",\n \"0.5486425\",\n \"0.54827213\",\n \"0.5427575\",\n \"0.5426606\",\n \"0.5411524\",\n \"0.54085886\",\n \"0.54085886\",\n \"0.54085886\",\n \"0.54085886\",\n \"0.54085886\",\n \"0.54085886\",\n \"0.53986\",\n \"0.5370979\",\n \"0.5370503\",\n \"0.5370475\",\n \"0.5364911\",\n \"0.536195\",\n \"0.53587836\",\n \"0.5351028\",\n \"0.53441715\",\n \"0.53379315\",\n \"0.53326714\",\n \"0.53294146\",\n \"0.53270894\",\n \"0.53163946\",\n \"0.53105134\",\n \"0.53103775\",\n \"0.53040475\",\n \"0.52996546\",\n \"0.52967894\",\n \"0.52888703\",\n \"0.52816117\",\n \"0.5278208\",\n \"0.52589846\",\n \"0.5255259\",\n \"0.5253289\",\n \"0.5236489\",\n \"0.5232979\",\n \"0.5219614\",\n \"0.52138215\",\n \"0.5203136\",\n \"0.519974\",\n \"0.51875097\",\n \"0.51853716\",\n \"0.5183313\",\n \"0.51727295\",\n \"0.51643234\",\n \"0.5153411\",\n \"0.5152877\",\n \"0.51493096\",\n \"0.5140954\",\n \"0.51248205\",\n \"0.5123222\",\n \"0.5122819\",\n \"0.51215124\",\n \"0.5120848\",\n \"0.5120689\",\n \"0.5120453\",\n \"0.5118943\",\n \"0.51183826\",\n \"0.5118254\",\n \"0.5117916\",\n \"0.5107305\",\n \"0.5105741\",\n \"0.5097183\",\n \"0.50926906\",\n \"0.50898635\",\n \"0.5087706\",\n \"0.5087706\",\n \"0.5078092\",\n \"0.50707245\",\n \"0.50701797\",\n \"0.5068228\",\n \"0.5066959\",\n \"0.5064344\",\n \"0.5061869\",\n \"0.50523967\",\n \"0.5033879\",\n \"0.5030043\",\n \"0.50286853\",\n \"0.5028655\",\n \"0.5025476\",\n \"0.5024317\",\n \"0.5019504\",\n \"0.50168395\",\n \"0.5015332\",\n \"0.50078374\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7872766"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":5,"numItemsPerPage":100,"numTotalItems":95772,"offset":500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzUzMTM2OSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM1MzQ5NjksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.CVNaTecqIHFg26S3chUVydRV1c0vbodMmP2fs_yGMiomrha5dFdgi_7MJ_hU_2DEuwHS3aaxzGlFDL6KwAFGAg","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 |
|---|---|---|---|---|---|---|
See ticket 2107 for the bug that this tickles. | def test_do_manga_dither_after_sequence(self):
sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])
dither = 'N'
cmdState = self.actorState.doMangaSequence
cmdState.reinitialize(self.cmd)
cmdState.count = 1
cmdState.dithers = 'NSE'
cmdState.reset_ditherSeq()
self.cmd.verbose = False
masterThread.do_apogeemanga_sequence(self.cmd, cmdState, myGlobals.actorState)
self.cmd.reset()
self.cmd.verbose = self.verbose
self._do_manga_dither(4, 28, 0, 0, dither=dither) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tick(self):",
"def tick(self):\r\n pass",
"def tick(self):\n pass",
"def tick(self):\n pass",
"def tick_descent(self):\n pass",
"def lastTick():",
"def tick(self, tick):\n pass",
"def tick(self, tick):\n pass",
"def tick_skipped(self):\n pass",
... | [
"0.68404317",
"0.67841446",
"0.67153627",
"0.67153627",
"0.6649946",
"0.6539368",
"0.6539086",
"0.6539086",
"0.6154324",
"0.60770965",
"0.6065959",
"0.6026124",
"0.5937391",
"0.58856446",
"0.580046",
"0.5741288",
"0.5730749",
"0.57282233",
"0.5695636",
"0.56728476",
"0.564394... | 0.0 | -1 |
See ticket 2107 for the bug that this tickles. | def test_do_apogeemanga_dither_after_sequence(self):
sopTester.updateModel('mcp', TestHelper.mcpState['apogee_science'])
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
sopTester.updateModel('platedb', TestHelper.platedbState['apgoeemangaDither'])
self._update_cart(1, 'APOGEE&MaNGA', 'MaNGA dither')
mangaDither = 'N'
cmdState = self.actorState.doApogeeMangaSequence
cmdState.reinitialize(self.cmd)
cmdState.count = 1
cmdState.mangaDithers = 'NSE'
cmdState.reset_ditherSeq()
self.cmd.verbose = False
masterThread.do_apogeemanga_sequence(self.cmd, cmdState, myGlobals.actorState)
self.cmd.reset()
self.cmd.verbose = self.verbose
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
self._do_apogeemanga_dither(7, 37, 0, 0, mangaDither) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tick(self):",
"def tick(self):\r\n pass",
"def tick(self):\n pass",
"def tick(self):\n pass",
"def tick_descent(self):\n pass",
"def tick(self, tick):\n pass",
"def tick(self, tick):\n pass",
"def lastTick():",
"def tick_skipped(self):\n pass",
... | [
"0.6841335",
"0.67850286",
"0.67163193",
"0.67163193",
"0.665169",
"0.65407777",
"0.65407777",
"0.6539678",
"0.61551094",
"0.6077852",
"0.6066676",
"0.6026107",
"0.5938928",
"0.58871347",
"0.57996696",
"0.57409745",
"0.57303774",
"0.57297117",
"0.5696213",
"0.56716204",
"0.56... | 0.0 | -1 |
For 371, not closing FFS for bias/dark. | def test_do_boss_calibs_one_bias_ffs_open(self):
sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])
cmdState = CmdState.DoBossCalibsCmd()
cmdState.nBias = 1
self._do_boss_calibs(4, 25, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close():\n\trfm.close()",
"def close_trace(self):\n if self.State==1:\n self.tf.close()\n self.State = 0 \n else:\n print \"Tracefile not open...\"",
"def safeClose():\n # outputToggle(ledPin, False)\n # outputToggle(auxlightPin, False)\n camera.stop_... | [
"0.63533455",
"0.5993525",
"0.59140307",
"0.5904497",
"0.5810159",
"0.5796537",
"0.5787865",
"0.57800907",
"0.5778978",
"0.577066",
"0.57619506",
"0.57507795",
"0.5708684",
"0.5704931",
"0.56797045",
"0.5677076",
"0.56575465",
"0.56262064",
"0.56262064",
"0.5623001",
"0.56024... | 0.0 | -1 |
For 371, not closing FFS for bias/dark. | def test_do_boss_calibs_one_dark_ffs_open(self):
sopTester.updateModel('mcp', TestHelper.mcpState['boss_science'])
cmdState = CmdState.DoBossCalibsCmd()
cmdState.nDark = 1
self._do_boss_calibs(4, 25, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close():\n\trfm.close()",
"def close_trace(self):\n if self.State==1:\n self.tf.close()\n self.State = 0 \n else:\n print \"Tracefile not open...\"",
"def safeClose():\n # outputToggle(ledPin, False)\n # outputToggle(auxlightPin, False)\n camera.stop_... | [
"0.6353356",
"0.5994088",
"0.5915026",
"0.59051275",
"0.58110243",
"0.5796057",
"0.57873064",
"0.57794714",
"0.5778692",
"0.57710266",
"0.5761392",
"0.57499737",
"0.5708475",
"0.57054716",
"0.5680105",
"0.56762487",
"0.5658499",
"0.5626224",
"0.5626224",
"0.5622663",
"0.56034... | 0.0 | -1 |
coobserving carts should close the apogee shutter first. | def test_do_boss_calibs_one_flat_coobserve(self):
cmdState = CmdState.DoBossCalibsCmd()
cmdState.nFlat = 1
sopTester.updateModel('guider', TestHelper.guiderState['apogeemangaDitherLoaded'])
sopTester.updateModel('mcp', TestHelper.mcpState['apogee_parked'])
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
self._do_boss_calibs(8, 38, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cart_flushed(self):\n self.fill_session_cart()\n\n session = self.client.session\n self.assertNotEqual(session['cart'], {})\n self.assertNotEqual(session['cart_cost'], 0)\n\n self.client.post(self.CHECKOUT_URL, self.build_checkout_form())\n\n session = self.client... | [
"0.615932",
"0.57919484",
"0.5666151",
"0.5642451",
"0.56404835",
"0.55797815",
"0.55783755",
"0.5517197",
"0.55146784",
"0.54833806",
"0.5479677",
"0.5449196",
"0.54028076",
"0.5392104",
"0.5381052",
"0.53170824",
"0.52840286",
"0.52400047",
"0.5232583",
"0.5214879",
"0.5207... | 0.0 | -1 |
Coobserving carts should not bother with the apogee shutter when the gang connector is not at the cart. | def test_do_boss_calibs_one_flat_coobserve_gangPodium(self):
cmdState = CmdState.DoBossCalibsCmd()
cmdState.nFlat = 1
sopTester.updateModel('guider', TestHelper.guiderState['apogeemangaDitherLoaded'])
sopTester.updateModel('mcp', TestHelper.mcpState['all_off'])
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
self._do_boss_calibs(7, 31, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_basicNoSalePC(self):\n # Basic price check\n self.log.info(\"Price checking Generic Item via speedkey\")\n pos.click(\"Price Check\")\n pos.click_speed_key(\"Generic Item\")\n \n # Confirm the right item, at the right price\n self.read_price_check(\"Generic... | [
"0.613266",
"0.6027911",
"0.5957148",
"0.58498114",
"0.5780373",
"0.57664615",
"0.57352144",
"0.5670634",
"0.5603377",
"0.5565635",
"0.55271673",
"0.5519921",
"0.55182767",
"0.55163413",
"0.54893744",
"0.54880553",
"0.54810375",
"0.54696536",
"0.5443818",
"0.543117",
"0.53950... | 0.0 | -1 |
coobserving carts should close the apogee shutter first. | def test_do_boss_calibs_one_arc_coobserve(self):
cmdState = CmdState.DoBossCalibsCmd()
cmdState.nArc = 1
sopTester.updateModel('guider', TestHelper.guiderState['apogeemangaDitherLoaded'])
sopTester.updateModel('mcp', TestHelper.mcpState['apogee_parked'])
sopTester.updateModel('apogee', TestHelper.apogeeState['B_open'])
self._do_boss_calibs(8, 39, 0, 0, cmdState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cart_flushed(self):\n self.fill_session_cart()\n\n session = self.client.session\n self.assertNotEqual(session['cart'], {})\n self.assertNotEqual(session['cart_cost'], 0)\n\n self.client.post(self.CHECKOUT_URL, self.build_checkout_form())\n\n session = self.client... | [
"0.6157707",
"0.579232",
"0.5664724",
"0.5641533",
"0.5639043",
"0.55788285",
"0.5577999",
"0.5516711",
"0.5514344",
"0.54846823",
"0.5480096",
"0.5448836",
"0.54019326",
"0.53919315",
"0.5380245",
"0.53151876",
"0.5282395",
"0.52394223",
"0.52324045",
"0.5215534",
"0.5207088... | 0.0 | -1 |
Unwraps the private key into an asn1crypto.keys.RSAPrivateKey, asn1crypto.keys.DSAPrivateKey or asn1crypto.keys.ECPrivateKey object | def unwrap(self):
if self.algorithm == 'rsa':
return self.asn1['private_key'].parsed
if self.algorithm == 'dsa':
params = self.asn1['private_key_algorithm']['parameters']
return DSAPrivateKey({
'version': 0,
'p': params['p'],
'q': params['q'],
'g': params['g'],
'public_key': self.public_key.unwrap(),
'private_key': self.asn1['private_key'].parsed,
})
if self.algorithm == 'ec':
output = self.asn1['private_key'].parsed
output['parameters'] = self.asn1['private_key_algorithm']['parameters']
output['public_key'] = self.public_key.unwrap()
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unwrap_private_key_info(key_info):\n\n key_alg = key_info.algorithm\n\n if key_alg == 'rsa' or key_alg == 'rsassa_pss':\n return key_info['private_key'].parsed\n\n if key_alg == 'dsa':\n params = key_info['private_key_algorithm']['parameters']\n parsed = key_info['private_key'].p... | [
"0.7709716",
"0.7091911",
"0.6661885",
"0.6650223",
"0.6593615",
"0.6553231",
"0.64998823",
"0.6498649",
"0.6429571",
"0.64050627",
"0.6381211",
"0.6249152",
"0.6246417",
"0.6217567",
"0.62138116",
"0.6204138",
"0.6198371",
"0.6193991",
"0.6141875",
"0.6141632",
"0.6117683",
... | 0.7861159 | 0 |
Unwraps a public key into an asn1crypto.keys.RSAPublicKey, asn1crypto.core.Integer (for DSA) or asn1crypto.keys.ECPointBitString object | def unwrap(self):
if self.algorithm == 'ec':
return self.asn1['public_key']
return self.asn1['public_key'].parsed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_credential_public_key(\n key: bytes,\n) -> Union[DecodedOKPPublicKey, DecodedEC2PublicKey, DecodedRSAPublicKey]:\n # Occassionally we might be given a public key in an \"uncompressed\" format,\n # typically from older U2F security keys. As per the FIDO spec this is indicated by\n # a leading... | [
"0.70528996",
"0.682243",
"0.6711425",
"0.67085093",
"0.6610189",
"0.65048105",
"0.6489869",
"0.6488379",
"0.64881927",
"0.64246345",
"0.6423231",
"0.64138883",
"0.6409382",
"0.6395284",
"0.63761365",
"0.6347127",
"0.6329381",
"0.6321539",
"0.62870216",
"0.6245045",
"0.619662... | 0.71075326 | 0 |
Creates a fingerprint that can be compared with a private key to see if the two form a pair. This fingerprint is not compatible with fingerprints generated by any other software. | def fingerprint(self):
if self._fingerprint is None:
self._fingerprint = _fingerprint(self.asn1, None)
return self._fingerprint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fingerprint(key_object, load_private_key):\n\n if isinstance(key_object, PrivateKeyInfo):\n key = key_object['private_key'].parsed\n\n if key_object.algorithm == 'rsa':\n to_hash = '%d:%d' % (\n key['modulus'].native,\n key['public_exponent'].native,\n... | [
"0.6485189",
"0.6272822",
"0.6004521",
"0.5935738",
"0.5886129",
"0.58848107",
"0.5814873",
"0.57364976",
"0.57348734",
"0.5725082",
"0.5690334",
"0.56683075",
"0.56541723",
"0.5592357",
"0.5590496",
"0.5577048",
"0.55707747",
"0.5545947",
"0.5468767",
"0.54511124",
"0.544233... | 0.0 | -1 |
Unwraps an asn1crypto.keys.PrivateKeyInfo object into an asn1crypto.keys.RSAPrivateKey, asn1crypto.keys.DSAPrivateKey or asn1crypto.keys.ECPrivateKey. | def _unwrap_private_key_info(key_info):
key_alg = key_info.algorithm
if key_alg == 'rsa' or key_alg == 'rsassa_pss':
return key_info['private_key'].parsed
if key_alg == 'dsa':
params = key_info['private_key_algorithm']['parameters']
parsed = key_info['private_key'].parsed
return DSAPrivateKey({
'version': 0,
'p': params['p'],
'q': params['q'],
'g': params['g'],
'public_key': Integer(pow(
params['g'].native,
parsed.native,
params['p'].native
)),
'private_key': parsed,
})
if key_alg == 'ec':
parsed = key_info['private_key'].parsed
parsed['parameters'] = key_info['private_key_algorithm']['parameters']
return parsed
raise ValueError('Unsupported key_info.algorithm "%s"' % key_info.algorithm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unwrap(self):\n\n if self.algorithm == 'rsa':\n return self.asn1['private_key'].parsed\n\n if self.algorithm == 'dsa':\n params = self.asn1['private_key_algorithm']['parameters']\n return DSAPrivateKey({\n 'version': 0,\n 'p': params[... | [
"0.72001606",
"0.61105424",
"0.59807235",
"0.59552276",
"0.5781235",
"0.5733041",
"0.5708165",
"0.56828797",
"0.5617318",
"0.56119716",
"0.55409443",
"0.55051327",
"0.54653615",
"0.54501706",
"0.5382498",
"0.53593355",
"0.53350115",
"0.5326151",
"0.5310217",
"0.5288465",
"0.5... | 0.82866263 | 0 |
Returns a fingerprint used for correlating public keys and private keys | def _fingerprint(key_object, load_private_key):
if isinstance(key_object, PrivateKeyInfo):
key = key_object['private_key'].parsed
if key_object.algorithm == 'rsa':
to_hash = '%d:%d' % (
key['modulus'].native,
key['public_exponent'].native,
)
elif key_object.algorithm == 'dsa':
params = key_object['private_key_algorithm']['parameters']
public_key = Integer(pow(
params['g'].native,
key_object['private_key'].parsed.native,
params['p'].native
))
to_hash = '%d:%d:%d:%d' % (
params['p'].native,
params['q'].native,
params['g'].native,
public_key.native,
)
elif key_object.algorithm == 'ec':
public_key = key['public_key'].native
if public_key is None:
# This is gross, but since the EC public key is optional,
# and we need to load the private key and use the crypto lib
# to get the public key, we have to import the platform-specific
# asymmetric implementation. This is the reason a bunch of the
# imports are module imports, so we don't get an import cycle.
public_key_object = load_private_key(key_object).public_key
public_key = public_key_object.asn1['public_key'].parsed.native
to_hash = '%s:' % key_object.curve[1]
to_hash = to_hash.encode('utf-8')
to_hash += public_key
if isinstance(to_hash, str_cls):
to_hash = to_hash.encode('utf-8')
return hashlib.sha256(to_hash).digest()
if isinstance(key_object, PublicKeyInfo):
if key_object.algorithm == 'rsa':
key = key_object['public_key'].parsed
to_hash = '%d:%d' % (
key['modulus'].native,
key['public_exponent'].native,
)
elif key_object.algorithm == 'dsa':
key = key_object['public_key'].parsed
params = key_object['algorithm']['parameters']
to_hash = '%d:%d:%d:%d' % (
params['p'].native,
params['q'].native,
params['g'].native,
key.native,
)
elif key_object.algorithm == 'ec':
public_key = key_object['public_key'].native
to_hash = '%s:' % key_object.curve[1]
to_hash = to_hash.encode('utf-8')
to_hash += public_key
if isinstance(to_hash, str_cls):
to_hash = to_hash.encode('utf-8')
return hashlib.sha256(to_hash).digest()
raise ValueError(pretty_message(
'''
key_object must be an instance of the
asn1crypto.keys.PrivateKeyInfo or asn1crypto.keys.PublicKeyInfo
classes, not %s
''',
type_name(key_object)
)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fingerprint(public_key):\r\n\r\n return hashlib.new('ripemd160', hashlib.sha256(public_key).digest()).digest()[:4]",
"def fingerprint_key(key):\n try: key = key.public_key()\n except: pass\n\n serialized = key.public_bytes(\n encoding = serialization.Encoding .OpenSSH,\n format ... | [
"0.787024",
"0.7284799",
"0.72343296",
"0.705091",
"0.6990618",
"0.6967752",
"0.6874012",
"0.6863513",
"0.68291414",
"0.6696847",
"0.66854084",
"0.6662513",
"0.6511653",
"0.6490654",
"0.6474358",
"0.64719266",
"0.6441411",
"0.64376676",
"0.63801914",
"0.63442427",
"0.63356423... | 0.70989317 | 3 |
Loads a public key from a DER or PEMformatted file. Supports RSA, DSA and EC public keys. For RSA keys, both the old RSAPublicKey and SubjectPublicKeyInfo structures are supported. Also allows extracting a public key from an X.509 certificate. | def parse_public(data):
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
key_type = None
# Appears to be PEM formatted
if re.match(b'\\s*-----', data) is not None:
key_type, algo, data = _unarmor_pem(data)
if key_type == 'private key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a public key or
certificate, but rather a private key
'''
))
# When a public key returning from _unarmor_pem has a known algorithm
# of RSA, that means the DER structure is of the type RSAPublicKey, so
# we need to wrap it in the PublicKeyInfo structure.
if algo == 'rsa':
return PublicKeyInfo.wrap(data, 'rsa')
if key_type is None or key_type == 'public key':
try:
pki = PublicKeyInfo.load(data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not PublicKeyInfo
try:
rpk = RSAPublicKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
rpk.native
return PublicKeyInfo.wrap(rpk, 'rsa')
except (ValueError):
pass # Data was not an RSAPublicKey
if key_type is None or key_type == 'certificate':
try:
parsed_cert = Certificate.load(data)
key_info = parsed_cert['tbs_certificate']['subject_public_key_info']
return key_info
except (ValueError):
pass # Data was not a cert
raise ValueError('The data specified does not appear to be a known public key or certificate format') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_public_key(file_path: str, encoding: Encoding = None) -> PublicKey:\n real_encoding = encoding or _get_encoding_type(file_path)\n\n def solve(key_data: bytes) -> PublicKey:\n \"\"\"Determine the type of data and perform loading based on data type.\n\n :param key_data: given public keys... | [
"0.7472575",
"0.72257024",
"0.71392846",
"0.68894285",
"0.67382544",
"0.6495051",
"0.6290962",
"0.62046856",
"0.61463255",
"0.6132795",
"0.6115434",
"0.6094741",
"0.608693",
"0.6077499",
"0.6075479",
"0.59709907",
"0.5938014",
"0.5919355",
"0.59184045",
"0.5892657",
"0.585911... | 0.6618405 | 5 |
Loads a certificate from a DER or PEMformatted file. Supports X.509 certificates only. | def parse_certificate(data):
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
key_type = None
# Appears to be PEM formatted
if re.match(b'\\s*-----', data) is not None:
key_type, _, data = _unarmor_pem(data)
if key_type == 'private key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a certificate, but
rather a private key
'''
))
if key_type == 'public key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a certificate, but
rather a public key
'''
))
if key_type is None or key_type == 'certificate':
try:
return Certificate.load(data)
except (ValueError):
pass # Data was not a Certificate
raise ValueError(pretty_message(
'''
The data specified does not appear to be a known certificate format
'''
)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_cert(file, format=FORMAT_PEM):\n bio = BIO.openfile(file)\n if format == FORMAT_PEM:\n return load_cert_bio(bio)\n elif format == FORMAT_DER:\n cptr = m2.d2i_x509(bio._ptr())\n if cptr is None:\n raise X509Error(Err.get_error())\n return X509(cptr, _pyfree=1... | [
"0.80966467",
"0.78768235",
"0.7402788",
"0.7182695",
"0.690147",
"0.6856863",
"0.675995",
"0.65883523",
"0.65731525",
"0.65720236",
"0.65545803",
"0.6515523",
"0.64636666",
"0.64080656",
"0.6395369",
"0.6282713",
"0.627722",
"0.6143954",
"0.6116484",
"0.6039491",
"0.6023128"... | 0.62535036 | 17 |
Loads a private key from a DER or PEMformatted file. Supports RSA, DSA and | def parse_private(data, password=None):
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
if password is not None:
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
else:
password = b''
# Appears to be PEM formatted
if re.match(b'\\s*-----', data) is not None:
key_type, _, data = _unarmor_pem(data, password)
if key_type == 'public key':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a private key, but
rather a public key
'''
))
if key_type == 'certificate':
raise ValueError(pretty_message(
'''
The data specified does not appear to be a private key, but
rather a certificate
'''
))
try:
pki = PrivateKeyInfo.load(data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not PrivateKeyInfo
try:
parsed_wrapper = EncryptedPrivateKeyInfo.load(data)
encryption_algorithm_info = parsed_wrapper['encryption_algorithm']
encrypted_data = parsed_wrapper['encrypted_data'].native
decrypted_data = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_data, password)
pki = PrivateKeyInfo.load(decrypted_data)
# Call .native to fully parse since asn1crypto is lazy
pki.native
return pki
except (ValueError):
pass # Data was not EncryptedPrivateKeyInfo
try:
parsed = RSAPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return PrivateKeyInfo.wrap(parsed, 'rsa')
except (ValueError):
pass # Data was not an RSAPrivateKey
try:
parsed = DSAPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return PrivateKeyInfo.wrap(parsed, 'dsa')
except (ValueError):
pass # Data was not a DSAPrivateKey
try:
parsed = ECPrivateKey.load(data)
# Call .native to fully parse since asn1crypto is lazy
parsed.native
return PrivateKeyInfo.wrap(parsed, 'ec')
except (ValueError):
pass # Data was not an ECPrivateKey
raise ValueError(pretty_message(
'''
The data specified does not appear to be a known private key format
'''
)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_private_key(file_path: str, password: bytes = None,\n encoding: Encoding = None) -> PrivateKey:\n real_encoding = encoding or _get_encoding_type(file_path)\n\n def solve(key_data: bytes) -> PrivateKey:\n \"\"\"Determine the type of data and perform loading based on data ty... | [
"0.7638723",
"0.760737",
"0.75808924",
"0.7359124",
"0.7319375",
"0.73121125",
"0.72465986",
"0.72324586",
"0.711873",
"0.6725466",
"0.6643382",
"0.65556437",
"0.65554005",
"0.65311825",
"0.6508552",
"0.6455299",
"0.6412754",
"0.639861",
"0.63618493",
"0.63402176",
"0.6329978... | 0.6443896 | 16 |
Removes PEMencoding from a public key, private key or certificate. If the private key is encrypted, the password will be used to decrypt it. | def _unarmor_pem(data, password=None):
object_type, headers, der_bytes = unarmor(data)
type_regex = '^((DSA|EC|RSA) PRIVATE KEY|ENCRYPTED PRIVATE KEY|PRIVATE KEY|PUBLIC KEY|RSA PUBLIC KEY|CERTIFICATE)'
armor_type = re.match(type_regex, object_type)
if not armor_type:
raise ValueError(pretty_message(
'''
data does not seem to contain a PEM-encoded certificate, private
key or public key
'''
))
pem_header = armor_type.group(1)
data = data.strip()
# RSA private keys are encrypted after being DER-encoded, but before base64
# encoding, so they need to be handled specially
if pem_header in set(['RSA PRIVATE KEY', 'DSA PRIVATE KEY', 'EC PRIVATE KEY']):
algo = armor_type.group(2).lower()
return ('private key', algo, _unarmor_pem_openssl_private(headers, der_bytes, password))
key_type = pem_header.lower()
algo = None
if key_type == 'encrypted private key':
key_type = 'private key'
elif key_type == 'rsa public key':
key_type = 'public key'
algo = 'rsa'
return (key_type, algo, der_bytes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key_to_pem(key, password=None):\n if password:\n enc = BestAvailableEncryption(as_bytes(password))\n else:\n enc = NoEncryption()\n return key.private_bytes(Encoding.PEM, PrivateFormat.PKCS8, enc)",
"def strip_begin_end_public_key(key):\n return key.replace(\"\\n\", \"\")\\\n ... | [
"0.5717775",
"0.5633551",
"0.55747586",
"0.55693495",
"0.55062234",
"0.5487441",
"0.544285",
"0.5425336",
"0.5414394",
"0.5376748",
"0.53717756",
"0.53678894",
"0.53630817",
"0.53443956",
"0.5333764",
"0.53271896",
"0.532627",
"0.5300595",
"0.5287096",
"0.5276774",
"0.5239591... | 0.5872964 | 0 |
Parses a PKCS1 private key, or encrypted private key | def _unarmor_pem_openssl_private(headers, data, password):
enc_algo = None
enc_iv_hex = None
enc_iv = None
if 'DEK-Info' in headers:
params = headers['DEK-Info']
if params.find(',') != -1:
enc_algo, enc_iv_hex = params.strip().split(',')
else:
enc_algo = 'RC4'
if not enc_algo:
return data
if enc_iv_hex:
enc_iv = binascii.unhexlify(enc_iv_hex.encode('ascii'))
enc_algo = enc_algo.lower()
enc_key_length = {
'aes-128-cbc': 16,
'aes-128': 16,
'aes-192-cbc': 24,
'aes-192': 24,
'aes-256-cbc': 32,
'aes-256': 32,
'rc4': 16,
'rc4-64': 8,
'rc4-40': 5,
'rc2-64-cbc': 8,
'rc2-40-cbc': 5,
'rc2-cbc': 16,
'rc2': 16,
'des-ede3-cbc': 24,
'des-ede3': 24,
'des3': 24,
'des-ede-cbc': 16,
'des-cbc': 8,
'des': 8,
}[enc_algo]
enc_key = hashlib.md5(password + enc_iv[0:8]).digest()
while enc_key_length > len(enc_key):
enc_key += hashlib.md5(enc_key + password + enc_iv[0:8]).digest()
enc_key = enc_key[0:enc_key_length]
enc_algo_name = {
'aes-128-cbc': 'aes',
'aes-128': 'aes',
'aes-192-cbc': 'aes',
'aes-192': 'aes',
'aes-256-cbc': 'aes',
'aes-256': 'aes',
'rc4': 'rc4',
'rc4-64': 'rc4',
'rc4-40': 'rc4',
'rc2-64-cbc': 'rc2',
'rc2-40-cbc': 'rc2',
'rc2-cbc': 'rc2',
'rc2': 'rc2',
'des-ede3-cbc': 'tripledes',
'des-ede3': 'tripledes',
'des3': 'tripledes',
'des-ede-cbc': 'tripledes',
'des-cbc': 'des',
'des': 'des',
}[enc_algo]
decrypt_func = crypto_funcs[enc_algo_name]
if enc_algo_name == 'rc4':
return decrypt_func(enc_key, data)
return decrypt_func(enc_key, data, enc_iv) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parsePrivateKey(s):\r\n return parsePEMKey(s, private=True)",
"def parse_private(data, password=None):\n\n if not isinstance(data, byte_cls):\n raise TypeError(pretty_message(\n '''\n data must be a byte string, not %s\n ''',\n type_name(data)\n ... | [
"0.7084714",
"0.6720833",
"0.6673835",
"0.6610752",
"0.6331672",
"0.6264508",
"0.6190057",
"0.6077617",
"0.6024118",
"0.6018048",
"0.5971257",
"0.59107363",
"0.5894486",
"0.58921105",
"0.58741915",
"0.5793097",
"0.57621163",
"0.5711211",
"0.5711122",
"0.5708818",
"0.570693",
... | 0.5370357 | 48 |
Parses a PKCS12 ANS.1 DERencoded structure and extracts certs and keys | def _parse_pkcs12(data, password, load_private_key):
if not isinstance(data, byte_cls):
raise TypeError(pretty_message(
'''
data must be a byte string, not %s
''',
type_name(data)
))
if password is not None:
if not isinstance(password, byte_cls):
raise TypeError(pretty_message(
'''
password must be a byte string, not %s
''',
type_name(password)
))
else:
password = b''
certs = {}
private_keys = {}
pfx = Pfx.load(data)
auth_safe = pfx['auth_safe']
if auth_safe['content_type'].native != 'data':
raise ValueError(pretty_message(
'''
Only password-protected PKCS12 files are currently supported
'''
))
authenticated_safe = pfx.authenticated_safe
mac_data = pfx['mac_data']
if mac_data:
mac_algo = mac_data['mac']['digest_algorithm']['algorithm'].native
key_length = {
'sha1': 20,
'sha224': 28,
'sha256': 32,
'sha384': 48,
'sha512': 64,
'sha512_224': 28,
'sha512_256': 32,
}[mac_algo]
mac_key = pkcs12_kdf(
mac_algo,
password,
mac_data['mac_salt'].native,
mac_data['iterations'].native,
key_length,
3 # ID 3 is for generating an HMAC key
)
hash_mod = getattr(hashlib, mac_algo)
computed_hmac = hmac.new(mac_key, auth_safe['content'].contents, hash_mod).digest()
stored_hmac = mac_data['mac']['digest'].native
if not constant_compare(computed_hmac, stored_hmac):
raise ValueError('Password provided is invalid')
for content_info in authenticated_safe:
content = content_info['content']
if isinstance(content, OctetString):
_parse_safe_contents(content.native, certs, private_keys, password, load_private_key)
elif isinstance(content, EncryptedData):
encrypted_content_info = content['encrypted_content_info']
encryption_algorithm_info = encrypted_content_info['content_encryption_algorithm']
encrypted_content = encrypted_content_info['encrypted_content'].native
decrypted_content = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password)
_parse_safe_contents(decrypted_content, certs, private_keys, password, load_private_key)
else:
raise ValueError(pretty_message(
'''
Public-key-based PKCS12 files are not currently supported
'''
))
key_fingerprints = set(private_keys.keys())
cert_fingerprints = set(certs.keys())
common_fingerprints = sorted(list(key_fingerprints & cert_fingerprints))
key = None
cert = None
other_certs = []
if len(common_fingerprints) >= 1:
fingerprint = common_fingerprints[0]
key = private_keys[fingerprint]
cert = certs[fingerprint]
other_certs = [certs[f] for f in certs if f != fingerprint]
return (key, cert, other_certs)
if len(private_keys) > 0:
first_key = sorted(list(private_keys.keys()))[0]
key = private_keys[first_key]
if len(certs) > 0:
first_key = sorted(list(certs.keys()))[0]
cert = certs[first_key]
del certs[first_key]
if len(certs) > 0:
other_certs = sorted(list(certs.values()), key=lambda c: c.subject.human_friendly)
return (key, cert, other_certs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseBinary(self, bytes):\r\n\r\n self.bytes = bytearray(bytes)\r\n p = ASN1Parser(bytes)\r\n\r\n #Get the tbsCertificate\r\n tbsCertificateP = p.getChild(0)\r\n\r\n #Is the optional version field present?\r\n #This determines which index the key is at.\r\n if t... | [
"0.60229003",
"0.5695678",
"0.5526086",
"0.54503",
"0.5424802",
"0.51653993",
"0.51222205",
"0.5089913",
"0.5076887",
"0.50647706",
"0.5058496",
"0.4928613",
"0.4890625",
"0.48888293",
"0.48255894",
"0.47993195",
"0.47745132",
"0.47668105",
"0.47628716",
"0.47628716",
"0.4759... | 0.67407256 | 0 |
Parses a SafeContents PKCS12 ANS.1 structure and extracts certs and keys | def _parse_safe_contents(safe_contents, certs, private_keys, password, load_private_key):
if isinstance(safe_contents, byte_cls):
safe_contents = SafeContents.load(safe_contents)
for safe_bag in safe_contents:
bag_value = safe_bag['bag_value']
if isinstance(bag_value, CertBag):
if bag_value['cert_id'].native == 'x509':
cert = bag_value['cert_value'].parsed
public_key_info = cert['tbs_certificate']['subject_public_key_info']
certs[_fingerprint(public_key_info, None)] = bag_value['cert_value'].parsed
elif isinstance(bag_value, PrivateKeyInfo):
private_keys[_fingerprint(bag_value, load_private_key)] = bag_value
elif isinstance(bag_value, EncryptedPrivateKeyInfo):
encryption_algorithm_info = bag_value['encryption_algorithm']
encrypted_key_bytes = bag_value['encrypted_data'].native
decrypted_key_bytes = _decrypt_encrypted_data(encryption_algorithm_info, encrypted_key_bytes, password)
private_key = PrivateKeyInfo.load(decrypted_key_bytes)
private_keys[_fingerprint(private_key, load_private_key)] = private_key
elif isinstance(bag_value, SafeContents):
_parse_safe_contents(bag_value, certs, private_keys, password, load_private_key)
else:
# We don't care about CRL bags or secret bags
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_pkcs12(data, password, load_private_key):\n\n if not isinstance(data, byte_cls):\n raise TypeError(pretty_message(\n '''\n data must be a byte string, not %s\n ''',\n type_name(data)\n ))\n\n if password is not None:\n if not isinsta... | [
"0.6905935",
"0.519228",
"0.5144184",
"0.5090635",
"0.4969031",
"0.49095032",
"0.48951414",
"0.48807597",
"0.4877804",
"0.48451734",
"0.4826676",
"0.48249158",
"0.48138803",
"0.4775471",
"0.47672594",
"0.4758738",
"0.47264582",
"0.47241712",
"0.46494445",
"0.4630516",
"0.4615... | 0.6486718 | 1 |
Decrypts encrypted ASN.1 data | def _decrypt_encrypted_data(encryption_algorithm_info, encrypted_content, password):
decrypt_func = crypto_funcs[encryption_algorithm_info.encryption_cipher]
# Modern, PKCS#5 PBES2-based encryption
if encryption_algorithm_info.kdf == 'pbkdf2':
if encryption_algorithm_info.encryption_cipher == 'rc5':
raise ValueError(pretty_message(
'''
PBES2 encryption scheme utilizing RC5 encryption is not supported
'''
))
enc_key = pbkdf2(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length
)
enc_iv = encryption_algorithm_info.encryption_iv
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
elif encryption_algorithm_info.kdf == 'pbkdf1':
derived_output = pbkdf1(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length + 8
)
enc_key = derived_output[0:8]
enc_iv = derived_output[8:16]
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
elif encryption_algorithm_info.kdf == 'pkcs12_kdf':
enc_key = pkcs12_kdf(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.key_length,
1 # ID 1 is for generating a key
)
# Since RC4 is a stream cipher, we don't use an IV
if encryption_algorithm_info.encryption_cipher == 'rc4':
plaintext = decrypt_func(enc_key, encrypted_content)
else:
enc_iv = pkcs12_kdf(
encryption_algorithm_info.kdf_hmac,
password,
encryption_algorithm_info.kdf_salt,
encryption_algorithm_info.kdf_iterations,
encryption_algorithm_info.encryption_block_size,
2 # ID 2 is for generating an IV
)
plaintext = decrypt_func(enc_key, encrypted_content, enc_iv)
return plaintext | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decrypt(self, data):",
"def rsa_pkcs1v15_decrypt(self, data):\n pass",
"def decode(self, crypto):",
"def decrypt(self, data):\n if not data:\n return ''\n data = self._crypt(data, self.DECRYPT)\n return self._unpad_data(data)",
"def decrypted(data: str) -> str:\n\... | [
"0.76379395",
"0.72864676",
"0.681302",
"0.6796825",
"0.67245364",
"0.67193043",
"0.66916806",
"0.66666394",
"0.6586855",
"0.6586855",
"0.6545387",
"0.6543017",
"0.64966065",
"0.6484453",
"0.6446464",
"0.643858",
"0.6381135",
"0.6379265",
"0.63670003",
"0.63490975",
"0.633111... | 0.5746602 | 71 |
Make a model where each trial has its own regressor using least squares all (LSA) | def _lsa_events_converter(events_file):
import pandas as pd
events = pd.read_csv(events_file, sep='\t')
events['original_trial_type'] = events['trial_type']
for cond, cond_df in events.groupby('trial_type'):
cond_idx = cond_df.index
for i_trial, trial_idx in enumerate(cond_idx):
trial_name = '{0}_{1:04d}'.format(cond, i_trial+1)
events.loc[trial_idx, 'trial_type'] = trial_name
return events | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize(self, trial):\r\n num_leaves = trial.suggest_int(\"num_leaves\", 6, 50)\r\n min_child_samples = trial.suggest_int(\"min_child_samples\", 100, 500)\r\n min_child_weight = trial.suggest_uniform(\"min_child_weight\", 1, 7)\r\n subsample = trial.suggest_uniform(\"subsample\", 0... | [
"0.6492245",
"0.64286274",
"0.6315411",
"0.62603295",
"0.62471396",
"0.62323004",
"0.61873966",
"0.61866516",
"0.61369425",
"0.6030381",
"0.6029556",
"0.60007995",
"0.5999436",
"0.5996053",
"0.5956116",
"0.5954355",
"0.59472334",
"0.5938865",
"0.59243846",
"0.5919388",
"0.590... | 0.0 | -1 |
Make a model for each trial using least squares separate (LSS) | def _lss_events_iterator(events_file):
import pandas as pd
import numpy as np
events = pd.read_csv(events_file, sep='\t')
trial_counter = dict([(t, 0) for t in np.unique(events['trial_type'])])
for trial_id in range(len(events)):
trial_type = events.loc[trial_id, 'trial_type']
# make a copy of the dataframe
events_trial = events.copy()
# assign new name to all events from original condition
trial_type_id = events_trial['trial_type'] == trial_type
events_trial.loc[trial_type_id, 'trial_type'] = 'other'
# assign the trial of interest to be its original value
events_trial.loc[trial_id, 'trial_type'] = trial_type
yield events_trial, trial_type, trial_counter[trial_type]
trial_counter[trial_type] += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_SLM():\n samples = 10\n predictors = 3\n\n grid = list(create_parameter_grid(samples, predictors))\n Y = np.random.rand(samples, 10242, predictors)\n\n for i in range(len(grid)):\n # Skip exceptions that we know error.\n if grid[i][\"surf\"] is None:\n if grid[i][\"... | [
"0.67663735",
"0.65927625",
"0.65322",
"0.6456039",
"0.6399128",
"0.6376486",
"0.6376346",
"0.6321311",
"0.62462187",
"0.6168609",
"0.6121046",
"0.60952455",
"0.60772586",
"0.60441196",
"0.6029791",
"0.60081315",
"0.5985883",
"0.59815985",
"0.5979063",
"0.59740895",
"0.595946... | 0.0 | -1 |
Process and return selected confounds from the confounds file | def _select_confounds(confounds_file, selected_confounds):
import pandas as pd
import numpy as np
confounds_df = pd.read_csv(confounds_file, sep='\t', na_values='n/a')
# fill the first value of FramewiseDisplacement with the mean.
if 'FramewiseDisplacement' in selected_confounds:
confounds_df['FramewiseDisplacement'] = confounds_df['FramewiseDisplacement'].fillna(
np.mean(confounds_df['FramewiseDisplacement']))
desired_confounds = confounds_df[selected_confounds]
return desired_confounds | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _select_confounds(confounds_file, selected_confounds):\n import pandas as pd\n import numpy as np\n import re\n\n confounds_df = pd.read_csv(confounds_file, sep='\\t', na_values='n/a')\n # regular expression to capture confounds specified at the command line\n confound_expr = re.compile(r\"|\... | [
"0.65061325",
"0.5781993",
"0.5781708",
"0.56171685",
"0.55821574",
"0.55591077",
"0.55106205",
"0.5485491",
"0.5484373",
"0.5472426",
"0.54602283",
"0.54551107",
"0.5445359",
"0.5434916",
"0.5391505",
"0.5335677",
"0.53314865",
"0.53281003",
"0.5295112",
"0.52804834",
"0.527... | 0.6170222 | 1 |
Create sinusoidal timestep embeddings. | def timestep_embedding(timesteps, dim, max_period=10000):
half = dim // 2
freqs = torch.exp(
-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
).to(device=timesteps.device)
args = timesteps[:, None].float() * freqs[None]
embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
if dim % 2:
embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
return embedding | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timestep_embedding(timesteps, dim, max_period=10000):\n half = dim // 2\n freqs = paddle.exp(-math.log(max_period) * paddle.arange(start=0, end=half, dtype=paddle.float32) / half)\n args = paddle.cast(timesteps[:, None], 'float32') * freqs[None]\n embedding = paddle.concat([paddle.cos(args), paddle... | [
"0.66800493",
"0.66085994",
"0.60627913",
"0.59043974",
"0.5894194",
"0.5874639",
"0.58046216",
"0.5689095",
"0.5540392",
"0.5476205",
"0.54213727",
"0.53775567",
"0.53557706",
"0.53395146",
"0.5328101",
"0.53141636",
"0.53015023",
"0.52998585",
"0.52972686",
"0.52835363",
"0... | 0.65616596 | 2 |
Return a cached copy of TestShib's metadata by reading it from disk | def metadata_callback(_request, _uri, headers):
return (200, headers, self.read_data_file('testshib_metadata.xml')) # lint-amnesty, pylint: disable=no-member | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_metadata(self):\n return copy.copy(self.metadata)",
"def get_and_update_metadata():\n if not os.path.exists('.git') and os.path.exists(METADATA_FILENAME):\n with open(METADATA_FILENAME) as fh:\n metadata = json.load(fh)\n else:\n git = Git()\n revision = os.en... | [
"0.6429627",
"0.63208026",
"0.6306309",
"0.62240237",
"0.6207978",
"0.6194947",
"0.6191376",
"0.61298776",
"0.61292166",
"0.6115907",
"0.60866165",
"0.60811806",
"0.6044135",
"0.6037326",
"0.6034143",
"0.6017177",
"0.5996634",
"0.59623575",
"0.594425",
"0.5941117",
"0.5909399... | 0.0 | -1 |
Return a cached copy of TestShib's metadata with a cacheDuration attribute | def cache_duration_metadata_callback(_request, _uri, headers):
return (200, headers, self.read_data_file('testshib_metadata_with_cache_duration.xml')) # lint-amnesty, pylint: disable=no-member | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_metadata(self) -> Metadata:\n manifest = self._get_manifest()\n\n return Metadata(**manifest[\"metadata\"])",
"def get_metadata(self):\n return copy.copy(self.metadata)",
"def cache_data(self):\n # Initialize key variables\n result = self.data['cache_data']\n ... | [
"0.5946828",
"0.5924196",
"0.5874222",
"0.58641565",
"0.58568573",
"0.5794843",
"0.57618964",
"0.5748162",
"0.5736788",
"0.5663821",
"0.5662813",
"0.5655036",
"0.5647174",
"0.56243145",
"0.55787057",
"0.5567786",
"0.55402327",
"0.5527116",
"0.55239946",
"0.55070686",
"0.54851... | 0.6988418 | 0 |
Mock the current time for SAML, so we can replay canned requests/responses | def _freeze_time(self, timestamp):
now_patch = patch('onelogin.saml2.utils.OneLogin_Saml2_Utils.now', return_value=timestamp)
now_patch.start()
self.addCleanup(now_patch.stop) # lint-amnesty, pylint: disable=no-member | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mocked_time():\n return datetime.datetime(2017, 10, 27, 22, 54, 56, 566179)",
"def test_method(self):\n response = self.app.get('/')\n assert isinstance(response.raw['now'], datetime.datetime)",
"def test_configure_testshib_provider_with_cache_duration(self):\n kwargs = {}\n ... | [
"0.6736465",
"0.6140573",
"0.60731506",
"0.60279644",
"0.59742117",
"0.5914771",
"0.5881534",
"0.5857517",
"0.5802075",
"0.57887524",
"0.57644403",
"0.5713352",
"0.56917495",
"0.5675409",
"0.56512123",
"0.5646837",
"0.56387556",
"0.5580659",
"0.557747",
"0.557065",
"0.5564709... | 0.586782 | 7 |
Enable and configure the TestShib SAML IdP as a third_party_auth provider | def _configure_testshib_provider(self, **kwargs):
fetch_metadata = kwargs.pop('fetch_metadata', True)
assert_metadata_updates = kwargs.pop('assert_metadata_updates', True)
kwargs.setdefault('name', self.PROVIDER_NAME)
kwargs.setdefault('enabled', True)
kwargs.setdefault('visible', True)
kwargs.setdefault("backend_name", "tpa-saml")
kwargs.setdefault('slug', self.PROVIDER_IDP_SLUG)
kwargs.setdefault('entity_id', TESTSHIB_ENTITY_ID)
kwargs.setdefault('metadata_source', TESTSHIB_METADATA_URL)
kwargs.setdefault('icon_class', 'fa-university')
kwargs.setdefault('attr_email', 'urn:oid:1.3.6.1.4.1.5923.1.1.1.6') # eduPersonPrincipalName
kwargs.setdefault('max_session_length', None)
kwargs.setdefault('send_to_registration_first', False)
kwargs.setdefault('skip_email_verification', False)
saml_provider = self.configure_saml_provider(**kwargs) # pylint: disable=no-member
if fetch_metadata:
assert httpretty.is_enabled() # lint-amnesty, pylint: disable=no-member
num_total, num_skipped, num_attempted, num_updated, num_failed, failure_messages = fetch_saml_metadata()
if assert_metadata_updates:
assert num_total == 1 # lint-amnesty, pylint: disable=no-member
assert num_skipped == 0 # lint-amnesty, pylint: disable=no-member
assert num_attempted == 1 # lint-amnesty, pylint: disable=no-member
assert num_updated == 1 # lint-amnesty, pylint: disable=no-member
assert num_failed == 0 # lint-amnesty, pylint: disable=no-member
assert len(failure_messages) == 0 # lint-amnesty, pylint: disable=no-member
return saml_provider | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enable_third_party_auth():\r\n\r\n from third_party_auth import settings as auth_settings\r\n auth_settings.apply_settings(settings.THIRD_PARTY_AUTH, settings)",
"def init_saml_auth(saml_prepared_flask_request):\n return OneLogin_Saml2_Auth(saml_prepared_flask_request, custom_base_path=app.config.ge... | [
"0.67878383",
"0.63547695",
"0.63465583",
"0.61199355",
"0.59225214",
"0.58825934",
"0.56425726",
"0.563755",
"0.562901",
"0.5535802",
"0.5476775",
"0.53583604",
"0.531819",
"0.5295527",
"0.52504843",
"0.51937705",
"0.5125788",
"0.50825155",
"0.5081821",
"0.5010863",
"0.49874... | 0.7070957 | 0 |
Gets dict (string > object) of merged data about the user. | def get_response_data(self):
response_data = dict(self.TOKEN_RESPONSE_DATA)
response_data.update(self.USER_RESPONSE_DATA)
return response_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_user_data(self):\n return {\"key\": self._key}",
"def get_dictionary(self):\n data = {\n \"user_first_name\": self.user.first_name,\n \"user_last_name\": self.user.last_name,\n }\n dct = provider.Provider.get_dictionary(self)\n dct.upd... | [
"0.67946744",
"0.673818",
"0.6689629",
"0.6652367",
"0.66178507",
"0.66178507",
"0.6612004",
"0.6559976",
"0.6502731",
"0.6489732",
"0.6368647",
"0.63625497",
"0.63397974",
"0.6320728",
"0.6294594",
"0.6281204",
"0.62439865",
"0.62202954",
"0.6208482",
"0.6208218",
"0.6160015... | 0.6040271 | 28 |
Configure TestShib before running the login test | def test_login(self):
self._configure_testshib_provider()
self._test_login() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register(self):\n self._configure_testshib_provider()\n self._test_register()",
"def set_up_login():\n\n bitool.app.testing = True\n bitool.app.config['TESTING'] = True\n bitool.app.login_manager.init_app(bitool.app)\n app = bitool.app.test_client()\n\n return app",
"def c... | [
"0.68922627",
"0.6773958",
"0.6753465",
"0.6616434",
"0.65026134",
"0.6428037",
"0.6423407",
"0.6388931",
"0.63668215",
"0.6346543",
"0.63392085",
"0.6336799",
"0.62982786",
"0.62645006",
"0.62591666",
"0.62502235",
"0.62502235",
"0.62462556",
"0.62462556",
"0.62462556",
"0.6... | 0.81601787 | 0 |
Configure TestShib before running the register test | def test_register(self):
self._configure_testshib_provider()
self._test_register() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configure_test(self, test, config_json):\n pass",
"def test_register():\n plug.manager.register(junit4)",
"def setUpConfig(self):\n pass",
"def test_login(self):\n self._configure_testshib_provider()\n self._test_login()",
"def setup_method(self, test_method):\n se... | [
"0.7068733",
"0.6525172",
"0.6467879",
"0.63710594",
"0.6313307",
"0.6234248",
"0.6212751",
"0.60972005",
"0.6043006",
"0.6039801",
"0.5995316",
"0.5995316",
"0.5995316",
"0.5995316",
"0.5992337",
"0.5989009",
"0.59598655",
"0.5953964",
"0.5928903",
"0.59063",
"0.5904783",
... | 0.83610606 | 0 |
Test that attributes sent by a SAML provider are stored in the UserSocialAuth table. | def test_login_records_attributes(self):
self.test_login()
record = UserSocialAuth.objects.get(
user=self.user, provider=self.PROVIDER_BACKEND, uid__startswith=self.PROVIDER_IDP_SLUG
)
attributes = record.extra_data
assert attributes.get('urn:oid:1.3.6.1.4.1.5923.1.1.1.9') == ['Member@testshib.org', 'Staff@testshib.org']
assert attributes.get('urn:oid:2.5.4.3') == ['Me Myself And I']
assert attributes.get('urn:oid:0.9.2342.19200300.100.1.1') == ['myself']
assert attributes.get('urn:oid:2.5.4.20') == ['555-5555']
# Phone number | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_insufficient_sapsf_metadata(self):\n self._configure_testshib_provider(\n identity_provider_type='sap_success_factors',\n metadata_source=TESTSHIB_METADATA_URL,\n other_settings='{\"key_i_dont_need\":\"value_i_also_dont_need\"}',\n )\n # Becau... | [
"0.6245322",
"0.59301543",
"0.5911321",
"0.58538973",
"0.58124703",
"0.57879347",
"0.56024635",
"0.5550127",
"0.55485487",
"0.54875433",
"0.54671925",
"0.54621214",
"0.54423463",
"0.5395432",
"0.5389309",
"0.5383121",
"0.5311547",
"0.5295665",
"0.5293737",
"0.52753067",
"0.52... | 0.7325418 | 0 |
Test SAML login logs with debug mode enabled or not | def test_debug_mode_login(self, debug_mode_enabled):
self._configure_testshib_provider(debug_mode=debug_mode_enabled)
with patch.object(saml_log, 'info') as mock_log:
self._test_login()
if debug_mode_enabled:
# We expect that test_login() does two full logins, and each attempt generates two
# logs - one for the request and one for the response
assert mock_log.call_count == 4
expected_next_url = "/dashboard"
(msg, action_type, idp_name, request_data, next_url, xml), _kwargs = mock_log.call_args_list[0]
assert msg.startswith('SAML login %s')
assert action_type == 'request'
assert idp_name == self.PROVIDER_IDP_SLUG
self.assertDictContainsSubset(
{"idp": idp_name, "auth_entry": "login", "next": expected_next_url},
request_data
)
assert next_url == expected_next_url
assert '<samlp:AuthnRequest' in xml
(msg, action_type, idp_name, response_data, next_url, xml), _kwargs = mock_log.call_args_list[1]
assert msg.startswith('SAML login %s')
assert action_type == 'response'
assert idp_name == self.PROVIDER_IDP_SLUG
self.assertDictContainsSubset({"RelayState": idp_name}, response_data)
assert 'SAMLResponse' in response_data
assert next_url == expected_next_url
assert '<saml2p:Response' in xml
else:
assert not mock_log.called | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_logging_running(self):\n tester = app.test_client(self)\n response = tester.get('/login', content_type='html/text')\n self.assertTrue(b'PLEASE LOGIN' in response.data)",
"def test_logging(self):\n self._verify_logging()",
"def test_successful_login(self):\n pass",
"def... | [
"0.6547012",
"0.61618876",
"0.6142526",
"0.6016165",
"0.5957221",
"0.59324735",
"0.5907222",
"0.58748484",
"0.58701736",
"0.5860925",
"0.582712",
"0.5819717",
"0.57623357",
"0.5748084",
"0.57179964",
"0.56889266",
"0.56684595",
"0.56650877",
"0.5635419",
"0.5612174",
"0.55851... | 0.8257416 | 0 |
Enable and configure the TestShib SAML IdP as a third_party_auth provider | def test_configure_testshib_provider_with_cache_duration(self):
kwargs = {}
kwargs.setdefault('name', self.PROVIDER_NAME)
kwargs.setdefault('enabled', True)
kwargs.setdefault('visible', True)
kwargs.setdefault('slug', self.PROVIDER_IDP_SLUG)
kwargs.setdefault('entity_id', TESTSHIB_ENTITY_ID)
kwargs.setdefault('metadata_source', TESTSHIB_METADATA_URL_WITH_CACHE_DURATION)
kwargs.setdefault('icon_class', 'fa-university')
kwargs.setdefault('attr_email', 'urn:oid:1.3.6.1.4.1.5923.1.1.1.6') # eduPersonPrincipalName
self.configure_saml_provider(**kwargs)
assert httpretty.is_enabled()
num_total, num_skipped, num_attempted, num_updated, num_failed, failure_messages = fetch_saml_metadata()
assert num_total == 1
assert num_skipped == 0
assert num_attempted == 1
assert num_updated == 1
assert num_failed == 0
assert len(failure_messages) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _configure_testshib_provider(self, **kwargs):\n fetch_metadata = kwargs.pop('fetch_metadata', True)\n assert_metadata_updates = kwargs.pop('assert_metadata_updates', True)\n kwargs.setdefault('name', self.PROVIDER_NAME)\n kwargs.setdefault('enabled', True)\n kwargs.setdefault... | [
"0.70712364",
"0.67885256",
"0.6354537",
"0.6346624",
"0.61197853",
"0.5923575",
"0.5643076",
"0.563825",
"0.5628388",
"0.55354863",
"0.54767126",
"0.5359936",
"0.5318166",
"0.5296389",
"0.5250402",
"0.5193824",
"0.512464",
"0.508345",
"0.5081745",
"0.50114036",
"0.49877226",... | 0.58824545 | 6 |
Test that when we have a TPA provider which as an explicit maximum session length set, waiting for longer than that between requests results in us being logged out. | def test_login_with_testshib_provider_short_session_length(self):
# Configure the provider with a 10-second timeout
self._configure_testshib_provider(max_session_length=10)
now = datetime.datetime.utcnow()
with freeze_time(now):
# Test the login flow, adding the user in the process
self._test_login()
# Wait 30 seconds; longer than the manually-set 10-second timeout
later = now + datetime.timedelta(seconds=30)
with freeze_time(later):
# Test returning as a logged in user; this method verifies that we're logged out first.
self._test_return_login(previous_session_timed_out=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_inactive_session_timeout(self):\r\n email, password = self.STUDENT_INFO[0]\r\n self.login(email, password)\r\n\r\n # make sure we can access courseware immediately\r\n resp = self.client.get(reverse('dashboard'))\r\n self.assertEquals(resp.status_code, 200)\r\n\r\n ... | [
"0.67007613",
"0.6563989",
"0.6529781",
"0.63517386",
"0.6243885",
"0.6232972",
"0.6106514",
"0.6026753",
"0.5952208",
"0.59390306",
"0.5926259",
"0.58408374",
"0.58186436",
"0.5785342",
"0.57843",
"0.57781994",
"0.57300466",
"0.572285",
"0.57226133",
"0.5715555",
"0.57084894... | 0.77491003 | 0 |
Mock out HTTP calls to various endpoints using httpretty. | def setUp(self):
super().setUp()
# Mock the call to the SAP SuccessFactors assertion endpoint
SAPSF_ASSERTION_URL = 'http://successfactors.com/oauth/idp'
def assertion_callback(_request, _uri, headers):
"""
Return a fake assertion after checking that the input is what we expect.
"""
assert b'private_key=fake_private_key_here' in _request.body
assert b'user_id=myself' in _request.body
assert b'token_url=http%3A%2F%2Fsuccessfactors.com%2Foauth%2Ftoken' in _request.body
assert b'client_id=TatVotSEiCMteSNWtSOnLanCtBGwNhGB' in _request.body
return (200, headers, 'fake_saml_assertion')
httpretty.register_uri(httpretty.POST, SAPSF_ASSERTION_URL, content_type='text/plain', body=assertion_callback)
SAPSF_BAD_ASSERTION_URL = 'http://successfactors.com/oauth-fake/idp'
def bad_callback(_request, _uri, headers):
"""
Return a 404 error when someone tries to call the URL.
"""
return (404, headers, 'NOT AN ASSERTION')
httpretty.register_uri(httpretty.POST, SAPSF_BAD_ASSERTION_URL, content_type='text/plain', body=bad_callback)
# Mock the call to the SAP SuccessFactors token endpoint
SAPSF_TOKEN_URL = 'http://successfactors.com/oauth/token'
def token_callback(_request, _uri, headers):
"""
Return a fake assertion after checking that the input is what we expect.
"""
assert b'assertion=fake_saml_assertion' in _request.body
assert b'company_id=NCC1701D' in _request.body
assert b'grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Asaml2-bearer' in _request.body
assert b'client_id=TatVotSEiCMteSNWtSOnLanCtBGwNhGB' in _request.body
return (200, headers, '{"access_token": "faketoken"}')
httpretty.register_uri(httpretty.POST, SAPSF_TOKEN_URL, content_type='application/json', body=token_callback)
# Mock the call to the SAP SuccessFactors OData user endpoint
ODATA_USER_URL = (
'http://api.successfactors.com/odata/v2/User(userId=\'myself\')'
'?$select=firstName,lastName,defaultFullName,email'
)
def user_callback(request, _uri, headers):
auth_header = request.headers.get('Authorization')
assert auth_header == 'Bearer faketoken'
return (
200,
headers,
json.dumps({
'd': {
'username': 'jsmith',
'firstName': 'John',
'lastName': 'Smith',
'defaultFullName': 'John Smith',
'email': 'john@smith.com',
'country': 'Australia',
}
})
)
httpretty.register_uri(httpretty.GET, ODATA_USER_URL, content_type='application/json', body=user_callback) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def httpretty():\n import httpretty\n httpretty.enable()\n yield httpretty\n httpretty.disable()",
"def test_get(self):\n client = RestClient(host=self.host, username='')\n rest_url = 'some/url/'\n \n # Mock good response\n with responses.RequestsMock() as rsps:\n ... | [
"0.7003493",
"0.6884988",
"0.6701029",
"0.66182",
"0.6446721",
"0.6388721",
"0.6341374",
"0.62644625",
"0.62517893",
"0.625138",
"0.62413937",
"0.6225622",
"0.6221288",
"0.6194367",
"0.61357135",
"0.61174285",
"0.6117166",
"0.609931",
"0.60828453",
"0.607748",
"0.6064459",
... | 0.5968934 | 27 |
Return a fake assertion after checking that the input is what we expect. | def assertion_callback(_request, _uri, headers):
assert b'private_key=fake_private_key_here' in _request.body
assert b'user_id=myself' in _request.body
assert b'token_url=http%3A%2F%2Fsuccessfactors.com%2Foauth%2Ftoken' in _request.body
assert b'client_id=TatVotSEiCMteSNWtSOnLanCtBGwNhGB' in _request.body
return (200, headers, 'fake_saml_assertion') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_func(input, expected):\n from parenthetics import paren\n assert paren(input) == expected",
"def test_example():\n answer = True\n expected = True\n assert answer == expected",
"def expected_value(expected, actual):\n assert expected == actual",
"def validate_Assert(result, _dummy_... | [
"0.6541787",
"0.647255",
"0.6471959",
"0.64491946",
"0.64080536",
"0.62548614",
"0.62316114",
"0.6227208",
"0.61887175",
"0.6130757",
"0.61267287",
"0.6095201",
"0.60947305",
"0.6071231",
"0.60602826",
"0.6057711",
"0.6053218",
"0.60242915",
"0.6014357",
"0.5987886",
"0.59692... | 0.0 | -1 |
Return a 404 error when someone tries to call the URL. | def bad_callback(_request, _uri, headers):
return (404, headers, 'NOT AN ASSERTION') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def not_found():\n return HttpError(404)",
"def error_404(error):\n return 'Bummer, there is nothing at this URL.'",
"def not_found():\n raise cherrypy.HTTPError(404, \"Not Found.\")",
"def page_not_found(e):\n return 'Sorry, nothing at this URL.', 404",
"def page_not_found(e):\n return 'Sorry... | [
"0.77854127",
"0.7611726",
"0.7589559",
"0.7564481",
"0.7564481",
"0.7564481",
"0.7564481",
"0.7564481",
"0.7564481",
"0.7564481",
"0.7528948",
"0.7528948",
"0.7528948",
"0.7528948",
"0.7528948",
"0.7528948",
"0.7528948",
"0.7528948",
"0.74066204",
"0.73611426",
"0.73296165",... | 0.0 | -1 |
Return a fake assertion after checking that the input is what we expect. | def token_callback(_request, _uri, headers):
assert b'assertion=fake_saml_assertion' in _request.body
assert b'company_id=NCC1701D' in _request.body
assert b'grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Asaml2-bearer' in _request.body
assert b'client_id=TatVotSEiCMteSNWtSOnLanCtBGwNhGB' in _request.body
return (200, headers, '{"access_token": "faketoken"}') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_func(input, expected):\n from parenthetics import paren\n assert paren(input) == expected",
"def test_example():\n answer = True\n expected = True\n assert answer == expected",
"def expected_value(expected, actual):\n assert expected == actual",
"def validate_Assert(result, _dummy_... | [
"0.65425646",
"0.64745665",
"0.64722836",
"0.644988",
"0.64093584",
"0.62563604",
"0.6232764",
"0.6228062",
"0.61891055",
"0.6131768",
"0.61279905",
"0.60960275",
"0.6095586",
"0.6073744",
"0.6061325",
"0.6057807",
"0.6056131",
"0.6024911",
"0.60140353",
"0.59895396",
"0.5970... | 0.0 | -1 |
Mock an error response when calling the OData API for user details. | def _mock_odata_api_for_error(self, odata_api_root_url, username):
def callback(request, uri, headers): # lint-amnesty, pylint: disable=unused-argument
"""
Return a 500 error when someone tries to call the URL.
"""
headers['CorrelationId'] = 'aefd38b7-c92c-445a-8c7a-487a3f0c7a9d'
headers['RequestNo'] = '[787177]' # This is the format SAPSF returns for the transaction request number
return 500, headers, 'Failure!'
fields = ','.join(SapSuccessFactorsIdentityProvider.default_field_mapping.copy())
url = '{root_url}User(userId=\'{user_id}\')?$select={fields}'.format(
root_url=odata_api_root_url,
user_id=username,
fields=fields,
)
httpretty.register_uri(httpretty.GET, url, body=callback, content_type='application/json')
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_response_error(self):\n r = mock.Mock(spec=requests.Response)\n r.content = \"{'normal': 'resource'}\"\n\n f = Fitbit(**self.client_kwargs)\n f.client._request = lambda *args, **kwargs: r\n\n r.status_code = 404\n self.assertRaises(exceptions.HTTPNotFound, f.user_... | [
"0.68724155",
"0.6683057",
"0.6637301",
"0.6578398",
"0.6559852",
"0.6474468",
"0.6464813",
"0.6425861",
"0.638332",
"0.63573205",
"0.6336519",
"0.6328632",
"0.63244635",
"0.62987155",
"0.6267484",
"0.62195075",
"0.61980534",
"0.6191649",
"0.61694646",
"0.614538",
"0.61373806... | 0.73752326 | 0 |
Return a 500 error when someone tries to call the URL. | def callback(request, uri, headers): # lint-amnesty, pylint: disable=unused-argument
headers['CorrelationId'] = 'aefd38b7-c92c-445a-8c7a-487a3f0c7a9d'
headers['RequestNo'] = '[787177]' # This is the format SAPSF returns for the transaction request number
return 500, headers, 'Failure!' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def internal_error():\n return HttpError(500)",
"def view_500(request, url = None):\n res = render_to_response(\"500.html\", context_instance=RequestContext(request))\n res.status_code = 500\n return res",
"def server_error(e):\n return 'Error while serving request', 500",
"def internal_server... | [
"0.7490835",
"0.74022293",
"0.70942414",
"0.70713156",
"0.7046498",
"0.7032829",
"0.70033985",
"0.69633645",
"0.6963141",
"0.6925367",
"0.6915124",
"0.69088185",
"0.6898223",
"0.68840873",
"0.6861838",
"0.68376124",
"0.6830139",
"0.68263555",
"0.6814626",
"0.67630464",
"0.675... | 0.0 | -1 |
Configure the provider such that it doesn't have enough details to contact the SAP SuccessFactors API, and test that it falls back to the data it receives from the SAML assertion. | def test_register_insufficient_sapsf_metadata(self):
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings='{"key_i_dont_need":"value_i_also_dont_need"}',
)
# Because we're getting details from the assertion, fall back to the initial set of details.
self.USER_EMAIL = "myself@testshib.org"
self.USER_NAME = "Me Myself And I"
self.USER_USERNAME = "myself"
self._test_register() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _configure_testshib_provider(self, **kwargs):\n fetch_metadata = kwargs.pop('fetch_metadata', True)\n assert_metadata_updates = kwargs.pop('assert_metadata_updates', True)\n kwargs.setdefault('name', self.PROVIDER_NAME)\n kwargs.setdefault('enabled', True)\n kwargs.setdefault... | [
"0.697038",
"0.6617586",
"0.6555091",
"0.5951466",
"0.5813457",
"0.5800178",
"0.5706513",
"0.57041866",
"0.5636675",
"0.56051576",
"0.56023586",
"0.55914366",
"0.5573786",
"0.5566785",
"0.55414",
"0.55256534",
"0.5518977",
"0.5488716",
"0.5402298",
"0.5390696",
"0.5382451",
... | 0.6533367 | 3 |
Configure the provider such that it can talk to a mockedout version of the SAP SuccessFactors API, and ensure that the data it gets that way gets passed to the registration form. Check that value mappings overrides work in cases where we override a value other than what we're looking for, and when an empty override is provided (expected behavior is that existing value maps will be left alone). | def test_register_sapsf_metadata_present(self):
expected_country = 'AU'
provider_settings = {
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
}
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps(provider_settings)
)
self._test_register(country=expected_country) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_sapsf_metadata_present_override_other_value(self):\n value_map = {'country': {'United States': 'blahfake'}}\n expected_country = 'AU'\n provider_settings = {\n 'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',\n 'sapsf_private_key': 'fake_priva... | [
"0.7055314",
"0.6939393",
"0.66155446",
"0.63423544",
"0.576975",
"0.5697624",
"0.5679179",
"0.55829513",
"0.5382714",
"0.5345334",
"0.5325174",
"0.53106457",
"0.5242109",
"0.52059597",
"0.5203102",
"0.5186651",
"0.5169315",
"0.51328266",
"0.51315385",
"0.5126731",
"0.5115003... | 0.50434846 | 26 |
Configure the provider such that it can talk to a mockedout version of the SAP SuccessFactors API, and ensure that the data it gets that way gets passed to the registration form. Check that value mappings overrides work in cases where we override a value other than what we're looking for, and when an empty override is provided it should use the default value provided by the configuration. | def test_register_sapsf_with_value_default(self):
# Mock the call to the SAP SuccessFactors OData user endpoint
ODATA_USER_URL = (
'http://api.successfactors.com/odata/v2/User(userId=\'myself\')'
'?$select=firstName,country,lastName,defaultFullName,email'
)
def user_callback(request, _uri, headers):
auth_header = request.headers.get('Authorization')
assert auth_header == 'Bearer faketoken'
return (
200,
headers,
json.dumps({
'd': {
'username': 'jsmith',
'firstName': 'John',
'lastName': 'Smith',
'defaultFullName': 'John Smith',
'country': 'Australia'
}
})
)
httpretty.register_uri(httpretty.GET, ODATA_USER_URL, content_type='application/json', body=user_callback)
provider_settings = {
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
}
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps(provider_settings),
default_email='default@testshib.org'
)
self.USER_EMAIL = 'default@testshib.org'
self._test_register() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_sapsf_metadata_present_override_other_value(self):\n value_map = {'country': {'United States': 'blahfake'}}\n expected_country = 'AU'\n provider_settings = {\n 'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',\n 'sapsf_private_key': 'fake_priva... | [
"0.67629653",
"0.6631736",
"0.6281163",
"0.5879345",
"0.5806605",
"0.55553335",
"0.5497894",
"0.546793",
"0.54649425",
"0.54343826",
"0.5406209",
"0.5285645",
"0.5254529",
"0.52485114",
"0.5243045",
"0.523051",
"0.5200763",
"0.5126939",
"0.5116786",
"0.5110514",
"0.51018703",... | 0.63661134 | 2 |
Configure the provider such that it can talk to a mockedout version of the SAP SuccessFactors API, and ensure that the data it gets that way gets passed to the registration form. Check that value mappings overrides work in cases where we override a value other than what we're looking for, and when an empty override is provided (expected behavior is that existing value maps will be left alone). | def test_register_sapsf_metadata_present_override_relevant_value(self):
value_map = {'country': {'Australia': 'NZ'}}
expected_country = 'NZ'
provider_settings = {
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
}
if value_map:
provider_settings['sapsf_value_mappings'] = value_map
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps(provider_settings)
)
self._test_register(country=expected_country) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_sapsf_metadata_present_override_other_value(self):\n value_map = {'country': {'United States': 'blahfake'}}\n expected_country = 'AU'\n provider_settings = {\n 'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',\n 'sapsf_private_key': 'fake_priva... | [
"0.70553404",
"0.66161525",
"0.63435036",
"0.57704574",
"0.56966025",
"0.5679671",
"0.55836266",
"0.53828114",
"0.53427476",
"0.5324517",
"0.53106654",
"0.52406067",
"0.52070177",
"0.5202646",
"0.5187437",
"0.51687354",
"0.51323",
"0.5131696",
"0.5125414",
"0.51162493",
"0.50... | 0.69396245 | 1 |
Configure the provider such that it can talk to a mockedout version of the SAP SuccessFactors API, and ensure that the data it gets that way gets passed to the registration form. Check that value mappings overrides work in cases where we override a value other than what we're looking for, and when an empty override is provided (expected behavior is that existing value maps will be left alone). | def test_register_sapsf_metadata_present_override_other_value(self):
value_map = {'country': {'United States': 'blahfake'}}
expected_country = 'AU'
provider_settings = {
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
}
if value_map:
provider_settings['sapsf_value_mappings'] = value_map
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps(provider_settings)
)
self._test_register(country=expected_country) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_sapsf_metadata_present_override_relevant_value(self):\n value_map = {'country': {'Australia': 'NZ'}}\n expected_country = 'NZ'\n provider_settings = {\n 'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',\n 'sapsf_private_key': 'fake_private_key_... | [
"0.6940789",
"0.6617741",
"0.6345586",
"0.57743275",
"0.5698771",
"0.56804734",
"0.55835336",
"0.5381514",
"0.5341755",
"0.5321272",
"0.5309637",
"0.5242255",
"0.5205009",
"0.5200889",
"0.5184601",
"0.51705694",
"0.51325846",
"0.5132514",
"0.5125601",
"0.51126003",
"0.5099695... | 0.70560694 | 0 |
Configure the provider such that it can talk to a mockedout version of the SAP SuccessFactors API, and ensure that the data it gets that way gets passed to the registration form. Check that value mappings overrides work in cases where we override a value other than what we're looking for, and when an empty override is provided (expected behavior is that existing value maps will be left alone). | def test_register_sapsf_metadata_present_empty_value_override(self):
value_map = {'country': {}}
expected_country = 'AU'
provider_settings = {
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
}
if value_map:
provider_settings['sapsf_value_mappings'] = value_map
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps(provider_settings)
)
self._test_register(country=expected_country) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_register_sapsf_metadata_present_override_other_value(self):\n value_map = {'country': {'United States': 'blahfake'}}\n expected_country = 'AU'\n provider_settings = {\n 'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',\n 'sapsf_private_key': 'fake_priva... | [
"0.7055314",
"0.6939393",
"0.63423544",
"0.576975",
"0.5697624",
"0.5679179",
"0.55829513",
"0.5382714",
"0.5345334",
"0.5325174",
"0.53106457",
"0.5242109",
"0.52059597",
"0.5203102",
"0.5186651",
"0.5169315",
"0.51328266",
"0.51315385",
"0.5126731",
"0.5115003",
"0.50994205... | 0.66155446 | 2 |
Ensure that if there's an HTTP failure while fetching metadata, we continue, using the metadata from the SAML assertion. | def test_register_http_failure(self):
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps({
'sapsf_oauth_root_url': 'http://successfactors.com/oauth-fake/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': 'http://api.successfactors.com/odata/v2/',
'odata_company_id': 'NCC1701D',
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
})
)
# Because we're getting details from the assertion, fall back to the initial set of details.
self.USER_EMAIL = "myself@testshib.org"
self.USER_NAME = "Me Myself And I"
self.USER_USERNAME = "myself"
self._test_register() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_metadata_saml_not_authorized():\n\n responses.add(\n responses.GET,\n f\"{SERVICE_URL}/$metadata\",\n content_type='text/html; charset=utf-8',\n status=200)\n\n with pytest.raises(HttpError) as e_info:\n pyodata.Client(SERVICE_URL, requests)\n\n assert str(e_inf... | [
"0.6340328",
"0.6015547",
"0.5980344",
"0.58028024",
"0.57724714",
"0.5630444",
"0.5626857",
"0.55482787",
"0.5516507",
"0.5385363",
"0.5247033",
"0.51967573",
"0.5134511",
"0.51058185",
"0.50990194",
"0.5066909",
"0.5056259",
"0.5038707",
"0.5012003",
"0.49886125",
"0.496665... | 0.0 | -1 |
Ensure that if there's an HTTP failure while fetching user details from SAP SuccessFactors OData API. | def test_register_http_failure_in_odata(self):
# Because we're getting details from the assertion, fall back to the initial set of details.
self.USER_EMAIL = "myself@testshib.org"
self.USER_NAME = "Me Myself And I"
self.USER_USERNAME = "myself"
odata_company_id = 'NCC1701D'
odata_api_root_url = 'http://api.successfactors.com/odata/v2/'
mocked_odata_api_url = self._mock_odata_api_for_error(odata_api_root_url, self.USER_USERNAME)
self._configure_testshib_provider(
identity_provider_type='sap_success_factors',
metadata_source=TESTSHIB_METADATA_URL,
other_settings=json.dumps({
'sapsf_oauth_root_url': 'http://successfactors.com/oauth/',
'sapsf_private_key': 'fake_private_key_here',
'odata_api_root_url': odata_api_root_url,
'odata_company_id': odata_company_id,
'odata_client_id': 'TatVotSEiCMteSNWtSOnLanCtBGwNhGB',
})
)
with LogCapture(level=logging.WARNING) as log_capture:
self._test_register()
logging_messages = str([log_msg.getMessage() for log_msg in log_capture.records]).replace('\\', '')
assert odata_company_id in logging_messages
assert mocked_odata_api_url in logging_messages
assert self.USER_USERNAME in logging_messages
assert 'SAPSuccessFactors' in logging_messages
assert 'Error message' in logging_messages
assert 'System message' in logging_messages
assert 'Headers' in logging_messages | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mock_odata_api_for_error(self, odata_api_root_url, username):\n\n def callback(request, uri, headers): # lint-amnesty, pylint: disable=unused-argument\n \"\"\"\n Return a 500 error when someone tries to call the URL.\n \"\"\"\n headers['CorrelationId'] = 'ae... | [
"0.6441003",
"0.60609096",
"0.6001092",
"0.5984341",
"0.5984341",
"0.59653944",
"0.5955787",
"0.5928276",
"0.59214807",
"0.59023386",
"0.5876574",
"0.5876278",
"0.58514905",
"0.58513963",
"0.5837443",
"0.583195",
"0.5824492",
"0.5800869",
"0.57902473",
"0.577529",
"0.5762384"... | 0.58489734 | 14 |
Method handling all item specific processing. Returns dictionary containing scraped report. | def process_item(self, item, spider):
# Memory has extra postfix letters and they need to be remove
# and then converted into actual integer
numeric = RE_MATCH.match(item['Memory']).group(0)
item['Memory'] = int(numeric)
# The same case as above but here the value is a float
numeric = RE_MATCH.match(item['Base Frequency']).group(0)
item['Base Frequency'] = float(numeric)
"""
Some folks identify MB as number making it 'int' in the spider causing
Pandas to get crazy so the value is explicity marked as 'str'.
Also sometimes motherboard information is missing but as it is not
necessarily making the data obsolete, the result is still stored.
"""
item['Motherboard'] = str(item['Motherboard']) if 'Motherboard' in item else ''
# In order to keep potential string processing simples, they are all
# converted into lowercase strings.
for key in item:
if type(item[key]) is str:
item[key] = item[key].lower()
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processItem(self):\r\n self.extract()\r\n self.mergeLanguageClaims()\r\n self.validateClaims()\r\n self.mergeWithWikidata()\r\n self.writeToWikidata()\r\n self.log()",
"def _parse_item(self, item):\n result = {}\n for f in self._invoice_report_item_fiel... | [
"0.6547524",
"0.6395213",
"0.619723",
"0.6070499",
"0.6036251",
"0.6004193",
"0.59119064",
"0.58983403",
"0.58883923",
"0.5818666",
"0.5750651",
"0.5722851",
"0.5683043",
"0.5669266",
"0.56607234",
"0.5656393",
"0.56268835",
"0.5572283",
"0.5531241",
"0.551983",
"0.5516696",
... | 0.5546761 | 18 |
Given inputs, take move and return outputs. | def move(self, env2):
output = dict()
if self.state == 0:
if (env2 == 0):
self.state = 0
output["loc"] = 16
output["stage"] = 1
elif (env2 == 1):
self.state = 33
output["loc"] = 17
output["stage"] = 1
elif (env2 == 2):
self.state = 34
output["loc"] = 17
output["stage"] = 1
else:
self._error(env2)
elif self.state == 1:
if (env2 == 0):
self.state = 0
output["loc"] = 16
output["stage"] = 1
elif (env2 == 1):
self.state = 33
output["loc"] = 17
output["stage"] = 1
elif (env2 == 2):
self.state = 34
output["loc"] = 17
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 2:
if (env2 == 0):
self.state = 0
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 34
output["loc"] = 17
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 1):
self.state = 33
output["loc"] = 17
output["stage"] = 1
else:
self._error(env2)
elif self.state == 3:
if (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 2
output["loc"] = 16
output["stage"] = 1
elif (env2 == 1):
self.state = 1
output["loc"] = 16
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 4:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 2
output["loc"] = 16
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 5:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 5
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 6:
if (env2 == 0):
self.state = 8
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 18
output["loc"] = 21
output["stage"] = 1
elif (env2 == 2):
self.state = 19
output["loc"] = 21
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 7:
if (env2 == 0):
self.state = 8
output["loc"] = 20
output["stage"] = 1
elif (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 18
output["loc"] = 21
output["stage"] = 1
elif (env2 == 2):
self.state = 19
output["loc"] = 21
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 8:
if (env2 == 0):
self.state = 8
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 18
output["loc"] = 21
output["stage"] = 1
elif (env2 == 2):
self.state = 19
output["loc"] = 21
output["stage"] = 1
else:
self._error(env2)
elif self.state == 9:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 7):
self.state = 20
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 10:
if (env2 == 7):
self.state = 10
output["loc"] = 20
output["stage"] = 2
elif (env2 == 6):
self.state = 11
output["loc"] = 20
output["stage"] = 2
elif (env2 == 5):
self.state = 12
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 11:
if (env2 == 7):
self.state = 10
output["loc"] = 20
output["stage"] = 2
elif (env2 == 6):
self.state = 11
output["loc"] = 20
output["stage"] = 2
elif (env2 == 5):
self.state = 12
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 12:
if (env2 == 7):
self.state = 10
output["loc"] = 20
output["stage"] = 2
elif (env2 == 6):
self.state = 11
output["loc"] = 20
output["stage"] = 2
elif (env2 == 5):
self.state = 12
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 13:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 6):
self.state = 11
output["loc"] = 20
output["stage"] = 2
elif (env2 == 5):
self.state = 12
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 14:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 5):
self.state = 12
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 15:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 0):
self.state = 17
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 16:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 0):
self.state = 17
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 17:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 0):
self.state = 17
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 18:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 0):
self.state = 17
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 19:
if (env2 == 2):
self.state = 16
output["loc"] = 20
output["stage"] = 2
elif (env2 == 0):
self.state = 17
output["loc"] = 20
output["stage"] = 2
elif (env2 == 4):
self.state = 13
output["loc"] = 20
output["stage"] = 2
elif (env2 == 3):
self.state = 14
output["loc"] = 20
output["stage"] = 2
elif (env2 == 1):
self.state = 15
output["loc"] = 20
output["stage"] = 2
else:
self._error(env2)
elif self.state == 20:
if (env2 == 7):
self.state = 20
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 21:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 18
output["loc"] = 21
output["stage"] = 1
elif (env2 == 2):
self.state = 19
output["loc"] = 21
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 22:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 7):
self.state = 20
output["loc"] = 20
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 23:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 7):
self.state = 20
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 24:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 2):
self.state = 19
output["loc"] = 21
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 25:
if (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 7):
self.state = 20
output["loc"] = 20
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 5):
self.state = 22
output["loc"] = 20
output["stage"] = 1
elif (env2 == 6):
self.state = 23
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 26:
if (env2 == 6):
self.state = 9
output["loc"] = 19
output["stage"] = 1
elif (env2 == 4):
self.state = 26
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 27
output["loc"] = 18
output["stage"] = 1
elif (env2 == 2):
self.state = 29
output["loc"] = 19
output["stage"] = 1
elif (env2 == 5):
self.state = 25
output["loc"] = 19
output["stage"] = 1
else:
self._error(env2)
elif self.state == 27:
if (env2 == 5):
self.state = 25
output["loc"] = 19
output["stage"] = 1
elif (env2 == 4):
self.state = 26
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 27
output["loc"] = 18
output["stage"] = 1
elif (env2 == 1):
self.state = 28
output["loc"] = 19
output["stage"] = 1
elif (env2 == 2):
self.state = 29
output["loc"] = 19
output["stage"] = 1
else:
self._error(env2)
elif self.state == 28:
if (env2 == 0):
self.state = 8
output["loc"] = 20
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 6
output["loc"] = 20
output["stage"] = 1
elif (env2 == 2):
self.state = 7
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 29:
if (env2 == 0):
self.state = 8
output["loc"] = 20
output["stage"] = 1
elif (env2 == 4):
self.state = 24
output["loc"] = 20
output["stage"] = 1
elif (env2 == 3):
self.state = 21
output["loc"] = 20
output["stage"] = 1
elif (env2 == 1):
self.state = 6
output["loc"] = 20
output["stage"] = 1
elif (env2 == 2):
self.state = 7
output["loc"] = 20
output["stage"] = 1
else:
self._error(env2)
elif self.state == 30:
if (env2 == 0):
self.state = 32
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 27
output["loc"] = 18
output["stage"] = 1
elif (env2 == 1):
self.state = 28
output["loc"] = 19
output["stage"] = 1
elif (env2 == 2):
self.state = 29
output["loc"] = 19
output["stage"] = 1
else:
self._error(env2)
elif self.state == 31:
if (env2 == 0):
self.state = 32
output["loc"] = 18
output["stage"] = 1
elif (env2 == 4):
self.state = 26
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 27
output["loc"] = 18
output["stage"] = 1
elif (env2 == 1):
self.state = 28
output["loc"] = 19
output["stage"] = 1
elif (env2 == 2):
self.state = 29
output["loc"] = 19
output["stage"] = 1
else:
self._error(env2)
elif self.state == 32:
if (env2 == 0):
self.state = 32
output["loc"] = 18
output["stage"] = 1
elif (env2 == 1):
self.state = 28
output["loc"] = 19
output["stage"] = 1
elif (env2 == 2):
self.state = 29
output["loc"] = 19
output["stage"] = 1
else:
self._error(env2)
elif self.state == 33:
if (env2 == 0):
self.state = 32
output["loc"] = 18
output["stage"] = 1
elif (env2 == 1):
self.state = 30
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 31
output["loc"] = 18
output["stage"] = 1
else:
self._error(env2)
elif self.state == 34:
if (env2 == 0):
self.state = 32
output["loc"] = 18
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 1):
self.state = 30
output["loc"] = 18
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 31
output["loc"] = 18
output["stage"] = 1
else:
self._error(env2)
elif self.state == 35:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 37
output["loc"] = 0
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 36:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 37
output["loc"] = 0
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 37:
if (env2 == 5):
self.state = 35
output["loc"] = 8
output["stage"] = 1
elif (env2 == 6):
self.state = 36
output["loc"] = 8
output["stage"] = 1
elif (env2 == 7):
self.state = 37
output["loc"] = 0
output["stage"] = 1
else:
self._error(env2)
elif self.state == 38:
if (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 34
output["loc"] = 17
output["stage"] = 1
elif (env2 == 1):
self.state = 33
output["loc"] = 17
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 39:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 5
output["loc"] = 16
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 40:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 5
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 41:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 2):
self.state = 34
output["loc"] = 17
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 42:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 37
output["loc"] = 0
output["stage"] = 1
elif (env2 == 3):
self.state = 38
output["loc"] = 16
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 43:
if (env2 == 6):
self.state = 40
output["loc"] = 16
output["stage"] = 1
elif (env2 == 4):
self.state = 41
output["loc"] = 16
output["stage"] = 1
elif (env2 == 7):
self.state = 37
output["loc"] = 0
output["stage"] = 1
elif (env2 == 5):
self.state = 39
output["loc"] = 16
output["stage"] = 1
else:
self._error(env2)
elif self.state == 44:
if (env2 == 1):
self.state = 48
output["loc"] = 0
output["stage"] = 0
elif (env2 == 0):
self.state = 44
output["loc"] = 0
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 45:
if (env2 == 6):
self.state = 43
output["loc"] = 8
output["stage"] = 0
elif (env2 == 5):
self.state = 42
output["loc"] = 8
output["stage"] = 0
elif (env2 == 3):
self.state = 3
output["loc"] = 8
output["stage"] = 0
elif (env2 == 4):
self.state = 4
output["loc"] = 8
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 46:
if (env2 == 1):
self.state = 48
output["loc"] = 0
output["stage"] = 0
elif (env2 == 0):
self.state = 44
output["loc"] = 0
output["stage"] = 0
elif (env2 == 3):
self.state = 3
output["loc"] = 8
output["stage"] = 0
elif (env2 == 4):
self.state = 4
output["loc"] = 8
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 47:
if (env2 == 6):
self.state = 43
output["loc"] = 8
output["stage"] = 0
elif (env2 == 5):
self.state = 42
output["loc"] = 8
output["stage"] = 0
elif (env2 == 7):
self.state = 51
output["loc"] = 0
output["stage"] = 0
elif (env2 == 4):
self.state = 4
output["loc"] = 8
output["stage"] = 0
else:
self._error(env2)
elif self.state == 48:
if (env2 == 1):
self.state = 48
output["loc"] = 0
output["stage"] = 0
elif (env2 == 3):
self.state = 3
output["loc"] = 8
output["stage"] = 0
elif (env2 == 0):
self.state = 44
output["loc"] = 0
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 49:
if (env2 == 7):
self.state = 51
output["loc"] = 0
output["stage"] = 0
elif (env2 == 5):
self.state = 42
output["loc"] = 8
output["stage"] = 0
elif (env2 == 3):
self.state = 3
output["loc"] = 8
output["stage"] = 0
elif (env2 == 4):
self.state = 4
output["loc"] = 8
output["stage"] = 0
elif (env2 == 6):
self.state = 43
output["loc"] = 8
output["stage"] = 0
else:
self._error(env2)
elif self.state == 50:
if (env2 == 1):
self.state = 48
output["loc"] = 0
output["stage"] = 0
elif (env2 == 5):
self.state = 42
output["loc"] = 8
output["stage"] = 0
elif (env2 == 3):
self.state = 3
output["loc"] = 8
output["stage"] = 0
elif (env2 == 4):
self.state = 4
output["loc"] = 8
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 51:
if (env2 == 6):
self.state = 43
output["loc"] = 8
output["stage"] = 0
elif (env2 == 5):
self.state = 42
output["loc"] = 8
output["stage"] = 0
elif (env2 == 7):
self.state = 51
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
elif self.state == 52:
if (env2 == 0):
self.state = 44
output["loc"] = 0
output["stage"] = 0
elif (env2 == 4):
self.state = 45
output["loc"] = 0
output["stage"] = 0
elif (env2 == 2):
self.state = 46
output["loc"] = 0
output["stage"] = 0
elif (env2 == 6):
self.state = 47
output["loc"] = 0
output["stage"] = 0
elif (env2 == 1):
self.state = 48
output["loc"] = 0
output["stage"] = 0
elif (env2 == 5):
self.state = 49
output["loc"] = 0
output["stage"] = 0
elif (env2 == 3):
self.state = 50
output["loc"] = 0
output["stage"] = 0
elif (env2 == 7):
self.state = 51
output["loc"] = 0
output["stage"] = 0
else:
self._error(env2)
else:
raise Exception("Unrecognized internal state: " + str(self.state))
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transduce(self,inputs):\n self.start()\n return [self.step(inp) for inp in inputs]",
"def api_make_move(self, move_input):\n return self.board.attempt_move(move_input)",
"def move(self, *args, **kw):\n return self.execute_action('move', *args, **kw)",
"def move(self, output_fi... | [
"0.62765896",
"0.5847411",
"0.58237934",
"0.5772807",
"0.5766127",
"0.56973183",
"0.56731117",
"0.5606184",
"0.54958546",
"0.5494064",
"0.546905",
"0.5464436",
"0.54533064",
"0.5435174",
"0.54249644",
"0.54240054",
"0.5407606",
"0.5406141",
"0.5403741",
"0.5398427",
"0.538479... | 0.0 | -1 |
Create source links to github | def linkcode_resolve(domain, info):
if domain != 'py' or not info['module']:
return None
filename = info['module'].replace('.', '/')
return "https://github.com/mathcamp/flywheel/blob/%s/%s.py" % (version_data['ref'], filename) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repo_link(repo):\n return \"https://github.com/\" + repo",
"def create_link(repository, project_name):\n beginning_url = \"https://api.github.com/repos/\"\n separator_url = \"/\"\n end_url = \"/commits\"\n\n base_url = beginning_url+repository+separator_url+project_name+end_url\n return bas... | [
"0.6921794",
"0.68528706",
"0.6557395",
"0.6166538",
"0.6133582",
"0.6098029",
"0.6074224",
"0.6037421",
"0.6030705",
"0.6019107",
"0.59831655",
"0.596135",
"0.59046274",
"0.58846396",
"0.58756024",
"0.58383036",
"0.5835905",
"0.5808838",
"0.5806285",
"0.579724",
"0.5761678",... | 0.5238986 | 86 |
Accept the path to the text files with lake ice fraction timeseries | def get_ts_from_file(path="", start_year=-np.Inf, end_year=np.Inf) -> pd.DataFrame:
df = pd.DataFrame.from_csv(path, sep="\s+")
cnames = df.columns[:]
for c in cnames:
y = int(c)
if y < start_year or y > end_year:
df.drop(c, axis=1, inplace=True)
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_local_20Hz_files(**kwargs):\n pathlst = kwargs.get('pathlst')\n product = kwargs.get('product')\n varalias = kwargs.get('varalias')\n sdate = kwargs.get('sdate')\n edate = kwargs.get('edate')\n twin = kwargs.get('twin')\n\n # establish coords if defined in config file\n timestr = s... | [
"0.5803808",
"0.57068276",
"0.56613946",
"0.5642458",
"0.562522",
"0.55623674",
"0.55397063",
"0.5512734",
"0.5485281",
"0.5476176",
"0.5475341",
"0.54747045",
"0.54190755",
"0.54162836",
"0.53791934",
"0.5370917",
"0.5362841",
"0.535579",
"0.5337363",
"0.5330271",
"0.5322317... | 0.0 | -1 |
Test case for get_chain_by_id | def test_get_chain_by_id(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_chains(self):\n pass",
"def get_chain(self, chain_id):\n if self.chain_dict.has_key(chain_id):\n return self.chain_dict[chain_id]\n return None",
"def test_solareclipses_id_get(self):\n pass",
"def sample_chains():\n c = chain(add.s(1, 1), add.s(1), add.... | [
"0.66562283",
"0.6344267",
"0.60350573",
"0.6012869",
"0.5983662",
"0.5644152",
"0.5638522",
"0.56080955",
"0.55986637",
"0.5579138",
"0.54949653",
"0.5461469",
"0.54595417",
"0.5459411",
"0.5446837",
"0.5446837",
"0.54265",
"0.53988206",
"0.5392831",
"0.5390298",
"0.5332432"... | 0.93600637 | 0 |
Test case for get_chains | def test_get_chains(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_chain_by_id(self):\n pass",
"def get_chains (structure):\n chains=[]\n for chain in structure[0]:\n chains.append(chain)\n return chains",
"def iter_chains(self):\n if self.default_model:\n return iter(self.default_model.chain_list)\n return iter(lis... | [
"0.6914287",
"0.67781395",
"0.6644035",
"0.6538033",
"0.652312",
"0.6489876",
"0.64195883",
"0.63450104",
"0.62671566",
"0.61932814",
"0.60854757",
"0.6066701",
"0.605091",
"0.6029899",
"0.6004666",
"0.60018355",
"0.5970353",
"0.59533113",
"0.5910838",
"0.5885802",
"0.5868115... | 0.94273794 | 0 |
Test case for post_chain | def test_post_chain(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_post_chain_search(self):\n pass",
"def test_rewrite_chains_cover(self):\n cb = Mock()\n self.ipt.rewrite_chains(\n {\"foo\": [\"--append foo --jump bar\"]},\n {\"foo\": set([\"bar\"])},\n async=True,\n callback=cb,\n )\n self... | [
"0.72168523",
"0.65788776",
"0.6171648",
"0.6129438",
"0.61099774",
"0.61021096",
"0.60098636",
"0.5998518",
"0.59712416",
"0.5869386",
"0.58414704",
"0.5824033",
"0.5820647",
"0.5788468",
"0.5751005",
"0.5730567",
"0.57289803",
"0.57287365",
"0.5715039",
"0.5704063",
"0.5691... | 0.9139945 | 0 |
Test case for post_chain_search | def test_post_chain_search(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_post_chain(self):\n pass",
"def test_post_foods_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search_systems_post(self):\n pass",
"def test_search_organizations_post(... | [
"0.7415727",
"0.6913196",
"0.66014063",
"0.66014063",
"0.66014063",
"0.65811795",
"0.6300726",
"0.615566",
"0.5992487",
"0.5984323",
"0.59211963",
"0.58675545",
"0.58613753",
"0.58335793",
"0.58033735",
"0.5775473",
"0.57752",
"0.5766603",
"0.57302696",
"0.57134694",
"0.56959... | 0.9217483 | 0 |
Build a networkx graph object from variables and relations. | def as_networkx_graph(variables, relations):
graph = nx.Graph()
# One node for each variables
graph.add_nodes_from([v.name for v in variables])
for r in relations:
for p in all_pairs([e.name for e in r.dimensions]):
graph.add_edge(*p)
return graph | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_networkx_bipartite_graph(variables, relations):\n graph = nx.Graph()\n\n # One node for each variables\n graph.add_nodes_from([v.name for v in variables], bipartite=0)\n graph.add_nodes_from([r.name for r in relations], bipartite=1)\n\n for r in relations:\n for e in r.dimensions:\n ... | [
"0.73159355",
"0.67514896",
"0.6639457",
"0.663262",
"0.6631219",
"0.6617338",
"0.65870404",
"0.6585843",
"0.65561634",
"0.64985657",
"0.64818686",
"0.64802456",
"0.64401877",
"0.64243275",
"0.64049304",
"0.6382079",
"0.63409054",
"0.6319503",
"0.6298616",
"0.6286521",
"0.627... | 0.81062376 | 0 |
Build a networkx graph object from variables and relations. | def as_networkx_bipartite_graph(variables, relations):
graph = nx.Graph()
# One node for each variables
graph.add_nodes_from([v.name for v in variables], bipartite=0)
graph.add_nodes_from([r.name for r in relations], bipartite=1)
for r in relations:
for e in r.dimensions:
graph.add_edge(r.name, e.name)
return graph | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_networkx_graph(variables, relations):\n graph = nx.Graph()\n\n # One node for each variables\n graph.add_nodes_from([v.name for v in variables])\n\n for r in relations:\n for p in all_pairs([e.name for e in r.dimensions]):\n graph.add_edge(*p)\n return graph",
"def initial... | [
"0.81066954",
"0.6750233",
"0.6639164",
"0.66322136",
"0.6630946",
"0.6617218",
"0.6586329",
"0.65858966",
"0.65559703",
"0.6498455",
"0.64820826",
"0.6480336",
"0.6440278",
"0.64248806",
"0.6404701",
"0.6381441",
"0.63398075",
"0.6318121",
"0.62991834",
"0.6286606",
"0.62709... | 0.73165965 | 1 |
Display the variables and relation as a graph, using networkx and matplotlib. | def display_graph(variables, relations):
graph = as_networkx_graph(variables, relations)
# Do not crash if matplotlib is not installed
try:
import matplotlib.pyplot as plt
nx.draw_networkx(graph, with_labels=True)
# nx.draw_random(graph)
# nx.draw_circular(graph)
# nx.draw_spectral(graph)
plt.show()
except ImportError:
print("ERROR: cannot display graph, matplotlib is not installed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_dependency_graph(self):\n if self.graph is None:\n self.logger.error(\"Graph value none cannot be plotted\")\n return\n\n nx.draw(self.graph, cmap=plt.get_cmap('jet'), with_labels=True)\n plt.show()",
"def plot_graph(self) -> None:",
"def display_biparti... | [
"0.75382435",
"0.7278241",
"0.7211741",
"0.71995574",
"0.70474607",
"0.69660336",
"0.6962253",
"0.68822443",
"0.6876223",
"0.68665344",
"0.685607",
"0.6749594",
"0.67388505",
"0.67268574",
"0.6711935",
"0.6700764",
"0.6693562",
"0.6683998",
"0.6630944",
"0.6603868",
"0.655565... | 0.8590499 | 0 |
Display the variables and relation as a graph, using networkx and matplotlib. | def display_bipartite_graph(variables, relations):
graph = as_networkx_bipartite_graph(variables, relations)
# Do not crash if matplotlib is not installed
try:
import matplotlib.pyplot as plt
pos = nx.drawing.spring_layout(graph)
variables = set(n for n, d in graph.nodes(data=True) if d["bipartite"] == 0)
factors = set(graph) - variables
nx.draw_networkx_nodes(
graph,
pos=pos,
with_labels=True,
nodelist=variables,
node_shape="o",
node_color="b",
label="variables",
alpha=0.5,
)
nx.draw_networkx_nodes(
graph,
pos=pos,
with_labels=True,
nodelist=factors,
node_shape="s",
node_color="r",
label="factors",
alpha=0.5,
)
nx.draw_networkx_labels(graph, pos=pos)
nx.draw_networkx_edges(graph, pos=pos)
# nx.draw_random(graph)
# nx.draw_circular(graph)
# nx.draw_spectral(graph)
plt.show()
except ImportError:
print("ERROR: cannot display graph, matplotlib is not installed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_graph(variables, relations):\n graph = as_networkx_graph(variables, relations)\n\n # Do not crash if matplotlib is not installed\n try:\n import matplotlib.pyplot as plt\n\n nx.draw_networkx(graph, with_labels=True)\n # nx.draw_random(graph)\n # nx.draw_circular(gra... | [
"0.8590499",
"0.75382435",
"0.7278241",
"0.71995574",
"0.70474607",
"0.69660336",
"0.6962253",
"0.68822443",
"0.6876223",
"0.68665344",
"0.685607",
"0.6749594",
"0.67388505",
"0.67268574",
"0.6711935",
"0.6700764",
"0.6693562",
"0.6683998",
"0.6630944",
"0.6603868",
"0.655565... | 0.7211741 | 3 |
Compute the graph diameter(s). If the graph contains several independent sub graph, returns a list the diamater of each of the subgraphs. | def graph_diameter(variables, relations):
diams = []
g = as_networkx_graph(variables, relations)
components = (g.subgraph(c).copy() for c in nx.connected_components(g))
for c in components:
diams.append(nx.diameter(c))
return diams | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def diameter(self):\n\n v = self.vertices()\n pairs = [ (v[i],v[j]) for i in range(len(v)-1) for j in range(i+1, len(v))]\n smallest_paths = []\n for (s,e) in pairs:\n paths = self.find_all_path(s,e)\n smallest = sorted(paths, key=len)[0]\n smallest_path... | [
"0.700528",
"0.64061725",
"0.6378661",
"0.6351375",
"0.6088722",
"0.5843668",
"0.5843668",
"0.5829243",
"0.57851386",
"0.56062824",
"0.55966824",
"0.55673695",
"0.55673695",
"0.55229545",
"0.5520967",
"0.5497087",
"0.54773235",
"0.54561347",
"0.5399723",
"0.5395755",
"0.53897... | 0.7837539 | 0 |
Generate all possible pairs from the list of given elements. | def all_pairs(elements):
if len(elements) < 2:
return []
elif len(elements) == 2:
return [(elements[0], elements[1])]
else:
new_pairs = []
for elt in elements[1:]:
new_pairs.append((elements[0], elt))
return all_pairs(elements[1:]) + new_pairs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pairs(lst):\r\n\tfor i in range(1, len(lst), 2):\r\n\t\tyield lst[i-1], lst[i]",
"def all_pairs(items, sort=False):\n if sort:\n items = sorted(items)\n for i, ni in enumerate(items):\n for j, nj in enumerate(items):\n if j > i: yield ni, nj",
"def __unordered_pairs(l):\n\n ... | [
"0.7500274",
"0.6851043",
"0.6840614",
"0.68141717",
"0.6754132",
"0.669949",
"0.6683781",
"0.6671177",
"0.6668704",
"0.65523124",
"0.64457446",
"0.64399433",
"0.6394851",
"0.636628",
"0.6352524",
"0.6351291",
"0.6324047",
"0.6315178",
"0.6308765",
"0.63008136",
"0.62359875",... | 0.8119166 | 0 |
Takes an optimisation step by calculating gradients given the loss and then updating the parameters. | def take_optimisation_step(
self, optimizer, network, loss, clipping_norm=None, retain_graph=False
):
if not isinstance(network, list): network = [network]
# reset gradients to 0
optimizer.zero_grad()
# this calculates the gradients
loss.backward(retain_graph=retain_graph)
if clipping_norm is not None:
for net in network:
# clip gradients to help stabilise training
nn.utils.clip_grad_norm_(net.parameters(), clipping_norm)
# this applies the gradients
optimizer.step() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_parameters(self, loss):\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()",
"def update_params(self, loss, step_size=0.5, first_order=False):\n #grads = torch.autograd.grad(loss, self.parameters(),\n # create_graph=not first_order)\n s... | [
"0.7796381",
"0.7476913",
"0.7210945",
"0.71824896",
"0.7161772",
"0.7142518",
"0.7097461",
"0.7039974",
"0.7000394",
"0.6955703",
"0.69353473",
"0.6932707",
"0.6929035",
"0.6923562",
"0.68890387",
"0.68879765",
"0.68699014",
"0.6863703",
"0.6860742",
"0.68581945",
"0.684478"... | 0.0 | -1 |
Returns an encoded sequence from contents in msg | def encode(msg):
#Corner cases:
if msg == '':
return '' # the empty string yields an empty string
if not isinstance(msg, str):
return '' # What to do on non-strings (isinstance also allows for subclasses)
if msg == None:
return '' # If None (void) is passed in
res = [] # Store RLE results in dict
old = msg[0] # Begin with the first char in the message
i = 0
for c in msg:
if c == old:
# Another observation of the same char, increase run length by 1
i += 1
else:
# A different char
# Store results up to now
res.append(f'{i}{old}')
# Prepare for next round
old = c
i = 1
res.append(f'{i}{old}')
# Return the concatenation of all observed run lengths
return ''.join(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode(rosMsg): #@NoSelf",
"def encode(self, seq):",
"def _to_cpp(self, msg):\n buf = BytesIO()\n msg.serialize(buf)\n value = buf.getvalue()\n return value",
"def chunkify(msg):\n return [\"%s %s\" % (i, msg[i*158 : (i+1)*158]) for i in range(len(msg)/158 + 1)]",
"def en... | [
"0.6726",
"0.64823467",
"0.6431121",
"0.6076899",
"0.60573506",
"0.6021212",
"0.6009153",
"0.59417653",
"0.5894444",
"0.58700716",
"0.5841319",
"0.5840961",
"0.5782641",
"0.5758987",
"0.572157",
"0.57201093",
"0.5666906",
"0.56631124",
"0.56581855",
"0.5646804",
"0.56445134",... | 0.5922205 | 8 |
Decodes a Runlength encoded sequence such as '2k3b' into 'kkbbb' | def decode(seq):
# Handle some corner cases
if (not seq) or (not isinstance(seq, str)):
return '' # Return empty string on non-strings and all non-true values (empty string, None, 0, ...)
# Use regex to match patterns, t is then a list of tuples (if any patterns found)
# '2k3b' -> [('2','k'), ('3','b')] ...notice that integers are still string-formatted
t = re.findall(r'(\d)(\D)', seq)
# Return if empty
if not t:
return ''
# Use a list comprehension to work on the tuples... Convert integers to int
# [('2','k'), ('3','b')] -> ['k'*2 , 'b'*3] -> ['kk', 'bbb']
msg = [c*int(i) for i,c in t]
# Concatenate without separators, msg is now a string
msg = ''.join(msg)
return msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode(k, key_length):\n key = k[:key_length]\n val_length, ber_length = decode_ber(k[key_length:])\n value = k[key_length + ber_length : key_length + ber_length + val_length]\n return key, value",
"def decode(b):\n\n if b.startswith(\"0z\"):\n b = b[2:]\n\n l, i, v = len(b), 0, 0\n ... | [
"0.69079274",
"0.67722535",
"0.6671197",
"0.6628837",
"0.6628837",
"0.6597548",
"0.6395014",
"0.6347437",
"0.63195705",
"0.62489367",
"0.6163923",
"0.6139675",
"0.6125669",
"0.609444",
"0.6063985",
"0.6007184",
"0.59968084",
"0.59952885",
"0.59780675",
"0.5940352",
"0.5912996... | 0.63877225 | 7 |
type + sequence_number + key_size + key + value_size + value 1bit 63bit 32bit varlength 32bit varlength | def __init__(self, key, sequence_number, type=KeyType.PUT, value=None):
assert key is not None
assert sequence_number >= 0
self.type = type
self.sequence_number = sequence_number
self.key = key
self.value = value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_meta_chunk(key, value):\n bkey = key.encode(\"utf-8\")\n bvalue = value.encode(\"utf-8\")\n return (wozardry.to_uint32(len(bkey) + len(bvalue) + 2) + bkey + b'\\x09' + bvalue + b'\\x0A').hex()",
"def _pack_dict( self, table, pad = False ) :\r\n\r\n keys, values = zip( *table... | [
"0.5809457",
"0.5597021",
"0.55033654",
"0.5478504",
"0.5475797",
"0.5431724",
"0.54011375",
"0.53711766",
"0.535695",
"0.53174025",
"0.53174025",
"0.5285025",
"0.5257738",
"0.52197987",
"0.5217525",
"0.52163196",
"0.51897675",
"0.51784354",
"0.5164822",
"0.5161085",
"0.51330... | 0.48401326 | 43 |
serialize internal keyvalue pair to byte_array, only pickle objects when necessary | def serialize(self):
byte_array = bytearray()
header = (
self.sequence_number | (1 << 63)
if self.type == KeyType.PUT
else self.sequence_number
)
# append header first
byte_array.extend(byte_utils.integer_to_n_bytes_array(header, 8))
pickle_key = pickle.dumps(self.key)
# key length
byte_array.extend(byte_utils.integer_to_four_bytes_array(len(pickle_key)))
# key byte array
byte_array.extend(pickle_key)
# it is a put operation, value is needed
if self.type == KeyType.PUT:
pickle_value = pickle.dumps(self.value)
# value length
byte_array.extend(byte_utils.integer_to_four_bytes_array(len(pickle_value)))
# value byte array
byte_array.extend(pickle_value)
return bytes(byte_array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self, value) -> bytes:\n pass",
"def _encode_value(self, value):\n return pickle.dumps(value)",
"def serialize(obj):\n return pickle.dumps(obj)",
"def dump_object(self, value):\n return pickle.dumps(value)",
"def __bytes__(self):\n byteout = bytearray()\n f... | [
"0.64888334",
"0.6360432",
"0.6315611",
"0.6277576",
"0.6177769",
"0.6171004",
"0.6164912",
"0.6144653",
"0.6144653",
"0.61439574",
"0.6126626",
"0.6126626",
"0.60924256",
"0.60020936",
"0.59987134",
"0.59793663",
"0.5974535",
"0.59639865",
"0.5963505",
"0.5941758",
"0.593160... | 0.7145172 | 0 |
return None is parsing failed | def deserialize(file_io):
header = file_io.read(8)
if len(header) != 8:
return None
# parsing header
header = byte_utils.byte_array_to_integer(header)
type = KeyType.PUT if (header & (1 << 63)) else KeyType.DELETE
sequence_number = header & ((1 << 63) - 1)
# parsing key and value
key_size = file_io.read(4)
if len(key_size) != 4:
return None
key_size = byte_utils.byte_array_to_integer(key_size)
key_byte_array = file_io.read(key_size)
if len(key_byte_array) != key_size:
return None
if type == KeyType.PUT:
value_size = file_io.read(4)
if len(value_size) != 4:
return None
value_size = byte_utils.byte_array_to_integer(value_size)
value_byte_array = file_io.read(value_size)
if len(value_byte_array) != value_size:
return None
key, value = pickle.loads(key_byte_array), pickle.loads(value_byte_array)
return InternalKeyValue(
key=key, sequence_number=sequence_number, type=type, value=value
)
else:
key = pickle.loads(key_byte_array)
return InternalKeyValue(key=key, sequence_number=sequence_number, type=type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse(self):\n pass",
"def test_simple_parse(self):\n pass",
"def parse(self) -> None:\n pass",
"def parse(self):",
"def parse(self, text):\n node = self.match(text)\n if node is None or node.end - node.start != len(text): # TODO: Why not test just end here? Are we ... | [
"0.6728034",
"0.65789205",
"0.6491963",
"0.64315605",
"0.6299717",
"0.6294331",
"0.6294331",
"0.6294331",
"0.6294331",
"0.6265237",
"0.62311304",
"0.60790735",
"0.60173225",
"0.6007963",
"0.6007318",
"0.6002458",
"0.5985229",
"0.59831566",
"0.5947476",
"0.5941684",
"0.5936475... | 0.0 | -1 |
Import ASHRAE data from a directory containing the .csv files. | def import_data(ashrae_dir, filenames=const.NAMES):
print('Importing data from csv')
ashrae_dir = pathlib.Path(ashrae_dir)
data = {name: pd.read_csv((ashrae_dir / name).with_suffix('.csv')) for name in filenames}
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv(self, path):\n for file in os.listdir(path):\n if file[-4:] == \".csv\":\n name = file[:-4]\n table_index_header = cfg.get_list(\"table_index_header\", name)\n filename = os.path.join(path, file)\n self.input_data[name] = pd... | [
"0.64119494",
"0.62574255",
"0.6136558",
"0.60596466",
"0.6012882",
"0.5962187",
"0.5958087",
"0.5912588",
"0.58974314",
"0.5878545",
"0.58628714",
"0.5797354",
"0.57774633",
"0.577703",
"0.5762553",
"0.57592994",
"0.57388955",
"0.57192475",
"0.57123953",
"0.5707139",
"0.5690... | 0.7007926 | 0 |
Import ASHRAE data with optional caching mechanism. | def get_raw_data(ashrae_dir, cache_file=None, filenames=const.NAMES):
cache_file = pathlib.Path(cache_file)
if cache_file is not None and cache_file.exists():
data = import_dict_from_cached(cache_file, filenames)
else:
data = import_data(ashrae_dir)
_cache_data(data, cache_file)
# Sanity check: the set of building ids should be the same in the train and test sets.
assert set(data['train'].building_id) == set(data['test'].building_id)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_(self, data):\n return self.__import(data)",
"def load_data(self) -> None:",
"def load_data(data_set_key: str, a2e_data_path: str = '../../../a2e-data/data', cache_dir: str = None) -> BearingDataSet:\n\n if a2e_data_path is not None and not a2e_data_path.startswith('http') and not a2e_data... | [
"0.5765304",
"0.5686181",
"0.56845134",
"0.56063354",
"0.56054366",
"0.55914676",
"0.5575657",
"0.55459553",
"0.5527377",
"0.54661703",
"0.5434593",
"0.54312104",
"0.5410122",
"0.5381183",
"0.5379974",
"0.5346656",
"0.5326773",
"0.5326303",
"0.52563024",
"0.52543855",
"0.5239... | 0.61214995 | 0 |
Return the number of timestamps missing | def count_missing_timestamps(df):
no_of_timestamps = len(df.timestamp)
no_of_sites = len(set(df.site_id))
full_date_range = pd.date_range(start=min(df.timestamp), end=max(df.timestamp), freq='H')
no_of_missing_timestamps = no_of_sites * len(full_date_range) - no_of_timestamps
print(f'There are {no_of_timestamps} timestamps in the data. The full date range is {len(full_date_range)} long and'
f' there are {no_of_sites} sites so there should be {no_of_sites * len(full_date_range)} '
f'timestamps in the data. There are therefore {no_of_missing_timestamps} missing. ')
return no_of_missing_timestamps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_no_missing_timesteps(timesteps, verbose=True):\n timesteps = _check_timesteps(timesteps)\n # Check if there are data\n if timesteps.size == 0:\n raise ValueError(\"No data available !\")\n # Check if missing timesteps\n dt = np.diff(timesteps)\n dts, counts = np.unique(dt, return... | [
"0.65900165",
"0.6369049",
"0.6316393",
"0.6256028",
"0.62290597",
"0.617701",
"0.61646646",
"0.6154375",
"0.60366976",
"0.6026818",
"0.6009626",
"0.5978013",
"0.59768033",
"0.5961701",
"0.5955014",
"0.58601505",
"0.5835052",
"0.58279943",
"0.5825557",
"0.5720708",
"0.5682689... | 0.8279923 | 0 |
Add missing timestamps to weather data and interpolate to fill in the data return df with missing times and weather data filled in | def add_missing_weather_data(df):
full_date_range = pd.date_range(start=min(df.timestamp), end=max(df.timestamp), freq='H')
sites = list(set(df.site_id))
full_data_site_range = pd.DataFrame(itertools.product(sites, full_date_range),
columns=['site_id', 'timestamp'])
df_all_dates = full_data_site_range.merge(df, on=['site_id', 'timestamp'], how='left')
df_all_dates = df_all_dates.groupby('site_id').apply(lambda group: group.interpolate(limit_direction='both'))
return df_all_dates | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auto_fillna(ts: TimeSeries,\n **interpolate_kwargs) -> TimeSeries:\n\n ts_temp = ts.pd_dataframe()\n\n # pandas interpolate wrapper, with chosen `method`\n if 'limit_direction' not in interpolate_kwargs:\n interpolate_kwargs['limit_direction'] = 'both'\n interpolate_kwargs['in... | [
"0.7080858",
"0.68412477",
"0.6801546",
"0.67576146",
"0.6569322",
"0.6546012",
"0.6509167",
"0.6458176",
"0.6420076",
"0.6409065",
"0.6344805",
"0.6284957",
"0.62729025",
"0.6232209",
"0.6207936",
"0.6158501",
"0.61142576",
"0.6104147",
"0.606371",
"0.5919506",
"0.59161085",... | 0.8054154 | 0 |
Convert timestamps to timestamp objects, fill in blanks in weather data, add names of meter types | def clean_data(raw_data, names=const.NAMES, meter_map=const.METER_MAP):
cleaned_data = {}
local_names = names.copy()
if 'building_metadata' in local_names:
local_names.remove('building_metadata')
for name in local_names:
print(f'Cleaning {name} dataset')
df = raw_data[name]
df.timestamp = pd.to_datetime(df.timestamp)
if name.startswith('weather'):
df = add_missing_weather_data(df)
elif name in ['train', 'test']:
df['meter_type'] = df['meter'].map(meter_map)
cleaned_data[name] = df
cleaned_data['building_metadata'] = raw_data['building_metadata']
return cleaned_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_time(data, metadata):\n timestamp_name = metadata[\"timestamp_name\"]\n if timestamp_name == \"\":\n timestamp_name = \"fake_ts\"\n data[timestamp_name] = data.index\n\n data[timestamp_name] = pd.to_datetime(data[timestamp_name])\n data.sort_values(by=[timestamp_name], inpl... | [
"0.5928694",
"0.5771849",
"0.57145715",
"0.56722647",
"0.5632749",
"0.55614084",
"0.55107826",
"0.55105793",
"0.5509269",
"0.55014396",
"0.5444029",
"0.5409909",
"0.5388422",
"0.5376563",
"0.5362756",
"0.535319",
"0.5340124",
"0.5325145",
"0.53104377",
"0.5308769",
"0.5271506... | 0.5138391 | 31 |
Join together the meter data, weather data and building metadata into one df data = dict of df's (keys are'building_metadata', 'weather_train', 'weather_test', 'train','test') dataset_name = 'train' or 'test' returns a merged df which includes building_metadata, weather_train (or weather_test) and train (or test) | def join_input_data_and_multi_index(data, dataset_name):
meter_df = data[dataset_name]
building_df = data['building_metadata']
weather_df = data['weather_' + dataset_name]
# join meter and weather data
building_n_meter = meter_df.merge(building_df, on='building_id', how='left')
joined_data = building_n_meter.merge(weather_df, on=['site_id', 'timestamp'], how='left')
# Add time related columns
joined_data['hour'] = joined_data['timestamp'].dt.hour
joined_data['weekday'] = joined_data['timestamp'].dt.dayofweek
joined_data['week_number'] = joined_data['timestamp'].dt.week
joined_data['month'] = joined_data['timestamp'].dt.month
joined_data['is_weekend'] = joined_data['weekday'].apply(lambda x: 1 if x in [0, 6] else 0)
# multi index on building id and timestamp
joined_data = joined_data.set_index(['building_id', 'timestamp']).sort_index()
return joined_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_data(self):\n # take care of samples\n patients = self.samples.iloc[:,1].tolist()\n samples = self.samples.iloc[:,0].tolist()\n self.samples = pd.DataFrame(patients,index = samples,columns = ['patient']) # indexed by sample\n #\n # take care of expression data\n cols = self.expression... | [
"0.59869367",
"0.57781816",
"0.5758608",
"0.563408",
"0.56181586",
"0.55629724",
"0.5561206",
"0.5549236",
"0.5505305",
"0.55047166",
"0.54905367",
"0.54782295",
"0.54737127",
"0.5469189",
"0.544329",
"0.54359186",
"0.54143375",
"0.5409169",
"0.5407379",
"0.53848493",
"0.5383... | 0.69934803 | 0 |
Split the joined data into a dict with a df for each meter type | def split_on_meter_type(joined_data, meter_types):
joined_data_dict = {meter_type: joined_data[joined_data['meter_type'] == meter_type]
for meter_type in meter_types}
return joined_data_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_meter_data_for_time_slice(apt_no, start_time, end_time):\n if apt_no in ['102A', 102]:\n apt_no = '102A'\n\n logger.debug(\"sMap: Getting meter data for %s between %s and %s\", apt_no, start_time, end_time)\n\n query = (\"select data in ('\" + str(start_time) + \"','\" + str(end_time) + \"'... | [
"0.54995227",
"0.5438723",
"0.5368502",
"0.5285218",
"0.5209991",
"0.5202449",
"0.51980925",
"0.5175748",
"0.5165017",
"0.5150522",
"0.51441115",
"0.5076895",
"0.50656265",
"0.50650203",
"0.5061612",
"0.5057883",
"0.50543916",
"0.5050856",
"0.49904716",
"0.4989884",
"0.498955... | 0.806629 | 0 |
dataset_name should be 'train' or 'test' | def produce_and_cache_small_dataset_dict(dataset_name,
n=500000,
meter_types=const.METER_MAP.values()):
small_dataset_cache_file = pathlib.Path(dataset_name + '_small_store_joined.h5')
if small_dataset_cache_file.exists():
small_dataset_dict = import_dict_from_cached(small_dataset_cache_file, meter_types)
else:
big_dataset_cache_file = pathlib.Path(dataset_name + '_store_joined.h5')
big_dataset_dict = import_dict_from_cached(big_dataset_cache_file, meter_types)
small_dataset_dict = {key: big_dataset.head(n) for key, big_dataset in big_dataset_dict.items()}
_cache_data(small_dataset_dict, small_dataset_cache_file)
return small_dataset_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataset(dataset_name):\n dataset_as_lower = dataset_name.lower()\n if dataset_as_lower in _datasets_from_keras.keys():\n data_details = _datasets_from_keras[dataset_as_lower]\n (x_train, y_train), (x_test, y_test) = data_details['data'].load_data()\n else:\n raise IOError(\... | [
"0.7228631",
"0.70241654",
"0.70175004",
"0.70087993",
"0.6977617",
"0.6900802",
"0.68130064",
"0.6774054",
"0.67727417",
"0.67533123",
"0.673811",
"0.67380196",
"0.6732079",
"0.6708",
"0.6619651",
"0.6580174",
"0.65409255",
"0.6507022",
"0.6495979",
"0.6469288",
"0.64399636"... | 0.0 | -1 |
Return the number of dimension of the state space | def getStatesDim(self):
return 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_space_dimension(cls) -> int:\n return 1",
"def n_dim(self):\n return self._n_dim",
"def num_dim(self):\n return len(self._dimensions)",
"def num_dim(self):\n return len(self._dimensions)",
"def _get_observation_dimension(self):\n return len(self._get_observation... | [
"0.8514534",
"0.78174734",
"0.77158946",
"0.77158946",
"0.7706377",
"0.77037966",
"0.7664541",
"0.76440984",
"0.7634386",
"0.7625269",
"0.75904065",
"0.7558156",
"0.75198585",
"0.7480286",
"0.7480286",
"0.7450488",
"0.7439861",
"0.74317974",
"0.73826283",
"0.7376509",
"0.7371... | 0.76861554 | 6 |
Returns the max and min values each dimension can take. These are returned as two tuples, `low` and `high`, where both are a list of as many elements as there is dimension to the state space. | def getStatesBounds(self):
return (0, 0), (self._width - 1, self._height - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in se... | [
"0.72885597",
"0.6820047",
"0.6709689",
"0.6641923",
"0.661468",
"0.648229",
"0.64780694",
"0.6453788",
"0.64332044",
"0.6412223",
"0.6407123",
"0.63986015",
"0.63950133",
"0.63915455",
"0.6389562",
"0.63883317",
"0.6370339",
"0.63583744",
"0.6325942",
"0.629759",
"0.62925905... | 0.58876115 | 80 |
The agent take the given action and receives back the new state, reward, whether the episode is terminated and some nothingness. | def step(self, action):
x, y = self._move(action, *self._currentPos)
if chr(self._grid[x, y]) == CASE_TYPES.Wall:
# error - previous state was already a wall
self._done = True
self._trajectory.append(self._currentPos)
return self._currentPos, -1, self._done, {}
reward = {
CASE_TYPES.Water: self.waterReward,
CASE_TYPES.Sand: self.sandReward,
CASE_TYPES.Open: self.stepReward,
CASE_TYPES.Termination: self.successReward,
CASE_TYPES.Trap: (
-(self.maxSteps - len(self._trajectory)) + self.failureReward +
self.trapReward)
}[chr(self._grid[x, y])]
# termination state
if chr(self._grid[x, y]) in [CASE_TYPES.Termination, CASE_TYPES.Trap]:
self._done = True
self._currentPos = (x, y)
self._trajectory.append(self._currentPos)
self._nbSteps += 1
if self._nbSteps >= self.maxSteps and not self._done:
reward += self.failureReward
return self._currentPos, reward, self._done, {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def agent_step(self, reward, state):\n self.sum_rewards += reward\n self.episode_steps += 1\n\n # Make state an array of shape (1, state_dim) to add a batch dimension and\n # to later match the get_action_values() and get_TD_update() functions\n state = np.array(state)\n\n ... | [
"0.77299076",
"0.7505443",
"0.7489188",
"0.7451101",
"0.7446967",
"0.7423517",
"0.7353827",
"0.73296374",
"0.732902",
"0.7246652",
"0.71973366",
"0.71956855",
"0.7170794",
"0.7170417",
"0.7162732",
"0.71451074",
"0.7140692",
"0.71406287",
"0.71278226",
"0.71219754",
"0.711092... | 0.0 | -1 |
Reset the state of the evironment for a new episode `setup` is used to let the reset function know when we're calling it from `setup`. If we don't, the 'random' init scheme should reset to the randomly choosen position instead of picking a new random one. | def reset(self, setup=False):
self._done = False
self._nbSteps = 0
x = None
if (self.startPosX == 'random' and setup) or (
self.startPosX == 'episodeRandom'):
x = random.randint(0, self._width - 1)
elif (self.startPosX == 'random' and not setup):
x = self._initState[0]
elif self.startPosX == 'center':
x = self._width - 1
else:
x = int(self.startPosX)
y = None
if (self.startPosX == 'random' and setup) or (
self.startPosX == 'episodeRandom'):
y = random.randint(0, self._height - 1)
elif (self.startPosY == 'random' and not setup):
y = self._initState[1]
elif self.startPosX == 'center':
y = self._height - 1
else:
y = int(self.startPosX)
self._currentPos = (x, y)
self._trajectory = [(x, y)]
return (x, y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n\n # initialize gym env variables\n self.finish = False\n self.curr_step = -1\n self.curr_episode += 1\n\n # initialize target position\n self.target = np.random.uniform(-10.0,10.0,size=(2))\n\n # initialize sheep positions\n if self.fixed_r... | [
"0.66944516",
"0.6647286",
"0.65143913",
"0.6312656",
"0.6290814",
"0.62830704",
"0.6277763",
"0.62062037",
"0.61978877",
"0.6173854",
"0.61685586",
"0.61399466",
"0.613353",
"0.61265284",
"0.6108667",
"0.6104944",
"0.60824627",
"0.60824627",
"0.6075161",
"0.6065723",
"0.6042... | 0.6798604 | 0 |
Render the environment serverside | def render(self, mode="human", close=False):
if close and self._viewer is None:
if self._viewer is not None:
self._viewer.close()
self._viewer = None
return
screen_width = 600
screen_height = 600
if self._viewer is None:
from gym.envs.classic_control import rendering
self._viewer = rendering.Viewer(screen_width, screen_height)
# generate the grid
xs, self._xstep = np.linspace(
0, screen_width, self._width + 1, retstep=True)
ys, self._ystep = np.linspace(
0, screen_height, self._height + 1, retstep=True)
# render the grid
for x in xrange(self._width):
for y in xrange(self._height):
l, r, t, b = (0, self._xstep, self._ystep, 0)
tile = rendering.FilledPolygon([
(l, b), (l, t), (r, t), (r, b)])
tile.add_attr(rendering.Transform(translation=(
x * self._xstep, y * self._ystep)))
tile.set_color(*CASE_COLORS[chr(self._grid[x, y])])
self._viewer.add_geom(tile)
# render starting point
l, r, t, b = (0, self._xstep, self._ystep, 0)
tile = rendering.FilledPolygon([
(l, b), (l, t), (r, t), (r, b)])
tile.add_attr(rendering.Transform(translation=(
self._trajectory[0][0] * self._xstep,
self._trajectory[0][1] * self._ystep)))
tile.set_color(0, 1.0, 1.0)
self._viewer.add_geom(tile)
# render grid lines
for x in xs[1:len(xs) - 1]:
# not including the first and last one
line = rendering.Line((x, 0), (x, screen_height))
self._viewer.add_geom(line)
for y in ys[1: len(ys) - 1]:
line = rendering.Line((0, y), (screen_width, y))
self._viewer.add_geom(line)
agent = rendering.make_circle(
radius=min(
screen_width / (self._width + 1) / 3,
screen_height / (self._height + 1) / 3),
res=30)
self._agentTrans = rendering.Transform(translation=(
self._currentPos[0] * self._xstep + (self._xstep / 2),
self._currentPos[1] * self._ystep + (self._ystep / 2)))
agent.add_attr(self._agentTrans)
self._viewer.add_geom(agent)
self._renderTrajectory()
self._agentTrans.set_translation(
self._currentPos[0] * self._xstep + (self._xstep / 2),
self._currentPos[1] * self._ystep + (self._ystep / 2))
self._viewer.render(return_rgb_array=(mode == 'rgb_array'))
if close:
if self._viewer is not None:
self._viewer.close()
self._viewer = None
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self):\n self.env.render()",
"def render(self):\n self.rendering = True\n self.env.render()",
"def render(self, mode='human'):\n return self._env.render(mode)",
"def _serve_environment(self, request):\n return http_util.Respond(\n request,\n {\n ... | [
"0.8079139",
"0.7380633",
"0.6701152",
"0.6639087",
"0.6605521",
"0.6443869",
"0.6436322",
"0.64339954",
"0.6354514",
"0.6319063",
"0.6319063",
"0.6318727",
"0.62650275",
"0.6256661",
"0.62470657",
"0.62287277",
"0.6225323",
"0.6188681",
"0.6188681",
"0.61411625",
"0.61068594... | 0.0 | -1 |
Fonction sans argument qui affiche un labyrinthe | def afficher_carte(self):
print(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple():",
"def simple():",
"def sth():",
"def saluda1(sujeto):\n print 'Hola '+sujeto+' !!'",
"def plothub1():\r\n pass",
"def saluda2(sujeto):\n print 'Hola %s !!' % sujeto",
"def func():",
"def getLabel(*args):",
"def getLabel(*args):",
"def getLabel(*args):",
"def getLabel2(*a... | [
"0.63914204",
"0.63914204",
"0.5986804",
"0.59826845",
"0.59645784",
"0.5792992",
"0.5778979",
"0.5771139",
"0.5771139",
"0.5771139",
"0.57593817",
"0.57593817",
"0.57460934",
"0.5673789",
"0.5656487",
"0.5655953",
"0.56223005",
"0.5616206",
"0.560993",
"0.56080663",
"0.56043... | 0.0 | -1 |
do api request, parse error, return response. | def get_subtitleinfo(fileFullName):
sys.stdout.write("Requesting subtitle info...\n")
#接口获取字幕信息
response = requests.post(
"https://www.shooter.cn/api/subapi.php",
verify=False,
params= {
'filehash': ComputeFileHash(fileFullName),
'pathinfo': os.path.realpath(fileFullName),
'format': 'json',
'lang': "Chn",
},
)
#未找到字幕处理
if response.text == u'\xff':
sys.stderr.write("Subtitle not found.\n")
sys.exit(1)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _api_request(self,\n method: str,\n path_url: str,\n params: Dict[str, Any] = {}) -> Dict[str, Any]:\n base_url = f\"https://{global_config_map['gateway_api_host'].value}:\" \\\n f\"{global_config_map['... | [
"0.6998465",
"0.697629",
"0.6958306",
"0.68044615",
"0.67445",
"0.673964",
"0.67353",
"0.67159045",
"0.6714112",
"0.6700891",
"0.6693908",
"0.66411114",
"0.6610895",
"0.6592531",
"0.65848005",
"0.6565488",
"0.65573376",
"0.6525482",
"0.64771914",
"0.6451753",
"0.6419186",
"... | 0.0 | -1 |
Returns Home Assistant base url without '/api' or trailing slash | def get_url(self, url):
if not url:
raise ValueError('Property "url" is missing in config')
return url.replace("/api", "").rstrip("/") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_url(url_base):\n return f\"{url_base}/api/v2\"",
"def get_api_url() -> str:\n\n site = pywikibot.Site()\n url = site.protocol() + \"://\" + site.hostname() + site.apipath()\n return url",
"def api_url(self) -> httpx.URL:\n return self._client.base_url",
"def get_api_url() -> str:\n... | [
"0.70845884",
"0.69659054",
"0.69256717",
"0.69165707",
"0.6896292",
"0.68960935",
"0.6873356",
"0.68278384",
"0.6792706",
"0.67290175",
"0.6711364",
"0.6674965",
"0.6651999",
"0.6650969",
"0.66333526",
"0.65721595",
"0.65439534",
"0.653448",
"0.6530355",
"0.6518613",
"0.6511... | 0.6285166 | 37 |
Make sure the netcdf cc data handler operates correctly | def test_data_handling_nc_cc():
input_files = [os.path.join(TEST_DATA_DIR, 'ua_test.nc'),
os.path.join(TEST_DATA_DIR, 'va_test.nc'),
os.path.join(TEST_DATA_DIR, 'orog_test.nc'),
os.path.join(TEST_DATA_DIR, 'zg_test.nc')]
with xr.open_mfdataset(input_files) as fh:
min_lat = np.min(fh.lat.values)
min_lon = np.min(fh.lon.values)
target = (min_lat, min_lon)
plevel = fh.plev[-1]
ua = np.transpose(fh['ua'][:, -1, ...].values, (1, 2, 0))
va = np.transpose(fh['va'][:, -1, ...].values, (1, 2, 0))
handler = DataHandlerNCforCC(input_files, features=['U_100m', 'V_100m'],
target=target, shape=(20, 20),
val_split=0.0,
worker_kwargs=dict(max_workers=1))
assert handler.data.shape == (20, 20, 20, 2)
handler = DataHandlerNCforCC(input_files,
features=[f'U_{int(plevel)}pa',
f'V_{int(plevel)}pa'],
target=target, shape=(20, 20),
val_split=0.0,
worker_kwargs=dict(max_workers=1))
if handler.invert_lat:
handler.data = handler.data[::-1]
assert handler.data.shape == (20, 20, 20, 2)
assert np.allclose(ua, handler.data[..., 0])
assert np.allclose(va, handler.data[..., 1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_data(self):\n # ================ CHECK DATA / CONNECT / SELECT ================\n N = self.xyz.shape[0]\n # Chech array :\n if (self.connect.shape != (N, N)) or not isinstance(self.connect,\n np.ndarray):\n ... | [
"0.60441834",
"0.5924442",
"0.5870361",
"0.56942517",
"0.5658238",
"0.56382203",
"0.5624735",
"0.5600587",
"0.5563595",
"0.55417067",
"0.54565823",
"0.5366081",
"0.5311197",
"0.53014123",
"0.5301123",
"0.52937174",
"0.5290408",
"0.5289225",
"0.52625626",
"0.52489024",
"0.5247... | 0.74189216 | 0 |
Test solar data handling from CC data file with clearsky ratio calculated using clearsky ratio from NSRDB h5 file. | def test_solar_cc():
features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']
input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]
nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')
with xr.open_mfdataset(input_files) as fh:
min_lat = np.min(fh.lat.values)
min_lon = np.min(fh.lon.values) - 360
target = (min_lat, min_lon)
shape = (len(fh.lat.values), len(fh.lon.values))
with pytest.raises(AssertionError):
handler = DataHandlerNCforCC(input_files, features=features,
target=target, shape=shape,
val_split=0.0,
worker_kwargs=dict(max_workers=1))
handler = DataHandlerNCforCC(input_files, features=features,
nsrdb_source_fp=nsrdb_source_fp,
target=target, shape=shape,
temporal_slice=slice(0, 1),
val_split=0.0,
worker_kwargs=dict(max_workers=1))
cs_ratio = handler.data[..., 0]
ghi = handler.data[..., 1]
cs_ghi = handler.data[..., 2]
cs_ratio_truth = ghi / cs_ghi
assert cs_ratio.max() < 1
assert cs_ratio.min() > 0
assert (ghi < cs_ghi).all()
assert np.allclose(cs_ratio, cs_ratio_truth)
with Resource(nsrdb_source_fp) as res:
meta = res.meta
tree = KDTree(meta[['latitude', 'longitude']])
cs_ghi_true = res['clearsky_ghi']
# check a few sites against NSRDB source file
for i in range(4):
for j in range(4):
test_coord = handler.lat_lon[i, j]
_, inn = tree.query(test_coord)
assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n regexham = r'\\s+\\((\\d+,\\s*\\d+)\\)\\s+([\\-+]?\\d+\\.\\d+[eEdD]?[\\-+]?\\d+)' #to extract the Hamiltonian.\n root = '.'\n #fname = 'output_files/'\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', ... | [
"0.6232863",
"0.6190931",
"0.6065787",
"0.5965935",
"0.59624934",
"0.5858929",
"0.5856982",
"0.5837951",
"0.5831565",
"0.58128524",
"0.5789938",
"0.57884246",
"0.5777758",
"0.5774943",
"0.57337826",
"0.5721014",
"0.569534",
"0.5672289",
"0.56514597",
"0.5634904",
"0.5580489",... | 0.7407615 | 0 |
Perform a 'run' action on a module. Module should have status LOADED for a System to actually call this method. | def run(self, **kwargs) -> None:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def module_runner(module):\n task_queue.put(1)\n result = sys.modules[module].run()\n task_queue.get()\n store_module_result(result) # Store the result in our repo",
"def do_run(self, line: str):\n if self._real_module is None:\n print(\"'run' command depends on using a module. See... | [
"0.749783",
"0.74799657",
"0.70269644",
"0.69892204",
"0.68432194",
"0.67123836",
"0.6491966",
"0.64515406",
"0.6416656",
"0.64033836",
"0.63711715",
"0.6279245",
"0.6268681",
"0.6221671",
"0.6220211",
"0.62159735",
"0.6164637",
"0.61534256",
"0.6147704",
"0.61080045",
"0.608... | 0.0 | -1 |
keys_to_track order is important! Matches will be tested in this order. | def __init__(self, keys_to_track):
self.keys_to_track = keys_to_track
self.tracker = {}
for key_to_track in self.keys_to_track:
self.tracker[key_to_track] = {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_matches(self):\r\n for record in self.records:\r\n match_dict={key_to_track: record.get(key_to_track)\r\n for key_to_track in self.key_matcher.keys()}\r\n self.key_matcher.add(obj=record,\r\n match_dict=match_dict)",
"d... | [
"0.72052854",
"0.6073225",
"0.5684413",
"0.5646537",
"0.55177075",
"0.54479295",
"0.54022795",
"0.5286637",
"0.5255114",
"0.52513975",
"0.5236649",
"0.52352864",
"0.5173165",
"0.5170619",
"0.5168231",
"0.51618785",
"0.51518595",
"0.51467997",
"0.5143868",
"0.51270205",
"0.509... | 0.6227405 | 1 |
Add obj as a match for match_dict values. Checks to make sure match_dict keys are valid. | def add(self, obj, match_dict):
for match_key in match_dict.keys():
assert match_key in self.keys_to_track
for key_to_track in self.keys_to_track:
if match_dict.has_key(key_to_track):
match_val = match_dict[key_to_track]
if match_val is None or match_val == '':
pass
else:
self.tracker[key_to_track][match_val] = obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_matches(self):\r\n for record in self.records:\r\n match_dict={key_to_track: record.get(key_to_track)\r\n for key_to_track in self.key_matcher.keys()}\r\n self.key_matcher.add(obj=record,\r\n match_dict=match_dict)",
"d... | [
"0.72251153",
"0.6223135",
"0.612522",
"0.6043846",
"0.6039093",
"0.5865672",
"0.5826964",
"0.5673978",
"0.5657533",
"0.56395197",
"0.5595575",
"0.55939347",
"0.5582442",
"0.55700904",
"0.55490994",
"0.54979956",
"0.5410391",
"0.5368418",
"0.536791",
"0.535772",
"0.5288205",
... | 0.84316427 | 0 |
Find a match using match_dict. Returns None if there is no match. Checks to make sure match_dict keys are valid. | def match(self, match_dict):
for match_key in match_dict.keys():
assert match_key in self.keys_to_track
for key_to_track in self.keys_to_track:
if match_dict.has_key(key_to_track):
match_val = match_dict[key_to_track]
if self.tracker[key_to_track].has_key(match_val):
return self.tracker[key_to_track][match_val]
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_match(needle: dict, haystack: list, keys: list):\n for item in haystack:\n for key in keys:\n if item.get(key) != needle[key]:\n break\n else:\n return item\n return None",
"def dict_match(d, key, default=None):\n\n if key in d and \"[\" not i... | [
"0.6650081",
"0.64368933",
"0.62785393",
"0.6271919",
"0.606207",
"0.60218126",
"0.6009384",
"0.59157956",
"0.5891576",
"0.586902",
"0.5831622",
"0.58111554",
"0.58071977",
"0.580484",
"0.57333195",
"0.5707258",
"0.5707258",
"0.57004094",
"0.5668807",
"0.561176",
"0.5579269",... | 0.8009377 | 0 |
Utility function to populate key_matcher from self.records. | def _add_matches(self):
for record in self.records:
match_dict={key_to_track: record.get(key_to_track)
for key_to_track in self.key_matcher.keys()}
self.key_matcher.add(obj=record,
match_dict=match_dict) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match_source_key(self, match):\n raise NotImplementedError",
"def __init__(self):\n self.key_to_record = {}\n self.mutation_to_key = {}\n self._innovation_key_generator = count(0)",
"def test_toofewkeys(self):\n self.assertRaises(recordparser.KeyListMismatchError,\n ... | [
"0.5777237",
"0.5721886",
"0.5531455",
"0.548444",
"0.54103255",
"0.54072803",
"0.5384197",
"0.53711194",
"0.5370351",
"0.53101146",
"0.5296817",
"0.52691966",
"0.5252932",
"0.5242916",
"0.5215903",
"0.52110225",
"0.5207979",
"0.5202271",
"0.5188836",
"0.5164202",
"0.51598597... | 0.7259984 | 0 |
Check if the origin_imgs are flipped correctly. | def _check_flip(origin_imgs, result_imgs):
h, w, c = origin_imgs.shape
for i in range(h):
for j in range(w):
for k in range(c):
if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_flip(origin_imgs, result_imgs, flip_type):\n n, _, _, _ = np.shape(origin_imgs)\n if flip_type == 'horizontal':\n for i in range(n):\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\n return False\n else:\n # yapf: disable\n for i in range(... | [
"0.7891626",
"0.7111249",
"0.588529",
"0.5814684",
"0.579397",
"0.5752564",
"0.5637771",
"0.5609224",
"0.5603559",
"0.5602122",
"0.55922",
"0.5581342",
"0.5511366",
"0.5511366",
"0.5508238",
"0.54916257",
"0.545488",
"0.54529166",
"0.5440112",
"0.5437185",
"0.5426509",
"0.5... | 0.8528314 | 0 |
make request to subredit and return numbers of subscribers | def recurse(subreddit, hot_list=[]):
headers = {'User-Agent': 'Mauricio'}
url = 'http://www.reddit.com/r/' + subreddit + '/hot/.json'
r = requests.get(url, headers=headers, params=parameters)
if r.status_code == 200:
answer_list_10 = r.json().get('data').get('children')
for top in range(len(answer_list_10)):
hot_list.append((answer_list_10[top].get('data').get('title')))
if len(answer_list_10) >= 100:
parameters['after'] = r.json().get('data').get('after')
recurse(subreddit, hot_list)
return(hot_list)
else:
return(None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_of_subscribers(subreddit):\n\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n headers = {\"User-Agent\": \"my-integration/1.2.3\"}\n\n response = get(url=url, headers=headers)\n\n if response.status_code == 200:\n # print(response.json())\n\n response_json... | [
"0.76823676",
"0.7451481",
"0.7448277",
"0.73799473",
"0.72858876",
"0.7222261",
"0.71943074",
"0.7162595",
"0.7158168",
"0.7157379",
"0.71367633",
"0.71244204",
"0.71223074",
"0.71045095",
"0.7061548",
"0.70038885",
"0.6953015",
"0.6951698",
"0.6925322",
"0.69033",
"0.682086... | 0.0 | -1 |
A cumulative metric is one that needs a prior value to calculate the next value. i.e. only the deltas for the current observed values are reported. A noncumulative metric is one where the absolute observed value is reported every time. | def is_cumulative(self):
return self.name in (
"app.cpu",
"app.uptime",
"app.disk.bytes",
"app.disk.requests",
"app.mem.majflt",
"app.io.wait",
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumulative_returns(self):\n return (1 + self.pct_change).cumprod()",
"def get_cumulative_model(self):\n cm = None\n for ac in self.ac:\n if ac[0] is None:\n continue\n m = self.get_model(last=False, a=ac[0], c=ac[1])\n cm = m if cm is None ... | [
"0.6869948",
"0.67523324",
"0.64255375",
"0.6341759",
"0.63019013",
"0.6291231",
"0.62111056",
"0.6121284",
"0.61202884",
"0.60518414",
"0.6049944",
"0.60443413",
"0.59521824",
"0.5944532",
"0.594417",
"0.5942714",
"0.5922843",
"0.5915984",
"0.58872694",
"0.58869976",
"0.5872... | 0.5677045 | 30 |
Initializes the base class. | def __init__(self, pid, monitor_id, logger, file_pattern):
self._pid = pid
self._id = monitor_id
self._file_pattern = file_pattern
# The file object to be read. We always keep this open and just seek to zero when we need to
# re-read it. Some of the /proc files do better with this approach.
self._file = None
# The time we last collected the metrics.
self._timestamp = None
# True if the reader failed for some unrecoverable error.
self._failed = False
self._logger = logger
self._metric_printer = MetricPrinter(logger, monitor_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(cls):",
"def initialize(self):\r\n pass",
"def initialize(self):\r\n pass",
"def initialize(self):\n\t\tpass",
"def init(self):\n raise NotImplementedError",
"def init(self):\n raise NotImplementedError",
"def _initialize(self):\n pass",
"def _initial... | [
"0.8141555",
"0.78926814",
"0.78926814",
"0.7889723",
"0.78779274",
"0.78779274",
"0.78618664",
"0.78618664",
"0.78618664",
"0.78496444",
"0.7829186",
"0.78273886",
"0.78159505",
"0.7813773",
"0.7813773",
"0.7813773",
"0.7813773",
"0.7813773",
"0.7808769",
"0.7808769",
"0.780... | 0.0 | -1 |
Runs a single cycle of the sample collection. It should read the monitored file and extract all metrics. | def run_single_cycle(self, collector=None):
self._timestamp = int(time.time())
# There are certain error conditions, such as the system not supporting
# a particular proc file type, that we will never recover from. So,
# just always early exit.
if self._failed:
return {}
filename = self._file_pattern % self._pid
if not collector:
collector = {}
if self._file is None:
try:
self._file = open(filename, "r")
except IOError as e:
# We take a simple approach. If we don't find the file or
# don't have permissions for it, then just don't collect this
# stat from now on. If the user changes the configuration file
# we will try again to read the file then.
self._failed = True
if e.errno == errno.EACCES:
self._logger.error(
"The agent does not have permission to read %s. "
"Maybe you should run it as root.",
filename,
)
elif e.errno == errno.ENOENT:
self._logger.error(
(
"The agent cannot read %s. Your system may not support that proc file "
'type or the process with pid "%s" doesn\'t exist'
),
filename,
self._pid,
)
# Ignore 'process not found' errors (likely caused because the process exited
# but re-raise the exception for all other errors
elif e.errno != errno.ESRCH:
raise e
if self._file is not None:
try:
self._file.seek(0)
return self.gather_sample(self._file, collector=collector)
except IOError as e:
# log the error if the errno isn't 'process not found'. Process not found likely means the
# process exited, so we ignore that because it's within the realm of expected behaviour
if e.errno != errno.ESRCH:
self._logger.error(
"Error gathering sample for file: '%s'\n\t%s"
% (filename, six.text_type(e))
)
# close the file. This will cause the file to be reopened next call to run_single_cycle
self.close()
return collector | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\r\n self.collect_data()",
"def gather_sample(self, my_file, collector=None):\n\n pass",
"def collect_samples(self):\n self.__running = True\n with open(self.__filename, 'a') as output:\n next_sample_time = time.time()\n while self.__running:\n ... | [
"0.6506419",
"0.64478827",
"0.6249575",
"0.6136713",
"0.6083549",
"0.60691047",
"0.5937353",
"0.5804329",
"0.5789543",
"0.5710799",
"0.5666293",
"0.56556666",
"0.5654352",
"0.5652799",
"0.5633741",
"0.5620311",
"0.5596868",
"0.55945826",
"0.5588704",
"0.5581774",
"0.5576543",... | 0.71581453 | 0 |
Reads the metrics from the file and records them. Derived classes must override this method to perform the actual work of collecting their specific samples. | def gather_sample(self, my_file, collector=None):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_metrics(self):\n raise NotImplementedError()",
"def setup_metrics_file(self):\n\n with open(self.metrics_path, \"w+\") as f_metrics:\n\n f_metrics.write(get_metrics_file_form())",
"def walk(self):\n data = open(self.data_file_path, 'rb')\n read_metric = globals()... | [
"0.6955891",
"0.69391584",
"0.6471244",
"0.63956815",
"0.6393039",
"0.63644856",
"0.6352858",
"0.6334597",
"0.6094666",
"0.6007557",
"0.5965609",
"0.59264725",
"0.58482134",
"0.5830391",
"0.58277",
"0.5824727",
"0.58074886",
"0.57781744",
"0.57719123",
"0.5734532",
"0.5728365... | 0.65097046 | 2 |
Closes any files held open by this reader. | def close(self):
try:
self._failed = True
if self._file is not None:
self._file.close()
self._failed = False
finally:
self._file = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close( self ):\n \n for file in self._files:\n ir.file_hub.close( file )",
"def close_all_files(self):\r\n while self.close_file():\r\n pass",
"def close(self):\n if self.current_file_number is not None:\n self.fh_raw.close()\n self.cu... | [
"0.7826722",
"0.77460366",
"0.7503366",
"0.72826236",
"0.72478783",
"0.7243321",
"0.7204818",
"0.7204593",
"0.7146203",
"0.7134031",
"0.7112463",
"0.71020526",
"0.70459485",
"0.7036263",
"0.70164305",
"0.7010969",
"0.6980717",
"0.6947164",
"0.6919161",
"0.68919945",
"0.688708... | 0.6589813 | 53 |
Returns the number of centiseconds (1/100ths secs) for the given number of jiffies (a weird timing unit used the kernel). | def __calculate_time_cs(self, jiffies):
return int((jiffies * 100.0) / self._jiffies_per_sec) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_time_ms(self, jiffies):\n\n return int((jiffies * 1000.0) / self._jiffies_per_sec)",
"def jiffies(_load_time=time.time()):\n return int(100*(time.time()-_load_time))",
"def _nsec_to_usec_round(nsec):\n return (nsec + 500) // 10 ** 3",
"def millis(): \n return int(round(mo... | [
"0.7653799",
"0.652349",
"0.6424848",
"0.6171948",
"0.6161103",
"0.6105997",
"0.5744971",
"0.56402147",
"0.5638903",
"0.5606995",
"0.5588372",
"0.5540272",
"0.5520585",
"0.5486425",
"0.54827213",
"0.5427575",
"0.5426606",
"0.5411524",
"0.54085886",
"0.54085886",
"0.54085886",... | 0.7872766 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.