0:\\n batchinds,keyids = self._samplebalanced(pool)\\n elif self.samplemethod == 'uniform':\\n batchinds,keyids = self._sampleuniform(pool)\\n else:\\n batchinds,keyids = self._samplesequential(i)\\n batch = self._extractInds(pool,batchinds,keyids)\\n for k in batch:\\n batch[k][np.isnan(batch[k])] = self.nanreplacement\\n yield batch\",\n \"def serialize_batches():\\n # a set of variables for the state of current batch which will be converted to Arrow\\n # RecordBatch.\\n pdfs = []\\n state_pdfs = []\\n pdf_data_cnt = 0\\n state_data_cnt = 0\\n\\n return_schema = None\\n\\n for data in iterator:\\n # data represents the result of each call of user function\\n packaged_result = data[0]\\n\\n # There are two results from the call of user function:\\n # 1) iterator of pandas DataFrame (output)\\n # 2) updated state instance\\n pdf_iter = packaged_result[0][0]\\n state = packaged_result[0][1]\\n\\n # This is static and won't change across batches.\\n return_schema = packaged_result[1]\\n\\n for pdf in pdf_iter:\\n # We ignore empty pandas DataFrame.\\n if len(pdf) > 0:\\n pdf_data_cnt += len(pdf)\\n pdfs.append(pdf)\\n\\n # If the total number of records in current batch exceeds the configured\\n # threshold, time to construct the Arrow RecordBatch from the batch.\\n if pdf_data_cnt > self.arrow_max_records_per_batch:\\n batch = construct_record_batch(\\n pdfs, pdf_data_cnt, return_schema, state_pdfs, state_data_cnt\\n )\\n\\n # Reset the variables to start with new batch for further data.\\n pdfs = []\\n state_pdfs = []\\n pdf_data_cnt = 0\\n state_data_cnt = 0\\n\\n yield batch\\n\\n # This has to be performed 'after' evaluating all elements in iterator, so that\\n # the user function has been completed and the state is guaranteed to be updated.\\n state_pdf = construct_state_pdf(state)\\n\\n state_pdfs.append(state_pdf)\\n state_data_cnt += 1\\n\\n # processed all output, but current batch may not be flushed yet.\\n if pdf_data_cnt > 0 or state_data_cnt > 0:\\n batch = construct_record_batch(\\n pdfs, pdf_data_cnt, return_schema, state_pdfs, state_data_cnt\\n )\\n\\n yield batch\",\n \"def _next(self):\\n i = 0\\n while i < self.size:\\n yield self.data[i]\\n i += 1\",\n \"def __iter__(self):\\n if not self.big:\\n yield self.D[:self.P, :self.d], self.labels[:self.P]\\n else:\\n for i in range(int(self.P / self.batch_size)):\\n yield self.D[i*self.batch_size:min(self.P, (i+1)*self.batch_size), :self.d].cuda(), \\\\\\n self.labels[i*self.batch_size:min(self.P, (i+1)*self.batch_size), :].cuda()\",\n \"def in_memory_rechunk(\\n inputs: List[Tuple[core.ChunkKey, xarray.Dataset]],\\n target_chunks: Mapping[str, int],\\n) -> Iterator[Tuple[core.ChunkKey, xarray.Dataset]]:\\n key, dataset = consolidate_chunks(inputs)\\n yield from split_chunks(key, dataset, target_chunks)\",\n \"def batch_data(source, target, batch_size):\\n for batch_i in range(0, len(source)//batch_size):\\n start_i = batch_i * batch_size\\n source_batch = source[start_i:start_i + batch_size]\\n target_batch = target[start_i:start_i + batch_size]\\n yield np.array(pad_sentence_batch(source_batch)), np.array(pad_sentence_batch(target_batch))\",\n \"def train_minibatches(self):\\n batch_size = self.params['batch_size']\\n start_index = 0\\n while start_index + batch_size < 500:\\n end_index = start_index + batch_size\\n yield self.input[start_index:end_index], self.y[start_index:end_index]\\n start_index = end_index\",\n \"def next(self):\\n # Keeps under lock only the mechanism which advances\\n # the indexing of each batch.\\n with self.lock:\\n index_array = next(self.index_generator)\\n # The transformation of images is not under thread lock\\n # so it can be done in parallel\\n return self._get_batches_of_transformed_samples(index_array)\",\n \"def data_generator(dataset, config, shuffle=True, augment=False, augmentation=None, batch_size=1):\\n b = 0 # batch item index\\n image_index = -1\\n image_ids = np.copy(dataset.image_ids)\\n error_count = 0\\n\\n # Keras requires a generator to run indefinately.\\n while True:\\n try:\\n # Increment index to pick next image. Shuffle if at the start of an epoch.\\n image_index = (image_index + 1) % len(image_ids)\\n if shuffle and image_index == 0:\\n np.random.shuffle(image_ids)\\n\\n # Get GT bounding boxes and masks for image.\\n image_id = image_ids[image_index]\\n image, gt_class_ids = load_image_gt(dataset, config, image_id, augment=augment,\\n augmentation=augmentation)\\n\\n # Init batch arrays\\n if b == 0:\\n batch_images = np.zeros(\\n (batch_size,) + image.shape, dtype=np.float32)\\n batch_gt_class_ids = np.zeros(\\n (batch_size, config.MAX_GT_INSTANCES), dtype=np.int32)\\n\\n # Add to batch\\n batch_images[b] = mold_image(image.astype(np.float32), config)\\n batch_gt_class_ids[b, gt_class_ids] = 1\\n b += 1\\n\\n # Batch full?\\n if b >= batch_size:\\n inputs = [batch_images, batch_gt_class_ids]\\n outputs = []\\n\\n yield inputs, outputs\\n\\n # start a new batch\\n b = 0\\n except (GeneratorExit, KeyboardInterrupt):\\n raise\\n except:\\n # Log it and skip the image\\n logging.exception(\\\"Error processing image {}\\\".format(\\n dataset.image_info[image_id]))\\n error_count += 1\\n if error_count > 5:\\n raise\",\n \"def data_iter(data, vocab, batch_size, shuffle=True, cuda=False):\\n\\n buckets = defaultdict(list)\\n for pair in data:\\n src_sent = pair[0]\\n buckets[len(src_sent)].append(pair)\\n\\n batched_data = []\\n for src_len in buckets:\\n tuples = buckets[src_len]\\n if shuffle: np.random.shuffle(tuples)\\n batched_data.extend(list(HNCMDataLoader.batch_slice(tuples, batch_size)))\\n\\n if shuffle:\\n np.random.shuffle(batched_data)\\n for src_sents, trg_sents, fact_sents in batched_data:\\n num_trg_word = sum(len(s[:-1]) for s in trg_sents)\\n src_lengths = [len(s) for s in src_sents]\\n src_seqs_var = to_input_var(src_sents, vocab.src, cuda)\\n trg_seqs_var = to_input_var(trg_sents, vocab.trg, cuda)\\n fact_lengths = [[len (s) for s in fact_sent] for fact_sent in fact_sents]\\n fact_seqs_var = to_input_var_2d(fact_sents, vocab.src, cuda)\\n\\n yield {\\n 'src_seq': src_seqs_var, 'src_lengths': src_lengths,\\n 'fact_seq': fact_seqs_var, 'fact_lengths': fact_lengths,\\n 'trg_seq': trg_seqs_var[:, :-1],\\n 'target': trg_seqs_var[:, 1:],\\n 'num_trg_word': num_trg_word, 'num_trg_seq': len(trg_sents)\\n }\",\n \"def example_generator(data_path, single_pass, device_rank,data_as_tf_example=True):\\n\\t\\t\\n\\trandom.seed(device_rank+1)\\n\\tif data_as_tf_example:\\n\\t\\tepoch = 0\\n\\t\\twhile True:\\n\\t\\t\\tfilelist = glob.glob(data_path) # get the list of datafiles\\n\\t\\t\\tassert filelist, ('Error: Empty filelist at %s' % data_path) # check filelist isn't empty\\n\\t\\t\\tif single_pass:\\n\\t\\t\\t\\tfilelist = sorted(filelist)\\n\\t\\t\\telse:\\n\\t\\t\\t\\trandom.shuffle(filelist)\\n\\t\\t\\t#tf.logging.info(filelist)\\t\\t\\t\\t\\n\\t\\t\\tfor file_no, f in enumerate(filelist):\\n\\t\\t\\t\\treader = open(f, 'rb')\\n\\t\\t\\t\\tall_examples = []\\n\\t\\t\\t\\twhile True:\\n\\t\\t\\t\\t\\tlen_bytes = reader.read(8)\\n\\t\\t\\t\\t\\tif not len_bytes: \\n\\t\\t\\t\\t\\t\\tif not single_pass:\\n\\t\\t\\t\\t\\t\\t\\trandom.shuffle(all_examples)\\n\\t\\t\\t\\t\\t\\tfor k in all_examples:\\n\\t\\t\\t\\t\\t\\t\\tyield example_pb2.Example.FromString(k), epoch\\n\\t\\t\\t\\t\\t\\tbreak # finished reading this file\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tstr_len = struct.unpack('q', len_bytes)[0]\\n\\t\\t\\t\\t\\texample_str = struct.unpack('%ds' % str_len, reader.read(str_len))[0]\\n\\t\\t\\t\\t\\tall_examples.append(example_str)\\n\\n\\t\\t\\tif single_pass:\\n\\t\\t\\t\\tprint \\\"example_generator completed reading all datafiles. No more data.\\\"\\n\\t\\t\\t\\tbreak\\n\\n\\t\\t\\n\\telse:\\n\\t\\t#pickle format\\n\\t\\twhile True:\\n\\t\\t\\tif single_pass:\\n\\t\\t\\t\\tfor data_ in data_path:\\n\\t\\t\\t\\t\\tfor i in data_:\\n\\t\\t\\t\\t\\t\\tyield i\\n\\t\\t\\telse:\\n\\t\\t\\t\\trandom.shuffle(data_path)\\n\\t\\t\\t\\tfor data_ in data_path:\\n\\t\\t\\t\\t\\tnew_data = data_\\n\\t\\t\\t\\t\\tx = np.arange(len(new_data))\\n\\t\\t\\t\\t\\tnp.random.shuffle(x)\\n\\t\\t\\t\\t\\t# random.shuffle(new_data)\\n\\t\\t\\t\\t\\tfor i in x:\\n\\t\\t\\t\\t\\t\\tyield new_data[i]\\n\\t\\t\\tif single_pass:\\n\\t\\t\\t\\tbreak\",\n \"def __iter__(self):\\n\\n # Open the data reader\\n self.data.open()\\n\\n starts = np.arange(self.start, self.stop, self.chunksize)\\n for a, b in zip_longest(starts, starts[1:], fillvalue=self.stop):\\n yield self.data.read(a, b, **self.kwargs)\",\n \"def batch_iter(X, *tensors, batch_size=256):\\n idxs = torch.randperm(X.size(0))\\n if X.is_cuda:\\n idxs = idxs.cuda()\\n for batch_idxs in idxs.split(batch_size):\\n res = [X[batch_idxs]]\\n for tensor in tensors:\\n res.append(tensor[batch_idxs])\\n yield res\",\n \"def __call__(self, batch_size=20, shuffle=True, augment=True):\\r\\n\\r\\n if batch_size < 1:\\r\\n raise ValueError(\\\"batch_size must be more than 1.\\\")\\r\\n if shuffle:\\r\\n self.shuffle()\\r\\n\\r\\n for start in range(0, self.length, batch_size):\\r\\n batch = self.perm(start, start+batch_size)\\r\\n if augment:\\r\\n assert self._augmenter is not None, \\\"you have to set an augmenter.\\\"\\r\\n yield self._augmenter.augment_dataset(batch, method=[ia.ImageAugmenter.NONE, ia.ImageAugmenter.FLIP])\\r\\n else:\\r\\n yield batch\",\n \"def get_batch(self):\\n result = self.buffer_.get()\\n self._async_next()\\n return result\",\n \"def get_batch(self):\\n result = self.buffer_.get()\\n self._async_next()\\n return result\",\n \"def make_data_iterator(dataset, batch_size):\\n \\n if dataset == '8gaussians':\\n scale = 2.\\n centers = [\\n (1, 0),\\n (-1, 0),\\n (0, 1),\\n (0, -1),\\n (1. / np.sqrt(2), 1. / np.sqrt(2)),\\n (1. / np.sqrt(2), -1. / np.sqrt(2)),\\n (-1. / np.sqrt(2), 1. / np.sqrt(2)),\\n (-1. / np.sqrt(2), -1. / np.sqrt(2))\\n ]\\n centers = [(scale * x, scale * y) for x, y in centers]\\n while True:\\n dataset = []\\n for i in range(batch_size):\\n point = np.random.randn(2) * .2\\n center = random.choice(centers)\\n point[0] += center[0]\\n point[1] += center[1]\\n dataset.append(point)\\n dataset = torch.Tensor(dataset)\\n dataset /= 1.414 # stdev\\n yield dataset\\n \\n elif dataset == 'sine':\\n while True:\\n noise = 0.2\\n x = torch.linspace(-4, 4, batch_size, dtype=torch.float32)\\n y = np.sin(x) + noise*np.random.randn(*x.shape)\\n yield torch.stack([x, y], dim=1)\\n \\n elif dataset == 'heteroscedastic':\\n theta = torch.linspace(0, 2, batch_size)\\n x = np.exp(theta)*np.tan(0.1*theta)\\n while True:\\n b = (0.001 + 0.5 * np.abs(x)) * np.random.normal(1, 1, batch_size)\\n y = np.exp(theta)*np.sin(0.1*theta) + b\\n yield torch.stack([x, y], dim=1)\\n \\n elif dataset == 'moon':\\n noise = 0.1\\n while True:\\n data, _ = sklearn.datasets.make_moons(n_samples=batch_size,\\n noise=noise)\\n yield torch.Tensor(data)\\n \\n elif dataset == 'helix':\\n noise = 0.2\\n while True:\\n t = torch.linspace(0, 20, batch_size)\\n x = np.cos(t)\\n x2 = np.sin(t) + noise * np.random.randn(*x.shape)\\n \\n yield torch.stack([x, x2, t], dim=1)\\n \\n elif dataset == 'circle':\\n while True:\\n t = np.random.random(batch_size) * 2 * np.pi - np.pi\\n length = 1 - np.random.random(batch_size)*0.4\\n x = torch.Tensor(np.multiply(np.cos(t), length))\\n y = torch.Tensor(np.multiply(np.sin(t), length))\\n \\n yield torch.stack([x, y], dim=1)\\n\\n elif dataset == '2spirals':\\n while True:\\n z = torch.randn(batch_size, 2)\\n n = torch.sqrt(torch.rand(batch_size // 2)) * 540 * (2 * math.pi) / 360\\n d1x = - torch.cos(n) * n + torch.rand(batch_size // 2) * 0.5\\n d1y = torch.sin(n) * n + torch.rand(batch_size // 2) * 0.5\\n x = torch.cat([torch.stack([ d1x, d1y], dim=1),\\n torch.stack([-d1x, -d1y], dim=1)], dim=0) / 3\\n yield x + 0.1*z\",\n \"def forward_batch(model, batch, device):\\n inputs, labels = (batch, batch)\\n inputs, labels = inputs.to(device), labels.to(device)\\n\\n outputs = model(inputs, labels=labels)\\n\\n return outputs[:2]\",\n \"def _batch_iter(line_iter, n_objects, batchsize, dtype):\\n new_dt = np.dtype(dtype.descr + [('mask',bool), ('weight', float)])\\n batch = np.zeros((batchsize, n_objects), dtype=new_dt)\\n sample_n = 0\\n for array, wt in line_iter:\\n\\n n_missing = n_objects - array.size\\n\\n array.resize(n_objects, refcheck=False)\\n batch[sample_n, :] = array\\n batch['weight'][sample_n, :] = wt\\n if n_missing > 0:\\n batch['mask'][sample_n, -n_missing:] = True\\n\\n sample_n += 1\\n if sample_n == batchsize:\\n yield batch\\n sample_n = 0\\n batch.fill(0)\\n yield batch[:sample_n, ...]\",\n \"def next(self):\\n if self._curr_batch + 1 > self.num_batches:\\n # no more batches in current iteration through data set so start\\n # new epoch ready for another pass and indicate iteration is at end\\n self.new_epoch()\\n raise StopIteration()\\n # create an index slice corresponding to current batch number\\n batch_slice = slice(self._curr_batch * self.batch_size,\\n (self._curr_batch + 1) * self.batch_size)\\n inputs_batch = self.inputs[batch_slice]\\n targets_batch = self.targets[batch_slice]\\n # target_ids_global = self.target_ids[batch_slice]\\n target_ids_batch = self.target_ids[batch_slice]\\n self._curr_batch += 1\\n\\n batch_inputs, batch_target_ids, batch_targets = \\\\\\n self.transform_batch(inputs_batch, target_ids_batch, targets_batch)\\n\\n return batch_inputs, batch_targets, batch_target_ids\",\n \"def next_batch(self):\\n # Whether an epoch is done.\\n done = False\\n samples = []\\n for _ in range(self.batch_size):\\n # Indeed, `>` will not occur.\\n if self.ptr >= self.dataset_size:\\n done = True\\n break\\n else:\\n self.ptr += 1\\n sample = self.enqueuer.queue.get()\\n samples.append(sample)\\n # print 'queue size: {}'.format(self.enqueuer.queue.qsize())\\n # Indeed, `>` will not occur.\\n if self.ptr >= self.dataset_size:\\n done = True\\n return samples, done\",\n \"def process(self, data_batch: Any, data_samples: Sequence[dict]) -> None:\",\n \"def next(self, batch_size):\\n if self.batch_id == len(self.data):\\n self.batch_id = 0\\n batch_data = (self.data[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n batch_labels = (self.labels[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n batch_seqlen = (self.seqlen[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n self.batch_id = min(self.batch_id + batch_size, len(self.data))\\n\\n\\n return batch_data, batch_labels, batch_seqlen\",\n \"def next(self, batch_size):\\n if self.batch_id == len(self.data):\\n self.batch_id = 0\\n batch_data = (self.data[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n batch_labels = (self.labels[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n batch_seqlen = (self.seqlen[self.batch_id:min(self.batch_id + batch_size, len(self.data))])\\n self.batch_id = min(self.batch_id + batch_size, len(self.data))\\n\\n\\n return batch_data, batch_labels, batch_seqlen\",\n \"def csv_data():\\r\\n for row in data:\\r\\n writer.writerow(row)\\r\\n csv_data = read_and_flush()\\r\\n yield csv_data\",\n \"def data_generator():\\n msg = Message(Message.ADD, queue.uuid, queue)\\n PROVIDER_MQ.put(msg)\\n keep_running = True\\n while keep_running:\\n try:\\n chunk = queue.get()\\n yield chunk\\n except Empty:\\n app.logger.info('Queue empty. Ending stream')\\n keep_running = False\",\n \"def get_batch(self, data, batch_size):\\n minibatch, size_so_far = [], 0\\n for ex in data:\\n minibatch.append(ex)\\n size_so_far = self.simple_batch_size_fn(ex, len(minibatch))\\n if size_so_far == batch_size:\\n yield minibatch\\n minibatch, size_so_far = [], 0\\n elif size_so_far > batch_size:\\n yield minibatch[:-1]\\n minibatch, size_so_far = minibatch[-1:], self.simple_batch_size_fn(ex, 1)\\n if minibatch:\\n yield minibatch\",\n \"def prepare_epoch(dataset):\\n print(\\\"[-] Epoch Start\\\")\\n\\n i = 0\\n for sample in range(len(dataset)):\\n if sample <= i + BATCH_SIZE-1:\\n continue\\n\\n batch = []\\n for i in range(i, i+BATCH_SIZE):\\n batch.append(get_image(dataset[i], OUT_SIZE, CHANNELS))\\n\\n i += BATCH_SIZE + 1\\n\\n batch_images = np.array(batch).astype(np.float32)\\n yield (batch_images, batch_images)\\n print(\\\"i: {}, s: {}\\\".format(i, sample))\\n\\n print(\\\"[+] Epoch complete\\\")\",\n \"def next_batch(memory_dim, batch_length, task):\\n batch_inputs = []\\n batch_targets = []\\n difficulty = 0.0\\n for _ in xrange(batch_length):\\n # Values as integers\\n random_input = task.generate_random_input(difficulty, memory_dim)\\n target_output = task.run(random_input)\\n\\n # Values as MxM memories\\n batch_inputs.append(values_to_distribution_memory(random_input))\\n batch_targets.append(values_to_distribution_memory(target_output))\\n\\n return batch_inputs, batch_targets\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8038773","0.6822095","0.6774101","0.6757084","0.6754781","0.67486644","0.66554976","0.6627214","0.6619876","0.65627116","0.6536915","0.6529731","0.6469983","0.64140165","0.63782895","0.6337724","0.631927","0.63143736","0.6306672","0.62904304","0.6277047","0.6276563","0.6265257","0.62384397","0.6233552","0.6227715","0.6224404","0.6211188","0.6199946","0.61789393","0.6178496","0.6175554","0.61753815","0.6171556","0.61583465","0.6154793","0.61293495","0.61272883","0.6127227","0.6126455","0.6118559","0.61168015","0.61168015","0.61097926","0.60845584","0.6069215","0.6062708","0.6048018","0.6043625","0.60340035","0.6028219","0.6028006","0.6024819","0.6019277","0.60156786","0.6015407","0.6012521","0.6009678","0.6004261","0.60029244","0.5997991","0.59954226","0.59947044","0.5994585","0.59909075","0.5969776","0.5951332","0.5950017","0.5947643","0.5947495","0.59336144","0.59241647","0.59222686","0.5919622","0.5917313","0.5892746","0.5888376","0.5887098","0.588192","0.5874423","0.5864864","0.5863472","0.58610874","0.58610874","0.5852324","0.58420724","0.5836585","0.583057","0.5828125","0.5822436","0.58218867","0.58218867","0.5819986","0.58007926","0.579476","0.57911026","0.57879806"],"string":"[\n \"0.8038773\",\n \"0.6822095\",\n \"0.6774101\",\n \"0.6757084\",\n \"0.6754781\",\n \"0.67486644\",\n \"0.66554976\",\n \"0.6627214\",\n \"0.6619876\",\n \"0.65627116\",\n \"0.6536915\",\n \"0.6529731\",\n \"0.6469983\",\n \"0.64140165\",\n \"0.63782895\",\n \"0.6337724\",\n \"0.631927\",\n \"0.63143736\",\n \"0.6306672\",\n \"0.62904304\",\n \"0.6277047\",\n \"0.6276563\",\n \"0.6265257\",\n \"0.62384397\",\n \"0.6233552\",\n \"0.6227715\",\n \"0.6224404\",\n \"0.6211188\",\n \"0.6199946\",\n \"0.61789393\",\n \"0.6178496\",\n \"0.6175554\",\n \"0.61753815\",\n \"0.6171556\",\n \"0.61583465\",\n \"0.6154793\",\n \"0.61293495\",\n \"0.61272883\",\n \"0.6127227\",\n \"0.6126455\",\n \"0.6118559\",\n \"0.61168015\",\n \"0.61168015\",\n \"0.61097926\",\n \"0.60845584\",\n \"0.6069215\",\n \"0.6062708\",\n \"0.6048018\",\n \"0.6043625\",\n \"0.60340035\",\n \"0.6028219\",\n \"0.6028006\",\n \"0.6024819\",\n \"0.6019277\",\n \"0.60156786\",\n \"0.6015407\",\n \"0.6012521\",\n \"0.6009678\",\n \"0.6004261\",\n \"0.60029244\",\n \"0.5997991\",\n \"0.59954226\",\n \"0.59947044\",\n \"0.5994585\",\n \"0.59909075\",\n \"0.5969776\",\n \"0.5951332\",\n \"0.5950017\",\n \"0.5947643\",\n \"0.5947495\",\n \"0.59336144\",\n \"0.59241647\",\n \"0.59222686\",\n \"0.5919622\",\n \"0.5917313\",\n \"0.5892746\",\n \"0.5888376\",\n \"0.5887098\",\n \"0.588192\",\n \"0.5874423\",\n \"0.5864864\",\n \"0.5863472\",\n \"0.58610874\",\n \"0.58610874\",\n \"0.5852324\",\n \"0.58420724\",\n \"0.5836585\",\n \"0.583057\",\n \"0.5828125\",\n \"0.5822436\",\n \"0.58218867\",\n \"0.58218867\",\n \"0.5819986\",\n \"0.58007926\",\n \"0.579476\",\n \"0.57911026\",\n \"0.57879806\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6813648"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":86498,"cells":{"query":{"kind":"string","value":"Shortcut to test \"total population\" field from the P1 (race) table since this table exists for both 2000 and 2010."},"document":{"kind":"string","value":"def _test_totalpop(self, obj, known_2000, known_2010):\n known_delta = known_2010 - known_2000\n known_pct = float(known_delta) / float(known_2000)\n\n self.assertEqual(float(obj['data']['2000'][\"P1\"]['P001001']), known_2000)\n self.assertEqual(float(obj['data']['2010'][\"P1\"]['P001001']), known_2010)\n self.assertEqual(float(obj['data']['delta'][\"P1\"]['P001001']), known_delta)\n self.assertAlmostEqual(\n float(obj['data']['pct_change'][\"P1\"]['P001001']),\n known_pct\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 test_county(self):\n counties = self.geographies.find({ 'geoid': '15009' })\n\n self.assertEqual(counties.count(), 1)\n\n county = counties[0]\n\n self.assertEqual(county['sumlev'], config.SUMLEV_COUNTY)\n self.assertEqual(county['metadata']['NAME'], 'Maui County')\n self.assertEqual(county['metadata']['STATE'], '15')\n self.assertEqual(county['metadata']['COUNTY'], '009')\n\n pop_2000 = 128094 \n pop_2010 = 154834\n self._test_totalpop(county, pop_2000, pop_2010)","def relative_population(data, population, ageclass):\n total_pop = data[population].sum(axis=0)\n data['rel_pop'] = (data[population]/total_pop)*100000\n relative_pop = data.pivot(columns=ageclass, values='rel_pop').sum(axis=0)\n return relative_pop","def c_test_population_function(self, function):\r\n return 1","def test_place(self):\n places = self.geographies.find({ 'geoid': '1562600' })\n\n self.assertEqual(places.count(), 1)\n\n place = places[0]\n\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\n self.assertEqual(place['metadata']['STATE'], '15')\n self.assertEqual(place['metadata']['PLACE'], '62600')\n\n pop_2000 = 30976\n pop_2010 = 47698 \n self._test_totalpop(place, pop_2000, pop_2010)","def test_census_county_population():\n dataframe = get_county_population_dataframe()\n boulder_county_row = dataframe.loc[dataframe['county_fips'] == 8013]\n boulder_county_population = boulder_county_row.get('county_population')\n assert float(boulder_county_population) == 326196","def __population_quality(self) -> float:\n population_identifier = np.zeros(shape=self.Dataset.size)\n subgroup_identifier = np.ones(shape=len(self.get_cover()))\n group = np.concatenate((population_identifier,\n subgroup_identifier))\n\n subgroup_times = self.Dataset.survival[self.get_cover()]\n subgroup_status = self.Dataset.status[self.get_cover()]\n\n time = np.concatenate((self.Dataset.survival, subgroup_times))\n status = np.concatenate((self.Dataset.status, subgroup_status))\n\n _, pvalue = sm.duration.survdiff(time, status, group)\n return 1 - pvalue","def large_p1_gap(self, row, name):\n all_pops = sorted(self.name_pops[name], reverse=True)\n pop = row.population or 0\n return pop - sum(all_pops[1:]) > self.min_p1_gap","def cr_check_population_availability(unit_id, table):\n\n T = current.T\n tablename = table._tablename\n\n if tablename == \"cr_shelter\":\n query = (table.site_id == site_id)\n #elif tablename == \"cr_shelter_unit\":\n else:\n query = (table.id == unit_id)\n\n record = current.db(query).select(table.capacity_day,\n table.population_day,\n table.capacity_night,\n table.population_night,\n limitby = (0, 1),\n ).first()\n\n day_and_night = current.deployment_settings.get_cr_day_and_night()\n\n warning = None\n full_day = full_night = False\n\n capacity_day = record.capacity_day\n population_day = record.population_day\n if capacity_day is not None and \\\n population_day and \\\n population_day >= capacity_day:\n full_day = True\n\n if day_and_night:\n capacity_night = record.capacity_night\n population_night = record.population_night\n if capacity_night is not None and \\\n population_night and \\\n population_night >= capacity_night:\n full_night = True\n\n if not day_and_night and full_day or full_day and full_night:\n if tablename == \"cr_shelter\":\n warning = T(\"Warning: this shelter is full\")\n elif tablename == \"cr_shelter_unit\":\n warning = T(\"Warning: this housing unit is full\")\n elif full_day:\n if tablename == \"cr_shelter\":\n warning = T(\"Warning: this shelter is full for daytime\")\n elif tablename == \"cr_shelter_unit\":\n warning = T(\"Warning: this housing unit is full for daytime\")\n elif full_night:\n if tablename == \"cr_shelter\":\n warning = T(\"Warning: this shelter is full for the night\")\n elif tablename == \"cr_shelter_unit\":\n warning = T(\"Warning: this housing unit is full for the night\")\n\n if warning:\n response = current.response\n response_warning = response.warning\n if response_warning:\n response.warning = \"%s - %s\" % (response_warning, warning)\n else:\n response.warning = warning","def test_nulls_for_year(year, state, conn):\n percent_nulls = pd.read_sql_query(f\"\"\"SELECT\n 100.0 * count(total_prison_pop) / count(1) as PercentNotNull\n FROM\n incarceration\n WHERE state = '{state}'\n AND year = {year};\n \"\"\", conn)\n return percent_nulls","def test_state(self):\n states = self.geographies.find({ 'geoid': config.SUMLEV_STATE })\n\n self.assertEqual(states.count(), 1)\n\n state = states[0]\n\n self.assertEqual(state['sumlev'], config.SUMLEV_STATE)\n self.assertEqual(state['metadata']['NAME'], 'Hawaii')\n self.assertEqual(state['metadata']['STATE'], '15')\n\n pop_2000 = 1211537\n pop_2010 = 1360301\n self._test_totalpop(state, pop_2000, pop_2010)","def test_county_subdivision(self):\n counties = self.geographies.find({ 'geoid': '1500190630' })\n\n self.assertEqual(counties.count(), 1)\n\n county = counties[0]\n\n self.assertEqual(county['sumlev'], config.SUMLEV_COUNTY_SUBDIVISION)\n self.assertEqual(county['metadata']['NAME'], 'Hilo CCD')\n self.assertEqual(county['metadata']['STATE'], '15')\n self.assertEqual(county['metadata']['COUNTY'], '001')\n\n pop_2000 = 42425 \n pop_2010 = 45714 \n self._test_totalpop(county, pop_2000, pop_2010)","def get_population_by_race_columns():\n return {\n 'DP05_0070E': 'Population (Total)',\n 'DP05_0071E': 'Population (Hispanic or Latino)',\n 'DP05_0077E': 'Population (White alone, Non-Hispanic)',\n 'DP05_0078E': 'Population (Black or African American alone, Non-Hispanic)',\n 'DP05_0080E': 'Population (Asian alone, Non-Hispanic)',\n\n # These will be grouped into an \"Other\" category\n 'DP05_0079E': 'Population (American Indian and Alaska Native alone, Non-Hispanic)',\n 'DP05_0081E': 'Population (Native Hawaiian and Other Pacific Islander alone, Non-Hispanic)',\n 'DP05_0082E': 'Population (Some other race alone, Non-Hispanic)',\n 'DP05_0083E': 'Population (Two or more races, Non-Hispanic)'\n }","def check_file_complete(state):\r\n\t# pull in ref file for synth pop\r\n\tpath = '/ihme/scratch/users/beatrixh/decennial_census_2010/{}_decennial_2010/{}2010ur1_all_vars.CSV'.format(state,state)\r\n\tusecols = location_cols + ['P0010001']\r\n\tdf = pd.read_csv(path, usecols=usecols)\r\n\tdf = df[df.BLOCK.notna()]\r\n\r\n\t# get state pop totals\r\n\tref = pd.read_csv('/ihme/scratch/users/beatrixh/us_state_pop_2010_decennial.csv')\r\n\tdif = ref[ref.state==state].pop_count.values[0] - df.P0010001.sum()\r\n\tif dif > 0:\r\n\t\tprint(\"{} pop total is off by {}\".format(state, dif))\r\n\treturn dif","def globalpopulation():\n startdate = datetime.datetime.now()\n enddate = startdate - datetime.timedelta(days=30)\n q = db.session.query(\n func.avg(PopSnap.popcount),\n func.strftime('%H', PopSnap.time)\n ).filter(\n PopSnap.time <= startdate,\n PopSnap.time >= enddate\n ).group_by(func.strftime('%H', PopSnap.time)).all()\n counts = [el[0] for el in q] # first piece of each grouped result\n hours = [el[1] for el in q] # second piece of each grouped result\n return render_template('populationstats.html', counts=counts, hours=hours)","def test_block_sum(self):\n blocks = self.geographies.find({ 'sumlev': config.SUMLEV_BLOCK })\n\n pop_2010 = sum([int(block['data']['2010']['P1']['P001001']) for block in blocks])\n\n self.assertEqual(pop_2010, 1360301)","def getStats(population, masterList):\n for team in population:\n for i in range(13): #13 are the number of roster spots?\n team.totHr += masterList[team.roster[i]].hr\n team.totAvg += masterList[team.roster[i]].avg\n team.totRuns += masterList[team.roster[i]].runs\n team.totSb += masterList[team.roster[i]].sb\n team.totRbi += masterList[team.roster[i]].rbi\n if i == 12:\n team.totAvg = team.totAvg / 13\n return population","def total_population(self):\n return self._total_population","def total_population(self):\n return self._total_population","def test_one_pop(data_: tuple, _is_pop: bool):\n x_bar = cls.get_mean(data_)\n s_x = cls.get_stdev(data_, is_population=_is_pop)\n n_x = cls.get_n(data_)\n return (x_bar - h0) / (s_x / sqrt(n_x))","def gopher_population_modifier(current_population):\n births = int(current_population * (randrange(10, 21) / 100))\n deaths = int(current_population * (randrange(5, 26) / 100))\n new_population = current_population + births - deaths\n print(\"{} gophers were born :) {} gophers died :(\\nTotal gopher population : {}\\n\".format\n (births, deaths, new_population))\n return new_population","def get_population_count(data_path:str, roi):\n try: # open population file\n df_pop = pd.read_csv(data_path / 'population_estimates.csv')\n except:\n print(\"Missing population_estimates.csv in data-path\")\n\n try:\n population = df_pop.query('roi == \"{}\"'.format(roi))['population'].values\n except:\n print(\"{} population estimate not found in population_estimates.csv\".format(args.roi))\n\n return int(population)","def isIndividualInPopulation(self, individual, population):\n\t\tfor i in population:\n\t\t\tif i == individual:\n\t\t\t\treturn True\n\t\treturn False","def check_how_much_to_paid(self, cells_number):\n if len(self.owner.countries[self.section]) == 2:\n return 10 * cells_number * 10000\n return 4 * cells_number * 10000","def average_population_grade(population):\r\n total = 0\r\n for individual in population :\r\n total += get_individual_fitness(individual)\r\n return total/POPULATION_COUNT","def current_world_population(self, option='total'):\n if option.lower() == 'total':\n return int(Worldometers.soup.find(id='cp1').getText().replace(',', ''))\n \n elif option.lower() == 'male':\n return int(Worldometers.soup.find(id='cp2').getText().replace(',', ''))\n \n elif option.lower() == 'female':\n return int(Worldometers.soup.find(id='cp3').getText().replace(',', ''))","def get_area_population(area=None):\n pop_dict = get_region_pop_dict()\n try:\n population = pop_dict[area]\n except KeyError:\n population = sum([v for v in pop_dict.values()])\n return population","def total_population(self):\n total_population_list = []\n for y in self.island_map:\n for cell in y:\n total_population_list += cell.population\n return total_population_list","def population(self):\n return self._population","def label_genres(row):\n\n if row[\"Price\"] < genres_mean.loc[(row[\"affordability\"], row[\"genre_count\"])]:\n return 1\n else:\n return 0","def prob4(file='crime_data.csv'):\n #Get the data\n df = pd.read_csv(file)\n df = df.set_index('Year')\n \n #Create a new column rate\n df['Rate'] = df['Total']/df['Population']\n vil_avg = df['Violent'].mean()\n \n #Create masks and get the murders for those years\n mask1 = df['Rate'] > .05\n mask2 = df['Violent'] > vil_avg\n murder_tracker = df[mask1][mask2][['Murder']]\n ans = murder_tracker.values\n ans = ans.squeeze()\n return(ans)\n #raise NotImplementedError(\"Problem 4 Incomplete\")","def get_population(self):\n population = 0\n for i in self:\n population += i.count(self.cell_state['alive'])\n return population","def get_population_for_health_board(health_board_to_council: pd.DataFrame,\r\n council_areas: pd.DataFrame) -> pd.Series:\r\n population_health_boards = {}\r\n for health_board, councils in health_board_to_council.iterrows():\r\n population_total = 0\r\n for council in councils:\r\n if council is not None:\r\n population_total += int(council_areas.loc[council][1])\r\n population_health_boards[health_board] = population_total\r\n return pd.Series(population_health_boards, name='Population mid 2018 ONS estimate')","def test_population_bioequivalence():\n\n # See 10.3 Example from Chow et al.\n h = Population(l=-0.2966, stdev_11=0.2, stdev_tt=math.sqrt(0.17),\n stdev_tr=math.sqrt(0.17), stdev_bt=0.4, stdev_br=0.4,\n rho=0.75, alpha=0.05, power=0.8)\n h.calculate()\n assert h.n == 12","def roulette(total_fitness, population):\n pie_slice = random.random() * total_fitness\n fitness_so_far = 0.0\n\n for i in range(len(population)):\n fitness_so_far += population[i].fitness\n\n if fitness_so_far >= pie_slice:\n return population[i]\n return None","def mda_population_calculations(sender, instance=None, **kwargs):\n eligible_field = \"_population_eligible\"\n treatment_field = \"_population_treatment\"\n persons_field = \"sprayable/anotherperson\"\n if instance.data and eligible_field not in instance.data:\n instance.data[eligible_field] = 0\n instance.data[treatment_field] = 0\n if persons_field in instance.data:\n for person in instance.data[persons_field]:\n if person.get(\"{}/eligible\".format(persons_field)) == \"yes\":\n instance.data[eligible_field] += 1\n treatment = person.get(\n \"{}/treatment\".format(persons_field)\n )\n if treatment == \"received\":\n instance.data[treatment_field] += 1","def passing_grade(row):\n if row['Combine'] >= 70.0:\n return 1\n else:\n return 0","def verify_aggPercPrimTreatment(self):\n self.c.execute('''SELECT aggCode, (aggC2*aggGenerated/100)\n FROM Agglomerations\n WHERE (aggC2*aggGenerated/100) >= 2000 \n AND aggPercPrimTreatment IS NULL OR aggPercPrimTreatment = \"\"\n ''')\n res = self.c.fetchall()\n if (len(res) > 0):\n return [False,\n \"In the agglomeration '%s' aggPercPrimTreatment must be reported since the generated load is '%s'\",\n res]\n else:\n return [True]","def test_calculates_risk_points_with_one_mortgaged_house(self):\n\n self.user[\"houses\"] = [{\n \"id\": 1,\n \"ownership_status\": \"mortgaged\"\n }]\n\n self.risk_profile[\"home\"] = [{\n \"id\": 1,\n \"is_eligible\": True,\n \"risk_points\": 1\n }]\n\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\n\n self.assertEquals(self.risk_profile[\"home\"][0][\"risk_points\"], 3)\n self.assertEquals(self.risk_profile[\"disability\"][\"risk_points\"], 2)","def population_projection(self):\n population_projection = Worldometers.soup.find_all(class_='years')[1]\n year_rows = population_projection.find_all('tr')\n\n population_projection_dict = {}\n for x in range(1, len(year_rows)):\n columns = year_rows[x].find_all('td')\n population_projection_dict[x-1] = {\n 'year': columns[0].getText().replace(',', ''),\n 'population': columns[1].getText().replace(',', ''),\n 'growth': columns[2].getText().replace(' %', '')\n }\n\n return population_projection_dict","def prob4():\n#pass\n n_men = 0\n n_women = 0\n db = sql.connect('sql2')\n cur = db.cursor()\n cur.execute(\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\")\n for gen in cur :\n if gen[0] == 'M' :\n n_men += 1\n else :\n n_women += 1\n db.close()\n return n_men,n_women","def all(fill_nan=True):\n df = population().merge(codemap(), left_index=True, right_on='Name')\n df = df[df.Population > MIN_POPULATION * POPULATION_SCALE]\n df.columns = [\"Population\", \"Code\", \"FullName\"]\n for g in map(lambda e: e().merge(codemap(), left_index=True, right_on='Name'),\n [employment, conflict, fertility, gdp]):\n df = df.merge(g, on='Code', how='left')\n df = df.merge(neighbors(), how='left', on='Code')\n df = df.set_index([\"Code\"])\n df = df[COUNTRY_COLS]\n df = df.sort_values(\"FullName\")\n if not fill_nan:\n return df\n # Some countries are missing data. We will guess this data using that of\n # neighboring countries.\n missing_cols = [\"Conflict\", \"Unemployment\", \"GDP\", \"Fertility\"]\n for _ in range(2):\n for column in missing_cols:\n for item, frame in df[df[column].isnull()][\"neighbors\"].iteritems():\n df.set_value(item, column, df[df.index.isin(frame)][column].mean())\n return df","def test_calculates_risk_points_with_mortgaged_house(self):\n\n self.user[\"houses\"].insert(0, {\n \"id\": 123,\n \"ownership_status\": \"mortgaged\"\n })\n\n self.risk_profile[\"home\"].insert(0, {\n \"id\": 123,\n \"is_eligible\": True,\n \"risk_points\": 1\n })\n\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\n\n for house in self.risk_profile[\"home\"]:\n if house[\"id\"] == 123:\n self.assertEquals(house[\"risk_points\"], 2)\n else: \n self.assertEquals(house[\"risk_points\"], 1)\n \n self.assertEquals(self.risk_profile[\"disability\"][\"risk_points\"], 2)","def getPopulation(self):\n\n return self.p","def get_popsize(popsizes_df, location):\n return popsizes_df.loc[popsizes_df['location'] == location]['population_size'].values[0]","def test_simple_tract(self):\n tracts = self.geographies.find({ 'geoid': '15007040500' })\n\n self.assertEqual(tracts.count(), 1)\n\n tract = tracts[0]\n\n self.assertEqual(tract['sumlev'], config.SUMLEV_TRACT)\n self.assertEqual(tract['metadata']['NAME'], 'Census Tract 405')\n self.assertEqual(tract['metadata']['STATE'], '15')\n self.assertEqual(tract['metadata']['COUNTY'], '007')\n\n pop_2000 = 5162 \n pop_2010 = 5943 \n self._test_totalpop(tract, pop_2000, pop_2010)","def grade(population, target_sum, target_mult):\r\n summed = reduce(add, (fitness(x, target_sum, target_mult) for x in population), 0)\r\n return summed / len(population)","def get_perc_pop_vax(population, area=None):\n tot_1st_admins = get_tot_admins(dtype=VAX_FIRST_DOSE_KEY, area=area)\n tot_2nd_admins = get_tot_admins(dtype=VAX_SECOND_DOSE_KEY, area=area)\n tot_3rd_admins = get_tot_admins(dtype=VAX_BOOSTER_DOSE_KEY, area=area)\n return {\n 'first': round(((int(tot_1st_admins) / population) * 100), 1),\n 'second': round(((int(tot_2nd_admins) / population) * 100), 1),\n 'booster': round(((int(tot_3rd_admins) / population) * 100), 1)\n }","def test_calculates_risk_points_with_one_house(self):\n\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\n\n for house in self.risk_profile[\"home\"]:\n self.assertEquals(house[\"risk_points\"], 2)","def _get_building_type_proportion_by_zone(self, db, gridcells_table_name):\r\n return db.GetResultsFromQuery(\r\n \"\"\"SELECT GRID_ID, g.ZONE_ID, RESIDENTIAL_UNITS/RES_TOTAL AS RES, \r\n GOVERNMENTAL_SQFT/GOV_TOTAL AS GOV, \r\n COMMERCIAL_SQFT/COM_TOTAL AS COM, \r\n INDUSTRIAL_SQFT/IND_TOTAL AS IND\r\n FROM %(grid)s AS g, \r\n (SELECT ZONE_ID, \r\n SUM(RESIDENTIAL_UNITS) AS RES_TOTAL,\r\n SUM(GOVERNMENTAL_SQFT) AS GOV_TOTAL,\r\n SUM(COMMERCIAL_SQFT) AS COM_TOTAL,\r\n SUM(INDUSTRIAL_SQFT) AS IND_TOTAL \r\n FROM %(grid)s\r\n GROUP BY ZONE_ID) AS t\r\n WHERE g.ZONE_ID = t.ZONE_ID\r\n \"\"\" % {'grid':gridcells_table_name})","def test_make_pop(self, pop_size, cell_number, microcell_number):\n for i in [0, 1]:\n pe.Parameters.instance().use_ages = i\n # Population is initialised with no households\n pop_params = {\"population_size\": pop_size,\n \"cell_number\": cell_number,\n \"microcell_number\": microcell_number}\n test_pop = ToyPopulationFactory.make_pop(pop_params)\n\n total_people = 0\n count_non_empty_cells = 0\n for cell in test_pop.cells:\n for microcell in cell.microcells:\n total_people += len(microcell.persons)\n if len(cell.persons) > 0:\n count_non_empty_cells += 1\n # Test there is at least one non-empty cell\n self.assertTrue(count_non_empty_cells >= 1)\n # Test that everyone in the population has been assigned a\n # microcell\n self.assertEqual(total_people, pop_size)\n\n # Test a population class object is returned\n self.assertIsInstance(test_pop, pe.Population)","def test_city_country_population(self):\n \tdublin_ireland = city_country('dublin', 'ireland', population=500000)\n \tself.assertEqual(dublin_ireland, 'Dublin, Ireland - Population 500000')","def test_create_population():\n pop = Population()\n assert len(pop.population) == POPULATION_SIZE\n assert isinstance(pop.population[0], Individual)","def read_population_assignation(namefile):\n db = shelve.open(namefile)\n hashes = db['hashes']\n key_firms = db['nif']\n year = db['year']\n population_value = db['population']\n methodvalues = db['methodvalues']\n db.close()\n return hashes, key_firms, year, population_value, methodvalues","def winningTeamPenalty(r):\n \n #Check if home or away had more goals at the 'event' time\n homecheck = int(r['about.goals.home'] > r['about.goals.away'])\n awaycheck = int(r['about.goals.away'] > r['about.goals.home'])\n \n #If home had more goals and the penalty was on the home team, set to 1\n if (homecheck > 0) and (r['against.homeTeam'] == 1):\n return 1\n #If away had more and the penalty was not on home team, set to 1\n if (awaycheck > 0) and (r['against.homeTeam'] == 0):\n return 1\n #Any other situation should be a zero in this column\n else:\n return 0","def load_population_data():\n return pd.read_csv(os.path.join('data', 'processed', 'worldometer_data.csv'),\n usecols = ['Country/Region','Population'])","def compare_bachelors_1980(data):\n d = data[(data['Year'] == 1980) & (data['Min degree'] == 'bachelor\\'s')]\\\n .groupby(['Sex'])['Total'].sum().loc[['M', 'F']]\n return (d[0], d[1])","def evaluateAll(population: list):\n worst = 0\n best = sys.maxsize\n sum = 0\n probabilites = []\n for i in range(len(population)):\n eval = population[i][1]\n if eval > worst:\n worst = eval\n if eval < best:\n best = eval\n for j in range(len(population)):\n fitness = updateFitness(population[j], worst)\n sum += fitness\n for k in range(len(population)):\n prob = updateProb(population[k], sum)\n probabilites.append(prob)\n\n print(\"worst chromosome makespan:\", worst, \"best chromosome makespan:\",best,file=out_file)\n return probabilites","def find_population(self, x, pops):\n M = sum([len(pops[pop]) for pop in pops])\n N = len(x)\n\n survival_values = []\n intersections = []\n lens = []\n\n rsv, rpop, rk = 2, -1, 0\n\n for pop in pops:\n n = len(pops[pop])\n intersec = np.intersect1d(x, pops[pop])\n k = len(intersec)\n sv = hypergeom.sf(k-1, M=M, n=n, N=N) if k > 0 else 1\n\n survival_values.append(sv)\n intersections.append(intersec)\n lens.append(len(pops[pop]))\n\n if sv <= rsv or (rsv == 2 and k > 0):\n rsv, rpop, rk = sv, pop, k\n\n all_pops = {'svs': np.array(survival_values),\n 'intersecs': np.array(intersections),\n 'lens': np.array(lens)}\n\n if rk == 0: # in case of no intersection, return -1\n return \"None\", 1, np.array([]), 0, all_pops\n else:\n return rpop, rsv, np.intersect1d(x, pops[rpop]), len(pops[rpop]), all_pops","def test_choropleth_pass():\n m = view(world, column=\"pop_est\")","def getPopulation(self):\n\n return self.population","def test_if_households(self, pop_size, cell_number, microcell_number,\n household_number):\n\n # Initialises population with households\n pop_params = {\"population_size\": pop_size, \"cell_number\": cell_number,\n \"microcell_number\": microcell_number,\n \"household_number\": household_number}\n toy_pop = ToyPopulationFactory.make_pop(pop_params)\n total_people = 0\n households = []\n num_empty_households = 0\n for cell in toy_pop.cells:\n for microcell in cell.microcells:\n for person in microcell.persons:\n if person.household not in households:\n households.append(person.household)\n if len(person.household.persons) == 0:\n num_empty_households += 1\n total_people += len(person.household.persons)\n # Some households may be empty so won't be included\n total_households = cell_number * microcell_number \\\n * household_number\n self.assertTrue(len(households) <= total_households)\n self.assertTrue(num_empty_households < total_households)","def get_testing_pop(agegroup_strata: List[str], country: Country, pop: Population):\n testing_region = \"Victoria\" if country.iso3 == \"AUS\" else pop.region\n testing_year = 2020 if country.iso3 == \"AUS\" else pop.year\n testing_pop = inputs.get_population_by_agegroup(\n agegroup_strata, country.iso3, testing_region, year=testing_year\n )\n return testing_pop, testing_region","def test_gross_income(self):\n self.assertEqual(\n self.forecast.gross_income,\n self.person1.gross_income + self.person2.gross_income)","def tirageR1(self):\n\n proba = np.zeros(shape=(3))\n proba[0] = self.__alpha0 + self.__beta + self.__eta/2.\n proba[1] = self.__alpha1 + self.__beta + self.__eta/2.\n proba[2] = 1. - (proba[0]+proba[1])\n # typeSample = np.random.choice(a=['0.', '1.', 'F'], size=1, p=proba)[0]\n typeSample = random.choices(population=['0.', '1.', 'F'], weights=proba)[0]\n if typeSample != 'F':\n r1 = float(typeSample)\n else:\n r1 = self.__rv_parab.rvs()\n\n return r1","def calc_population(self, vars_int, vars_float, problem_results, components=None):\n n_pop = problem_results[\"n_pop\"].values\n n_states = problem_results[\"n_org_states\"].values\n n_turbines = problem_results.dims[FC.TURBINE]\n data = (\n problem_results[self.variable]\n .to_numpy()\n .reshape(n_pop, n_states, n_turbines)\n )\n data = xr.DataArray(data, dims=(FC.POP, FC.STATE, FC.TURBINE))\n\n if self.n_sel_turbines < self.farm.n_turbines:\n data = data[:, self.sel_turbines]\n\n return self._contract(data / self.scale).to_numpy()[:, None]","def test_getTotalIndividualCount(self):\r\n # Verified with iNEXT.\r\n self.assertEqual(self.est1.getTotalIndividualCount(), 15)\r\n\r\n # Verified against results in Colwell 2012 paper.\r\n self.assertEqual(self.est2.getTotalIndividualCount(), 976)\r\n self.assertEqual(self.est3.getTotalIndividualCount(), 237)","def point_occupancy(isotherm, pressure):\n\n indx = np.where(isotherm['pressure'] >= pressure)[0][0]\n\n return isotherm['occ_sum'][indx]","def _add_PERC1(self, w2, row):\n if 'PASS' not in row:\n return False\n if 'EQ' not in row:\n return False\n if row['PASS']:\n row['PERC1'] = 100.0 * row['EQ'] / row['PASS']\n else:\n row['PERC1'] = 0.0\n return True","def testNumberIndividuals(self):\n self.assertEqual(557, self.tree.get_number_individuals(community_reference=1))","def population():\n pop_csv = pd.read_csv(csv_path(\"Population.csv\"),\n index_col=0,\n dtype={\"Population\": np.uint32})\n pop_csv[\"Population\"] = (pop_csv[\"Population\"] * POPULATION_SCALE).astype(\"uint32\")\n return pop_csv","def population_print(population, value):\n increase_amount = population_increase(population)\n decrease_amount = population_decrease(population)\n print(\"{0} gophers were born. {1} died.\".format(int(increase_amount), int(decrease_amount)))\n population = population + int(increase_amount) - int(decrease_amount)\n print(\"Population: {0}\".format(int(population)))\n print(\"Year {0}\\n\".format(value))","def test_non_zero_sum_profile_welfare():\n game = matgame.matgame([[[3.5, 2.5]]])\n assert np.isclose(\n regret.pure_social_welfare(game, [1, 1]), 6\n ), \"didn't properly sum welfare\"","def count_gold(pyramid):\n\n #replace this for solution\n return 0","def grade(population, targetSum, targetProduct):\n summed = reduce (add,(fitness(x, targetSum, targetProduct) for x in population), 0 )\n return summed / len(population)","def pct_bust(data):\n return round((data[\"new_total\"] > 21).sum() / len(data), 3)","def percentage_40(set_):\n db = TinyDB(CARD_DATA_FILE)\n card_data = db.table('card_data')\n total = card_data.count(where('set') == set_)\n q = Query()\n num_forties = card_data.count((q.set == set_) & (q.commons == 4) & (q.rares == 1))\n\n print(num_forties/total)","def prob(self, event_details):\n color_count_probs = event_details.color_count_probs(self.prob_tier)\n return color_count_probs.loc[\n (\n color_count_probs.index >= tuple(self.stone_summons.values)\n ).all(axis=1)\n & (\n color_count_probs.index * tuple(1 - self.stone_presences.values)\n <= tuple(self.stone_summons.values)\n ).all(axis=1)\n ].sum()","def grade_inst(inst, population):\n \n # Initialize to keep track of score \n inst_score = 0\n \n # Battle against each instance in population\n for i in range(len(population)):\n battle_result = inst.battle(population[i])\n inst_score += battle_result[0]\n \n # Also record the score in the instance\n inst.set_score(inst_score)\n\n return inst_score","def testNumberIndividualsAddsUp(self):\n number = sum([x[1] for x in self.tree.get_species_abundances(reference=3)])\n number2 = sum([x[1] for x in self.tree.get_species_abundances(reference=3)])\n self.assertEqual(number, 3734)\n self.assertEqual(number2, 3734)","def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\n x_bar = cls.get_mean(data1_)\n y_bar = cls.get_mean(data2_)\n var_x = cls.get_var(data1_, is_population=True)\n var_y = cls.get_var(data2_, is_population=True)\n n_x = cls.get_n(data1_)\n n_y = cls.get_n(data2_)\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)","def _individual_pension_insurance(self, total_salary, month=None, year=None):\n individual_pension_insurance = 0\n\n pension_max_fee = self.pension_max_fee\n # special case in 2018\n if year == 2018:\n if month <= 2:\n pension_max_fee = self.old_pension_max_fee\n #end if\n #end if\n\n if total_salary > pension_max_fee:\n individual_pension_insurance = pension_max_fee \\\n * self.individual_pension_insurance_rate\n else:\n individual_pension_insurance = total_salary \\\n * self.individual_pension_insurance_rate\n #end if\n return individual_pension_insurance","def get_pop(api_key, year = str(), map = bool()):\n try:\n year = year\n pop_url = f'http://api.census.gov/data/{year}/pep/population?get=POP&for=state:*&key={api_key}'\n r = requests.get(pop_url)\n data = json.loads(r.content) \n pop_df = pd.DataFrame(data[1:], columns=data[0]).\\\n rename(columns={\"POP\": \"Pop_Count\", \"state\": \"STATEFP\"})\n pop_df['Pop_Count'] = pop_df['Pop_Count'].astype(str).astype(int)\n geodata_url = f\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/state.json\"\n geo_df = gpd.read_file(geodata_url)\n geo_df = geo_df.merge(pop_df, on = 'STATEFP')\n if map == True:\n return geo_df.plot(column = 'Pop_Count')\n else:\n return geo_df\n r.raise_for_status()\n except HTTPError as http_err:\n print(f'HTTP error occurred: {http_err}')\n except Exception as err:\n print(f'An error occured. All parameters must exist in the Census GeoJSON database. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')","def getSalaryStat(self, year = 2014):\r\n year_str = str(year+1)\r\n \r\n df = pd.read_html('http://espn.go.com/nba/salaries/_/year/' + year_str)[0]\r\n df.columns = df.iloc[0]\r\n df = df[df.NAME != 'NAME']\r\n \r\n for page in range(2,12):\r\n page_df = pd.read_html('http://espn.go.com/nba/salaries/_/year/' + \\\r\n year_str + '/page/' + str(page))[0]\r\n page_df.columns = page_df.iloc[0]\r\n page_df = page_df[page_df.NAME != 'NAME']\r\n df = pd.concat([df, page_df])\r\n \r\n df['SALARY'] = df['SALARY'].replace('[\\$,]', '', regex=True).astype(int)\r\n cut_df = df[['NAME', 'SALARY']]\r\n cut_df = cut_df.reset_index(drop=True)\r\n cut_df.columns = [['PLAYER_NAME', 'SALARY']]\r\n \r\n salary_df = self.fixSalaryName(cut_df)\r\n \r\n return salary_df","def get_region_pop(api_key, year = str(), map = bool()):\n try:\n year = year\n pop_url = f'http://api.census.gov/data/{year}/pep/population?get=POP&for=REGION:*&key={api_key}'\n r = requests.get(pop_url)\n data = json.loads(r.content) \n pop_df = pd.DataFrame(data[1:], columns=data[0]).\\\n rename(columns={\"POP\": \"Pop_Count\", \"region\": \"REGIONCE\"})\n pop_df['Pop_Count'] = pop_df['Pop_Count'].astype(str).astype(int)\n geodata_url = f\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/region.json\"\n geo_df = gpd.read_file(geodata_url)\n geo_df = geo_df.merge(pop_df, on = 'REGIONCE')\n if map == True:\n return geo_df.plot(column = 'Pop_Count')\n else:\n return geo_df\n r.raise_for_status()\n except HTTPError as http_err:\n print(f'HTTP error occurred: {http_err}')\n except Exception as err:\n print(f'An error occured. All parameters must exist in the Census GeoJSON database and API. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')","def test_city_country_population(self):\n\t\tformatted_address = city_country(\n\t\t\t'santiago', 'chile', '5000000')\n\t\tself.assertEqual(formatted_address, \n\t\t\t'Santiago, Chile - Population 5000000')","def test_topo_current_occupants_positive():\n instance = topo.Topography()\n assert instance.current_occupants()[\"Herbivores\"] >= 0\\\n and instance.current_occupants()[\"Carnivores\"] >= 0","def total_occupancy_modifier(frame, data):\n\n occupancies = data.particles['Occupancy'][...]\n site_type = data.particles['Particle Type'][...]\n num_site_types = occupancies.shape[1] #Accessing the number of columns in the Occupancy matrix\n total_occupancy = np.sum(occupancies, axis=1) #Summing over all columns\n # NOTE By convention, the first half of types is Si, the second half is C\n is_si_site = site_type <= num_site_types//2\n is_c_site = site_type > num_site_types//2\n si_occupancy = np.sum(occupancies[:, :(num_site_types//2)], axis=1)\n c_occupancy = np.sum(occupancies[:, (num_site_types//2):], axis=1)\n data.particles_.create_property('Total Occupancy', data=total_occupancy.astype(int))\n data.particles_.create_property('Is Si Site', data=is_si_site.astype(int))\n data.particles_.create_property('Is C Site', data=is_c_site.astype(int))\n data.particles_.create_property('Si Occupancy', data=si_occupancy.astype(int))\n data.particles_.create_property('C Occupancy', data=c_occupancy.astype(int))","def showStats(population, masterList, index):\n count = 0\n if index == \"all\":\n for team in population:\n print (\"Team at index\", count)\n print(\"Tot Avg\", team.totAvg)\n print(\"Tot Runs\", team.totRuns)\n print(\"Tot HRs\", team.totHr)\n print(\"Tot RBIs\", team.totRbi)\n print(\"Tot SB\", team.totSb)\n print(\"Tot points\", team.points, '\\n')\n count += 1\n else:\n print(\"Team at index\", index)\n print(\"Tot Avg\", population[index].totAvg)\n print(\"Tot Runs\", population[index].totRuns)\n print(\"Tot HRs\", population[index].totHr)\n print(\"Tot RBIs\", population[0].totRbi)\n print(\"Tot SB\", population[0].totSb)\n print(\"Tot points\", population[0].points, '\\n')","def test_city_country_population(self):\n formatted_name = make_formatted_name('santiago', 'chile', 5000000)\n self.assertEqual(formatted_name, 'Santiago, Chile - population 5000000')","def was_pig_caught(prize):\n if prize > 20:\n return True\n return False","def testNumberIndividuals(self):\n self.assertEqual(self.tree.get_number_individuals(community_reference=1), 284)","def query_settlement_layer(grid):\n path = os.path.join(SHAPEFILE_DIR, f'{COUNTRY_ABBRV}.tif')\n\n grid['population'] = pd.DataFrame(\n zonal_stats(vectors=grid['geometry'], raster=path, stats='sum'))['sum']\n\n grid = grid.replace([np.inf, -np.inf], np.nan)\n\n return grid","def get_num_railroads_owned(self, player_name):\n total = 0\n if self.get_owner(\"Reading Railroad\") == player_name:\n total += 1\n if self.get_owner(\"Pennsylvania Railroad\") == player_name:\n total += 1\n if self.get_owner(\"B. & O. Railroad\") == player_name:\n total += 1\n if self.get_owner(\"Short Line\") == player_name:\n total += 1\n return total","def sample(self):\n # Convert year from number to string (i.e. -1200 to 1200BC)\n year = self.world.year()\n if year < 0:\n year = str(year)[1:] + 'BC'\n elif year == 0:\n year = '0'\n elif year > 0:\n year = str(year) + 'AD'\n # Only sample when we are at a valid year\n if year not in self.years:\n return\n\n # retrieve list of occupied tile coordinates\n occupied = self.occupied[year]\n\n # Sum the number of polities in the historical extent of the empire,\n # and their sizes\n included_polities = []\n n_polities = 0\n polity_sizes = []\n for coordinates in occupied:\n tile = self.world.index(coordinates[0], coordinates[1])\n # Skip desert tiles included in the extent of the empire\n if not tile.terrain.polity_forming:\n continue\n polity = tile.polity\n # Ensure polities are not doubly counted if they possess more than\n # one community in the extent of the empire\n if polity in included_polities:\n continue\n included_polities.append(polity)\n n_polities += 1\n polity_sizes.append(polity.size())\n\n self.n_polities[year] = n_polities\n self.polity_sizes[year] = polity_sizes","def pon(self):\n return self.table[1, 1] / (self.table[0, 1] + self.table[1, 1])","def testNumberIndividuals(self):\n self.assertEqual(396, self.tree2.get_number_individuals(community_reference=1))\n self.assertEqual(9549, self.tree.get_number_individuals(community_reference=1))","def combined_crude_rate(total_incidence, grouped_populations):\n grouped_population = list(map(sum, zip(*grouped_populations)))\n crude = list(map(lambda incidence: (incidence/grouped_population)*100000,\n total_incidence))\n combined_crude = pd.DataFrame((sum(crude)))\n return combined_crude","def define_geotype(x):\n if x['population_km2'] > 2000:\n return 'urban'\n elif x['population_km2'] > 1500:\n return 'suburban 1'\n elif x['population_km2'] > 1000:\n return 'suburban 2'\n elif x['population_km2'] > 500:\n return 'rural 1'\n elif x['population_km2'] > 100:\n return 'rural 2'\n elif x['population_km2'] > 50:\n return 'rural 3'\n elif x['population_km2'] > 10:\n return 'rural 4'\n else:\n return 'rural 5'","def get_country_percentage(db, percent):\n # Hint: Use get_total_stateless(db)[0][0] to get the total population\n # total_population = get_total_stateless(db)[0][0]\n # percent = (percent / 100)\n pass","def compute_tot_fitness(fitness_function, pop):\n probs = np.zeros(len(pop)) # list to house probabilites\n best_member = ''\n best_fitness = -10**18\n total_fitness = 0 # The sum of of all the fitness values from the population.\n for i, chromosome in enumerate(pop):\n new_fitness = fitness_function(chromosome)\n if new_fitness > best_fitness:\n best_member = chromosome\n best_fitness = new_fitness\n total_fitness += new_fitness\n probs[i] = new_fitness\n probs = probs / total_fitness\n return total_fitness, best_fitness, best_member, probs"],"string":"[\n \"def test_county(self):\\n counties = self.geographies.find({ 'geoid': '15009' })\\n\\n self.assertEqual(counties.count(), 1)\\n\\n county = counties[0]\\n\\n self.assertEqual(county['sumlev'], config.SUMLEV_COUNTY)\\n self.assertEqual(county['metadata']['NAME'], 'Maui County')\\n self.assertEqual(county['metadata']['STATE'], '15')\\n self.assertEqual(county['metadata']['COUNTY'], '009')\\n\\n pop_2000 = 128094 \\n pop_2010 = 154834\\n self._test_totalpop(county, pop_2000, pop_2010)\",\n \"def relative_population(data, population, ageclass):\\n total_pop = data[population].sum(axis=0)\\n data['rel_pop'] = (data[population]/total_pop)*100000\\n relative_pop = data.pivot(columns=ageclass, values='rel_pop').sum(axis=0)\\n return relative_pop\",\n \"def c_test_population_function(self, function):\\r\\n return 1\",\n \"def test_place(self):\\n places = self.geographies.find({ 'geoid': '1562600' })\\n\\n self.assertEqual(places.count(), 1)\\n\\n place = places[0]\\n\\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\\n self.assertEqual(place['metadata']['STATE'], '15')\\n self.assertEqual(place['metadata']['PLACE'], '62600')\\n\\n pop_2000 = 30976\\n pop_2010 = 47698 \\n self._test_totalpop(place, pop_2000, pop_2010)\",\n \"def test_census_county_population():\\n dataframe = get_county_population_dataframe()\\n boulder_county_row = dataframe.loc[dataframe['county_fips'] == 8013]\\n boulder_county_population = boulder_county_row.get('county_population')\\n assert float(boulder_county_population) == 326196\",\n \"def __population_quality(self) -> float:\\n population_identifier = np.zeros(shape=self.Dataset.size)\\n subgroup_identifier = np.ones(shape=len(self.get_cover()))\\n group = np.concatenate((population_identifier,\\n subgroup_identifier))\\n\\n subgroup_times = self.Dataset.survival[self.get_cover()]\\n subgroup_status = self.Dataset.status[self.get_cover()]\\n\\n time = np.concatenate((self.Dataset.survival, subgroup_times))\\n status = np.concatenate((self.Dataset.status, subgroup_status))\\n\\n _, pvalue = sm.duration.survdiff(time, status, group)\\n return 1 - pvalue\",\n \"def large_p1_gap(self, row, name):\\n all_pops = sorted(self.name_pops[name], reverse=True)\\n pop = row.population or 0\\n return pop - sum(all_pops[1:]) > self.min_p1_gap\",\n \"def cr_check_population_availability(unit_id, table):\\n\\n T = current.T\\n tablename = table._tablename\\n\\n if tablename == \\\"cr_shelter\\\":\\n query = (table.site_id == site_id)\\n #elif tablename == \\\"cr_shelter_unit\\\":\\n else:\\n query = (table.id == unit_id)\\n\\n record = current.db(query).select(table.capacity_day,\\n table.population_day,\\n table.capacity_night,\\n table.population_night,\\n limitby = (0, 1),\\n ).first()\\n\\n day_and_night = current.deployment_settings.get_cr_day_and_night()\\n\\n warning = None\\n full_day = full_night = False\\n\\n capacity_day = record.capacity_day\\n population_day = record.population_day\\n if capacity_day is not None and \\\\\\n population_day and \\\\\\n population_day >= capacity_day:\\n full_day = True\\n\\n if day_and_night:\\n capacity_night = record.capacity_night\\n population_night = record.population_night\\n if capacity_night is not None and \\\\\\n population_night and \\\\\\n population_night >= capacity_night:\\n full_night = True\\n\\n if not day_and_night and full_day or full_day and full_night:\\n if tablename == \\\"cr_shelter\\\":\\n warning = T(\\\"Warning: this shelter is full\\\")\\n elif tablename == \\\"cr_shelter_unit\\\":\\n warning = T(\\\"Warning: this housing unit is full\\\")\\n elif full_day:\\n if tablename == \\\"cr_shelter\\\":\\n warning = T(\\\"Warning: this shelter is full for daytime\\\")\\n elif tablename == \\\"cr_shelter_unit\\\":\\n warning = T(\\\"Warning: this housing unit is full for daytime\\\")\\n elif full_night:\\n if tablename == \\\"cr_shelter\\\":\\n warning = T(\\\"Warning: this shelter is full for the night\\\")\\n elif tablename == \\\"cr_shelter_unit\\\":\\n warning = T(\\\"Warning: this housing unit is full for the night\\\")\\n\\n if warning:\\n response = current.response\\n response_warning = response.warning\\n if response_warning:\\n response.warning = \\\"%s - %s\\\" % (response_warning, warning)\\n else:\\n response.warning = warning\",\n \"def test_nulls_for_year(year, state, conn):\\n percent_nulls = pd.read_sql_query(f\\\"\\\"\\\"SELECT\\n 100.0 * count(total_prison_pop) / count(1) as PercentNotNull\\n FROM\\n incarceration\\n WHERE state = '{state}'\\n AND year = {year};\\n \\\"\\\"\\\", conn)\\n return percent_nulls\",\n \"def test_state(self):\\n states = self.geographies.find({ 'geoid': config.SUMLEV_STATE })\\n\\n self.assertEqual(states.count(), 1)\\n\\n state = states[0]\\n\\n self.assertEqual(state['sumlev'], config.SUMLEV_STATE)\\n self.assertEqual(state['metadata']['NAME'], 'Hawaii')\\n self.assertEqual(state['metadata']['STATE'], '15')\\n\\n pop_2000 = 1211537\\n pop_2010 = 1360301\\n self._test_totalpop(state, pop_2000, pop_2010)\",\n \"def test_county_subdivision(self):\\n counties = self.geographies.find({ 'geoid': '1500190630' })\\n\\n self.assertEqual(counties.count(), 1)\\n\\n county = counties[0]\\n\\n self.assertEqual(county['sumlev'], config.SUMLEV_COUNTY_SUBDIVISION)\\n self.assertEqual(county['metadata']['NAME'], 'Hilo CCD')\\n self.assertEqual(county['metadata']['STATE'], '15')\\n self.assertEqual(county['metadata']['COUNTY'], '001')\\n\\n pop_2000 = 42425 \\n pop_2010 = 45714 \\n self._test_totalpop(county, pop_2000, pop_2010)\",\n \"def get_population_by_race_columns():\\n return {\\n 'DP05_0070E': 'Population (Total)',\\n 'DP05_0071E': 'Population (Hispanic or Latino)',\\n 'DP05_0077E': 'Population (White alone, Non-Hispanic)',\\n 'DP05_0078E': 'Population (Black or African American alone, Non-Hispanic)',\\n 'DP05_0080E': 'Population (Asian alone, Non-Hispanic)',\\n\\n # These will be grouped into an \\\"Other\\\" category\\n 'DP05_0079E': 'Population (American Indian and Alaska Native alone, Non-Hispanic)',\\n 'DP05_0081E': 'Population (Native Hawaiian and Other Pacific Islander alone, Non-Hispanic)',\\n 'DP05_0082E': 'Population (Some other race alone, Non-Hispanic)',\\n 'DP05_0083E': 'Population (Two or more races, Non-Hispanic)'\\n }\",\n \"def check_file_complete(state):\\r\\n\\t# pull in ref file for synth pop\\r\\n\\tpath = '/ihme/scratch/users/beatrixh/decennial_census_2010/{}_decennial_2010/{}2010ur1_all_vars.CSV'.format(state,state)\\r\\n\\tusecols = location_cols + ['P0010001']\\r\\n\\tdf = pd.read_csv(path, usecols=usecols)\\r\\n\\tdf = df[df.BLOCK.notna()]\\r\\n\\r\\n\\t# get state pop totals\\r\\n\\tref = pd.read_csv('/ihme/scratch/users/beatrixh/us_state_pop_2010_decennial.csv')\\r\\n\\tdif = ref[ref.state==state].pop_count.values[0] - df.P0010001.sum()\\r\\n\\tif dif > 0:\\r\\n\\t\\tprint(\\\"{} pop total is off by {}\\\".format(state, dif))\\r\\n\\treturn dif\",\n \"def globalpopulation():\\n startdate = datetime.datetime.now()\\n enddate = startdate - datetime.timedelta(days=30)\\n q = db.session.query(\\n func.avg(PopSnap.popcount),\\n func.strftime('%H', PopSnap.time)\\n ).filter(\\n PopSnap.time <= startdate,\\n PopSnap.time >= enddate\\n ).group_by(func.strftime('%H', PopSnap.time)).all()\\n counts = [el[0] for el in q] # first piece of each grouped result\\n hours = [el[1] for el in q] # second piece of each grouped result\\n return render_template('populationstats.html', counts=counts, hours=hours)\",\n \"def test_block_sum(self):\\n blocks = self.geographies.find({ 'sumlev': config.SUMLEV_BLOCK })\\n\\n pop_2010 = sum([int(block['data']['2010']['P1']['P001001']) for block in blocks])\\n\\n self.assertEqual(pop_2010, 1360301)\",\n \"def getStats(population, masterList):\\n for team in population:\\n for i in range(13): #13 are the number of roster spots?\\n team.totHr += masterList[team.roster[i]].hr\\n team.totAvg += masterList[team.roster[i]].avg\\n team.totRuns += masterList[team.roster[i]].runs\\n team.totSb += masterList[team.roster[i]].sb\\n team.totRbi += masterList[team.roster[i]].rbi\\n if i == 12:\\n team.totAvg = team.totAvg / 13\\n return population\",\n \"def total_population(self):\\n return self._total_population\",\n \"def total_population(self):\\n return self._total_population\",\n \"def test_one_pop(data_: tuple, _is_pop: bool):\\n x_bar = cls.get_mean(data_)\\n s_x = cls.get_stdev(data_, is_population=_is_pop)\\n n_x = cls.get_n(data_)\\n return (x_bar - h0) / (s_x / sqrt(n_x))\",\n \"def gopher_population_modifier(current_population):\\n births = int(current_population * (randrange(10, 21) / 100))\\n deaths = int(current_population * (randrange(5, 26) / 100))\\n new_population = current_population + births - deaths\\n print(\\\"{} gophers were born :) {} gophers died :(\\\\nTotal gopher population : {}\\\\n\\\".format\\n (births, deaths, new_population))\\n return new_population\",\n \"def get_population_count(data_path:str, roi):\\n try: # open population file\\n df_pop = pd.read_csv(data_path / 'population_estimates.csv')\\n except:\\n print(\\\"Missing population_estimates.csv in data-path\\\")\\n\\n try:\\n population = df_pop.query('roi == \\\"{}\\\"'.format(roi))['population'].values\\n except:\\n print(\\\"{} population estimate not found in population_estimates.csv\\\".format(args.roi))\\n\\n return int(population)\",\n \"def isIndividualInPopulation(self, individual, population):\\n\\t\\tfor i in population:\\n\\t\\t\\tif i == individual:\\n\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def check_how_much_to_paid(self, cells_number):\\n if len(self.owner.countries[self.section]) == 2:\\n return 10 * cells_number * 10000\\n return 4 * cells_number * 10000\",\n \"def average_population_grade(population):\\r\\n total = 0\\r\\n for individual in population :\\r\\n total += get_individual_fitness(individual)\\r\\n return total/POPULATION_COUNT\",\n \"def current_world_population(self, option='total'):\\n if option.lower() == 'total':\\n return int(Worldometers.soup.find(id='cp1').getText().replace(',', ''))\\n \\n elif option.lower() == 'male':\\n return int(Worldometers.soup.find(id='cp2').getText().replace(',', ''))\\n \\n elif option.lower() == 'female':\\n return int(Worldometers.soup.find(id='cp3').getText().replace(',', ''))\",\n \"def get_area_population(area=None):\\n pop_dict = get_region_pop_dict()\\n try:\\n population = pop_dict[area]\\n except KeyError:\\n population = sum([v for v in pop_dict.values()])\\n return population\",\n \"def total_population(self):\\n total_population_list = []\\n for y in self.island_map:\\n for cell in y:\\n total_population_list += cell.population\\n return total_population_list\",\n \"def population(self):\\n return self._population\",\n \"def label_genres(row):\\n\\n if row[\\\"Price\\\"] < genres_mean.loc[(row[\\\"affordability\\\"], row[\\\"genre_count\\\"])]:\\n return 1\\n else:\\n return 0\",\n \"def prob4(file='crime_data.csv'):\\n #Get the data\\n df = pd.read_csv(file)\\n df = df.set_index('Year')\\n \\n #Create a new column rate\\n df['Rate'] = df['Total']/df['Population']\\n vil_avg = df['Violent'].mean()\\n \\n #Create masks and get the murders for those years\\n mask1 = df['Rate'] > .05\\n mask2 = df['Violent'] > vil_avg\\n murder_tracker = df[mask1][mask2][['Murder']]\\n ans = murder_tracker.values\\n ans = ans.squeeze()\\n return(ans)\\n #raise NotImplementedError(\\\"Problem 4 Incomplete\\\")\",\n \"def get_population(self):\\n population = 0\\n for i in self:\\n population += i.count(self.cell_state['alive'])\\n return population\",\n \"def get_population_for_health_board(health_board_to_council: pd.DataFrame,\\r\\n council_areas: pd.DataFrame) -> pd.Series:\\r\\n population_health_boards = {}\\r\\n for health_board, councils in health_board_to_council.iterrows():\\r\\n population_total = 0\\r\\n for council in councils:\\r\\n if council is not None:\\r\\n population_total += int(council_areas.loc[council][1])\\r\\n population_health_boards[health_board] = population_total\\r\\n return pd.Series(population_health_boards, name='Population mid 2018 ONS estimate')\",\n \"def test_population_bioequivalence():\\n\\n # See 10.3 Example from Chow et al.\\n h = Population(l=-0.2966, stdev_11=0.2, stdev_tt=math.sqrt(0.17),\\n stdev_tr=math.sqrt(0.17), stdev_bt=0.4, stdev_br=0.4,\\n rho=0.75, alpha=0.05, power=0.8)\\n h.calculate()\\n assert h.n == 12\",\n \"def roulette(total_fitness, population):\\n pie_slice = random.random() * total_fitness\\n fitness_so_far = 0.0\\n\\n for i in range(len(population)):\\n fitness_so_far += population[i].fitness\\n\\n if fitness_so_far >= pie_slice:\\n return population[i]\\n return None\",\n \"def mda_population_calculations(sender, instance=None, **kwargs):\\n eligible_field = \\\"_population_eligible\\\"\\n treatment_field = \\\"_population_treatment\\\"\\n persons_field = \\\"sprayable/anotherperson\\\"\\n if instance.data and eligible_field not in instance.data:\\n instance.data[eligible_field] = 0\\n instance.data[treatment_field] = 0\\n if persons_field in instance.data:\\n for person in instance.data[persons_field]:\\n if person.get(\\\"{}/eligible\\\".format(persons_field)) == \\\"yes\\\":\\n instance.data[eligible_field] += 1\\n treatment = person.get(\\n \\\"{}/treatment\\\".format(persons_field)\\n )\\n if treatment == \\\"received\\\":\\n instance.data[treatment_field] += 1\",\n \"def passing_grade(row):\\n if row['Combine'] >= 70.0:\\n return 1\\n else:\\n return 0\",\n \"def verify_aggPercPrimTreatment(self):\\n self.c.execute('''SELECT aggCode, (aggC2*aggGenerated/100)\\n FROM Agglomerations\\n WHERE (aggC2*aggGenerated/100) >= 2000 \\n AND aggPercPrimTreatment IS NULL OR aggPercPrimTreatment = \\\"\\\"\\n ''')\\n res = self.c.fetchall()\\n if (len(res) > 0):\\n return [False,\\n \\\"In the agglomeration '%s' aggPercPrimTreatment must be reported since the generated load is '%s'\\\",\\n res]\\n else:\\n return [True]\",\n \"def test_calculates_risk_points_with_one_mortgaged_house(self):\\n\\n self.user[\\\"houses\\\"] = [{\\n \\\"id\\\": 1,\\n \\\"ownership_status\\\": \\\"mortgaged\\\"\\n }]\\n\\n self.risk_profile[\\\"home\\\"] = [{\\n \\\"id\\\": 1,\\n \\\"is_eligible\\\": True,\\n \\\"risk_points\\\": 1\\n }]\\n\\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\\n\\n self.assertEquals(self.risk_profile[\\\"home\\\"][0][\\\"risk_points\\\"], 3)\\n self.assertEquals(self.risk_profile[\\\"disability\\\"][\\\"risk_points\\\"], 2)\",\n \"def population_projection(self):\\n population_projection = Worldometers.soup.find_all(class_='years')[1]\\n year_rows = population_projection.find_all('tr')\\n\\n population_projection_dict = {}\\n for x in range(1, len(year_rows)):\\n columns = year_rows[x].find_all('td')\\n population_projection_dict[x-1] = {\\n 'year': columns[0].getText().replace(',', ''),\\n 'population': columns[1].getText().replace(',', ''),\\n 'growth': columns[2].getText().replace(' %', '')\\n }\\n\\n return population_projection_dict\",\n \"def prob4():\\n#pass\\n n_men = 0\\n n_women = 0\\n db = sql.connect('sql2')\\n cur = db.cursor()\\n cur.execute(\\\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\\\")\\n for gen in cur :\\n if gen[0] == 'M' :\\n n_men += 1\\n else :\\n n_women += 1\\n db.close()\\n return n_men,n_women\",\n \"def all(fill_nan=True):\\n df = population().merge(codemap(), left_index=True, right_on='Name')\\n df = df[df.Population > MIN_POPULATION * POPULATION_SCALE]\\n df.columns = [\\\"Population\\\", \\\"Code\\\", \\\"FullName\\\"]\\n for g in map(lambda e: e().merge(codemap(), left_index=True, right_on='Name'),\\n [employment, conflict, fertility, gdp]):\\n df = df.merge(g, on='Code', how='left')\\n df = df.merge(neighbors(), how='left', on='Code')\\n df = df.set_index([\\\"Code\\\"])\\n df = df[COUNTRY_COLS]\\n df = df.sort_values(\\\"FullName\\\")\\n if not fill_nan:\\n return df\\n # Some countries are missing data. We will guess this data using that of\\n # neighboring countries.\\n missing_cols = [\\\"Conflict\\\", \\\"Unemployment\\\", \\\"GDP\\\", \\\"Fertility\\\"]\\n for _ in range(2):\\n for column in missing_cols:\\n for item, frame in df[df[column].isnull()][\\\"neighbors\\\"].iteritems():\\n df.set_value(item, column, df[df.index.isin(frame)][column].mean())\\n return df\",\n \"def test_calculates_risk_points_with_mortgaged_house(self):\\n\\n self.user[\\\"houses\\\"].insert(0, {\\n \\\"id\\\": 123,\\n \\\"ownership_status\\\": \\\"mortgaged\\\"\\n })\\n\\n self.risk_profile[\\\"home\\\"].insert(0, {\\n \\\"id\\\": 123,\\n \\\"is_eligible\\\": True,\\n \\\"risk_points\\\": 1\\n })\\n\\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\\n\\n for house in self.risk_profile[\\\"home\\\"]:\\n if house[\\\"id\\\"] == 123:\\n self.assertEquals(house[\\\"risk_points\\\"], 2)\\n else: \\n self.assertEquals(house[\\\"risk_points\\\"], 1)\\n \\n self.assertEquals(self.risk_profile[\\\"disability\\\"][\\\"risk_points\\\"], 2)\",\n \"def getPopulation(self):\\n\\n return self.p\",\n \"def get_popsize(popsizes_df, location):\\n return popsizes_df.loc[popsizes_df['location'] == location]['population_size'].values[0]\",\n \"def test_simple_tract(self):\\n tracts = self.geographies.find({ 'geoid': '15007040500' })\\n\\n self.assertEqual(tracts.count(), 1)\\n\\n tract = tracts[0]\\n\\n self.assertEqual(tract['sumlev'], config.SUMLEV_TRACT)\\n self.assertEqual(tract['metadata']['NAME'], 'Census Tract 405')\\n self.assertEqual(tract['metadata']['STATE'], '15')\\n self.assertEqual(tract['metadata']['COUNTY'], '007')\\n\\n pop_2000 = 5162 \\n pop_2010 = 5943 \\n self._test_totalpop(tract, pop_2000, pop_2010)\",\n \"def grade(population, target_sum, target_mult):\\r\\n summed = reduce(add, (fitness(x, target_sum, target_mult) for x in population), 0)\\r\\n return summed / len(population)\",\n \"def get_perc_pop_vax(population, area=None):\\n tot_1st_admins = get_tot_admins(dtype=VAX_FIRST_DOSE_KEY, area=area)\\n tot_2nd_admins = get_tot_admins(dtype=VAX_SECOND_DOSE_KEY, area=area)\\n tot_3rd_admins = get_tot_admins(dtype=VAX_BOOSTER_DOSE_KEY, area=area)\\n return {\\n 'first': round(((int(tot_1st_admins) / population) * 100), 1),\\n 'second': round(((int(tot_2nd_admins) / population) * 100), 1),\\n 'booster': round(((int(tot_3rd_admins) / population) * 100), 1)\\n }\",\n \"def test_calculates_risk_points_with_one_house(self):\\n\\n self.calculates_risk_points_by_houses.execute(self.user, self.risk_profile)\\n\\n for house in self.risk_profile[\\\"home\\\"]:\\n self.assertEquals(house[\\\"risk_points\\\"], 2)\",\n \"def _get_building_type_proportion_by_zone(self, db, gridcells_table_name):\\r\\n return db.GetResultsFromQuery(\\r\\n \\\"\\\"\\\"SELECT GRID_ID, g.ZONE_ID, RESIDENTIAL_UNITS/RES_TOTAL AS RES, \\r\\n GOVERNMENTAL_SQFT/GOV_TOTAL AS GOV, \\r\\n COMMERCIAL_SQFT/COM_TOTAL AS COM, \\r\\n INDUSTRIAL_SQFT/IND_TOTAL AS IND\\r\\n FROM %(grid)s AS g, \\r\\n (SELECT ZONE_ID, \\r\\n SUM(RESIDENTIAL_UNITS) AS RES_TOTAL,\\r\\n SUM(GOVERNMENTAL_SQFT) AS GOV_TOTAL,\\r\\n SUM(COMMERCIAL_SQFT) AS COM_TOTAL,\\r\\n SUM(INDUSTRIAL_SQFT) AS IND_TOTAL \\r\\n FROM %(grid)s\\r\\n GROUP BY ZONE_ID) AS t\\r\\n WHERE g.ZONE_ID = t.ZONE_ID\\r\\n \\\"\\\"\\\" % {'grid':gridcells_table_name})\",\n \"def test_make_pop(self, pop_size, cell_number, microcell_number):\\n for i in [0, 1]:\\n pe.Parameters.instance().use_ages = i\\n # Population is initialised with no households\\n pop_params = {\\\"population_size\\\": pop_size,\\n \\\"cell_number\\\": cell_number,\\n \\\"microcell_number\\\": microcell_number}\\n test_pop = ToyPopulationFactory.make_pop(pop_params)\\n\\n total_people = 0\\n count_non_empty_cells = 0\\n for cell in test_pop.cells:\\n for microcell in cell.microcells:\\n total_people += len(microcell.persons)\\n if len(cell.persons) > 0:\\n count_non_empty_cells += 1\\n # Test there is at least one non-empty cell\\n self.assertTrue(count_non_empty_cells >= 1)\\n # Test that everyone in the population has been assigned a\\n # microcell\\n self.assertEqual(total_people, pop_size)\\n\\n # Test a population class object is returned\\n self.assertIsInstance(test_pop, pe.Population)\",\n \"def test_city_country_population(self):\\n \\tdublin_ireland = city_country('dublin', 'ireland', population=500000)\\n \\tself.assertEqual(dublin_ireland, 'Dublin, Ireland - Population 500000')\",\n \"def test_create_population():\\n pop = Population()\\n assert len(pop.population) == POPULATION_SIZE\\n assert isinstance(pop.population[0], Individual)\",\n \"def read_population_assignation(namefile):\\n db = shelve.open(namefile)\\n hashes = db['hashes']\\n key_firms = db['nif']\\n year = db['year']\\n population_value = db['population']\\n methodvalues = db['methodvalues']\\n db.close()\\n return hashes, key_firms, year, population_value, methodvalues\",\n \"def winningTeamPenalty(r):\\n \\n #Check if home or away had more goals at the 'event' time\\n homecheck = int(r['about.goals.home'] > r['about.goals.away'])\\n awaycheck = int(r['about.goals.away'] > r['about.goals.home'])\\n \\n #If home had more goals and the penalty was on the home team, set to 1\\n if (homecheck > 0) and (r['against.homeTeam'] == 1):\\n return 1\\n #If away had more and the penalty was not on home team, set to 1\\n if (awaycheck > 0) and (r['against.homeTeam'] == 0):\\n return 1\\n #Any other situation should be a zero in this column\\n else:\\n return 0\",\n \"def load_population_data():\\n return pd.read_csv(os.path.join('data', 'processed', 'worldometer_data.csv'),\\n usecols = ['Country/Region','Population'])\",\n \"def compare_bachelors_1980(data):\\n d = data[(data['Year'] == 1980) & (data['Min degree'] == 'bachelor\\\\'s')]\\\\\\n .groupby(['Sex'])['Total'].sum().loc[['M', 'F']]\\n return (d[0], d[1])\",\n \"def evaluateAll(population: list):\\n worst = 0\\n best = sys.maxsize\\n sum = 0\\n probabilites = []\\n for i in range(len(population)):\\n eval = population[i][1]\\n if eval > worst:\\n worst = eval\\n if eval < best:\\n best = eval\\n for j in range(len(population)):\\n fitness = updateFitness(population[j], worst)\\n sum += fitness\\n for k in range(len(population)):\\n prob = updateProb(population[k], sum)\\n probabilites.append(prob)\\n\\n print(\\\"worst chromosome makespan:\\\", worst, \\\"best chromosome makespan:\\\",best,file=out_file)\\n return probabilites\",\n \"def find_population(self, x, pops):\\n M = sum([len(pops[pop]) for pop in pops])\\n N = len(x)\\n\\n survival_values = []\\n intersections = []\\n lens = []\\n\\n rsv, rpop, rk = 2, -1, 0\\n\\n for pop in pops:\\n n = len(pops[pop])\\n intersec = np.intersect1d(x, pops[pop])\\n k = len(intersec)\\n sv = hypergeom.sf(k-1, M=M, n=n, N=N) if k > 0 else 1\\n\\n survival_values.append(sv)\\n intersections.append(intersec)\\n lens.append(len(pops[pop]))\\n\\n if sv <= rsv or (rsv == 2 and k > 0):\\n rsv, rpop, rk = sv, pop, k\\n\\n all_pops = {'svs': np.array(survival_values),\\n 'intersecs': np.array(intersections),\\n 'lens': np.array(lens)}\\n\\n if rk == 0: # in case of no intersection, return -1\\n return \\\"None\\\", 1, np.array([]), 0, all_pops\\n else:\\n return rpop, rsv, np.intersect1d(x, pops[rpop]), len(pops[rpop]), all_pops\",\n \"def test_choropleth_pass():\\n m = view(world, column=\\\"pop_est\\\")\",\n \"def getPopulation(self):\\n\\n return self.population\",\n \"def test_if_households(self, pop_size, cell_number, microcell_number,\\n household_number):\\n\\n # Initialises population with households\\n pop_params = {\\\"population_size\\\": pop_size, \\\"cell_number\\\": cell_number,\\n \\\"microcell_number\\\": microcell_number,\\n \\\"household_number\\\": household_number}\\n toy_pop = ToyPopulationFactory.make_pop(pop_params)\\n total_people = 0\\n households = []\\n num_empty_households = 0\\n for cell in toy_pop.cells:\\n for microcell in cell.microcells:\\n for person in microcell.persons:\\n if person.household not in households:\\n households.append(person.household)\\n if len(person.household.persons) == 0:\\n num_empty_households += 1\\n total_people += len(person.household.persons)\\n # Some households may be empty so won't be included\\n total_households = cell_number * microcell_number \\\\\\n * household_number\\n self.assertTrue(len(households) <= total_households)\\n self.assertTrue(num_empty_households < total_households)\",\n \"def get_testing_pop(agegroup_strata: List[str], country: Country, pop: Population):\\n testing_region = \\\"Victoria\\\" if country.iso3 == \\\"AUS\\\" else pop.region\\n testing_year = 2020 if country.iso3 == \\\"AUS\\\" else pop.year\\n testing_pop = inputs.get_population_by_agegroup(\\n agegroup_strata, country.iso3, testing_region, year=testing_year\\n )\\n return testing_pop, testing_region\",\n \"def test_gross_income(self):\\n self.assertEqual(\\n self.forecast.gross_income,\\n self.person1.gross_income + self.person2.gross_income)\",\n \"def tirageR1(self):\\n\\n proba = np.zeros(shape=(3))\\n proba[0] = self.__alpha0 + self.__beta + self.__eta/2.\\n proba[1] = self.__alpha1 + self.__beta + self.__eta/2.\\n proba[2] = 1. - (proba[0]+proba[1])\\n # typeSample = np.random.choice(a=['0.', '1.', 'F'], size=1, p=proba)[0]\\n typeSample = random.choices(population=['0.', '1.', 'F'], weights=proba)[0]\\n if typeSample != 'F':\\n r1 = float(typeSample)\\n else:\\n r1 = self.__rv_parab.rvs()\\n\\n return r1\",\n \"def calc_population(self, vars_int, vars_float, problem_results, components=None):\\n n_pop = problem_results[\\\"n_pop\\\"].values\\n n_states = problem_results[\\\"n_org_states\\\"].values\\n n_turbines = problem_results.dims[FC.TURBINE]\\n data = (\\n problem_results[self.variable]\\n .to_numpy()\\n .reshape(n_pop, n_states, n_turbines)\\n )\\n data = xr.DataArray(data, dims=(FC.POP, FC.STATE, FC.TURBINE))\\n\\n if self.n_sel_turbines < self.farm.n_turbines:\\n data = data[:, self.sel_turbines]\\n\\n return self._contract(data / self.scale).to_numpy()[:, None]\",\n \"def test_getTotalIndividualCount(self):\\r\\n # Verified with iNEXT.\\r\\n self.assertEqual(self.est1.getTotalIndividualCount(), 15)\\r\\n\\r\\n # Verified against results in Colwell 2012 paper.\\r\\n self.assertEqual(self.est2.getTotalIndividualCount(), 976)\\r\\n self.assertEqual(self.est3.getTotalIndividualCount(), 237)\",\n \"def point_occupancy(isotherm, pressure):\\n\\n indx = np.where(isotherm['pressure'] >= pressure)[0][0]\\n\\n return isotherm['occ_sum'][indx]\",\n \"def _add_PERC1(self, w2, row):\\n if 'PASS' not in row:\\n return False\\n if 'EQ' not in row:\\n return False\\n if row['PASS']:\\n row['PERC1'] = 100.0 * row['EQ'] / row['PASS']\\n else:\\n row['PERC1'] = 0.0\\n return True\",\n \"def testNumberIndividuals(self):\\n self.assertEqual(557, self.tree.get_number_individuals(community_reference=1))\",\n \"def population():\\n pop_csv = pd.read_csv(csv_path(\\\"Population.csv\\\"),\\n index_col=0,\\n dtype={\\\"Population\\\": np.uint32})\\n pop_csv[\\\"Population\\\"] = (pop_csv[\\\"Population\\\"] * POPULATION_SCALE).astype(\\\"uint32\\\")\\n return pop_csv\",\n \"def population_print(population, value):\\n increase_amount = population_increase(population)\\n decrease_amount = population_decrease(population)\\n print(\\\"{0} gophers were born. {1} died.\\\".format(int(increase_amount), int(decrease_amount)))\\n population = population + int(increase_amount) - int(decrease_amount)\\n print(\\\"Population: {0}\\\".format(int(population)))\\n print(\\\"Year {0}\\\\n\\\".format(value))\",\n \"def test_non_zero_sum_profile_welfare():\\n game = matgame.matgame([[[3.5, 2.5]]])\\n assert np.isclose(\\n regret.pure_social_welfare(game, [1, 1]), 6\\n ), \\\"didn't properly sum welfare\\\"\",\n \"def count_gold(pyramid):\\n\\n #replace this for solution\\n return 0\",\n \"def grade(population, targetSum, targetProduct):\\n summed = reduce (add,(fitness(x, targetSum, targetProduct) for x in population), 0 )\\n return summed / len(population)\",\n \"def pct_bust(data):\\n return round((data[\\\"new_total\\\"] > 21).sum() / len(data), 3)\",\n \"def percentage_40(set_):\\n db = TinyDB(CARD_DATA_FILE)\\n card_data = db.table('card_data')\\n total = card_data.count(where('set') == set_)\\n q = Query()\\n num_forties = card_data.count((q.set == set_) & (q.commons == 4) & (q.rares == 1))\\n\\n print(num_forties/total)\",\n \"def prob(self, event_details):\\n color_count_probs = event_details.color_count_probs(self.prob_tier)\\n return color_count_probs.loc[\\n (\\n color_count_probs.index >= tuple(self.stone_summons.values)\\n ).all(axis=1)\\n & (\\n color_count_probs.index * tuple(1 - self.stone_presences.values)\\n <= tuple(self.stone_summons.values)\\n ).all(axis=1)\\n ].sum()\",\n \"def grade_inst(inst, population):\\n \\n # Initialize to keep track of score \\n inst_score = 0\\n \\n # Battle against each instance in population\\n for i in range(len(population)):\\n battle_result = inst.battle(population[i])\\n inst_score += battle_result[0]\\n \\n # Also record the score in the instance\\n inst.set_score(inst_score)\\n\\n return inst_score\",\n \"def testNumberIndividualsAddsUp(self):\\n number = sum([x[1] for x in self.tree.get_species_abundances(reference=3)])\\n number2 = sum([x[1] for x in self.tree.get_species_abundances(reference=3)])\\n self.assertEqual(number, 3734)\\n self.assertEqual(number2, 3734)\",\n \"def test_two_pop_known_var_ind(data1_: tuple, data2_: tuple):\\n x_bar = cls.get_mean(data1_)\\n y_bar = cls.get_mean(data2_)\\n var_x = cls.get_var(data1_, is_population=True)\\n var_y = cls.get_var(data2_, is_population=True)\\n n_x = cls.get_n(data1_)\\n n_y = cls.get_n(data2_)\\n return (x_bar - y_bar) / sqrt(var_x / n_x + var_y / n_y)\",\n \"def _individual_pension_insurance(self, total_salary, month=None, year=None):\\n individual_pension_insurance = 0\\n\\n pension_max_fee = self.pension_max_fee\\n # special case in 2018\\n if year == 2018:\\n if month <= 2:\\n pension_max_fee = self.old_pension_max_fee\\n #end if\\n #end if\\n\\n if total_salary > pension_max_fee:\\n individual_pension_insurance = pension_max_fee \\\\\\n * self.individual_pension_insurance_rate\\n else:\\n individual_pension_insurance = total_salary \\\\\\n * self.individual_pension_insurance_rate\\n #end if\\n return individual_pension_insurance\",\n \"def get_pop(api_key, year = str(), map = bool()):\\n try:\\n year = year\\n pop_url = f'http://api.census.gov/data/{year}/pep/population?get=POP&for=state:*&key={api_key}'\\n r = requests.get(pop_url)\\n data = json.loads(r.content) \\n pop_df = pd.DataFrame(data[1:], columns=data[0]).\\\\\\n rename(columns={\\\"POP\\\": \\\"Pop_Count\\\", \\\"state\\\": \\\"STATEFP\\\"})\\n pop_df['Pop_Count'] = pop_df['Pop_Count'].astype(str).astype(int)\\n geodata_url = f\\\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/state.json\\\"\\n geo_df = gpd.read_file(geodata_url)\\n geo_df = geo_df.merge(pop_df, on = 'STATEFP')\\n if map == True:\\n return geo_df.plot(column = 'Pop_Count')\\n else:\\n return geo_df\\n r.raise_for_status()\\n except HTTPError as http_err:\\n print(f'HTTP error occurred: {http_err}')\\n except Exception as err:\\n print(f'An error occured. All parameters must exist in the Census GeoJSON database. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')\",\n \"def getSalaryStat(self, year = 2014):\\r\\n year_str = str(year+1)\\r\\n \\r\\n df = pd.read_html('http://espn.go.com/nba/salaries/_/year/' + year_str)[0]\\r\\n df.columns = df.iloc[0]\\r\\n df = df[df.NAME != 'NAME']\\r\\n \\r\\n for page in range(2,12):\\r\\n page_df = pd.read_html('http://espn.go.com/nba/salaries/_/year/' + \\\\\\r\\n year_str + '/page/' + str(page))[0]\\r\\n page_df.columns = page_df.iloc[0]\\r\\n page_df = page_df[page_df.NAME != 'NAME']\\r\\n df = pd.concat([df, page_df])\\r\\n \\r\\n df['SALARY'] = df['SALARY'].replace('[\\\\$,]', '', regex=True).astype(int)\\r\\n cut_df = df[['NAME', 'SALARY']]\\r\\n cut_df = cut_df.reset_index(drop=True)\\r\\n cut_df.columns = [['PLAYER_NAME', 'SALARY']]\\r\\n \\r\\n salary_df = self.fixSalaryName(cut_df)\\r\\n \\r\\n return salary_df\",\n \"def get_region_pop(api_key, year = str(), map = bool()):\\n try:\\n year = year\\n pop_url = f'http://api.census.gov/data/{year}/pep/population?get=POP&for=REGION:*&key={api_key}'\\n r = requests.get(pop_url)\\n data = json.loads(r.content) \\n pop_df = pd.DataFrame(data[1:], columns=data[0]).\\\\\\n rename(columns={\\\"POP\\\": \\\"Pop_Count\\\", \\\"region\\\": \\\"REGIONCE\\\"})\\n pop_df['Pop_Count'] = pop_df['Pop_Count'].astype(str).astype(int)\\n geodata_url = f\\\"https://raw.githubusercontent.com/uscensusbureau/citysdk/master/v2/GeoJSON/20m/{year}/region.json\\\"\\n geo_df = gpd.read_file(geodata_url)\\n geo_df = geo_df.merge(pop_df, on = 'REGIONCE')\\n if map == True:\\n return geo_df.plot(column = 'Pop_Count')\\n else:\\n return geo_df\\n r.raise_for_status()\\n except HTTPError as http_err:\\n print(f'HTTP error occurred: {http_err}')\\n except Exception as err:\\n print(f'An error occured. All parameters must exist in the Census GeoJSON database and API. Please check https://github.com/uscensusbureau/citysdk/tree/master/v2/GeoJSON: {err}')\",\n \"def test_city_country_population(self):\\n\\t\\tformatted_address = city_country(\\n\\t\\t\\t'santiago', 'chile', '5000000')\\n\\t\\tself.assertEqual(formatted_address, \\n\\t\\t\\t'Santiago, Chile - Population 5000000')\",\n \"def test_topo_current_occupants_positive():\\n instance = topo.Topography()\\n assert instance.current_occupants()[\\\"Herbivores\\\"] >= 0\\\\\\n and instance.current_occupants()[\\\"Carnivores\\\"] >= 0\",\n \"def total_occupancy_modifier(frame, data):\\n\\n occupancies = data.particles['Occupancy'][...]\\n site_type = data.particles['Particle Type'][...]\\n num_site_types = occupancies.shape[1] #Accessing the number of columns in the Occupancy matrix\\n total_occupancy = np.sum(occupancies, axis=1) #Summing over all columns\\n # NOTE By convention, the first half of types is Si, the second half is C\\n is_si_site = site_type <= num_site_types//2\\n is_c_site = site_type > num_site_types//2\\n si_occupancy = np.sum(occupancies[:, :(num_site_types//2)], axis=1)\\n c_occupancy = np.sum(occupancies[:, (num_site_types//2):], axis=1)\\n data.particles_.create_property('Total Occupancy', data=total_occupancy.astype(int))\\n data.particles_.create_property('Is Si Site', data=is_si_site.astype(int))\\n data.particles_.create_property('Is C Site', data=is_c_site.astype(int))\\n data.particles_.create_property('Si Occupancy', data=si_occupancy.astype(int))\\n data.particles_.create_property('C Occupancy', data=c_occupancy.astype(int))\",\n \"def showStats(population, masterList, index):\\n count = 0\\n if index == \\\"all\\\":\\n for team in population:\\n print (\\\"Team at index\\\", count)\\n print(\\\"Tot Avg\\\", team.totAvg)\\n print(\\\"Tot Runs\\\", team.totRuns)\\n print(\\\"Tot HRs\\\", team.totHr)\\n print(\\\"Tot RBIs\\\", team.totRbi)\\n print(\\\"Tot SB\\\", team.totSb)\\n print(\\\"Tot points\\\", team.points, '\\\\n')\\n count += 1\\n else:\\n print(\\\"Team at index\\\", index)\\n print(\\\"Tot Avg\\\", population[index].totAvg)\\n print(\\\"Tot Runs\\\", population[index].totRuns)\\n print(\\\"Tot HRs\\\", population[index].totHr)\\n print(\\\"Tot RBIs\\\", population[0].totRbi)\\n print(\\\"Tot SB\\\", population[0].totSb)\\n print(\\\"Tot points\\\", population[0].points, '\\\\n')\",\n \"def test_city_country_population(self):\\n formatted_name = make_formatted_name('santiago', 'chile', 5000000)\\n self.assertEqual(formatted_name, 'Santiago, Chile - population 5000000')\",\n \"def was_pig_caught(prize):\\n if prize > 20:\\n return True\\n return False\",\n \"def testNumberIndividuals(self):\\n self.assertEqual(self.tree.get_number_individuals(community_reference=1), 284)\",\n \"def query_settlement_layer(grid):\\n path = os.path.join(SHAPEFILE_DIR, f'{COUNTRY_ABBRV}.tif')\\n\\n grid['population'] = pd.DataFrame(\\n zonal_stats(vectors=grid['geometry'], raster=path, stats='sum'))['sum']\\n\\n grid = grid.replace([np.inf, -np.inf], np.nan)\\n\\n return grid\",\n \"def get_num_railroads_owned(self, player_name):\\n total = 0\\n if self.get_owner(\\\"Reading Railroad\\\") == player_name:\\n total += 1\\n if self.get_owner(\\\"Pennsylvania Railroad\\\") == player_name:\\n total += 1\\n if self.get_owner(\\\"B. & O. Railroad\\\") == player_name:\\n total += 1\\n if self.get_owner(\\\"Short Line\\\") == player_name:\\n total += 1\\n return total\",\n \"def sample(self):\\n # Convert year from number to string (i.e. -1200 to 1200BC)\\n year = self.world.year()\\n if year < 0:\\n year = str(year)[1:] + 'BC'\\n elif year == 0:\\n year = '0'\\n elif year > 0:\\n year = str(year) + 'AD'\\n # Only sample when we are at a valid year\\n if year not in self.years:\\n return\\n\\n # retrieve list of occupied tile coordinates\\n occupied = self.occupied[year]\\n\\n # Sum the number of polities in the historical extent of the empire,\\n # and their sizes\\n included_polities = []\\n n_polities = 0\\n polity_sizes = []\\n for coordinates in occupied:\\n tile = self.world.index(coordinates[0], coordinates[1])\\n # Skip desert tiles included in the extent of the empire\\n if not tile.terrain.polity_forming:\\n continue\\n polity = tile.polity\\n # Ensure polities are not doubly counted if they possess more than\\n # one community in the extent of the empire\\n if polity in included_polities:\\n continue\\n included_polities.append(polity)\\n n_polities += 1\\n polity_sizes.append(polity.size())\\n\\n self.n_polities[year] = n_polities\\n self.polity_sizes[year] = polity_sizes\",\n \"def pon(self):\\n return self.table[1, 1] / (self.table[0, 1] + self.table[1, 1])\",\n \"def testNumberIndividuals(self):\\n self.assertEqual(396, self.tree2.get_number_individuals(community_reference=1))\\n self.assertEqual(9549, self.tree.get_number_individuals(community_reference=1))\",\n \"def combined_crude_rate(total_incidence, grouped_populations):\\n grouped_population = list(map(sum, zip(*grouped_populations)))\\n crude = list(map(lambda incidence: (incidence/grouped_population)*100000,\\n total_incidence))\\n combined_crude = pd.DataFrame((sum(crude)))\\n return combined_crude\",\n \"def define_geotype(x):\\n if x['population_km2'] > 2000:\\n return 'urban'\\n elif x['population_km2'] > 1500:\\n return 'suburban 1'\\n elif x['population_km2'] > 1000:\\n return 'suburban 2'\\n elif x['population_km2'] > 500:\\n return 'rural 1'\\n elif x['population_km2'] > 100:\\n return 'rural 2'\\n elif x['population_km2'] > 50:\\n return 'rural 3'\\n elif x['population_km2'] > 10:\\n return 'rural 4'\\n else:\\n return 'rural 5'\",\n \"def get_country_percentage(db, percent):\\n # Hint: Use get_total_stateless(db)[0][0] to get the total population\\n # total_population = get_total_stateless(db)[0][0]\\n # percent = (percent / 100)\\n pass\",\n \"def compute_tot_fitness(fitness_function, pop):\\n probs = np.zeros(len(pop)) # list to house probabilites\\n best_member = ''\\n best_fitness = -10**18\\n total_fitness = 0 # The sum of of all the fitness values from the population.\\n for i, chromosome in enumerate(pop):\\n new_fitness = fitness_function(chromosome)\\n if new_fitness > best_fitness:\\n best_member = chromosome\\n best_fitness = new_fitness\\n total_fitness += new_fitness\\n probs[i] = new_fitness\\n probs = probs / total_fitness\\n return total_fitness, best_fitness, best_member, probs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5652595","0.5537479","0.55229443","0.55086374","0.54755175","0.53278923","0.5322063","0.53090984","0.5220111","0.5202973","0.51130104","0.51096696","0.5104361","0.5068363","0.5034627","0.5024377","0.50120425","0.50120425","0.49283358","0.49250224","0.4909916","0.4882738","0.48582637","0.48516685","0.48161575","0.47850055","0.47732696","0.47383204","0.47342888","0.4732576","0.4731256","0.47105467","0.4664335","0.46621767","0.46580878","0.46479902","0.46479583","0.46463457","0.4646182","0.46448204","0.4636617","0.4633743","0.46323344","0.46260956","0.46205565","0.46087167","0.45991236","0.4596189","0.458168","0.4581385","0.45750248","0.4572063","0.45633605","0.45616648","0.4542911","0.45409247","0.45307392","0.45289886","0.45209083","0.4508029","0.44831046","0.44761273","0.4475922","0.44740453","0.44720936","0.44615275","0.44541696","0.4451739","0.44483042","0.44456294","0.44410554","0.44396615","0.44371504","0.44330502","0.44297123","0.4421543","0.44194373","0.44121942","0.44050387","0.44003993","0.43995845","0.4388125","0.43872008","0.4384501","0.43818337","0.43749052","0.4368841","0.4366547","0.43650112","0.43542314","0.4349055","0.43430865","0.43427896","0.43412662","0.43361124","0.43322206","0.43321162","0.43272212","0.43264586","0.43229565"],"string":"[\n \"0.5652595\",\n \"0.5537479\",\n \"0.55229443\",\n \"0.55086374\",\n \"0.54755175\",\n \"0.53278923\",\n \"0.5322063\",\n \"0.53090984\",\n \"0.5220111\",\n \"0.5202973\",\n \"0.51130104\",\n \"0.51096696\",\n \"0.5104361\",\n \"0.5068363\",\n \"0.5034627\",\n \"0.5024377\",\n \"0.50120425\",\n \"0.50120425\",\n \"0.49283358\",\n \"0.49250224\",\n \"0.4909916\",\n \"0.4882738\",\n \"0.48582637\",\n \"0.48516685\",\n \"0.48161575\",\n \"0.47850055\",\n \"0.47732696\",\n \"0.47383204\",\n \"0.47342888\",\n \"0.4732576\",\n \"0.4731256\",\n \"0.47105467\",\n \"0.4664335\",\n \"0.46621767\",\n \"0.46580878\",\n \"0.46479902\",\n \"0.46479583\",\n \"0.46463457\",\n \"0.4646182\",\n \"0.46448204\",\n \"0.4636617\",\n \"0.4633743\",\n \"0.46323344\",\n \"0.46260956\",\n \"0.46205565\",\n \"0.46087167\",\n \"0.45991236\",\n \"0.4596189\",\n \"0.458168\",\n \"0.4581385\",\n \"0.45750248\",\n \"0.4572063\",\n \"0.45633605\",\n \"0.45616648\",\n \"0.4542911\",\n \"0.45409247\",\n \"0.45307392\",\n \"0.45289886\",\n \"0.45209083\",\n \"0.4508029\",\n \"0.44831046\",\n \"0.44761273\",\n \"0.4475922\",\n \"0.44740453\",\n \"0.44720936\",\n \"0.44615275\",\n \"0.44541696\",\n \"0.4451739\",\n \"0.44483042\",\n \"0.44456294\",\n \"0.44410554\",\n \"0.44396615\",\n \"0.44371504\",\n \"0.44330502\",\n \"0.44297123\",\n \"0.4421543\",\n \"0.44194373\",\n \"0.44121942\",\n \"0.44050387\",\n \"0.44003993\",\n \"0.43995845\",\n \"0.4388125\",\n \"0.43872008\",\n \"0.4384501\",\n \"0.43818337\",\n \"0.43749052\",\n \"0.4368841\",\n \"0.4366547\",\n \"0.43650112\",\n \"0.43542314\",\n \"0.4349055\",\n \"0.43430865\",\n \"0.43427896\",\n \"0.43412662\",\n \"0.43361124\",\n \"0.43322206\",\n \"0.43321162\",\n \"0.43272212\",\n \"0.43264586\",\n \"0.43229565\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6115375"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":86499,"cells":{"query":{"kind":"string","value":"Data import test against known values that Hawaii should have."},"document":{"kind":"string","value":"def test_state(self):\n states = self.geographies.find({ 'geoid': config.SUMLEV_STATE })\n\n self.assertEqual(states.count(), 1)\n\n state = states[0]\n\n self.assertEqual(state['sumlev'], config.SUMLEV_STATE)\n self.assertEqual(state['metadata']['NAME'], 'Hawaii')\n self.assertEqual(state['metadata']['STATE'], '15')\n\n pop_2000 = 1211537\n pop_2010 = 1360301\n self._test_totalpop(state, pop_2000, pop_2010)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_addr_country_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_country(input_val)\n self.assertEqual(output_val, self.line.addr_country)","def test_csv_reader_data_contents(process_data):\n data = process_data(file_name_or_type='clean_map.csv')\n\n # Check row types\n for row in data:\n assert(isinstance(row['Country'], str))\n assert(isinstance(row['City'], str))\n assert(isinstance(row['State_Or_Province'], str))\n assert(isinstance(row['Lat'], float))\n assert(isinstance(row['Long'], float))\n assert(isinstance(row['Altitude'], float))\n\n # Basic data checks\n assert len(data) == 180 # We have collected 180 rows\n assert data[0]['Country'] == 'Andorra'\n assert data[106]['Country'] == 'Japan'","def test_toplevel_query_lat_mappings(self):\n\n patient = Semiology('Aphasia', Laterality.NEUTRAL, Laterality.NEUTRAL)\n patient.data_frame = self.df\n all_combined_gifs = patient.query_lateralisation(\n one_map_dummy)\n\n self.assertIs(type(all_combined_gifs), pd.DataFrame)\n assert not all_combined_gifs.empty\n\n labels = ['Gif Parcellations', 'pt #s']\n all_combined_gifs = all_combined_gifs.astype(\n {'Gif Parcellations': 'int32', 'pt #s': 'int32'})\n new_all_combined_gifindexed = all_combined_gifs.loc[:, labels]\n\n new_all_combined_gifindexed.set_index(\n 'Gif Parcellations', inplace=True)\n\n # new_all_combined_gifindexed.to_csv(r'D:\\aphasia_fixture.csv')\n # load fixture:\n fixture = pd.read_excel(\n dummy_data_path,\n header=0,\n usecols='A:B',\n sheet_name='fixture_aphasia',\n index_col=0,\n engine=\"openpyxl\",\n )\n # fixture.sort_index(inplace=True)\n assert((new_all_combined_gifindexed.shape) == (fixture.shape))\n# print('new_all_combined_gifindexed.shape is: ',\n# new_all_combined_gifindexed.shape)\n# print('fixture.shape.shape is: ', fixture.shape)\n\n assert(new_all_combined_gifindexed.index == fixture.index).all()\n assert(new_all_combined_gifindexed.values == fixture.values).all()","def import_data_helper(self): \n if len(self.components) == 1:\n hapi.fetch(TableName = self.tablename, M = self.components[0][0], I = self.components[0][1], numin = self.min_x, numax = self.max_x)\n else: \n global_id = []\n for c in self.components:\n global_id.append(hapi.ISO[c][0])\n hapi.fetch_by_ids(TableName = self.tablename, iso_id_list = global_id, numin = self.min_x, numax = self.max_x)","def test_import_data():\n\n file_path = os.path.join(CONST_ADVANTICSYS_DIR, CONST_ADVANTICSYS_TEST_1)\n\n # Bring df\n success, log, test_ingress_df = advanticsys_import(file_path)\n assert success, log\n assert isinstance(test_ingress_df, pd.DataFrame)\n\n # Test import function\n success, log = import_data(\n test_ingress_df,\n CONST_ADVANTICSYS,\n SQL_USER,\n SQL_PASSWORD,\n SQL_HOST,\n SQL_PORT,\n SQL_TEST_DBNAME\n )\n\n assert success is True, log \n assert log == \"New: 0 (uploaded); Duplicates: 75 (ignored)\"","def test_unknown_countries(self):\n # Currently, there are no Countries or Regions\n self.assertEqual(Country.objects.count(), 0)\n self.assertEqual(Region.objects.count(), 0)\n\n # Call the command with countries that are not recognized by the iso3166 library\n self.call_command(filename='power_plant_import/tests/data/unknown_countries.csv')\n\n # No Countries or Regions were created during the test\n self.assertEqual(Country.objects.count(), 0)\n self.assertEqual(Region.objects.count(), 0)","def test_correct_data_under_places(self):\n load_to_datastore(self.places_sofia, self.metadata_sofia)\n CommonAssertions.check_correct_data_under_places(tester=self, places=self.places_sofia,\n metadata=self.metadata_sofia)","def safely_load_data(data_file, data_description, filter_value=None, filter_column=constants.COUNTRY_COL, has_metadata=False, na_values=None):\n success = False\n result = None\n metadata = None\n file_path = None\n try:\n file_path = os.path.join(constants.EXAMPLE_DERIVED_DATA_PATH, data_file)\n if has_metadata and na_values:\n result = pd.read_csv(file_path, encoding='utf-8', header=1, na_values=na_values)\n elif has_metadata:\n result = pd.read_csv(file_path, encoding='utf-8', header=1)\n elif na_values:\n result = pd.read_csv(file_path, encoding='utf-8', na_values=na_values)\n else:\n result = pd.read_csv(file_path, encoding='utf-8')\n success = True\n if result.empty:\n result = 'Error: No {} data was found (empty file)'.format(data_description)\n success = False\n elif filter_value:\n result = result.loc[result[filter_column] == filter_value]\n if result.empty:\n result = 'Error: No {} data was found for the filter [{}: {}] (empty file)'.format(data_description, filter_column, filter_value)\n success = False\n except Exception as e:\n result = 'Error: No {} data was found ({})'.format(data_description, e)\n success = False\n\n if success:\n result = result.where((pd.notnull(result)), None)\n if has_metadata:\n # Extract metadata as json, expected to have the form \"#{metadata_json}\"\n # Find \"source_key\" key and do an org lookup and append with \"source_org\"\n with io.open(file_path, 'r', encoding='utf-8') as data_file:\n metadata_str = data_file.readline().strip()\n if metadata_str.startswith('#{') and metadata_str.endswith('}'):\n metadata = json.loads(metadata_str[1:])\n metadata[\"source_org\"] = constants.DATA_SOURCES[metadata[\"source_key\"]]\n\n return success, result, metadata","def test_unknowns(self):\n cr = CaseReader(self.filename)\n last_case = cr.get_case(-1)\n last_case_id = cr.list_cases()[-1]\n with h5py.File(self.filename, 'r') as f:\n for key in f[last_case_id]['Unknowns'].keys():\n val = f[last_case_id]['Unknowns'][key][()]\n np.testing.assert_almost_equal(last_case[key], val,\n err_msg='Case reader gives '\n 'incorrect Unknown value'\n ' for {0}'.format(key))","def insert_humans_staging(self):\n for year in range(1880, CURRENT_YEAR):\n self.load_wikidata(\"humans\", HUMANS_BY_YEAR_SPARQL_QUERY, INSERT_HUMAN_SQL_QUERY,\n INSERT_HUMAN_MAP_COLUMNS, year=year)","def test_parse_weather_two_missing_ghi(self):\n data = copy.deepcopy(self.weather_two)\n\n # Remove a ghi entry.\n del data['data'][0]['GlobalCM22']\n\n actual = timeseries.parse_weather(data)\n\n # We'll have a NaN.\n self.assertTrue(actual['ghi'].isna().any())","def test_addr_zip_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_zip(input_val)\n self.assertEqual(output_val, self.line.addr_zip)","def test_hav_bad_input(self):\n self.assertRaises(ValueError, lambda: latlongcalcs.hav('$'))\n self.assertRaises(ValueError, lambda: latlongcalcs.hav('ge'))","def test_import(self):\n graph = from_hipathia_paths(\n name=\"test1\",\n att_path=TEST_1_ATT_PATH,\n sif_path=TEST_1_SIF_PATH,\n )\n a = Protein(namespace=\"ncbigene\", identifier=\"1\")\n b_family = Protein(namespace=\"hipathia.family\", identifier=\"B_Family\")\n b_2 = Protein(namespace=\"ncbigene\", identifier=\"2\")\n b_3 = Protein(namespace=\"ncbigene\", identifier=\"3\")\n c_family = Protein(namespace=\"hipathia.family\", identifier=\"C_Family\")\n c_4 = Protein(namespace=\"ncbigene\", identifier=\"4\")\n c_5 = Protein(namespace=\"ncbigene\", identifier=\"5\")\n d = Protein(namespace=\"ncbigene\", identifier=\"6\")\n c_d = ComplexAbundance([c_family, d])\n\n self.assertEqual(\n sorted({a, b_family, b_2, b_3, c_family, c_4, c_5, d, c_d}, key=str),\n sorted(graph, key=str),\n )","def test_team_reg_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_team_reg(input_val)\n self.assertEqual(output_val, self.line.team_reg)","def testhospital_vs_confirmed(self):\n data = load_covid_data(file)\n aim_day = data['evolution']['2020-03-16']\n # Artificial cut one value , it supposed to be 4 number\n aim_day['epidemiology']['confirmed']['total']['age'] = [10, 11, 12]\n try:\n cases_population = cases_per_population_by_age(data)\n except Exception as e:\n raise Exception","def test_addr_city_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_city(input_val)\n self.assertEqual(output_val, self.line.addr_city)","def load_data(city, month, week_day):\n# name for day variable changed from \"day_name\" into week_day to take into account new pandas method \".day_name()\"\n# read in file form selected city\n df = pd.read_csv(CITY_DATA[city])\n# create additional columns for months, days, start/ end times, hours and station combinations\n df['Start Time'] = pd.to_datetime(df['Start Time'])\n df['End Time'] = pd.to_datetime(df['End Time'])\n df['month_start'] = df['Start Time'].dt.month\n df['month_end'] = df['End Time'].dt.month\n df['day_start'] = df['Start Time'].dt.day_name()\n df['day_end'] = df['End Time'].dt.day_name()\n df['hour'] = df['Start Time'].dt.hour\n df['station_comb'] = df['Start Station'] + ' &AND& ' + df['End Station']\n# filter data file by month: capture start and end months\n if month != 7:\n df1 = df[df['month_start'] == month]\n df2 = df1.append(df[df['month_end'] == month])\n df = df2.drop_duplicates()\n# filter data file by day: capture start and end days\n if week_day != 'All':\n df3 = df[df['day_start'] == week_day]\n df4 = df3.append(df[df['day_end'] == week_day])\n df = df4.drop_duplicates()\n# reset index to facilitate looping in station_stats function\n df = df.reset_index()\n# check if user wants to check first data lines\n req_check_df = input('\\nIf you want to check the selected data please enter y.')\n if req_check_df[0:1].lower() == 'y':\n print('check df = \\n', df.head())\n wait = input('Press Enter to continue. ')\n\n return df","def test_import(self):\n\n database.delete_database()\n\n #Fully successful import\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\n self.assertEqual(actual_tuples1, expected_tuples1)\n database.delete_database()\n\n #Partially successful import with failed product_data\n actual_tuples2 = database.import_data('csvs', 'produc_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples2 = ((0, 1, 1), (1, 0, 0))\n self.assertEqual(actual_tuples2, expected_tuples2)\n database.delete_database()\n\n #Partially successful import with failed customer_data\n actual_tuples3 = database.import_data('csvs', 'product_data.csv', 'custome_data.csv',\n 'rentals_data.csv')\n expected_tuples3 = ((1, 0, 1), (0, 1, 0))\n self.assertEqual(actual_tuples3, expected_tuples3)\n database.delete_database()\n\n #Partially successful import with failed rentals_data\n actual_tuples4 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rental_data.csv')\n expected_tuples4 = ((1, 1, 0), (0, 0, 1))\n self.assertEqual(actual_tuples4, expected_tuples4)\n database.delete_database()","def test_bad_ascii_data(self):\n\n # Bad file\n asc_filename = os.path.join(TESTDATA, 'bad_ascii_format.asc')\n try:\n read_layer(asc_filename)\n except ReadLayerError, e:\n # Check that error message is reasonable, e.g.\n # File /home/nielso/sandpit/inasafe_data/test/bad_ascii_format.asc\n # exists, but could not be read. Please check if the file can\n # be opened with e.g. qgis or gdalinfo\n\n msg = 'Unexpected error message for corrupt asc file: %s' % e\n assert 'exists' in str(e), msg\n assert 'gdalinfo' in str(e), msg\n assert 'qgis' in str(e), msg\n assert 'Please' in str(e), msg\n\n # No file\n asc_filename = 'nonexisting_ascii_file_234xxxlcrhgqjk.asc'\n try:\n read_layer(asc_filename)\n except ReadLayerError, e:\n # Check that this error message reflects that file did not exist\n msg = 'Unexpected error message for non existing asc file: %s' % e\n assert 'Could not find file' in str(e), msg","def test_get_country_states(self):\n pass","def is_good_data(d):\n source_sents, extracts = d\n return source_sents and extracts","def test_id_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_team_swimmer_id(input_val)\n self.assertEqual(output_val, self.line.team_swimmer_id)","def load_unicef_data():\n fname = 'SOWC_combined_simple.csv'\n \n \n # Uses pandas to help with string-NaN-numeric data.\n data = pd.read_csv(fname, na_values='_', encoding='latin1')\n \n \n # Strip countries title from feature names.\n features = data.axes[1][1:]\n # Separate country names from feature values.\n countries = data.values[:,0]\n values = data.values[:,1:]\n # Convert to numpy matrix for real.\n values = np.asmatrix(values,dtype='float64')\n # Modify NaN values (missing values).\n mean_vals = nanmean(values, axis=0)\n inds = np.where(np.isnan(values))\n values[inds] = np.take(mean_vals, inds[1])\n return (countries, features, values)","def test_addr_country_bad_values(self):\n for val in self.bad_values:\n self.assertRaises(line_format_errors.FieldParseError,\n lambda: self.line._parse_addr_country(val))","def test_loadData():\n \n sys = LVsystem.Ecosystem()\n \n sys.loadSetup('2Prey1Predator')\n \n \n data = sys.create_data()\n \n assert data[0] == 3\n assert data[1] == ['rabbit', 'hen', 'fox']\n assert data[2] == [30,10,20]\n assert data[3] == [0.09,0.07,-0.06] \n assert data[4] == [10000,10000,1]\n assert data[5] == [400,500,250]\n assert data[6][1][2] == -data[6][2][1]\n assert data[6][2][2] == 0\n\n sys.removeSpecies('rabbit')\n sys.removeSpecies('fox')\n sys.removeSpecies('hen')","def fixture_example_data():\n import_example_data()","def load_s2(\n human=True,\n hla_type=None,\n exclude_hla_type=None):\n s2_path = join(DATA_DIR, 'calis_s2.csv')\n df = pd.read_csv(s2_path)\n mask = ~df.peptide.str.contains(bad_amino_acids)\n if human:\n mask &= df.host == 'Homo'\n if hla_type:\n mask &= df.HLA.str.contains(hla_type, na=False).astype('bool')\n if exclude_hla_type:\n mask &= ~df.HLA.str.contains(exclude_hla_type, na=False).astype('bool')\n return df[mask]","def add_hospital_feature(data):\n data.loc[:, 'has_hospital'] = data.loc[:, 'district'].apply(\n lambda x: mapping.SOFIA_HOSPITALS_TRUE_FALSE_MAPPING[x])\n\n return data","def test_import(self, game=\"SuperMarioKart-Snes\"):\n self.assertTrue(game in retro.data.list_games())","def test_inserted_data(client):\n data = pd.read_csv(\"housing.csv\")\n data = format_data_housing(data)\n House.insert_from_pd(data)\n houses: DataFrame = pd.read_sql(\"SELECT * FROM house\", db.engine)\n assert len(houses) == data.shape[0]\n houses = house_results_to_dataframe(houses)\n assert_frame_equal(houses, data, check_dtype=False)","def test_census_county_population():\n dataframe = get_county_population_dataframe()\n boulder_county_row = dataframe.loc[dataframe['county_fips'] == 8013]\n boulder_county_population = boulder_county_row.get('county_population')\n assert float(boulder_county_population) == 326196","def test_temperatures_when_data_present(self):\n\n temp_data = [(1.00, time.localtime()), (2.00, time.localtime()),\n (3.00, time.localtime()), (4.00, time.localtime())]\n\n tt = TemperatureTracker(temp_data)\n result = tt.temperatures()\n for i in range(0, len(result)):\n self.assertEqual(result[i][0], temp_data[i][0])\n self.assertEqual(result[i][1], temp_data[i][1])","def test_import_evidence_mapped(self, status):\n object_generator = ObjectGenerator()\n _, user = object_generator.generate_person(user_role=\"Creator\")\n assessment = factories.AssessmentFactory()\n assessment.add_person_with_role_name(user, \"Verifiers\")\n assessment.status = status\n db.session.commit()\n\n response = self.import_data(collections.OrderedDict([\n (\"object_type\", \"Assessment\"),\n (\"Code*\", assessment.slug),\n (\"Evidence URL\", \"some url\"),\n ]))\n self._check_csv_response(response, {})\n self.assert_asmnt_notifications()","def test02Something(self):\n\n summaryFile = re.sub(\"\\.csv\",\"\",self.parsedFile)+\"_summary.csv\"\n bmap = self.bm.load_summary(summaryFile,taxaList=[\"10090\"])\n self.assertEqual(bmap['GG11117|c2_g1_i1'][0],'INT1_MOUSE')\n self.assertEqual(bmap['GG11117|c2_g1_i1'][1],'68510')\n \n bmap = self.bm.load_summary(summaryFile,taxaList=[\"10090\"],trinityGene=True)\n self.assertEqual(bmap['GG11117|c2_g1'][0],'INT1_MOUSE')\n\n bmap = self.bm.load_summary(summaryFile,taxaList=[\"10090\"],trinityGene=True,best=False)\n self.assertEqual(bmap['GG11117|c2_g1'][0][0],'INT1_MOUSE')\n self.assertEqual(bmap['GG11117|c2_g1'][0][4],0.0)","def test_extract_per_individual_state_metadatum_from_sample_metadata(self):\r\n veil_expected = {'001': [6.9, 9.3],\r\n '006': [4.2, 5.1],\r\n '007': [12.0, 1.8],\r\n '008': [10.0, None]}\r\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"VeillonellaAbundance\",\r\n process_f=float)\r\n self.assertEqual(actual, veil_expected)\r\n\r\n # different metadata_category yields different result\r\n strep_expected = {'001': [57.4, 26],\r\n '006': [19, 15.2],\r\n '007': [33.2, 50],\r\n '008': [3.2, 20]}\r\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"StreptococcusAbundance\",\r\n process_f=float)\r\n self.assertEqual(actual, strep_expected)\r\n\r\n # different metadata_category yields different result\r\n response_expected = {'001': [\"Improved\", \"Improved\"],\r\n '006': [\"Improved\", \"Improved\"],\r\n '007': [\"Worsened\", \"Worsened\"],\r\n '008': [\"Worsened\", \"Worsened\"]}\r\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"Response\",\r\n process_f=str)\r\n self.assertEqual(actual, response_expected)\r\n\r\n # alt input file with more states\r\n expected = {'001': [6.9, 9.3, 10.1]}\r\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\r\n self.individual_states_and_responses_map_f2,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\", \"PostPost\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"VeillonellaAbundance\",\r\n process_f=float)\r\n self.assertEqual(actual, expected)\r\n\r\n # unlisted states are ignored\r\n expected = {'001': [6.9, 9.3]}\r\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\r\n self.individual_states_and_responses_map_f2,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"VeillonellaAbundance\",\r\n process_f=float)\r\n self.assertEqual(actual, expected)","def test_extract_per_individual_states_from_sample_metadata_invalid(self):\r\n self.assertRaises(KeyError,\r\n extract_per_individual_states_from_sample_metadata,\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"some-invalid-category\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\")\r\n self.assertRaises(KeyError,\r\n extract_per_individual_states_from_sample_metadata,\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"some-other-invalid-category\")","def test_missing_color_by_value():\n svl_string = \"\"\"\n DATASETS bigfoot \"bigfoot.csv\"\n SCATTER bigfoot X latitude Y temperature_mid COLOR BY\n \"\"\"\n\n with pytest.raises(SvlMissingValue):\n parse_svl(svl_string)","def test_dbscan_hav_euc(self):\n sp_file = os.path.join(\"tests\", \"data\", \"geolife\", \"geolife_staypoints.csv\")\n sp = ti.read_staypoints_csv(sp_file, tz=\"utc\", index_col=\"id\", crs=\"epsg:4326\")\n\n # haversine calculation\n _, loc_har = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=100, num_samples=1, distance_metric=\"haversine\", agg_level=\"dataset\"\n )\n # WGS_1984\n sp.crs = \"epsg:4326\"\n # WGS_1984_UTM_Zone_49N\n sp = sp.to_crs(\"epsg:32649\")\n\n # euclidean calculation\n _, loc_eu = sp.as_staypoints.generate_locations(\n method=\"dbscan\", epsilon=100, num_samples=1, distance_metric=\"euclidean\", agg_level=\"dataset\"\n )\n\n assert len(loc_har) == len(loc_eu)","def test_import_assessments_with_templates(self):\n\n self.import_file(\"assessment_template_no_warnings.csv\")\n response = self.import_file(\"assessment_with_templates.csv\")\n self._check_csv_response(response, {})\n\n assessment = models.Assessment.query.filter(\n models.Assessment.slug == \"A 4\").first()\n\n values = set(v.attribute_value for v in assessment.custom_attribute_values)\n self.assertIn(\"abc\", values)\n self.assertIn(\"2015-07-15\", values)","def handle_missing_values(dataset, missing_values_header, missing_label):\n\n return dataset[dataset[missing_values_header] != missing_label]","def test_read_dynamic_missing_row(self):\n myisam_data_file = MyIsamDataFile(\"dataFiles/tests/examples/test_basics/myisam_table_one.MYD\")\n myisam_data_file.column_types = [MYSQL_FIELD_TYPES.MYSQL_TYPE_LONG, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR]\n self.assertRaises(MyIsamDataFileException, myisam_data_file.get_row, (6))","def check_mapping_data(mapping_data, headers, filename_column):\r\n\r\n # First make sure there is a SampleID and filename_column present\r\n try:\r\n sample_id_ix = headers.index(\"SampleID\")\r\n except ValueError:\r\n raise ValueError(\"SampleID column not found in mapping file, please \" +\r\n \"check mapping file with validate_mapping_file.py\")\r\n\r\n try:\r\n filename_col_ix = headers.index(filename_column)\r\n except ValueError:\r\n raise ValueError(\"Specified column %s not found in mapping file.\" %\r\n filename_column)\r\n\r\n valid_mimarks = letters + digits + \".\"\r\n\r\n fasta_name_to_sample_id = {}\r\n\r\n fasta_names = []\r\n sample_ids = []\r\n for line in mapping_data:\r\n\r\n try:\r\n fasta_name_to_sample_id[basename(line[filename_col_ix].strip())] =\\\r\n line[sample_id_ix]\r\n except IndexError:\r\n raise IndexError(\"Missing filename column data in line %s \" %\r\n line)\r\n\r\n for curr_char in line[sample_id_ix]:\r\n if curr_char not in valid_mimarks:\r\n raise ValueError(\"Found invalid character in line: %s\\n\" %\r\n line + \"SampleIDs must be alphanumeric and . characters \" +\r\n \"only\")\r\n sample_ids.append(line[sample_id_ix].strip())\r\n fasta_names.append(line[filename_col_ix].strip())\r\n\r\n fasta_name_dups = duplicates_indices(fasta_names)\r\n if fasta_name_dups:\r\n raise ValueError(\"Found duplicate fasta names: %s\" %\r\n \"\\t\".join([fasta_name for fasta_name in fasta_name_dups.keys()]))\r\n\r\n sample_id_dups = duplicates_indices(sample_ids)\r\n if sample_id_dups:\r\n raise ValueError(\"Found duplicate SampleID names: %s\" %\r\n \"\\t\".join([sample_id for sample_id in sample_id_dups.keys()]))\r\n\r\n return fasta_name_to_sample_id","def read_data(city='Chicago'):\n df = pd.read_csv('train.csv')\n df = df[df.City==city]\n\n # I will be using this dictionary to convert direction to degrees\n degrees = {'N':0, 'NE':45, 'E':90, 'SE':135, 'S':180, 'SW':225, 'W':270, 'NW':315}\n\n df[\"EntryHeading_deg\"] = df.EntryHeading.apply(lambda x:degrees[x])\n df[\"ExitHeading_deg\"] = df.ExitHeading.apply(lambda x:degrees[x])\n df[\"TurnDegree\"] = (df.EntryHeading_deg-df.ExitHeading_deg).apply(lambda x: x if abs(x) <=180 else (x+360 if x<0 else x-360))\n df[\"TurnDegree\"] = df.TurnDegree.apply(lambda x: x if x != -180 else x*-1)\n\n # Lets assign a number(StreetId) to each street\n all_streets = np.concatenate([df.ExitStreetName.reindex().values, df.EntryStreetName.reindex().values])\n # there are some nan values so lets just replace them with Unknown\n street_name_list = ['Unknown' if type(x)==type(0.0) else x for x in all_streets]\n street_names = {name: num for num, name in enumerate(street_name_list)}\n df[\"EntryStreetId\"] = np.array([street_names[x] if x in street_names else -999 for x in df.EntryStreetName])\n df[\"ExitStreetId\"] = np.array([street_names[x] if x in street_names else -999 for x in df.ExitStreetName])\n\n # we also want to categorize the street by its type (road, boulevard, ...)\n street_types = {n: i for i, n in enumerate(np.unique([x.split()[-1] for x in street_names.keys()]))}\n street_name_to_type = {}\n for name in street_names.keys():\n typ = name.split()[-1]\n street_name_to_type[name] = street_types[typ]\n df[\"EntryStreetType\"] = np.array([street_name_to_type[x] if x in street_names else -999 for x in df.EntryStreetName])\n df[\"ExitStreetType\"] = np.array([street_name_to_type[x] if x in street_names else -999 for x in df.ExitStreetName])\n\n df[\"EnterHighway\"] = np.array([1 if type(x)==type('') and x.split()[-1] in ['Broadway', 'Parkway', 'Expressway', 'Highway'] else 0 for x in df.EntryStreetName])\n df[\"ExitHighway\"] = np.array([1 if type(x)==type('') and x.split()[-1] in ['Broadway', 'Parkway', 'Expressway', 'Highway'] else 0 for x in df.ExitStreetName])\n df['Season'] = np.array([1 if month in (12,1,2) else 2 if month in (6,7,8) else 3 for month in df.Month.reindex().values])\n df['RushHour'] = np.array([1 if hour in (7,8,9) else 2 if hour in (16,17,18) else 3 if hour>=10 and hour<=15 else 4 for hour in df.Hour])\n return df","def load_default_atf_data():\n df = load_dataframe(\"oqmd_1.2_voronoi_magpie_fingerprints\")\n return df[df['N_species'] == 2].sample(frac=0.2)","def test_extract_per_individual_state_metadatum_from_sample_metadata_invalid(\r\n self):\r\n self.assertRaises(KeyError,\r\n extract_per_individual_state_metadatum_from_sample_metadata,\r\n self.individual_states_and_responses_map_f1,\r\n state_category=\"TreatmentState\",\r\n state_values=[\"Pre\", \"Post\"],\r\n individual_identifier_category=\"PersonalID\",\r\n metadata_category=\"some-non-existant-category\",\r\n process_f=float)","def test_invlaid_data(self):\n # Currently, there are no PowerPlant or Project objects in the database\n self.assertEqual(PowerPlant.objects.count(), 0)\n self.assertEqual(Project.objects.count(), 0)\n\n # Call the command with invalid data.\n # The first row is for a power plant, but it has an invalid latitude.\n # The second row is for a project, but it has an invalid project capacity.\n # The third row is for a project, but it has an invalid project capacity unit.\n # The fourth row is for a power plant, but has an invalid status.\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\n\n # Each of the objects were created, though the invalid data was not saved.\n self.assertEqual(PowerPlant.objects.count(), 3)\n self.assertEqual(Project.objects.count(), 2)","def DataLoader():\n #importing data\n House_Prices_Uncleaned = pd.read_csv(\"zillow_data/Zip_zhvi_uc_sfrcondo_tier_0.33_0.67_sm_sa_mon.csv\")\n #Cleaning house prices data\n\n House_Prices=pd.DataFrame(House_Prices_Uncleaned[\"RegionName\"][House_Prices_Uncleaned[\"CountyName\"]==\"New York County\"])\n\n House_Prices[\"Price\"]=pd.DataFrame(House_Prices_Uncleaned[\"2020-09-30\"])\n\n House_Rent_Uncleaned= pd.read_csv(\"zillow_data/Zip_ZORI_AllHomesPlusMultifamily_SSA.csv\")\n\n #Cleaning house rent data\n House_Rent=pd.DataFrame(House_Rent_Uncleaned[\"RegionName\"])\n House_Rent[\"Rent\"]=pd.DataFrame(House_Rent_Uncleaned[\"2020-09\"])\n\n return House_Prices, House_Rent","def test_missing_data_sources(self):","def import_building_from_excel(\n project, building_name, construction_age, path_to_excel, sheet_names\n):\n\n def warn_constructiontype(element):\n \"\"\"Generic warning function\"\"\"\n if element.construction_type is None:\n warnings.warn(\n 'In zone \"%s\" the %s construction \"%s\" could not be loaded from the TypeBuildingElements.json, '\n \"an error will occur due to missing data for calculation.\"\n \"Check for spelling and the correct combination of building age and construction type.\"\n \"Here is the list of faulty entries:\\n%s\"\n \"\\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx\"\n % (\n group[\"zone\"].iloc[0],\n element.name,\n group[\"OuterWallConstruction\"].iloc[0],\n group,\n )\n )\n\n bldg = Building(parent=project)\n bldg.name = building_name\n bldg.year_of_construction = construction_age\n bldg.with_ahu = True # HardCodedInput\n if bldg.with_ahu is True:\n bldg.central_ahu.heat_recovery = True # HardCodedInput\n bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput\n bldg.central_ahu.temperature_profile = 25 * [273.15 + 18] # HardCodedInput\n bldg.central_ahu.min_relative_humidity_profile = 25 * [0] # HardCodedInput\n bldg.central_ahu.max_relative_humidity_profile = 25 * [1] # HardCodedInput\n bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput\n\n # Parameters that need hard coding in teasers logic classes\n # 1. \"use_set_back\" needs hard coding at aixlib.py in the init; defines\n # if the in the useconditions stated\n # heating_time with the respective set_back_temp should be applied.\n # use_set_back = false -> all hours of the day\n # have same set_temp_heat actual value: use_set_back = Check your current version!\n # 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text\n # file\n # \"teaser / data / output / modelicatemplate / AixLib /\n # AixLib_ThermalZoneRecord_TwoElement\"\n # actual changes: Check your current version!\n\n # Parameters to be set for each and every zone (#HardCodedInput)\n # -----------------------------\n out_wall_tilt = 90\n window_tilt = 90\n ground_floor_tilt = 0\n floor_tilt = 0\n ceiling_tilt = 0\n rooftop_tilt = 0\n ground_floor_orientation = -2\n floor_orientation = -2\n rooftop_orientation = -1\n ceiling_orientation = -1\n # -----------------------------\n\n # load_building_data from excel_to_pandas DataFrame:\n data = import_data(path_to_excel, sheet_names)\n\n # informative print\n usage_types = get_list_of_present_entries(data[\"UsageType\"])\n print(\"List of present usage_types in the original Data set: \\n%s\" % usage_types)\n\n # define the zoning methodology/function\n data = zoning_example(data)\n\n # informative print\n usage_types = get_list_of_present_entries(data[\"Zone\"])\n print(\"List of zones after the zoning is applied: \\n%s\" % usage_types)\n\n # aggregate all rooms of each zone and for each set general parameter,\n # boundary conditions\n # and parameter regarding the building physics\n zones = data.groupby([\"Zone\"])\n for name, zone in zones:\n\n # Block: Thermal zone (general parameter)\n tz = ThermalZone(parent=bldg)\n tz.name = str(name)\n tz.area = zone[\"NetArea[m²]\"].sum()\n # room vice calculation of volume plus summing those\n tz.volume = (\n np.array(zone[\"NetArea[m²]\"]) * np.array(zone[\"HeatedRoomHeight[m]\"])\n ).sum()\n\n # Block: Boundary Conditions\n # load UsageOperationTime, Lighting, RoomClimate and InternalGains\n # from the \"UseCondition.json\"\n tz.use_conditions = UseConditions(parent=tz)\n tz.use_conditions.load_use_conditions(zone[\"Zone\"].iloc[0], project.data)\n\n # Block: Building Physics\n # Grouping by orientation and construction type\n # aggregating and feeding to the teaser logic classes\n grouped = zone.groupby([\"OuterWallOrientation[°]\", \"OuterWallConstruction\"])\n for name, group in grouped:\n # looping through a groupby object automatically discards the\n # groups where one of the attributes is nan\n # additionally check for strings, since the value must be of type\n # int or float\n if not isinstance(group[\"OuterWallOrientation[°]\"].iloc[0], str):\n out_wall = OuterWall(parent=tz)\n out_wall.name = (\n \"outer_wall_\"\n + str(int(group[\"OuterWallOrientation[°]\"].iloc[0]))\n + \"_\"\n + str(group[\"OuterWallConstruction\"].iloc[0])\n )\n out_wall.area = group[\"OuterWallArea[m²]\"].sum()\n out_wall.tilt = out_wall_tilt\n out_wall.orientation = group[\"OuterWallOrientation[°]\"].iloc[0]\n # load wall properties from \"TypeBuildingElements.json\"\n out_wall.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"OuterWallConstruction\"].iloc[0],\n )\n warn_constructiontype(out_wall)\n else:\n warnings.warn(\n 'In zone \"%s\" the OuterWallOrientation \"%s\" is '\n \"neither float nor int, \"\n \"hence this building element is not added.\\nHere is the \"\n \"list of faulty entries:\\n%s\"\n \"\\n These entries can easily be found checking the stated \"\n \"index in the produced ZonedInput.xlsx\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"OuterWallOrientation[°]\"].iloc[0],\n group,\n )\n )\n\n grouped = zone.groupby([\"WindowOrientation[°]\", \"WindowConstruction\"])\n for name, group in grouped:\n # looping through a groupby object automatically discards the\n # groups where one of the attributes is nan\n # additionally check for strings, since the value must be of type\n # int or float\n if not isinstance(group[\"OuterWallOrientation[°]\"].iloc[0], str):\n window = Window(parent=tz)\n window.name = (\n \"window_\"\n + str(int(group[\"WindowOrientation[°]\"].iloc[0]))\n + \"_\"\n + str(group[\"WindowConstruction\"].iloc[0])\n )\n window.area = group[\"WindowArea[m²]\"].sum()\n window.tilt = window_tilt\n window.orientation = group[\"WindowOrientation[°]\"].iloc[0]\n # load wall properties from \"TypeBuildingElements.json\"\n window.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"WindowConstruction\"].iloc[0],\n )\n warn_constructiontype(window)\n else:\n warnings.warn(\n 'In zone \"%s\" the window orientation \"%s\" is neither '\n \"float nor int, \"\n \"hence this building element is not added. Here is the \"\n \"list of faulty entries:\\n%s\"\n \"\\nThese entries can easily be found checking the stated \"\n \"index in the produced ZonedInput.xlsx\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"WindowOrientation[°]\"].iloc[0],\n group,\n )\n )\n\n grouped = zone.groupby([\"IsGroundFloor\", \"FloorConstruction\"])\n for name, group in grouped:\n if group[\"NetArea[m²]\"].sum() != 0: # to avoid devision by 0\n if group[\"IsGroundFloor\"].iloc[0] == 1:\n ground_floor = GroundFloor(parent=tz)\n ground_floor.name = \"ground_floor\" + str(\n group[\"FloorConstruction\"].iloc[0]\n )\n ground_floor.area = group[\"NetArea[m²]\"].sum()\n ground_floor.tilt = ground_floor_tilt\n ground_floor.orientation = ground_floor_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n ground_floor.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"FloorConstruction\"].iloc[0],\n )\n warn_constructiontype(ground_floor)\n elif group[\"IsGroundFloor\"].iloc[0] == 0:\n floor = Floor(parent=tz)\n floor.name = \"floor\" + str(group[\"FloorConstruction\"].iloc[0])\n floor.area = group[\"NetArea[m²]\"].sum() / 2 # only half of\n # the floor belongs to this story\n floor.tilt = floor_tilt\n floor.orientation = floor_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n floor.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"FloorConstruction\"].iloc[0],\n )\n warn_constructiontype(floor)\n else:\n warnings.warn(\n \"Values for IsGroundFloor have to be either 0 or 1, \"\n \"for no or yes respectively\"\n )\n else:\n warnings.warn(\n 'zone \"%s\" with IsGroundFloor \"%s\" and construction '\n 'type \"%s\" '\n \"has no floor nor groundfloor, since the area equals 0.\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"IsGroundFloor\"].iloc[0],\n group[\"FloorConstruction\"].iloc[0],\n )\n )\n\n grouped = zone.groupby([\"IsRooftop\", \"CeilingConstruction\"])\n for name, group in grouped:\n if group[\"NetArea[m²]\"].sum() != 0: # to avoid devision by 0\n if group[\"IsRooftop\"].iloc[0] == 1:\n rooftop = Rooftop(parent=tz)\n rooftop.name = \"rooftop\" + str(group[\"CeilingConstruction\"].iloc[0])\n rooftop.area = group[\n \"NetArea[m²]\"\n ].sum() # sum up area of respective\n # rooftop parts\n rooftop.tilt = rooftop_tilt\n rooftop.orientation = rooftop_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n rooftop.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"CeilingConstruction\"].iloc[0],\n )\n warn_constructiontype(rooftop)\n elif group[\"IsRooftop\"].iloc[0] == 0:\n ceiling = Ceiling(parent=tz)\n ceiling.name = \"ceiling\" + str(group[\"CeilingConstruction\"].iloc[0])\n ceiling.area = group[\"NetArea[m²]\"].sum() / 2 # only half\n # of the ceiling belongs to a story,\n # the other half to the above\n ceiling.tilt = ceiling_tilt\n ceiling.orientation = ceiling_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n ceiling.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"CeilingConstruction\"].iloc[0],\n )\n warn_constructiontype(ceiling)\n else:\n warnings.warn(\n \"Values for IsRooftop have to be either 0 or 1, \"\n \"for no or yes respectively\"\n )\n else:\n warnings.warn(\n 'zone \"%s\" with IsRooftop \"%s\" and construction type '\n '\"%s\" '\n \"has no ceiling nor rooftop, since the area equals 0.\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"IsRooftop\"].iloc[0],\n group[\"CeilingConstruction\"].iloc[0],\n )\n )\n\n grouped = zone.groupby([\"InnerWallConstruction\"])\n for name, group in grouped:\n if group[\"InnerWallArea[m²]\"].sum() != 0: # to avoid devision by 0\n in_wall = InnerWall(parent=tz)\n in_wall.name = \"inner_wall\" + str(\n group[\"InnerWallConstruction\"].iloc[0]\n )\n in_wall.area = group[\"InnerWallArea[m²]\"].sum() / 2 # only\n # half of the wall belongs to each room,\n # the other half to the adjacent\n # load wall properties from \"TypeBuildingElements.json\"\n in_wall.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"InnerWallConstruction\"].iloc[0],\n )\n warn_constructiontype(in_wall)\n else:\n warnings.warn(\n 'zone \"%s\" with inner wall construction \"%s\" has no '\n \"inner walls, since area = 0.\"\n % (group[\"Zone\"].iloc[0], group[\"InnerWallConstructio\" \"n\"].iloc[0])\n )\n\n # Block: AHU and infiltration #Attention hard coding\n # set the supply volume flow of the AHU per zone\n ahu_dict = {\n \"Bedroom\": [15.778, 15.778],\n \"Corridorsinthegeneralcarearea\": [5.2941, 5.2941],\n \"Examinationortreatmentroom\": [15.743, 15.743],\n \"MeetingConferenceseminar\": [16.036, 16.036],\n \"Stocktechnicalequipmentarchives\": [20.484, 20.484],\n \"WCandsanitaryroomsinnonresidentialbuildings\": [27.692, 27.692],\n }\n _i = 0\n for key in ahu_dict:\n if tz.name == key:\n tz.use_conditions.min_ahu = ahu_dict[key][0]\n tz.use_conditions.max_ahu = ahu_dict[key][1]\n _i = 1\n if _i == 0:\n warnings.warn(\n \"The zone %s could not be found in your ahu_dict. Hence, \"\n \"no AHU flow is defined. The default value is \"\n \"0 (min_ahu = 0; max_ahu=0\" % tz.name\n )\n\n return project, data","def test_dataset_found_when_querying_number_in_name(self):\n models.Study.objects.all().delete()\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\n study_name = 'unlikely_24601_dataset'\n # Use an accession that won't match for one dataset but not the other\n name_match = factories.StudyFactory.create(i_study_name=study_name, i_accession=123456)\n phs_match = factories.StudyFactory.create(i_study_name='other_name', i_accession=24601)\n url = self.get_url()\n response = self.client.get(url, {'q': 246})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted(returned_pks),\n sorted([name_match.i_accession, phs_match.i_accession]))","def test_from_icao(self):\n for icao, name, city in (\n (\"KJFK\", \"John F Kennedy International Airport\", \"New York\"),\n (\"kjfk\", \"John F Kennedy International Airport\", \"New York\"),\n (\"KLAX\", \"Los Angeles International Airport\", \"Los Angeles\"),\n (\"PHNL\", \"Daniel K Inouye International Airport\", \"Honolulu\"),\n (\"EGLL\", \"London Heathrow Airport\", \"London\"),\n ):\n stn = station.Station.from_icao(icao)\n self.assertIsInstance(stn, station.Station)\n self.assertEqual(icao.upper(), stn.icao)\n self.assertEqual(name, stn.name)\n self.assertEqual(city, stn.city)\n for bad in (\"1234\", 1234, None, True, \"\"):\n with self.assertRaises(exceptions.BadStation):\n station.Station.from_icao(bad)","def load_country_code_data():\n name_conversion = {\n 'East Timor': 'Timor-Leste',\n 'Republic of the Congo': 'Congo (Kinshasa)',\n 'Ivory Coast': 'Cote d\\'Ivoire',\n 'Macedonia': 'North Macedonia',\n 'Myanmar': 'Burma',\n 'Republic of Serbia': 'Serbia',\n 'Taiwan': 'Taiwan*',\n 'The Bahamas': 'Bahamas',\n 'United Republic of Tanzania': 'Tanzania',\n 'United States of America': 'US'\n }\n\n shapefile = os.path.join('data', 'ne_110m_admin_0_countries.shp')\n\n gdf = gpd.read_file(shapefile)[['ADMIN', 'ADM0_A3', 'geometry']]\n gdf.columns = ['country', 'country_code', 'geometry']\n\n gdf.loc[gdf['country'].isin(name_conversion.keys()), 'country'] = gdf['country'].map(name_conversion)\n\n return gdf","def testTaxaData(self):\n try:\n numEukaryota = 0\n numBacteria = 0\n numVirus = 0\n numArchaea = 0\n numOther = 0\n numUnclass = 0\n logger.info(\"Loading taxonomy data\")\n tU = TaxonomyUtils()\n logger.info(\"Done loading taxonomy data\")\n iCount = 0\n entryD = self.__mU.doImport(self.__instanceSavePath, fmt=\"pickle\")\n for entryId in entryD:\n for entityId, eD in entryD[entryId][\"selected_polymer_entities\"].items():\n taxId = eD[\"ncbi_taxonomy_id\"] if \"ncbi_taxonomy_id\" in eD else None\n if taxId is None:\n logger.debug(\"Missing taxId entryId %s entityId %s\", entryId, entityId)\n continue\n # lin = tU.getLineage(taxId)\n # nmL = tU.getLineageNames(taxId)\n ok1 = tU.isEukaryota(taxId)\n if ok1:\n numEukaryota += 1\n ok3 = tU.isVirus(taxId)\n if ok3:\n numVirus += 1\n ok2 = tU.isBacteria(taxId)\n if ok2:\n numBacteria += 1\n #\n ok4 = tU.isArchaea(taxId)\n if ok4:\n numArchaea += 1\n #\n ok5 = tU.isOther(taxId)\n if ok5:\n numOther += 1\n #\n ok6 = tU.isUnclassified(taxId)\n if ok6:\n numUnclass += 1\n\n if ok1 and (ok1 and ok2):\n logger.info(\"taxid %r conflicting lineage\", taxId)\n #\n if not ok1 and not ok2 and not ok3 and not ok4 and not ok5 and not ok6:\n logger.info(\"unassigned taxid %r\", taxId)\n\n logger.debug(\"taxId %r entryId %s entityId %s\", taxId, entryId, entityId)\n iCount += 1\n # if iCount > 5000:\n # break\n logger.info(\"Eukaryota %d Bacteria %d Virus %d Archaea %d Other/Syn %r Unclass %d\", numEukaryota, numBacteria, numVirus, numArchaea, numOther, numUnclass)\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def import_data(self, data):\n # Import additional data for tuning\n # data: a list of dictionarys, each of which has at least two keys, 'parameter' and 'value'\n pass","def test_get_return_default(self):\n ars = self.ar[2009][11]['general']\n self.assertTrue(ars.get('invalid_row') is None)","def test_get_g_data_1(self):\n self.db_filter.values = [40481]\n\n g_data = review.get_g_data(self.alchemist, self.db_filter, 40481)\n\n self.assertTrue(isinstance(g_data, list))\n\n for header in review.PG_HEADER:\n with self.subTest(header=header):\n self.assertTrue(header in g_data[0].keys())\n self.assertFalse(isinstance(g_data[0][header], list))","def test_parse_sample_sheet(self):\n pass","def test_lookup_different_columns(self):\n lookup = ProbeSetLookup(lookup_data_fp=self.fp2,cols=(0,1))\n self.assertEqual(lookup.lookup('1255_g_at'),['1421061_at'])\n self.assertEqual(lookup.lookup('1294_at'),['1426970_a_at',\n '1426971_at',\n '1437317_at'])","def test_data_creation_from_base_row(self, mock_read_csv):\n f = StringIO(self.data_header + self.data_row)\n reader = csv.DictReader(f)\n mock_read_csv.return_value = reader\n load_values()\n self.assertEqual(CountyMortgageData.objects.count(), 1)\n county = CountyMortgageData.objects.first()\n fields = reader.fieldnames\n fields.pop(fields.index('fips')) # test string separately\n fields.pop(fields.index('open')) # 'open' is stored as 'total'\n fields.pop(fields.index('date')) # date must be parsed before testing\n self.assertEqual(county.fips, self.data_row_dict.get('fips'))\n open_value = int(self.data_row_dict.get('open'))\n self.assertEqual(county.total, open_value)\n target_date = parser.parse(self.data_row_dict['date']).date()\n self.assertEqual(county.date, target_date)\n for field in fields: # remaining fields can be tested in a loop\n self.assertEqual(\n getattr(county, field), int(self.data_row_dict.get(field)))\n # test computed values\n self.assertEqual(\n county.epoch,\n int(target_date.strftime('%s')) * 1000)\n self.assertEqual(\n county.percent_90,\n int(self.data_row_dict.get('ninety')) * 1.0 / open_value)\n self.assertEqual(\n county.percent_30_60,\n (int(self.data_row_dict.get('thirty')) +\n int(self.data_row_dict.get('sixty'))) * 1.0 / open_value)","def test_correct_dataset_found_with_pht_in_name(self):\n models.SourceTrait.objects.all().delete()\n name_trait = factories.SourceDatasetFactory.create(\n dataset_name='pht557',\n source_study_version=self.source_study_version\n )\n pht_trait = factories.SourceDatasetFactory.create(\n i_accession=557,\n source_study_version=self.source_study_version\n )\n url = self.get_url(self.study.pk)\n response = self.client.get(url, {'q': 'pht557'})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(len(returned_pks), 2)\n self.assertIn(name_trait.pk, returned_pks)\n self.assertIn(pht_trait.pk, returned_pks)","def us31(self, file_path=None):\n file_path = file_path if file_path else get_data_file_path('US31.ged')\n family_tree = TreeLine().process_data(file_path)\n us31_fail = []\n indi_list = family_tree.get_indi_list()\n for indi in indi_list:\n spouse_list = indi.get_spouses(family_tree)\n if len(spouse_list) == 0:\n age = indi.get_age()\n if age and age > 30:\n warn_msg = f'{indi.name} age is {age} and has never been married'\n print(warn_msg)\n indi.err = TreeError(TreeError.TYPE_ANOMALY, TreeError.ON_INDI, 'US31', indi.id, warn_msg)\n us31_fail.append(indi)\n return us31_fail","def test_id_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_event_swimmer_id(input_val)\n self.assertEqual(output_val, self.line.event_swimmer_id)","def test_import(import_data):\n try:\n df_tab = import_data()\n logging.info(\"Testing import_data: Successfully Found File\")\n except FileNotFoundError as err:\n logging.error(\"Testing import_data: The file wasn't found\")\n raise err\n\n try:\n assert df_tab.shape[0] > 0\n assert df_tab.shape[1] > 0\n logging.info(\"Testing import_data: Successfully Available Data\")\n except AssertionError as err:\n logging.error(\n \"Testing import_data: The file doesn't appear to have rows and columns\"\n )\n raise err\n\n return df_tab","def load_data():\n if _LOCATIONS_BY_ID:\n return _LOCATIONS_BY_NAME, _LOCATIONS_BY_ID\n\n # We need to read the locations in order of country -> admin level 1 -> admin level 2 -> city.\n # This is so that the higher resolution locations can look up the lower resolution locations\n # that they belong to, and compute the necessary fields.\n countries_by_code = _load_country_data(_DATA_FILES['country'])\n admin1_by_code = _load_admin1_data(_DATA_FILES['admin_1'], countries_by_code)\n admin2_by_code = _load_admin2_data(_DATA_FILES['admin_2'], countries_by_code, admin1_by_code)\n _load_city_data(_DATA_FILES['city'], countries_by_code, admin1_by_code, admin2_by_code)\n _add_alternate_names(_DATA_FILES['alt_wiki_names'])\n _add_estimated_importances(_DATA_FILES['estimated_importance'])\n\n return _LOCATIONS_BY_NAME, _LOCATIONS_BY_ID","def _import(self, data):\n if isinstance(data, dict):\n if len(data):\n for key in data:\n if data.get(key) is not None:\n if not self.set(key, data.get(key)):\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))","def check_usability(hdulist):\n status = True\n\n if 'INSTRUME' in hdulist[0].header:\n if change_style(hdulist[0].header['INSTRUME']):\n pass\n else:\n print (\"Not a valid value for INSTRUME: {}\".format(hdulist[0].header['INSTRUME']))\n status = False\n else:\n print (\"Missing INSTRUME header in file \")\n status = False\n if 'REFTYPE' in hdulist[0].header:\n pass\n else:\n print (\"Missing REFTYPE header in file \")\n status = False\n\n return status","def load_s1(\n human=True,\n peptide_length=None,\n hla_type=None,\n exclude_hla_type=None):\n s1_path = join(DATA_DIR, 'calis_s1.csv')\n df = pd.read_csv(s1_path)\n mask = ~df.Peptide.str.contains(bad_amino_acids)\n if human:\n mask &= df.Species == 'Homo'\n if peptide_length:\n mask &= df.Peptide.str.len() == peptide_length\n if hla_type:\n mask &= df.MHC.str.contains(hla_type, na=False).astype('bool')\n if exclude_hla_type:\n contains_hla_type = df.MHC.str.contains(exclude_hla_type, na=False)\n mask &= ~(contains_hla_type.astype('bool'))\n return df[mask]","def test_reading_warehouse_map(warehouse_map1):\n map_ = (\n (2, 2, 2, 2, 3),\n (1, \"a\", 1, \"b\", 3),\n (1, \"c\", 1, \"d\", 3),\n (1, \"e\", 1, \"f\", 3),\n (1, 4, 4, 4, 9),\n )\n assert map_ == warehouse_map1","def test_prepare_essentiality_data(ijr904, combined_dataframe):\n tested_dataframe = essential.prepare_essentiality_data(\n join(dirname(__file__), \"data\", \"essentiality\", \"mock_essential.csv\"), ijr904\n )\n assert tested_dataframe.equals(combined_dataframe)","def test_age_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_age(input_val)\n self.assertEqual(output_val, self.line.age)","def test_alien_data(self):","def _check_hour_data(self, ls_row):\n for attr in ['kt_re', 'kt_im', 'div', 'type', 'area_code']:\n self._check_datum(attr, getattr(ls_row, attr))","def isUndefinedData(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address) -> bool:\n ...","def init(city: str, country: str, list_of_streets: list):\n if check(city, country, list_of_streets):\n return get_sample_data(city, country, list_of_streets)","def load_unicef_data():\n fname = 'SOWC_combined_simple.csv'\n\n # Uses pandas to help with string-NaN-numeric data.\n data = pd.read_csv(fname, na_values='_')\n # Strip countries title from feature names.\n features = data.axes[1][1:]\n # Separate country names from feature values.\n countries = data.values[:,0]\n values = data.values[:,1:]\n # Convert to numpy matrix for real.\n values = np.asmatrix(values,dtype='float64')\n\n # Modify NaN values (missing values).\n mean_vals = np.nanmean(values, axis=0)\n inds = np.where(np.isnan(values))\n values[inds] = np.take(mean_vals, inds[1])\n return (countries, features, values)","def test_read_dynamic_third_row(self):\n myisam_data_file = MyIsamDataFile(\"dataFiles/tests/examples/test_basics/myisam_table_one.MYD\")\n myisam_data_file.column_types = [MYSQL_FIELD_TYPES.MYSQL_TYPE_LONG, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR]\n myisam_record = myisam_data_file.get_row(3)\n myisam_values = [3, 'lastname 3', 'firstname 3', 'address 3', 'city 3']\n self.assertEqual(myisam_record, myisam_values)","def get_jhu(data_path: str, filter_: Union[dict, bool] = True) -> None:\n # Where JHU stores their data\n url_template = (\"https://raw.githubusercontent.com/CSSEGISandData/\"\n \"COVID-19/master/csse_covid_19_data/\"\n \"csse_covid_19_time_series/time_series_covid19_%s_%s.csv\")\n\n # Scrape the data\n dfs = {}\n for region in ['global', 'US']:\n dfs[region] = {}\n for kind in ['confirmed', 'deaths', 'recovered']:\n url = url_template % (kind, region) # Create the full data URL\n try:\n df = pd.read_csv(url) # Download the data into a dataframe\n except HTTPError:\n print(\"Could not download data for %s, %s\" % (kind, region))\n else:\n if region == 'global':\n has_no_province = df['Province/State'].isnull()\n # Whole countries only; use country name as index\n df1 = df[has_no_province].set_index('Country/Region')\n more_dfs = []\n for country in ['China', 'Canada', 'Australia']:\n if country == 'Canada' and kind in 'recovered':\n continue\n is_c = df['Country/Region'] == country\n df2 = df[is_c].sum(axis=0, skipna=False).to_frame().T\n df2['Country/Region'] = country\n df2 = df2.set_index('Country/Region')\n more_dfs.append(df2)\n df = pd.concat([df1] + more_dfs)\n elif region == 'US':\n # Use state name as index\n for k, v in us_state_abbrev.items(): # get US state abbrev\n if not us_state_abbrev[k].startswith('US_'):\n us_state_abbrev[k] = 'US_' + v # Add 'US_' to abbrev\n df.replace(us_state_abbrev, inplace=True)\n df = df.set_index('Province_State')\n df = df.groupby('Province_State').sum() # combine counties to create state level data\n\n df = df[[x for x in df if any(year in x for year in ['20', '21'])]] # Use only data columns\n # 20 or 21 signifies 2020 or 2021\n dfs[region][kind] = df # Add to dictionary of dataframes\n\n # Generate a list of countries that have \"good\" data,\n # according to these criteria:\n good_countries = get_countries(dfs['global'], filter_=filter_)\n\n # For each \"good\" country,\n # reformat and save that data in its own .csv file.\n source = dfs['global']\n for country in tqdm(good_countries, desc='Countries'): # For each country\n if country in ['Diamond Princess', 'MS Zaandam', 'Samoa',\n 'Vanuatu', 'Marshall Islands', 'US', 'Micronesia']:\n print(\"Skipping {}\".format(country))\n continue\n # If we have data in the downloaded JHU files for that country\n if country in source['confirmed'].index:\n df = pd.DataFrame(columns=['dates2', 'cum_cases', 'cum_deaths',\n 'cum_recover', 'new_cases',\n 'new_deaths', 'new_recover',\n 'new_uninfected'])\n df['dates2'] = source['confirmed'].columns\n df['dates2'] = df['dates2'].apply(fix_jhu_dates)\n df['cum_cases'] = source['confirmed'].loc[country].values\n df['cum_deaths'] = source['deaths'].loc[country].values\n df['cum_recover'] = source['recovered'].loc[country].values\n df[['new_cases', 'new_deaths', 'new_recover']] = \\\n df[['cum_cases', 'cum_deaths', 'cum_recover']].diff()\n df['new_uninfected'] = df['new_recover'] + df['new_deaths']\n\n\n try:\n population = get_population_count(data_path, country)\n df['population'] = population\n except:\n pass\n\n # Fill NaN with 0 and convert to int\n dfs[country] = df.set_index('dates2').fillna(0).astype(int)\n dfs[country].to_csv(data_path / ('covidtimeseries_%s.csv' % country))\n\n else:\n print(\"No data for %s\" % country)\n\n source = dfs['US']\n states = source['confirmed'].index.tolist()\n us_recovery_data = covid_tracking_recovery(data_path)\n for state in tqdm(states, desc='US States'): # For each country\n if state in ['Diamond Princess', 'Grand Princess', 'MS Zaandam', 'US_AS']:\n print(\"Skipping {}\".format(state))\n continue\n # If we have data in the downloaded JHU files for that country\n if state in source['confirmed'].index:\n df = pd.DataFrame(columns=['dates2', 'cum_cases', 'cum_deaths',\n 'new_cases','new_deaths','new_uninfected'])\n df['dates2'] = source['confirmed'].columns\n df['dates2'] = df['dates2'].apply(fix_jhu_dates)\n df['cum_cases'] = source['confirmed'].loc[state].values\n df['cum_deaths'] = source['deaths'].loc[state].values\n\n df[['new_cases', 'new_deaths']] = df[['cum_cases', 'cum_deaths']].diff()\n\n # add recovery data\n df.set_index('dates2', inplace=True)\n df = df.merge(us_recovery_data[state], on='dates2', how='left')\n df['new_uninfected'] = df['new_recover'] + df['new_deaths']\n\n try:\n population = get_population_count(data_path, state)\n df['population'] = population\n except:\n pass\n # Fill NaN with 0 and convert to int\n dfs[state] = df.fillna(0).astype(int)\n dfs[state].to_csv(data_path /\n ('covidtimeseries_%s.csv' % state))\n else:\n print(\"No data for %s\" % state)","def csv_parser_test():\r\n data = csv_parser(myspreadsheet)\r\n print('Your data object:')\r\n pp = pprint.PrettyPrinter(indent=4)\r\n pp.pprint(data) \r\n # Did your parser work?\r\n for row_num, row in enumerate(data):\r\n try:\r\n assert len(row) == 3\r\n except AssertionError:\r\n print ((\"Row %s seems to be misparsed; its length is %s\") % (row_num, len(row)))\r\n # Check on one of the values:\r\n try:\r\n assert data[4][2] == 'Linguist'\r\n except AssertionError:\r\n print ((\"Error: data[4][2] should equal 'Linguist'; actual value is %s\") % data[4][2])\r\n # Did you remember your int conversions?\r\n try:\r\n assert isinstance(data[0][0], int)\r\n except AssertionError:\r\n print (\"Error: data[0][0] should be an int\")\r\n # Did you remember your float conversions?\r\n try:\r\n assert isinstance(data[6][1], float)\r\n except AssertionError:\r\n print (\"Error: data[6][1] should be a float\")","def test_getknowndata(self):\n result = recordparser.getfields(self.rawdata, self.fieldmap,\n self.sourcekeys)\n self.assertEqual(self.knownvalues, result)","def test_import_values_dense():\n x = np.random.rand(7, 11)\n export_data('/tmp/test.dense', x)\n assert np.array_equal(x, import_data('/tmp/test.dense'))","def load_census_data_uci(local_path: str,\n write_data_locally: bool,\n columns: Tuple[str],\n uci_train_link_path: str,\n uci_test_link_path: str,\n seed: int=0\n ) -> Tuple[pd.DataFrame]:\n train_file, test_file = \"census-income.data\", \"census-income.test\"\n if not local_path:\n local_path = os.getcwd()\n train_file_path = os.path.join(local_path, train_file)\n test_file_path = os.path.join(local_path, test_file)\n \n # load training data \n if train_file in os.listdir(local_path):\n data_train = pd.read_csv(train_file_path, \n index_col=0)\n else:\n data_train = pd.read_csv(uci_train_link_path, \n header=None, \n index_col=False, \n names=columns)\n \n # load test data \n if test_file in os.listdir(local_path):\n data_test_orig = pd.read_csv(test_file_path, \n index_col=0)\n else:\n data_test_orig = pd.read_csv(uci_test_link_path, \n header=None, \n index_col=False, \n names=columns)\n assert list(data_train.columns) == list(data_test_orig.columns)\n\n\n # write loaded data to local path if they are not there already\n if write_data_locally:\n if train_file not in os.listdir(local_path):\n data_train.to_csv(train_file_path)\n if test_file not in os.listdir(local_path):\n data_test_orig.to_csv(test_file_path)\n\n # drop instance weight ( in section 6.3 of the paper there is no mention\n # of using instance_weight as sample weights for the loss functions)\n data_train.drop(\"instance_weight\", axis=1, inplace=True)\n data_test_orig.drop(\"instance_weight\", axis=1, inplace=True)\n\n # split original test data into training and validation as mentioned \n # in the paper\n data_val, data_test = train_test_split(data_test_orig, test_size=0.5, random_state=seed)\n return data_train, data_val, data_test","def load_data(self):\n df= self.read_file()\n for row,col in df.iterrows():\n Employeeid = int(col['Empolyeeid'])\n Employee_Name = col['Employee_Name']\n Age = col['Age']\n Salary = col['Salary']\n self.table.put_item(\n Item={\n \"Employeeid\":Employeeid,\n \"Employee_Name\": Employee_Name,\n \"Age\": Age,\n \"Salary\": Salary\n }\n )\n return True","def test_excel(test_data,tmp_path):\n\n for d in test_data:\n\n gpm = GenotypePhenotypeMap(genotype=d[\"genotype\"],\n wildtype=d[\"wildtype\"],\n phenotype=d[\"phenotype\"],\n uncertainty=d[\"uncertainty\"])\n\n # Write excel file\n excel_file = os.path.join(tmp_path,\"tmp.xlsx\")\n gpm.to_excel(filename=excel_file)\n assert os.path.isfile(excel_file)\n\n # Read in and make sure it worked.\n new_gpm = gpmap.read_excel(filename=excel_file,wildtype=d[\"wildtype\"])\n conftest.compare_gpmap(gpm,new_gpm)\n\n # Do not give wildtype. Should still work because the wildtype was\n # inferred.\n gpm_read = gpmap.read_excel(filename=excel_file)\n conftest.compare_gpmap(gpm,gpm_read)\n\n # Check ability to read labels back in\n site_labels = [f\"{x}\" for x in range(10,10+len(d[\"wildtype\"]),1)]\n gpm = GenotypePhenotypeMap(genotype=d[\"genotype\"],\n wildtype=d[\"wildtype\"],\n site_labels=site_labels)\n out_file = os.path.join(tmp_path,\"tmp.xlsx\")\n gpm.to_excel(out_file)\n\n gpm_read = gpmap.read_excel(out_file)\n\n for i in range(len(gpm_read.site_labels)):\n\n # Skip virtual site_labels added for invariant sites\n if len(d[\"mutations\"][i]) == 1:\n continue\n\n assert gpm_read.site_labels[i] == gpm.site_labels[i]\n\n # Read in with bad wildtype. Should throw warning and then have\n # sequential site labels.\n with pytest.warns(UserWarning):\n gpm_read = gpmap.read_excel(out_file,wildtype=d[\"mutant\"])\n\n assert np.array_equal(gpm_read.site_labels,range(len(d[\"wildtype\"])))","def validate_types_and_id(metaDictionary, logger, filename):\n result = True\n # this validation only applies to items that have genetic_alteration_type and datatype and stable_id\n if 'genetic_alteration_type' in metaDictionary and 'datatype' in metaDictionary and 'stable_id' in metaDictionary:\n alt_type_datatype_and_stable_id = {}\n script_dir = os.path.dirname(__file__)\n allowed_data_types_file_name = os.path.join(script_dir, \"allowed_data_types.txt\")\n data_line_nr = 0\n # build up map alt_type_datatype_and_stable_id:\n with open(allowed_data_types_file_name) as allowed_data_types_file:\n for line in allowed_data_types_file:\n if line.startswith(\"#\"):\n continue\n data_line_nr += 1\n # skip header, so if line is not header then process as tab separated:\n if (data_line_nr > 1):\n line_cols = csv.reader([line], delimiter='\\t').next()\n genetic_alteration_type = line_cols[0]\n data_type = line_cols[1]\n # add to map:\n if (genetic_alteration_type, data_type) not in alt_type_datatype_and_stable_id:\n alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)] = []\n alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)].append(line_cols[2])\n # init:\n stable_id = metaDictionary['stable_id']\n genetic_alteration_type = metaDictionary['genetic_alteration_type']\n data_type = metaDictionary['datatype']\n # validate the genetic_alteration_type/data_type combination:\n if (genetic_alteration_type, data_type) not in alt_type_datatype_and_stable_id:\n # unexpected as this is already validated in get_meta_file_type\n raise RuntimeError('Unexpected error: genetic_alteration_type and data_type combination not found in allowed_data_types.txt.',\n genetic_alteration_type, data_type)\n # validate stable_id:\n elif stable_id not in alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)]:\n logger.error(\"Invalid stable id for genetic_alteration_type '%s', \"\n \"data_type '%s'; expected one of [%s]\",\n genetic_alteration_type,\n data_type,\n ', '.join(alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)]),\n extra={'filename_': filename,\n 'cause': stable_id}\n )\n result = False\n\n return result","def test_with_data(self):\n create_states()\n response = self.client.get(reverse('education:states'))\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response.context.get(\"states\").count(), 52)\n self.assertContains(response, \"Home\")\n self.assertNotContains(response, \"No Data Available\")\n self.assertContains(response, \"Number of Public High Schools\")\n self.assertContains(response, \"Mississippi\")\n self.assertContains(response, \"90.0%\")\n self.assertContains(response, \"1,000\")\n self.assertContains(response, \"10\")","def test_export_data_on_nonexistent_user(self) -> None:\n user_data = user_models.UserStatsModel.export_data(\n self.NONEXISTENT_USER_ID)\n test_data: Dict[str, str] = {}\n self.assertEqual(user_data, test_data)","def test_lat_not_loc_1(self):\n patient = Semiology('lat_not_loc', Laterality.LEFT, Laterality.LEFT)\n patient.data_frame = self.df\n lat_not_loc_all_combined_gifs = patient.query_lateralisation(\n one_map_dummy)\n\n # inspect result\n lat_not_loc_result, num_query_loc = patient.query_semiology()\n\n self.assertIs(type(lat_not_loc_all_combined_gifs), pd.DataFrame)\n assert not lat_not_loc_all_combined_gifs.empty\n\n # drop the zero entries as these are from the CL/IL zeros:\n lat_not_loc_all_combined_gifs = lat_not_loc_all_combined_gifs[['Gif Parcellations', 'pt #s']].astype(\n {'Gif Parcellations': 'int32', 'pt #s': 'int32'})\n lat_not_loc_all_combined_gifs.set_index(\n 'Gif Parcellations', inplace=True)\n lat_not_loc_gifsclean = lat_not_loc_all_combined_gifs.loc[\n lat_not_loc_all_combined_gifs['pt #s'] != 0, :]\n # now we know only the CL data remains in this dummy data, which is on the RIGHT.\n gifs_right, gifs_left = gifs_lat_factor()\n lat_not_loc_gifsclean_rights = (\n lat_not_loc_gifsclean.index.isin(gifs_right).all()\n )\n\n # inspect result assertions\n assert(lat_not_loc_result.Localising.sum() == 0)\n assert(lat_not_loc_result['Lateralising'].sum() == 1)\n\n # all_combined_gifs assertions\n assert((\n lat_not_loc_gifsclean_rights == True)\n )\n assert(\n (\n lat_not_loc_gifsclean.index.isin(gifs_left)).any() == False\n )\n assert (lat_not_loc_gifsclean['pt #s'].sum()\n == lat_not_loc_gifsclean.shape[0])\n\n # test MTG on right 155 gif # gives 1:\n heatmap, _ = patient.get_num_datapoints_dict(method='minmax')\n assert 156 not in heatmap # left\n assert heatmap[155] == 1 # right","def test_correct_dataset_found_with_pht_in_name(self):\n models.SourceTrait.objects.all().delete()\n name_trait = factories.SourceDatasetFactory.create(dataset_name='pht557')\n pht_trait = factories.SourceDatasetFactory.create(i_accession=557)\n url = self.get_url()\n response = self.client.get(url, {'q': 'pht557'})\n returned_pks = get_autocomplete_view_ids(response)\n self.assertEqual(len(returned_pks), 2)\n self.assertIn(name_trait.pk, returned_pks)\n self.assertIn(pht_trait.pk, returned_pks)","def test_c_get_existing_records(self):\n\n success = True\n records = get_existing_records(location, database)\n\n if records['variable'].values[0] != value:\n success = False\n\n for function in records['function'].values:\n if function not in outcome_methods:\n success = False\n\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\n success = False\n\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\n success = False\n\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\n success = False\n\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\n success = False\n\n assert(success)","def test_parse_flag_file_1(self):\n flag_file = Path(test_file_dir, \"test_flag_file_1.csv\")\n flag_dict = basic.parse_flag_file(flag_file)\n with self.subTest():\n self.assertEqual(len(flag_dict.keys()), 3)\n with self.subTest():\n self.assertTrue(flag_dict[\"check_a\"])\n with self.subTest():\n self.assertFalse(flag_dict[\"check_b\"])\n with self.subTest():\n self.assertFalse(flag_dict[\"check_c\"])","def csv_parser_test():\n data = csv_parser(myspreadsheet)\n print 'Your data object:'\n pp = pprint.PrettyPrinter(indent=4)\n pp.pprint(data) \n # Did your parser work?\n for row_num, row in enumerate(data):\n try:\n assert len(row) == 3\n except AssertionError:\n print \"Row %s seems to be misparsed; its length is %s\" % (row_num, len(row))\n # Check on one of the values:\n try:\n assert data[4][2] == 'Linguist'\n except AssertionError:\n print \"Error: data[4][2] should equal 'Linguist'; actual value is %s\" % data[4][2]\n # Did you remember your int conversions?\n try:\n assert isinstance(data[0][0], int)\n except AssertionError:\n print \"Error: data[0][0] should be an int\"\n # Did you remember your float conversions?\n try:\n assert isinstance(data[6][1], float)\n except AssertionError:\n print \"Error: data[6][1] should be a float\"","def test_with_data(self):\n create_states()\n response = self.client.get(reverse('education:index'))\n self.assertEqual(response.status_code, 200)\n self.assertNotEqual(response.context.get(\"json_data\"), None)\n self.assertContains(response, \"High School Graduation\")\n self.assertContains(response, \"How Rates Were Calculated\")\n self.assertContains(response, '<svg id=\"graduation_rate_map\"')","def test_SampleIds(self):\r\n exp = [\"PC.354\", \"PC.355\", \"PC.356\", \"PC.481\", \"PC.593\", \"PC.607\",\r\n \"PC.634\", \"PC.635\", \"PC.636\"]\r\n obs = self.overview_map.SampleIds\r\n self.assertEqual(obs, exp)\r\n\r\n obs = self.no_metadata.SampleIds\r\n self.assertEqual(obs, exp)\r\n\r\n obs = self.empty_map.SampleIds\r\n self.assertEqual(obs, [])","def test_invalid_request_values(self):\n TEST_DATA = [\n (-100, 0, 0, 0),\n (100, 0, 0, 0),\n (0, -190, 0, 0),\n (0, 190, 0, 0),\n (0, 0, 0, -10),\n (0, 0, 0, 370)\n ] # yapf: disable\n for (lat, lon, alt, heading) in TEST_DATA:\n self.assertEqual(400,\n self.eval_request_values(lat, lon, alt, heading))","def test_check_data_fields(self):\r\n\r\n header =\\\r\n ['SampleID',\r\n 'BarcodeSequence',\r\n 'LinkerPrimerSequence',\r\n 'Description']\r\n mapping_data = [['s1', 'ACGT', 'AAAA', 's1_data'],\r\n ['s2', 'CGTA', 'AAAA', 's2_data']]\r\n errors = []\r\n warnings = []\r\n\r\n errors, warnings = check_data_fields(header,\r\n mapping_data, errors, warnings)\r\n\r\n expected_errors = []\r\n expected_warnings = []\r\n\r\n self.assertEqual(errors, expected_errors)\r\n self.assertEqual(warnings, expected_warnings)","def test_valid_country():\n assert valid_country(\"Democratic Republic of Lungary\") is True\n assert valid_country(\"Kraznoviklandstan\") is True\n assert valid_country(\"kraznoviklandstan\") is True\n assert valid_country(\"KRAZNOVIKLANDSTAN\") is True\n\n assert valid_country(\"Democratic_Republic982759\") is False\n assert valid_country(\"Kraznoviklandsta\") is False\n assert valid_country(\"Principalities of Fryed\") is False\n assert valid_country(\"FRY\") is False","def test_get_return_default_provided(self):\n ars = self.ar[2009][11]['general']\n self.assertEqual(ars.get('invalid_row', 'ZZZZZZ'), 'ZZZZZZ')","def test_country_code(self):\n\t\tcountry_name = 'United States'\n#\t\tpopulation = int(float(pop_dict['Value']))\n\t\tcode = get_country_code(country_name)\t\t\n\t\t#Assert methods verifies result received matches expected one\n\t\tself.assertEqual(code, 'usa')","def test_SampleIds(self):\n exp = [\"PC.354\", \"PC.355\", \"PC.356\", \"PC.481\", \"PC.593\", \"PC.607\",\n \"PC.634\", \"PC.635\", \"PC.636\"]\n obs = self.overview_map.SampleIds\n self.assertEqual(obs, exp)\n\n obs = self.no_metadata.SampleIds\n self.assertEqual(obs, exp)\n\n obs = self.empty_map.SampleIds\n self.assertEqual(obs, [])","def test_incorrect_data_type_plate():\n \n test_object = fa.read_in_envision(data_csv=list_A, platemap_csv=plate_map_file, data_type='plate', size=384)"],"string":"[\n \"def test_addr_country_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_addr_country(input_val)\\n self.assertEqual(output_val, self.line.addr_country)\",\n \"def test_csv_reader_data_contents(process_data):\\n data = process_data(file_name_or_type='clean_map.csv')\\n\\n # Check row types\\n for row in data:\\n assert(isinstance(row['Country'], str))\\n assert(isinstance(row['City'], str))\\n assert(isinstance(row['State_Or_Province'], str))\\n assert(isinstance(row['Lat'], float))\\n assert(isinstance(row['Long'], float))\\n assert(isinstance(row['Altitude'], float))\\n\\n # Basic data checks\\n assert len(data) == 180 # We have collected 180 rows\\n assert data[0]['Country'] == 'Andorra'\\n assert data[106]['Country'] == 'Japan'\",\n \"def test_toplevel_query_lat_mappings(self):\\n\\n patient = Semiology('Aphasia', Laterality.NEUTRAL, Laterality.NEUTRAL)\\n patient.data_frame = self.df\\n all_combined_gifs = patient.query_lateralisation(\\n one_map_dummy)\\n\\n self.assertIs(type(all_combined_gifs), pd.DataFrame)\\n assert not all_combined_gifs.empty\\n\\n labels = ['Gif Parcellations', 'pt #s']\\n all_combined_gifs = all_combined_gifs.astype(\\n {'Gif Parcellations': 'int32', 'pt #s': 'int32'})\\n new_all_combined_gifindexed = all_combined_gifs.loc[:, labels]\\n\\n new_all_combined_gifindexed.set_index(\\n 'Gif Parcellations', inplace=True)\\n\\n # new_all_combined_gifindexed.to_csv(r'D:\\\\aphasia_fixture.csv')\\n # load fixture:\\n fixture = pd.read_excel(\\n dummy_data_path,\\n header=0,\\n usecols='A:B',\\n sheet_name='fixture_aphasia',\\n index_col=0,\\n engine=\\\"openpyxl\\\",\\n )\\n # fixture.sort_index(inplace=True)\\n assert((new_all_combined_gifindexed.shape) == (fixture.shape))\\n# print('new_all_combined_gifindexed.shape is: ',\\n# new_all_combined_gifindexed.shape)\\n# print('fixture.shape.shape is: ', fixture.shape)\\n\\n assert(new_all_combined_gifindexed.index == fixture.index).all()\\n assert(new_all_combined_gifindexed.values == fixture.values).all()\",\n \"def import_data_helper(self): \\n if len(self.components) == 1:\\n hapi.fetch(TableName = self.tablename, M = self.components[0][0], I = self.components[0][1], numin = self.min_x, numax = self.max_x)\\n else: \\n global_id = []\\n for c in self.components:\\n global_id.append(hapi.ISO[c][0])\\n hapi.fetch_by_ids(TableName = self.tablename, iso_id_list = global_id, numin = self.min_x, numax = self.max_x)\",\n \"def test_import_data():\\n\\n file_path = os.path.join(CONST_ADVANTICSYS_DIR, CONST_ADVANTICSYS_TEST_1)\\n\\n # Bring df\\n success, log, test_ingress_df = advanticsys_import(file_path)\\n assert success, log\\n assert isinstance(test_ingress_df, pd.DataFrame)\\n\\n # Test import function\\n success, log = import_data(\\n test_ingress_df,\\n CONST_ADVANTICSYS,\\n SQL_USER,\\n SQL_PASSWORD,\\n SQL_HOST,\\n SQL_PORT,\\n SQL_TEST_DBNAME\\n )\\n\\n assert success is True, log \\n assert log == \\\"New: 0 (uploaded); Duplicates: 75 (ignored)\\\"\",\n \"def test_unknown_countries(self):\\n # Currently, there are no Countries or Regions\\n self.assertEqual(Country.objects.count(), 0)\\n self.assertEqual(Region.objects.count(), 0)\\n\\n # Call the command with countries that are not recognized by the iso3166 library\\n self.call_command(filename='power_plant_import/tests/data/unknown_countries.csv')\\n\\n # No Countries or Regions were created during the test\\n self.assertEqual(Country.objects.count(), 0)\\n self.assertEqual(Region.objects.count(), 0)\",\n \"def test_correct_data_under_places(self):\\n load_to_datastore(self.places_sofia, self.metadata_sofia)\\n CommonAssertions.check_correct_data_under_places(tester=self, places=self.places_sofia,\\n metadata=self.metadata_sofia)\",\n \"def safely_load_data(data_file, data_description, filter_value=None, filter_column=constants.COUNTRY_COL, has_metadata=False, na_values=None):\\n success = False\\n result = None\\n metadata = None\\n file_path = None\\n try:\\n file_path = os.path.join(constants.EXAMPLE_DERIVED_DATA_PATH, data_file)\\n if has_metadata and na_values:\\n result = pd.read_csv(file_path, encoding='utf-8', header=1, na_values=na_values)\\n elif has_metadata:\\n result = pd.read_csv(file_path, encoding='utf-8', header=1)\\n elif na_values:\\n result = pd.read_csv(file_path, encoding='utf-8', na_values=na_values)\\n else:\\n result = pd.read_csv(file_path, encoding='utf-8')\\n success = True\\n if result.empty:\\n result = 'Error: No {} data was found (empty file)'.format(data_description)\\n success = False\\n elif filter_value:\\n result = result.loc[result[filter_column] == filter_value]\\n if result.empty:\\n result = 'Error: No {} data was found for the filter [{}: {}] (empty file)'.format(data_description, filter_column, filter_value)\\n success = False\\n except Exception as e:\\n result = 'Error: No {} data was found ({})'.format(data_description, e)\\n success = False\\n\\n if success:\\n result = result.where((pd.notnull(result)), None)\\n if has_metadata:\\n # Extract metadata as json, expected to have the form \\\"#{metadata_json}\\\"\\n # Find \\\"source_key\\\" key and do an org lookup and append with \\\"source_org\\\"\\n with io.open(file_path, 'r', encoding='utf-8') as data_file:\\n metadata_str = data_file.readline().strip()\\n if metadata_str.startswith('#{') and metadata_str.endswith('}'):\\n metadata = json.loads(metadata_str[1:])\\n metadata[\\\"source_org\\\"] = constants.DATA_SOURCES[metadata[\\\"source_key\\\"]]\\n\\n return success, result, metadata\",\n \"def test_unknowns(self):\\n cr = CaseReader(self.filename)\\n last_case = cr.get_case(-1)\\n last_case_id = cr.list_cases()[-1]\\n with h5py.File(self.filename, 'r') as f:\\n for key in f[last_case_id]['Unknowns'].keys():\\n val = f[last_case_id]['Unknowns'][key][()]\\n np.testing.assert_almost_equal(last_case[key], val,\\n err_msg='Case reader gives '\\n 'incorrect Unknown value'\\n ' for {0}'.format(key))\",\n \"def insert_humans_staging(self):\\n for year in range(1880, CURRENT_YEAR):\\n self.load_wikidata(\\\"humans\\\", HUMANS_BY_YEAR_SPARQL_QUERY, INSERT_HUMAN_SQL_QUERY,\\n INSERT_HUMAN_MAP_COLUMNS, year=year)\",\n \"def test_parse_weather_two_missing_ghi(self):\\n data = copy.deepcopy(self.weather_two)\\n\\n # Remove a ghi entry.\\n del data['data'][0]['GlobalCM22']\\n\\n actual = timeseries.parse_weather(data)\\n\\n # We'll have a NaN.\\n self.assertTrue(actual['ghi'].isna().any())\",\n \"def test_addr_zip_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_addr_zip(input_val)\\n self.assertEqual(output_val, self.line.addr_zip)\",\n \"def test_hav_bad_input(self):\\n self.assertRaises(ValueError, lambda: latlongcalcs.hav('$'))\\n self.assertRaises(ValueError, lambda: latlongcalcs.hav('ge'))\",\n \"def test_import(self):\\n graph = from_hipathia_paths(\\n name=\\\"test1\\\",\\n att_path=TEST_1_ATT_PATH,\\n sif_path=TEST_1_SIF_PATH,\\n )\\n a = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"1\\\")\\n b_family = Protein(namespace=\\\"hipathia.family\\\", identifier=\\\"B_Family\\\")\\n b_2 = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"2\\\")\\n b_3 = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"3\\\")\\n c_family = Protein(namespace=\\\"hipathia.family\\\", identifier=\\\"C_Family\\\")\\n c_4 = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"4\\\")\\n c_5 = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"5\\\")\\n d = Protein(namespace=\\\"ncbigene\\\", identifier=\\\"6\\\")\\n c_d = ComplexAbundance([c_family, d])\\n\\n self.assertEqual(\\n sorted({a, b_family, b_2, b_3, c_family, c_4, c_5, d, c_d}, key=str),\\n sorted(graph, key=str),\\n )\",\n \"def test_team_reg_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_team_reg(input_val)\\n self.assertEqual(output_val, self.line.team_reg)\",\n \"def testhospital_vs_confirmed(self):\\n data = load_covid_data(file)\\n aim_day = data['evolution']['2020-03-16']\\n # Artificial cut one value , it supposed to be 4 number\\n aim_day['epidemiology']['confirmed']['total']['age'] = [10, 11, 12]\\n try:\\n cases_population = cases_per_population_by_age(data)\\n except Exception as e:\\n raise Exception\",\n \"def test_addr_city_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_addr_city(input_val)\\n self.assertEqual(output_val, self.line.addr_city)\",\n \"def load_data(city, month, week_day):\\n# name for day variable changed from \\\"day_name\\\" into week_day to take into account new pandas method \\\".day_name()\\\"\\n# read in file form selected city\\n df = pd.read_csv(CITY_DATA[city])\\n# create additional columns for months, days, start/ end times, hours and station combinations\\n df['Start Time'] = pd.to_datetime(df['Start Time'])\\n df['End Time'] = pd.to_datetime(df['End Time'])\\n df['month_start'] = df['Start Time'].dt.month\\n df['month_end'] = df['End Time'].dt.month\\n df['day_start'] = df['Start Time'].dt.day_name()\\n df['day_end'] = df['End Time'].dt.day_name()\\n df['hour'] = df['Start Time'].dt.hour\\n df['station_comb'] = df['Start Station'] + ' &AND& ' + df['End Station']\\n# filter data file by month: capture start and end months\\n if month != 7:\\n df1 = df[df['month_start'] == month]\\n df2 = df1.append(df[df['month_end'] == month])\\n df = df2.drop_duplicates()\\n# filter data file by day: capture start and end days\\n if week_day != 'All':\\n df3 = df[df['day_start'] == week_day]\\n df4 = df3.append(df[df['day_end'] == week_day])\\n df = df4.drop_duplicates()\\n# reset index to facilitate looping in station_stats function\\n df = df.reset_index()\\n# check if user wants to check first data lines\\n req_check_df = input('\\\\nIf you want to check the selected data please enter y.')\\n if req_check_df[0:1].lower() == 'y':\\n print('check df = \\\\n', df.head())\\n wait = input('Press Enter to continue. ')\\n\\n return df\",\n \"def test_import(self):\\n\\n database.delete_database()\\n\\n #Fully successful import\\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\\n 'rentals_data.csv')\\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\\n self.assertEqual(actual_tuples1, expected_tuples1)\\n database.delete_database()\\n\\n #Partially successful import with failed product_data\\n actual_tuples2 = database.import_data('csvs', 'produc_data.csv', 'customer_data.csv',\\n 'rentals_data.csv')\\n expected_tuples2 = ((0, 1, 1), (1, 0, 0))\\n self.assertEqual(actual_tuples2, expected_tuples2)\\n database.delete_database()\\n\\n #Partially successful import with failed customer_data\\n actual_tuples3 = database.import_data('csvs', 'product_data.csv', 'custome_data.csv',\\n 'rentals_data.csv')\\n expected_tuples3 = ((1, 0, 1), (0, 1, 0))\\n self.assertEqual(actual_tuples3, expected_tuples3)\\n database.delete_database()\\n\\n #Partially successful import with failed rentals_data\\n actual_tuples4 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\\n 'rental_data.csv')\\n expected_tuples4 = ((1, 1, 0), (0, 0, 1))\\n self.assertEqual(actual_tuples4, expected_tuples4)\\n database.delete_database()\",\n \"def test_bad_ascii_data(self):\\n\\n # Bad file\\n asc_filename = os.path.join(TESTDATA, 'bad_ascii_format.asc')\\n try:\\n read_layer(asc_filename)\\n except ReadLayerError, e:\\n # Check that error message is reasonable, e.g.\\n # File /home/nielso/sandpit/inasafe_data/test/bad_ascii_format.asc\\n # exists, but could not be read. Please check if the file can\\n # be opened with e.g. qgis or gdalinfo\\n\\n msg = 'Unexpected error message for corrupt asc file: %s' % e\\n assert 'exists' in str(e), msg\\n assert 'gdalinfo' in str(e), msg\\n assert 'qgis' in str(e), msg\\n assert 'Please' in str(e), msg\\n\\n # No file\\n asc_filename = 'nonexisting_ascii_file_234xxxlcrhgqjk.asc'\\n try:\\n read_layer(asc_filename)\\n except ReadLayerError, e:\\n # Check that this error message reflects that file did not exist\\n msg = 'Unexpected error message for non existing asc file: %s' % e\\n assert 'Could not find file' in str(e), msg\",\n \"def test_get_country_states(self):\\n pass\",\n \"def is_good_data(d):\\n source_sents, extracts = d\\n return source_sents and extracts\",\n \"def test_id_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_team_swimmer_id(input_val)\\n self.assertEqual(output_val, self.line.team_swimmer_id)\",\n \"def load_unicef_data():\\n fname = 'SOWC_combined_simple.csv'\\n \\n \\n # Uses pandas to help with string-NaN-numeric data.\\n data = pd.read_csv(fname, na_values='_', encoding='latin1')\\n \\n \\n # Strip countries title from feature names.\\n features = data.axes[1][1:]\\n # Separate country names from feature values.\\n countries = data.values[:,0]\\n values = data.values[:,1:]\\n # Convert to numpy matrix for real.\\n values = np.asmatrix(values,dtype='float64')\\n # Modify NaN values (missing values).\\n mean_vals = nanmean(values, axis=0)\\n inds = np.where(np.isnan(values))\\n values[inds] = np.take(mean_vals, inds[1])\\n return (countries, features, values)\",\n \"def test_addr_country_bad_values(self):\\n for val in self.bad_values:\\n self.assertRaises(line_format_errors.FieldParseError,\\n lambda: self.line._parse_addr_country(val))\",\n \"def test_loadData():\\n \\n sys = LVsystem.Ecosystem()\\n \\n sys.loadSetup('2Prey1Predator')\\n \\n \\n data = sys.create_data()\\n \\n assert data[0] == 3\\n assert data[1] == ['rabbit', 'hen', 'fox']\\n assert data[2] == [30,10,20]\\n assert data[3] == [0.09,0.07,-0.06] \\n assert data[4] == [10000,10000,1]\\n assert data[5] == [400,500,250]\\n assert data[6][1][2] == -data[6][2][1]\\n assert data[6][2][2] == 0\\n\\n sys.removeSpecies('rabbit')\\n sys.removeSpecies('fox')\\n sys.removeSpecies('hen')\",\n \"def fixture_example_data():\\n import_example_data()\",\n \"def load_s2(\\n human=True,\\n hla_type=None,\\n exclude_hla_type=None):\\n s2_path = join(DATA_DIR, 'calis_s2.csv')\\n df = pd.read_csv(s2_path)\\n mask = ~df.peptide.str.contains(bad_amino_acids)\\n if human:\\n mask &= df.host == 'Homo'\\n if hla_type:\\n mask &= df.HLA.str.contains(hla_type, na=False).astype('bool')\\n if exclude_hla_type:\\n mask &= ~df.HLA.str.contains(exclude_hla_type, na=False).astype('bool')\\n return df[mask]\",\n \"def add_hospital_feature(data):\\n data.loc[:, 'has_hospital'] = data.loc[:, 'district'].apply(\\n lambda x: mapping.SOFIA_HOSPITALS_TRUE_FALSE_MAPPING[x])\\n\\n return data\",\n \"def test_import(self, game=\\\"SuperMarioKart-Snes\\\"):\\n self.assertTrue(game in retro.data.list_games())\",\n \"def test_inserted_data(client):\\n data = pd.read_csv(\\\"housing.csv\\\")\\n data = format_data_housing(data)\\n House.insert_from_pd(data)\\n houses: DataFrame = pd.read_sql(\\\"SELECT * FROM house\\\", db.engine)\\n assert len(houses) == data.shape[0]\\n houses = house_results_to_dataframe(houses)\\n assert_frame_equal(houses, data, check_dtype=False)\",\n \"def test_census_county_population():\\n dataframe = get_county_population_dataframe()\\n boulder_county_row = dataframe.loc[dataframe['county_fips'] == 8013]\\n boulder_county_population = boulder_county_row.get('county_population')\\n assert float(boulder_county_population) == 326196\",\n \"def test_temperatures_when_data_present(self):\\n\\n temp_data = [(1.00, time.localtime()), (2.00, time.localtime()),\\n (3.00, time.localtime()), (4.00, time.localtime())]\\n\\n tt = TemperatureTracker(temp_data)\\n result = tt.temperatures()\\n for i in range(0, len(result)):\\n self.assertEqual(result[i][0], temp_data[i][0])\\n self.assertEqual(result[i][1], temp_data[i][1])\",\n \"def test_import_evidence_mapped(self, status):\\n object_generator = ObjectGenerator()\\n _, user = object_generator.generate_person(user_role=\\\"Creator\\\")\\n assessment = factories.AssessmentFactory()\\n assessment.add_person_with_role_name(user, \\\"Verifiers\\\")\\n assessment.status = status\\n db.session.commit()\\n\\n response = self.import_data(collections.OrderedDict([\\n (\\\"object_type\\\", \\\"Assessment\\\"),\\n (\\\"Code*\\\", assessment.slug),\\n (\\\"Evidence URL\\\", \\\"some url\\\"),\\n ]))\\n self._check_csv_response(response, {})\\n self.assert_asmnt_notifications()\",\n \"def test02Something(self):\\n\\n summaryFile = re.sub(\\\"\\\\.csv\\\",\\\"\\\",self.parsedFile)+\\\"_summary.csv\\\"\\n bmap = self.bm.load_summary(summaryFile,taxaList=[\\\"10090\\\"])\\n self.assertEqual(bmap['GG11117|c2_g1_i1'][0],'INT1_MOUSE')\\n self.assertEqual(bmap['GG11117|c2_g1_i1'][1],'68510')\\n \\n bmap = self.bm.load_summary(summaryFile,taxaList=[\\\"10090\\\"],trinityGene=True)\\n self.assertEqual(bmap['GG11117|c2_g1'][0],'INT1_MOUSE')\\n\\n bmap = self.bm.load_summary(summaryFile,taxaList=[\\\"10090\\\"],trinityGene=True,best=False)\\n self.assertEqual(bmap['GG11117|c2_g1'][0][0],'INT1_MOUSE')\\n self.assertEqual(bmap['GG11117|c2_g1'][0][4],0.0)\",\n \"def test_extract_per_individual_state_metadatum_from_sample_metadata(self):\\r\\n veil_expected = {'001': [6.9, 9.3],\\r\\n '006': [4.2, 5.1],\\r\\n '007': [12.0, 1.8],\\r\\n '008': [10.0, None]}\\r\\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"VeillonellaAbundance\\\",\\r\\n process_f=float)\\r\\n self.assertEqual(actual, veil_expected)\\r\\n\\r\\n # different metadata_category yields different result\\r\\n strep_expected = {'001': [57.4, 26],\\r\\n '006': [19, 15.2],\\r\\n '007': [33.2, 50],\\r\\n '008': [3.2, 20]}\\r\\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"StreptococcusAbundance\\\",\\r\\n process_f=float)\\r\\n self.assertEqual(actual, strep_expected)\\r\\n\\r\\n # different metadata_category yields different result\\r\\n response_expected = {'001': [\\\"Improved\\\", \\\"Improved\\\"],\\r\\n '006': [\\\"Improved\\\", \\\"Improved\\\"],\\r\\n '007': [\\\"Worsened\\\", \\\"Worsened\\\"],\\r\\n '008': [\\\"Worsened\\\", \\\"Worsened\\\"]}\\r\\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"Response\\\",\\r\\n process_f=str)\\r\\n self.assertEqual(actual, response_expected)\\r\\n\\r\\n # alt input file with more states\\r\\n expected = {'001': [6.9, 9.3, 10.1]}\\r\\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\\r\\n self.individual_states_and_responses_map_f2,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\", \\\"PostPost\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"VeillonellaAbundance\\\",\\r\\n process_f=float)\\r\\n self.assertEqual(actual, expected)\\r\\n\\r\\n # unlisted states are ignored\\r\\n expected = {'001': [6.9, 9.3]}\\r\\n actual = extract_per_individual_state_metadatum_from_sample_metadata(\\r\\n self.individual_states_and_responses_map_f2,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"VeillonellaAbundance\\\",\\r\\n process_f=float)\\r\\n self.assertEqual(actual, expected)\",\n \"def test_extract_per_individual_states_from_sample_metadata_invalid(self):\\r\\n self.assertRaises(KeyError,\\r\\n extract_per_individual_states_from_sample_metadata,\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"some-invalid-category\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\")\\r\\n self.assertRaises(KeyError,\\r\\n extract_per_individual_states_from_sample_metadata,\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"some-other-invalid-category\\\")\",\n \"def test_missing_color_by_value():\\n svl_string = \\\"\\\"\\\"\\n DATASETS bigfoot \\\"bigfoot.csv\\\"\\n SCATTER bigfoot X latitude Y temperature_mid COLOR BY\\n \\\"\\\"\\\"\\n\\n with pytest.raises(SvlMissingValue):\\n parse_svl(svl_string)\",\n \"def test_dbscan_hav_euc(self):\\n sp_file = os.path.join(\\\"tests\\\", \\\"data\\\", \\\"geolife\\\", \\\"geolife_staypoints.csv\\\")\\n sp = ti.read_staypoints_csv(sp_file, tz=\\\"utc\\\", index_col=\\\"id\\\", crs=\\\"epsg:4326\\\")\\n\\n # haversine calculation\\n _, loc_har = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=100, num_samples=1, distance_metric=\\\"haversine\\\", agg_level=\\\"dataset\\\"\\n )\\n # WGS_1984\\n sp.crs = \\\"epsg:4326\\\"\\n # WGS_1984_UTM_Zone_49N\\n sp = sp.to_crs(\\\"epsg:32649\\\")\\n\\n # euclidean calculation\\n _, loc_eu = sp.as_staypoints.generate_locations(\\n method=\\\"dbscan\\\", epsilon=100, num_samples=1, distance_metric=\\\"euclidean\\\", agg_level=\\\"dataset\\\"\\n )\\n\\n assert len(loc_har) == len(loc_eu)\",\n \"def test_import_assessments_with_templates(self):\\n\\n self.import_file(\\\"assessment_template_no_warnings.csv\\\")\\n response = self.import_file(\\\"assessment_with_templates.csv\\\")\\n self._check_csv_response(response, {})\\n\\n assessment = models.Assessment.query.filter(\\n models.Assessment.slug == \\\"A 4\\\").first()\\n\\n values = set(v.attribute_value for v in assessment.custom_attribute_values)\\n self.assertIn(\\\"abc\\\", values)\\n self.assertIn(\\\"2015-07-15\\\", values)\",\n \"def handle_missing_values(dataset, missing_values_header, missing_label):\\n\\n return dataset[dataset[missing_values_header] != missing_label]\",\n \"def test_read_dynamic_missing_row(self):\\n myisam_data_file = MyIsamDataFile(\\\"dataFiles/tests/examples/test_basics/myisam_table_one.MYD\\\")\\n myisam_data_file.column_types = [MYSQL_FIELD_TYPES.MYSQL_TYPE_LONG, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR]\\n self.assertRaises(MyIsamDataFileException, myisam_data_file.get_row, (6))\",\n \"def check_mapping_data(mapping_data, headers, filename_column):\\r\\n\\r\\n # First make sure there is a SampleID and filename_column present\\r\\n try:\\r\\n sample_id_ix = headers.index(\\\"SampleID\\\")\\r\\n except ValueError:\\r\\n raise ValueError(\\\"SampleID column not found in mapping file, please \\\" +\\r\\n \\\"check mapping file with validate_mapping_file.py\\\")\\r\\n\\r\\n try:\\r\\n filename_col_ix = headers.index(filename_column)\\r\\n except ValueError:\\r\\n raise ValueError(\\\"Specified column %s not found in mapping file.\\\" %\\r\\n filename_column)\\r\\n\\r\\n valid_mimarks = letters + digits + \\\".\\\"\\r\\n\\r\\n fasta_name_to_sample_id = {}\\r\\n\\r\\n fasta_names = []\\r\\n sample_ids = []\\r\\n for line in mapping_data:\\r\\n\\r\\n try:\\r\\n fasta_name_to_sample_id[basename(line[filename_col_ix].strip())] =\\\\\\r\\n line[sample_id_ix]\\r\\n except IndexError:\\r\\n raise IndexError(\\\"Missing filename column data in line %s \\\" %\\r\\n line)\\r\\n\\r\\n for curr_char in line[sample_id_ix]:\\r\\n if curr_char not in valid_mimarks:\\r\\n raise ValueError(\\\"Found invalid character in line: %s\\\\n\\\" %\\r\\n line + \\\"SampleIDs must be alphanumeric and . characters \\\" +\\r\\n \\\"only\\\")\\r\\n sample_ids.append(line[sample_id_ix].strip())\\r\\n fasta_names.append(line[filename_col_ix].strip())\\r\\n\\r\\n fasta_name_dups = duplicates_indices(fasta_names)\\r\\n if fasta_name_dups:\\r\\n raise ValueError(\\\"Found duplicate fasta names: %s\\\" %\\r\\n \\\"\\\\t\\\".join([fasta_name for fasta_name in fasta_name_dups.keys()]))\\r\\n\\r\\n sample_id_dups = duplicates_indices(sample_ids)\\r\\n if sample_id_dups:\\r\\n raise ValueError(\\\"Found duplicate SampleID names: %s\\\" %\\r\\n \\\"\\\\t\\\".join([sample_id for sample_id in sample_id_dups.keys()]))\\r\\n\\r\\n return fasta_name_to_sample_id\",\n \"def read_data(city='Chicago'):\\n df = pd.read_csv('train.csv')\\n df = df[df.City==city]\\n\\n # I will be using this dictionary to convert direction to degrees\\n degrees = {'N':0, 'NE':45, 'E':90, 'SE':135, 'S':180, 'SW':225, 'W':270, 'NW':315}\\n\\n df[\\\"EntryHeading_deg\\\"] = df.EntryHeading.apply(lambda x:degrees[x])\\n df[\\\"ExitHeading_deg\\\"] = df.ExitHeading.apply(lambda x:degrees[x])\\n df[\\\"TurnDegree\\\"] = (df.EntryHeading_deg-df.ExitHeading_deg).apply(lambda x: x if abs(x) <=180 else (x+360 if x<0 else x-360))\\n df[\\\"TurnDegree\\\"] = df.TurnDegree.apply(lambda x: x if x != -180 else x*-1)\\n\\n # Lets assign a number(StreetId) to each street\\n all_streets = np.concatenate([df.ExitStreetName.reindex().values, df.EntryStreetName.reindex().values])\\n # there are some nan values so lets just replace them with Unknown\\n street_name_list = ['Unknown' if type(x)==type(0.0) else x for x in all_streets]\\n street_names = {name: num for num, name in enumerate(street_name_list)}\\n df[\\\"EntryStreetId\\\"] = np.array([street_names[x] if x in street_names else -999 for x in df.EntryStreetName])\\n df[\\\"ExitStreetId\\\"] = np.array([street_names[x] if x in street_names else -999 for x in df.ExitStreetName])\\n\\n # we also want to categorize the street by its type (road, boulevard, ...)\\n street_types = {n: i for i, n in enumerate(np.unique([x.split()[-1] for x in street_names.keys()]))}\\n street_name_to_type = {}\\n for name in street_names.keys():\\n typ = name.split()[-1]\\n street_name_to_type[name] = street_types[typ]\\n df[\\\"EntryStreetType\\\"] = np.array([street_name_to_type[x] if x in street_names else -999 for x in df.EntryStreetName])\\n df[\\\"ExitStreetType\\\"] = np.array([street_name_to_type[x] if x in street_names else -999 for x in df.ExitStreetName])\\n\\n df[\\\"EnterHighway\\\"] = np.array([1 if type(x)==type('') and x.split()[-1] in ['Broadway', 'Parkway', 'Expressway', 'Highway'] else 0 for x in df.EntryStreetName])\\n df[\\\"ExitHighway\\\"] = np.array([1 if type(x)==type('') and x.split()[-1] in ['Broadway', 'Parkway', 'Expressway', 'Highway'] else 0 for x in df.ExitStreetName])\\n df['Season'] = np.array([1 if month in (12,1,2) else 2 if month in (6,7,8) else 3 for month in df.Month.reindex().values])\\n df['RushHour'] = np.array([1 if hour in (7,8,9) else 2 if hour in (16,17,18) else 3 if hour>=10 and hour<=15 else 4 for hour in df.Hour])\\n return df\",\n \"def load_default_atf_data():\\n df = load_dataframe(\\\"oqmd_1.2_voronoi_magpie_fingerprints\\\")\\n return df[df['N_species'] == 2].sample(frac=0.2)\",\n \"def test_extract_per_individual_state_metadatum_from_sample_metadata_invalid(\\r\\n self):\\r\\n self.assertRaises(KeyError,\\r\\n extract_per_individual_state_metadatum_from_sample_metadata,\\r\\n self.individual_states_and_responses_map_f1,\\r\\n state_category=\\\"TreatmentState\\\",\\r\\n state_values=[\\\"Pre\\\", \\\"Post\\\"],\\r\\n individual_identifier_category=\\\"PersonalID\\\",\\r\\n metadata_category=\\\"some-non-existant-category\\\",\\r\\n process_f=float)\",\n \"def test_invlaid_data(self):\\n # Currently, there are no PowerPlant or Project objects in the database\\n self.assertEqual(PowerPlant.objects.count(), 0)\\n self.assertEqual(Project.objects.count(), 0)\\n\\n # Call the command with invalid data.\\n # The first row is for a power plant, but it has an invalid latitude.\\n # The second row is for a project, but it has an invalid project capacity.\\n # The third row is for a project, but it has an invalid project capacity unit.\\n # The fourth row is for a power plant, but has an invalid status.\\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\\n\\n # Each of the objects were created, though the invalid data was not saved.\\n self.assertEqual(PowerPlant.objects.count(), 3)\\n self.assertEqual(Project.objects.count(), 2)\",\n \"def DataLoader():\\n #importing data\\n House_Prices_Uncleaned = pd.read_csv(\\\"zillow_data/Zip_zhvi_uc_sfrcondo_tier_0.33_0.67_sm_sa_mon.csv\\\")\\n #Cleaning house prices data\\n\\n House_Prices=pd.DataFrame(House_Prices_Uncleaned[\\\"RegionName\\\"][House_Prices_Uncleaned[\\\"CountyName\\\"]==\\\"New York County\\\"])\\n\\n House_Prices[\\\"Price\\\"]=pd.DataFrame(House_Prices_Uncleaned[\\\"2020-09-30\\\"])\\n\\n House_Rent_Uncleaned= pd.read_csv(\\\"zillow_data/Zip_ZORI_AllHomesPlusMultifamily_SSA.csv\\\")\\n\\n #Cleaning house rent data\\n House_Rent=pd.DataFrame(House_Rent_Uncleaned[\\\"RegionName\\\"])\\n House_Rent[\\\"Rent\\\"]=pd.DataFrame(House_Rent_Uncleaned[\\\"2020-09\\\"])\\n\\n return House_Prices, House_Rent\",\n \"def test_missing_data_sources(self):\",\n \"def import_building_from_excel(\\n project, building_name, construction_age, path_to_excel, sheet_names\\n):\\n\\n def warn_constructiontype(element):\\n \\\"\\\"\\\"Generic warning function\\\"\\\"\\\"\\n if element.construction_type is None:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the %s construction \\\"%s\\\" could not be loaded from the TypeBuildingElements.json, '\\n \\\"an error will occur due to missing data for calculation.\\\"\\n \\\"Check for spelling and the correct combination of building age and construction type.\\\"\\n \\\"Here is the list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"zone\\\"].iloc[0],\\n element.name,\\n group[\\\"OuterWallConstruction\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n bldg = Building(parent=project)\\n bldg.name = building_name\\n bldg.year_of_construction = construction_age\\n bldg.with_ahu = True # HardCodedInput\\n if bldg.with_ahu is True:\\n bldg.central_ahu.heat_recovery = True # HardCodedInput\\n bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput\\n bldg.central_ahu.temperature_profile = 25 * [273.15 + 18] # HardCodedInput\\n bldg.central_ahu.min_relative_humidity_profile = 25 * [0] # HardCodedInput\\n bldg.central_ahu.max_relative_humidity_profile = 25 * [1] # HardCodedInput\\n bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput\\n\\n # Parameters that need hard coding in teasers logic classes\\n # 1. \\\"use_set_back\\\" needs hard coding at aixlib.py in the init; defines\\n # if the in the useconditions stated\\n # heating_time with the respective set_back_temp should be applied.\\n # use_set_back = false -> all hours of the day\\n # have same set_temp_heat actual value: use_set_back = Check your current version!\\n # 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text\\n # file\\n # \\\"teaser / data / output / modelicatemplate / AixLib /\\n # AixLib_ThermalZoneRecord_TwoElement\\\"\\n # actual changes: Check your current version!\\n\\n # Parameters to be set for each and every zone (#HardCodedInput)\\n # -----------------------------\\n out_wall_tilt = 90\\n window_tilt = 90\\n ground_floor_tilt = 0\\n floor_tilt = 0\\n ceiling_tilt = 0\\n rooftop_tilt = 0\\n ground_floor_orientation = -2\\n floor_orientation = -2\\n rooftop_orientation = -1\\n ceiling_orientation = -1\\n # -----------------------------\\n\\n # load_building_data from excel_to_pandas DataFrame:\\n data = import_data(path_to_excel, sheet_names)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"UsageType\\\"])\\n print(\\\"List of present usage_types in the original Data set: \\\\n%s\\\" % usage_types)\\n\\n # define the zoning methodology/function\\n data = zoning_example(data)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"Zone\\\"])\\n print(\\\"List of zones after the zoning is applied: \\\\n%s\\\" % usage_types)\\n\\n # aggregate all rooms of each zone and for each set general parameter,\\n # boundary conditions\\n # and parameter regarding the building physics\\n zones = data.groupby([\\\"Zone\\\"])\\n for name, zone in zones:\\n\\n # Block: Thermal zone (general parameter)\\n tz = ThermalZone(parent=bldg)\\n tz.name = str(name)\\n tz.area = zone[\\\"NetArea[m²]\\\"].sum()\\n # room vice calculation of volume plus summing those\\n tz.volume = (\\n np.array(zone[\\\"NetArea[m²]\\\"]) * np.array(zone[\\\"HeatedRoomHeight[m]\\\"])\\n ).sum()\\n\\n # Block: Boundary Conditions\\n # load UsageOperationTime, Lighting, RoomClimate and InternalGains\\n # from the \\\"UseCondition.json\\\"\\n tz.use_conditions = UseConditions(parent=tz)\\n tz.use_conditions.load_use_conditions(zone[\\\"Zone\\\"].iloc[0], project.data)\\n\\n # Block: Building Physics\\n # Grouping by orientation and construction type\\n # aggregating and feeding to the teaser logic classes\\n grouped = zone.groupby([\\\"OuterWallOrientation[°]\\\", \\\"OuterWallConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n out_wall = OuterWall(parent=tz)\\n out_wall.name = (\\n \\\"outer_wall_\\\"\\n + str(int(group[\\\"OuterWallOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"OuterWallConstruction\\\"].iloc[0])\\n )\\n out_wall.area = group[\\\"OuterWallArea[m²]\\\"].sum()\\n out_wall.tilt = out_wall_tilt\\n out_wall.orientation = group[\\\"OuterWallOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n out_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"OuterWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(out_wall)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the OuterWallOrientation \\\"%s\\\" is '\\n \\\"neither float nor int, \\\"\\n \\\"hence this building element is not added.\\\\nHere is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\n These entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"OuterWallOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"WindowOrientation[°]\\\", \\\"WindowConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n window = Window(parent=tz)\\n window.name = (\\n \\\"window_\\\"\\n + str(int(group[\\\"WindowOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"WindowConstruction\\\"].iloc[0])\\n )\\n window.area = group[\\\"WindowArea[m²]\\\"].sum()\\n window.tilt = window_tilt\\n window.orientation = group[\\\"WindowOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n window.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"WindowConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(window)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the window orientation \\\"%s\\\" is neither '\\n \\\"float nor int, \\\"\\n \\\"hence this building element is not added. Here is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"WindowOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsGroundFloor\\\", \\\"FloorConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsGroundFloor\\\"].iloc[0] == 1:\\n ground_floor = GroundFloor(parent=tz)\\n ground_floor.name = \\\"ground_floor\\\" + str(\\n group[\\\"FloorConstruction\\\"].iloc[0]\\n )\\n ground_floor.area = group[\\\"NetArea[m²]\\\"].sum()\\n ground_floor.tilt = ground_floor_tilt\\n ground_floor.orientation = ground_floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ground_floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ground_floor)\\n elif group[\\\"IsGroundFloor\\\"].iloc[0] == 0:\\n floor = Floor(parent=tz)\\n floor.name = \\\"floor\\\" + str(group[\\\"FloorConstruction\\\"].iloc[0])\\n floor.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half of\\n # the floor belongs to this story\\n floor.tilt = floor_tilt\\n floor.orientation = floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(floor)\\n else:\\n warnings.warn(\\n \\\"Values for IsGroundFloor have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsGroundFloor \\\"%s\\\" and construction '\\n 'type \\\"%s\\\" '\\n \\\"has no floor nor groundfloor, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsGroundFloor\\\"].iloc[0],\\n group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsRooftop\\\", \\\"CeilingConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsRooftop\\\"].iloc[0] == 1:\\n rooftop = Rooftop(parent=tz)\\n rooftop.name = \\\"rooftop\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n rooftop.area = group[\\n \\\"NetArea[m²]\\\"\\n ].sum() # sum up area of respective\\n # rooftop parts\\n rooftop.tilt = rooftop_tilt\\n rooftop.orientation = rooftop_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n rooftop.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(rooftop)\\n elif group[\\\"IsRooftop\\\"].iloc[0] == 0:\\n ceiling = Ceiling(parent=tz)\\n ceiling.name = \\\"ceiling\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n ceiling.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half\\n # of the ceiling belongs to a story,\\n # the other half to the above\\n ceiling.tilt = ceiling_tilt\\n ceiling.orientation = ceiling_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ceiling.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ceiling)\\n else:\\n warnings.warn(\\n \\\"Values for IsRooftop have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsRooftop \\\"%s\\\" and construction type '\\n '\\\"%s\\\" '\\n \\\"has no ceiling nor rooftop, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsRooftop\\\"].iloc[0],\\n group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"InnerWallConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"InnerWallArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n in_wall = InnerWall(parent=tz)\\n in_wall.name = \\\"inner_wall\\\" + str(\\n group[\\\"InnerWallConstruction\\\"].iloc[0]\\n )\\n in_wall.area = group[\\\"InnerWallArea[m²]\\\"].sum() / 2 # only\\n # half of the wall belongs to each room,\\n # the other half to the adjacent\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n in_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"InnerWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(in_wall)\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with inner wall construction \\\"%s\\\" has no '\\n \\\"inner walls, since area = 0.\\\"\\n % (group[\\\"Zone\\\"].iloc[0], group[\\\"InnerWallConstructio\\\" \\\"n\\\"].iloc[0])\\n )\\n\\n # Block: AHU and infiltration #Attention hard coding\\n # set the supply volume flow of the AHU per zone\\n ahu_dict = {\\n \\\"Bedroom\\\": [15.778, 15.778],\\n \\\"Corridorsinthegeneralcarearea\\\": [5.2941, 5.2941],\\n \\\"Examinationortreatmentroom\\\": [15.743, 15.743],\\n \\\"MeetingConferenceseminar\\\": [16.036, 16.036],\\n \\\"Stocktechnicalequipmentarchives\\\": [20.484, 20.484],\\n \\\"WCandsanitaryroomsinnonresidentialbuildings\\\": [27.692, 27.692],\\n }\\n _i = 0\\n for key in ahu_dict:\\n if tz.name == key:\\n tz.use_conditions.min_ahu = ahu_dict[key][0]\\n tz.use_conditions.max_ahu = ahu_dict[key][1]\\n _i = 1\\n if _i == 0:\\n warnings.warn(\\n \\\"The zone %s could not be found in your ahu_dict. Hence, \\\"\\n \\\"no AHU flow is defined. The default value is \\\"\\n \\\"0 (min_ahu = 0; max_ahu=0\\\" % tz.name\\n )\\n\\n return project, data\",\n \"def test_dataset_found_when_querying_number_in_name(self):\\n models.Study.objects.all().delete()\\n # Use a different study to ensure that one of the pre-created datasets doesn't match.\\n study_name = 'unlikely_24601_dataset'\\n # Use an accession that won't match for one dataset but not the other\\n name_match = factories.StudyFactory.create(i_study_name=study_name, i_accession=123456)\\n phs_match = factories.StudyFactory.create(i_study_name='other_name', i_accession=24601)\\n url = self.get_url()\\n response = self.client.get(url, {'q': 246})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted(returned_pks),\\n sorted([name_match.i_accession, phs_match.i_accession]))\",\n \"def test_from_icao(self):\\n for icao, name, city in (\\n (\\\"KJFK\\\", \\\"John F Kennedy International Airport\\\", \\\"New York\\\"),\\n (\\\"kjfk\\\", \\\"John F Kennedy International Airport\\\", \\\"New York\\\"),\\n (\\\"KLAX\\\", \\\"Los Angeles International Airport\\\", \\\"Los Angeles\\\"),\\n (\\\"PHNL\\\", \\\"Daniel K Inouye International Airport\\\", \\\"Honolulu\\\"),\\n (\\\"EGLL\\\", \\\"London Heathrow Airport\\\", \\\"London\\\"),\\n ):\\n stn = station.Station.from_icao(icao)\\n self.assertIsInstance(stn, station.Station)\\n self.assertEqual(icao.upper(), stn.icao)\\n self.assertEqual(name, stn.name)\\n self.assertEqual(city, stn.city)\\n for bad in (\\\"1234\\\", 1234, None, True, \\\"\\\"):\\n with self.assertRaises(exceptions.BadStation):\\n station.Station.from_icao(bad)\",\n \"def load_country_code_data():\\n name_conversion = {\\n 'East Timor': 'Timor-Leste',\\n 'Republic of the Congo': 'Congo (Kinshasa)',\\n 'Ivory Coast': 'Cote d\\\\'Ivoire',\\n 'Macedonia': 'North Macedonia',\\n 'Myanmar': 'Burma',\\n 'Republic of Serbia': 'Serbia',\\n 'Taiwan': 'Taiwan*',\\n 'The Bahamas': 'Bahamas',\\n 'United Republic of Tanzania': 'Tanzania',\\n 'United States of America': 'US'\\n }\\n\\n shapefile = os.path.join('data', 'ne_110m_admin_0_countries.shp')\\n\\n gdf = gpd.read_file(shapefile)[['ADMIN', 'ADM0_A3', 'geometry']]\\n gdf.columns = ['country', 'country_code', 'geometry']\\n\\n gdf.loc[gdf['country'].isin(name_conversion.keys()), 'country'] = gdf['country'].map(name_conversion)\\n\\n return gdf\",\n \"def testTaxaData(self):\\n try:\\n numEukaryota = 0\\n numBacteria = 0\\n numVirus = 0\\n numArchaea = 0\\n numOther = 0\\n numUnclass = 0\\n logger.info(\\\"Loading taxonomy data\\\")\\n tU = TaxonomyUtils()\\n logger.info(\\\"Done loading taxonomy data\\\")\\n iCount = 0\\n entryD = self.__mU.doImport(self.__instanceSavePath, fmt=\\\"pickle\\\")\\n for entryId in entryD:\\n for entityId, eD in entryD[entryId][\\\"selected_polymer_entities\\\"].items():\\n taxId = eD[\\\"ncbi_taxonomy_id\\\"] if \\\"ncbi_taxonomy_id\\\" in eD else None\\n if taxId is None:\\n logger.debug(\\\"Missing taxId entryId %s entityId %s\\\", entryId, entityId)\\n continue\\n # lin = tU.getLineage(taxId)\\n # nmL = tU.getLineageNames(taxId)\\n ok1 = tU.isEukaryota(taxId)\\n if ok1:\\n numEukaryota += 1\\n ok3 = tU.isVirus(taxId)\\n if ok3:\\n numVirus += 1\\n ok2 = tU.isBacteria(taxId)\\n if ok2:\\n numBacteria += 1\\n #\\n ok4 = tU.isArchaea(taxId)\\n if ok4:\\n numArchaea += 1\\n #\\n ok5 = tU.isOther(taxId)\\n if ok5:\\n numOther += 1\\n #\\n ok6 = tU.isUnclassified(taxId)\\n if ok6:\\n numUnclass += 1\\n\\n if ok1 and (ok1 and ok2):\\n logger.info(\\\"taxid %r conflicting lineage\\\", taxId)\\n #\\n if not ok1 and not ok2 and not ok3 and not ok4 and not ok5 and not ok6:\\n logger.info(\\\"unassigned taxid %r\\\", taxId)\\n\\n logger.debug(\\\"taxId %r entryId %s entityId %s\\\", taxId, entryId, entityId)\\n iCount += 1\\n # if iCount > 5000:\\n # break\\n logger.info(\\\"Eukaryota %d Bacteria %d Virus %d Archaea %d Other/Syn %r Unclass %d\\\", numEukaryota, numBacteria, numVirus, numArchaea, numOther, numUnclass)\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def import_data(self, data):\\n # Import additional data for tuning\\n # data: a list of dictionarys, each of which has at least two keys, 'parameter' and 'value'\\n pass\",\n \"def test_get_return_default(self):\\n ars = self.ar[2009][11]['general']\\n self.assertTrue(ars.get('invalid_row') is None)\",\n \"def test_get_g_data_1(self):\\n self.db_filter.values = [40481]\\n\\n g_data = review.get_g_data(self.alchemist, self.db_filter, 40481)\\n\\n self.assertTrue(isinstance(g_data, list))\\n\\n for header in review.PG_HEADER:\\n with self.subTest(header=header):\\n self.assertTrue(header in g_data[0].keys())\\n self.assertFalse(isinstance(g_data[0][header], list))\",\n \"def test_parse_sample_sheet(self):\\n pass\",\n \"def test_lookup_different_columns(self):\\n lookup = ProbeSetLookup(lookup_data_fp=self.fp2,cols=(0,1))\\n self.assertEqual(lookup.lookup('1255_g_at'),['1421061_at'])\\n self.assertEqual(lookup.lookup('1294_at'),['1426970_a_at',\\n '1426971_at',\\n '1437317_at'])\",\n \"def test_data_creation_from_base_row(self, mock_read_csv):\\n f = StringIO(self.data_header + self.data_row)\\n reader = csv.DictReader(f)\\n mock_read_csv.return_value = reader\\n load_values()\\n self.assertEqual(CountyMortgageData.objects.count(), 1)\\n county = CountyMortgageData.objects.first()\\n fields = reader.fieldnames\\n fields.pop(fields.index('fips')) # test string separately\\n fields.pop(fields.index('open')) # 'open' is stored as 'total'\\n fields.pop(fields.index('date')) # date must be parsed before testing\\n self.assertEqual(county.fips, self.data_row_dict.get('fips'))\\n open_value = int(self.data_row_dict.get('open'))\\n self.assertEqual(county.total, open_value)\\n target_date = parser.parse(self.data_row_dict['date']).date()\\n self.assertEqual(county.date, target_date)\\n for field in fields: # remaining fields can be tested in a loop\\n self.assertEqual(\\n getattr(county, field), int(self.data_row_dict.get(field)))\\n # test computed values\\n self.assertEqual(\\n county.epoch,\\n int(target_date.strftime('%s')) * 1000)\\n self.assertEqual(\\n county.percent_90,\\n int(self.data_row_dict.get('ninety')) * 1.0 / open_value)\\n self.assertEqual(\\n county.percent_30_60,\\n (int(self.data_row_dict.get('thirty')) +\\n int(self.data_row_dict.get('sixty'))) * 1.0 / open_value)\",\n \"def test_correct_dataset_found_with_pht_in_name(self):\\n models.SourceTrait.objects.all().delete()\\n name_trait = factories.SourceDatasetFactory.create(\\n dataset_name='pht557',\\n source_study_version=self.source_study_version\\n )\\n pht_trait = factories.SourceDatasetFactory.create(\\n i_accession=557,\\n source_study_version=self.source_study_version\\n )\\n url = self.get_url(self.study.pk)\\n response = self.client.get(url, {'q': 'pht557'})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(len(returned_pks), 2)\\n self.assertIn(name_trait.pk, returned_pks)\\n self.assertIn(pht_trait.pk, returned_pks)\",\n \"def us31(self, file_path=None):\\n file_path = file_path if file_path else get_data_file_path('US31.ged')\\n family_tree = TreeLine().process_data(file_path)\\n us31_fail = []\\n indi_list = family_tree.get_indi_list()\\n for indi in indi_list:\\n spouse_list = indi.get_spouses(family_tree)\\n if len(spouse_list) == 0:\\n age = indi.get_age()\\n if age and age > 30:\\n warn_msg = f'{indi.name} age is {age} and has never been married'\\n print(warn_msg)\\n indi.err = TreeError(TreeError.TYPE_ANOMALY, TreeError.ON_INDI, 'US31', indi.id, warn_msg)\\n us31_fail.append(indi)\\n return us31_fail\",\n \"def test_id_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_event_swimmer_id(input_val)\\n self.assertEqual(output_val, self.line.event_swimmer_id)\",\n \"def test_import(import_data):\\n try:\\n df_tab = import_data()\\n logging.info(\\\"Testing import_data: Successfully Found File\\\")\\n except FileNotFoundError as err:\\n logging.error(\\\"Testing import_data: The file wasn't found\\\")\\n raise err\\n\\n try:\\n assert df_tab.shape[0] > 0\\n assert df_tab.shape[1] > 0\\n logging.info(\\\"Testing import_data: Successfully Available Data\\\")\\n except AssertionError as err:\\n logging.error(\\n \\\"Testing import_data: The file doesn't appear to have rows and columns\\\"\\n )\\n raise err\\n\\n return df_tab\",\n \"def load_data():\\n if _LOCATIONS_BY_ID:\\n return _LOCATIONS_BY_NAME, _LOCATIONS_BY_ID\\n\\n # We need to read the locations in order of country -> admin level 1 -> admin level 2 -> city.\\n # This is so that the higher resolution locations can look up the lower resolution locations\\n # that they belong to, and compute the necessary fields.\\n countries_by_code = _load_country_data(_DATA_FILES['country'])\\n admin1_by_code = _load_admin1_data(_DATA_FILES['admin_1'], countries_by_code)\\n admin2_by_code = _load_admin2_data(_DATA_FILES['admin_2'], countries_by_code, admin1_by_code)\\n _load_city_data(_DATA_FILES['city'], countries_by_code, admin1_by_code, admin2_by_code)\\n _add_alternate_names(_DATA_FILES['alt_wiki_names'])\\n _add_estimated_importances(_DATA_FILES['estimated_importance'])\\n\\n return _LOCATIONS_BY_NAME, _LOCATIONS_BY_ID\",\n \"def _import(self, data):\\n if isinstance(data, dict):\\n if len(data):\\n for key in data:\\n if data.get(key) is not None:\\n if not self.set(key, data.get(key)):\\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))\",\n \"def check_usability(hdulist):\\n status = True\\n\\n if 'INSTRUME' in hdulist[0].header:\\n if change_style(hdulist[0].header['INSTRUME']):\\n pass\\n else:\\n print (\\\"Not a valid value for INSTRUME: {}\\\".format(hdulist[0].header['INSTRUME']))\\n status = False\\n else:\\n print (\\\"Missing INSTRUME header in file \\\")\\n status = False\\n if 'REFTYPE' in hdulist[0].header:\\n pass\\n else:\\n print (\\\"Missing REFTYPE header in file \\\")\\n status = False\\n\\n return status\",\n \"def load_s1(\\n human=True,\\n peptide_length=None,\\n hla_type=None,\\n exclude_hla_type=None):\\n s1_path = join(DATA_DIR, 'calis_s1.csv')\\n df = pd.read_csv(s1_path)\\n mask = ~df.Peptide.str.contains(bad_amino_acids)\\n if human:\\n mask &= df.Species == 'Homo'\\n if peptide_length:\\n mask &= df.Peptide.str.len() == peptide_length\\n if hla_type:\\n mask &= df.MHC.str.contains(hla_type, na=False).astype('bool')\\n if exclude_hla_type:\\n contains_hla_type = df.MHC.str.contains(exclude_hla_type, na=False)\\n mask &= ~(contains_hla_type.astype('bool'))\\n return df[mask]\",\n \"def test_reading_warehouse_map(warehouse_map1):\\n map_ = (\\n (2, 2, 2, 2, 3),\\n (1, \\\"a\\\", 1, \\\"b\\\", 3),\\n (1, \\\"c\\\", 1, \\\"d\\\", 3),\\n (1, \\\"e\\\", 1, \\\"f\\\", 3),\\n (1, 4, 4, 4, 9),\\n )\\n assert map_ == warehouse_map1\",\n \"def test_prepare_essentiality_data(ijr904, combined_dataframe):\\n tested_dataframe = essential.prepare_essentiality_data(\\n join(dirname(__file__), \\\"data\\\", \\\"essentiality\\\", \\\"mock_essential.csv\\\"), ijr904\\n )\\n assert tested_dataframe.equals(combined_dataframe)\",\n \"def test_age_good_values(self):\\n for input_val, output_val in self.known_values:\\n self.line._parse_age(input_val)\\n self.assertEqual(output_val, self.line.age)\",\n \"def test_alien_data(self):\",\n \"def _check_hour_data(self, ls_row):\\n for attr in ['kt_re', 'kt_im', 'div', 'type', 'area_code']:\\n self._check_datum(attr, getattr(ls_row, attr))\",\n \"def isUndefinedData(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address) -> bool:\\n ...\",\n \"def init(city: str, country: str, list_of_streets: list):\\n if check(city, country, list_of_streets):\\n return get_sample_data(city, country, list_of_streets)\",\n \"def load_unicef_data():\\n fname = 'SOWC_combined_simple.csv'\\n\\n # Uses pandas to help with string-NaN-numeric data.\\n data = pd.read_csv(fname, na_values='_')\\n # Strip countries title from feature names.\\n features = data.axes[1][1:]\\n # Separate country names from feature values.\\n countries = data.values[:,0]\\n values = data.values[:,1:]\\n # Convert to numpy matrix for real.\\n values = np.asmatrix(values,dtype='float64')\\n\\n # Modify NaN values (missing values).\\n mean_vals = np.nanmean(values, axis=0)\\n inds = np.where(np.isnan(values))\\n values[inds] = np.take(mean_vals, inds[1])\\n return (countries, features, values)\",\n \"def test_read_dynamic_third_row(self):\\n myisam_data_file = MyIsamDataFile(\\\"dataFiles/tests/examples/test_basics/myisam_table_one.MYD\\\")\\n myisam_data_file.column_types = [MYSQL_FIELD_TYPES.MYSQL_TYPE_LONG, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR, MYSQL_FIELD_TYPES.MYSQL_TYPE_VARCHAR]\\n myisam_record = myisam_data_file.get_row(3)\\n myisam_values = [3, 'lastname 3', 'firstname 3', 'address 3', 'city 3']\\n self.assertEqual(myisam_record, myisam_values)\",\n \"def get_jhu(data_path: str, filter_: Union[dict, bool] = True) -> None:\\n # Where JHU stores their data\\n url_template = (\\\"https://raw.githubusercontent.com/CSSEGISandData/\\\"\\n \\\"COVID-19/master/csse_covid_19_data/\\\"\\n \\\"csse_covid_19_time_series/time_series_covid19_%s_%s.csv\\\")\\n\\n # Scrape the data\\n dfs = {}\\n for region in ['global', 'US']:\\n dfs[region] = {}\\n for kind in ['confirmed', 'deaths', 'recovered']:\\n url = url_template % (kind, region) # Create the full data URL\\n try:\\n df = pd.read_csv(url) # Download the data into a dataframe\\n except HTTPError:\\n print(\\\"Could not download data for %s, %s\\\" % (kind, region))\\n else:\\n if region == 'global':\\n has_no_province = df['Province/State'].isnull()\\n # Whole countries only; use country name as index\\n df1 = df[has_no_province].set_index('Country/Region')\\n more_dfs = []\\n for country in ['China', 'Canada', 'Australia']:\\n if country == 'Canada' and kind in 'recovered':\\n continue\\n is_c = df['Country/Region'] == country\\n df2 = df[is_c].sum(axis=0, skipna=False).to_frame().T\\n df2['Country/Region'] = country\\n df2 = df2.set_index('Country/Region')\\n more_dfs.append(df2)\\n df = pd.concat([df1] + more_dfs)\\n elif region == 'US':\\n # Use state name as index\\n for k, v in us_state_abbrev.items(): # get US state abbrev\\n if not us_state_abbrev[k].startswith('US_'):\\n us_state_abbrev[k] = 'US_' + v # Add 'US_' to abbrev\\n df.replace(us_state_abbrev, inplace=True)\\n df = df.set_index('Province_State')\\n df = df.groupby('Province_State').sum() # combine counties to create state level data\\n\\n df = df[[x for x in df if any(year in x for year in ['20', '21'])]] # Use only data columns\\n # 20 or 21 signifies 2020 or 2021\\n dfs[region][kind] = df # Add to dictionary of dataframes\\n\\n # Generate a list of countries that have \\\"good\\\" data,\\n # according to these criteria:\\n good_countries = get_countries(dfs['global'], filter_=filter_)\\n\\n # For each \\\"good\\\" country,\\n # reformat and save that data in its own .csv file.\\n source = dfs['global']\\n for country in tqdm(good_countries, desc='Countries'): # For each country\\n if country in ['Diamond Princess', 'MS Zaandam', 'Samoa',\\n 'Vanuatu', 'Marshall Islands', 'US', 'Micronesia']:\\n print(\\\"Skipping {}\\\".format(country))\\n continue\\n # If we have data in the downloaded JHU files for that country\\n if country in source['confirmed'].index:\\n df = pd.DataFrame(columns=['dates2', 'cum_cases', 'cum_deaths',\\n 'cum_recover', 'new_cases',\\n 'new_deaths', 'new_recover',\\n 'new_uninfected'])\\n df['dates2'] = source['confirmed'].columns\\n df['dates2'] = df['dates2'].apply(fix_jhu_dates)\\n df['cum_cases'] = source['confirmed'].loc[country].values\\n df['cum_deaths'] = source['deaths'].loc[country].values\\n df['cum_recover'] = source['recovered'].loc[country].values\\n df[['new_cases', 'new_deaths', 'new_recover']] = \\\\\\n df[['cum_cases', 'cum_deaths', 'cum_recover']].diff()\\n df['new_uninfected'] = df['new_recover'] + df['new_deaths']\\n\\n\\n try:\\n population = get_population_count(data_path, country)\\n df['population'] = population\\n except:\\n pass\\n\\n # Fill NaN with 0 and convert to int\\n dfs[country] = df.set_index('dates2').fillna(0).astype(int)\\n dfs[country].to_csv(data_path / ('covidtimeseries_%s.csv' % country))\\n\\n else:\\n print(\\\"No data for %s\\\" % country)\\n\\n source = dfs['US']\\n states = source['confirmed'].index.tolist()\\n us_recovery_data = covid_tracking_recovery(data_path)\\n for state in tqdm(states, desc='US States'): # For each country\\n if state in ['Diamond Princess', 'Grand Princess', 'MS Zaandam', 'US_AS']:\\n print(\\\"Skipping {}\\\".format(state))\\n continue\\n # If we have data in the downloaded JHU files for that country\\n if state in source['confirmed'].index:\\n df = pd.DataFrame(columns=['dates2', 'cum_cases', 'cum_deaths',\\n 'new_cases','new_deaths','new_uninfected'])\\n df['dates2'] = source['confirmed'].columns\\n df['dates2'] = df['dates2'].apply(fix_jhu_dates)\\n df['cum_cases'] = source['confirmed'].loc[state].values\\n df['cum_deaths'] = source['deaths'].loc[state].values\\n\\n df[['new_cases', 'new_deaths']] = df[['cum_cases', 'cum_deaths']].diff()\\n\\n # add recovery data\\n df.set_index('dates2', inplace=True)\\n df = df.merge(us_recovery_data[state], on='dates2', how='left')\\n df['new_uninfected'] = df['new_recover'] + df['new_deaths']\\n\\n try:\\n population = get_population_count(data_path, state)\\n df['population'] = population\\n except:\\n pass\\n # Fill NaN with 0 and convert to int\\n dfs[state] = df.fillna(0).astype(int)\\n dfs[state].to_csv(data_path /\\n ('covidtimeseries_%s.csv' % state))\\n else:\\n print(\\\"No data for %s\\\" % state)\",\n \"def csv_parser_test():\\r\\n data = csv_parser(myspreadsheet)\\r\\n print('Your data object:')\\r\\n pp = pprint.PrettyPrinter(indent=4)\\r\\n pp.pprint(data) \\r\\n # Did your parser work?\\r\\n for row_num, row in enumerate(data):\\r\\n try:\\r\\n assert len(row) == 3\\r\\n except AssertionError:\\r\\n print ((\\\"Row %s seems to be misparsed; its length is %s\\\") % (row_num, len(row)))\\r\\n # Check on one of the values:\\r\\n try:\\r\\n assert data[4][2] == 'Linguist'\\r\\n except AssertionError:\\r\\n print ((\\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\") % data[4][2])\\r\\n # Did you remember your int conversions?\\r\\n try:\\r\\n assert isinstance(data[0][0], int)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[0][0] should be an int\\\")\\r\\n # Did you remember your float conversions?\\r\\n try:\\r\\n assert isinstance(data[6][1], float)\\r\\n except AssertionError:\\r\\n print (\\\"Error: data[6][1] should be a float\\\")\",\n \"def test_getknowndata(self):\\n result = recordparser.getfields(self.rawdata, self.fieldmap,\\n self.sourcekeys)\\n self.assertEqual(self.knownvalues, result)\",\n \"def test_import_values_dense():\\n x = np.random.rand(7, 11)\\n export_data('/tmp/test.dense', x)\\n assert np.array_equal(x, import_data('/tmp/test.dense'))\",\n \"def load_census_data_uci(local_path: str,\\n write_data_locally: bool,\\n columns: Tuple[str],\\n uci_train_link_path: str,\\n uci_test_link_path: str,\\n seed: int=0\\n ) -> Tuple[pd.DataFrame]:\\n train_file, test_file = \\\"census-income.data\\\", \\\"census-income.test\\\"\\n if not local_path:\\n local_path = os.getcwd()\\n train_file_path = os.path.join(local_path, train_file)\\n test_file_path = os.path.join(local_path, test_file)\\n \\n # load training data \\n if train_file in os.listdir(local_path):\\n data_train = pd.read_csv(train_file_path, \\n index_col=0)\\n else:\\n data_train = pd.read_csv(uci_train_link_path, \\n header=None, \\n index_col=False, \\n names=columns)\\n \\n # load test data \\n if test_file in os.listdir(local_path):\\n data_test_orig = pd.read_csv(test_file_path, \\n index_col=0)\\n else:\\n data_test_orig = pd.read_csv(uci_test_link_path, \\n header=None, \\n index_col=False, \\n names=columns)\\n assert list(data_train.columns) == list(data_test_orig.columns)\\n\\n\\n # write loaded data to local path if they are not there already\\n if write_data_locally:\\n if train_file not in os.listdir(local_path):\\n data_train.to_csv(train_file_path)\\n if test_file not in os.listdir(local_path):\\n data_test_orig.to_csv(test_file_path)\\n\\n # drop instance weight ( in section 6.3 of the paper there is no mention\\n # of using instance_weight as sample weights for the loss functions)\\n data_train.drop(\\\"instance_weight\\\", axis=1, inplace=True)\\n data_test_orig.drop(\\\"instance_weight\\\", axis=1, inplace=True)\\n\\n # split original test data into training and validation as mentioned \\n # in the paper\\n data_val, data_test = train_test_split(data_test_orig, test_size=0.5, random_state=seed)\\n return data_train, data_val, data_test\",\n \"def load_data(self):\\n df= self.read_file()\\n for row,col in df.iterrows():\\n Employeeid = int(col['Empolyeeid'])\\n Employee_Name = col['Employee_Name']\\n Age = col['Age']\\n Salary = col['Salary']\\n self.table.put_item(\\n Item={\\n \\\"Employeeid\\\":Employeeid,\\n \\\"Employee_Name\\\": Employee_Name,\\n \\\"Age\\\": Age,\\n \\\"Salary\\\": Salary\\n }\\n )\\n return True\",\n \"def test_excel(test_data,tmp_path):\\n\\n for d in test_data:\\n\\n gpm = GenotypePhenotypeMap(genotype=d[\\\"genotype\\\"],\\n wildtype=d[\\\"wildtype\\\"],\\n phenotype=d[\\\"phenotype\\\"],\\n uncertainty=d[\\\"uncertainty\\\"])\\n\\n # Write excel file\\n excel_file = os.path.join(tmp_path,\\\"tmp.xlsx\\\")\\n gpm.to_excel(filename=excel_file)\\n assert os.path.isfile(excel_file)\\n\\n # Read in and make sure it worked.\\n new_gpm = gpmap.read_excel(filename=excel_file,wildtype=d[\\\"wildtype\\\"])\\n conftest.compare_gpmap(gpm,new_gpm)\\n\\n # Do not give wildtype. Should still work because the wildtype was\\n # inferred.\\n gpm_read = gpmap.read_excel(filename=excel_file)\\n conftest.compare_gpmap(gpm,gpm_read)\\n\\n # Check ability to read labels back in\\n site_labels = [f\\\"{x}\\\" for x in range(10,10+len(d[\\\"wildtype\\\"]),1)]\\n gpm = GenotypePhenotypeMap(genotype=d[\\\"genotype\\\"],\\n wildtype=d[\\\"wildtype\\\"],\\n site_labels=site_labels)\\n out_file = os.path.join(tmp_path,\\\"tmp.xlsx\\\")\\n gpm.to_excel(out_file)\\n\\n gpm_read = gpmap.read_excel(out_file)\\n\\n for i in range(len(gpm_read.site_labels)):\\n\\n # Skip virtual site_labels added for invariant sites\\n if len(d[\\\"mutations\\\"][i]) == 1:\\n continue\\n\\n assert gpm_read.site_labels[i] == gpm.site_labels[i]\\n\\n # Read in with bad wildtype. Should throw warning and then have\\n # sequential site labels.\\n with pytest.warns(UserWarning):\\n gpm_read = gpmap.read_excel(out_file,wildtype=d[\\\"mutant\\\"])\\n\\n assert np.array_equal(gpm_read.site_labels,range(len(d[\\\"wildtype\\\"])))\",\n \"def validate_types_and_id(metaDictionary, logger, filename):\\n result = True\\n # this validation only applies to items that have genetic_alteration_type and datatype and stable_id\\n if 'genetic_alteration_type' in metaDictionary and 'datatype' in metaDictionary and 'stable_id' in metaDictionary:\\n alt_type_datatype_and_stable_id = {}\\n script_dir = os.path.dirname(__file__)\\n allowed_data_types_file_name = os.path.join(script_dir, \\\"allowed_data_types.txt\\\")\\n data_line_nr = 0\\n # build up map alt_type_datatype_and_stable_id:\\n with open(allowed_data_types_file_name) as allowed_data_types_file:\\n for line in allowed_data_types_file:\\n if line.startswith(\\\"#\\\"):\\n continue\\n data_line_nr += 1\\n # skip header, so if line is not header then process as tab separated:\\n if (data_line_nr > 1):\\n line_cols = csv.reader([line], delimiter='\\\\t').next()\\n genetic_alteration_type = line_cols[0]\\n data_type = line_cols[1]\\n # add to map:\\n if (genetic_alteration_type, data_type) not in alt_type_datatype_and_stable_id:\\n alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)] = []\\n alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)].append(line_cols[2])\\n # init:\\n stable_id = metaDictionary['stable_id']\\n genetic_alteration_type = metaDictionary['genetic_alteration_type']\\n data_type = metaDictionary['datatype']\\n # validate the genetic_alteration_type/data_type combination:\\n if (genetic_alteration_type, data_type) not in alt_type_datatype_and_stable_id:\\n # unexpected as this is already validated in get_meta_file_type\\n raise RuntimeError('Unexpected error: genetic_alteration_type and data_type combination not found in allowed_data_types.txt.',\\n genetic_alteration_type, data_type)\\n # validate stable_id:\\n elif stable_id not in alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)]:\\n logger.error(\\\"Invalid stable id for genetic_alteration_type '%s', \\\"\\n \\\"data_type '%s'; expected one of [%s]\\\",\\n genetic_alteration_type,\\n data_type,\\n ', '.join(alt_type_datatype_and_stable_id[(genetic_alteration_type, data_type)]),\\n extra={'filename_': filename,\\n 'cause': stable_id}\\n )\\n result = False\\n\\n return result\",\n \"def test_with_data(self):\\n create_states()\\n response = self.client.get(reverse('education:states'))\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response.context.get(\\\"states\\\").count(), 52)\\n self.assertContains(response, \\\"Home\\\")\\n self.assertNotContains(response, \\\"No Data Available\\\")\\n self.assertContains(response, \\\"Number of Public High Schools\\\")\\n self.assertContains(response, \\\"Mississippi\\\")\\n self.assertContains(response, \\\"90.0%\\\")\\n self.assertContains(response, \\\"1,000\\\")\\n self.assertContains(response, \\\"10\\\")\",\n \"def test_export_data_on_nonexistent_user(self) -> None:\\n user_data = user_models.UserStatsModel.export_data(\\n self.NONEXISTENT_USER_ID)\\n test_data: Dict[str, str] = {}\\n self.assertEqual(user_data, test_data)\",\n \"def test_lat_not_loc_1(self):\\n patient = Semiology('lat_not_loc', Laterality.LEFT, Laterality.LEFT)\\n patient.data_frame = self.df\\n lat_not_loc_all_combined_gifs = patient.query_lateralisation(\\n one_map_dummy)\\n\\n # inspect result\\n lat_not_loc_result, num_query_loc = patient.query_semiology()\\n\\n self.assertIs(type(lat_not_loc_all_combined_gifs), pd.DataFrame)\\n assert not lat_not_loc_all_combined_gifs.empty\\n\\n # drop the zero entries as these are from the CL/IL zeros:\\n lat_not_loc_all_combined_gifs = lat_not_loc_all_combined_gifs[['Gif Parcellations', 'pt #s']].astype(\\n {'Gif Parcellations': 'int32', 'pt #s': 'int32'})\\n lat_not_loc_all_combined_gifs.set_index(\\n 'Gif Parcellations', inplace=True)\\n lat_not_loc_gifsclean = lat_not_loc_all_combined_gifs.loc[\\n lat_not_loc_all_combined_gifs['pt #s'] != 0, :]\\n # now we know only the CL data remains in this dummy data, which is on the RIGHT.\\n gifs_right, gifs_left = gifs_lat_factor()\\n lat_not_loc_gifsclean_rights = (\\n lat_not_loc_gifsclean.index.isin(gifs_right).all()\\n )\\n\\n # inspect result assertions\\n assert(lat_not_loc_result.Localising.sum() == 0)\\n assert(lat_not_loc_result['Lateralising'].sum() == 1)\\n\\n # all_combined_gifs assertions\\n assert((\\n lat_not_loc_gifsclean_rights == True)\\n )\\n assert(\\n (\\n lat_not_loc_gifsclean.index.isin(gifs_left)).any() == False\\n )\\n assert (lat_not_loc_gifsclean['pt #s'].sum()\\n == lat_not_loc_gifsclean.shape[0])\\n\\n # test MTG on right 155 gif # gives 1:\\n heatmap, _ = patient.get_num_datapoints_dict(method='minmax')\\n assert 156 not in heatmap # left\\n assert heatmap[155] == 1 # right\",\n \"def test_correct_dataset_found_with_pht_in_name(self):\\n models.SourceTrait.objects.all().delete()\\n name_trait = factories.SourceDatasetFactory.create(dataset_name='pht557')\\n pht_trait = factories.SourceDatasetFactory.create(i_accession=557)\\n url = self.get_url()\\n response = self.client.get(url, {'q': 'pht557'})\\n returned_pks = get_autocomplete_view_ids(response)\\n self.assertEqual(len(returned_pks), 2)\\n self.assertIn(name_trait.pk, returned_pks)\\n self.assertIn(pht_trait.pk, returned_pks)\",\n \"def test_c_get_existing_records(self):\\n\\n success = True\\n records = get_existing_records(location, database)\\n\\n if records['variable'].values[0] != value:\\n success = False\\n\\n for function in records['function'].values:\\n if function not in outcome_methods:\\n success = False\\n\\n if records[records['function'] == 'nanmean']['value'].values != 2.143:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_25']['value'].values != 1.0:\\n success = False\\n\\n if records[records['function'] == 'nanpercentile_75']['value'].values != 2.5:\\n success = False\\n\\n if not np.isnan(records[records['function'] == 'std']['value'].values[0]):\\n success = False\\n\\n assert(success)\",\n \"def test_parse_flag_file_1(self):\\n flag_file = Path(test_file_dir, \\\"test_flag_file_1.csv\\\")\\n flag_dict = basic.parse_flag_file(flag_file)\\n with self.subTest():\\n self.assertEqual(len(flag_dict.keys()), 3)\\n with self.subTest():\\n self.assertTrue(flag_dict[\\\"check_a\\\"])\\n with self.subTest():\\n self.assertFalse(flag_dict[\\\"check_b\\\"])\\n with self.subTest():\\n self.assertFalse(flag_dict[\\\"check_c\\\"])\",\n \"def csv_parser_test():\\n data = csv_parser(myspreadsheet)\\n print 'Your data object:'\\n pp = pprint.PrettyPrinter(indent=4)\\n pp.pprint(data) \\n # Did your parser work?\\n for row_num, row in enumerate(data):\\n try:\\n assert len(row) == 3\\n except AssertionError:\\n print \\\"Row %s seems to be misparsed; its length is %s\\\" % (row_num, len(row))\\n # Check on one of the values:\\n try:\\n assert data[4][2] == 'Linguist'\\n except AssertionError:\\n print \\\"Error: data[4][2] should equal 'Linguist'; actual value is %s\\\" % data[4][2]\\n # Did you remember your int conversions?\\n try:\\n assert isinstance(data[0][0], int)\\n except AssertionError:\\n print \\\"Error: data[0][0] should be an int\\\"\\n # Did you remember your float conversions?\\n try:\\n assert isinstance(data[6][1], float)\\n except AssertionError:\\n print \\\"Error: data[6][1] should be a float\\\"\",\n \"def test_with_data(self):\\n create_states()\\n response = self.client.get(reverse('education:index'))\\n self.assertEqual(response.status_code, 200)\\n self.assertNotEqual(response.context.get(\\\"json_data\\\"), None)\\n self.assertContains(response, \\\"High School Graduation\\\")\\n self.assertContains(response, \\\"How Rates Were Calculated\\\")\\n self.assertContains(response, '<svg id=\\\"graduation_rate_map\\\"')\",\n \"def test_SampleIds(self):\\r\\n exp = [\\\"PC.354\\\", \\\"PC.355\\\", \\\"PC.356\\\", \\\"PC.481\\\", \\\"PC.593\\\", \\\"PC.607\\\",\\r\\n \\\"PC.634\\\", \\\"PC.635\\\", \\\"PC.636\\\"]\\r\\n obs = self.overview_map.SampleIds\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n obs = self.no_metadata.SampleIds\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n obs = self.empty_map.SampleIds\\r\\n self.assertEqual(obs, [])\",\n \"def test_invalid_request_values(self):\\n TEST_DATA = [\\n (-100, 0, 0, 0),\\n (100, 0, 0, 0),\\n (0, -190, 0, 0),\\n (0, 190, 0, 0),\\n (0, 0, 0, -10),\\n (0, 0, 0, 370)\\n ] # yapf: disable\\n for (lat, lon, alt, heading) in TEST_DATA:\\n self.assertEqual(400,\\n self.eval_request_values(lat, lon, alt, heading))\",\n \"def test_check_data_fields(self):\\r\\n\\r\\n header =\\\\\\r\\n ['SampleID',\\r\\n 'BarcodeSequence',\\r\\n 'LinkerPrimerSequence',\\r\\n 'Description']\\r\\n mapping_data = [['s1', 'ACGT', 'AAAA', 's1_data'],\\r\\n ['s2', 'CGTA', 'AAAA', 's2_data']]\\r\\n errors = []\\r\\n warnings = []\\r\\n\\r\\n errors, warnings = check_data_fields(header,\\r\\n mapping_data, errors, warnings)\\r\\n\\r\\n expected_errors = []\\r\\n expected_warnings = []\\r\\n\\r\\n self.assertEqual(errors, expected_errors)\\r\\n self.assertEqual(warnings, expected_warnings)\",\n \"def test_valid_country():\\n assert valid_country(\\\"Democratic Republic of Lungary\\\") is True\\n assert valid_country(\\\"Kraznoviklandstan\\\") is True\\n assert valid_country(\\\"kraznoviklandstan\\\") is True\\n assert valid_country(\\\"KRAZNOVIKLANDSTAN\\\") is True\\n\\n assert valid_country(\\\"Democratic_Republic982759\\\") is False\\n assert valid_country(\\\"Kraznoviklandsta\\\") is False\\n assert valid_country(\\\"Principalities of Fryed\\\") is False\\n assert valid_country(\\\"FRY\\\") is False\",\n \"def test_get_return_default_provided(self):\\n ars = self.ar[2009][11]['general']\\n self.assertEqual(ars.get('invalid_row', 'ZZZZZZ'), 'ZZZZZZ')\",\n \"def test_country_code(self):\\n\\t\\tcountry_name = 'United States'\\n#\\t\\tpopulation = int(float(pop_dict['Value']))\\n\\t\\tcode = get_country_code(country_name)\\t\\t\\n\\t\\t#Assert methods verifies result received matches expected one\\n\\t\\tself.assertEqual(code, 'usa')\",\n \"def test_SampleIds(self):\\n exp = [\\\"PC.354\\\", \\\"PC.355\\\", \\\"PC.356\\\", \\\"PC.481\\\", \\\"PC.593\\\", \\\"PC.607\\\",\\n \\\"PC.634\\\", \\\"PC.635\\\", \\\"PC.636\\\"]\\n obs = self.overview_map.SampleIds\\n self.assertEqual(obs, exp)\\n\\n obs = self.no_metadata.SampleIds\\n self.assertEqual(obs, exp)\\n\\n obs = self.empty_map.SampleIds\\n self.assertEqual(obs, [])\",\n \"def test_incorrect_data_type_plate():\\n \\n test_object = fa.read_in_envision(data_csv=list_A, platemap_csv=plate_map_file, data_type='plate', size=384)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5858138","0.5747929","0.557032","0.5442017","0.5428693","0.54078037","0.5387139","0.53781325","0.53706044","0.5339871","0.53369933","0.5305489","0.5301975","0.5299098","0.5246788","0.5234629","0.5231527","0.52192","0.52166295","0.5214664","0.5204877","0.5200792","0.5186949","0.5183266","0.51695013","0.51627475","0.5159448","0.5141205","0.5141196","0.5139459","0.51383567","0.513153","0.5128432","0.5121249","0.5117363","0.5116537","0.5108433","0.51043844","0.5097247","0.50966847","0.5095784","0.5090788","0.50773686","0.5073949","0.50733966","0.5068685","0.5062846","0.5048682","0.5045334","0.5039299","0.50343907","0.5033436","0.5031365","0.5028095","0.50191104","0.50180066","0.5017406","0.50145805","0.5014532","0.5011999","0.5008236","0.5006704","0.5006656","0.50032765","0.50026214","0.49955553","0.499449","0.4994337","0.4983968","0.49821672","0.4980268","0.49800006","0.49799415","0.49791658","0.4975351","0.49748555","0.49676648","0.4965611","0.49635053","0.49621102","0.4959871","0.49544165","0.49510673","0.49490592","0.494455","0.4944221","0.49435383","0.49383757","0.49380478","0.4937655","0.4935894","0.49319667","0.49269328","0.49263576","0.49256986","0.49256337","0.49253613","0.49249804","0.49174228","0.4911398","0.4911019"],"string":"[\n \"0.5858138\",\n \"0.5747929\",\n \"0.557032\",\n \"0.5442017\",\n \"0.5428693\",\n \"0.54078037\",\n \"0.5387139\",\n \"0.53781325\",\n \"0.53706044\",\n \"0.5339871\",\n \"0.53369933\",\n \"0.5305489\",\n \"0.5301975\",\n \"0.5299098\",\n \"0.5246788\",\n \"0.5234629\",\n \"0.5231527\",\n \"0.52192\",\n \"0.52166295\",\n \"0.5214664\",\n \"0.5204877\",\n \"0.5200792\",\n \"0.5186949\",\n \"0.5183266\",\n \"0.51695013\",\n \"0.51627475\",\n \"0.5159448\",\n \"0.5141205\",\n \"0.5141196\",\n \"0.5139459\",\n \"0.51383567\",\n \"0.513153\",\n \"0.5128432\",\n \"0.5121249\",\n \"0.5117363\",\n \"0.5116537\",\n \"0.5108433\",\n \"0.51043844\",\n \"0.5097247\",\n \"0.50966847\",\n \"0.5095784\",\n \"0.5090788\",\n \"0.50773686\",\n \"0.5073949\",\n \"0.50733966\",\n \"0.5068685\",\n \"0.5062846\",\n \"0.5048682\",\n \"0.5045334\",\n \"0.5039299\",\n \"0.50343907\",\n \"0.5033436\",\n \"0.5031365\",\n \"0.5028095\",\n \"0.50191104\",\n \"0.50180066\",\n \"0.5017406\",\n \"0.50145805\",\n \"0.5014532\",\n \"0.5011999\",\n \"0.5008236\",\n \"0.5006704\",\n \"0.5006656\",\n \"0.50032765\",\n \"0.50026214\",\n \"0.49955553\",\n \"0.499449\",\n \"0.4994337\",\n \"0.4983968\",\n \"0.49821672\",\n \"0.4980268\",\n \"0.49800006\",\n \"0.49799415\",\n \"0.49791658\",\n \"0.4975351\",\n \"0.49748555\",\n \"0.49676648\",\n \"0.4965611\",\n \"0.49635053\",\n \"0.49621102\",\n \"0.4959871\",\n \"0.49544165\",\n \"0.49510673\",\n \"0.49490592\",\n \"0.494455\",\n \"0.4944221\",\n \"0.49435383\",\n \"0.49383757\",\n \"0.49380478\",\n \"0.4937655\",\n \"0.4935894\",\n \"0.49319667\",\n \"0.49269328\",\n \"0.49263576\",\n \"0.49256986\",\n \"0.49256337\",\n \"0.49253613\",\n \"0.49249804\",\n \"0.49174228\",\n \"0.4911398\",\n \"0.4911019\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":864,"numItemsPerPage":100,"numTotalItems":95772,"offset":86400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTkyOTg4MiwianRpIjoiZWNiYTRkMDMtYTMwNS00ODBiLTkwZGQtYzI4ZTA3YWMwNmIyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU5MzM0ODIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.9Ms8FjB0w-rrfVF1LhBoV_k9jC8vSLSoGUKnGqCZmq2PjMxdIALQAA6s-G-kXce3bebhQGe77C9blp6G5DIdDQ","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 |
|---|---|---|---|---|---|---|
Calculates full IPv6 Address from configured prefix part (assigned_ip_block) + unique session prefix part + interface identifier | def alloc_ip_address(self, sid: str, _) -> IPDesc:
if not self._assigned_ip_block:
raise NoAvailableIPError('No IP block assigned to the allocator')
# Take available ipv6 host from network
ipv6_addr_part = next(self._assigned_ip_block.hosts())
# Calculate session part from r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PrefixIpv6Address(self):\n if self.force_auto_sync:\n self.get('PrefixIpv6Address')\n return self._PrefixIpv6Address",
"def _get_ipv6_addresses(self, host: str) -> Dict[str, List[IPv6Address]]:\n if host == \"self\":\n command = \"show ipv6 interface\"\n elif... | [
"0.6910526",
"0.65779537",
"0.6209948",
"0.61726016",
"0.6144157",
"0.61233974",
"0.60638624",
"0.604678",
"0.60410076",
"0.6017673",
"0.59840125",
"0.59752476",
"0.59653044",
"0.5943439",
"0.59116113",
"0.5887834",
"0.58841777",
"0.5866893",
"0.5860087",
"0.584282",
"0.58301... | 0.58512235 | 19 |
Deallocates session prefix part from identifier and allocated IID | def release_ip(self, ip_desc: IPDesc):
sid = ip_desc.sid
ip_addr = ip_desc.ip
if not self._assigned_ip_block or not ip_addr:
return
ipv6_addr_part = int(next(self._assigned_ip_block.hosts()))
session_prefix = self._store.sid_session_prefix_allocated.get(sid)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, session: \"pwncat.manager.Session\"):",
"def __del__(self):\n\t\tself._pc.gid_clear()",
"def uninstall_mac_processor(interface, mac_profile):\n pass",
"def __del__(self) -> None:\n self.map.ent_id.discard(self.id)",
"def __del__(self) -> None:\n self.map.face_id.discard(se... | [
"0.54009336",
"0.5383645",
"0.528721",
"0.5048347",
"0.50450915",
"0.50395787",
"0.5034124",
"0.50252444",
"0.4981584",
"0.49631837",
"0.4954482",
"0.48777702",
"0.48424858",
"0.4835618",
"0.4832245",
"0.4826465",
"0.48210236",
"0.47948185",
"0.47716922",
"0.47629887",
"0.475... | 0.0 | -1 |
Calculates IPv6 Interface identifier using random calculation, if it exceeds MAX_RAND calculation tries, it returns None | def _get_ipv6_iid_part(self, sid: str, length: int = 64) -> Optional[int]:
for _ in range(MAX_CALC_TRIES):
rand_iid_bits = random.getrandbits(length)
if rand_iid_bits not in self._store.allocated_iid.values():
self._store.allocated_iid[sid] = float(rand_iid_bits)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_global_ip_ipv6():\n network_info_providers = [\n 'http://v6.ipv6-test.com/api/myip.php',\n 'http://v6.ident.me/',\n ]\n random.shuffle(network_info_providers)\n for url in network_info_providers:\n try:\n return requests.get(url).text.lstrip().rstrip()\n e... | [
"0.68891776",
"0.64426214",
"0.620123",
"0.6159654",
"0.604859",
"0.60376155",
"0.5968478",
"0.58275694",
"0.58260953",
"0.57802504",
"0.5730758",
"0.5716164",
"0.5675554",
"0.5665045",
"0.56566995",
"0.565064",
"0.5581765",
"0.5577801",
"0.55600667",
"0.54716736",
"0.5455122... | 0.7597928 | 0 |
Returns unique session prefix using configurable allocation mode, it return None if it exceeds MAX calculation tries | def _get_session_prefix(self, sid: str) -> Optional[int]:
if not self._assigned_ip_block:
return None
session_prefix_len = IPV6_PREFIX_PART_LEN - self._assigned_ip_block.prefixlen
session_prefix_allocated = self._store.sid_session_prefix_allocated.get(
sid,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_session_key():\r\n\tresult = \"\"\r\n\tfor i in range(1, 11):\r\n\t\tresult += str(int(9 * random.random())+1)[0]\r\n\treturn result",
"def session_scope_prefix():\n return ''.join(choice(ascii_uppercase) for _ in range(6)) + '-'",
"def generate_session_id():\n return utils.get_32bit_random_n... | [
"0.6613998",
"0.6112346",
"0.594193",
"0.58871245",
"0.5856393",
"0.5854491",
"0.5833352",
"0.58139443",
"0.56881344",
"0.56545293",
"0.56332517",
"0.5606701",
"0.5599535",
"0.5568258",
"0.5566027",
"0.5544654",
"0.5539258",
"0.5526119",
"0.548038",
"0.54656816",
"0.54589933"... | 0.77052504 | 0 |
returns a distribtution of users language | def get_language_distribution(username):
users_repos, api_calls = get_repos(username)
language_count = {}
for repo in users_repos:
language_count[repo.language] = language_count.get(repo.language, 0) + 1
return language_count, api_calls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_language() -> str:\n languages = {\n \"arabic\": \"arb\",\n \"chinese\": \"cmn-CN\",\n \"danish\": \"da-DK\",\n \"english\": \"en-GB\",\n \"french\": \"fr-FR\",\n \"german\": \"de-DE\",\n \"portuguese\": \"pl-PT\",\n \"spanish\": \"es-ES\"\n ... | [
"0.67478734",
"0.6641548",
"0.66355497",
"0.6397517",
"0.6390574",
"0.634528",
"0.62134975",
"0.6182951",
"0.6168857",
"0.61553353",
"0.61037403",
"0.60909534",
"0.60517937",
"0.6047791",
"0.6003909",
"0.59509397",
"0.5943521",
"0.5928852",
"0.5909752",
"0.5901832",
"0.588105... | 0.59818065 | 15 |
returns repos sorted by a function specific to the user | def repo_reccommender_by_language(username):
# get a BFS of 100 repos or all of their second-degree repos (rate-limiting ourselves along the way)
# we have to get their language
# ideally i would get all of their repos, then get the full byte distribution of all the repos,
# but unfortunately that... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getuserrepos(gh, user):\n repos = list()\n pages = int(math.ceil(n_public_repos(gh, user) / float(R_PAGE)))\n for i in range(pages):\n # github index their pages from 1, hence the +1\n qs = user + \"/repos?page=\" + str(i + 1)\n repos.extend(gh.users(qs).get())\n return repos",... | [
"0.65797734",
"0.6357986",
"0.6169354",
"0.61645705",
"0.6126076",
"0.59924364",
"0.59314895",
"0.59142524",
"0.59004796",
"0.5889744",
"0.5883316",
"0.583544",
"0.58113974",
"0.5799293",
"0.57418406",
"0.56899685",
"0.5682869",
"0.5678501",
"0.56633633",
"0.56563205",
"0.560... | 0.66649884 | 0 |
gets a user as input from the user gets the users top languages gets the reccomended repos by language outputs information to the user | def repo_reccommender():
username = raw_input('Enter a username > ')
language_sorted_repos = repo_reccommender_by_language(username)
print "getting language distribution..."
language_distribution, api_calls = get_language_distribution(username)
top_languages = sorted(language_distribu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n for feature in [\"stars\", \"forks\"]:\n top_repos = get_top_repos(feature, 100)\n languages = dict()\n for repo in top_repos:\n repo_lang = get_languages_info(repo)\n languages = merge_dicts(repo_lang, languages)\n languages = sort_dict_by_values(... | [
"0.71570027",
"0.613498",
"0.5938341",
"0.5896585",
"0.554118",
"0.54729676",
"0.5383736",
"0.5352208",
"0.5300897",
"0.5294068",
"0.5266819",
"0.5192093",
"0.5187008",
"0.51816845",
"0.51671326",
"0.51529074",
"0.51410156",
"0.5128342",
"0.5122156",
"0.5088876",
"0.5053089",... | 0.69052 | 1 |
Invoke kinit command with credential parameters. | def invoke_kinit(user, password):
proc = subprocess.Popen(['kinit', '--version'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE, universal_newlines=True)
output = " ".join(proc.communicate())
if "Heimdal" in output:
# Heimdal Kerberos implementation.
with tempfil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_cmd(ctx: click.Context, create_certs: str):\r\n from pathlib import Path\r\n from .init_funcs import init\r\n\r\n init(Path(create_certs) if create_certs is not None else None, ctx.obj[\"root_path\"])",
"def provider_init(self) -> str:\n return self.context.get(\"/ckks/provider/init\", N... | [
"0.61337215",
"0.59598976",
"0.5945157",
"0.58642584",
"0.5745467",
"0.570381",
"0.5647389",
"0.56395113",
"0.56101763",
"0.55136085",
"0.5466123",
"0.54543585",
"0.5422648",
"0.5399167",
"0.5387691",
"0.5384564",
"0.5343504",
"0.5337933",
"0.53334135",
"0.5316237",
"0.528744... | 0.750472 | 0 |
Set network delay and wait for a TimeoutError during search. | def receive_search_timeout(client, ipaddr, search_dn):
conn = client.connect()
proxy = rpc.ServerProxy("http://%s:%d/" % (ipaddr, 8000))
proxy.set_delay(6.1)
time.sleep(3.0)
return conn.search(search_dn, 1, timeout=3.2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_timeout(self, connect_timeout, read_timeout, search_timeout = None):\n self.timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = read_timeout)\n if (search_timeout != None):\n self.search_timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = s... | [
"0.6397809",
"0.6393789",
"0.63774186",
"0.6359635",
"0.6314871",
"0.6286007",
"0.625403",
"0.6253369",
"0.6244708",
"0.6162222",
"0.6126679",
"0.6104902",
"0.5908944",
"0.5907687",
"0.5897068",
"0.5891048",
"0.5871515",
"0.5843934",
"0.58401537",
"0.58351934",
"0.5822568",
... | 0.5839808 | 19 |
Set network delay and wait for a TimeoutError during whoami. | def receive_whoami_timeout(client, ipaddr):
conn = client.connect()
proxy = rpc.ServerProxy("http://%s:%d/" % (ipaddr, 8000))
proxy.set_delay(6.1)
time.sleep(3.0)
return conn.whoami(timeout=3.2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timeout(self):\n self._status_update(\"Pyloton: Timeout\")\n time.sleep(3)",
"def _timeout(delay):\n loop = asyncio.get_running_loop()\n return _Timeout(loop.time() + delay if delay is not None else None)",
"def set_timeout(self, timeout):\n self.timeout = timeout",
"def set_timeou... | [
"0.6217196",
"0.6111047",
"0.6017958",
"0.5990512",
"0.58705217",
"0.5795436",
"0.57816774",
"0.57786757",
"0.5769765",
"0.5763559",
"0.5720535",
"0.5702743",
"0.56964594",
"0.56891686",
"0.5687772",
"0.5677685",
"0.56613404",
"0.5650001",
"0.564143",
"0.56334734",
"0.5632506... | 0.5314187 | 48 |
Set LDAP URL and open connection. | def setUp(self):
curdir = os.path.abspath(os.path.dirname(__file__))
self.cfg = configparser.ConfigParser()
self.cfg.read(os.path.join(curdir, 'test.ini'))
self.ipaddr = self.cfg["SERVER"]["hostip"]
self.url = "ldap://%s:%s/ou=nerdherd,%s?%s?%s" % \
(self.cfg["SERVER"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self):\n conf = self.conf\n\n if not conf.uris or not conf.base:\n raise ConfigError('Base DN and LDAP URI(s) must be provided.', 1)\n\n if conf.tls_require_cert is not None:\n if conf.tls_require_cert not in [ldap.OPT_X_TLS_DEMAND, ldap.OPT_X_TLS_HARD]:\n ... | [
"0.72773224",
"0.72446734",
"0.68512195",
"0.6373252",
"0.631165",
"0.6288941",
"0.62554586",
"0.6027716",
"0.5974323",
"0.58640504",
"0.5747047",
"0.5709453",
"0.5663428",
"0.5642652",
"0.56288767",
"0.55807847",
"0.5500194",
"0.5495493",
"0.54281527",
"0.5393592",
"0.525447... | 0.5556497 | 16 |
Test DIGESTMD5 connection with authorization ID. | def test_bind_digest_with_authzid(self):
if self.cfg["DIGESTAUTH"]["authzid"] == "None":
self.skipTest("Authorization ID is not set.")
if sys.platform == "win32":
self.skipTest("Authz is not set on AD.")
authzid = self.cfg["DIGESTAUTH"]["authzid"]
with self._bindi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_digest_auth_error(self):\n if \"DIGESTAUTH\" not in self.cfg:\n self.skipTest(\"No digest authentication is set.\")\n client = LDAPClient(self.url)\n if self.cfg[\"DIGESTAUTH\"][\"realm\"] == \"None\":\n realm = None\n else:\n realm = self.cfg[\... | [
"0.6327718",
"0.60657185",
"0.5936145",
"0.57661295",
"0.5729836",
"0.568655",
"0.56798357",
"0.5622916",
"0.5620633",
"0.5610848",
"0.558695",
"0.54626304",
"0.5433472",
"0.54068273",
"0.5376766",
"0.5373301",
"0.53653115",
"0.536526",
"0.53354263",
"0.53354263",
"0.53083426... | 0.68475235 | 0 |
Test GSSAPI connection with authorization ID. | def test_bind_gssapi_with_authzid_kinit(self):
if self.cfg["GSSAPIAUTH"]["authzid"] == "None":
self.skipTest("Authorization ID is not set.")
authzid = self.cfg["GSSAPIAUTH"]["authzid"]
conn = self._bind_gssapi_kinit(authzid)
self.assertEqual(self.cfg["GSSAPIAUTH"]["dn"], conn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bind_gssapi(self):\n if (\"realm\" not in self.cfg[\"GSSAPIAUTH\"]\n or self.cfg[\"GSSAPIAUTH\"][\"realm\"] == \"None\"):\n self.skipTest(\"Realm is not set.\")\n if sys.platform == \"linux\":\n # Make sure keytab is empty.\n subprocess.check_c... | [
"0.6637385",
"0.6162936",
"0.5963409",
"0.5909624",
"0.56840336",
"0.5674692",
"0.5672899",
"0.5652379",
"0.56363773",
"0.56293917",
"0.56263334",
"0.5601988",
"0.5553723",
"0.5549749",
"0.5543101",
"0.5525071",
"0.55245596",
"0.54843396",
"0.54602516",
"0.5450428",
"0.544928... | 0.72466063 | 0 |
Test GSSAPI connection with automatic TGT requesting. | def test_bind_gssapi(self):
if ("realm" not in self.cfg["GSSAPIAUTH"]
or self.cfg["GSSAPIAUTH"]["realm"] == "None"):
self.skipTest("Realm is not set.")
if sys.platform == "linux":
# Make sure keytab is empty.
subprocess.check_call("kdestroy")
c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test_gw(test_cli):\n conn = await gw_start(test_cli)\n\n hello = await _json(conn)\n assert hello['op'] == OP.HELLO\n\n assert isinstance(hello['d'], dict)\n assert isinstance(hello['d']['heartbeat_interval'], int)\n assert isinstance(hello['d']['_trace'], list)\n\n await conn.close(... | [
"0.57935935",
"0.5780655",
"0.5607268",
"0.55693626",
"0.5539238",
"0.5500747",
"0.54985845",
"0.54976887",
"0.54841346",
"0.5475272",
"0.5446739",
"0.5421863",
"0.5406196",
"0.5399782",
"0.5370997",
"0.5365647",
"0.5359539",
"0.5353054",
"0.5349188",
"0.5335557",
"0.5328453"... | 0.5683782 | 2 |
Test automatic TGT requesting with wrong realm name. | def test_bind_gssapi_error(self):
if "GSSAPIAUTH" not in self.cfg:
self.skipTest("GSSAPI authentication is not set.")
if not bonsai.has_krb5_support():
self.skipTest("Module doesn't have KRB5 support.")
if sys.platform == "darwin":
self.skipTest("Kerberos is n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_org_specific_allowance_trial(self):\n self.given({\n \"rules\": {\n \"12\": \"restrict\",\n },\n \"rules:trial\": {\n \"123\": \"restrict\",\n },\n \"rules:org\": {\n \"1234\": \"allow\"\n ... | [
"0.5641785",
"0.54971045",
"0.536007",
"0.5274659",
"0.52139777",
"0.5198941",
"0.519817",
"0.511543",
"0.50957334",
"0.50944114",
"0.5092667",
"0.50914085",
"0.50912154",
"0.5087112",
"0.50351",
"0.50296783",
"0.49982587",
"0.4993607",
"0.49838197",
"0.49684337",
"0.496144",... | 0.0 | -1 |
Test EXTERNAL connection with authorization ID. | def test_bind_external_with_authzid(self):
if self.cfg["EXTERNALAUTH"]["authzid"] == "None":
self.skipTest("Authorization ID is not set.")
authzid = self.cfg["EXTERNALAUTH"]["authzid"]
with self._bind_external(authzid) as conn:
self.assertEqual(self.cfg["EXTERNALAUTH"]["d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_o_auth_client_authorization(self):\n pass",
"def test_read_o_auth_client(self):\n pass",
"def test_create_o_auth_client_authorization(self):\n pass",
"def test_auth_public(self):\n self.do_visible(True, None, True, tenant='froggy')",
"def test_verify_connection_to_... | [
"0.6595947",
"0.6288124",
"0.60532445",
"0.5988806",
"0.5940299",
"0.5915462",
"0.59024686",
"0.588784",
"0.5816472",
"0.58081985",
"0.5744265",
"0.57390004",
"0.57381225",
"0.5705428",
"0.56985146",
"0.56872666",
"0.5663291",
"0.5663291",
"0.56296337",
"0.56017727",
"0.55908... | 0.6811685 | 0 |
Test searching with LDAPDN object. | def test_search_ldapdn(self):
ldap_dn = LDAPDN(self.basedn)
obj = self.conn.search(ldap_dn, 1)
self.assertIsNotNone(obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ldap(self):\n results = self.sync.ldap.conn.search_s('ou=example,o=test', ldap.SCOPE_ONELEVEL, '(cn=*)')\n self.assertEquals(self.ldapobj.methods_called(), ['initialize', 'simple_bind_s', 'search_s'])\n self.assertEquals(sorted(results), sorted([self.manager, self.alice]))",
"def te... | [
"0.70454746",
"0.6954678",
"0.6645752",
"0.6632754",
"0.6471215",
"0.6217639",
"0.6171891",
"0.6105286",
"0.60873157",
"0.6058489",
"0.60166645",
"0.6012985",
"0.60115427",
"0.59174424",
"0.5915946",
"0.5903678",
"0.5895523",
"0.5862923",
"0.5836762",
"0.57706964",
"0.5753892... | 0.882768 | 0 |
Test searching with given list of attributes. | def test_search_attr(self):
obj = self.conn.search(self.basedn, 2, "(objectclass=person)",
['cn'])[0]
self.assertIsNotNone(obj)
if 'cn' not in obj.keys():
self.fail() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def in_attr_list(self, attrs):\n for other in attrs:\n if other.matches(self): return True\n return False",
"def test_attributes(self):\n comp = str(self.test1)\n attr = ['BaseModel', 'id', 'created_at', 'updated_at']\n counter = 0\n for a in attr:\n if a in attr... | [
"0.66435045",
"0.63999295",
"0.6337153",
"0.6267349",
"0.6267349",
"0.61889493",
"0.6158053",
"0.61370564",
"0.6100694",
"0.6098542",
"0.60753375",
"0.6055099",
"0.6048664",
"0.603057",
"0.5954546",
"0.5943922",
"0.59394",
"0.5937579",
"0.59231544",
"0.5869347",
"0.5784163",
... | 0.56246084 | 29 |
Test search receiving only attributes. | def test_search_attrsonly(self):
obj = self.conn.search(self.basedn, 2, "(objectclass=person)",
['cn'], attrsonly=True)[0]
self.assertIsNotNone(obj)
self.assertListEqual(obj['cn'], []) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_attributes(self):\n pass",
"def test_search_attr(self):\n obj = self.conn.search(self.basedn, 2, \"(objectclass=person)\",\n ['cn'])[0]\n self.assertIsNotNone(obj)\n if 'cn' not in obj.keys():\n self.fail()",
"def test_search_mis... | [
"0.6979749",
"0.69117343",
"0.689508",
"0.67205864",
"0.6559061",
"0.6548601",
"0.63411415",
"0.63288885",
"0.6302406",
"0.6302406",
"0.6302406",
"0.62407386",
"0.6193288",
"0.6188873",
"0.61561745",
"0.61465657",
"0.61031437",
"0.6068137",
"0.60603863",
"0.60401607",
"0.5984... | 0.6743762 | 3 |
Test adding and removing an LDAP entry. | def test_add_and_delete(self):
entry = bonsai.LDAPEntry("cn=example,%s" % self.basedn)
entry.update({"objectclass" : ["top", "inetorgperson"],
"cn" : "example", "sn" : "example"})
try:
self.conn.add(entry)
res = self.conn.search(entry.dn, 0)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testAsLDIF(self):\n sut = delta.AddOp(\n entry.BaseLDAPEntry(\n dn=\"dc=example,dc=com\",\n attributes={\n \"foo\": [\"bar\", \"baz\"],\n \"quux\": [\"thud\"],\n },\n )\n )\n\n result =... | [
"0.7018198",
"0.67601484",
"0.63521296",
"0.6233793",
"0.60527146",
"0.5993023",
"0.5943836",
"0.5865035",
"0.5850916",
"0.5821462",
"0.5703637",
"0.5692997",
"0.5683843",
"0.5639278",
"0.56210375",
"0.5592167",
"0.55881655",
"0.55870444",
"0.55792624",
"0.5564181",
"0.556384... | 0.8286179 | 0 |
Test removing a subtree recursively. | def test_recursive_delete(self):
org1 = bonsai.LDAPEntry("ou=testusers,%s" % self.basedn)
org1.update({"objectclass" : ['organizationalUnit', 'top'],
"ou" : "testusers"})
org2 = bonsai.LDAPEntry("ou=tops,ou=testusers,%s" % self.basedn)
org2.update({"objectclass" : ['... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_remove_childless_on_delete_tree2(delete_tree):\n delete_tree.remove(\"teabaggers\")\n assert delete_tree.contains(\"teabaggers\") is False",
"def test_remove_top_but_not_root2(delete_tree):\n delete_tree.remove(\"tea\")\n assert delete_tree.contains(\"teabag\") is True",
"def test_remove_m... | [
"0.77839214",
"0.74135566",
"0.7287522",
"0.71570563",
"0.6911262",
"0.6886111",
"0.68713844",
"0.68078643",
"0.68013424",
"0.6751551",
"0.6650767",
"0.6635288",
"0.6632491",
"0.6611354",
"0.6564653",
"0.6559428",
"0.65034735",
"0.6447768",
"0.63806474",
"0.6378148",
"0.62895... | 0.0 | -1 |
Test simple authentication error. | def test_simple_auth_error(self):
client = LDAPClient(self.url)
client.set_credentials("SIMPLE", ("cn=wrong", "wronger"))
self.assertRaises(bonsai.AuthenticationError, client.connect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_failure(self):\n \n result = self.authenticator.authenticate(\n username=u'thruflo', \n password=u'wrong'\n )\n self.assertTrue(result is None)",
"def test_valid_login_form_but_failed_authentication(self):\n\n\n\t\tpass",
"def test_auth_neg(self):\n ... | [
"0.8160639",
"0.7902072",
"0.78756416",
"0.7854512",
"0.7853043",
"0.78114414",
"0.7806747",
"0.77066267",
"0.77066267",
"0.769299",
"0.76880956",
"0.7650529",
"0.7629429",
"0.76141727",
"0.75927913",
"0.7539589",
"0.75344485",
"0.75258625",
"0.74972916",
"0.7496218",
"0.7488... | 0.7740019 | 7 |
Test DIGESTMD5 authentication error. | def test_digest_auth_error(self):
if "DIGESTAUTH" not in self.cfg:
self.skipTest("No digest authentication is set.")
client = LDAPClient(self.url)
if self.cfg["DIGESTAUTH"]["realm"] == "None":
realm = None
else:
realm = self.cfg["DIGESTAUTH"]["realm"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_authenticationChallengeDecodingException(self):\n transport = StringTransportWithDisconnection()\n protocol = imap4.IMAP4Client()\n transport.protocol = protocol\n\n protocol.makeConnection(transport)\n protocol.lineReceived(\n b'* OK [CAPABILITY IMAP4rev1 IDL... | [
"0.6640376",
"0.6612457",
"0.6572347",
"0.6549485",
"0.6495003",
"0.6441326",
"0.636666",
"0.63042474",
"0.62318647",
"0.61930764",
"0.61313355",
"0.61058384",
"0.60507107",
"0.59778947",
"0.5900525",
"0.5880734",
"0.5875102",
"0.5864537",
"0.5811011",
"0.57827723",
"0.576572... | 0.7635065 | 0 |
Test setting sort order. | def test_sort_order(self):
obj = self.conn.search(self.basedn, 2, attrlist=['uidNumber'],
sort_order=["-uidNumber"])
sort = [o['uidNumber'][0] for o in obj if 'uidNumber' in o]
self.assertTrue((all(sort[i] >= sort[i+1]
for i in range(le... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testSorting(self):\n if self.sorting in tools.SORTINGS:\n self.assertEqual(\n self.sorting,\n self.config.sorting\n )\n else:\n self.assertNotEqual(\n self.sorting,\n self.config.sorting\n )\n ... | [
"0.8135057",
"0.7092",
"0.6721787",
"0.6597684",
"0.6479855",
"0.64016086",
"0.6378493",
"0.6352672",
"0.6286349",
"0.62723154",
"0.6233688",
"0.61776847",
"0.61464125",
"0.61213744",
"0.61046416",
"0.6052762",
"0.6042817",
"0.6038616",
"0.6021032",
"0.59977347",
"0.59925616"... | 0.6106187 | 14 |
Test remove pending operations after close. | def test_async_close_remove_pendig_ops(self):
msgid = self.async_conn.open()
while self.async_conn.get_result(msgid) is None:
pass
self.async_conn.search(self.basedn, 2)
self.async_conn.search(self.basedn, 0)
self.async_conn.close()
self.assertTrue(self.async_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _teardown(self, commit: bool = None):",
"def test_terminate_run(self):\n pass",
"def test_remove(self):\n pass",
"def test_close(self):\n db = database.Database()\n db.close()\n self.assertTrue(self.mocked_connection.close.call_count is 1)",
"def test_cleanup_as... | [
"0.64919806",
"0.6325584",
"0.6325501",
"0.61880726",
"0.617823",
"0.6134211",
"0.6123258",
"0.6067313",
"0.60664797",
"0.60664797",
"0.60664797",
"0.60664797",
"0.6056546",
"0.5998878",
"0.59824914",
"0.59811395",
"0.5954082",
"0.59276146",
"0.59248227",
"0.59237075",
"0.592... | 0.6874929 | 0 |
Test VLV control with offset. | def test_vlv_offset(self):
search_dn = "ou=nerdherd,%s" % self.basedn
res, ctrl = self.conn.search(search_dn, 1, attrlist=['uidNumber'],
offset=2, sort_order=["-uidNumber"],
before_count=1, after_count=1,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_SemiF47_level_0_5(self):\n self.assertEqual(viol_check(self.vol,5), [[131, 143]])",
"def test_minv_keyword(self):\n # Set minv to 200\n byt = bytscl(self.array2, minv=200)\n control = numpy.sum(self.array2 <= 200)\n total = numpy.sum(byt == 0)\n self.assertEqual... | [
"0.54132396",
"0.53664666",
"0.5291695",
"0.5147984",
"0.51463264",
"0.51174176",
"0.510954",
"0.50887066",
"0.5086787",
"0.5055929",
"0.50394547",
"0.4952077",
"0.49265426",
"0.4918608",
"0.49168146",
"0.4895624",
"0.48828602",
"0.4879761",
"0.4838646",
"0.483553",
"0.483007... | 0.6655514 | 0 |
Test VLV control with attribute value. | def test_vlv_attrvalue(self):
search_dn = "ou=nerdherd,%s" % self.basedn
res, ctrl = self.conn.search(search_dn, 1, attrlist=['uidNumber'],
attrvalue=2, sort_order=["uidNumber"],
before_count=1, after_count=2,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testPsychControl(self):\n attr = self.session.create_visit_attr()\n\n self.util.intTypeTest(self, attr, \"control\")\n\n self.util.intPropertyTest(self, attr, \"control\")",
"def test_attributeWithValue(self):\n xp = XPathQuery(\"/foo[@attrib1='value1']\")\n self.assertEqua... | [
"0.5968753",
"0.5513699",
"0.5358866",
"0.5314102",
"0.5314102",
"0.5314102",
"0.5314102",
"0.5263289",
"0.5260972",
"0.5128111",
"0.5100677",
"0.5072715",
"0.5041433",
"0.5022484",
"0.50177157",
"0.5000374",
"0.49968424",
"0.4985033",
"0.49849218",
"0.4967097",
"0.49632353",... | 0.62106925 | 0 |
Test VLV control without sort control. | def test_vlv_without_sort_order(self):
search_dn = "ou=nerdherd,%s" % self.basedn
self.assertRaises(bonsai.UnwillingToPerform,
lambda: self.conn.search(search_dn, 1,
attrlist=['uidNumber'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _lv_test(self):\n raise NotImplementedError('Levene Test is not implemented')",
"def test_DisplayReturnsNone(self):\r\n self.assertEqual(self.lv._display([]), None)",
"def test_call_suppress_sort(self):\r\n\r\n exp_otu_ids = range(3)\r\n exp_clusters = [['uclust_test_seqs_0'],\r... | [
"0.5744305",
"0.5515212",
"0.54154176",
"0.5396088",
"0.5275995",
"0.52594316",
"0.5172056",
"0.5172056",
"0.51444876",
"0.5143461",
"0.51239437",
"0.5066076",
"0.5050928",
"0.5001201",
"0.49996036",
"0.4972062",
"0.49702373",
"0.49619678",
"0.49604535",
"0.495707",
"0.494579... | 0.62800914 | 0 |
Test VLV control with page size. | def test_vlv_with_page_size(self):
search_dn = "ou=nerdherd,%s" % self.basedn
self.assertRaises(bonsai.UnwillingToPerform,
lambda: self.conn.search(search_dn, 1, page_size=3,
sort_order=["-uidNumber"],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_05_vmcp(self):\r\n url = '/api/vmcp'\r\n self.check_limit(url, 'get', 'app')",
"def test_size_layout(testapp):\n response = testapp.get('/size', status=200)\n html = response.html\n assert 'Size' in html.find(\"h1\").text",
"def test_svm_vs_vm_count():\n assert templates.svms... | [
"0.58396465",
"0.5596314",
"0.55891645",
"0.55699897",
"0.5551119",
"0.5515642",
"0.54765373",
"0.5391576",
"0.53537965",
"0.5290339",
"0.5280267",
"0.52721274",
"0.5219186",
"0.52178174",
"0.52002454",
"0.51872075",
"0.51788443",
"0.5148499",
"0.5134438",
"0.5123979",
"0.510... | 0.67544186 | 0 |
Test paged results control. | def test_paged_search(self):
search_dn = "ou=nerdherd,%s" % self.basedn
res = self.conn.search(search_dn, 1, page_size=2)
for ent in res:
self.assertIsInstance(ent, bonsai.LDAPEntry)
page = 1 # First page already is acquired.
while True:
if len(res) > 2:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_pagination(self):\n self.check_pagination()",
"def test_pagination(self):\n for page in range(1, 5):\n self._test_one_page(page=page)",
"def test_iter_paging(self):\n ref = mock.Mock()\n ref.side_effect = [\n {'rows': [x for x in range(100)]},\n ... | [
"0.73542345",
"0.70421594",
"0.6698459",
"0.6664925",
"0.66160214",
"0.6580792",
"0.6575952",
"0.62992656",
"0.6298293",
"0.6291728",
"0.6289881",
"0.6248205",
"0.62364775",
"0.62084365",
"0.6200387",
"0.61718667",
"0.6151887",
"0.60827196",
"0.60827196",
"0.60296124",
"0.601... | 0.658415 | 5 |
Test paged results control with automatic page acquiring. | def test_paged_search_with_auto_acq(self):
client = LDAPClient(self.url)
conn = client.connect()
search_dn = "ou=nerdherd,%s" % self.basedn
res = conn.search(search_dn, 1, page_size=3)
if len(res) != 3:
self.fail("The size of the page is not what is expected.")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_pagination(self):\n self.check_pagination()",
"def test_pagination(self):\n for page in range(1, 5):\n self._test_one_page(page=page)",
"def test_search_paginate(page_size, page_num, expected_result):\n result = search_paginate(page_size, page_num)\n assert result == exp... | [
"0.7288579",
"0.6902279",
"0.6450426",
"0.64395285",
"0.6397602",
"0.6360776",
"0.62607944",
"0.6246416",
"0.6217707",
"0.62045294",
"0.61306936",
"0.61147946",
"0.61100405",
"0.60696965",
"0.6053422",
"0.6053422",
"0.60343534",
"0.5994941",
"0.5988161",
"0.59819627",
"0.5969... | 0.6649057 | 2 |
Test passing wrong parameters for LDAPConnection. | def test_wrong_conn_param(self):
self.assertRaises(TypeError, lambda: LDAPConnection("wrong"))
self.assertRaises(TypeError, lambda: LDAPConnection(LDAPClient(), 1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testInvalidConnectionParameters(self):\r\n \r\n self._configuration.serverUri = _SERVER_DOWN_URI\r\n self.assertRaises(PersistenceError, self._ldapPrincipalSearcher.searchPrincipal,\r\n _VALID_USER_GROUP_QUERY, constants.SEARCH_MODE_GROUP_ONLY)",
"def test_wrong_... | [
"0.7524373",
"0.70150065",
"0.6916773",
"0.68465286",
"0.66269404",
"0.6596362",
"0.6466661",
"0.6193457",
"0.61694545",
"0.59333795",
"0.5901588",
"0.58959955",
"0.58886415",
"0.58343107",
"0.5831784",
"0.57771206",
"0.57743895",
"0.5743263",
"0.57277405",
"0.57073027",
"0.5... | 0.75680727 | 0 |
Test passing wrong parameters for search method. | def test_wrong_search_param(self):
def close_conn():
cli = LDAPClient("ldap://%s" % self.ipaddr)
LDAPConnection(cli).search()
def missing_scope():
cli = LDAPClient("ldap://%s" % self.ipaddr)
LDAPConnection(cli).open().search()
def wrong():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_search_no_params_error(self):\n self.assertRaises(\n TypeError,\n lambda: self.t['Scrubs'].search()\n )",
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search_query_wrongtype(obj... | [
"0.7945164",
"0.77503645",
"0.77503645",
"0.77503645",
"0.7738949",
"0.7389785",
"0.73361635",
"0.72530264",
"0.72413445",
"0.71735513",
"0.71677125",
"0.7097528",
"0.70773447",
"0.7055344",
"0.69934136",
"0.69510794",
"0.69244516",
"0.68074024",
"0.67974705",
"0.6763249",
"0... | 0.6752381 | 20 |
Test passing wrong parameter for add method. | def test_wrong_add_param(self):
def close_conn():
cli = LDAPClient("ldap://%s" % self.ipaddr)
LDAPConnection(cli).add(bonsai.LDAPEntry("cn=dummy"))
self.assertRaises(ClosedConnection, close_conn)
self.assertRaises(TypeError, lambda: self.conn.add("wrong")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add(self):\n self.assertEqual(3, foo.add(1, 2))\n self.assertNotEqual(3, foo.add(2, 2))",
"def test_add(self):\n self.assertEqual(3, add(1, 2))\n self.assertNotEqual(3, add(2, 2))",
"def test_add(self):\n print('test_add')\n \n self.assertEqual(120, add... | [
"0.8064812",
"0.79411405",
"0.77598226",
"0.7634203",
"0.7425481",
"0.7362449",
"0.731181",
"0.7137341",
"0.70950186",
"0.70194846",
"0.6975826",
"0.6966621",
"0.6905885",
"0.6871949",
"0.6864412",
"0.68441737",
"0.68376404",
"0.6798079",
"0.67966104",
"0.67796755",
"0.677035... | 0.6966413 | 12 |
Test passing wrong parameter for delete method. | def test_wrong_delete_param(self):
def close_conn():
cli = LDAPClient("ldap://%s" % self.ipaddr)
LDAPConnection(cli).delete("cn=dummy")
self.assertRaises(ClosedConnection, close_conn)
self.assertRaises(TypeError, lambda: self.conn.delete(0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete(self):\n pass",
"def test_delete1(self):\n pass",
"def test_delete_case(self):\n pass",
"def do_delete(self, arg):\n \treturn False",
"def test_delete_run(self):\n pass",
"def test_delete_item_using_delete(self):\n pass",
"def test_delete_record(sel... | [
"0.81362563",
"0.78087914",
"0.7780758",
"0.7746777",
"0.774375",
"0.76655203",
"0.7561211",
"0.7514759",
"0.7312061",
"0.72756827",
"0.72699475",
"0.72408867",
"0.7219854",
"0.721095",
"0.71852905",
"0.7138387",
"0.7133738",
"0.7111839",
"0.71118313",
"0.70879745",
"0.708017... | 0.72905856 | 9 |
Test password locking with password policy. | def test_password_lockout(self):
if sys.platform == "win32":
self.skipTest("Cannot use password policy on Windows")
user_dn = "cn=jeff,ou=nerdherd,dc=bonsai,dc=test"
cli = LDAPClient("ldap://%s" % self.ipaddr)
cli.set_password_policy(True)
try:
cli.set_cre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_forced_password_change(self):\r\n\r\n student_email, student_password = self._setup_user()\r\n staff_email, staff_password = self._setup_user(is_staff=True)\r\n\r\n self._login(student_email, student_password)\r\n self._login(staff_email, staff_password)\r\n\r\n staff_re... | [
"0.6874066",
"0.6578467",
"0.6546355",
"0.65354776",
"0.6521407",
"0.6484819",
"0.64839184",
"0.6438782",
"0.6404049",
"0.6390272",
"0.63591725",
"0.63541543",
"0.6281434",
"0.6275415",
"0.62695897",
"0.6252212",
"0.62510914",
"0.62440634",
"0.62384504",
"0.6221138",
"0.61975... | 0.73470205 | 0 |
Test password expiring with password policy. | def test_password_expire(self):
user_dn = "cn=skip,ou=nerdherd,dc=bonsai,dc=test"
cli = LDAPClient("ldap://%s" % self.ipaddr)
cli.set_password_policy(True)
cli.set_credentials("SIMPLE", (user_dn, "p@ssword"))
conn, ctrl = cli.connect()
entry = conn.search(user_dn, 0)[0]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_passwordsuccess(self):\n old_time = timezone.now()\n self.u.extra.password_expires = old_time\n form_data = self.form_data('2$n5[]$nnA5Y}2}}^gba')\n form = self.form(data=form_data, user=self.u)\n self.assertTrue(form.is_valid())\n form.save()\n new_time = ... | [
"0.73911214",
"0.7176944",
"0.66216415",
"0.6572187",
"0.6437454",
"0.634047",
"0.63339823",
"0.63237965",
"0.6312588",
"0.63042474",
"0.6275768",
"0.6275104",
"0.6263584",
"0.624678",
"0.62428534",
"0.6227891",
"0.62078655",
"0.61909306",
"0.61644655",
"0.6162078",
"0.615218... | 0.76759005 | 0 |
Test Password Modify extended operation. | def test_password_modify_extop(self):
user_dn = LDAPDN("cn=skip,ou=nerdherd,dc=bonsai,dc=test")
cli = LDAPClient("ldap://%s" % self.ipaddr)
cli.set_credentials("SIMPLE", (str(user_dn), "p@ssword"))
conn = cli.connect()
self.assertRaises(TypeError,
lambda... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testEditPassword(self):\n self._login_user('eschoppik','secret')\n response = self.client.post('/users/1/edit_password?_method=PATCH',\n data=dict(new_password='newpass', confirm_password='newpass',\n old_password='secret'), follow_redirects=True)\n user = User.query.... | [
"0.72992325",
"0.72059107",
"0.71185523",
"0.7043154",
"0.6966417",
"0.69475526",
"0.69261074",
"0.68819994",
"0.68134713",
"0.6801481",
"0.6751851",
"0.67470604",
"0.6723605",
"0.6700132",
"0.6692681",
"0.6681687",
"0.66731286",
"0.66515154",
"0.6604505",
"0.6600074",
"0.658... | 0.784557 | 0 |
Test searching with manageDsaIT control. | def test_search_with_managedsait_ctrl(self):
refdn = LDAPDN("o=admin-ref,ou=nerdherd,dc=bonsai,dc=test")
cli = LDAPClient("ldap://%s" % self.ipaddr)
with cli.connect() as conn:
res = conn.search(refdn, LDAPSearchScope.BASE, attrlist=['ref'])[0]
self.assertEqual(str(res.dn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def test_search(self):\n pass",
"def testSEFinder(self):\n\n seNames = self.mySiteDB.getAllSENames()\n self.assertTrue(len(seNames) > 1)\n self.assertTrue('cmsdcadisk01.fnal.gov' in seNames)\n r... | [
"0.64256716",
"0.64256716",
"0.64256716",
"0.581726",
"0.57539856",
"0.57405406",
"0.57157606",
"0.57095516",
"0.5678199",
"0.55709195",
"0.5569848",
"0.5566419",
"0.5517554",
"0.54758906",
"0.5449588",
"0.5442283",
"0.5432611",
"0.542784",
"0.5410762",
"0.538501",
"0.5368395... | 0.5767459 | 4 |
Create a new bank information | def create_new_banks():
city = request.form.get('bankCity', '')
name = request.form.get('bankName', '')
address = request.form.get('bankAddress', '')
info = dict(city=city, name=name, address=address)
# print(info)
bank = Bank(city, name, address)
res = bank.save()
# print('res=%d' % res)
return send_result(i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bank():\n\n bank = Bank.objects.create(name='Random Bank')\n return bank",
"def test_client_bank_account_create(self):\n pass",
"def new_bank_account(payment_doc, bankData):\n from erpnextfints.utils.bank_account_controller import \\\n BankAccountController\n return BankAccountCon... | [
"0.7559602",
"0.71903527",
"0.69491756",
"0.6763208",
"0.67325413",
"0.6730462",
"0.66991276",
"0.6647563",
"0.66253805",
"0.65569913",
"0.6554133",
"0.6422634",
"0.6422634",
"0.64211667",
"0.63165236",
"0.6168401",
"0.6161851",
"0.61598647",
"0.61535907",
"0.61501044",
"0.61... | 0.8252264 | 0 |
get a new bank object and details | def get_banks():
bank_list = []
bank_obj = lib.operations.bank.get_bank_list()
for obj in bank_obj:
checkbox = "<div class='checkbox'>" \
"<label><input name='checkbox' type='checkbox' id='bankBox' value='{id}'></label>" \
"</div>".format(id=obj.id)
btn_group = "<div class='btn-group'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bank():\n\n bank = Bank.objects.create(name='Random Bank')\n return bank",
"def bank_account():\n return BankAccount()",
"def example_bank_account():\n \n return BankAccount(\"Test User\", 1000.0)",
"def create_new_banks():\n\n\tcity = request.form.get('bankCity', '')\n\tname = request.for... | [
"0.77258354",
"0.7678284",
"0.7248556",
"0.6961261",
"0.67643434",
"0.67433494",
"0.6585655",
"0.6585587",
"0.64266276",
"0.63645226",
"0.63021654",
"0.6287894",
"0.6259636",
"0.6231028",
"0.6111299",
"0.6096521",
"0.6052425",
"0.6022077",
"0.60201436",
"0.6006879",
"0.598461... | 0.0 | -1 |
delete a bank information from bank store | def delete_banks():
res = None
request_str = "request url: {0}?{1}".format(request.url, request.get_data().decode('utf8'))
# print("request url: %s" % request_str)
req_param = request_str.split('?')[-1]
for id_param in req_param.split('&'):
id_value = id_param.split('=')[1]
print("id=%s" % id_value)
res = B... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_client_bank_account_delete(self):\n pass",
"def delete_account(request):\n ubanks = request.user.userbank.all()\n for ubank in ubanks:\n ubank.delete()\n user = request.user\n log_out(request)\n user.delete()\n return HttpResponse(\"Account succesfully deleted\")",
"def... | [
"0.71329033",
"0.68773824",
"0.680916",
"0.67814386",
"0.65903366",
"0.63704675",
"0.6302377",
"0.6252257",
"0.6244305",
"0.6241191",
"0.61959",
"0.6166826",
"0.6166826",
"0.6166826",
"0.6166826",
"0.6139188",
"0.6130949",
"0.6124565",
"0.60743225",
"0.6066364",
"0.60517305",... | 0.74057645 | 0 |
delete a bank information from bank store | def update_banks(bank_id):
city = request.form.get('bankCity', '')
name = request.form.get('bankName', '')
address = request.form.get('bankAddress', '')
info = dict(id=bank_id, city=city, name=name, address=address)
print(info)
bank = Bank.query.filter_by(id=bank_id).first()
if bank:
bank.name = name
bank... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_banks():\n\n\tres = None\n\trequest_str = \"request url: {0}?{1}\".format(request.url, request.get_data().decode('utf8'))\n\t# print(\"request url: %s\" % request_str)\n\treq_param = request_str.split('?')[-1]\n\tfor id_param in req_param.split('&'):\n\t\tid_value = id_param.split('=')[1]\n\t\tprint(\"i... | [
"0.7404798",
"0.7132652",
"0.68761516",
"0.68083924",
"0.6781729",
"0.6588969",
"0.6368554",
"0.6302607",
"0.6252452",
"0.6243891",
"0.62412745",
"0.61952716",
"0.61665446",
"0.61665446",
"0.61665446",
"0.61665446",
"0.6137177",
"0.6130539",
"0.6124873",
"0.6073968",
"0.60649... | 0.0 | -1 |
Two Register and Immediate instructions Parser. | def parse(arg: Tuple[str, str, str, str, str]) -> Tuple[str, str, str]:
return (arg[2], arg[3], arg[4]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_control(self,ins): \n if ins.instr == 'j':\n if len(ins.args) == 1:\n if type(ins.args[0]) == Register:\n self.need = [ins.args[0]]\n if ins.args[0].expr == \"$31\":\n self.need += [Register(\"$2\"), Register... | [
"0.5297825",
"0.526232",
"0.52386516",
"0.51448655",
"0.5074047",
"0.5039886",
"0.5036299",
"0.5004861",
"0.50040513",
"0.49939978",
"0.49608114",
"0.4955953",
"0.49455416",
"0.4897556",
"0.48950177",
"0.48696256",
"0.48126158",
"0.47999066",
"0.47873563",
"0.47853625",
"0.47... | 0.42107955 | 97 |
Branch to label if Reg[rs] == Reg[rt]. | def beq(program: MipsProgram, rs: str, rt: str, label: str):
if program.registers[rs] == program.registers[rt]:
program.registers["pc"] = program.labels[label].value - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bne(program: MipsProgram, rs: str, rt: str, label: str):\n if program.registers[rs] != program.registers[rt]:\n program.registers[\"pc\"] = program.labels[label].value - 1",
"def branch_if_equal_reg(self):\n registers = self.return_middle_registers(self.opcode)\n\n if self.registers[r... | [
"0.62456226",
"0.60115707",
"0.54348534",
"0.54297096",
"0.5392624",
"0.5327324",
"0.52737606",
"0.52281475",
"0.5189784",
"0.51500887",
"0.50746506",
"0.5074509",
"0.503317",
"0.5016388",
"0.5003025",
"0.50009066",
"0.49789795",
"0.49279445",
"0.49165267",
"0.49081331",
"0.4... | 0.6317092 | 0 |
Branch to label if Reg[rs] != Reg[rt]. | def bne(program: MipsProgram, rs: str, rt: str, label: str):
if program.registers[rs] != program.registers[rt]:
program.registers["pc"] = program.labels[label].value - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def branch_if_equal_reg(self):\n registers = self.return_middle_registers(self.opcode)\n\n if self.registers[registers[0]] == self.registers[registers[1]]:\n self.pc += 2\n logger.info(\n \"Skipped {} because register V{} and V{} are equal to {}\".format(\n ... | [
"0.62894225",
"0.6026388",
"0.55991274",
"0.5560397",
"0.54077464",
"0.5354878",
"0.5353679",
"0.5219369",
"0.5173581",
"0.5097688",
"0.5076022",
"0.50460917",
"0.5016778",
"0.4973996",
"0.49441072",
"0.4922955",
"0.49188864",
"0.4892238",
"0.4891666",
"0.4877365",
"0.4875250... | 0.6580701 | 0 |
creates DNS workspace with fake data angle Angle of detector bank rotation flipper Flipper state (ON/OFF) dataY Data array to set as DataY of the created workspace, will be set to np.ones if None loadinstrument If True api.LoadInstrument will be executed, needed for DNSMergeRuns | def create_fake_dns_workspace(wsname, angle=-7.53, flipper='ON', dataY=None, loadinstrument=False):
ndet = 24
dataX = np.zeros(2*ndet)
dataX.fill(4.2 + 0.00001)
dataX[::2] -= 0.000002
if dataY is None:
dataY = np.ones(ndet)
dataE = np.sqrt(dataY)
# create workspace
api.CreateWork... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 tw... | [
"0.528857",
"0.5275683",
"0.5244616",
"0.5172132",
"0.5155412",
"0.50693256",
"0.5061431",
"0.50385815",
"0.5015966",
"0.50138897",
"0.5005705",
"0.49955073",
"0.49795848",
"0.49606365",
"0.4959157",
"0.49444878",
"0.49352133",
"0.49344248",
"0.49275932",
"0.49208367",
"0.491... | 0.6685899 | 0 |
Randomly generates objects based on rarity | def drop_item(dictionary):
drops_i = []
for k, v in dictionary.items():
quantity = dropper(v['rarity'])
if quantity:
drops_i.append(Item(name=k, quantity=quantity, **v))
return drops_i | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRandomRarity():\n r = random.randint(1,100)\n if r <= Rarities.IMPOSIBIL:\n return \"IMPOSIBIL\"\n elif r <= Rarities.LEGENDAR:\n return \"LEGENDAR\"\n elif r <= Rarities.EPIC:\n return \"EPIC\"\n else:\n return \"COMUN\"",
"de... | [
"0.6996102",
"0.6694256",
"0.6340941",
"0.622799",
"0.620527",
"0.6175181",
"0.61681855",
"0.61256886",
"0.6113648",
"0.6070151",
"0.6064537",
"0.6034091",
"0.60101193",
"0.600747",
"0.59982055",
"0.5995867",
"0.59806323",
"0.5942219",
"0.5933879",
"0.59222144",
"0.5916376",
... | 0.0 | -1 |
Remove items with quantity of zero from the map inventory | def clean_up_map(self):
self.items = [i for i in self.items if i.quantity != 0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_0_items(inventory):\n for k,v in inventory.copy().items():\n if inventory[k] == 0:\n inventory.pop(k)\n return inventory",
"def clean_up_inventory(self):\n self.inventory = [i for i in self.inventory if i.quantity != 0]",
"def filter_0_items(inventory):\r\n\r\n\tnew_li... | [
"0.819584",
"0.771313",
"0.76574916",
"0.68226224",
"0.6534319",
"0.65251803",
"0.6427881",
"0.61505413",
"0.6041092",
"0.5901576",
"0.587836",
"0.5865126",
"0.585266",
"0.5846387",
"0.5802365",
"0.5761933",
"0.57600087",
"0.57220966",
"0.57096773",
"0.57003164",
"0.56371963"... | 0.8265239 | 0 |
With the player's location in the center, draw a 5 x 5 map with map square type and coordinates in each square | def map_picture(the_map, p):
xy = (p.location[0] - 2, p.location[1] + 2)
map_coords = []
for y in range(0, 5):
row = [(xy[0] + x, xy[1] - y) for x in range(0, 5)]
map_coords.append(row)
pretty_map = []
for r in map_coords:
row = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawMap(self):\n for position, contain in self.map.items():\n if contain is \"block\":\n self.blocks.add(Block(position[1]*50,position[0]*50))\n elif contain is \"Coins\":\n self.Coins.add(Coins(position[1]*50+10,position[0]*50+10))",
"def test_sprea... | [
"0.7309115",
"0.71187574",
"0.7117415",
"0.7008887",
"0.6868376",
"0.6814788",
"0.6781789",
"0.6701914",
"0.6671221",
"0.6619516",
"0.6612153",
"0.6599288",
"0.65620023",
"0.6553493",
"0.6492683",
"0.64801276",
"0.64664316",
"0.6461657",
"0.64449847",
"0.643181",
"0.63907826"... | 0.6469946 | 16 |
Remove items with quantity of zero from the map inventory | def clean_up_inventory(self):
self.inventory = [i for i in self.inventory if i.quantity != 0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_up_map(self):\n self.items = [i for i in self.items if i.quantity != 0]",
"def filter_0_items(inventory):\n for k,v in inventory.copy().items():\n if inventory[k] == 0:\n inventory.pop(k)\n return inventory",
"def filter_0_items(inventory):\r\n\r\n\tnew_list = [] # crea... | [
"0.8266549",
"0.8194865",
"0.7657122",
"0.682121",
"0.6535803",
"0.65241736",
"0.64271444",
"0.61508083",
"0.6040893",
"0.59006655",
"0.5876113",
"0.5865422",
"0.5852331",
"0.58450437",
"0.580205",
"0.576084",
"0.5757937",
"0.5721766",
"0.571097",
"0.5699798",
"0.5637236",
... | 0.77110225 | 2 |
Pick the skills for a mob, these determine what a player can get from completing a quest | def skills():
all_skills = ["strength", "patience", "cleanliness", "leadership", "communication",
"science", "math", "engineering", "intelligence", "driving"]
random.shuffle(all_skills)
return all_skills[0:2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_quest(self):\n\n if odds(3):\n\n quest_items = add_dicts_together(items[\"master\"], items[self.p.square.square_type])\n quest_item = random.choice(list(quest_items.keys()))\n\n i = Item(quest_item, 0, **quest_items[quest_item])\n self.inventory.appen... | [
"0.63136405",
"0.6310787",
"0.6310787",
"0.6310787",
"0.6310787",
"0.6231838",
"0.6196677",
"0.619384",
"0.61357206",
"0.6035391",
"0.60149455",
"0.5892159",
"0.57440823",
"0.5698521",
"0.5648801",
"0.56278664",
"0.56115097",
"0.56068945",
"0.5603691",
"0.55618465",
"0.555885... | 0.6408001 | 0 |
inventory based bring me x of an object to learn a skill | def generate_quest(self):
if odds(3):
quest_items = add_dicts_together(items["master"], items[self.p.square.square_type])
quest_item = random.choice(list(quest_items.keys()))
i = Item(quest_item, 0, **quest_items[quest_item])
self.inventory.append(i)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_skill(self, other_card):\n ## YOUR CODE IS HERE ##",
"def get_skill(self, other_card):\n ## YOUR CODE IS HERE ##",
"def get_skill(self, other_card):\n ## YOUR CODE IS HERE ##",
"def get_skill(self, other_card):\n ## YOUR CODE IS HERE ##",
"def use_skill(self, g, i, x, y)... | [
"0.6652004",
"0.6652004",
"0.6652004",
"0.6652004",
"0.6390162",
"0.6274836",
"0.624927",
"0.62181085",
"0.606496",
"0.6056187",
"0.59883636",
"0.5947959",
"0.59235936",
"0.5900774",
"0.5862118",
"0.578877",
"0.5775404",
"0.5752975",
"0.57500863",
"0.5741891",
"0.5694833",
... | 0.5862948 | 14 |
Convert magnitude to AB magnitude | def convert_to_abmag(value, name):
mag_constants = {
'tmassJmag': 0.90,
'tmassHmag': 1.37,
'tmassKsMag': 1.85,
'SDSSuMag': 0.0,
'SDSSgMag': 0.0,
'SDSSrMag': 0.0,
'SDSSiMag': 0.0,
'SDSSzMag': 0.0,
'JpgMag': -0.055,
'FpgMag': 0.24,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def magnitude(a):\n return dot_product(a, a)**0.5",
"def magtoflux(_mag, _id):\n return math.pow(10, -0.4*(_mag + VegaToAB[_id] - 8.9))",
"def AB_zero_mag(self):\n if self.wavelength_unit is None:\n raise AttributeError('Needs wavelength units')\n\n C1 = (Unit(self.wavelength_uni... | [
"0.67562544",
"0.6364612",
"0.62620175",
"0.622684",
"0.5995404",
"0.59550416",
"0.5898912",
"0.58955497",
"0.588089",
"0.58797747",
"0.5833462",
"0.58331496",
"0.58265626",
"0.5806616",
"0.57999116",
"0.57599926",
"0.5759203",
"0.57434416",
"0.5739705",
"0.57364446",
"0.5704... | 0.6649778 | 1 |
Returns the given HTML with all tags stripped. | def strip_tags(value):
return re.sub(r'<[^>]*?>', '', value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stripHTMLTags (html):\r\n import re\r\n text = html\r\n \r\n # apply rules in given order!\r\n rules = [\r\n { r'>\\s+' : u'>'}, # remove spaces after a tag opens or closes\r\n { r'\\s+' : u' '}, # replace consecutive spaces\r\n { r'\\s*<br\\s*/?>\\s*' : u'\\n'},... | [
"0.8138946",
"0.8109891",
"0.810231",
"0.8100899",
"0.80280966",
"0.7989464",
"0.79603654",
"0.78888774",
"0.788333",
"0.78830826",
"0.78644603",
"0.7843869",
"0.7843869",
"0.7841764",
"0.78237224",
"0.7817937",
"0.77888054",
"0.7782822",
"0.7782822",
"0.77559096",
"0.7739701... | 0.67446905 | 69 |
Presents the response of the DBLP Query to the user | def do_response(data):
def on_done(i):
if i == -1:
return
cite_key = data[i][2]
view = sublime.active_window().active_view()
view.run_command("dblp_insert_result", {"text": cite_key})
sublime.active_window().show_quick_panel(data, on_done) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_query_response(response):\n if response.text is not None:\n print(json.loads(response.text))\n else:\n logger.warning('Response not valid.')",
"def query(output, query):\n gqlapi = gql.get_api()\n print_output(output, gqlapi.query(query))",
"def display_results():\n pass"... | [
"0.6287405",
"0.6051548",
"0.5986355",
"0.5806126",
"0.5794586",
"0.5725075",
"0.57025176",
"0.5640118",
"0.5639316",
"0.563691",
"0.56218725",
"0.56141347",
"0.56090456",
"0.5501721",
"0.54835856",
"0.54765683",
"0.54745716",
"0.54676145",
"0.5460552",
"0.54593676",
"0.54542... | 0.6363756 | 0 |
Get the task ids of running celery tasks. | def running_celery_tasks(request):
active_dict = CELERY_INSPECT.active()
active_tasks = []
if active_dict:
for task_list in active_dict.values():
active_tasks.extend(task_list)
if active_tasks:
active_tasks = [dikt.get("id", "") for dikt in active_tasks]
return Response({... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTaskIds(self, director):\n # the computation record\n computation = self._getComputationRecord(director)\n \n # search for tasks\n iworker = self.inventory.iworker\n tasks = computation.findTasks(director.clerk.db, iworker)\n\n ids = [t.id for t in tasks]\n ... | [
"0.75938624",
"0.7282718",
"0.7028011",
"0.690821",
"0.6904824",
"0.6813038",
"0.6770491",
"0.6752051",
"0.66965824",
"0.6624447",
"0.66147155",
"0.66134167",
"0.6579048",
"0.6572047",
"0.65634185",
"0.6556381",
"0.6547194",
"0.6485782",
"0.6478132",
"0.64532846",
"0.6437751"... | 0.68382025 | 5 |
Get the length of the celery queues. | def celery_queue_lengths(request):
queue_len = collect_queue_metrics()
LOG.info(f"Celery queue backlog info: {queue_len}")
return Response(queue_len) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queue_count(self):\n with self.mutex:\n return len(self.queues)",
"def _getqueuesize(self):\n return self._queuesize",
"def queue_size(self):\n return len(self.groups)",
"def api_get_queue_len():\n try:\n ret = AppStatus.check_manager_status(brief=False)\... | [
"0.7977187",
"0.7841889",
"0.7757675",
"0.769324",
"0.7620035",
"0.76058805",
"0.7603171",
"0.7603171",
"0.7603171",
"0.7603171",
"0.7571514",
"0.7556391",
"0.75545263",
"0.75499344",
"0.75499344",
"0.75169873",
"0.7493885",
"0.7483426",
"0.7447149",
"0.7440828",
"0.74081135"... | 0.81154 | 0 |
Makes sure that a matrix is square | def check_squareness(A):
if len(A) != len(A[0]):
raise ArithmeticError("Matrix must be square to inverse.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_square(self):\n if self.rows != self.cols:\n raise IndexError(\"Matrix is not square\")",
"def is_square(matrix):\n return is_matrix(matrix) and matrix.shape[0] == matrix.shape[1]",
"def square_check(self):\n return len(self.matrix) == len(self.matrix[0])",
"def chec... | [
"0.82600665",
"0.8005253",
"0.7705513",
"0.76000637",
"0.7547414",
"0.7547172",
"0.7285882",
"0.7285882",
"0.7253775",
"0.7096642",
"0.690228",
"0.681686",
"0.6795993",
"0.67146957",
"0.66360945",
"0.66099375",
"0.6561458",
"0.65606064",
"0.65251964",
"0.651151",
"0.6493142",... | 0.7680184 | 4 |
Creates a matrix filled with zeros. | def zeros_matrix(rows, cols):
M = []
while len(M) < rows:
M.append([])
while len(M[-1]) < cols:
M[-1].append(0.0)
return M | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zeroes(height, width):\n g = [[0.0 for _ in range(width)] for __ in range(height)]\n return Matrix(g)",
"def zeroMatrix(width, height):\n returnvalue = Matrix()\n for i in range(width):\n newrow = [0] * height\n returnvalue.addRow(*newrow)\n return returnvalue",
"def ze... | [
"0.83105844",
"0.82251585",
"0.8177624",
"0.814171",
"0.80738527",
"0.8053129",
"0.7960837",
"0.7792159",
"0.7705187",
"0.7678834",
"0.76101226",
"0.7580145",
"0.74690133",
"0.7464018",
"0.7462307",
"0.74617356",
"0.7240482",
"0.7231481",
"0.718796",
"0.71302176",
"0.70924646... | 0.7950135 | 8 |
Creates and returns an identity matrix. | def identity_matrix(n):
I = zeros_matrix(n, n)
for i in range(n):
I[i][i] = 1.0
return I | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identity_matrix():\r\n return numpy.identity(4)",
"def identity_matrix():\n return numpy.identity(4)",
"def IdentityMatrix():\n return RotationMatrix([\n [1, 0, 0],\n [0, 1, 0],\n [0, 0, 1]\n ])",
"def identity_matrix(n: int) -> Matrix:\n return make_matrix(n, n, lambd... | [
"0.87470335",
"0.874405",
"0.82996976",
"0.82049274",
"0.82049274",
"0.82049274",
"0.8065252",
"0.80513746",
"0.792574",
"0.78846717",
"0.78415334",
"0.7787648",
"0.7665313",
"0.7528092",
"0.7517327",
"0.7159512",
"0.68217206",
"0.67490846",
"0.67490846",
"0.6670712",
"0.6534... | 0.7780349 | 13 |
Creates and returns a copy of a matrix. | def copy_matrix(M):
rows = len(M)
cols = len(M[0])
MC = zeros_matrix(rows, cols)
for i in range(rows):
for j in range(rows):
MC[i][j] = M[i][j]
return MC | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_matrix(matrix):\n import numpy as np\n copy_of_m = np.copy(matrix)\n return copy_of_m",
"def copy(self):\n rdd = self._data.map(\n lambda m: m\n )\n\n return Matrix(rdd, self._shape,\n dtype=self._dtype, coord_format=self._coord_format, nelem... | [
"0.8205669",
"0.79022706",
"0.78004694",
"0.7544755",
"0.7494636",
"0.7439033",
"0.7438018",
"0.73586124",
"0.72616833",
"0.72254306",
"0.7184861",
"0.71509737",
"0.71381754",
"0.70306104",
"0.6880537",
"0.6872653",
"0.6872653",
"0.6836561",
"0.68200153",
"0.67752004",
"0.644... | 0.76325834 | 3 |
Creates and returns a transpose of a matrix. | def transpose(M):
rows = len(M)
cols = len(M[0])
MT = zeros_matrix(cols, rows)
for i in range(rows):
for j in range(cols):
MT[j][i] = M[i][j]
return MT | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transpose_matrix(matrix):\n n = len(matrix[0])\n m = len(matrix)\n matrix_t = create_matrix(n,m)\n for j in range(n):\n for i in range(m):\n matrix_t[j][i] = matrix[i][j]\n \n return matrix_t",
"def transpose(self):\n transposed_data = []\n for i in range(1, ... | [
"0.81251967",
"0.7924036",
"0.79103607",
"0.79101074",
"0.78539556",
"0.7807774",
"0.7785112",
"0.7656858",
"0.7643545",
"0.76049787",
"0.7601282",
"0.75942373",
"0.759238",
"0.7577282",
"0.7569614",
"0.75598514",
"0.75094044",
"0.74728984",
"0.74510014",
"0.74472064",
"0.742... | 0.7711812 | 7 |
Returns the product of the matrix A B | def matrix_multiply(A,B):
rowsA = len(A)
colsA = len(A[0])
rowsB = len(B)
colsB = len(B[0])
if colsA != rowsB:
raise ArithmeticError('Number of A columns must equal number of B rows.')
C = zeros_matrix(rowsA, colsB)
for i in range(rowsA):
for j in range(colsB):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matr_prod(_A, _B):\r\n # Matrix multiplication\r\n B0 = _B[0]\r\n lenB = len(_B)\r\n lenA = len(_A)\r\n if(len(_A[0]) != lenB): # Check matrix dimensions \r\n Exception('Matrices have wrong dimensions')\r\n if(isinstance(B0, list) or isinstance(B0, array) or isinstance(B0, tuple... | [
"0.8343431",
"0.8087157",
"0.8086567",
"0.80407274",
"0.79556924",
"0.7707546",
"0.77015364",
"0.76632124",
"0.76312715",
"0.76082563",
"0.7588993",
"0.75824964",
"0.75753325",
"0.74819463",
"0.7461189",
"0.74422127",
"0.74324286",
"0.7333407",
"0.72310764",
"0.7207229",
"0.7... | 0.824016 | 1 |
Checks the equality of two matrices. | def check_matrix_equality(A,B, tol=None):
if len(A) != len(B) or len(A[0]) != len(B[0]):
return False
for i in range(len(A)):
for j in range(len(A[0])):
if tol == None:
if abs(A[i][j] - B[i][j]) > 1e-10:
return False
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsEqual(*args, **kwargs):\n return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs)",
"def _are_matrix_elements_equal(element, another_element):\n difference = sympy.N(sympy.expand(element) - sympy.expand(another_element))\n\n try:\n return np.allclose(\n float(sympy.re(difference... | [
"0.7714554",
"0.740203",
"0.7387387",
"0.73428464",
"0.73169017",
"0.7311009",
"0.7276583",
"0.7269618",
"0.7231773",
"0.71865493",
"0.7137955",
"0.71372896",
"0.7098439",
"0.7072754",
"0.7070013",
"0.7067749",
"0.70479655",
"0.69766957",
"0.69462913",
"0.6940412",
"0.693163"... | 0.7398573 | 2 |
Returns the inverse of the passed in matrix. | def invert_matrix(A, tol=None):
check_squareness(A)
check_non_singular(A)
n = len(A)
AM = copy_matrix(A)
I = identity_matrix(n)
IM = copy_matrix(I)
indices = list(range(n))
for fd in range(n):
fdScaler = 1.0 / AM[fd][fd]
for j in range(n):
AM[fd][j] *= fdSca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self,mat):\n result = np.linalg.inv(mat)\n self.out = result\n return self.out",
"def inv(matrix):\n if sp.sparse.issparse(matrix):\n result = spla.inv(matrix)\n else:\n result = sp.linalg.inv(matrix)\n return result",
"def invert(M):\r\n M = isMatrix(... | [
"0.8345577",
"0.8109512",
"0.7889959",
"0.7608118",
"0.7588944",
"0.75702876",
"0.7569624",
"0.7557103",
"0.7554652",
"0.7536533",
"0.7501843",
"0.74276596",
"0.74266934",
"0.73573285",
"0.735046",
"0.7318116",
"0.73134756",
"0.7303804",
"0.72714496",
"0.7263057",
"0.7237953"... | 0.66334236 | 42 |
Multiply vector by scalar. | def mult_vect_by_scalar(v, a):
return [a * i for i in v] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]",
"def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]",
"def scalar_multiply(s: float, v: Vector) -> Vector:\n return [s * v_item for v_item in v]",
"def apply_scalar(vector, scalar):... | [
"0.80728054",
"0.80728054",
"0.78996766",
"0.77208054",
"0.7540622",
"0.746231",
"0.74302906",
"0.7429139",
"0.7425227",
"0.72692066",
"0.7259795",
"0.7232113",
"0.72266245",
"0.72266245",
"0.7076444",
"0.7076444",
"0.7040157",
"0.7023348",
"0.6994792",
"0.6898495",
"0.687613... | 0.7260508 | 10 |
Scalar multiplication of two vectors. | def scalar_mult(v, u):
return [v[i] * u[i] for i in range(len(v))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mulVectors(X1,X2):\n _checkSize(X1,X2)\n return sum([ X1[i] * X2[i] for i in range(len(X1))])",
"def vectordot(a, b):\n return np.sum(a * b, 1)",
"def __mul__(self, other): \n if isinstance(other, Iterable):\n # dot product\n return self.x * other[0] + self.y *... | [
"0.7891071",
"0.7588624",
"0.745898",
"0.7430685",
"0.7415986",
"0.7390709",
"0.738733",
"0.7380874",
"0.7380874",
"0.7368991",
"0.7364799",
"0.7343856",
"0.73292464",
"0.7321248",
"0.7282088",
"0.7271174",
"0.7239274",
"0.72315997",
"0.7225507",
"0.72147185",
"0.7187455",
... | 0.70368165 | 27 |
L1norm of a vector. | def l1_norm(v):
res = 0
for e in v:
res += abs(e)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1(vec):\n return np.linalg.norm(vec, ord=1)",
"def l1_norm(f):\n return dmp_l1_norm(f.rep, f.lev, f.dom)",
"def l1_norm(vec):\n res = sum(abs(float(x)) for x in vec.values())\n return res",
"def func_val_l1_norm(w):\n\treturn np.linalg.norm(w,ord = 1)",
"def normalise1D(*vector):\n\n ... | [
"0.9103843",
"0.8192758",
"0.810895",
"0.8001383",
"0.78128934",
"0.7798467",
"0.77959925",
"0.7714896",
"0.76301044",
"0.7540783",
"0.75042504",
"0.7388181",
"0.72909045",
"0.7280093",
"0.72323036",
"0.72279674",
"0.7182461",
"0.715058",
"0.71115243",
"0.70706004",
"0.706851... | 0.856022 | 1 |
L2norm of a vector. | def l2_norm(v):
res = 0
for e in v:
res += e * e
return math.sqrt(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l2(vec):\n return np.linalg.norm(vec)",
"def norm_l2(v):\n return np.sqrt((v**2).sum())",
"def norm_l2(u):\n return linalg.norm(u.ravel())",
"def l2norm(X):\n norm = np.linalg.norm(X, axis=1, keepdims=True)\n return 1.0 * X / norm",
"def l2_norm(vec_or_matrix):\n if len(vec_or_mat... | [
"0.8957043",
"0.8518496",
"0.8318099",
"0.82683444",
"0.8182556",
"0.8119852",
"0.8069992",
"0.8067408",
"0.800764",
"0.79987574",
"0.78410333",
"0.7818018",
"0.77782995",
"0.775152",
"0.77224255",
"0.77148014",
"0.7711236",
"0.7711236",
"0.7711236",
"0.76835793",
"0.7682921"... | 0.88052756 | 1 |
Get chain info by chain_code | def get_chain_info(chain_code: str) -> ChainInfo:
if chain_code not in registry.chain_dict:
raise exceptions.ChainNotFound(chain_code)
return registry.chain_dict[chain_code] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chain(self, chain_id, model_num = 0):\n return self.struct[model_num][chain_id]",
"def getChain(self, chain):\n\n\t\tfor i in self.chain:\n\t\t\tif i.name == chain:\n\t\t\t\treturn i\n\n\t\treturn None",
"def get_chain(self, chain_id):\n if self.chain_dict.has_key(chain_id):\n retu... | [
"0.6661691",
"0.66171616",
"0.66006386",
"0.6534698",
"0.65320975",
"0.6259728",
"0.59668124",
"0.5826618",
"0.57274354",
"0.56827086",
"0.56827086",
"0.56683314",
"0.5597438",
"0.5557106",
"0.55414283",
"0.54523975",
"0.54389966",
"0.5433401",
"0.5423506",
"0.5423506",
"0.54... | 0.85973877 | 0 |
Check if a specific chain is enabled | def is_chain_enabled(chain_code: str) -> bool:
return chain_code in settings.ENABLED_CHAIN_COINS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chainExists(self, chain):\n\n\t\tfor i in self.chain:\n\t\t\tif i.name == chain:\n\t\t\t\treturn True\n\n\t\treturn False",
"def is_enabled(self):",
"def Enabled(self) -> bool:",
"def check_enable_mode(self, *args, **kwargs):\n pass",
"async def enabled(self) -> bool:\n response = await s... | [
"0.65481395",
"0.64991826",
"0.62574923",
"0.6183565",
"0.60547596",
"0.6043707",
"0.5994459",
"0.5947198",
"0.5914833",
"0.58447534",
"0.5816314",
"0.5812519",
"0.58103377",
"0.5808176",
"0.5804365",
"0.57402676",
"0.5713707",
"0.5713226",
"0.5707869",
"0.56262934",
"0.56247... | 0.8113589 | 0 |
Get coin info by coin_code | def get_coin_info(coin_code: str, nullable: bool = False) -> Optional[CoinInfo]:
coin = registry.coin_dict.get(coin_code) or daos.get_coin_info(coin_code)
if not coin and not nullable:
raise exceptions.CoinNotFound(coin_code)
return coin | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coin_info(self):\n res = r.get(self.url + self.coin)\n return self.execute(res)",
"def get_related_coins(coin_code: str) -> Tuple[CoinInfo, CoinInfo, CoinInfo]:\n coin_info = get_coin_info(coin_code)\n chain_info = get_chain_info(coin_info.chain_code)\n\n return get_coin_info(coin_info... | [
"0.70733917",
"0.697701",
"0.6623063",
"0.63734275",
"0.60808015",
"0.6028087",
"0.59553903",
"0.580595",
"0.5796195",
"0.579552",
"0.5762164",
"0.56983614",
"0.5668701",
"0.5658127",
"0.56063265",
"0.56048506",
"0.55384284",
"0.5512767",
"0.55095935",
"0.5492337",
"0.5482836... | 0.7121802 | 0 |
Get all chains info | def get_all_chains() -> List[ChainInfo]:
return list(registry.chain_dict.values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_chains(self):\n pass",
"def get_chain_info(self, symbol: str): \n return self.trader.fetch_chain_info(symbol)",
"def chains(self, model_num = 0):\n return [c for c in self.struct]",
"def iter_all_chains(self):\n for model in self.model_list:\n for chain in ... | [
"0.6648737",
"0.66053885",
"0.6406602",
"0.6345221",
"0.6315527",
"0.62710094",
"0.62423307",
"0.6205776",
"0.61464137",
"0.61464137",
"0.5986051",
"0.59603333",
"0.58953345",
"0.58749545",
"0.58068633",
"0.58068633",
"0.57895243",
"0.57617736",
"0.567747",
"0.565552",
"0.565... | 0.7985782 | 0 |
Get all coins info | def get_all_coins() -> List[CoinInfo]:
coins = list(registry.coin_dict.values())
coins.extend(daos.get_all_coins())
coins = _deduplicate_coins(coins)
return coins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coin_info(self):\n res = r.get(self.url + self.coin)\n return self.execute(res)",
"def getCoins(self):\n return self.coins",
"def get_coins(self):\n if self.coins:\n return self.coins.keys()\n else:\n return []",
"def get_coins():\n coinsq = ses... | [
"0.809754",
"0.7908469",
"0.78092235",
"0.7444306",
"0.6880037",
"0.684716",
"0.6776203",
"0.65017116",
"0.6385217",
"0.6361425",
"0.6349795",
"0.6266025",
"0.61859596",
"0.61856484",
"0.61380804",
"0.6127478",
"0.60958624",
"0.60535365",
"0.5931904",
"0.5909271",
"0.58948857... | 0.7782449 | 3 |
Get coins by specific chain_code | def get_coins_by_chain(chain_code: str) -> List[CoinInfo]:
coins = [i for i in registry.coin_dict.values() if i.chain_code == chain_code]
coins.extend(daos.get_coins_by_chain(chain_code))
coins = _deduplicate_coins(coins)
return coins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_related_coins(coin_code: str) -> Tuple[CoinInfo, CoinInfo, CoinInfo]:\n coin_info = get_coin_info(coin_code)\n chain_info = get_chain_info(coin_info.chain_code)\n\n return get_coin_info(coin_info.chain_code), coin_info, get_coin_info(chain_info.fee_code)",
"def get_chain_info(chain_code: str) ->... | [
"0.66432834",
"0.6530525",
"0.6016952",
"0.59838",
"0.5890483",
"0.57192004",
"0.5628259",
"0.5595202",
"0.5588637",
"0.5577032",
"0.55668074",
"0.55609953",
"0.5553892",
"0.5499243",
"0.5496403",
"0.54455143",
"0.5414286",
"0.54084104",
"0.5376834",
"0.53712624",
"0.53567535... | 0.81350636 | 0 |
Get tuple of (coin info of chain_code, coin info of coin_code, coin info of fee_code) at the same time | def get_related_coins(coin_code: str) -> Tuple[CoinInfo, CoinInfo, CoinInfo]:
coin_info = get_coin_info(coin_code)
chain_info = get_chain_info(coin_info.chain_code)
return get_coin_info(coin_info.chain_code), coin_info, get_coin_info(chain_info.fee_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_coins_by_chain(chain_code: str) -> List[CoinInfo]:\n coins = [i for i in registry.coin_dict.values() if i.chain_code == chain_code]\n coins.extend(daos.get_coins_by_chain(chain_code))\n\n coins = _deduplicate_coins(coins)\n return coins",
"async def get_coins_of_interest(\n self,\n ... | [
"0.63832754",
"0.62517136",
"0.6153005",
"0.6009365",
"0.58502924",
"0.5819006",
"0.57800615",
"0.5763463",
"0.56328285",
"0.5569762",
"0.5514283",
"0.5464755",
"0.545611",
"0.54450524",
"0.53672785",
"0.53528535",
"0.53291386",
"0.53156674",
"0.5303876",
"0.530158",
"0.52653... | 0.79970706 | 0 |
Generate an internal objective, `dlik_dh H`, for a given GP layer. | def gen_gp_loss(gp):
def loss(_, H):
dlik_dh_times_H = H * K.gather(gp.dlik_dh, gp.batch_ids[:gp.batch_sz])
return K.sum(dlik_dh_times_H, axis=1, keepdims=True)
return loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dh(z,h=0.7,omegalambda=0.7,omegam=0.3,omegak=0.0):\n return distcalc(z,h,omegalambda,omegam,omegak)['dh']",
"def Hstep_cost_function(H): \n U = Wold - Yold\n #cost = -np.trace(H.T@K@H) + (self.admm_rho/2)*(norm(H.T@D - Wold + self.Y, 'fro')**2) \n ... | [
"0.6006004",
"0.585712",
"0.57309765",
"0.57007205",
"0.55555654",
"0.5549013",
"0.54939693",
"0.5392773",
"0.5370718",
"0.53684366",
"0.5349288",
"0.53174835",
"0.529212",
"0.52497977",
"0.5234803",
"0.5220896",
"0.52103525",
"0.5194645",
"0.51926285",
"0.5189824",
"0.517168... | 0.6818806 | 0 |
Tokenizes code into a list of CuBERT sentences. | def code_to_cubert_sentences(
code,
initial_tokenizer,
subword_tokenizer,
):
tokens = initial_tokenizer.tokenize(code)[:-1] # type: List[Text]
logging.vlog(5, 'Code >>>%s<<< is tokenized into >>>%s<<<.', code, tokens)
# This will split the list into sublists of non-NEWLINE tokens (key is
# False) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tokenize_for_bleu_eval(self, code):\n code = re.sub(r'([^A-Za-z0-9_])', r' \\1 ', code)\n code = re.sub(r'([a-z])([A-Z])', r'\\1 \\2', code)\n code = re.sub(r'\\s+', ' ', code)\n code = code.replace('\"', '`')\n code = code.replace('\\'', '`')\n tokens = [t for t in co... | [
"0.6863243",
"0.67525357",
"0.67525357",
"0.669251",
"0.6580094",
"0.65743464",
"0.6467367",
"0.64577",
"0.63880205",
"0.6343771",
"0.62983996",
"0.62966585",
"0.6272456",
"0.6251971",
"0.62455213",
"0.6221313",
"0.61965567",
"0.6195651",
"0.61892426",
"0.61888105",
"0.616274... | 0.7083132 | 0 |
121 yes ! 21 no! nouse str space | def is_palindrome(a):
max = a
min = 0
while max > 0:
min = (min * 10 + max % 10)
max /= 10
return min == a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nostatement(phrase):\n\n is_printable = lambda x: x in printable\n is_whitespace = lambda x: x in whitespace\n if not any([is_printable(x) and not is_whitespace(x) for x in phrase]):\n return 'Fine. Be that way!'",
"def verse_2():\n print(\"Old MacDonald had a farm\")\n print(\"E-I-E-I-... | [
"0.6229907",
"0.6042719",
"0.5840087",
"0.57881814",
"0.5769659",
"0.57432306",
"0.5722412",
"0.57041365",
"0.5596774",
"0.55785036",
"0.55535126",
"0.55232805",
"0.5517944",
"0.55135435",
"0.5506934",
"0.5497256",
"0.5475314",
"0.5472987",
"0.54542875",
"0.5442861",
"0.54366... | 0.0 | -1 |
format metadata, multiline tags are not supported in markdown2 | def format_markdown(md_content: str) -> str:
tag_index = md_content.find('tags')
if tag_index > -1:
meta_end = md_content.find(META_SEPARATOR)
r = format_meta(md_content[:meta_end])
return r + md_content[meta_end:]
return md_content | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _display_metadata_markdown(self, filename, metadata, options):\n show_all = \"all\" in options\n options = string_to_list(options)\n lines = []\n if \"description\" in options or show_all:\n if metadata.description:\n lines += [f\":Description: {metadata.de... | [
"0.6714001",
"0.6370263",
"0.6355281",
"0.6342423",
"0.620168",
"0.61515206",
"0.61427075",
"0.614102",
"0.60519606",
"0.6008847",
"0.59557945",
"0.59388214",
"0.5937017",
"0.5912883",
"0.5902827",
"0.590074",
"0.5844119",
"0.57907736",
"0.57890886",
"0.5786218",
"0.5786025",... | 0.6650283 | 1 |
Function to export multiple Jobs, with folder hierarchy for each Job | def export_records_as_xml(spark, ct_id):
# init logging support
spark.sparkContext.setLogLevel('INFO')
log4jLogger = spark.sparkContext._jvm.org.apache.log4j
logger = log4jLogger.LogManager.getLogger(__name__)
# hydrate CombineBackgroundTask
ct = CombineBackgroundTask.objects.get(pk=int(ct_id)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_jobs_file(jobs_file: Path, root_dir: Path):\n output_dir = root_dir / 'output'\n output_dir.mkdir(exist_ok=True)\n\n jobs_entries = []\n\n input_root_dir = root_dir / 'inputs' # This will contain one or more line folders or a single baseline folder\n\n # Get the line subdirectories\n fo... | [
"0.6415777",
"0.6293375",
"0.61829567",
"0.6166739",
"0.6111535",
"0.5940927",
"0.58963144",
"0.58238053",
"0.5741773",
"0.57335037",
"0.573221",
"0.571614",
"0.57016623",
"0.5636251",
"0.5616405",
"0.56129754",
"0.5601236",
"0.55718577",
"0.555322",
"0.553652",
"0.55194795",... | 0.0 | -1 |
Function to export multiple Jobs, with folder hierarchy for each Job | def export_records_as_tabular_data(spark, ct_id):
# hydrate CombineBackgroundTask
ct = CombineBackgroundTask.objects.get(pk=int(ct_id))
# reconstitute fm_export_config_json
fm_config = json.loads(ct.task_params['fm_export_config_json'])
# clean base path
output_path = "file:///%s" % ct.task_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_jobs_file(jobs_file: Path, root_dir: Path):\n output_dir = root_dir / 'output'\n output_dir.mkdir(exist_ok=True)\n\n jobs_entries = []\n\n input_root_dir = root_dir / 'inputs' # This will contain one or more line folders or a single baseline folder\n\n # Get the line subdirectories\n fo... | [
"0.6415852",
"0.62944436",
"0.61835885",
"0.6166434",
"0.6109709",
"0.5941371",
"0.5897114",
"0.58242196",
"0.5741506",
"0.5733732",
"0.5731104",
"0.5715749",
"0.57014203",
"0.56365126",
"0.56180114",
"0.56140405",
"0.560171",
"0.55737257",
"0.55544275",
"0.55366474",
"0.5519... | 0.0 | -1 |
SubFunction to convert RDD of XML to KVP | def _convert_xml_to_kvp(batch_rdd, fm_config):
def kvp_writer_udf(row, fm_config):
"""
Converts XML to kvpjson
"""
# get handler, that includes defaults
xml2kvp_defaults = XML2kvp(**fm_config)
# convert XML to kvp
xml2kvp_handler = XML2kvp.xml_to_kvp(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kml_extract_RDD(xml_file):\n soup = BeautifulSoup(xml_file, \"lxml-xml\")\n return get_kml_content(soup)",
"def apply_transformations(rdd):\n ### BEGIN SOLUTION ###\n return rdd",
"def test_xml_kpointsw(xml_parser):\n \n kpointsw = xml_parser.get_kpointsw()\n test = np.array([0.0046296... | [
"0.68342566",
"0.610607",
"0.56533575",
"0.56469774",
"0.5593624",
"0.55702865",
"0.532358",
"0.5312068",
"0.52508914",
"0.52455354",
"0.52455354",
"0.51781493",
"0.5105279",
"0.5073926",
"0.5057156",
"0.500157",
"0.4992597",
"0.49787492",
"0.49769318",
"0.49672762",
"0.49443... | 0.66812235 | 1 |
Converts XML to kvpjson | def kvp_writer_udf(row, fm_config):
# get handler, that includes defaults
xml2kvp_defaults = XML2kvp(**fm_config)
# convert XML to kvp
xml2kvp_handler = XML2kvp.xml_to_kvp(
row.document, return_handler=True, handler=xml2kvp_defaults)
# loop through and convert list... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xml_to_json(xml):\n\n logging.debug(\"-> xml_to_json()\")\n\n xml_as_dict = xmltodict.parse(xml)\n xml_as_json = json.dumps(xml_as_dict)\n\n logging.debug(\"<- xml_to_json()\")\n\n return xml_as_json",
"def parse_xml(request):\n data = xmltodict.parse(request.data)\n return json.dumps(da... | [
"0.67457545",
"0.67316794",
"0.6506803",
"0.6358584",
"0.62381154",
"0.6031014",
"0.59227693",
"0.5880872",
"0.58055216",
"0.5778025",
"0.5774834",
"0.5770503",
"0.5769801",
"0.56389093",
"0.552329",
"0.5490419",
"0.54871583",
"0.54609096",
"0.5427796",
"0.54215163",
"0.53701... | 0.0 | -1 |
Function to write RDD to S3 | def _write_rdd_to_s3(
spark,
rdd,
bucket,
key,
access_key=settings.AWS_ACCESS_KEY_ID,
secret_key=settings.AWS_SECRET_ACCESS_KEY):
# dynamically set s3 credentials
spark.sparkContext._jsc.hadoopConfiguration().set("fs.s3a.access.key", access_key)
spark.sparkCo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_to_s3(df, bucket, path):\n pass",
"def write_to_S3(data_bucket, data_key, model_version, bucket_name):\n df = get_S3_df(data_bucket, data_key)\n X = df.drop(columns='target')\n y = df['target']\n fitted_model = fit(RF, X, y)\n\n key = f'model_{model_version}.joblib'\n\n with tempfi... | [
"0.76141727",
"0.6810543",
"0.6776571",
"0.6726307",
"0.6726292",
"0.6584743",
"0.635899",
"0.63203007",
"0.6299286",
"0.62920445",
"0.6272629",
"0.62652814",
"0.61964273",
"0.61855865",
"0.6088748",
"0.60656327",
"0.60344815",
"0.6034407",
"0.6029303",
"0.6028873",
"0.602505... | 0.79717773 | 0 |
Convenience method to retrieve set of records as Spark DataFrame | def get_job_as_df(spark, job_id, remove_id=False):
pipeline = json.dumps({'$match': {'job_id': job_id}})
mdf = spark.read.format("com.mongodb.spark.sql.DefaultSource")\
.option("uri", "mongodb://%s" % settings.MONGO_HOST)\
.option("database", "combine")\
.option("collection", "record")\... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def qset_to_df(qset, datatype='object'):\n df = pd.DataFrame(list(qset.values()), dtype=datatype)\n return df",
"def spark_df_to_records(df):\n return [tuple(r) for r in df.collect()]",
"def pd(self, *args, **kwargs):\n return pd.DataFrame.from_records(self.aslist(), *args, **kwargs)",
"def dat... | [
"0.6874762",
"0.67645144",
"0.6537734",
"0.6515892",
"0.6470557",
"0.6428499",
"0.6179536",
"0.61614597",
"0.61406046",
"0.6136869",
"0.61283815",
"0.6064281",
"0.60510206",
"0.6005521",
"0.5992337",
"0.5990479",
"0.5971488",
"0.5949681",
"0.59414095",
"0.5937641",
"0.5907337... | 0.0 | -1 |
Convenience method to retrieve mapped fields from ElasticSearch | def get_job_es(spark,
job_id=None,
indices=None,
doc_type='record',
es_query=None,
field_include=None,
field_exclude=None,
as_rdd=False):
# handle indices
if job_id:
es_indexes = 'j%s' % job_id
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indices_get_mapping(es):\n index = 'customer'\n\n print(es.indices.get_mapping(index=index))",
"def get_field_mapping(self, index: str, field_name: str) -> Dict[str, str]:\n try:\n response = self.__client__.indices.get_field_mapping(\n fields=field_name,\n ... | [
"0.59721637",
"0.5970356",
"0.59351563",
"0.5892698",
"0.5837377",
"0.57440674",
"0.5576286",
"0.55681604",
"0.54960465",
"0.54954594",
"0.54876953",
"0.5435626",
"0.5426065",
"0.5390112",
"0.5383841",
"0.538376",
"0.5365062",
"0.5359541",
"0.53305423",
"0.5322735",
"0.530604... | 0.0 | -1 |
Reads the config dictionary from the yaml file. | def read_config(path: str) -> Dict[str, Any]:
with open(path, 'r') as stream:
config = yaml.load(stream, Loader=yaml.FullLoader)
return config | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config() -> dict:\n with Path(\"config.yaml\").open(\"r\") as file_pointer:\n try:\n return yaml.safe_load(file_pointer)\n except yaml.YAMLError as e:\n logging.error(e)",
"def _parse_from_yaml(self) -> Dict:\n config_path = path.join(path.dirname(path.abspath(_... | [
"0.8510703",
"0.8170443",
"0.81028724",
"0.79346716",
"0.7744516",
"0.77233523",
"0.7691615",
"0.7677799",
"0.76556385",
"0.7655394",
"0.76022524",
"0.75331354",
"0.75172734",
"0.7492183",
"0.7491954",
"0.74798125",
"0.7412121",
"0.7409238",
"0.74053746",
"0.73853785",
"0.738... | 0.7777115 | 4 |
Saves the config as a yaml file. | def save_config(config: Dict[str, Any], path: str) -> None:
with open(path, 'w+', encoding='utf-8') as stream:
yaml.dump(config, stream, default_flow_style=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save():\n print(\"Saving config file..\")\n\n res = yaml.round_trip_dump(_conf, indent=2, block_seq_indent=1)\n\n with open(__config_file, 'w', encoding='utf-8') as stream:\n stream.write(res)",
"def _save_configuration_to_yml(self):\n data = self.get_configuration_data()\n time... | [
"0.8711886",
"0.8137157",
"0.8060888",
"0.8050422",
"0.78260994",
"0.780826",
"0.77677363",
"0.7716582",
"0.7687827",
"0.76815486",
"0.7630702",
"0.7618591",
"0.7603628",
"0.75903785",
"0.7572619",
"0.7515349",
"0.7492995",
"0.7472796",
"0.7456314",
"0.7413156",
"0.74058336",... | 0.78916246 | 4 |
Recursively retrieves all files with a given extension from a folder. | def get_files(path: str, extension: str = '.wav') -> List[Path]:
return list(Path(path).expanduser().resolve().rglob(f'*{extension}')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAllFilesWithExtension(directory,extension):\n filesWithExtension = []\n for root, dirs, files in os.walk(directory):\n for file in files:\n if file.endswith(extension):\n filesWithExtension.append(os.path.realpath(os.path.join(root, file)))\n return filesWithExtens... | [
"0.7754233",
"0.77189565",
"0.76108575",
"0.7574856",
"0.7549951",
"0.75188273",
"0.7362993",
"0.73599476",
"0.7358571",
"0.73053837",
"0.72964454",
"0.72771573",
"0.7267167",
"0.7237166",
"0.72353244",
"0.71759224",
"0.7163786",
"0.71300334",
"0.7105351",
"0.708306",
"0.7051... | 0.6895741 | 36 |
Pickles a given object to a binary file. | def pickle_binary(data: object, file: Union[str, Path]) -> None:
with open(str(file), 'wb') as f:
pickle.dump(data, f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pickle_object(Object, file):\n filehandler = open(file, 'wb')\n pickle.dump(Object, filehandler)\n filehandler.close()",
"def pickleSave(object, filename):\n #Todo: Handle exceptions from pickle\n filehandler = open(\"obj/\" + filename + \".obj\", 'wb')\n pickle.dump(object, filehandler)",
... | [
"0.8000543",
"0.7845757",
"0.7839422",
"0.7826546",
"0.78225243",
"0.78010195",
"0.7790488",
"0.7765061",
"0.7754899",
"0.771234",
"0.770211",
"0.76987827",
"0.7672998",
"0.7647847",
"0.7638088",
"0.7612324",
"0.7594783",
"0.75926596",
"0.75694567",
"0.7567726",
"0.75617766",... | 0.74191135 | 30 |
Unpickles a given binary file to an object | def unpickle_binary(file: Union[str, Path]) -> object:
with open(str(file), 'rb') as f:
return pickle.load(f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unpickle_object(file):\n filehandler = open(file, 'rb')\n Object = pickle.load(filehandler)\n filehandler.close()\n return Object",
"def pickle2obj(file):\n with open(file, mode = \"rb\") as fileObj:\n return pickle.load(fileObj)",
"def load_object(fpath):\r\n with open(fpath, 'rb'... | [
"0.7907008",
"0.7405966",
"0.7287658",
"0.7250862",
"0.718685",
"0.7156075",
"0.70729834",
"0.7040878",
"0.70087326",
"0.69523394",
"0.6948881",
"0.68949765",
"0.6875697",
"0.6867291",
"0.68491626",
"0.684888",
"0.6835081",
"0.6835064",
"0.683392",
"0.682806",
"0.6804208",
... | 0.8081387 | 0 |
Sends a batch of data to the given torch devicee (cpu or cuda). | def to_device(batch: Dict[str, torch.Tensor], device: torch.device) -> Dict[str, torch.Tensor]:
return {key: val.to(device) for key, val in batch.items()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_device(data, device):\n if isinstance(data, (list,tuple)): # allows to apply function to lists or tuples of tensors\n return [to_device(x, device) for x in data]\n return data.to(device, non_blocking=True)",
"def sample_batch(pid, args, batch_queue, port_dict, device, actor_id_to_ip_dataport,... | [
"0.6475205",
"0.6251601",
"0.6216795",
"0.6203235",
"0.6198509",
"0.61853004",
"0.61313254",
"0.6042927",
"0.60021627",
"0.6000432",
"0.5995935",
"0.5995935",
"0.5995935",
"0.5995935",
"0.5981431",
"0.5953888",
"0.5864239",
"0.58164024",
"0.5712651",
"0.57055473",
"0.56818134... | 0.5653224 | 22 |
To jest prosta strategia | def strategiaa(stan_gry):
ruch = min(random.randint(1,3), stan_gry)
return ruch | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_extract_categories():\n pass",
"def test_get_categories(self):\n pass",
"def test_category_manip_pipeline(self):\n raise NotImplementedError(\"\")",
"def test_create_category(self):\n pass",
"def test_category(self):\n # XXX identifiers would be groovy\n self.... | [
"0.7005442",
"0.68592596",
"0.67686164",
"0.64699984",
"0.6344549",
"0.62875855",
"0.6275784",
"0.62219745",
"0.6193412",
"0.6188195",
"0.6186761",
"0.61033666",
"0.60116494",
"0.60108453",
"0.59562004",
"0.59385",
"0.5936525",
"0.5885948",
"0.5882332",
"0.5873498",
"0.587303... | 0.0 | -1 |
Pick GPU if available, else CPU | def get_default_device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_gpu_device_if_present():\n d = dpctl.SyclDevice(\"gpu,cpu\")\n print(\"Selected \" + (\"GPU\" if d.is_gpu else \"CPU\") + \" device\")",
"def return_free_GPU():\r\n if torch.cuda.is_available():\r\n gpu_num = torch.cuda.device_count()\r\n device = torch.device('cuda:{}'.format(g... | [
"0.7640736",
"0.7275291",
"0.7263306",
"0.71874255",
"0.70942754",
"0.70831823",
"0.7029543",
"0.7010545",
"0.69923997",
"0.69889635",
"0.69889635",
"0.69889635",
"0.69685453",
"0.6955028",
"0.6901109",
"0.6901109",
"0.68919945",
"0.68757796",
"0.68671566",
"0.6804158",
"0.67... | 0.6680308 | 27 |
Move tensor(s) to chosen device | def to_device(data, device):
if isinstance(data, (list,tuple)):
return [to_device(x, device) for x in data]
return data.to(device, non_blocking=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_to_device(input_tensors: List[torch.Tensor],\n target_device: Optional[torch.device],\n non_blocking: bool = False) -> Iterable[torch.Tensor]:\n return (tensor if tensor.device == target_device or target_device is None\n else tensor.to(target_device, non_b... | [
"0.62680835",
"0.5991555",
"0.58284396",
"0.5823883",
"0.57600415",
"0.5746575",
"0.56958485",
"0.56943864",
"0.5671953",
"0.56672454",
"0.56561226",
"0.55128235",
"0.55102444",
"0.5509777",
"0.547726",
"0.5452295",
"0.54366887",
"0.53767467",
"0.53539515",
"0.53539515",
"0.5... | 0.0 | -1 |
Yield a batch of data after moving it to device | def __iter__(self):
for b in self.dl:
yield to_device(b, self.device) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n for b in self.dl: \n yield to_device(b, self.device) # yield pauses the execution, not store values in memory, forgets about them once iterated\n # no need to remove batch of data from device, done automatically",
"def __iter__(self):\n while True:\n ... | [
"0.8038773",
"0.6822095",
"0.6774101",
"0.6757084",
"0.6754781",
"0.67486644",
"0.66554976",
"0.6627214",
"0.6619876",
"0.65627116",
"0.6536915",
"0.6529731",
"0.6469983",
"0.64140165",
"0.63782895",
"0.6337724",
"0.631927",
"0.63143736",
"0.6306672",
"0.62904304",
"0.6277047... | 0.6813648 | 5 |
Shortcut to test "total population" field from the P1 (race) table since this table exists for both 2000 and 2010. | def _test_totalpop(self, obj, known_2000, known_2010):
known_delta = known_2010 - known_2000
known_pct = float(known_delta) / float(known_2000)
self.assertEqual(float(obj['data']['2000']["P1"]['P001001']), known_2000)
self.assertEqual(float(obj['data']['2010']["P1"]['P001001']), known_2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_county(self):\n counties = self.geographies.find({ 'geoid': '15009' })\n\n self.assertEqual(counties.count(), 1)\n\n county = counties[0]\n\n self.assertEqual(county['sumlev'], config.SUMLEV_COUNTY)\n self.assertEqual(county['metadata']['NAME'], 'Maui County')\n s... | [
"0.5652595",
"0.5537479",
"0.55229443",
"0.55086374",
"0.54755175",
"0.53278923",
"0.5322063",
"0.53090984",
"0.5220111",
"0.5202973",
"0.51130104",
"0.51096696",
"0.5104361",
"0.5068363",
"0.5034627",
"0.5024377",
"0.50120425",
"0.50120425",
"0.49283358",
"0.49250224",
"0.49... | 0.6115375 | 0 |
Data import test against known values that Hawaii should have. | def test_state(self):
states = self.geographies.find({ 'geoid': config.SUMLEV_STATE })
self.assertEqual(states.count(), 1)
state = states[0]
self.assertEqual(state['sumlev'], config.SUMLEV_STATE)
self.assertEqual(state['metadata']['NAME'], 'Hawaii')
self.assertEqual(st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_addr_country_good_values(self):\n for input_val, output_val in self.known_values:\n self.line._parse_addr_country(input_val)\n self.assertEqual(output_val, self.line.addr_country)",
"def test_csv_reader_data_contents(process_data):\n data = process_data(file_name_or_type=... | [
"0.5858138",
"0.5747929",
"0.557032",
"0.5442017",
"0.5428693",
"0.54078037",
"0.5387139",
"0.53781325",
"0.53706044",
"0.5339871",
"0.53369933",
"0.5305489",
"0.5301975",
"0.5299098",
"0.5246788",
"0.5234629",
"0.5231527",
"0.52192",
"0.52166295",
"0.5214664",
"0.5204877",
... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.