None:\\n video_file = self.dataset_name + '_' + str(video).zfill(2) + '.mp4'\\n\\n # Create camera directory to store all frames\\n camera = 'camera' + str(video).zfill(2)\\n camera_dir = os.path.join(self.videos_dir, camera)\\n os.mkdir(camera_dir)\\n\\n if self.image_format == 'jpeg':\\n unroll = subprocess.run([\\\"ffmpeg\\\", \\\"-i\\\", os.path.join(self.dataset_dir, video_file), \\\"-qscale:v\\\", \\\"2\\\", \\\"-vf\\\", \\\"scale=1280:720\\\",\\n os.path.join(camera_dir, self.frame_format + \\\".\\\" + self.image_format)])\\n else:\\n unroll = subprocess.run([\\\"ffmpeg\\\", \\\"-i\\\", os.path.join(self.dataset_dir, video_file), \\\"-vf\\\", \\\"scale=1280:720\\\",\\n os.path.join(camera_dir, self.frame_format + \\\".\\\" + self.image_format)])\\n # print(\\\"The exit code was: %d\\\" % unroll.returncode)\",\n \"def process_video(data_info, name, mode, is_training=True):\\r\\n data = Action_Dataset(name, mode, [data_info])\\r\\n if is_training:\\r\\n clip_seq, label_seq = data.next_batch(1, _CLIP_SIZE)\\r\\n else:\\r\\n clip_seq, label_seq = data.next_batch(\\r\\n 1, _EACH_VIDEO_TEST_SIZE+1, shuffle=False, data_augment=False)\\r\\n clip_seq = 2*(clip_seq/255) - 1\\r\\n clip_seq = np.array(clip_seq, dtype='float32')\\r\\n return clip_seq, label_seq\",\n \"def preprocess(config_path, save_dir):\\r\\n \\r\\n cfg = mmcv.Config.fromfile(config_path)\\r\\n cfg.merge_from_dict({\\r\\n 'model.test_cfg.mode': 'slide', \\r\\n 'model.test_cfg.crop_size': (512, 512), \\r\\n 'model.test_cfg.stride': (384, 384)\\r\\n })\\r\\n\\r\\n # build the dataloader\\r\\n dataset = build_dataset(cfg.data.test)\\r\\n data_loader = build_dataloader(\\r\\n dataset,\\r\\n samples_per_gpu=1,\\r\\n workers_per_gpu=cfg.data.workers_per_gpu,\\r\\n dist=False,\\r\\n shuffle=False)\\r\\n\\r\\n # slide window and crop image\\r\\n cnt = 0\\r\\n for data in tqdm.tqdm(data_loader, desc=\\\"Processing\\\"):\\r\\n img = data['img'][0]\\r\\n img_meta = data['img_metas'][0].data[0]\\r\\n cnt += slide_crop(img, img_meta, cfg.model, save_dir)\\r\\n print(f'Preprocess finished, {cnt} binary files generated.')\",\n \"def process_video(input_file, output_file):\\n with open('all-features-rbf-svm.p', 'rb') as svm_fd:\\n clf = pickle.load(svm_fd)\\n with open('all-features-scaler.p', 'rb') as scaler_fd:\\n hog_scaler = pickle.load(scaler_fd)\\n hog_parameters = HogParameters(orientations=18, pixels_per_cell=8, cells_per_block=2)\\n clip = VideoFileClip(input_file)\\n test_clip = clip.fl_image(\\n lambda frame: process_frame(frame, clf=clf, norm_scaler=hog_scaler, hog_parameters=hog_parameters, spatial_size=(16, 16), hist_bins=32))\\n test_clip.write_videofile(output_file, audio=False)\",\n \"def video_encoding(self):\\n self.output_file = outputs_filenames(self.input, self.output_file)\\n\\n if self.resume and (self.temp / 'done.json').exists():\\n set_logging(self.logging, self.temp)\\n else:\\n setup(self.temp, self.resume)\\n set_logging(self.logging, self.temp)\\n print(self.queue)\\n framenums = split_routine(self.input, self.scenes, self.split_method, self.temp, self.min_scene_len, self.queue, self.threshold)\\n\\n if self.extra_split:\\n framenums = extra_splits(input, framenums, self.extra_split)\\n\\n segment(self.input, self.temp, framenums)\\n extract_audio(input, self.temp, self.audio_params)\\n\\n chunk = get_video_queue(self.temp, self.resume)\\n\\n # Make encode queue\\n commands, self.video_params = compose_encoding_queue(chunk, self.temp, self.encoder, self.video_params, self.ffmpeg_pipe, self.passes)\\n log(f'Encoding Queue Composed\\\\n'\\n f'Encoder: {self.encoder.upper()} Queue Size: {len(commands)} Passes: {self.passes}\\\\n'\\n f'Params: {self.video_params}\\\\n\\\\n')\\n\\n self.workers = determine_resources(self.encoder, self.workers)\\n\\n self.encoding_loop(commands)\\n\\n try:\\n concatenate_video(self.temp, self.output_file, keep=self.keep)\\n\\n except Exception as e:\\n _, _, exc_tb = sys.exc_info()\\n print(f'Concatenation failed, FFmpeg error\\\\nAt line: {exc_tb.tb_lineno}\\\\nError:{str(e)}')\\n log(f'Concatenation failed, aborting, error: {e}\\\\n')\\n terminate()\\n\\n if self.vmaf:\\n plot_vmaf(self.input, self.output_file, model=self.vmaf_path)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Tracks adult fish\\\")\\n # add options for argument parser\\n parser.add_argument(\\\"in_path\\\",\\n help=\\\"Path to the video directory.\\\")\\n parser.add_argument(\\\"out_path\\\",\\n help=\\\"Directory for results. Should be empty.\\\")\\n parser.add_argument(\\\"-x\\\", \\\"--keep_temp\\\", action=\\\"store_true\\\",\\n help=\\\"Keep temporary folder after execution.\\\")\\n parser.add_argument(\\\"--visual\\\", action=\\\"store_true\\\",\\n help=\\\"shows a visual representation of the tracking progress.\\\")\\n\\n # parse arguments from command line\\n args = parser.parse_args()\\n # get all file names and directories ready\\n out_dir, temp_dir, video_bases, videos = housekeeping(args)\\n borders = []\\n for i in range(len(videos)):\\n v = videos[i]\\n get_borders(borders, temp_dir, v)\\n\\n for i in range(len(videos)):\\n vbn = video_bases[i]\\n v = videos[i]\\n scaled_video = \\\"scaled_\\\" + vbn + \\\".avi\\\"\\n ffmpeg = Ffmpeg(v, os.path.join(temp_dir, scaled_video))\\n ffmpeg.f = \\\"avi\\\"\\n ffmpeg.vcodec = \\\"libx264rgb\\\"\\n ffmpeg.width = 480\\n ffmpeg.run()\\n\\n for i in range(len(videos)):\\n vbn = video_bases[i]\\n pts = tracker(args, temp_dir, vbn)\\n border = borders[i]\\n tracks_lower, tracks_upper = split_tracks(border, pts)\\n analysis = Analysis(tracks_lower, tracks_upper, px_size=0.06)\\n analysis.analyze(os.path.join(out_dir, 'stats.txt'), vbn, vel=True)\\n\\n if not args.keep_temp:\\n shutil.rmtree(temp_dir)\",\n \"def convert_all(base_path: Path,\\n dest_path: Path,\\n count: int,\\n max_size: int) -> None:\\n os.makedirs(DEST_FOLDER, exist_ok=True)\\n os.makedirs(CONVERTED_VIDEOS_FOLDER, exist_ok=True)\\n\\n processes_count = mp.cpu_count() - 1 or 1\\n with mp.Pool(processes_count) as pool:\\n pool.starmap(\\n convert_file_to_mp4, files(base_path, dest_path, count, max_size)\\n )\",\n \"def imagesFromVideo(vid_path, out_path):\\n if not os.path.exists(vid_path):\\n raise ValueError(\\\"Input video file %s does not exist.\\\" % vid_path)\\n\\n cap = skvideo.io.FFmpegReader(vid_path)\\n frame_nr, _, _, _ = cap.getShape()\\n\\n with tqdm.tqdm(total=frame_nr) as pbar:\\n for i, frame in enumerate(cap.nextFrame()):\\n Image.fromarray(frame).save(out_path + \\\"/\\\" + str(i) + \\\".png\\\")\\n pbar.update()\\n\\n cap.close()\",\n \"def create_movie(name, folder):\\n cmd = [\\\"ffmpeg\\\", \\\"-framerate\\\", \\\"1\\\", \\\"-i\\\", folder + \\\"/pic%04d.png\\\", \\\"-c:v\\\",\\n \\\"libx264\\\", \\\"-r\\\", \\\"30\\\", \\\"-pix_fmt\\\", \\\"yuv420p\\\", name]\\n return subprocess.call(cmd)\",\n \"def save_features(videos, net, transformer):\\n n_features = 4096\\n name = 'baseline'\\n for video in videos:\\n X = np.empty((0, n_features))\\n y = np.empty(0)\\n print '[INFO] processing video %d / %d' % (videos.index(video) + 1, len(videos))\\n for reverse in [False, True]:\\n for flip in [False, True]:\\n if (is_forward(video) and (not reverse)) or ((not is_forward(video)) and reverse):\\n direction = 'f'\\n else:\\n direction = 'b'\\n flows = load_video(video, './data/ArrowDataAll/', mask = lambda x: x[:3] == 'of' + direction, grayscale = True, flip = flip, reverse = reverse)\\n sel = np.asarray([[2*i, 2*i+1] for i in select(flows, 1)]).flatten()\\n flows = np.take(flows, sel, axis = 0)\\n imgs = []\\n for i in range(len(flows)/2):\\n _, ang = cv2.cartToPolar(np.asarray(flows[0], dtype = np.float32), np.asarray(flows[1], dtype = np.float32))\\n image = np.stack([flows[0], flows[1], cv2.normalize(ang,None,0,255,cv2.NORM_MINMAX)], axis = -1)\\n imgs.append(image)\\n imgs = map(lambda x: transformer.preprocess('data', x), imgs)\\n net.blobs['data'].data[...] = imgs\\n net.forward()\\n X = np.append(X, net.blobs['fc7'].data, axis = 0)\\n if direction == 'f':\\n y = np.append(y, 1)\\n else:\\n y = np.append(y, 0)\\n with open(os.path.join('./data/ArrowDataAll', video, 'features-' + name + '.csv'), 'w') as f:\\n np.savetxt(f, X, delimiter = ',', fmt = '%f')\\n with open(os.path.join('./data/ArrowDataAll', video, 'labels-' + name + '.csv'), 'w') as f:\\n np.savetxt(f, y, delimiter = ',', fmt = '%d')\",\n \"def generate_video_from_frames(path_to_frames, title):\\r\\n mean_height = 0\\r\\n mean_width = 0\\r\\n num_of_images = load_one_setting(settings_filename, 'MAX_CYCLES')\\r\\n os.chdir(path_to_frames)\\r\\n '''Loading all frames'''\\r\\n for file in os.listdir('.'):\\r\\n if file.endswith(\\\".jpg\\\") or file.endswith(\\\".jpeg\\\") or file.endswith(\\\"png\\\") or file.endswith(\\\"JPEG\\\"):\\r\\n im = Image.open(file)\\r\\n width, height = im.size\\r\\n mean_width += width\\r\\n mean_height += height\\r\\n\\r\\n mean_width = int(mean_width / num_of_images)\\r\\n mean_height = int(mean_height / num_of_images)\\r\\n\\r\\n for file in os.listdir('.'):\\r\\n if file.endswith(\\\".jpg\\\") or file.endswith(\\\".jpeg\\\") or file.endswith(\\\"png\\\") or file.endswith(\\\"JPEG\\\"):\\r\\n im = Image.open(file)\\r\\n imResize = im.resize((mean_width, mean_height), Image.ANTIALIAS)\\r\\n imResize.save(file, 'JPEG', quality=95)\\r\\n release_video(title)\\r\\n os.chdir(r'../..')\",\n \"def extract_frame(vid_item):\\n full_path, subdir, save_path = vid_item\\n\\n out_full_path = save_path\\n\\n vr = wmli.VideoReader(full_path)\\n print(f\\\"{full_path} fps {vr.fps}.\\\")\\n sys.stdout.flush()\\n # for i in range(len(vr)):\\n all_frames = []\\n try:\\n for i, vr_frame in enumerate(vr):\\n if vr_frame is not None:\\n if img_process_fn is not None:\\n vr_frame = img_process_fn(vr_frame)\\n w, h, _ = np.shape(vr_frame)\\n if args.new_short == 0:\\n if args.new_width == 0 or args.new_height == 0:\\n # Keep original shape\\n out_img = vr_frame\\n else:\\n out_img = mmcv.imresize(vr_frame,\\n (args.new_width,\\n args.new_height))\\n else:\\n if min(h, w) == h:\\n new_h = args.new_short\\n new_w = int((new_h / h) * w)\\n else:\\n new_w = args.new_short\\n new_h = int((new_w / w) * h)\\n out_img = mmcv.imresize(vr_frame, (new_h, new_w))\\n all_frames.append(wmli.encode_img(out_img))\\n else:\\n warnings.warn(\\n 'Length inconsistent!'\\n f'Early stop with {i + 1} out of {len(vr)} frames.')\\n break\\n\\n out_full_path = out_full_path+f\\\"_{len(all_frames)}.np\\\"\\n with open(out_full_path,\\\"wb\\\") as f:\\n pickle.dump(all_frames,f)\\n except Exception as e:\\n print(f\\\"Process {full_path} faild, {e}\\\")\\n\\n print(f'{full_path} -> {out_full_path} done')\\n sys.stdout.flush()\\n return True\",\n \"def encode_movie(dir):\\n root, ext = 'movie', 'avi'\\n for i in itertools.count():\\n path = '.'.join([root + str(i).zfill(5), ext])\\n\\n if not os.path.exists(path):\\n break\\n\\n call(['mencoder', 'mf://' + dir + '/*.png', '-mf', 'fps=10', '-o',\\n path, '-ovc', 'xvid', '-xvidencopts', 'bitrate=3000'])\\n\\n shutil.rmtree(dir)\\n\\n print('movie saved to %s.' % path)\",\n \"def save_video(foldername, songname, songlen, num_steps, output):\\n num_steps_by_len = num_steps / songlen\\n p = subprocess.Popen(['ffmpeg', '-f', 'image2', '-r', str(num_steps_by_len), '-i', '%d.png', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-vf', 'pad=ceil(iw/2)*2:ceil(ih/2)*2', 'movie.mp4'], cwd=foldername)\\n p.wait()\\n\\n p = subprocess.Popen(['ffmpeg', '-i', 'movie.mp4', '-i', '../audio_files/' + songname + '.mp3', '-map', '0:v', '-map', '1:a', '-c', 'copy', output], cwd=foldername)\\n p.wait()\",\n \"def make_video(input_files, width=0, height=0, frame_rate=24, crf=20, output_path=\\\"video.mp4\\\"):\\n if isinstance(input_files, list):\\n from PIL import Image # pylint: disable=C0415\\n\\n with Image.open(input_files[0]) as img:\\n width, height = img.size\\n tmp_dir = \\\"tmp_ffmpeg_dir\\\"\\n os.mkdir(tmp_dir)\\n if width % 2 != 0:\\n print(f\\\"Width ({width}) not divisible by 2\\\")\\n width -= 1\\n if height % 2 != 0:\\n print(f\\\"Height ({width}) not divisible by 2\\\")\\n height -= 1\\n for i, inp in enumerate(input_files):\\n shutil.copy(inp, os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n inputs = f\\\"{tmp_dir}/%06d.png\\\"\\n command = ffmpeg_common_args(frame_rate, inputs, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n for i in range(len(input_files)):\\n os.remove(os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n os.rmdir(tmp_dir)\\n elif isinstance(input_files, str):\\n assert width != 0 and height != 0\\n command = ffmpeg_common_args(frame_rate, input_files, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n else:\\n assert (\\n False\\n ), f'input_files should be list (of files) or str (of file template, e.g., \\\"%04d.png\\\") instead of {type(input_files)}'\",\n \"def create_video(input_file, output_file):\\n input_video = VideoFileClip(input_file)\\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\\n output_video.write_videofile(output_file, audio=False)\",\n \"def run_video(self, video_path):\\n file, ext = os.path.splitext(video_path)\\n video_name = file.split('/')[-1]\\n out_filename = video_name + '_out' + '.avi'\\n\\n cap = cv2.VideoCapture(video_path)\\n wi = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n he = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n print(wi, he)\\n\\n vwriter = cv2.VideoWriter(out_filename, cv2.VideoWriter_fourcc(*'MJPG'), 10, (wi, he))\\n counter = 0\\n fac = 2\\n start = time.time()\\n while True:\\n ret, image = cap.read()\\n\\n if ret:\\n counter += 1\\n\\n ## resize image\\n\\n height, width, channels = image.shape\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n resized_image = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)\\n output = resized_image.copy()\\n\\n ## get segmentation map\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\n seg_map = batch_seg_map[0]\\n\\n ## visualize\\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\\n\\n ## overlay on image\\n alpha = 0.7\\n cv2.addWeighted(seg_image, alpha, output, 1 - alpha, 0, output)\\n\\n output = cv2.resize(output, (wi, he), interpolation=cv2.INTER_AREA)\\n # outimg = 'image_' + str(counter) + '.jpg'\\n # cv2.imwrite(os.path.join(os.getcwd(), 'test_out', outimg),output)\\n vwriter.write(output)\\n else:\\n break\\n\\n end = time.time()\\n print(\\\"Frames and Time Taken: \\\", counter, end - start)\\n cap.release()\\n vwriter.release()\",\n \"def main(input_file_name,output_file_name,video_length):\\n length_of_video = video_length\\n with open(input_file_name + '.pkl', 'rb') as fin:\\n frames = pickle.load(fin)\\n\\n sorted_frames = list(list(x[1]) for x in itertools.groupby(frames, operator.itemgetter(1)))\\n final_dict = dict()\\n for element in sorted_frames:\\n for f in element:\\n name = f[0]\\n video_name = name[name.rindex(\\\"/\\\")+1:name.rindex(\\\"frame\\\")-1]\\n if video_name not in final_dict:\\n final_dict[video_name] = []\\n\\n final_dict[video_name].append(f)\\n\\n new_frames = []\\n\\n for key in final_dict:\\n #elements = takespread(final_dict[key],length_of_video)\\n new_frames.extend(final_dict[key])\\n\\n print(\\\"size:\\\", len(new_frames))\\n predictions = predict_on_frames(new_frames)\\n\\n with open(output_file_name + '.pkl', 'wb') as fout:\\n pickle.dump(predictions, fout)\",\n \"def makeVideo():\\n os.system(\\\"cd video && ffmpeg -r 10 -i img%05d.jpg -vcodec mpeg4 -y caronthehill_clip.mp4\\\")\",\n \"def video_to_frames(input_loc, output_loc, frame_skip):\\n try:\\n os.mkdir(output_loc)\\n except OSError as e:\\n print(e)\\n pass\\n # Log the time\\n time_start = time.time()\\n # Start capturing the feed\\n cap = cv2.VideoCapture(input_loc)\\n # Find the number of frames\\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\\n print (\\\"Number of frames: \\\", video_length)\\n count = 0\\n actual_frames = 0\\n print (\\\"Converting video..\\\\n\\\")\\n # Start converting the video\\n while cap.isOpened():\\n # Extract the frame\\n ret, frame = (None, None)\\n for i in range(frame_skip):\\n ret, frame = cap.read()\\n actual_frames += 1\\n cv2.imwrite(output_loc + \\\"/%#05d.jpg\\\" % (actual_frames), frame)\\n count += 1\\n # Write the results back to output location.\\n # If there are no more frames left\\n if (actual_frames > (video_length) - frame_skip):\\n # Log the time again\\n time_end = time.time()\\n # Release the feed\\n cap.release()\\n # Print stats\\n print (\\\"Done extracting frames.\\\\n%d frames extracted\\\" % count)\\n print (\\\"It took %d seconds forconversion.\\\" % (time_end-time_start))\\n break\",\n \"def outputs(folderName):\\n for i in itertools.count(1):\\n yield io.open('%s/Video_%s.h264' %\\n (folderName,\\n datetime.now().strftime('%Y_%m_%d_%H_%M_%S')),\\n 'wb')\",\n \"def reencode(filepath, loglevel='panic'):\\n try:\\n import ffmpeg\\n except ImportError:\\n logger.error(\\n 'Import Error! Cant import ffmpeg. '\\n 'Annotations operations will be limited. import manually and fix errors')\\n raise\\n if not os.path.isfile(filepath):\\n raise IOError('File doesnt exists: {}'.format(filepath))\\n # re encode video without b frame and as mp4\\n basename, ext = os.path.splitext(filepath)\\n output_filepath = os.path.join(basename, os.path.basename(filepath).replace(ext, '.mp4'))\\n if not os.path.isdir(os.path.dirname(output_filepath)):\\n os.makedirs(os.path.dirname(output_filepath))\\n try:\\n stream = ffmpeg.input(filepath, **{'loglevel': loglevel}).output(output_filepath,\\n **{'x264opts': 'bframes=0',\\n 'f': 'mp4'})\\n ffmpeg.overwrite_output(stream).run()\\n except Exception as e:\\n logger.exception('ffmpeg error in disassemble:')\\n raise\\n\\n output_probe = Videos.get_info(output_filepath)\\n start_time = eval(output_probe['streams'][0]['start_time'])\\n fps = eval(output_probe['streams'][0]['avg_frame_rate'])\\n has_b_frames = output_probe['streams'][0]['has_b_frames']\\n start_frame = fps * start_time\\n if start_time != 0:\\n logger.warning('Video start_time is not 0!')\\n if has_b_frames != 0:\\n logger.warning('Video still has b frames!')\\n return output_filepath\",\n \"def main(video_folder, database_location):\\n \\n # Validate parameters\\n if not path.isdir(video_folder):\\n print 'Invalid video directory path: {}'.format(video_folder)\\n return\\n \\n if not path.exists(database_location):\\n print 'Invalid database location: {}'.format(database_location)\\n return\\n \\n # Connect to database\\n conn = sqlite3.connect(database_location)\\n cursor = conn.cursor()\\n\\n # Get data\\n video_files = listdir(video_folder)\\n video_ids = [f.split('.')[0] for f in video_files if f.endswith('.avi')]\\n \\n # Stats\\n true_positives = 0 # Category 1 classified as category 1\\n false_positives = 0 # Categories 2 or 3 classified as category 1\\n true_negatives = 0 # Categories 2 or 3 classified as categories 2 or 3\\n false_negatives = 0 # Category 1 classified as categories 2 or 3\\n\\n for video_id in video_ids:\\n \\n # Make sure both a .avi and .wav file are available for this id\\n video_location = path.join(video_folder, '{}.avi'.format(video_id))\\n audio_location = path.join(video_folder, '{}.wav'.format(video_id))\\n \\n if not path.exists(video_location) or not path.exists(audio_location):\\n continue\\n \\n # Process video\\n print 'Processing `{}`...'.format(video_id) \\n category_classifier = process_video.process(\\n video_location,\\n audio_location,\\n database_location\\n )\\n\\n # Get actual label\\n metadata = video_id.split('-')\\n db_video_id = ''.join(metadata[:-2])\\n db_start_time_ms = metadata[-2]\\n\\n query = '''\\n SELECT category FROM classifications\\n WHERE video_id = ?\\n AND start_time_ms = ?\\n '''\\n cursor.execute(query, (db_video_id, db_start_time_ms))\\n result = cursor.fetchone()\\n \\n # (Skip if the video isn't labeled)\\n if result is None:\\n print 'No label - skipped'\\n continue\\n \\n category_actual = result[0]\\n\\n # Mark as TP, FP, TN, or FN\\n if category_classifier == 1:\\n if category_actual == 1:\\n true_positives += 1\\n mark = 'TP'\\n else:\\n false_positives += 1\\n mark = 'FP'\\n else:\\n if category_actual == 1:\\n false_negatives += 1\\n mark = 'FN'\\n else:\\n true_negatives += 1\\n mark = 'TN'\\n \\n print 'Classified as category {} ({})'.format(\\n category_classifier,\\n mark\\n )\\n \\n print\\n\\n print\\n\\n print 'RESULTS:'\\n print\\n print 'True Positives (TP) =', true_positives\\n print 'False Positives (FP) =', false_positives\\n print 'True Negatives (TN) =', true_negatives\\n print 'False Negatives (FN) =', false_negatives\\n\\n print\\n print 'Recall [TP / (TP + FN)] =', float(true_positives) / (true_positives + false_negatives)\\n print 'Precision [TP / (TP + FP)] =', float(true_positives) / (true_positives + false_positives)\",\n \"def video_to_frames(video_filename,output_dir):\\n cap = cv2.VideoCapture(video_filename)\\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\\n vid_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n vid_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n vid_fps = int(cap.get(cv2.CAP_PROP_FPS))\\n print(\\\"vid_res=%d x %d, fps=%d\\\\n\\\" % (vid_width, vid_height,vid_fps))\\n crop_width=int(vid_width/128)*128\\n crop_height=int(vid_height/128)*128\\n grab_step=int(vid_fps/2)\\n if cap.isOpened() and video_length > 0:\\n count = 0\\n frame_id=0\\n success, image = cap.read()\\n while success and frame_id <= 9999:\\n if count%grab_step==0:\\n crop_img = image[0:crop_width, 0:crop_height]\\n resized_img = cv2.resize(crop_img, (128, 128)) \\n cv2.imwrite(output_dir+\\\"/frame%05d.jpg\\\" % frame_id, resized_img)\\n frame_id+=1\\n success, image = cap.read()\\n count += 1\\n return 0\",\n \"def process_video(self):\\n if os.path.isfile(self.source):\\n self.cap = cv2.VideoCapture(self.source)\\n else:\\n try:\\n file_name = \\\"input.mp4\\\"\\n self.source = self.source.replace('open', 'uc')\\n print( \\\"\\\\nDownloading video file from drive link to %s\\\\n\\\"%file_name)\\n gdown.download(self.source, file_name, quiet=False)\\n print( \\\"%s downloaded!\\\\n\\\"%file_name )\\n self.cap = cv2.VideoCapture(file_name)\\n except Exception:\\n raise RuntimeError(\\\"Invalid source input, please specify a Google drive link or a downloaded local file as input \\\\n\\\")\\n\\n\\n assert self.cap.isOpened(), \\\"Failed to open %s\\\" % self.source\\n\\n self.w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n self.h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n self.fps = self.cap.get(cv2.CAP_PROP_FPS) \\n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\\n return\",\n \"def take_one_shot(path_to_images, name_image, video_source=\\\"/dev/video0\\\"):\\n subprocess_cmd(\\\"ffmpeg -f video4linux2 -s 1280x720 -i {} -frames 1 ./{}/{} -loglevel error -nostats\\\".format(video_source, path_to_images, name_image))\",\n \"def generate_clips(input_dir, output_dir, duration=20, ext='.mkv'):\\n \\n i = [0,0,0,0]\\n \\n output_dirs = [os.path.join(output_dir, 'goals'),\\n os.path.join(output_dir, 'bg'),\\n os.path.join(output_dir, 'cards'),\\n os.path.join(output_dir, 'subs')]\\n\\n for dir in output_dirs:\\n if not os.path.exists(dir):\\n os.mkdir(dir)\\n print('Made directory ' + dir)\\n \\n \\n for path in input_dir:\\n print(path)\\n \\n with open(os.path.join(path, 'Labels.json')) as f:\\n file = json.load(f)\\n labels = parseLabels(file)\\n \\n # for each item in label, crop a specified length and save to output_dir\\n for timestamp, label in labels:\\n half = timestamp[0]\\n time = timestamp[1]\\n vid_name = os.path.join(path, half + ext)\\n\\n if time - 5 > 0:\\n\\n if label == 'soccer-ball':\\n # collect an instance of a goal\\n clip_video(vid_name, time - 5, duration, i[0], output_dirs[0])\\n i[0] += 1\\n\\n # collect an instance of a non-goal, if it does not overlap with another event\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n elif 'card' in label:\\n # collect an instance of a carding event\\n clip_video(vid_name, time - 4, duration, i[2], output_dirs[2])\\n i[2] += 1\\n\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n\\n elif 'substitution' in label:\\n # collect an instance of a carding event\\n clip_video(vid_name, time - 4, duration, i[3], output_dirs[3])\\n i[3] += 1\\n\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n print('Saved clip from ' + path)\",\n \"def main():\\n # Parameters\\n opt = get_args()\\n\\n assert os.path.exists(opt.path_video), \\\"Video file does not exist\\\"\\n try:\\n os.makedirs(opt.path_images)\\n except Exception:\\n print(\\\"Folder already exists. Overwriting it\\\")\\n pass\\n\\n assert opt.size is None or opt.size is not None and len(opt.size) <= 2, \\\"Make sure the size indicated contains at maximum two numbers [none, max_dimension or width and height]\\\"\\n\\n # Get base path\\n base_path = os.path.join(opt.path_images, opt.basename)\\n\\n # Load video from file\\n try:\\n cap = cv2.VideoCapture(opt.path_video)\\n except Exception as e:\\n print('Video failed to be loaded:', e)\\n sys.exit(0)\\n\\n # Parse video\\n parse_video(cap, base_path, opt.step, opt.size)\\n\\n # Release capture\\n cap.release()\\n cv2.destroyAllWindows()\\n \\n return 0\",\n \"def make_images_from_video(video_name, video_dir, out_dir, limit=None):\\n video_path = f\\\"{video_dir}/{video_name}\\\"\\n video_name = os.path.basename(video_path)\\n vidcap = cv2.VideoCapture(video_path)\\n print(video_path)\\n frame = 0\\n while True:\\n it_worked, img = vidcap.read()\\n if not it_worked:\\n break\\n frame += 1\\n # print(frame)\\n image_path = f\\\"{out_dir}/{video_name}\\\".replace(\\\".mp4\\\", f\\\"_{frame}.png\\\")\\n success = cv2.imwrite(image_path, img)\\n if not success:\\n raise ValueError(\\\"couldn't write image successfully\\\")\\n if limit and frame > limit:\\n print(f\\\"Made maximum: {limit} frames\\\")\\n break\",\n \"def seqIo_frImgs(fName, header=[], aviName=[], Is=[], sDir=[], name='I', ndig=5, f0=0, f1=1e6):\\n \\n if aviName!=[]: #avi movie exists\\n vc = cv2.VideoCapture(aviName)\\n if vc.isOpened(): rval = True\\n else:\\n rval = False\\n print('video not readable')\\n return\\n fps = vc.get(cv2.cv.CV_CAP_PROP_FPS)\\n NUM_FRAMES = int(vc.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))\\n print(NUM_FRAMES)\\n IM_TOP_H = vc.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)\\n IM_TOP_W = vc.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)\\n header['width']=IM_TOP_W\\n header['height']=IM_TOP_H\\n header['fps']=fps\\n\\n sw = seqIo_writer(fName,header)\\n print('creating seq from AVI')\\n # initialize timer\\n timer = pb.ProgressBar(widgets=['Converting ', pb.Percentage(), ' -- ',\\n pb.FormatLabel('Frame %(value)d'), '/',\\n pb.FormatLabel('%(max)d'), ' [', pb.Timer(), '] ',\\n pb.Bar(), ' (', pb.ETA(), ') '], maxval=NUM_FRAMES)\\n for f in range(NUM_FRAMES):\\n rval, im = vc.read()\\n if rval:\\n im= im.astype(np.uint8)\\n sw.addFrame(im)\\n timer.update(f)\\n sw.close()\\n timer.finish()\\n elif Is==[]:\\n assert(os.path.isdir(sDir))\\n sw = seqIo_writer(fName,header)\\n frmstr = '%s/%s%%0%ii.%s' % (sDir,name,ndig,header.ext)\\n for frame in range(f0,f1):\\n f = frmstr % frame\\n if not os.path.isfile(f):break\\n fid = open(f, 'r')\\n if fid<0: sw.close(); assert(False)\\n I = fid.read()\\n fid.close()\\n b = bytearray(I)\\n assert (b[0] == 255 and b[1] == 216 and b[-2] == 255 and b[-1] == 217); # JPG\\n I = np.array(list(b)).astype(np.uint8)\\n sw.addFrame(I,0,0)\\n sw.close()\\n if frame==f0: print('No images found')\\n else:\\n nd = len(Is.shape)\\n if nd==2: nd=3\\n assert(nd<=4)\\n nFrm = Is.shape[nd-1]\\n header['height']=Is.shape[0]\\n header['width']=Is.shape[1]\\n sw =seqIo_writer(fName,header)\\n if nd==3:\\n for f in range(nFrm): sw.addFrame(Is[:,:,f])\\n if nd==4:\\n for f in range(nFrm): sw.addFrame(Is[:,:,:,f])\\n sw.close()\",\n \"def extract_tubelets(dname, gpu=-1, redo=False):\\n d = GetDataset(dname)\\n\\n if gpu >= 0:\\n caffe.set_mode_gpu()\\n caffe.set_device(gpu)\\n\\n model_dir = os.path.join(os.path.dirname(__file__), '../models/ACT-detector/', dname)\\n output_dir = os.path.join(os.path.dirname(__file__), '../results/ACT-detector/', dname)\\n \\n # load the RGB network\\n rgb_proto = os.path.join(model_dir, \\\"deploy_RGB.prototxt\\\")\\n rgb_model = os.path.join(model_dir, \\\"../generated_AVA_iter_118662.caffemodel\\\")\\n net_rgb = caffe.Net(rgb_proto, caffe.TEST, weights=rgb_model)\\n \\n # load the FLOW5 network\\n flo_proto = os.path.join(model_dir, \\\"deploy_FLOW5.prototxt\\\")\\n flo_model = os.path.join(model_dir, \\\"../generated_AVA_iter_59463.caffemodel\\\")\\n net_flo = caffe.Net(flo_proto, caffe.TEST, weights=flo_model)\\n\\n vlist = d.test_vlist()\\n for iv, v in enumerate(vlist):\\n print(\\\"Processing video {:d}/{:d}: {:s}\\\".format( iv+1, len(vlist), v))\\n h, w = d.resolution(v)\\n \\n # network output is normalized between 0,1 ; so we will multiply it by the following array\\n resolution_array = np.array([w,h,w,h]*K, dtype=np.float32)\\n \\n # now process each frame\\n for i in xrange(1, 1 + d.nframes(v) - K + 1):\\n outfile = os.path.join(output_dir, d.frame_format(v,i) + \\\".pkl\\\")\\n \\n # skip if already computed\\n if os.path.isfile(outfile) and not redo:\\n continue\\n \\n # read the frames for the forward\\n kwargs_rgb = {}\\n kwargs_flo = {}\\n for j in xrange(K):\\n cap = cv2.VideoCapture(d.vidfile(v,0))\\n #print(frame)\\n #print(int(cap.get(7)))\\n cap.set(1,i + j - 1)\\n im = cap.read()[1]\\n cap.release()\\n #im = cv2.imread(d.imfile(v, i + j))\\n if im is None:\\n print \\\"Image {:s} does not exist\\\".format(d.imfile(v, i+j))\\n return\\n imscale = cv2.resize(im, (IMGSIZE, IMGSIZE), interpolation=cv2.INTER_LINEAR)\\n kwargs_rgb['data_stream' + str(j)] = np.transpose(imscale-MEAN, (2, 0, 1))[None, :, :, :]\\n imf = [cv2.imread(d.flowfile(v.split(\\\".\\\")[0], min(d.nframes(v), i + j + iflow))) for iflow in xrange(NFLOWS)]\\n if np.any(imf) is None:\\n print \\\"Flow image {:s} does not exist\\\".format(d.flowfile(v, i+j))\\n return\\n imscalef = [cv2.resize(im, (IMGSIZE, IMGSIZE), interpolation=cv2.INTER_LINEAR) for im in imf]\\n timscale = [np.transpose(im-MEAN, (2, 0, 1))[None, :, :, :] for im in imscalef]\\n kwargs_flo['data_stream' + str(j) + 'flow'] = np.concatenate(timscale, axis=1)\\n \\n # compute rgb and flow scores\\n # two forward passes: one for the rgb and one for the flow \\n net_rgb.forward(end=\\\"mbox_conf_flatten\\\", **kwargs_rgb) # forward of rgb with confidence and regression\\n net_flo.forward(end=\\\"mbox_conf_flatten\\\", **kwargs_flo) # forward of flow5 with confidence and regression\\n \\n # compute late fusion of rgb and flow scores (keep regression from rgb)\\n # use net_rgb for standard detections, net_flo for having all boxes\\n scores = 0.5 * (net_rgb.blobs['mbox_conf_flatten'].data + net_flo.blobs['mbox_conf_flatten'].data)\\n net_rgb.blobs['mbox_conf_flatten'].data[...] = scores\\n net_flo.blobs['mbox_conf_flatten'].data[...] = scores\\n net_flo.blobs['mbox_loc'].data[...] = net_rgb.blobs['mbox_loc'].data\\n \\n # two forward passes, only for the last layer \\n # dets is the detections after per-class NMS and thresholding (stardard)\\n # dets_all contains all the scores and regressions for all tubelets \\n dets = net_rgb.forward(start='detection_out')['detection_out'][0, 0, :, 1:]\\n dets_all = net_flo.forward(start='detection_out_full')['detection_out_full'][0, 0, :, 1:]\\n \\n # parse detections with per-class NMS\\n if dets.shape[0] == 1 and np.all(dets == -1):\\n dets = np.empty((0, dets.shape[1]), dtype=np.float32)\\n\\n dets[:, 2:] *= resolution_array # network output was normalized in [0..1]\\n dets[:, 0] -= 1 # label 0 was background, come back to label in [0..nlabels-1]\\n dets[:, 2::2] = np.maximum(0, np.minimum(w, dets[:, 2::2]))\\n dets[:, 3::2] = np.maximum(0, np.minimum(h, dets[:, 3::2]))\\n\\n # parse detections with global NMS at 0.7 (top 300)\\n # coordinates were normalized in [0..1]\\n dets_all[:, 0:4*K] *= resolution_array \\n dets_all[:, 0:4*K:2] = np.maximum(0, np.minimum(w, dets_all[:, 0:4*K:2]))\\n dets_all[:, 1:4*K:2] = np.maximum(0, np.minimum(h, dets_all[:, 1:4*K:2]))\\n idx = nms_tubelets(np.concatenate((dets_all[:, :4*K], np.max(dets_all[:, 4*K+1:], axis=1)[:, None]), axis=1), 0.7, 300)\\n dets_all = dets_all[idx, :]\\n \\n # save file\\n if not os.path.isdir(os.path.dirname(outfile)):\\n os.system('mkdir -p ' + os.path.dirname(outfile))\\n\\n with open(outfile, 'wb') as fid:\\n pickle.dump((dets, dets_all), fid)\",\n \"def prepare_test_frames(self, idx):\\n results = copy.deepcopy(self.video_infos[idx])\\n results['filename_tmpl'] = self.filename_tmpl\\n results['modality'] = self.modality\\n results['start_index'] = self.start_index\\n ann_frame_dir = results['frame_dir'].replace(self.data_prefix,\\n self.anno_prefix)\\n results['seg_map'] = osp.join(\\n ann_frame_dir,\\n self.filename_tmpl.format(0).replace('jpg', 'png'))\\n return self.pipeline(results)\",\n \"def __init__(self, input_file_path, convert_to_bgr=False):\\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\\n print('After INSTANTIATION')\\n self.__yuv_video.start()\",\n \"def preprocessing_pipeline(self):\\n self.__multilabel_processing()\\n self.__split_dataset()\\n self.__save_datasets()\",\n \"def create_video_data_labels(interpolation_frames=CONFIG[\\\"interpolation_frames\\\"],\\n noise_parameters=CONFIG[\\\"noise_frames\\\"], used_keypoints=CONFIG[\\\"used_keypoints\\\"],\\n matrix_size=CONFIG[\\\"matrix_size\\\"], use_dilation=CONFIG[\\\"use_dilation\\\"],\\n kernel_size=CONFIG[\\\"kernel_size\\\"], augmentation_batch=900):\\n xml_folder = os.path.dirname(os.path.realpath(__file__)).split(\\\"src\\\")[0].replace(\\\"\\\\\\\\\\\", \\\"/\\\") + CONFIG[\\n \\\"xml_files_path\\\"]\\n data = []\\n labels = []\\n min_data = 99\\n kernel = np.ones((kernel_size, kernel_size), np.uint8)\\n for label, folder in enumerate(os.listdir(xml_folder)):\\n for file in os.listdir(xml_folder + '/' + folder):\\n file_path = xml_folder + '/' + folder + '/' + file\\n video_data = VideoData(interpolations_frames=interpolation_frames, matrix_size=matrix_size,\\n used_keypoints=used_keypoints, noise_frames=noise_parameters)\\n video_data.load_xml_file(file_path)\\n matrix = video_data.get_matrices()\\n for frame in matrix:\\n\\n # Apply dilation if enabled.\\n if use_dilation:\\n data.append(cv2.dilate(frame, kernel, iterations=1))\\n else:\\n data.append(frame)\\n\\n labels.append(label)\\n if matrix.shape[0] < min_data:\\n min_data = matrix.shape[0]\\n\\n print(folder, \\\"folder done. Label =\\\", label)\\n\\n # Uncomment if a new class with noise white images is desired\\n # white_image = np.ones((matrix_size - CONFIG[\\\"matrix_vertical_crop\\\"], matrix_size))\\n # for i in range(6000):\\n # noise = abs(np.random.normal(0, 0.1, white_image.shape))\\n # new_image = white_image - noise\\n # data.append(np.float32(new_image))\\n # labels.append(4)\\n\\n if augmentation_batch != 0:\\n X_augmented, y_augmented = data_augmentation(data, labels, augmentation_batch)\\n data = np.append(data, X_augmented, axis=0)\\n labels = labels + y_augmented\\n\\n print(\\\"Smallest matrix size is\\\", min_data)\\n return np.array(data), np.array(labels)\",\n \"def adorn_video(self, iterator):\\n return iterator \\\\\\n | select(lambda f: f + (\\n video_to_npy(f[1],\\n # note weird thing here, width doesn't work they appear to be inverted\\n height=self.video_size,\\n squarecrop=self.squarecrop,\\n fps=self.framerate,\\n maxlength=self.max_length,\\n # save a npy replacement\\n outfile=self.get_numpy_filename(f[1]),\\n use_cache=self.use_cache\\n ),))\",\n \"def load_data():\\n # use the load_snippet_pths_test in data writer to get frames and labels\\n print('Loading frames and labels...')\\n dataset_writer = dataset_factory.get_writer(FLAGS.datasetname)\\n writer = dataset_writer()\\n\\n # retrieve list of test videos\\n vid_lst = writer.generate_data_lst_from_split(FLAGS.split_fn)\\n if _DEBUG_:\\n vid_lst = vid_lst[:3]\\n\\n # for each video, collect fnames and labels with downsampling\\n frames, labels = [], []\\n print('Found {:d} videos'.format(len(vid_lst)))\\n for vid in vid_lst:\\n print(' Loading {}...'.format(vid))\\n fname_pths_per_vid, labels_per_vid = writer.load_snippet_pths_test(\\n FLAGS.datadir, [vid], FLAGS.labels_fname, FLAGS.bg_lbl,\\n FLAGS.ext, FLAGS.frameskip)\\n fname_pths_per_vid = [x[0] for x in fname_pths_per_vid]\\n\\n if _DEBUG_:\\n fname_pths_per_vid = fname_pths_per_vid[:200]\\n labels_per_vid = labels_per_vid[:200]\\n\\n frames.append(_load_images(fname_pths_per_vid))\\n labels.append(np.array(labels_per_vid))\\n return frames, labels\",\n \"def preprocess_images():\\n \\n # Set up the lists to collect the images and measurements\\n images = []\\n measurements = []\\n \\n # Set up the path to the data files \\n data_sets_path = 'data'\\n data_sets = [os.path.join(data_sets_path, i) for i\\n in os.listdir(data_sets_path)]\\n \\n # Step through the data folders and collect the images\\n # and the steering angles\\n for data_set in data_sets:\\n lines = []\\n \\n # Open up the csv file of image paths and steering angles\\n with open(os.path.join(data_set,\\n 'driving_log.csv')) as csvfile:\\n reader = csv.reader(csvfile)\\n for line in reader:\\n lines.append(line)\\n for line in lines:\\n source_path = line[0]\\n filename = source_path.split('\\\\\\\\')[-1]\\n current_path = os.path.join(data_set, 'IMG',\\n filename)\\n \\n # Import each image and change it to RGB\\n BGR_image = cv2.imread(current_path)\\n image = cv2.cvtColor(BGR_image, cv2.COLOR_BGR2RGB)\\n rows, cols, depth = image.shape\\n flipped_image = cv2.flip(image, 1)\\n \\n # Create a scaled version of the image\\n scale = [0.9, 1.1]\\n zoomfactor = random.choice(scale)\\n scale_matrix = cv2.getRotationMatrix2D((cols/2, rows/2),\\n 0, zoomfactor)\\n scaled_image = cv2.warpAffine(image, scale_matrix,\\n (cols, rows))\\n\\n # Append the images to the image list\\n images.append(image)\\n images.append(scaled_image)\\n images.append(flipped_image)\\n \\n # Append the steering angle to the measurements list\\n measurement = float(line[3])\\n measurements.append(measurement)\\n measurements.append(measurement)\\n measurements.append(-1*measurement)\\n \\n return images, measurements\",\n \"def B_VER(self, ver_path, dlist): \\n for folder in dlist:\\n dpath = os.path.join(ver_path, folder)\\n #Ensure folder exists\\n assert(os.path.exists(dpath)),\\\"B_VER Error: Folder {folder} cannot be found in {ver_path}\\\".format(folder=folder, ver_path=ver_path)\\n \\n csvpath = os.path.join(dpath, 'data.csv')\\n #Check for data.csv\\n assert(os.path.isfile(csvpath)),\\\"B_VER Error: data.csv could not be found in {dpath}\\\".format(dpath=dpath)\\n\\n #Verify 4 columns in csv\\n df = pd.read_csv(csvpath)\\n assert(len(df.columns) == 4),\\\"B_VER Error: Need four columns in data.csv in {csvpath}\\\".format(csvpath=csvpath)\\n\\n #The number of jpg files in this directory should equal num rows\\n num_jpgs = len(glob.glob1(dpath, \\\"*.jpg\\\"))\\n assert(len(df) == num_jpgs),\\\"B_VER Error: num_jpgs in {dpath} must = num_rows in data.csv\\\".format(dpath=dpath)\\n\\n #Index the first 20 and last 20, and ensure that those images exist\\n for i in range(20):\\n img_name = df.iloc[i, 0]\\n framepath = os.path.join(dpath, img_name)\\n frame = cv2.imread(framepath)\\n assert(os.path.isfile(framepath)), \\\"B_VER Error: frame {framepath} is not a path, but is in the csv\\\".format(framepath=framepath)\\n\\n for i in range(20):\\n img_name = df.iloc[-i, 0]\\n framepath = os.path.join(dpath, img_name)\\n frame = cv2.imread(framepath)\\n assert(os.path.isfile(framepath)), \\\"B_VER Error: frame {framepath} is not a path, but is in the csv\\\".format(framepath=framepath)\",\n \"def bulk_process_images(inputpath, outputpath, extension):\\n\\n for dirpath, dirnames, filenames in os.walk(inputpath):\\n structure = os.path.join(outputpath, dirpath[len(inputpath) + 1:])\\n for file in filenames:\\n if file.endswith(extension):\\n src = os.path.join(dirpath, file)\\n dest = os.path.join(structure, file)\\n img = load_and_preprocess_image(src)\\n cv2.imwrite(dest, img)\",\n \"def preprocessfolder(self):\\n imgs, _ = getFilesAndHdf(str(self.in_directory.text()))\\n self.img_list = sorted(imgs)\\n self.updateImageGroups()\",\n \"def TextureFiles():\\n import shutil\\n\\n # first convert the .psd files to .png\\n\\n FbmDir = glo.outputFolder + '.fbm'\\n\\n for d1, d2, filenames in os.walk(FbmDir):\\n for filename in filenames:\\n \\\"\\\"\\\"filename: vitrin_diffuse.psd\\n \\\"\\\"\\\"\\n # print \\\"TextureFiles():\\\", filename\\n if filename[-4:].upper() == '.PSD':\\n #print \\\" -- FbmDir:\\\" , FbmDir\\n #print \\\" -- in the if clause with filename:\\\" , filename\\n #print \\\" -- glo.outputFolder\\\" , glo.outputFolder\\n # FbmDir = '../fbx/simplelifeembedmedia.fbm'\\n # filename = 'shelves_light.PSD'\\n PsdToPngConverter(FbmDir, filename)\\n\\n # Move only the .png file to the ../png/ directory\\n filename = filename[:-4] + '.png'\\n src = os.path.join(FbmDir, filename)\\n elif filename[0] != '.':\\n src = os.path.join(FbmDir, filename)\\n pass\\n\\n shutil.copy(src, glo.outputFolder)\\n print os.path.join(glo.outputFolder, filename), \\\"\\\\n\\\"\\n sys.stdout.flush()\\n # for d1, d2, files in os.walk(glo.outputFolder):\\n # if not filename in files:\\n # #print \\\"moving: \\\", files, filename, not filename in files\\n # shutil.copy(src, glo.outputFolder)\\n # print os.path.join(glo.outputFolder, filename), \\\"\\\\n\\\"\\n # else:\\n # print \\\"%s/%s already exists. File not moved\\\" % (glo.outputFolder,filename)\",\n \"def video_process(threshold=THRESHOLD, inputpath=INPUTPATH, file=FILE):\\n #create video capture object\\n cap = cv2.VideoCapture(f'{inputpath}{file}')\\n name = file.split('/')[-1].split('.')[0]\\n frame_sqrs_list = []\\n if (cap.isOpened()==False):\\n logging.error('Error opening video stream or file')\\n model = load_model()\\n frame_n = 1\\n print('model loaded')\\n while(cap.isOpened()):\\n #capture frame-by-frame\\n ret, frame = cap.read()\\n if ret == True:\\n squares_list = img_preprocess(frame)\\n frame_n = frame_n+1\\n print(f'enter video file, frame{frame_n}')\\n x_list = []\\n y_list = []\\n for sq in squares_list:\\n predict = predict_hot_pxl(sq.sq, model)\\n if predict > threshold:\\n pred = 1\\n print('ERROR')\\n x_list.append(sq.y)\\n y_list.append(sq.x)\\n # draw square around error in frame:\\n # FIXME: save a square to a list of squares\\n continue\\n else:\\n pred = 0\\n print('no error')\\n # FIXME: draw_sqr(name, frame, frame_n, !!! PASS LIST INSTEAD !!! and rewrite the draw func to draw several squares sq.y, sq.x) \\n sq = sq._replace(pred_float = predict)\\n sq = sq._replace(pred_int = pred)\\n # dict element sq is now obsolete, remove it\\n sq = sq._replace(sq = None)\\n # save single frame with squares marking errors as png to disc:\\n draw_sqr(name, frame, frame_n, x_list, y_list)\\n frame_sqrs_list.append(sq)\\n # Break the loop\\n else:\\n break\\n return name, frame_sqrs_list\",\n \"def load_video_data(self):\\n self.file_videos = [\\n Video.from_file(path, self)\\n for path in self.video_dir.glob('*.json')\\n ]\",\n \"def analyze_video(vidNum_iter, config, pointInds_toUse, pts_spaced, session): # function needed for multiprocessing\\n\\n optic = config['Optic']\\n\\n numVids = session['num_vids']\\n path_vid_allFiles = session['videos']\\n lk_names = [key for key in optic.keys() if 'lk_' in key]\\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\\\\n for k in lk_names}\\n\\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\\n # metadata = vid.get_meta_data()\\n\\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\\n numFrames = int(video.get(\\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\\n\\n frameToSet = 0\\n frame = vid.get_data(\\n frameToSet) # Get a single frame to use as the first 'previous frame' in calculating optic flow\\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n old_frame = new_frame_gray\\n\\n displacements_tmp = np.zeros((pts_spaced.shape[0], 2, np.uint64(numFrames + (numVids * 1000)))) * np.nan\\n\\n print(' ', end='', flush=True)\\n text = \\\"progresser #{}\\\".format(vidNum_iter)\\n print(f'\\\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\\n\\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames, desc=text, position=vidNum_iter)):\\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n ##calculate optical flow\\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n\\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter)\\n if iter_frame == 0:\\n displacements_tmp[:, :, iter_frame] = np.zeros((pts_spaced.shape[0], 2))\\n else:\\n displacements_tmp[:, :, iter_frame] = np.single(np.squeeze((\\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\\n\\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\\n\\n return displacements_tmp\",\n \"def main():\\n nb_processed = 0\\n for dataset_name in DATASETS:\\n print(\\\"-----------------\\\")\\n print(\\\"Dataset: '%s'\\\" % (dataset_name,))\\n print(\\\"-----------------\\\")\\n\\n dataset_dir = os.path.join(WRITE_MAIN_DIR, dataset_name)\\n if not os.path.isdir(dataset_dir):\\n os.makedirs(dataset_dir)\\n\\n dataset = Dataset([os.path.join(READ_MAIN_DIR, dataset_name)])\\n print(\\\"Found %d images total.\\\" % (len(dataset.fps),))\\n\\n errors = []\\n\\n scale_height, scale_width = SCALES[dataset_name]\\n target_aspect_ratio = scale_width / scale_height\\n\\n # iterate over every image in the current dataset,\\n # augment that image N times, add cols/rows until target aspect ratio\\n # is reached, resize it (e.g. 64x64), save it\\n for img_idx, (image_filepath, image) in enumerate(zip(dataset.fps, dataset.get_images())):\\n print(\\\"[%s] Image %d of %d (%.2f%%)...\\\" \\\\\\n % (dataset_name, img_idx+1, len(dataset.fps),\\n 100*(img_idx+1)/len(dataset.fps)))\\n\\n # IOErrors during loading of images result here in a None value\\n if image is None:\\n print(\\\"Error / None\\\")\\n errors.append((\\n image_filepath,\\n \\\"Failed to load image '%s' (idx %d for dataset %s)\\\" \\\\\\n % (image_filepath, img_idx, dataset_name)\\n ))\\n else:\\n # resize too big images to smaller ones before any augmentation\\n # (for performance reasons)\\n height = image.shape[0]\\n width = image.shape[1]\\n aspect_ratio = width / height\\n if width > 1000 or height > 1000:\\n image = misc.imresize(image, (1000, int(1000 * aspect_ratio)))\\n\\n # augment image\\n # converts augmented versions automatically to float32, 0-1\\n augmentations = augment(image, **AUGMENTATIONS[dataset_name])\\n\\n # create list of original image + augmented versions\\n images_aug = [image / 255.0]\\n images_aug.extend(augmentations)\\n\\n # for each augmented version of the images:\\n # resize it to target aspect ratio (e.g. same width and height),\\n # save it\\n for aug_idx, image_aug in enumerate(images_aug):\\n image_aug = to_aspect_ratio_add(image_aug, target_aspect_ratio)\\n filename = \\\"{:0>6}_{:0>3}.jpg\\\".format(img_idx, aug_idx)\\n img_scaled = misc.imresize(image_aug, (scale_height, scale_width))\\n misc.imsave(os.path.join(dataset_dir, filename), img_scaled)\\n\\n nb_processed += 1\\n\\n print(\\\"Processed %d images with %d errors.\\\" % (nb_processed, len(errors)))\\n for (fp, err) in errors:\\n print(\\\"File %s error:\\\" % (fp,))\\n print(err)\\n print(\\\"Finished.\\\")\",\n \"def run_all(movie_name):\\n s = time.time()\\n panorama_generator = sol4.PanoramicVideoGenerator('dump/%s/' % movie_name, movie_name, 2100)\\n panorama_generator.align_images(translation_only=False)\\n panorama_generator.generate_panoramic_images(9)\\n print(' time for %s: %.1f' % (movie_name, time.time() - s))\\n panorama_generator.save_panoramas_to_video()\",\n \"def demo_video(net, im,frame_number,args, output_folder, conf_thresh):\\n \\n #data_dir = '/mnt/nfs/scratch1/souyoungjin/RESULTS_FACE_DETECTIONS/ARUNI/video'+str(args.video_id)\\n #out_dir = '/mnt/nfs/scratch1/ashishsingh/RESULTS_DOG_DETECTIONS/ARUNI/OHEM/'+args.video_folder_name\\n \\n out_dir = join(output_folder, args.video_id)\\n\\n if not os.path.exists(out_dir):\\n os.makedirs(out_dir)\\n\\n\\n timer = Timer()\\n timer.tic()\\n scores, boxes = im_detect(net, im)\\n timer.toc()\\n print ('Detection took {:.3f}s for '\\n '{:d} object proposals').format(timer.total_time, boxes.shape[0])\\n\\n # Visualize detections for each class\\n #CONF_THRESH = 0.80 #check threshold values\\n CONF_THRESH = conf_thresh\\n NMS_THRESH = 0.15 #check threshold values\\n \\n # detection file\\n dets_file_name = os.path.join(out_dir, 'video'+str(args.video_id)+'.txt') \\n fid = open(dets_file_name, 'a+')\\n sys.stdout.write('%s ' % (frame_number))\\n \\n cls_ind = 1\\n cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n cls_scores = scores[:, cls_ind]\\n dets = np.hstack((cls_boxes,cls_scores[:, np.newaxis])).astype(np.float32)\\n keep = nms(dets, NMS_THRESH)\\n dets = dets[keep, :]\\n\\n keep = np.where(dets[:, 4] > CONF_THRESH)\\n dets = dets[keep]\\n \\n dets[:, 2] = dets[:, 2] - dets[:, 0] + 1\\n dets[:, 3] = dets[:, 3] - dets[:, 1] + 1\\n \\n fid.write('FRAME NUMBER: '+ str(frame_number) + '\\\\n')\\n fid.write(str(dets.shape[0]) + '\\\\n')\\n for j in xrange(dets.shape[0]):\\n fid.write('%f %f %f %f %f\\\\n' % (dets[j, 0], dets[j, 1], dets[j, 2], dets[j, 3], dets[j, 4]))\\n\\n print ''\\n fid.close()\\n \\n #for cls_ind, cls in enumerate(CLASSES[1:]):\\n #cls_ind += 1 # because we skipped background\\n #cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]\\n\\n #cls_scores = scores[:, cls_ind]\\n #dets = np.hstack((cls_boxes,cls_scores[:, np.newaxis])).astype(np.float32)\\n #keep = nms(dets, NMS_THRESH)\\n #dets = dets[keep, :]\\n #im=vis_detections_video(im, cls, dets, thresh=CONF_THRESH)\\n #cv2.imwrite(os.path.join('output',str(time.time())+'.jpg'),im)\\n \\n \\n #cv2.imshow('ret',im)\\n #cv2.waitKey(20)\",\n \"def __init__(self,vid_path:str,num_frames:int=None,vid_flow_direction:str='left'):\\n \\n self.num_frames=num_frames\\n if vid_path.split('.')[-1]=='cine' or vid_flow_direction!='left':\\n #This is a cine file or needs to be rotated, convert to mp4\\n print('Converting .cine file to mp4 (lossless)')\\n #detect platform so we can correct file paths for ffmpeg\\n is_win=re.compile('.*[Ww]in.*')\\n if is_win.match(sys.platform):\\n corrected_vid_path='\\\"'+vid_path+'\\\"'\\n else:\\n #Put escape characters in front of spaces in file name\\n corrected_vid_path=[]\\n for c in vid_path:\\n if c==' ':\\n corrected_vid_path.append('\\\\\\\\')\\n corrected_vid_path.append(c)\\n corrected_vid_path=''.join(corrected_vid_path)\\n if vid_flow_direction=='up':\\n rotate='-vf \\\"transpose=2\\\" '\\n elif vid_flow_direction=='left':\\n rotate=''\\n elif vid_flow_direction=='right':\\n rotate='-vf \\\"transpose=2,transpose=2\\\" '\\n else:\\n raise Exception(\\\"vid_flow_direction must be 'up', 'left' or 'right'\\\")\\n if num_frames!=None:\\n frames='-frames:v {0} '.format(num_frames)\\n else:\\n frames=''\\n os_handle,new_file_path=tempfile.mkstemp(suffix='.mp4')\\n #close file, we don't work with it directly\\n os.close(os_handle)\\n ffmpeg_command='ffmpeg -y -i {orig_file} {frames}{rotate}-f mp4 -crf 0 {new_file}'.format(orig_file=corrected_vid_path,rotate=rotate,new_file=new_file_path,frames=frames)\\n print(ffmpeg_command)\\n list(os.popen(ffmpeg_command))\\n self.vid_path=new_file_path\\n self.delete_file=True\\n stats=os.stat(new_file_path)\\n if stats.st_size==0:\\n raise Exception('File conversion failed, check that ffmpeg is on PATH')\\n else:\\n #Not a cine\\n self.vid_path=vid_path\\n self.delete_file=False\",\n \"def preprocess(exam, data_folder, save_path, image_format):\\n for v in ['L-CC', 'L-MLO', 'R-CC', 'R-MLO']:\\n if len(exam[v]) == 0:\\n continue\\n else:\\n for image in exam[v]:\\n image_path = data_folder + '/' + image + '.' + image_format\\n # Extract subdirectories\\n subdirs = \\\"/\\\".join(image.split('/')[:-1])\\n save_dirs = os.path.join(save_path, subdirs)\\n # Extract image id\\n image_id = image.split('/')[-1]\\n # Create save directories\\n os.makedirs(save_dirs, exist_ok=True)\\n png_save_path = os.path.join(save_dirs, image_id + '.png')\\n with Image(filename=image_path, format=image_format) as img:\\n with img.clone() as i:\\n i.auto_level()\\n with i.convert('png') as png_image:\\n png_image.transform(resize='896x1152!')\\n png_image.save(filename=png_save_path)\",\n \"def run(input_video_file, output_video_file):\\n print(\\\"Debut de la transformation du format de la video\\\")\\n #récupération de la vidéo\\n video = cv2.VideoCapture(input_video_file)\\n #fps de la vidéo\\n fps = video.get(cv2.CAP_PROP_FPS)\\n #largeur des images de la vidéo\\n width_video = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))\\n #hauteur des images de la vidéo\\n height_video = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n #nombre d'images dans la vidéo\\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\\n #durée de la vidéo\\n duration = frame_count/fps\\n #nouvelle durée de la vidéo (on arrondi)\\n new_duration = math.floor(duration)\\n #nouveau fps de la vidéo\\n new_fps = float(round(fps))\\n #appliquer le nouveau fps\\n video.set(cv2.CAP_PROP_FPS,new_fps)\\n #appliquer la nouvelle durée\\n print(new_duration)\\n print(new_fps)\\n print(new_duration*new_fps)\\n new_frame_count = new_duration*new_fps\\n video.set(cv2.CAP_PROP_FRAME_COUNT,new_duration*new_fps)\\n #déffinition du format de la vidéo en sortie\\n video_out = cv2.VideoWriter(output_video_file,0x7634706d,new_fps,(width_video,height_video),True)\\n \\n count = 0\\n #ouverture de la vidéo\\n while(video.isOpened()):\\n #lecture image par image\\n ret, frame = video.read()\\n if ret==True:\\n\\n #ecriture de l'image dans la vidéo en sortie\\n video_out.write(frame)\\n count = count + 1\\n \\n if (count > (new_frame_count-1)):\\n # Libérer la vidéo\\n video.release()\\n break\\n else:\\n break\\n\\n print(\\\"fin de la transformation\\\")\\n #fermer les vidéos\\n video.release()\\n video_out.release()\",\n \"def Preprocess_IMDB(path=\\\"datasets/raw/aclImdb/\\\"):\\n output_path = \\\"datasets/preprocessed/IMDB_Data\\\"\\n\\n neg = glob.glob(os.path.join(path, 'test', 'neg', '*'))\\n neg += glob.glob(os.path.join(path, 'train', 'neg', '*'))\\n neg_data = [io.open(fname, 'r', encoding='utf-8').readlines() for fname in neg]\\n neg_data = [sentence[0] for sentence in neg_data]\\n\\n\\n pos = glob.glob(os.path.join(path, 'test', 'pos', '*'))\\n pos += glob.glob(os.path.join(path, 'train', 'pos', '*'))\\n pos_data = [io.open(fname, 'r', encoding='utf-8').readlines() for fname in pos]\\n pos_data = [sentence[0] for sentence in pos_data]\\n\\n labels = compute_labels(pos_data, neg_data)\\n text, labels = shuffle_data(pos_data + neg_data, labels)\\n\\n if not os.path.exists(output_path):\\n os.makedirs(output_path)\\n\\n # split data in 70%/20%/10% train/test/dev split\\n train_len = ((len(text) / 10) * 7) + (len(text) % 10)\\n test_len = (len(text) / 10) * 2\\n dev_len = len(text) / 10\\n\\n trX = text[0:train_len]\\n teX = text[train_len:train_len + test_len]\\n vaX = text[train_len + test_len: train_len + test_len + dev_len]\\n\\n trY = labels[0:train_len]\\n teY = labels[train_len:train_len + test_len]\\n vaY = labels[train_len + test_len: train_len + test_len + dev_len]\\n\\n dat1 = pd.DataFrame({'label': trY})\\n dat2 = pd.DataFrame({'sentence': trX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"train_binary_sent.csv\\\"), encoding='utf-8', index=False)\\n\\n\\n dat1 = pd.DataFrame({'label': teY})\\n dat2 = pd.DataFrame({'sentence': teX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"test_binary_sent.csv\\\"), encoding='utf-8', index=False)\\n\\n dat1 = pd.DataFrame({'label': vaY})\\n dat2 = pd.DataFrame({'sentence': vaX})\\n df = dat1.join(dat2)\\n df.to_csv(os.path.join(output_path, \\\"dev_binary_sent.csv\\\"), encoding='utf-8', index=False)\",\n \"def videoFrames(filename, framerate=1):\\n vid_file = os.path.join(os.path.dirname(os.getcwd()), \\\"Database\\\", \\\"Video\\\", filename)\\n print(vid_file)\\n assert os.path.isfile(vid_file), \\\"Given path is not a valid file\\\"\\n tmpdir = os.path.join(os.getcwd(), \\\"tmp\\\")\\n subprocess.run(\\n [\\n \\\"ffmpeg\\\",\\n \\\"-i\\\",\\n vid_file,\\n \\\"-r\\\",\\n f\\\"{framerate}\\\",\\n os.path.join(tmpdir, \\\"img_%04d.jpg\\\"),\\n ]\\n )\\n return [os.path.join(tmpdir, i) for i in os.listdir(tmpdir) if not i.endswith(\\\".wav\\\")]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69390935","0.6890178","0.66392815","0.66133606","0.66133606","0.65581614","0.6554764","0.651356","0.64366","0.6430591","0.6429932","0.6412027","0.6364831","0.63648057","0.6340141","0.63109636","0.6306809","0.62747556","0.62535834","0.6226402","0.6222001","0.6217131","0.6202541","0.61934507","0.6181919","0.6180442","0.61701983","0.6156406","0.6141857","0.613601","0.6075945","0.605225","0.6040363","0.6017272","0.60147697","0.6009592","0.6006662","0.60041946","0.59844375","0.59765095","0.5936685","0.59347844","0.5930422","0.59277314","0.59232193","0.5915072","0.5912558","0.5887367","0.5869833","0.5861115","0.58525693","0.58504117","0.58362454","0.5834738","0.58289355","0.5820284","0.58046883","0.5799977","0.5780683","0.5773419","0.5769039","0.5766135","0.57536846","0.5752242","0.57516795","0.5744385","0.57382965","0.5711796","0.5688138","0.5687508","0.5681258","0.5680422","0.56605417","0.56558424","0.5644434","0.563297","0.5629452","0.56184036","0.5614029","0.559622","0.55919564","0.5590179","0.55882055","0.55751073","0.55732435","0.55650645","0.5560465","0.5558563","0.5540837","0.5524435","0.55241334","0.5522848","0.5518838","0.5514824","0.5511513","0.5506605","0.5497691","0.54935604","0.5482816","0.5471405"],"string":"[\n \"0.69390935\",\n \"0.6890178\",\n \"0.66392815\",\n \"0.66133606\",\n \"0.66133606\",\n \"0.65581614\",\n \"0.6554764\",\n \"0.651356\",\n \"0.64366\",\n \"0.6430591\",\n \"0.6429932\",\n \"0.6412027\",\n \"0.6364831\",\n \"0.63648057\",\n \"0.6340141\",\n \"0.63109636\",\n \"0.6306809\",\n \"0.62747556\",\n \"0.62535834\",\n \"0.6226402\",\n \"0.6222001\",\n \"0.6217131\",\n \"0.6202541\",\n \"0.61934507\",\n \"0.6181919\",\n \"0.6180442\",\n \"0.61701983\",\n \"0.6156406\",\n \"0.6141857\",\n \"0.613601\",\n \"0.6075945\",\n \"0.605225\",\n \"0.6040363\",\n \"0.6017272\",\n \"0.60147697\",\n \"0.6009592\",\n \"0.6006662\",\n \"0.60041946\",\n \"0.59844375\",\n \"0.59765095\",\n \"0.5936685\",\n \"0.59347844\",\n \"0.5930422\",\n \"0.59277314\",\n \"0.59232193\",\n \"0.5915072\",\n \"0.5912558\",\n \"0.5887367\",\n \"0.5869833\",\n \"0.5861115\",\n \"0.58525693\",\n \"0.58504117\",\n \"0.58362454\",\n \"0.5834738\",\n \"0.58289355\",\n \"0.5820284\",\n \"0.58046883\",\n \"0.5799977\",\n \"0.5780683\",\n \"0.5773419\",\n \"0.5769039\",\n \"0.5766135\",\n \"0.57536846\",\n \"0.5752242\",\n \"0.57516795\",\n \"0.5744385\",\n \"0.57382965\",\n \"0.5711796\",\n \"0.5688138\",\n \"0.5687508\",\n \"0.5681258\",\n \"0.5680422\",\n \"0.56605417\",\n \"0.56558424\",\n \"0.5644434\",\n \"0.563297\",\n \"0.5629452\",\n \"0.56184036\",\n \"0.5614029\",\n \"0.559622\",\n \"0.55919564\",\n \"0.5590179\",\n \"0.55882055\",\n \"0.55751073\",\n \"0.55732435\",\n \"0.55650645\",\n \"0.5560465\",\n \"0.5558563\",\n \"0.5540837\",\n \"0.5524435\",\n \"0.55241334\",\n \"0.5522848\",\n \"0.5518838\",\n \"0.5514824\",\n \"0.5511513\",\n \"0.5506605\",\n \"0.5497691\",\n \"0.54935604\",\n \"0.5482816\",\n \"0.5471405\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6655314"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":93074,"cells":{"query":{"kind":"string","value":"start threads and idle handler (update_ui) for callback dispatching"},"document":{"kind":"string","value":"def start_thread():\n global gIt, gOt, gRunning\n gRunning = True\n gIt = Thread(target = input_thread)\n gIt.start()\n gOt = Thread(target = output_thread)\n gOt.start()"},"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 polling( self, ):\r\n \"\"\"\r\n queue protocol, data = ( action, function, function_args )\r\n action = a string\r\n function = a function\r\n function_args = arguments to function which will be called function( function_args ) This should be a tuple\r\n \"\"\"\r\n\r\n # !! may be phasing out\r\n# if self.request_to_pause:\r\n# self.paused = True\r\n#\r\n# while self.request_to_pause: # think function part not used ??\r\n# time.sleep( .1 )\r\n#\r\n# self.paused = False\r\n\r\n# if self.parameters.start_helper_delay > 0:\r\n# helper_start = True\r\n# else:\r\n# helper_start = False\r\n # two bits here just used once, have a polling0 then swtch over to this\r\n\r\n if self.is_first_gui_loop:\r\n # perhaps a polling method polling0 that then calls polling\r\n # should be moved to gui !! turn back on unless messing up whole app\r\n # print(\"lifting...\")\r\n# self.gui.root.attributes(\"-topmost\", True) # seems to work\r\n# self.gui.root.lift() # did not work\r\n self.is_first_gui_loop = False\r\n# self.gui.root.attributes(\"-topmost\", False) # seems to work\r\n try:\r\n if self.start_helper and ( self.start_helper_after < time.time() ):\r\n # if self.start_helper_after < time.time() :\r\n self.start_helper = False\r\n\r\n msg = f\"We have an start_helper_function setting in the parameter file = {self.parameters.start_helper_function}\"\r\n print( msg )\r\n self.gui.print_info_string( msg )\r\n to_eval = f\"self.ext_processing. {self.parameters.start_helper_function}\"\r\n a_function = eval( to_eval ) # or hava a way to pass eval to other side ??\r\n # a_function() # run in gt of ext_processing module -- not a good idea\r\n # next was to run in the background thread\r\n self.post_to_queue( \"call\", a_function , self.parameters.start_helper_args )\r\n# else:\r\n# print( self.start_helper_after < time.time() )\r\n# print( self.start_helper )\r\n# print( \"\")\r\n if self.gui_recieve_lock.locked():\r\n self.receive()\r\n # self.start_helper_after time to start helper if used\r\n # loop till queue empty\r\n ( action, function, function_args ) = self.rec_from_queue()\r\n while action != \"\":\r\n if action == \"call\":\r\n #print( \"controller making call\" )\r\n sys.stdout.flush()\r\n function( *function_args )\r\n elif action == \"rec\":\r\n self.gui.print_rec_string( function_args[ 0 ] )\r\n elif action == \"send\":\r\n # but where is it actually sent ??\r\n self.gui.print_send_string( function_args[ 0 ] )\r\n elif action == \"info\":\r\n self.gui.print_info_string( function_args[ 0 ] )\r\n\r\n ( action, function, function_args ) = self.rec_from_queue()\r\n\r\n self.task_tick += 1 # for delay in list send\r\n\r\n if self.list_send: # used for ir_processing and motor processing\r\n #self.loggerit( str( self.task_tick % self.parameters.send_array_mod ) )\r\n if ( ( self.task_tick % self.parameters.send_array_mod ) == 0 ): # 5 might be in parms\r\n #---\r\n #print \"send ix_array\", self.send_list_ix\r\n #self.send( \"xxx\\n\" )\r\n self.send( str( self.send_list[ self.send_list_ix ] ) + \"\\n\" )\r\n\r\n self.send_list_ix += 1\r\n if ( self.send_list_ix >= len( self.send_list ) ):\r\n self.list_send = False\r\n\r\n except Exception as ex_arg:\r\n # !! think there is a type of logging that gives traceback info\r\n self.logger.error( \"polling Exception in smart_terminal: \" + str( ex_arg ) )\r\n # ?? need to look at which we catch maybe just rsh\r\n (atype, avalue, atraceback) = sys.exc_info()\r\n a_join = \"\".join( traceback.format_list ( traceback.extract_tb( atraceback ) ) )\r\n self.logger.error( a_join )\r\n\r\n a_ex_record = ExceptionRecord( time.time) # add at end limit self.ex_max\r\n self.exception_records.append( a_ex_record )\r\n if ( len( self.exception_records ) > self.parameters.ex_max ):\r\n msg = \"too many exceptions polling in smart terminal may die\"\r\n print( msg )\r\n self.logger.error( msg )\r\n self.logger.error( \"too many exceptions what to do???\" )\r\n self.polling_fail = True\r\n #raise Exception( \"too many\" )\r\n #self.restart() # may leave return on stack ??\r\n # here we need to set the next task?? lets try, as function may not have returned\r\n # self.task_list.what_next = self.task_list.advance_next\r\n\r\n finally:\r\n if self.polling_fail:\r\n pass\r\n else:\r\n self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # reschedule event\r\n\r\n return","def _StatusUpdateThreadMain(self):\n while self._status_update_active:\n self._UpdateStatus()\n time.sleep(self._status_update_interval)","def mainloop(self, *args, **kwargs):\n if in_idle():\n return\n self.top.mainloop(*args, **kwargs)","def run(self):\n\t\tgtk.gdk.threads_init()\t\t\t# (!) important for multi-threading to work with GTK+\n\t\tself.__update_timer = gobject.timeout_add(250, self.__update, self)\n\t\tself.statusbar1.push(0, \"Ready (for about dialog; right-click to lower right corner).\")\n\t\tgtk.main()","def mainloop(self, *args, **kwargs):\n if in_idle():\n return\n self._top.mainloop(*args, **kwargs)","def _bg_thread_main(self) -> None:\n while not self._done:\n self._run_server_cycle()","def main(self):\n\n updater = Updater(self.token)\n dp = updater.dispatcher\n\n dp.add_handler(MessageHandler(Filters.text, self.__msg_handler))\n dp.add_handler(MessageHandler(Filters.command, self.__msg_handler))\n dp.add_handler(CallbackQueryHandler(callback=self.__clb_handler))\n\n updater.start_polling()\n updater.idle()","def idle():","def event_loop(self) -> None:\n logging.info(\"Initializing default window opacity...\")\n self._set_all_window_opacity_to_default()\n try:\n logging.info(\"Initializing threads...\")\n for producer in self.producers:\n producer.start()\n for producer in self.producers:\n while not producer.ready:\n pass\n self.ready = True\n logging.info(\"Threads initialized, waiting for events...\")\n while self.keep_going:\n self._flash_queued_window()\n except (KeyboardInterrupt, SystemExit):\n logging.warn(\"Interrupt received, shutting down...\")\n self.shutdown()","def _StartStatusUpdateThread(self):\n self._status_update_active = True\n self._status_update_thread = threading.Thread(\n name='Status update', target=self._StatusUpdateThreadMain)\n self._status_update_thread.start()","def __init__(self, update_func):\n QtCore.QThread.__init__(self)\n self._update_func = update_func","def dispatch_loop(self):\n pass","def main(self):\n\n dp = self.dispatcher\n\n dp.add_handler(MessageHandler(Filters.text, self.__msg_handler))\n dp.add_handler(MessageHandler(Filters.command, self.__msg_handler))\n dp.add_handler(MessageHandler(Filters.photo, self.__photo_handler))\n dp.add_handler(MessageHandler(\n Filters.location, self.__location_handler))\n dp.add_handler(CallbackQueryHandler(callback=self.__clb_handler))\n\n self.updater.start_polling()\n self.updater.idle()","def run(self):\n\n while not self.done:\n\n self.event_loop()\n\n self.update()","def run( self ):\r\n \r\n # Execute the per-cycle work specifed by the user\r\n for f in self.updateFuncList:\r\n f() # Please make these lightweight and pertain to UI drawing!\r\n \r\n # Update window\r\n self.rootWin.update_idletasks() # idk , draw or something!\r\n \r\n # Wait remainder of period\r\n elapsed = time.time() * 1000 - self.last\r\n if elapsed < self.stepTime:\r\n sleepTime = int( self.stepTime - elapsed ) \r\n else:\r\n sleepTime = 0\r\n # 4.e. Mark beginning of next loop\r\n self.last = time.time() * 1000 \r\n self.rootWin.after( sleepTime , self.run )","def _gui_thread(self):\n self.setup_gui()\n\n while not self.stop:\n if dpg.is_dearpygui_running():\n data = self.process_data.get()\n self.process_output(*data)\n else:\n self.stop = True\n\n self.detach_from_output()","def main_thread_enter(self):\n ...","def loop(self):\n while True:\n if self.gui_updates:\n self.update_gui()\n\n event, values = self.window.read(100)\n\n if event == \"btn_con_game\":\n Thread(target=self.connect_game, daemon=True).start()\n elif event == \"btn_con_headset\":\n Thread(target=self.connect_headset, daemon=True).start()\n elif event == \"btn_train_model\":\n Thread(target=self.train_model, daemon=True).start()\n elif event == \"btn_finalize\":\n Thread(target=self.finalize, daemon=True).start()\n \n to_update = self.loading.copy()\n for update in to_update:\n self.window.Element(f'{update}_loading').UpdateAnimation('assets/loading.gif')\n\n # End program if user closes window\n if event == sg.WIN_CLOSED:\n break\n\n self.window.close()","def start(self):\n self.__main_window = Tk()\n self.__start_loading_window()","def Start(self):\r\n # Attach a WorkerDispatcher to the current thread\r\n self.m_disp = ttapi.Dispatcher.AttachWorkerDispatcher()\r\n self.m_disp.BeginInvoke(Action(self.Init))\r\n self.m_disp.Run()","def Start(self):\r\n # Attach a WorkerDispatcher to the current thread\r\n self.m_disp = ttapi.Dispatcher.AttachWorkerDispatcher()\r\n self.m_disp.BeginInvoke(Action(self.Init))\r\n self.m_disp.Run()","def _spin_wx(self):\n import wx\n app = wx.GetApp()\n if app is not None and wx.Thread_IsMain():\n evtloop = wx.EventLoop()\n ea = wx.EventLoopActivator(evtloop)\n while evtloop.Pending():\n evtloop.Dispatch()\n app.ProcessIdle()\n del ea","def process_thread(self):","def __loop(self):\n\n self.__update_table()\n self.__update_labels()\n if self.remote_stop:\n self.__stop(\"remote telegram admin\")\n else:\n self.__main_window.after(1000, self.__loop)","def on_run(self):\n wxMediator.on_run(self)\n listener_evt = InterThreadEventWX(self,\n wxEVT_NEW_LISTEN_CONN) \n talker_evt = InterThreadEventWX(self,\n wxEVT_NEW_TALK_CONN) \n server = self.server()\n sys.stderr.write('Starting server threads...\\n')\n sys.stderr.flush()\n server.start_other_threads(listener_evt, talker_evt)","def start_ui(self):\n\t\tself.start_animation()\n\t\tself.app.exec()","def init(self):\n self.dispatcher.start()\n self.replyer.start()","def start(self, callback):\n\n def cb_wrapper(idle_h):\n callback(self)\n\n self._ffi_cb = ffi.callback('void (*)(uv_idle_t *)', cb_wrapper)\n libuv.uv_idle_start(self.handle, self._ffi_cb)","def takeControl(self):\n mainloop()","def takeControl(self):\n mainloop()","def run(self):\n\n self._keep_running.set()\n\n # Create a command window to take user inputs\n # gui_handler = threading.Thread(name=\"CommandWindow\", daemon=True, \\\n # target=self._command_window.mainloop)\n\n # Launch a thread for fetching position data constantly\n # TODO: Making these threads stoppable is too much of a pain!\n position_fetcher = threading.Thread(name=\"PositionFetcher\", daemon=True, \\\n target=self.fetch_position_and_update_frames)\n spike_fetcher = threading.Thread(name=\"SpikeFetcher\", daemon=True, \\\n target=self.fetch_spikes_and_update_frames)\n place_field_fetcher = threading.Thread(name=\"PlaceFieldFetched\", daemon=True, \\\n target=self.fetch_place_fields)\n ripple_frame_fetcher = threading.Thread(name=\"RippleFrameFetcher\", daemon=True, \\\n target=self.fetch_incident_ripple)\n\n position_fetcher.start()\n spike_fetcher.start()\n place_field_fetcher.start()\n ripple_frame_fetcher.start()\n\n # Start the animation for Spike-Position figure, place field figure\n self.initialize_ripple_detection_fig()\n self.initialize_spike_pos_fig()\n self.initialize_place_field_fig()\n plt.show()\n\n # This is a blocking command... After you exit this, everything will end.\n self._command_window.mainloop()\n position_fetcher.join()\n spike_fetcher.join()\n place_field_fetcher.join()\n ripple_frame_fetcher.join()\n logging.info(MODULE_IDENTIFIER + \"Closed GUI and display pipes\")","def create_threads(self):\n # Dictionary with the interface items that will be passed to the functions\n gui_items = {\"VCV_frequency_spb\":self.VCV_frequency_spb,\n \"VCV_volume_spb\":self.VCV_volume_spb,\n \"VCV_pressure_max_spb\":self.VCV_pressure_max_spb,\n \"PCV_frequency_spb\":self.PCV_frequency_spb,\n \"PCV_pressure_spb\":self.PCV_pressure_spb,\n \"PCV_volume_max_spb\":self.PCV_volume_max_spb,\n \"PSV_pressure_spb\":self.PSV_pressure_spb,\n \"PSV_sensitivity_spb\":self.PSV_sensitivity_spb,\n \"al_PEEP_min_spb\":self.al_PEEP_min_spb,\n \"al_apnea_min_spb\":self.al_apnea_min_spb,\n \"al_flow_min_spb\":self.al_flow_min_spb,\n \"al_frequency_min_spb\":self.al_frequency_min_spb,\n \"al_paw_min_spb\":self.al_paw_min_spb,\n \"al_plateau_pressure_min_spb\":self.al_plateau_pressure_min_spb,\n \"al_tidal_volume_min_spb\":self.al_tidal_volume_min_spb,\n \"al_volume_minute_min_spb\":self.al_volume_minute_min_spb,\n \"al_PEEP_max_spb\":self.al_PEEP_max_spb,\n \"al_apnea_max_spb\":self.al_apnea_max_spb,\n \"al_flow_max_spb\":self.al_flow_max_spb,\n \"al_frequency_max_spb\":self.al_frequency_max_spb,\n \"al_paw_max_spb\":self.al_paw_max_spb,\n \"al_plateau_pressure_max_spb\":self.al_plateau_pressure_max_spb,\n \"al_tidal_volume_max_spb\":self.al_tidal_volume_max_spb,\n \"al_volume_minute_max_spb\":self.al_volume_minute_max_spb,\n \"inhale_pause_spb\":self.inhale_pause_spb}\n\n # Sensors thread\n self.worker_sensors = ReadSensors(self.flw_q, self.prs_q)\n self.thread_sensors = QtCore.QThread()\n self.worker_sensors.moveToThread(self.thread_sensors)\n # Passing the arrays to the thread\n # self.worker_sensors.signal_sensors.connect(self.update_sensors)\n self.thread_sensors.started.connect(self.worker_sensors.work)\n self.thread_sensors.start()\n \n # Piston control thread\n # self.worker_piston = ControlPiston(self.piston, gui_items, mode=0)\n self.worker_piston = ControlPiston(gui_items, self.flw_lifo_q, self.prs_lifo_q,\n self.vol_lifo_q, mode=0)\n self.thread_piston = QtCore.QThread()\n self.worker_piston.moveToThread(self.thread_piston)\n # Another way of passing variables to threads\n # This is done again at every loop where flow, pressure and volume are updated\n # This is not thread safe, the correct way to pass data to threads is using queues\n # self.worker_piston.flw_data = self.flw_data\n # self.worker_piston.vol_data = self.vol_data\n # self.worker_piston.prs_data = self.prs_data\n self.worker_piston.signal_cycle_data.connect(self.update_interface)\n self.worker_piston.signal_startup_error.connect(self.error_window.show)\n self.error_window.signal_retry_startup.connect(self.worker_piston.startup)\n self.worker_piston.signal_get_tare.connect(self.set_tare_var)\n self.thread_piston.started.connect(self.worker_piston.startup)\n self.thread_piston.start()\n\n # Buttons control thread\n self.worker_buttons = InterfaceControl()\n self.thread_buttons = QtCore.QThread()\n self.worker_buttons.moveToThread(self.thread_buttons)\n self.worker_buttons.signal_button.connect(self.spinbox_control)\n self.thread_buttons.started.connect(self.worker_buttons.read_queue_state)\n self.thread_buttons.start()\n\n # Buzzer thread\n self.worker_buzzer = BuzBuzzer()\n self.thread_buzzer = QtCore.QThread()\n self.worker_buzzer.moveToThread(self.thread_buzzer)\n # led thread\n self.worker_led = LEDControl()\n self.thread_led = QtCore.QThread()\n self.worker_led.moveToThread(self.thread_led)","def execute(self):\n while(self._running):\n # get all pygame events from queue\n for event in pygame.event.get():\n self.event_handler(event)\n self.update()\n self.render()\n self.cleanup()","def run(self):\n self.ident = threading.current_thread().ident\n self.ready.set()\n self.exec_()","def _init_threads(self):\n\n startTh = Thread(name='InitialStart', target = self._singleUpdate, args=(self.outPs, ))\n self.threads.append(startTh)\n\n sendTh = Thread(name='SteeringListen',target = self._listen_for_steering, args = (self.inPs[0], self.outPs, ))\n self.threads.append(sendTh)","def startSubscribers(self):\n if (self.on_TB1_Viewer.isChecked()):\n self.threadpool = QThreadPool()\n worker = tb1Worker()\n self.threadpool.start(worker)\n \n elif (self.on_TB2_Viewer.isChecked()):\n self.threadpool = QThreadPool()\n worker = tb2Worker()\n self.threadpool.start(worker)\n \n elif (self.on_TB3_Viewer.isChecked()):\n self.threadpool = QThreadPool()\n worker = tb3Worker()\n self.threadpool.start(worker)\n \n elif (self.on_TB4_Viewer.isChecked()):\n self.threadpool = QThreadPool()\n worker = tb4Worker()\n self.threadpool.start(worker)","def run():\n gui = GUI()\n gui.mainloop()","def main_loop(self):\n dt = 0.3\n self.clock.tick(self.fps)\n while not self.done:\n self.event_loop()\n self.update(dt)\n self.render()\n dt = self.clock.tick(self.fps)/1000.0 # create delta time variable to multiply with movement and rotation\n self.display_fps()\n self.health_bar()\n self.enemy_health()\n self.energy_bar()","def create_and_start_threads(self):\r\n self.create_threads()\r\n self.start_threads()","def start(self, actions_to_run=None):\n\n self.__thread = Thread(target = self.__run, args=[actions_to_run])\n self.__thread.start()\n self.__set_state(WorkerState.Idle)","def run(self):\n self.thread = threading.Thread(target=self._main)\n self.thread.start()\n self.running = True","def main_loop(self):\n dt = 0\n self.clock.tick(FPS)\n while not self.done:\n self.event_loop()\n self.update(dt)\n self.render()\n dt = self.clock.tick(FPS) / 1000.0","def __call__(self, event_queue, in_queue, out_queue):\n\n running = True\n self.in_q = in_queue # command received from the main thread\n self.out_q = out_queue # responses, commands to the main thread\n self.ev_q = event_queue # return pending events to the main thread\n shutdown = False\n self.light_state = False # current state of beat light\n\n # send first beat light message\n if self.btic.BeatLight() is True:\n self.out_q.put(\"beaton\")\n else:\n self.out_q.put(\"beatoff\")\n\n # run thread loop\n while running is True:\n if self.die_pending is False:\n self.sendPendingEvents()\n self.processCommands()\n\n \"\"\"\n if self.btic.BeatLightToggle() == True:\n self.out_q.put(\"beat\")\n wx.WakeUpIdle()\n \"\"\"\n\n # display beat light on UI\n light = self.btic.BeatLight()\n if light != self.light_state:\n self.light_state = light\n if light is True:\n self.out_q.put(\"beatoff\")\n else:\n self.out_q.put(\"beaton\")\n wx.WakeUpIdle() \n \n if self.allClear() is True:\n time.sleep(.01)\n #pass\n else:\n # stop the loop/thread when all is cleaned up\n self.sendPendingEvents()\n if self.allClear() is True:\n self.clearBank() \n self.die_pending = False\n running = False\n else:\n time.sleep(.01)\n # pass","def main_loop():\n while len(fake_threads) > 0:\n pulse(0.1)","def _preloop_hook(self) -> None:\n self.selectorloop = SelectorThread(daemon=True)\n self.selectorloop.start()","def startMainLoop(self):\n self.thread.start()\n self.theMainLoop.emit(QtCore.SIGNAL(\"step()\"))\n self.app.exec_()","def main(self, screen: curses.window) -> None:\n curses.curs_set(0)\n curses.mousemask(curses.BUTTON1_RELEASED)\n curses.mouseinterval(0)\n self.initialize_colors()\n self.draw_menu(screen)\n status_bar_thread = threading.Thread(target=self.draw_status_bar_continuously, args=(screen, 0.5))\n status_bar_thread.daemon = True\n status_bar_thread.start()\n\n while True:\n ch = screen.getch()\n if ch == curses.KEY_RESIZE:\n curses.curs_set(0)\n self.draw_menu(screen)\n elif ch == curses.KEY_MOUSE:\n _, mouse_x, mouse_y, _, mouse_state = curses.getmouse()\n if not mouse_state:\n for button in self.buttons:\n if not button.try_click(mouse_y, mouse_x):\n continue\n if button == self.start_button:\n if self.start_button.get_current_option() == \"STOP\":\n self.draw_menu(screen)\n file_format = self.file_format_button.get_current_option().lower()\n try:\n self.comic_results = xkcd_extractor.crawl(self.comic_id_button.text, file_format)\n except ValueError:\n self.start_button.cycle()\n curses.beep()\n else:\n self.comic_results = None\n self.comic_results_index = 0\n elif button == self.next_button:\n self.comic_results_index = (self.comic_results_index + 1) % len(self.comic_results.comics)\n elif button == self.back_button:\n self.comic_results_index = (self.comic_results_index - 1) % len(self.comic_results.comics)\n elif button == self.open_folder_button:\n comic = self.comic_results.comics[self.comic_results_index]\n folder_path = '\\\\'.join(comic.image_path.split('\\\\')[:-1])\n os.startfile(folder_path) # noqa: S606\n self.draw_menu(screen)\n elif ch == ord('q'):\n return\n else:\n if not self.comic_id_button.next_character(ch):\n curses.beep()\n self.draw_menu(screen)","def start(self):\r\n # self._app.console.widget().clear() # clear log window\r\n # reset threads\r\n self._threads = []\r\n self.set_threads()\r\n self.ui_pump.setValue(0)\r\n self.ui_fan.setValue(0)\r\n self._motor_controllers[0].set_device(port=\"COM7\")\r\n self._labjacks[0].activate()\r\n logging.info('Starting acquisition', extra=self.extra)\r\n\r\n self.set_data() # initialize both data frame and plot selection\r\n self._signal = self._signal_selection.currentText()\r\n\r\n self._times = [0.0]\r\n self._timer.start() # start timer\r\n for thread in self._threads: # start remaining threads\r\n thread.start()\r\n self.start_rec()\r\n\r\n self.ui_start.setEnabled(False)\r\n self.ui_time.setEnabled(False)\r\n self.ui_stop.setEnabled(True)","def mainloop(self):\n self.root.mainloop()","def mainloop(self):\n self.root.mainloop()","def call_start_cbs(self):\n try:\n for (cb,args) in self._start_cbs:\n cb(self.userdata, self.get_initial_states(), *args)\n except:\n smach.logerr(\"Could not execute start callback: \"+traceback.format_exc())","def updateGraphics():\n _root.update_idletasks()","def mainloop(self):\n self.master.mainloop()","def main():\n root = tkinter.Tk()\n delegate = ReceiveMessages()\n mqtt_client = com.MqttClient(delegate)\n mqtt_client.connect_to_ev3()\n\n progress_bar = setup_gui(root, mqtt_client)\n delegate.progress_bar = progress_bar\n\n root.mainloop()","def init_ui():\n\t# Use wrapper to set reasonable defaults and reset the terminal on exit\n\t#curses.wrapper(_main_loop)\n\tcurses.wrapper(_init_func)","def main(self,q,controlQueue):\n\n self.dataQueue=q\n\n t1=threading.Thread(target=self.updater,args=(controlQueue,))\n #t2=threading.Thread(target=self.xMotor,args=(controlQueue,))\n #t3=threading.Thread(target=self.yMotor,args=(controlQueue,))\n t1.start()\n #t2.start()\n #t3.start()","def main_loop(self):\n while self.game_manager.game_state != GameState.Quit:\n\n self.handle_events()\n self.handle_ui_response()\n #in menu\n if self.game_manager.game_state == GameState.Menu: \n self.display.clear()\n\n #in game\n elif self.game_manager.game_state == GameState.Running:\n self.game_manager.move_players()\n\n #after game\n elif self.game_manager.game_state == GameState.Finished:\n if self.game_manager.winner == None:\n self.game_manager.player1.decay()\n self.game_manager.player2.decay() \n else:\n self.game_manager.loser.decay()\n self.game_manager.loser.draw()\n\n #perform game manager actions\n self.game_manager.act()\n #do all the rendering stuff\n self.render_scene()\n #control FPS\n self.clock.tick(self.FPS)","def startGTK( ):\n if not INITIALIZED:\n init()\n if LOOP_TRACKER:\n LOOP_TRACKER.increment()","def __init__(self, master, user, song, cdLen, goHold):\n # GUI will be visible window after init\n self.master = master\n\n # get window size\n self.w = self.master.winfo_screenwidth()\n self.h = self.master.winfo_screenheight()\n\n # GUI will be visible after tkinter.Tk()\n # hide the GUI window for now\n self.guiVisible = 1\n self.GUIhide()\n\n # keep track of whether alarm is active or not\n self.shotsFired = 0\n\n # keep track of whether we have flashed hue\n self.flashed = 0\n self.flashed2 = 0\n\n # keep track of seconds into a given track\n self.count = 0\n\n # What song are we going to play??\n self.song = song\n\n # keep track of length (sec) of selected song\n # this will be assigned at alarmActivate()\n self.songLength = 0\n\n # song countdown length\n # this is assigned by init call\n self.cdLen = cdLen\n\n # how long to display \"GO!!\"\n # this is assigned by init call\n self.goHold = goHold\n\n # Create the queue\n self.queue = Queue.Queue()\n\n # Create a lock to access shared resources amongst threads\n self.lock = threading.Lock()\n\n # Set up the GUIPart\n # we pass it the master (root), the queue, the endApplication function, and the hide / show functions\n self.gui = DisplayController(master, self.queue, self.alarmCancel, self.GUIhide, self.GUIshow)\n\n # Set up the Spotify instance\n self.mySpotipy = ASpotipy(user, Private.CLIENT_ID, Private.CLIENT_SECRET, Private.REDIRECT_URI)\n\n # setup hue\n self.myHue = hueControl()\n\n # Set up the thread to do asynchronous I/O\n self.running = 1\n self.thread1 = threading.Thread(target=self.workerThread1)\n self.thread1.start()\n\n self.thread2 = threading.Thread(target=self.workerThread2)\n self.thread2.start()\n\n self.thread3 = threading.Thread(target=self.workerThread3)\n self.thread3.start()\n\n self.thread4 = threading.Thread(target=self.workerThread4)\n self.thread4.start()\n\n # Start the periodic call in the GUI to check if the queue contains\n # anything\n self.periodicCall()","def _dispatch(f = None):\n #first install signal handler\n #this way we can quit the program easily from the command line\n #also, this makes libevent block on the first loop\n #otherwise when there are no events in the beginning, loop will not\n #block and our main dispatch loop would claim 100% CPU time\n def interrupt():\n quit(EXIT_CODE_SIGINT)\n event_interrupt = SignalEvent(SIGINT, interrupt)\n\n #the heartbeat makes sure the main loop below at least\n #makes a cycle every second. otherwise, if there are no pending signals\n #libevent._loop would block indefinitly, causing our loop never to check\n #if it still must be _running...\n event_heartbeat = TimeoutEvent(1.0, None, True)\n\n #as a convenience, user can provide a callable *f* to start a new task\n #lets start it here\n if callable(f):\n Tasklet.new(f)()\n\n global _running\n _running = True\n e = None\n try:\n #this is it, the main dispatch loop...\n #tasklets are scheduled to run by stackless,\n #and if no more are runnable, we wait for IO events to happen\n #that will trigger tasks to become runnable\n #ad infinitum...\n while _running:\n #first let any tasklets run until they have all become blocked on IO\n try:\n while stackless.getruncount() > 1:\n stackless.schedule()\n except TaskletExit:\n pass\n except:\n logging.exception(\"unhandled exception in dispatch schedule\")\n\n #now block on IO till any IO is ready.\n #care has been taken to not callback directly into python\n #from libevent. that would add c-data on the stack which would\n #make stackless need to use hard-switching, which is slow.\n #so we call 'loop' which blocks until something available.\n try:\n event.loop()\n except TaskletExit:\n raise\n except:\n logging.exception(\"unhandled exception in event loop\")\n\n #we iterate over the available triggered events and\n #call the callback which is available as the 'data' object of the event\n #some callbacks may trigger direct action (for instance timeouts, signals)\n #others might resume a waiting task (socket io).\n while event.has_next():\n try:\n e, event_type, fd = event.next()\n e.data(event_type)\n except TaskletExit:\n raise\n except:\n logging.exception(\"unhandled exception in event callback\")\n\n finally:\n del e\n event_interrupt.close()\n del event_interrupt\n event_heartbeat.close()\n del event_heartbeat\n\n if DEBUG_LEAK:\n logging.warn(\"alive objects:\")\n gc.collect()\n _print_objects(gc.get_objects())\n logging.warn('garbage:')\n _print_objects(gc.garbage)\n\n sys._exit(_exitcode)","def loop_run(self):\n super(EventLoop, self).loop_run()\n self.inq = self.cothread.EventQueue()","def start(cls):\n\n cls._set_mode_running()\n TimeDisplay.start_time()\n for callback in cls.start_callback:\n callback()","def __init__(self, width, height):\n # Initialize the tk root window\n self._controller = Controller(self)\n self.root = tk.Tk()\n self.init_dx = width\n self.init_dy = height\n self.root.geometry(\"%dx%d+50+30\"%(self.init_dx, self.init_dy))\n self.root.title(\"RDM user interface version: 1.0\")\n self.root.maxsize(1600, 900)\n self.root.lift()\n self.root.update_idletasks()\n # Assigning fields\n self.universe = tk.IntVar(self.root)\n self.universe.set(1)\n self.universe_list = [1, 2, 3, 4, 5]\n self.cur_uid = None\n self.id_state = tk.IntVar(self.root)\n self.auto_disc = tk.BooleanVar(self.root)\n self.id_state.set(0)\n# self.state = 0\n self._uid_dict = {}\n \n # Call initialing functions\n self._pid_store = PidStore.GetStore()\n self.ola_thread = olathread.OLAThread(self._pid_store)\n self.ola_thread.start()\n self.build_frames()\n self.build_cntrl()\n self._notebook = notebook.RDMNotebook(self.root, self._controller)\n self.discover()\n self.auto_disc.set(False)\n\n print \"currently in thread: %d\"%threading.currentThread().ident\n time.sleep(1)\n print \"back from sleep\"","def mainloop(self):\r\n self.bindHotkeys()\r\n self.root.mainloop()","def mainloop(self):\n\t\tself.root.after(100, self.tkloop)\n\t\tself.root.mainloop()","async def _main(self):\n while True:\n time.sleep(1)","def run(self):\n\n # This is the code executing in the new thread. Simulation of\n # a long process as a simple urllib call\n\n try:\n url = _docsURL % ReplaceCapitals(self.selectedClass)\n fid = urllib.request.urlopen(url)\n\n if six.PY2:\n originalText = fid.read()\n else:\n originalText = fid.read().decode(\"utf-8\")\n text = RemoveHTMLTags(originalText).split(\"\\n\")\n data = FindWindowStyles(text, originalText, self.selectedClass)\n\n if not self.keepRunning:\n return\n\n wx.CallAfter(self.notifyWindow.LoadDocumentation, data)\n except (IOError, urllib.error.HTTPError):\n # Unable to get to the internet\n t, v = sys.exc_info()[:2]\n message = traceback.format_exception_only(t, v)\n wx.CallAfter(self.notifyWindow.StopDownload, message)\n except:\n # Some other strange error...\n t, v = sys.exc_info()[:2]\n message = traceback.format_exception_only(t, v)\n wx.CallAfter(self.notifyWindow.StopDownload, message)","def start(self):\n\n # ioloop.install()\n threading.Thread(target=self.loop.start).start()\n time.sleep(1)","def _make_thread(self):\r\n pass","def start(self):\r\n monitor_thread = Thread(target = self.monitor)\r\n monitor_thread.setDaemon(True)\r\n monitor_thread.start()\r\n\r\n main_thread = Thread(target = self.run)\r\n main_thread.setDaemon(True)\r\n main_thread.start()","def run(self):\n while self._update_func():\n self.update_signal.emit(None)","def run(self):\n while self.running:\n QtCore.QCoreApplication.processEvents()","def cb_gui_test_1( self, ):\r\n print( \"cb_gui_test_1\" )\r\n self.helper_thread.toggle_lock()","def start_threading(self):\n\n # For Demo only commented\n self.progress_label.config(text='Running...')\n # self.progress_label.config(text='Estimating Time Reamining')\n self.prev_prog = progressbar.current\n self.submit_thread = threading.Thread(target=self.run)\n self.start_time = time.time()\n self.submit_thread.daemon = True\n self.submit_thread.start()\n self.after(1000, self.check_thread)","def start(self):\n if self.__started:\n return\n\n self.__started = True\n GLib.timeout_add(GtkMainLoop.DEADLINE_GLIB, self.__ioloop_run)\n self.__gi_loop.run()","def state_processing_do(cfg, app, win, events):","def start(self):\n #Starting the thread able to handle the administrator request\n t2 = threading.Thread(target=self.handleServer)\n t2.start()\n self.ActiveThreads.append(t2)\n #Listen continously\n while True:\n self.server.listen(50)\n self.Log.log(\"Waiting for connections...\")\n #Obtaining the parameters like the socket and the address/port of the incoming connection\n (conn, (ip,port)) = self.server.accept()\n #Creating a new thread able to handle the new connection with the client\n newClient = ClientHandler(conn,ip,port,self.DB,self.Users,self.Log,self.XML);\n #Starting the new thread\n newClient.start()\n #Appending the thread to the list of active threads\n self.ActiveThreads.append(newClient)","def main(self):\n self.root.mainloop()","def temp_mainloop(self, cycles_to_respond=1000):\n\n if self.com_port_select.count() > 0:\n report = \"Begin measuring\"\n self.go_button.setEnabled(False) # don't allow to create new threads\n self.state_temp_loop(True)\n self.append_msg_box(report)\n\n while self.temp_loop_actiator:\n for num in range(self.com_port_select.count()):\n # self.MainWindow_exec_thread(lambda: self.sample_devices(cycles_to_respond, num))\n self.sample_devices(cycles_to_respond, num)\n self.temp_repr.plot_tc_temp(self.temp_log)\n timeo = float(self.timeout.text()) # timeout\n sleep(timeo)\n # -------- record data once in msg box --------\n\n self.go_button.setEnabled(True)\n self.led_light.setPixmap(QtGui.QPixmap(img[\"red_led\"]))\n else:\n self.append_msg_box(\"No device is connected\")","def __init__(self ):\r\n # ------------------- basic setup --------------------------------\r\n AppGlobal.controller = self\r\n msg = \"\"\r\n msg = ( f\"{msg}\\n=============== starting SmartTerminal ===============\" )\r\n msg = ( f\"{msg}\\n\" )\r\n msg = ( f\"{msg}\\n -----> prints may be sent to log file !\" )\r\n msg = ( f\"{msg}\\n\" )\r\n AppGlobal.logger.log( 55, msg )\r\n\r\n # AppGlobal.logger.info( \"no logger\" )\r\n # AppGlobal.logger.debug( \"no logger 2\" )\r\n\r\n self.app_name = \"SmartTerminal\"\r\n self.version = \"Ver6: 2020 02 22.0\"\r\n self.gui = None # build later\r\n self.no_restarts = -1 # start is restart 0\r\n self.no_helper_restarts = 0\r\n\r\n # ----------- for second thread -------\r\n #self.helper_thread_manager = None\r\n self.queue_to_gui = None\r\n self.queue_from_gui = None\r\n self.gui_recieve_lock = threading.Lock() # when locked the gui will process receive, acquired released in helper\r\n # how different from just a variable set?\r\n self.restart( )","def server_init(self):\n if not self.web_interface_thread.isAlive():\n # spawn the web interface.\n self.web_interface_thread.start()","def run_main_loop():\n mainloop = GObject.MainLoop()","def start(self):\n self.thread.start()","def initThread(self):\n thread1 = threading.Thread(target=self.processData)\n self.info(\"starting cod7http thread\")\n thread1.start()\n self.httpthreadinst = thread1","def on_data(self, status):\r\n self.counter += 1\r\n start_new_thread(self.arduPusherClick,(1,))\r\n # start new thread to print out the text\r\n start_new_thread(self.printerTweet, (status,))\r\n return","def update_ui(self):\n # main data\n self.lAcc.setText(self.settings.ACCOUNT)\n # self.lExcessLiquidity.setText(str(self.ibkrworker.app.excessLiquidity))\n # self.lSma.setText(str(self.ibkrworker.app.sMa))\n if hasattr(self.ibkrworker.app, 'smaWithSafety'):\n self.lSma.setText(str(round(self.ibkrworker.app.smaWithSafety, 1)))\n else:\n self.lSma.setText(str(round(self.ibkrworker.app.sMa, 1)))\n self.lMarketValue.setText(str(self.ibkrworker.app.netLiquidation))\n self.lblAvailTrades.setText(str(self.ibkrworker.app.tradesRemaining))\n self.lcdPNL.display(self.ibkrworker.app.dailyPnl)\n if self.ibkrworker.app.dailyPnl > 0:\n palette = self.lcdPNL.palette()\n palette.setColor(palette.WindowText, QtGui.QColor(51, 153, 51))\n self.lcdPNL.setPalette(palette)\n elif self.ibkrworker.app.dailyPnl < 0:\n palette = self.lcdPNL.palette()\n palette.setColor(palette.WindowText, QtGui.QColor(255, 0, 0))\n self.lcdPNL.setPalette(palette)\n\n total_positions_value = 0\n for p in self.ibkrworker.app.openPositions.values():\n if hasattr(p, 'Value'):\n total_positions_value += p[\"Value\"]\n self.lPositionsTotalValue.setText(str(round(total_positions_value, 1)))\n\n self.update_open_positions()\n self.update_live_candidates()\n self.update_open_orders()\n\n # everything disabled for safety - is now enabled\n self.chbxProcess.setEnabled(True)\n self.btnSettings.setEnabled(True)\n\n self.update_session_state()\n\n if not self.uiTimer.isActive():\n self.update_console(\"UI resumed.\")\n self.uiTimer.start(int(self.settings.INTERVALUI) * 1000) # reset the ui timer","def run(self):\n run=0\n wx.CallAfter(Publisher().sendMessage, \"update\", \"\")\n time.sleep(10)\n while (run==0):\n wx.CallAfter(Publisher().sendMessage, \"updatebuttons\", \"\")\n time.sleep(10)","def run(self):\n\t\t\n\t\twhile self.update():\n\t\t\tpass","def run_in_background(self):\n threading.Thread(target=self._run_loop).start()","def _main_loop(self):\n while not rospy.is_shutdown():\n # Check for reconfiguration data\n if self._transfer_reconfigure_data is not None:\n # Copy reconfigure data from shared memory\n with self._transfer_reconfigure_data_mutex:\n reconfigure_data = deepcopy(self._transfer_reconfigure_data)\n self._transfer_reconfigure_data = None\n # Run vision reconfiguration\n self._configure_vision(*reconfigure_data)\n # Check for new image\n elif self._transfer_image_msg is not None:\n # Copy image from shared memory\n with self._transfer_image_msg_mutex:\n image_msg = self._transfer_image_msg\n self._transfer_image_msg = None\n # Run the vision pipeline\n self._handle_image(image_msg)\n # Now the first image has been processed\n self._first_image_callback = False\n else:\n try:\n self._rate.sleep()\n except rospy.exceptions.ROSTimeMovedBackwardsException:\n pass","def run_main(self):\n self.addSensors()\n \n while True:\n # Leemos los sensores\n self.readSensors()\n \n # Extraemos la información a partir de los datos\n self.processData()\n \n # Actualizamos la máquina de estados a partir de la información recibida por los sensores \n self.updateFiniteStateMachine()\n \n # Calculamos las acciones que tenemos que aplicar a los distintos motores, en función del\n # estado y las lecturas de los sensores\n self.controller()\n \n # Pasamos a motores las acciones calculadas\n self.execute()\n\n # Publicamos info importante para el debug\n self.refreshUserInterface()\n \n print(self.name + \": --------------------------\")\n time.sleep(2) #!!!!!!!!!!!!!!!! ELIMINAR DELAY !!!!!!!!!!!!!!!!# ","def background(self):\n self.thread = threading.Thread(target=self.run)\n self.thread.setDaemon(True)\n self.thread.start()","def start(self):\n if not self.thread:\n self.thread = WndUtils.run_thread(None, self.save_data_thread, ())","def __init__(self):\n\n self._system = None\n self._running_thread = None\n self._running_task = None\n\n self._root = tk.Tk(className='Quake AI')\n self._root.configure(background='white')\n self._logo = tk.PhotoImage(file='./resources/logo.png')\n logo_frame = tk.Frame(self._root, bg='white')\n tk.Label(logo_frame, image=self._logo, bd=0).pack()\n logo_frame.pack()\n\n # Start frame\n self._start_frame = tk.Frame(self._root, bg='white')\n\n self._config_path = tk.StringVar()\n\n tk.Label(self._start_frame, text='Quake AI needs config to startup the system. Either choose an\\n '\n 'existing configuration file or provide a file path and a default one\\n '\n 'will be generated.',\n bg='white', font=('Helvetica', 10)).pack(fill='x')\n\n tk.Button(self._start_frame, text=\"Choose config\", font=('Helvetica', 10),\n command=self._startup_system).pack(pady=10)\n self._start_frame.pack(side=tk.BOTTOM)\n\n # Main frame\n self._main_frame = tk.Frame(self._root, bg='white')\n\n self._status_text = tk.StringVar(self._main_frame)\n self._status_text.set('Idle')\n tk.Label(self._main_frame, textvariable=self._status_text, font=('Helvetica', 16, 'bold'), bg='white',\n relief=tk.SUNKEN).pack(pady=10)\n\n trigger_training = tk.LabelFrame(self._main_frame, text=\"Triggerbot Training\", font=('Helvetica', 10), bg='white')\n tk.Button(trigger_training, text=\"Capture Images for Triggerbot\", font=('Helvetica', 10),\n command=self._run_trigger_capture_task).pack(pady=10)\n tk.Button(trigger_training, text=\"Start Training for Triggerbot\", font=('Helvetica', 10),\n command=self._run_trigger_training_task).pack(pady=10)\n trigger_training.pack(ipadx=110)\n\n triggerbot = tk.LabelFrame(self._main_frame, text=\"Triggerbot\", font=('Helvetica', 10), bg='white')\n tk.Button(triggerbot, text=\"Start Triggerbot\", font=('Helvetica', 10),\n command=self._run_trigger_inference_task).pack(pady=10)\n triggerbot.pack(ipadx=150)\n\n aimbot_training = tk.LabelFrame(self._main_frame, text=\"Aimbot Training\", font=('Helvetica', 10), bg='white')\n tk.Button(aimbot_training, text=\"Capture Images for Aimbot\", font=('Helvetica', 10),\n command=self._run_aimbot_capture_task).pack(pady=10)\n tk.Button(aimbot_training, text=\"Annotate Images for Aimbot\", font=('Helvetica', 10),\n command=self._run_aimbot_annotation_task).pack(pady=10)\n tk.Button(aimbot_training, text=\"Train Aimbot\", font=('Helvetica', 10),\n command=self._run_aimbot_training_task).pack(pady=10)\n aimbot_training.pack(ipadx=115)\n\n aimbot = tk.LabelFrame(self._main_frame, text=\"Aimbot\", font=('Helvetica', 10), bg='white')\n tk.Button(aimbot, text=\"Start Aimbot\", font=('Helvetica', 10),\n command=self._run_aimbot_inference_task).pack(pady=10)\n aimbot.pack(ipadx=159)\n\n tk.Button(self._main_frame, text=\"Stop Current Task\", font=('Helvetica', 10),\n command=self._stop_current_task).pack(pady=10)\n\n # Mixing win32gui and tkinter leads to crashes on exit --> prevent this by hard shutdown via os\n self._root.protocol(\"WM_DELETE_WINDOW\", self._on_closing)\n\n self._root.mainloop()","def _start_io_event_loop(self):\r\n self._event_loop_started = threading.Lock()\r\n self._event_loop_started.acquire()\r\n threading.Thread(None, self._io_event_loop_thread).start()\r\n self._event_loop_started.acquire()","def run(self):\n self.loop.spawn_callback(self.main)\n self.loop.start()\n if self.exc_info:\n six.reraise(*self.exc_info)","def start(self):\n if not self._is_running:\n self._pos_thread = Timer(self.draw_intvl, self._run)\n self._pos_thread.start()\n self._is_running = True","def launchFunc():\n th = threading.Thread(target=progressScreen)\n th.start()","def run(self):\n self._start_servers()\n monitor = KodiMonitor(self.nx_common, self.nx_common.log)\n while not monitor.abortRequested():\n monitor.update_playback_progress()\n try:\n if self.library_update_scheduled() and self._is_idle():\n self.update_library()\n except RuntimeError as exc:\n self.nx_common.log(\n 'RuntimeError: {}'.format(exc), xbmc.LOGERROR)\n if monitor.waitForAbort(5):\n break\n self._shutdown()","def run(self):\n self.window.mainloop()","def start(self):\n self.open()\n #t = Thread(target=self._cache_update, args=())\n #t.daemon = True\n #t.start()"],"string":"[\n \"def polling( self, ):\\r\\n \\\"\\\"\\\"\\r\\n queue protocol, data = ( action, function, function_args )\\r\\n action = a string\\r\\n function = a function\\r\\n function_args = arguments to function which will be called function( function_args ) This should be a tuple\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # !! may be phasing out\\r\\n# if self.request_to_pause:\\r\\n# self.paused = True\\r\\n#\\r\\n# while self.request_to_pause: # think function part not used ??\\r\\n# time.sleep( .1 )\\r\\n#\\r\\n# self.paused = False\\r\\n\\r\\n# if self.parameters.start_helper_delay > 0:\\r\\n# helper_start = True\\r\\n# else:\\r\\n# helper_start = False\\r\\n # two bits here just used once, have a polling0 then swtch over to this\\r\\n\\r\\n if self.is_first_gui_loop:\\r\\n # perhaps a polling method polling0 that then calls polling\\r\\n # should be moved to gui !! turn back on unless messing up whole app\\r\\n # print(\\\"lifting...\\\")\\r\\n# self.gui.root.attributes(\\\"-topmost\\\", True) # seems to work\\r\\n# self.gui.root.lift() # did not work\\r\\n self.is_first_gui_loop = False\\r\\n# self.gui.root.attributes(\\\"-topmost\\\", False) # seems to work\\r\\n try:\\r\\n if self.start_helper and ( self.start_helper_after < time.time() ):\\r\\n # if self.start_helper_after < time.time() :\\r\\n self.start_helper = False\\r\\n\\r\\n msg = f\\\"We have an start_helper_function setting in the parameter file = {self.parameters.start_helper_function}\\\"\\r\\n print( msg )\\r\\n self.gui.print_info_string( msg )\\r\\n to_eval = f\\\"self.ext_processing. {self.parameters.start_helper_function}\\\"\\r\\n a_function = eval( to_eval ) # or hava a way to pass eval to other side ??\\r\\n # a_function() # run in gt of ext_processing module -- not a good idea\\r\\n # next was to run in the background thread\\r\\n self.post_to_queue( \\\"call\\\", a_function , self.parameters.start_helper_args )\\r\\n# else:\\r\\n# print( self.start_helper_after < time.time() )\\r\\n# print( self.start_helper )\\r\\n# print( \\\"\\\")\\r\\n if self.gui_recieve_lock.locked():\\r\\n self.receive()\\r\\n # self.start_helper_after time to start helper if used\\r\\n # loop till queue empty\\r\\n ( action, function, function_args ) = self.rec_from_queue()\\r\\n while action != \\\"\\\":\\r\\n if action == \\\"call\\\":\\r\\n #print( \\\"controller making call\\\" )\\r\\n sys.stdout.flush()\\r\\n function( *function_args )\\r\\n elif action == \\\"rec\\\":\\r\\n self.gui.print_rec_string( function_args[ 0 ] )\\r\\n elif action == \\\"send\\\":\\r\\n # but where is it actually sent ??\\r\\n self.gui.print_send_string( function_args[ 0 ] )\\r\\n elif action == \\\"info\\\":\\r\\n self.gui.print_info_string( function_args[ 0 ] )\\r\\n\\r\\n ( action, function, function_args ) = self.rec_from_queue()\\r\\n\\r\\n self.task_tick += 1 # for delay in list send\\r\\n\\r\\n if self.list_send: # used for ir_processing and motor processing\\r\\n #self.loggerit( str( self.task_tick % self.parameters.send_array_mod ) )\\r\\n if ( ( self.task_tick % self.parameters.send_array_mod ) == 0 ): # 5 might be in parms\\r\\n #---\\r\\n #print \\\"send ix_array\\\", self.send_list_ix\\r\\n #self.send( \\\"xxx\\\\n\\\" )\\r\\n self.send( str( self.send_list[ self.send_list_ix ] ) + \\\"\\\\n\\\" )\\r\\n\\r\\n self.send_list_ix += 1\\r\\n if ( self.send_list_ix >= len( self.send_list ) ):\\r\\n self.list_send = False\\r\\n\\r\\n except Exception as ex_arg:\\r\\n # !! think there is a type of logging that gives traceback info\\r\\n self.logger.error( \\\"polling Exception in smart_terminal: \\\" + str( ex_arg ) )\\r\\n # ?? need to look at which we catch maybe just rsh\\r\\n (atype, avalue, atraceback) = sys.exc_info()\\r\\n a_join = \\\"\\\".join( traceback.format_list ( traceback.extract_tb( atraceback ) ) )\\r\\n self.logger.error( a_join )\\r\\n\\r\\n a_ex_record = ExceptionRecord( time.time) # add at end limit self.ex_max\\r\\n self.exception_records.append( a_ex_record )\\r\\n if ( len( self.exception_records ) > self.parameters.ex_max ):\\r\\n msg = \\\"too many exceptions polling in smart terminal may die\\\"\\r\\n print( msg )\\r\\n self.logger.error( msg )\\r\\n self.logger.error( \\\"too many exceptions what to do???\\\" )\\r\\n self.polling_fail = True\\r\\n #raise Exception( \\\"too many\\\" )\\r\\n #self.restart() # may leave return on stack ??\\r\\n # here we need to set the next task?? lets try, as function may not have returned\\r\\n # self.task_list.what_next = self.task_list.advance_next\\r\\n\\r\\n finally:\\r\\n if self.polling_fail:\\r\\n pass\\r\\n else:\\r\\n self.gui.root.after( self.parameters.gt_delta_t, self.polling ) # reschedule event\\r\\n\\r\\n return\",\n \"def _StatusUpdateThreadMain(self):\\n while self._status_update_active:\\n self._UpdateStatus()\\n time.sleep(self._status_update_interval)\",\n \"def mainloop(self, *args, **kwargs):\\n if in_idle():\\n return\\n self.top.mainloop(*args, **kwargs)\",\n \"def run(self):\\n\\t\\tgtk.gdk.threads_init()\\t\\t\\t# (!) important for multi-threading to work with GTK+\\n\\t\\tself.__update_timer = gobject.timeout_add(250, self.__update, self)\\n\\t\\tself.statusbar1.push(0, \\\"Ready (for about dialog; right-click to lower right corner).\\\")\\n\\t\\tgtk.main()\",\n \"def mainloop(self, *args, **kwargs):\\n if in_idle():\\n return\\n self._top.mainloop(*args, **kwargs)\",\n \"def _bg_thread_main(self) -> None:\\n while not self._done:\\n self._run_server_cycle()\",\n \"def main(self):\\n\\n updater = Updater(self.token)\\n dp = updater.dispatcher\\n\\n dp.add_handler(MessageHandler(Filters.text, self.__msg_handler))\\n dp.add_handler(MessageHandler(Filters.command, self.__msg_handler))\\n dp.add_handler(CallbackQueryHandler(callback=self.__clb_handler))\\n\\n updater.start_polling()\\n updater.idle()\",\n \"def idle():\",\n \"def event_loop(self) -> None:\\n logging.info(\\\"Initializing default window opacity...\\\")\\n self._set_all_window_opacity_to_default()\\n try:\\n logging.info(\\\"Initializing threads...\\\")\\n for producer in self.producers:\\n producer.start()\\n for producer in self.producers:\\n while not producer.ready:\\n pass\\n self.ready = True\\n logging.info(\\\"Threads initialized, waiting for events...\\\")\\n while self.keep_going:\\n self._flash_queued_window()\\n except (KeyboardInterrupt, SystemExit):\\n logging.warn(\\\"Interrupt received, shutting down...\\\")\\n self.shutdown()\",\n \"def _StartStatusUpdateThread(self):\\n self._status_update_active = True\\n self._status_update_thread = threading.Thread(\\n name='Status update', target=self._StatusUpdateThreadMain)\\n self._status_update_thread.start()\",\n \"def __init__(self, update_func):\\n QtCore.QThread.__init__(self)\\n self._update_func = update_func\",\n \"def dispatch_loop(self):\\n pass\",\n \"def main(self):\\n\\n dp = self.dispatcher\\n\\n dp.add_handler(MessageHandler(Filters.text, self.__msg_handler))\\n dp.add_handler(MessageHandler(Filters.command, self.__msg_handler))\\n dp.add_handler(MessageHandler(Filters.photo, self.__photo_handler))\\n dp.add_handler(MessageHandler(\\n Filters.location, self.__location_handler))\\n dp.add_handler(CallbackQueryHandler(callback=self.__clb_handler))\\n\\n self.updater.start_polling()\\n self.updater.idle()\",\n \"def run(self):\\n\\n while not self.done:\\n\\n self.event_loop()\\n\\n self.update()\",\n \"def run( self ):\\r\\n \\r\\n # Execute the per-cycle work specifed by the user\\r\\n for f in self.updateFuncList:\\r\\n f() # Please make these lightweight and pertain to UI drawing!\\r\\n \\r\\n # Update window\\r\\n self.rootWin.update_idletasks() # idk , draw or something!\\r\\n \\r\\n # Wait remainder of period\\r\\n elapsed = time.time() * 1000 - self.last\\r\\n if elapsed < self.stepTime:\\r\\n sleepTime = int( self.stepTime - elapsed ) \\r\\n else:\\r\\n sleepTime = 0\\r\\n # 4.e. Mark beginning of next loop\\r\\n self.last = time.time() * 1000 \\r\\n self.rootWin.after( sleepTime , self.run )\",\n \"def _gui_thread(self):\\n self.setup_gui()\\n\\n while not self.stop:\\n if dpg.is_dearpygui_running():\\n data = self.process_data.get()\\n self.process_output(*data)\\n else:\\n self.stop = True\\n\\n self.detach_from_output()\",\n \"def main_thread_enter(self):\\n ...\",\n \"def loop(self):\\n while True:\\n if self.gui_updates:\\n self.update_gui()\\n\\n event, values = self.window.read(100)\\n\\n if event == \\\"btn_con_game\\\":\\n Thread(target=self.connect_game, daemon=True).start()\\n elif event == \\\"btn_con_headset\\\":\\n Thread(target=self.connect_headset, daemon=True).start()\\n elif event == \\\"btn_train_model\\\":\\n Thread(target=self.train_model, daemon=True).start()\\n elif event == \\\"btn_finalize\\\":\\n Thread(target=self.finalize, daemon=True).start()\\n \\n to_update = self.loading.copy()\\n for update in to_update:\\n self.window.Element(f'{update}_loading').UpdateAnimation('assets/loading.gif')\\n\\n # End program if user closes window\\n if event == sg.WIN_CLOSED:\\n break\\n\\n self.window.close()\",\n \"def start(self):\\n self.__main_window = Tk()\\n self.__start_loading_window()\",\n \"def Start(self):\\r\\n # Attach a WorkerDispatcher to the current thread\\r\\n self.m_disp = ttapi.Dispatcher.AttachWorkerDispatcher()\\r\\n self.m_disp.BeginInvoke(Action(self.Init))\\r\\n self.m_disp.Run()\",\n \"def Start(self):\\r\\n # Attach a WorkerDispatcher to the current thread\\r\\n self.m_disp = ttapi.Dispatcher.AttachWorkerDispatcher()\\r\\n self.m_disp.BeginInvoke(Action(self.Init))\\r\\n self.m_disp.Run()\",\n \"def _spin_wx(self):\\n import wx\\n app = wx.GetApp()\\n if app is not None and wx.Thread_IsMain():\\n evtloop = wx.EventLoop()\\n ea = wx.EventLoopActivator(evtloop)\\n while evtloop.Pending():\\n evtloop.Dispatch()\\n app.ProcessIdle()\\n del ea\",\n \"def process_thread(self):\",\n \"def __loop(self):\\n\\n self.__update_table()\\n self.__update_labels()\\n if self.remote_stop:\\n self.__stop(\\\"remote telegram admin\\\")\\n else:\\n self.__main_window.after(1000, self.__loop)\",\n \"def on_run(self):\\n wxMediator.on_run(self)\\n listener_evt = InterThreadEventWX(self,\\n wxEVT_NEW_LISTEN_CONN) \\n talker_evt = InterThreadEventWX(self,\\n wxEVT_NEW_TALK_CONN) \\n server = self.server()\\n sys.stderr.write('Starting server threads...\\\\n')\\n sys.stderr.flush()\\n server.start_other_threads(listener_evt, talker_evt)\",\n \"def start_ui(self):\\n\\t\\tself.start_animation()\\n\\t\\tself.app.exec()\",\n \"def init(self):\\n self.dispatcher.start()\\n self.replyer.start()\",\n \"def start(self, callback):\\n\\n def cb_wrapper(idle_h):\\n callback(self)\\n\\n self._ffi_cb = ffi.callback('void (*)(uv_idle_t *)', cb_wrapper)\\n libuv.uv_idle_start(self.handle, self._ffi_cb)\",\n \"def takeControl(self):\\n mainloop()\",\n \"def takeControl(self):\\n mainloop()\",\n \"def run(self):\\n\\n self._keep_running.set()\\n\\n # Create a command window to take user inputs\\n # gui_handler = threading.Thread(name=\\\"CommandWindow\\\", daemon=True, \\\\\\n # target=self._command_window.mainloop)\\n\\n # Launch a thread for fetching position data constantly\\n # TODO: Making these threads stoppable is too much of a pain!\\n position_fetcher = threading.Thread(name=\\\"PositionFetcher\\\", daemon=True, \\\\\\n target=self.fetch_position_and_update_frames)\\n spike_fetcher = threading.Thread(name=\\\"SpikeFetcher\\\", daemon=True, \\\\\\n target=self.fetch_spikes_and_update_frames)\\n place_field_fetcher = threading.Thread(name=\\\"PlaceFieldFetched\\\", daemon=True, \\\\\\n target=self.fetch_place_fields)\\n ripple_frame_fetcher = threading.Thread(name=\\\"RippleFrameFetcher\\\", daemon=True, \\\\\\n target=self.fetch_incident_ripple)\\n\\n position_fetcher.start()\\n spike_fetcher.start()\\n place_field_fetcher.start()\\n ripple_frame_fetcher.start()\\n\\n # Start the animation for Spike-Position figure, place field figure\\n self.initialize_ripple_detection_fig()\\n self.initialize_spike_pos_fig()\\n self.initialize_place_field_fig()\\n plt.show()\\n\\n # This is a blocking command... After you exit this, everything will end.\\n self._command_window.mainloop()\\n position_fetcher.join()\\n spike_fetcher.join()\\n place_field_fetcher.join()\\n ripple_frame_fetcher.join()\\n logging.info(MODULE_IDENTIFIER + \\\"Closed GUI and display pipes\\\")\",\n \"def create_threads(self):\\n # Dictionary with the interface items that will be passed to the functions\\n gui_items = {\\\"VCV_frequency_spb\\\":self.VCV_frequency_spb,\\n \\\"VCV_volume_spb\\\":self.VCV_volume_spb,\\n \\\"VCV_pressure_max_spb\\\":self.VCV_pressure_max_spb,\\n \\\"PCV_frequency_spb\\\":self.PCV_frequency_spb,\\n \\\"PCV_pressure_spb\\\":self.PCV_pressure_spb,\\n \\\"PCV_volume_max_spb\\\":self.PCV_volume_max_spb,\\n \\\"PSV_pressure_spb\\\":self.PSV_pressure_spb,\\n \\\"PSV_sensitivity_spb\\\":self.PSV_sensitivity_spb,\\n \\\"al_PEEP_min_spb\\\":self.al_PEEP_min_spb,\\n \\\"al_apnea_min_spb\\\":self.al_apnea_min_spb,\\n \\\"al_flow_min_spb\\\":self.al_flow_min_spb,\\n \\\"al_frequency_min_spb\\\":self.al_frequency_min_spb,\\n \\\"al_paw_min_spb\\\":self.al_paw_min_spb,\\n \\\"al_plateau_pressure_min_spb\\\":self.al_plateau_pressure_min_spb,\\n \\\"al_tidal_volume_min_spb\\\":self.al_tidal_volume_min_spb,\\n \\\"al_volume_minute_min_spb\\\":self.al_volume_minute_min_spb,\\n \\\"al_PEEP_max_spb\\\":self.al_PEEP_max_spb,\\n \\\"al_apnea_max_spb\\\":self.al_apnea_max_spb,\\n \\\"al_flow_max_spb\\\":self.al_flow_max_spb,\\n \\\"al_frequency_max_spb\\\":self.al_frequency_max_spb,\\n \\\"al_paw_max_spb\\\":self.al_paw_max_spb,\\n \\\"al_plateau_pressure_max_spb\\\":self.al_plateau_pressure_max_spb,\\n \\\"al_tidal_volume_max_spb\\\":self.al_tidal_volume_max_spb,\\n \\\"al_volume_minute_max_spb\\\":self.al_volume_minute_max_spb,\\n \\\"inhale_pause_spb\\\":self.inhale_pause_spb}\\n\\n # Sensors thread\\n self.worker_sensors = ReadSensors(self.flw_q, self.prs_q)\\n self.thread_sensors = QtCore.QThread()\\n self.worker_sensors.moveToThread(self.thread_sensors)\\n # Passing the arrays to the thread\\n # self.worker_sensors.signal_sensors.connect(self.update_sensors)\\n self.thread_sensors.started.connect(self.worker_sensors.work)\\n self.thread_sensors.start()\\n \\n # Piston control thread\\n # self.worker_piston = ControlPiston(self.piston, gui_items, mode=0)\\n self.worker_piston = ControlPiston(gui_items, self.flw_lifo_q, self.prs_lifo_q,\\n self.vol_lifo_q, mode=0)\\n self.thread_piston = QtCore.QThread()\\n self.worker_piston.moveToThread(self.thread_piston)\\n # Another way of passing variables to threads\\n # This is done again at every loop where flow, pressure and volume are updated\\n # This is not thread safe, the correct way to pass data to threads is using queues\\n # self.worker_piston.flw_data = self.flw_data\\n # self.worker_piston.vol_data = self.vol_data\\n # self.worker_piston.prs_data = self.prs_data\\n self.worker_piston.signal_cycle_data.connect(self.update_interface)\\n self.worker_piston.signal_startup_error.connect(self.error_window.show)\\n self.error_window.signal_retry_startup.connect(self.worker_piston.startup)\\n self.worker_piston.signal_get_tare.connect(self.set_tare_var)\\n self.thread_piston.started.connect(self.worker_piston.startup)\\n self.thread_piston.start()\\n\\n # Buttons control thread\\n self.worker_buttons = InterfaceControl()\\n self.thread_buttons = QtCore.QThread()\\n self.worker_buttons.moveToThread(self.thread_buttons)\\n self.worker_buttons.signal_button.connect(self.spinbox_control)\\n self.thread_buttons.started.connect(self.worker_buttons.read_queue_state)\\n self.thread_buttons.start()\\n\\n # Buzzer thread\\n self.worker_buzzer = BuzBuzzer()\\n self.thread_buzzer = QtCore.QThread()\\n self.worker_buzzer.moveToThread(self.thread_buzzer)\\n # led thread\\n self.worker_led = LEDControl()\\n self.thread_led = QtCore.QThread()\\n self.worker_led.moveToThread(self.thread_led)\",\n \"def execute(self):\\n while(self._running):\\n # get all pygame events from queue\\n for event in pygame.event.get():\\n self.event_handler(event)\\n self.update()\\n self.render()\\n self.cleanup()\",\n \"def run(self):\\n self.ident = threading.current_thread().ident\\n self.ready.set()\\n self.exec_()\",\n \"def _init_threads(self):\\n\\n startTh = Thread(name='InitialStart', target = self._singleUpdate, args=(self.outPs, ))\\n self.threads.append(startTh)\\n\\n sendTh = Thread(name='SteeringListen',target = self._listen_for_steering, args = (self.inPs[0], self.outPs, ))\\n self.threads.append(sendTh)\",\n \"def startSubscribers(self):\\n if (self.on_TB1_Viewer.isChecked()):\\n self.threadpool = QThreadPool()\\n worker = tb1Worker()\\n self.threadpool.start(worker)\\n \\n elif (self.on_TB2_Viewer.isChecked()):\\n self.threadpool = QThreadPool()\\n worker = tb2Worker()\\n self.threadpool.start(worker)\\n \\n elif (self.on_TB3_Viewer.isChecked()):\\n self.threadpool = QThreadPool()\\n worker = tb3Worker()\\n self.threadpool.start(worker)\\n \\n elif (self.on_TB4_Viewer.isChecked()):\\n self.threadpool = QThreadPool()\\n worker = tb4Worker()\\n self.threadpool.start(worker)\",\n \"def run():\\n gui = GUI()\\n gui.mainloop()\",\n \"def main_loop(self):\\n dt = 0.3\\n self.clock.tick(self.fps)\\n while not self.done:\\n self.event_loop()\\n self.update(dt)\\n self.render()\\n dt = self.clock.tick(self.fps)/1000.0 # create delta time variable to multiply with movement and rotation\\n self.display_fps()\\n self.health_bar()\\n self.enemy_health()\\n self.energy_bar()\",\n \"def create_and_start_threads(self):\\r\\n self.create_threads()\\r\\n self.start_threads()\",\n \"def start(self, actions_to_run=None):\\n\\n self.__thread = Thread(target = self.__run, args=[actions_to_run])\\n self.__thread.start()\\n self.__set_state(WorkerState.Idle)\",\n \"def run(self):\\n self.thread = threading.Thread(target=self._main)\\n self.thread.start()\\n self.running = True\",\n \"def main_loop(self):\\n dt = 0\\n self.clock.tick(FPS)\\n while not self.done:\\n self.event_loop()\\n self.update(dt)\\n self.render()\\n dt = self.clock.tick(FPS) / 1000.0\",\n \"def __call__(self, event_queue, in_queue, out_queue):\\n\\n running = True\\n self.in_q = in_queue # command received from the main thread\\n self.out_q = out_queue # responses, commands to the main thread\\n self.ev_q = event_queue # return pending events to the main thread\\n shutdown = False\\n self.light_state = False # current state of beat light\\n\\n # send first beat light message\\n if self.btic.BeatLight() is True:\\n self.out_q.put(\\\"beaton\\\")\\n else:\\n self.out_q.put(\\\"beatoff\\\")\\n\\n # run thread loop\\n while running is True:\\n if self.die_pending is False:\\n self.sendPendingEvents()\\n self.processCommands()\\n\\n \\\"\\\"\\\"\\n if self.btic.BeatLightToggle() == True:\\n self.out_q.put(\\\"beat\\\")\\n wx.WakeUpIdle()\\n \\\"\\\"\\\"\\n\\n # display beat light on UI\\n light = self.btic.BeatLight()\\n if light != self.light_state:\\n self.light_state = light\\n if light is True:\\n self.out_q.put(\\\"beatoff\\\")\\n else:\\n self.out_q.put(\\\"beaton\\\")\\n wx.WakeUpIdle() \\n \\n if self.allClear() is True:\\n time.sleep(.01)\\n #pass\\n else:\\n # stop the loop/thread when all is cleaned up\\n self.sendPendingEvents()\\n if self.allClear() is True:\\n self.clearBank() \\n self.die_pending = False\\n running = False\\n else:\\n time.sleep(.01)\\n # pass\",\n \"def main_loop():\\n while len(fake_threads) > 0:\\n pulse(0.1)\",\n \"def _preloop_hook(self) -> None:\\n self.selectorloop = SelectorThread(daemon=True)\\n self.selectorloop.start()\",\n \"def startMainLoop(self):\\n self.thread.start()\\n self.theMainLoop.emit(QtCore.SIGNAL(\\\"step()\\\"))\\n self.app.exec_()\",\n \"def main(self, screen: curses.window) -> None:\\n curses.curs_set(0)\\n curses.mousemask(curses.BUTTON1_RELEASED)\\n curses.mouseinterval(0)\\n self.initialize_colors()\\n self.draw_menu(screen)\\n status_bar_thread = threading.Thread(target=self.draw_status_bar_continuously, args=(screen, 0.5))\\n status_bar_thread.daemon = True\\n status_bar_thread.start()\\n\\n while True:\\n ch = screen.getch()\\n if ch == curses.KEY_RESIZE:\\n curses.curs_set(0)\\n self.draw_menu(screen)\\n elif ch == curses.KEY_MOUSE:\\n _, mouse_x, mouse_y, _, mouse_state = curses.getmouse()\\n if not mouse_state:\\n for button in self.buttons:\\n if not button.try_click(mouse_y, mouse_x):\\n continue\\n if button == self.start_button:\\n if self.start_button.get_current_option() == \\\"STOP\\\":\\n self.draw_menu(screen)\\n file_format = self.file_format_button.get_current_option().lower()\\n try:\\n self.comic_results = xkcd_extractor.crawl(self.comic_id_button.text, file_format)\\n except ValueError:\\n self.start_button.cycle()\\n curses.beep()\\n else:\\n self.comic_results = None\\n self.comic_results_index = 0\\n elif button == self.next_button:\\n self.comic_results_index = (self.comic_results_index + 1) % len(self.comic_results.comics)\\n elif button == self.back_button:\\n self.comic_results_index = (self.comic_results_index - 1) % len(self.comic_results.comics)\\n elif button == self.open_folder_button:\\n comic = self.comic_results.comics[self.comic_results_index]\\n folder_path = '\\\\\\\\'.join(comic.image_path.split('\\\\\\\\')[:-1])\\n os.startfile(folder_path) # noqa: S606\\n self.draw_menu(screen)\\n elif ch == ord('q'):\\n return\\n else:\\n if not self.comic_id_button.next_character(ch):\\n curses.beep()\\n self.draw_menu(screen)\",\n \"def start(self):\\r\\n # self._app.console.widget().clear() # clear log window\\r\\n # reset threads\\r\\n self._threads = []\\r\\n self.set_threads()\\r\\n self.ui_pump.setValue(0)\\r\\n self.ui_fan.setValue(0)\\r\\n self._motor_controllers[0].set_device(port=\\\"COM7\\\")\\r\\n self._labjacks[0].activate()\\r\\n logging.info('Starting acquisition', extra=self.extra)\\r\\n\\r\\n self.set_data() # initialize both data frame and plot selection\\r\\n self._signal = self._signal_selection.currentText()\\r\\n\\r\\n self._times = [0.0]\\r\\n self._timer.start() # start timer\\r\\n for thread in self._threads: # start remaining threads\\r\\n thread.start()\\r\\n self.start_rec()\\r\\n\\r\\n self.ui_start.setEnabled(False)\\r\\n self.ui_time.setEnabled(False)\\r\\n self.ui_stop.setEnabled(True)\",\n \"def mainloop(self):\\n self.root.mainloop()\",\n \"def mainloop(self):\\n self.root.mainloop()\",\n \"def call_start_cbs(self):\\n try:\\n for (cb,args) in self._start_cbs:\\n cb(self.userdata, self.get_initial_states(), *args)\\n except:\\n smach.logerr(\\\"Could not execute start callback: \\\"+traceback.format_exc())\",\n \"def updateGraphics():\\n _root.update_idletasks()\",\n \"def mainloop(self):\\n self.master.mainloop()\",\n \"def main():\\n root = tkinter.Tk()\\n delegate = ReceiveMessages()\\n mqtt_client = com.MqttClient(delegate)\\n mqtt_client.connect_to_ev3()\\n\\n progress_bar = setup_gui(root, mqtt_client)\\n delegate.progress_bar = progress_bar\\n\\n root.mainloop()\",\n \"def init_ui():\\n\\t# Use wrapper to set reasonable defaults and reset the terminal on exit\\n\\t#curses.wrapper(_main_loop)\\n\\tcurses.wrapper(_init_func)\",\n \"def main(self,q,controlQueue):\\n\\n self.dataQueue=q\\n\\n t1=threading.Thread(target=self.updater,args=(controlQueue,))\\n #t2=threading.Thread(target=self.xMotor,args=(controlQueue,))\\n #t3=threading.Thread(target=self.yMotor,args=(controlQueue,))\\n t1.start()\\n #t2.start()\\n #t3.start()\",\n \"def main_loop(self):\\n while self.game_manager.game_state != GameState.Quit:\\n\\n self.handle_events()\\n self.handle_ui_response()\\n #in menu\\n if self.game_manager.game_state == GameState.Menu: \\n self.display.clear()\\n\\n #in game\\n elif self.game_manager.game_state == GameState.Running:\\n self.game_manager.move_players()\\n\\n #after game\\n elif self.game_manager.game_state == GameState.Finished:\\n if self.game_manager.winner == None:\\n self.game_manager.player1.decay()\\n self.game_manager.player2.decay() \\n else:\\n self.game_manager.loser.decay()\\n self.game_manager.loser.draw()\\n\\n #perform game manager actions\\n self.game_manager.act()\\n #do all the rendering stuff\\n self.render_scene()\\n #control FPS\\n self.clock.tick(self.FPS)\",\n \"def startGTK( ):\\n if not INITIALIZED:\\n init()\\n if LOOP_TRACKER:\\n LOOP_TRACKER.increment()\",\n \"def __init__(self, master, user, song, cdLen, goHold):\\n # GUI will be visible window after init\\n self.master = master\\n\\n # get window size\\n self.w = self.master.winfo_screenwidth()\\n self.h = self.master.winfo_screenheight()\\n\\n # GUI will be visible after tkinter.Tk()\\n # hide the GUI window for now\\n self.guiVisible = 1\\n self.GUIhide()\\n\\n # keep track of whether alarm is active or not\\n self.shotsFired = 0\\n\\n # keep track of whether we have flashed hue\\n self.flashed = 0\\n self.flashed2 = 0\\n\\n # keep track of seconds into a given track\\n self.count = 0\\n\\n # What song are we going to play??\\n self.song = song\\n\\n # keep track of length (sec) of selected song\\n # this will be assigned at alarmActivate()\\n self.songLength = 0\\n\\n # song countdown length\\n # this is assigned by init call\\n self.cdLen = cdLen\\n\\n # how long to display \\\"GO!!\\\"\\n # this is assigned by init call\\n self.goHold = goHold\\n\\n # Create the queue\\n self.queue = Queue.Queue()\\n\\n # Create a lock to access shared resources amongst threads\\n self.lock = threading.Lock()\\n\\n # Set up the GUIPart\\n # we pass it the master (root), the queue, the endApplication function, and the hide / show functions\\n self.gui = DisplayController(master, self.queue, self.alarmCancel, self.GUIhide, self.GUIshow)\\n\\n # Set up the Spotify instance\\n self.mySpotipy = ASpotipy(user, Private.CLIENT_ID, Private.CLIENT_SECRET, Private.REDIRECT_URI)\\n\\n # setup hue\\n self.myHue = hueControl()\\n\\n # Set up the thread to do asynchronous I/O\\n self.running = 1\\n self.thread1 = threading.Thread(target=self.workerThread1)\\n self.thread1.start()\\n\\n self.thread2 = threading.Thread(target=self.workerThread2)\\n self.thread2.start()\\n\\n self.thread3 = threading.Thread(target=self.workerThread3)\\n self.thread3.start()\\n\\n self.thread4 = threading.Thread(target=self.workerThread4)\\n self.thread4.start()\\n\\n # Start the periodic call in the GUI to check if the queue contains\\n # anything\\n self.periodicCall()\",\n \"def _dispatch(f = None):\\n #first install signal handler\\n #this way we can quit the program easily from the command line\\n #also, this makes libevent block on the first loop\\n #otherwise when there are no events in the beginning, loop will not\\n #block and our main dispatch loop would claim 100% CPU time\\n def interrupt():\\n quit(EXIT_CODE_SIGINT)\\n event_interrupt = SignalEvent(SIGINT, interrupt)\\n\\n #the heartbeat makes sure the main loop below at least\\n #makes a cycle every second. otherwise, if there are no pending signals\\n #libevent._loop would block indefinitly, causing our loop never to check\\n #if it still must be _running...\\n event_heartbeat = TimeoutEvent(1.0, None, True)\\n\\n #as a convenience, user can provide a callable *f* to start a new task\\n #lets start it here\\n if callable(f):\\n Tasklet.new(f)()\\n\\n global _running\\n _running = True\\n e = None\\n try:\\n #this is it, the main dispatch loop...\\n #tasklets are scheduled to run by stackless,\\n #and if no more are runnable, we wait for IO events to happen\\n #that will trigger tasks to become runnable\\n #ad infinitum...\\n while _running:\\n #first let any tasklets run until they have all become blocked on IO\\n try:\\n while stackless.getruncount() > 1:\\n stackless.schedule()\\n except TaskletExit:\\n pass\\n except:\\n logging.exception(\\\"unhandled exception in dispatch schedule\\\")\\n\\n #now block on IO till any IO is ready.\\n #care has been taken to not callback directly into python\\n #from libevent. that would add c-data on the stack which would\\n #make stackless need to use hard-switching, which is slow.\\n #so we call 'loop' which blocks until something available.\\n try:\\n event.loop()\\n except TaskletExit:\\n raise\\n except:\\n logging.exception(\\\"unhandled exception in event loop\\\")\\n\\n #we iterate over the available triggered events and\\n #call the callback which is available as the 'data' object of the event\\n #some callbacks may trigger direct action (for instance timeouts, signals)\\n #others might resume a waiting task (socket io).\\n while event.has_next():\\n try:\\n e, event_type, fd = event.next()\\n e.data(event_type)\\n except TaskletExit:\\n raise\\n except:\\n logging.exception(\\\"unhandled exception in event callback\\\")\\n\\n finally:\\n del e\\n event_interrupt.close()\\n del event_interrupt\\n event_heartbeat.close()\\n del event_heartbeat\\n\\n if DEBUG_LEAK:\\n logging.warn(\\\"alive objects:\\\")\\n gc.collect()\\n _print_objects(gc.get_objects())\\n logging.warn('garbage:')\\n _print_objects(gc.garbage)\\n\\n sys._exit(_exitcode)\",\n \"def loop_run(self):\\n super(EventLoop, self).loop_run()\\n self.inq = self.cothread.EventQueue()\",\n \"def start(cls):\\n\\n cls._set_mode_running()\\n TimeDisplay.start_time()\\n for callback in cls.start_callback:\\n callback()\",\n \"def __init__(self, width, height):\\n # Initialize the tk root window\\n self._controller = Controller(self)\\n self.root = tk.Tk()\\n self.init_dx = width\\n self.init_dy = height\\n self.root.geometry(\\\"%dx%d+50+30\\\"%(self.init_dx, self.init_dy))\\n self.root.title(\\\"RDM user interface version: 1.0\\\")\\n self.root.maxsize(1600, 900)\\n self.root.lift()\\n self.root.update_idletasks()\\n # Assigning fields\\n self.universe = tk.IntVar(self.root)\\n self.universe.set(1)\\n self.universe_list = [1, 2, 3, 4, 5]\\n self.cur_uid = None\\n self.id_state = tk.IntVar(self.root)\\n self.auto_disc = tk.BooleanVar(self.root)\\n self.id_state.set(0)\\n# self.state = 0\\n self._uid_dict = {}\\n \\n # Call initialing functions\\n self._pid_store = PidStore.GetStore()\\n self.ola_thread = olathread.OLAThread(self._pid_store)\\n self.ola_thread.start()\\n self.build_frames()\\n self.build_cntrl()\\n self._notebook = notebook.RDMNotebook(self.root, self._controller)\\n self.discover()\\n self.auto_disc.set(False)\\n\\n print \\\"currently in thread: %d\\\"%threading.currentThread().ident\\n time.sleep(1)\\n print \\\"back from sleep\\\"\",\n \"def mainloop(self):\\r\\n self.bindHotkeys()\\r\\n self.root.mainloop()\",\n \"def mainloop(self):\\n\\t\\tself.root.after(100, self.tkloop)\\n\\t\\tself.root.mainloop()\",\n \"async def _main(self):\\n while True:\\n time.sleep(1)\",\n \"def run(self):\\n\\n # This is the code executing in the new thread. Simulation of\\n # a long process as a simple urllib call\\n\\n try:\\n url = _docsURL % ReplaceCapitals(self.selectedClass)\\n fid = urllib.request.urlopen(url)\\n\\n if six.PY2:\\n originalText = fid.read()\\n else:\\n originalText = fid.read().decode(\\\"utf-8\\\")\\n text = RemoveHTMLTags(originalText).split(\\\"\\\\n\\\")\\n data = FindWindowStyles(text, originalText, self.selectedClass)\\n\\n if not self.keepRunning:\\n return\\n\\n wx.CallAfter(self.notifyWindow.LoadDocumentation, data)\\n except (IOError, urllib.error.HTTPError):\\n # Unable to get to the internet\\n t, v = sys.exc_info()[:2]\\n message = traceback.format_exception_only(t, v)\\n wx.CallAfter(self.notifyWindow.StopDownload, message)\\n except:\\n # Some other strange error...\\n t, v = sys.exc_info()[:2]\\n message = traceback.format_exception_only(t, v)\\n wx.CallAfter(self.notifyWindow.StopDownload, message)\",\n \"def start(self):\\n\\n # ioloop.install()\\n threading.Thread(target=self.loop.start).start()\\n time.sleep(1)\",\n \"def _make_thread(self):\\r\\n pass\",\n \"def start(self):\\r\\n monitor_thread = Thread(target = self.monitor)\\r\\n monitor_thread.setDaemon(True)\\r\\n monitor_thread.start()\\r\\n\\r\\n main_thread = Thread(target = self.run)\\r\\n main_thread.setDaemon(True)\\r\\n main_thread.start()\",\n \"def run(self):\\n while self._update_func():\\n self.update_signal.emit(None)\",\n \"def run(self):\\n while self.running:\\n QtCore.QCoreApplication.processEvents()\",\n \"def cb_gui_test_1( self, ):\\r\\n print( \\\"cb_gui_test_1\\\" )\\r\\n self.helper_thread.toggle_lock()\",\n \"def start_threading(self):\\n\\n # For Demo only commented\\n self.progress_label.config(text='Running...')\\n # self.progress_label.config(text='Estimating Time Reamining')\\n self.prev_prog = progressbar.current\\n self.submit_thread = threading.Thread(target=self.run)\\n self.start_time = time.time()\\n self.submit_thread.daemon = True\\n self.submit_thread.start()\\n self.after(1000, self.check_thread)\",\n \"def start(self):\\n if self.__started:\\n return\\n\\n self.__started = True\\n GLib.timeout_add(GtkMainLoop.DEADLINE_GLIB, self.__ioloop_run)\\n self.__gi_loop.run()\",\n \"def state_processing_do(cfg, app, win, events):\",\n \"def start(self):\\n #Starting the thread able to handle the administrator request\\n t2 = threading.Thread(target=self.handleServer)\\n t2.start()\\n self.ActiveThreads.append(t2)\\n #Listen continously\\n while True:\\n self.server.listen(50)\\n self.Log.log(\\\"Waiting for connections...\\\")\\n #Obtaining the parameters like the socket and the address/port of the incoming connection\\n (conn, (ip,port)) = self.server.accept()\\n #Creating a new thread able to handle the new connection with the client\\n newClient = ClientHandler(conn,ip,port,self.DB,self.Users,self.Log,self.XML);\\n #Starting the new thread\\n newClient.start()\\n #Appending the thread to the list of active threads\\n self.ActiveThreads.append(newClient)\",\n \"def main(self):\\n self.root.mainloop()\",\n \"def temp_mainloop(self, cycles_to_respond=1000):\\n\\n if self.com_port_select.count() > 0:\\n report = \\\"Begin measuring\\\"\\n self.go_button.setEnabled(False) # don't allow to create new threads\\n self.state_temp_loop(True)\\n self.append_msg_box(report)\\n\\n while self.temp_loop_actiator:\\n for num in range(self.com_port_select.count()):\\n # self.MainWindow_exec_thread(lambda: self.sample_devices(cycles_to_respond, num))\\n self.sample_devices(cycles_to_respond, num)\\n self.temp_repr.plot_tc_temp(self.temp_log)\\n timeo = float(self.timeout.text()) # timeout\\n sleep(timeo)\\n # -------- record data once in msg box --------\\n\\n self.go_button.setEnabled(True)\\n self.led_light.setPixmap(QtGui.QPixmap(img[\\\"red_led\\\"]))\\n else:\\n self.append_msg_box(\\\"No device is connected\\\")\",\n \"def __init__(self ):\\r\\n # ------------------- basic setup --------------------------------\\r\\n AppGlobal.controller = self\\r\\n msg = \\\"\\\"\\r\\n msg = ( f\\\"{msg}\\\\n=============== starting SmartTerminal ===============\\\" )\\r\\n msg = ( f\\\"{msg}\\\\n\\\" )\\r\\n msg = ( f\\\"{msg}\\\\n -----> prints may be sent to log file !\\\" )\\r\\n msg = ( f\\\"{msg}\\\\n\\\" )\\r\\n AppGlobal.logger.log( 55, msg )\\r\\n\\r\\n # AppGlobal.logger.info( \\\"no logger\\\" )\\r\\n # AppGlobal.logger.debug( \\\"no logger 2\\\" )\\r\\n\\r\\n self.app_name = \\\"SmartTerminal\\\"\\r\\n self.version = \\\"Ver6: 2020 02 22.0\\\"\\r\\n self.gui = None # build later\\r\\n self.no_restarts = -1 # start is restart 0\\r\\n self.no_helper_restarts = 0\\r\\n\\r\\n # ----------- for second thread -------\\r\\n #self.helper_thread_manager = None\\r\\n self.queue_to_gui = None\\r\\n self.queue_from_gui = None\\r\\n self.gui_recieve_lock = threading.Lock() # when locked the gui will process receive, acquired released in helper\\r\\n # how different from just a variable set?\\r\\n self.restart( )\",\n \"def server_init(self):\\n if not self.web_interface_thread.isAlive():\\n # spawn the web interface.\\n self.web_interface_thread.start()\",\n \"def run_main_loop():\\n mainloop = GObject.MainLoop()\",\n \"def start(self):\\n self.thread.start()\",\n \"def initThread(self):\\n thread1 = threading.Thread(target=self.processData)\\n self.info(\\\"starting cod7http thread\\\")\\n thread1.start()\\n self.httpthreadinst = thread1\",\n \"def on_data(self, status):\\r\\n self.counter += 1\\r\\n start_new_thread(self.arduPusherClick,(1,))\\r\\n # start new thread to print out the text\\r\\n start_new_thread(self.printerTweet, (status,))\\r\\n return\",\n \"def update_ui(self):\\n # main data\\n self.lAcc.setText(self.settings.ACCOUNT)\\n # self.lExcessLiquidity.setText(str(self.ibkrworker.app.excessLiquidity))\\n # self.lSma.setText(str(self.ibkrworker.app.sMa))\\n if hasattr(self.ibkrworker.app, 'smaWithSafety'):\\n self.lSma.setText(str(round(self.ibkrworker.app.smaWithSafety, 1)))\\n else:\\n self.lSma.setText(str(round(self.ibkrworker.app.sMa, 1)))\\n self.lMarketValue.setText(str(self.ibkrworker.app.netLiquidation))\\n self.lblAvailTrades.setText(str(self.ibkrworker.app.tradesRemaining))\\n self.lcdPNL.display(self.ibkrworker.app.dailyPnl)\\n if self.ibkrworker.app.dailyPnl > 0:\\n palette = self.lcdPNL.palette()\\n palette.setColor(palette.WindowText, QtGui.QColor(51, 153, 51))\\n self.lcdPNL.setPalette(palette)\\n elif self.ibkrworker.app.dailyPnl < 0:\\n palette = self.lcdPNL.palette()\\n palette.setColor(palette.WindowText, QtGui.QColor(255, 0, 0))\\n self.lcdPNL.setPalette(palette)\\n\\n total_positions_value = 0\\n for p in self.ibkrworker.app.openPositions.values():\\n if hasattr(p, 'Value'):\\n total_positions_value += p[\\\"Value\\\"]\\n self.lPositionsTotalValue.setText(str(round(total_positions_value, 1)))\\n\\n self.update_open_positions()\\n self.update_live_candidates()\\n self.update_open_orders()\\n\\n # everything disabled for safety - is now enabled\\n self.chbxProcess.setEnabled(True)\\n self.btnSettings.setEnabled(True)\\n\\n self.update_session_state()\\n\\n if not self.uiTimer.isActive():\\n self.update_console(\\\"UI resumed.\\\")\\n self.uiTimer.start(int(self.settings.INTERVALUI) * 1000) # reset the ui timer\",\n \"def run(self):\\n run=0\\n wx.CallAfter(Publisher().sendMessage, \\\"update\\\", \\\"\\\")\\n time.sleep(10)\\n while (run==0):\\n wx.CallAfter(Publisher().sendMessage, \\\"updatebuttons\\\", \\\"\\\")\\n time.sleep(10)\",\n \"def run(self):\\n\\t\\t\\n\\t\\twhile self.update():\\n\\t\\t\\tpass\",\n \"def run_in_background(self):\\n threading.Thread(target=self._run_loop).start()\",\n \"def _main_loop(self):\\n while not rospy.is_shutdown():\\n # Check for reconfiguration data\\n if self._transfer_reconfigure_data is not None:\\n # Copy reconfigure data from shared memory\\n with self._transfer_reconfigure_data_mutex:\\n reconfigure_data = deepcopy(self._transfer_reconfigure_data)\\n self._transfer_reconfigure_data = None\\n # Run vision reconfiguration\\n self._configure_vision(*reconfigure_data)\\n # Check for new image\\n elif self._transfer_image_msg is not None:\\n # Copy image from shared memory\\n with self._transfer_image_msg_mutex:\\n image_msg = self._transfer_image_msg\\n self._transfer_image_msg = None\\n # Run the vision pipeline\\n self._handle_image(image_msg)\\n # Now the first image has been processed\\n self._first_image_callback = False\\n else:\\n try:\\n self._rate.sleep()\\n except rospy.exceptions.ROSTimeMovedBackwardsException:\\n pass\",\n \"def run_main(self):\\n self.addSensors()\\n \\n while True:\\n # Leemos los sensores\\n self.readSensors()\\n \\n # Extraemos la información a partir de los datos\\n self.processData()\\n \\n # Actualizamos la máquina de estados a partir de la información recibida por los sensores \\n self.updateFiniteStateMachine()\\n \\n # Calculamos las acciones que tenemos que aplicar a los distintos motores, en función del\\n # estado y las lecturas de los sensores\\n self.controller()\\n \\n # Pasamos a motores las acciones calculadas\\n self.execute()\\n\\n # Publicamos info importante para el debug\\n self.refreshUserInterface()\\n \\n print(self.name + \\\": --------------------------\\\")\\n time.sleep(2) #!!!!!!!!!!!!!!!! ELIMINAR DELAY !!!!!!!!!!!!!!!!# \",\n \"def background(self):\\n self.thread = threading.Thread(target=self.run)\\n self.thread.setDaemon(True)\\n self.thread.start()\",\n \"def start(self):\\n if not self.thread:\\n self.thread = WndUtils.run_thread(None, self.save_data_thread, ())\",\n \"def __init__(self):\\n\\n self._system = None\\n self._running_thread = None\\n self._running_task = None\\n\\n self._root = tk.Tk(className='Quake AI')\\n self._root.configure(background='white')\\n self._logo = tk.PhotoImage(file='./resources/logo.png')\\n logo_frame = tk.Frame(self._root, bg='white')\\n tk.Label(logo_frame, image=self._logo, bd=0).pack()\\n logo_frame.pack()\\n\\n # Start frame\\n self._start_frame = tk.Frame(self._root, bg='white')\\n\\n self._config_path = tk.StringVar()\\n\\n tk.Label(self._start_frame, text='Quake AI needs config to startup the system. Either choose an\\\\n '\\n 'existing configuration file or provide a file path and a default one\\\\n '\\n 'will be generated.',\\n bg='white', font=('Helvetica', 10)).pack(fill='x')\\n\\n tk.Button(self._start_frame, text=\\\"Choose config\\\", font=('Helvetica', 10),\\n command=self._startup_system).pack(pady=10)\\n self._start_frame.pack(side=tk.BOTTOM)\\n\\n # Main frame\\n self._main_frame = tk.Frame(self._root, bg='white')\\n\\n self._status_text = tk.StringVar(self._main_frame)\\n self._status_text.set('Idle')\\n tk.Label(self._main_frame, textvariable=self._status_text, font=('Helvetica', 16, 'bold'), bg='white',\\n relief=tk.SUNKEN).pack(pady=10)\\n\\n trigger_training = tk.LabelFrame(self._main_frame, text=\\\"Triggerbot Training\\\", font=('Helvetica', 10), bg='white')\\n tk.Button(trigger_training, text=\\\"Capture Images for Triggerbot\\\", font=('Helvetica', 10),\\n command=self._run_trigger_capture_task).pack(pady=10)\\n tk.Button(trigger_training, text=\\\"Start Training for Triggerbot\\\", font=('Helvetica', 10),\\n command=self._run_trigger_training_task).pack(pady=10)\\n trigger_training.pack(ipadx=110)\\n\\n triggerbot = tk.LabelFrame(self._main_frame, text=\\\"Triggerbot\\\", font=('Helvetica', 10), bg='white')\\n tk.Button(triggerbot, text=\\\"Start Triggerbot\\\", font=('Helvetica', 10),\\n command=self._run_trigger_inference_task).pack(pady=10)\\n triggerbot.pack(ipadx=150)\\n\\n aimbot_training = tk.LabelFrame(self._main_frame, text=\\\"Aimbot Training\\\", font=('Helvetica', 10), bg='white')\\n tk.Button(aimbot_training, text=\\\"Capture Images for Aimbot\\\", font=('Helvetica', 10),\\n command=self._run_aimbot_capture_task).pack(pady=10)\\n tk.Button(aimbot_training, text=\\\"Annotate Images for Aimbot\\\", font=('Helvetica', 10),\\n command=self._run_aimbot_annotation_task).pack(pady=10)\\n tk.Button(aimbot_training, text=\\\"Train Aimbot\\\", font=('Helvetica', 10),\\n command=self._run_aimbot_training_task).pack(pady=10)\\n aimbot_training.pack(ipadx=115)\\n\\n aimbot = tk.LabelFrame(self._main_frame, text=\\\"Aimbot\\\", font=('Helvetica', 10), bg='white')\\n tk.Button(aimbot, text=\\\"Start Aimbot\\\", font=('Helvetica', 10),\\n command=self._run_aimbot_inference_task).pack(pady=10)\\n aimbot.pack(ipadx=159)\\n\\n tk.Button(self._main_frame, text=\\\"Stop Current Task\\\", font=('Helvetica', 10),\\n command=self._stop_current_task).pack(pady=10)\\n\\n # Mixing win32gui and tkinter leads to crashes on exit --> prevent this by hard shutdown via os\\n self._root.protocol(\\\"WM_DELETE_WINDOW\\\", self._on_closing)\\n\\n self._root.mainloop()\",\n \"def _start_io_event_loop(self):\\r\\n self._event_loop_started = threading.Lock()\\r\\n self._event_loop_started.acquire()\\r\\n threading.Thread(None, self._io_event_loop_thread).start()\\r\\n self._event_loop_started.acquire()\",\n \"def run(self):\\n self.loop.spawn_callback(self.main)\\n self.loop.start()\\n if self.exc_info:\\n six.reraise(*self.exc_info)\",\n \"def start(self):\\n if not self._is_running:\\n self._pos_thread = Timer(self.draw_intvl, self._run)\\n self._pos_thread.start()\\n self._is_running = True\",\n \"def launchFunc():\\n th = threading.Thread(target=progressScreen)\\n th.start()\",\n \"def run(self):\\n self._start_servers()\\n monitor = KodiMonitor(self.nx_common, self.nx_common.log)\\n while not monitor.abortRequested():\\n monitor.update_playback_progress()\\n try:\\n if self.library_update_scheduled() and self._is_idle():\\n self.update_library()\\n except RuntimeError as exc:\\n self.nx_common.log(\\n 'RuntimeError: {}'.format(exc), xbmc.LOGERROR)\\n if monitor.waitForAbort(5):\\n break\\n self._shutdown()\",\n \"def run(self):\\n self.window.mainloop()\",\n \"def start(self):\\n self.open()\\n #t = Thread(target=self._cache_update, args=())\\n #t.daemon = True\\n #t.start()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64265764","0.64098173","0.6402181","0.6346647","0.6325017","0.62540954","0.6195212","0.6173926","0.61703956","0.6163969","0.6110663","0.6080352","0.6075288","0.6012084","0.6007064","0.6005521","0.5975944","0.59583676","0.5932319","0.59218866","0.59218866","0.59203523","0.59001535","0.58951133","0.58663726","0.5853474","0.58307534","0.5777187","0.5768934","0.5768934","0.5735464","0.57159567","0.5715074","0.57070404","0.57049996","0.56805456","0.5680094","0.56757504","0.56624216","0.5642842","0.56400424","0.5621354","0.56125647","0.56096053","0.56092656","0.56089264","0.560514","0.55929136","0.55893224","0.55893224","0.5587441","0.5583754","0.5577746","0.55765826","0.5574174","0.55682075","0.5563631","0.5553769","0.5546605","0.5538383","0.55104357","0.55041057","0.5498339","0.5486574","0.5468181","0.5444839","0.54427123","0.5440853","0.5434288","0.5433783","0.5431921","0.5430322","0.54300654","0.54258394","0.54179966","0.54164106","0.54162294","0.54158825","0.5413683","0.5413358","0.54121935","0.54115945","0.5411372","0.53957826","0.5393933","0.53938675","0.53921443","0.53916246","0.53905964","0.53861254","0.53849345","0.53837633","0.53822076","0.53801554","0.53710896","0.5364245","0.53524864","0.53445226","0.5343132","0.5341971","0.5340688"],"string":"[\n \"0.64265764\",\n \"0.64098173\",\n \"0.6402181\",\n \"0.6346647\",\n \"0.6325017\",\n \"0.62540954\",\n \"0.6195212\",\n \"0.6173926\",\n \"0.61703956\",\n \"0.6163969\",\n \"0.6110663\",\n \"0.6080352\",\n \"0.6075288\",\n \"0.6012084\",\n \"0.6007064\",\n \"0.6005521\",\n \"0.5975944\",\n \"0.59583676\",\n \"0.5932319\",\n \"0.59218866\",\n \"0.59218866\",\n \"0.59203523\",\n \"0.59001535\",\n \"0.58951133\",\n \"0.58663726\",\n \"0.5853474\",\n \"0.58307534\",\n \"0.5777187\",\n \"0.5768934\",\n \"0.5768934\",\n \"0.5735464\",\n \"0.57159567\",\n \"0.5715074\",\n \"0.57070404\",\n \"0.57049996\",\n \"0.56805456\",\n \"0.5680094\",\n \"0.56757504\",\n \"0.56624216\",\n \"0.5642842\",\n \"0.56400424\",\n \"0.5621354\",\n \"0.56125647\",\n \"0.56096053\",\n \"0.56092656\",\n \"0.56089264\",\n \"0.560514\",\n \"0.55929136\",\n \"0.55893224\",\n \"0.55893224\",\n \"0.5587441\",\n \"0.5583754\",\n \"0.5577746\",\n \"0.55765826\",\n \"0.5574174\",\n \"0.55682075\",\n \"0.5563631\",\n \"0.5553769\",\n \"0.5546605\",\n \"0.5538383\",\n \"0.55104357\",\n \"0.55041057\",\n \"0.5498339\",\n \"0.5486574\",\n \"0.5468181\",\n \"0.5444839\",\n \"0.54427123\",\n \"0.5440853\",\n \"0.5434288\",\n \"0.5433783\",\n \"0.5431921\",\n \"0.5430322\",\n \"0.54300654\",\n \"0.54258394\",\n \"0.54179966\",\n \"0.54164106\",\n \"0.54162294\",\n \"0.54158825\",\n \"0.5413683\",\n \"0.5413358\",\n \"0.54121935\",\n \"0.54115945\",\n \"0.5411372\",\n \"0.53957826\",\n \"0.5393933\",\n \"0.53938675\",\n \"0.53921443\",\n \"0.53916246\",\n \"0.53905964\",\n \"0.53861254\",\n \"0.53849345\",\n \"0.53837633\",\n \"0.53822076\",\n \"0.53801554\",\n \"0.53710896\",\n \"0.5364245\",\n \"0.53524864\",\n \"0.53445226\",\n \"0.5343132\",\n \"0.5341971\",\n \"0.5340688\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93075,"cells":{"query":{"kind":"string","value":"output thread function for getting inference results from Movidius NCS running graph specific post processing of inference result queuing the results for main thread callbacks"},"document":{"kind":"string","value":"def output_thread():\n global gRunning\n\n try:\n while gRunning:\n try:\n inference_result, user_data = gGraph.GetResult()\n \n print (postprocess(inference_result))\n #print(user_data)\n # gUpdateq.put((postprocess(inference_result), user_data))\n\n \n except KeyError:\n # This error occurs when GetResult can't access the user param from the graph, we're just ignoring it for now\n print(\"KeyError\")\n pass\n except Exception as e:\n print(e)\n pass\n print(\"Output thread terminating\")"},"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 inference(self):\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].send(\"inference\")\n \n ## wait for the finalization to be completed\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].recv()","def serve_inference_requests():\n global image_queue\n\n with tf.Session() as sess:\n while True:\n image_data = image_queue.get()\n\n tensor = sess.graph.get_tensor_by_name('final_result:0')\n predictions = sess.run(tensor, {'DecodeJpeg/contents:0': image_data})\n predictions = np.squeeze(predictions)\n\n top_k = predictions.argsort()[-NUM_PREDICTIONS:][::-1]\n\n human_string = labels[top_k[0]]\n score = predictions[top_k[0]]\n logging.info('%s classified with score %.5f', human_string, score)\n\n emit_image = False\n if human_string != 'nothing':\n emit_image = True\n logging.debug('emitting image cause %s was detected', human_string)\n elif score <= config['inference']['threshold']:\n emit_image = True\n logging.debug('emitting image cause score %.5f is below threshold of %s',\n score, config['inference']['threshold'])\n else:\n logging.debug('image not emitted, cause nothing was detected with a probability of %.5f',\n score)\n\n if emit_image:\n mqtt_publish(image_data)\n else:\n save_image(image_data)","def postprocess(self, inference_output):\n logger.info(inference_output)\n return inference_output","def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None,goal='IC',save_path_dir=None): #b/c it is single, models_list contains one model only\n running_loss = 0.0\n \n# outputs_list = []\n# representations_list = []\n# labels_list = []\n# modality_list = []\n# indices_list = []\n# task_names_list = []\n# attn_coefs_list = []\n# sentence_lens_list = []\n# class_labels_list = []\n# class_predictions_list = []\n \n \"\"\" Initialize Dictionaries to Store Results \"\"\" \n outputs_dict = dict()\n representations_dict = dict()\n attn_coefs_dict = dict()\n labels_dict = dict()\n sentence_lens_dict = dict()\n class_labels_dict = dict()\n class_predictions_dict = dict()\n epoch_bleu = dict()\n epoch_rouge = dict()\n epoch_meteor = dict()\n\n for dest_lang in token2id_dict.keys():\n outputs_dict[dest_lang] = list()\n attn_coefs_dict[dest_lang] = list()\n representations_dict[dest_lang] = list()\n labels_dict[dest_lang] = list()\n sentence_lens_dict[dest_lang] = list()\n class_labels_dict[dest_lang] = list()\n class_predictions_dict[dest_lang] = list()\n epoch_bleu[dest_lang] = 0\n epoch_rouge[dest_lang] = 0\n epoch_meteor[dest_lang] = 0\n\n batch_num = 0\n batch = 0\n #class label is that in IC setting, but class label is answer in VQA setting\n for inputs, text_indices, sentence_lens, class_labels, languages, document_level_text_indices, document_level_sentence_lens in tqdm(dataloaders[phase]):\n \"\"\" Weaning Off of Teacher Forcing in a Linear Manner \"\"\"\n #sampling_prob = (0.4/30000)*(batch+1)*(epoch_count+1)\n #uniform_value = np.random.uniform(0,1)\n #sampling = True if uniform_value < sampling_prob else False\n sampling = False\n batch += 1\n \"\"\" Send Data to Device \"\"\"\n inputs = inputs.to(device)\n class_labels = class_labels.to(device)\n #print(text_indices)\n with torch.set_grad_enabled('train1' in phase):# and inference == False): #('train' in phase and inference == False)\n \"\"\" Image Captioning Path \"\"\"\n if goal == 'IC':\n \"\"\" Perform Forward Pass i.e. Encoder and Decoder \"\"\"\n current_labels_dict = dict() #text\n# current_class_labels_dict = dict()\n# current_class_predictions_dict = dict()\n current_outputs_dict = dict()\n# current_attn_coefs_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n outputs, representations = model(inputs,current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],dest_lang,phase,sampling,device) #outputs is B x S x Words\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n #current_text_indices = current_text_indices[:,1:] # B x (S-1)\n if phase == 'train1':\n attn_coefs = 5\n class_predictions = 6\n loss = calculate_IC_loss(criterion,outputs,current_text_indices[:,1:],class_predictions,class_labels,attn_coefs,auxiliary_loss,attn_loss)\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \"\"\" Store Results \"\"\"\n current_labels_dict[dest_lang] = current_text_indices[:,1:].cpu().detach().numpy()\n# current_class_labels_dict[dest_lang] = class_labels\n# current_class_predictions_dict[dest_lang] = class_predictions\n current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\n# current_attn_coefs_dict[dest_lang] = attn_coefs\n# current_representations_dict[dest_lang] = representations\n #\"\"\" Detach Outputs and Attn Coefs To Avoid Memory Leakage \"\"\"\n #outputs = outputs.detach()\n #attn_coefs = attn_coefs.detach()\n current_text_indices.detach()\n elif goal == 'VQA':\n \"\"\" Perform Forward Pass and Get Answers \"\"\"\n outputs, representations, attn_coefs, class_predictions = model(inputs,text_indices,sentence_lens,id2embedding_dict,phase,device)\n \"\"\" Calculate MSE Loss \"\"\"\n #criterion = nn.MSELoss()\n #class_labels = class_labels.type(torch.float)\n \"\"\" Calculate CrossEntropyLoss \"\"\"\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n #print(outputs,outputs.shape)\n loss = criterion(outputs,class_labels)\n elif goal == 'Supervised': #encoder supervised pre-training\n h, representations, class_predictions = model(inputs)#,text_indices,sentence_lens,id2embedding_dict,phase,device)\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n loss = criterion(class_predictions,class_labels)\n elif goal == 'Text_Supervised':\n #h, class_predictions = model.supervised_forward(text_indices,sentence_lens,token2id_dict,id2embedding_dict,phase,device)\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n class_predictions = model.supervised_forward(current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],phase,device)\n loss = criterion(class_predictions,class_labels)\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n\n current_class_labels_dict[dest_lang] = class_labels.cpu().detach().numpy()\n current_class_predictions_dict[dest_lang] = class_predictions.cpu().detach().numpy()\n# current_representations_dict[dest_lang] = h\n #loss = criterion(class_predictions,class_labels)\n #print(loss)\n elif goal == 'Language_Change_Detection':\n criterion = nn.BCEWithLogitsLoss()\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n \"\"\" Forward Pass \"\"\"\n replacement_predictions, replacement_labels = model.language_change_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\n #replacement_labels = replacement_labels.type(torch.float) #needed for BCELoss\n \"\"\" Instance-Wise Loss Because Each Sentence is of a Different Length \"\"\"\n loss = 0\n for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\n current_loss = criterion(replacement_prediction,replacement_label)\n loss = loss + current_loss\n if i == len(replacement_predictions)-1:\n loss = loss / len(replacement_predictions)\n #loss = torch.mean(torch.tensor([criterion(replacement_prediction,replacement_label) for replacement_prediction,replacement_label in zip(replacement_predictions,replacement_labels)]))\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n \"\"\" Store Representations and Labels \"\"\"\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\n# current_representations_dict[dest_lang] = h \n elif goal == 'Language_Detection':\n criterion = nn.CrossEntropyLoss(ignore_index=0)\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n \"\"\" Forward Pass \"\"\"\n replacement_predictions, replacement_labels = model.language_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\n #replacement_labels = replacement_labels.type(torch.long) #needed for CrossEntropyLoss\n \"\"\" Instance-Wise Loss Because Each Sentence is of a Different Length \"\"\"\n# loss = 0\n# for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\n# replacement_label = replacement_label.type(torch.long)\n# current_loss = criterion(replacement_prediction,replacement_label)\n# loss = loss + current_loss\n# if i == len(replacement_predictions)-1:\n# loss = loss / len(replacement_predictions)\n #print(replacement_predictions.shape,replacement_labels.shape)\n loss = criterion(replacement_predictions.permute(0,2,1),replacement_labels)\n #print(loss)\n total_loss = total_loss + loss\n #print(dest_lang,total_loss)\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n \"\"\" Store Representations and Labels \"\"\"\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\n# current_representations_dict[dest_lang] = h\n elif goal == 'MLM':\n criterion = nn.CrossEntropyLoss(reduction='none')\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n outputs, replacement_predictions = model.MLM_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device) #outputs is B x S x Words\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n \"\"\" Obtain Applicable Loss Locations (i.e., Where Token Was Masked) \"\"\"\n token_loss_mask = torch.where(replacement_predictions == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\n #print(outputs.shape)\n #if phase == 'train1':\n \"\"\" Obtain Each Token's Loss \"\"\"\n token_loss = criterion(outputs.permute(0,2,1),current_text_indices)\n \"\"\" Retrieve Only Relevant Losses (Masked) \"\"\"\n loss = torch.mean(token_loss.masked_select(token_loss_mask))\n \"\"\" Aggregate Loss Across Languages \"\"\"\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n del current_text_indices\n del token_loss\n del token_loss_mask\n# \"\"\" Store Results \"\"\"\n# current_labels_dict[dest_lang] = current_text_indices.cpu().detach().numpy()\n# current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\n elif goal == 'ELECTRA':\n generator_criterion = nn.CrossEntropyLoss(reduction='none')\n discriminator_criterion = nn.BCEWithLogitsLoss(reduction='none')\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Perform Forward Pass Through ELECTRA \"\"\"\n generator_outputs, generator_labels, discriminator_outputs, discriminator_labels = model.ELECTRA_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,sampling,device) #outputs is B x S x Words\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n \"\"\" Generator Loss Mask (i.e., Only Consider Originally Masked Tokens ) \"\"\"\n generator_token_loss_mask = torch.where(generator_labels == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\n \"\"\" Discrimiantor Loss Mask (i.e., Do Not Consider Padded Regions ) \"\"\"\n discriminator_labels = discriminator_labels.view_as(discriminator_outputs) \n discriminator_token_loss_mask = torch.ones_like(discriminator_labels)\n for i,sentence_len in zip(range(discriminator_token_loss_mask.shape[0]),current_sentence_lens):\n discriminator_token_loss_mask[i,sentence_len:] = 0\n \n #if phase == 'train1':\n \"\"\" Obtain Each Generator Token's Loss \"\"\"\n generator_token_loss = generator_criterion(generator_outputs.permute(0,2,1),current_text_indices) # B x S\n #print(generator_token_loss.shape,generator_token_loss_mask.shape)\n \"\"\" Retrieve Only Relevant Loss (Masked) \"\"\"\n generator_loss = torch.mean(generator_token_loss.masked_select(generator_token_loss_mask)) #scalar\n \n \"\"\" Obtain Each Discriminator Token's Loss \"\"\" \n discriminator_token_loss = discriminator_criterion(discriminator_outputs,discriminator_labels) # B x S\n #print(discriminator_token_loss.shape,discriminator_token_loss_mask.shape)\n \"\"\" Retrieve Only Relevant Loss (Masked) \"\"\"\n discriminator_loss = torch.mean(discriminator_token_loss.masked_select(discriminator_token_loss_mask.type(torch.bool))) #scalar\n \n #print(generator_loss,discriminator_loss)\n \"\"\" Aggregate Loss Across Languages \"\"\"\n total_loss = total_loss + generator_loss + discriminator_loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \"\"\" Store Results \"\"\"\n# current_labels_dict[dest_lang] = discriminator_labels.cpu().detach().numpy()\n# current_outputs_dict[dest_lang] = discriminator_outputs.cpu().detach().numpy() #text\n elif goal == 'MARGE':\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n #total_loss = 0\n #for (dest_lang,current_text_indices),current_sentence_lens,current_languages in zip(text_indices.items(),sentence_lens.values(),languages.values()): #, sorted_indices, attn_coefs, class_predictions\n \"\"\" Randomly Choose Target Lang for This Mini-Batch \"\"\"\n #lang_list = list(text_indices.keys())\n #target_lang = random.sample(lang_list,1).item()\n #target_lang = 'de' #option to change based on dataset (MUST CHANGE IN PAD COLLATE)\n outputs, target_lang = model(text_indices,sentence_lens,languages,document_level_text_indices,document_level_sentence_lens,token2id_dict,id2embedding_dict,phase,device)\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = text_indices[target_lang].to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n #if phase == 'train1':\n \"\"\" Obtain Each Token's Loss \"\"\"\n loss = criterion(outputs.permute(0,2,1),current_text_indices)\n #print(loss)\n #\"\"\" Aggregate Loss Across Languages \"\"\"\n #total_loss = total_loss + loss\n #\"\"\" Average Loss if This is Final Loss Collected \"\"\"\n #if dest_lang == list(text_indices.keys())[-1]:\n # loss = total_loss / len(text_indices)\n# print(loss)\n# \"\"\" Store Results \"\"\"\n# current_labels_dict[target_lang] = current_text_indices.cpu().detach().numpy()\n# current_outputs_dict[target_lang] = outputs.cpu().detach().numpy() #text\n \n\n \"\"\" Backpropagation and Update Step \"\"\"\n if phase == 'train1': #only perform backprop for train1 phase \n loss.backward()\n \n \"\"\" Network Parameters \"\"\"\n if isinstance(optimizer,tuple):\n optimizer[0].step()\n \"\"\" Task-Instance Parameters \"\"\"\n optimizer[1].step() \n optimizer[0].zero_grad()\n optimizer[1].zero_grad()\n else:\n optimizer.step()\n optimizer.zero_grad()\n \n \"\"\" Calculate Metrics \"\"\"\n if goal == 'IC':\n if phase == 'train1':\n running_loss += loss.item() * inputs.shape[0]\n elif goal == 'VQA':\n running_loss += loss.item() * inputs.shape[0] \n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\n running_loss += loss.item() * inputs.shape[0] \n \n# \"\"\" These Need to be Language Specific \"\"\"\n \n if goal in ['IC']:\n batch_bleu = calculate_bleu_score(current_outputs_dict,current_labels_dict,token2id_dict)\n batch_rouge = calculate_rouge_score(current_outputs_dict,current_labels_dict,token2id_dict)\n batch_meteor = calculate_meteor_score(current_outputs_dict,current_labels_dict,token2id_dict) \n \n for dest_lang in batch_bleu.keys():\n epoch_bleu[dest_lang] = epoch_bleu[dest_lang] + (1/batch)*(batch_bleu[dest_lang] - epoch_bleu[dest_lang])\n epoch_rouge[dest_lang] = epoch_rouge[dest_lang] + (1/batch)*(batch_rouge[dest_lang] - epoch_rouge[dest_lang])\n epoch_meteor[dest_lang] = epoch_meteor[dest_lang] + (1/batch)*(batch_meteor[dest_lang] - epoch_meteor[dest_lang])\n \n if phase in ['val']:\n for dest_lang in text_indices.keys():\n predicted_sentences = convert_predicted_ids_to_sentences(current_outputs_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\n target_sentences = convert_target_ids_to_sentences(current_labels_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\n outputs_dict[dest_lang].extend(predicted_sentences)\n labels_dict[dest_lang].extend(target_sentences)\n \n elif goal in ['Language_Change_Detection','Language_Detection']:\n for dest_lang in text_indices.keys():\n if goal in ['Language_Change_Detection','Language_Detection']:\n \"\"\" Store Batch Data in The Dictionaries \"\"\"\n class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\n class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\n \n# elif goal in ['Text_Supervised']:\n## current_class_labels = current_class_labels_dict[dest_lang]\n## current_class_predictions = current_class_predictions_dict[dest_lang]\n## current_class_labels = current_class_labels.cpu().detach().numpy()\n## current_class_predictions = current_class_predictions.cpu().detach().numpy()\n# \n# \"\"\" Store Batch Data in The Dictionaries \"\"\"\n# #sentence_lens_dict[dest_lang].extend(current_sentence_lens)\n# class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\n# class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\n#\n# elif goal in ['MARGE']:\n# labels_dict[target_lang].extend(current_labels_dict[target_lang]) #.cpu().detach().numpy())\n# outputs_dict[target_lang].extend(current_outputs_dict[target_lang]) #.cpu().detach().numpy())\n# break # because only one target language per minibatch \n# if goal not in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\n## if current_labels_dict[dest_lang].data.dtype != torch.long:\n## current_labels_dict[dest_lang].data = current_labels_dict[dest_lang].data.type(torch.long)\n# \n## current_text_indices = current_labels_dict[dest_lang]\n## current_outputs = current_outputs_dict[dest_lang]\n## current_attn_coefs = current_attn_coefs_dict[dest_lang]\n## current_representations = current_representations_dict[dest_lang]\n# \"\"\" Store Batch Data in The Dictionaries \"\"\" \n# labels_dict[dest_lang].extend(current_labels_dict[dest_lang]) #.cpu().detach().numpy())\n# outputs_dict[dest_lang].extend(current_outputs_dict[dest_lang]) #.cpu().detach().numpy())\n## attn_coefs_dict[dest_lang].extend(current_attn_coefs.cpu().detach().numpy())\n## representations_dict[dest_lang].extend(current_representations.cpu().detach().numpy())\n## elif goal in ['Text_Supervised']:\n## current_representations = current_representations_dict[dest_lang]\n## representations_dict[dest_lang].extend(current_representations.squeeze().cpu().detach().numpy()) \n## else:\n## current_representations = current_representations_dict[dest_lang]\n## if goal in ['Language_Change_Detection','Language_Detection']:\n## current_representations = [representations.cpu().detach().numpy() for representations in current_representations]\n## else:\n## current_representations = current_representations.cpu().detach().numpy()\n## representations_dict[dest_lang].extend(current_representations) \n# \n## modality_list.append(modality)\n## indices_list.append(indices)\n## task_names_list.append(task_names)\n \n batch_num += 1\n #if batch_num == 2:\n # break\n \n #outputs_list, labels_list, modality_list, indices_list, task_names_list, pids_list = flatten_arrays(outputs_list,labels_list,modality_list,indices_list,task_names_list,pids_list)\n if goal == 'IC':\n if phase == 'train1':\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\n else:\n epoch_loss = 0 #filler\n elif goal in ['VQA','Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\n epoch_loss = running_loss / len(dataloaders[phase].dataset) \n \n \"\"\" Removed Recently \"\"\"\n #representations_list = np.concatenate(representations_list)\n \n if goal == 'IC':\n \"\"\" BLEU Score Evaluation \"\"\"\n# epoch_bleu = calculate_bleu_score(outputs_dict,labels_dict,token2id_dict)\n# epoch_rouge = calculate_rouge_score(outputs_dict,labels_dict,token2id_dict)\n# epoch_meteor = calculate_meteor_score(outputs_dict,labels_dict,token2id_dict) \n return epoch_loss, epoch_bleu, epoch_rouge, epoch_meteor, outputs_dict, labels_dict #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal == 'VQA':\n \"\"\" Accuracy of Answers \"\"\"\n epoch_acc = calculate_answer_accuracy(outputs_dict,class_labels_dict)\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\n if goal in ['Language_Change_Detection','Language_Detection']:\n epoch_acc = calculate_language_detection_accuracy(class_predictions_dict,class_labels_dict,goal)\n else:\n \"\"\" Accuracy of Answers \"\"\"\n epoch_acc = calculate_answer_accuracy(class_predictions_dict,class_labels_dict)\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal in ['MLM','ELECTRA','MARGE']:\n return epoch_loss#, outputs_dict, labels_dict #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list","def infer():\n\n # Create StreamManagerApi object\n stream_manager_api = StreamManagerApi()\n # Use InitManager method init StreamManagerApi\n ret = stream_manager_api.InitManager()\n if ret != 0:\n print(\"Failed to init Stream manager, ret=%s\" % str(ret))\n exit()\n\n # create streams by pipeline config file\n with open(args.pipeline_path, \"rb\") as f:\n pipeline_str = f.read()\n\n # Configuring a stream\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\n if ret != 0:\n print(\"Failed to create Stream, ret=%s\" % str(ret))\n exit()\n\n # Construct the input of the stream\n data_input = MxDataInput()\n # Stream_name encoded in UTF-8\n stream_name = args.stream_name.encode()\n print(stream_name)\n predictions = []\n with open(args.label_path, 'rt') as f:\n val_cls = f.read().rstrip(\"\\n\").split(\"\\n\")\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(args.instances_path)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n for file_name in os.listdir(args.img_path):\n pred_data = []\n # Gets the Address of each image\n img_id = int(file_name.split('.')[0])\n file_path = args.img_path + file_name\n size = (cv2.imread(file_path)).shape\n\n # Read each photo in turn\n with open(file_path, \"rb\") as f:\n img_data = f.read()\n if not img_data:\n print(f\"read empty data from img:{file_name}\")\n continue\n # The element value img_data\n data_input.data = img_data\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\n pred_data.append({\"boxes\": boxes_output,\n \"box_scores\": scores_output,\n \"img_id\": img_id,\n \"image_shape\": size})\n\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\n print(f\"Inferred image:{file_name} success!\")\n\n # Save the result in JSON format\n if not os.path.exists(args.res_path):\n os.makedirs(args.res_path)\n with open(args.res_path + 'predictions_test.json', 'w') as f:\n json.dump(predictions, f)\n stream_manager_api.DestroyAllStreams()","def main():\n args, config = parse_args()\n\n \"\"\"\n Log on wandb for track of experiments\n \"\"\"\n wandb.init(project=\"adaptive-finetuning-resnet\", name=f'Inference_{config.VERSION}', config=config)\n\n \"\"\"\n Set config GPUs and torch cuda device\n \"\"\"\n config.GPUS = str(0)\n torch.cuda.set_device(0)\n\n \"\"\"\n Create the model, put it to GPU and then create dataloader\n \"\"\"\n model = eval(config.MODULE)(config=config.NETWORK)\n model = model.cuda()\n\n val_loader = make_dataloader(config, mode='val', distributed=False)\n\n \"\"\"\n Load the model with pretrained weights\n \"\"\"\n assert config.NETWORK.PRETRAINED_MODEL != '', \"For inference, there must be pre-trained weights\"\n\n pretrain_state_dict = torch.load(config.NETWORK.PRETRAINED_MODEL, map_location = lambda storage, loc: storage)['net_state_dict']\n smart_model_load(model, pretrain_state_dict, loading_method=config.NETWORK.PRETRAINED_LOADING_METHOD)\n\n \"\"\"\n Pass the model and val loader for validation\n \"\"\"\n print(\"Inference started!!\")\n val_accuracy = do_validation(config, model, val_loader)\n print(f\"Inference complete!!\\nAccuracy:{val_accuracy}\")\n\n wandb.log({'Accuracy': val_accuracy})","def thread_main(self, sess):\n for x_h, x_m, y in self.data_iterator():\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m})","def inference_end(self, inputs, results):\n return","def process_thread(self):","def thread_main(self, sess):\n for x_h, x_m, y in self.data_iterator():\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m, self.y:y})","def inference():\n inf_dataset = dataset\n net.eval()\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\n \n num_crop = args.test_crops\n length = 3\n if args.modality == 'Flow':\n length = 10\n elif args.modality == 'RGBDiff':\n length = 18\n \n # First get the base_out outputs\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\n volatile=True)\n cnt = 0\n for frames in frames_gen:\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\n # frame_batch_size is 4 by default\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\n volatile=True)\n base_out = net(input_var, None, None, None, None)\n bsc = base_out.view(num_crop, -1, base_out_dim)\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\n cnt += bsc.size(1)\n\n n_frames = base_output.size(1)\n assert frame_cnt == n_frames\n # GLCU\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\n gate, glcu_task_pred = net.glcu(step_features)\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\n if net.additive_glcu:\n base_output = base_output + gate\n else:\n base_output = base_output * gate\n\n # output.shape == [num_frames, 7791]\n output = torch.zeros((frame_cnt, output_dim)).cuda()\n cnt = 0\n for i in range(0, frame_cnt, 4):\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\n rst = net.test_fc(base_out)\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\n output[cnt: cnt + sc.size(0), :] = sc\n cnt += sc.size(0)\n base_output = base_output.mean(dim=0).data\n\n # act_scores.shape == [num_proposals, K+1]\n # comp_scores.shape == [num_proposals, K]\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\n\n # Task Head\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\n\n act_scores = act_scores.data\n comp_scores = comp_scores.data\n\n if reg_scores is not None:\n reg_scores = reg_scores.view(-1, num_class, 2)\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\n\n torch.cuda.empty_cache() # To empty the cache from previous iterations\n\n # perform stpp on scores\n return ((inf_dataset.video_list[index].id,\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \n glcu_task_pred, task_pred),\n output.cpu().numpy(),\n base_output.cpu().numpy()))","def get_inference_result(self, dataset_file: dir):\n tf.reset_default_graph()\n with tf.Graph().as_default():\n global_step = tf.contrib.framework.get_or_create_global_step()\n # global_step_tensor = tf.Variable(1, trainable=False, name='global_step')\n\n pic_batch, label_batch, enqueue_op, enq_image, enq_label, examples_in_queue = self.readOnTheFly()\n\n # logits, tiles = self.inference(pic_batch)\n logits = self.inference(pic_batch)\n\n \"\"\"\n label_batch_filtered = tf.boolean_mask(\n label_batch,\n tf.cast(label_batch[:,:,4], dtype=tf.bool))\n label_batch_filtered = tf.Print(label_batch_filtered, [label_batch_filtered], \"\\n\\nLABEL BATCH FILTERED: \", summarize=250)\n label_batch_filtered = tf.Print(label_batch_filtered, [label_batch], \"\\n\\nLABEL BATCH: \", summarize=250)\n \"\"\"\n number_of_boxes = tf.cast(tf.count_nonzero(label_batch[:, :, 4], 1), dtype=tf.int32)\n # number_of_boxes = tf.Print(number_of_boxes, [number_of_boxes], \"\\n\\nNumber of boxes: \",\n # summarize=10)\n self.network.loss, _ = self.loss(logits, label_batch, number_of_boxes)\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(extra_update_ops):\n self.network.train_op, grads = self.train(self.network.loss, global_step)\n\n coord = tf.train.Coordinator()\n\n samples_iter = get_samples()\n\n with tf.Session().as_default() as sess:\n sess.run(tf.local_variables_initializer())\n sess.run(tf.global_variables_initializer())\n # tf.train.global_step(sess, global_step_tensor)\n\n threads = []\n for i in range(self.num_of_preprocess_threads):\n # print(\"Creating thread %i\" % i)\n t = threading.Thread(target=load_preproc_enqueue_thread, args=(\n sess, coord, enqueue_op, enq_image, enq_label, samples_iter\n ))\n\n t.setDaemon(True)\n t.start()\n threads.append(t)\n coord.register_thread(t)\n time.sleep(0.5)\n\n num_examples_in_queue = sess.run(examples_in_queue)\n while num_examples_in_queue < self.min_queue_examples:\n num_examples_in_queue = sess.run(examples_in_queue)\n for t in threads:\n if not t.isAlive():\n coord.request_stop()\n raise ValueError(\"One or more enqueuing threads crashed...\")\n time.sleep(0.1)\n\n print(\"# of examples in queue: %i\" % num_examples_in_queue)\n\n # Create a coordinator and run all QueueRunner objects\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(coord=coord)\n\n last_time = time.time()\n saver = tf.train.Saver()\n # saver = tf.train.import_meta_graph(join(self..checkpoint_dir, \"my_model.meta\"))\n checkpoint_file = join(self.checkpoint_dir, \"my_model\")\n if isfile(join(self.checkpoint_dir, \"checkpoint\")):\n # saver.restore(sess,tf.train.latest_checkpoint(self.checkpoint_dir))\n optimistic_restore(sess, checkpoint_file)\n initialize_uninitialized_vars(sess)\n print(\"Model loaded.\")\n\n sum_writer = tf.summary.FileWriter(self.log_dir, graph=tf.get_default_graph())\n merged = tf.summary.merge_all()\n\n collected_grads = {g: g[1].name for g in grads if g[0] is not None}\n loss_result, logit_result, label_result, pic_result, collected_grad_result, _ = (\n sess.run([self.network.loss, logits, label_batch, pic_batch,\n collected_grads, self.network.train_op]))\n\n # return sess.run(list(collected_grads.keys())), list(collected_grads.values())\n\n coord.request_stop()\n coord.join(threads)\n\n return loss_result, logit_result, label_result, pic_result, collected_grad_result","def _inference_step(self, state):\n\n decoder_inputs = state[\"inputs\"]\n encoder_outputs = state[\"encoder_outputs\"]\n attention_bias = state[\"encoder_decoder_attention_bias\"]\n alignment_positions = state[\"alignment_positions\"]\n\n outputs = self._decode_pass(\n decoder_inputs=decoder_inputs,\n encoder_outputs=encoder_outputs,\n enc_dec_attention_bias=attention_bias,\n alignment_positions=alignment_positions\n )\n\n with tf.variable_scope(\"inference_step\"):\n next_inputs_mel = outputs[\"post_net_spec\"][:, -1:, :]\n next_inputs_mel = self._expand(next_inputs_mel, self.reduction_factor)\n next_inputs_mag = outputs[\"mag_spec\"][:, -1:, :]\n next_inputs_mag = self._expand(next_inputs_mag, self.reduction_factor)\n next_inputs = tf.concat([next_inputs_mel, next_inputs_mag], axis=-1)\n\n n_features = self.num_mels + self.num_freq\n next_inputs = self._shrink(next_inputs, n_features, self.reduction_factor)\n\n # Set zero if sequence is finished\n next_inputs = tf.where(\n state[\"finished\"],\n tf.zeros_like(next_inputs),\n next_inputs\n )\n next_inputs = tf.concat([decoder_inputs, next_inputs], 1)\n\n # Update lengths\n lengths = state[\"outputs\"][\"lengths\"]\n lengths = tf.where(\n state[\"finished\"],\n lengths,\n lengths + 1 * self.reduction_factor\n )\n outputs[\"lengths\"] = lengths\n\n # Update spec, post_net_spec and mag_spec\n for key in [\"spec\", \"post_net_spec\", \"mag_spec\"]:\n output = outputs[key][:, -1:, :]\n output = tf.where(state[\"finished\"], tf.zeros_like(output), output)\n outputs[key] = tf.concat([state[\"outputs\"][key], output], 1)\n\n # Update stop token logits\n stop_token_logits = outputs[\"stop_token_logits\"][:, -1:, :]\n stop_token_logits = tf.where(\n state[\"finished\"],\n tf.zeros_like(stop_token_logits) + 1e9,\n stop_token_logits\n )\n stop_prediction = tf.sigmoid(stop_token_logits)\n stop_prediction = tf.reduce_max(stop_prediction, axis=-1)\n\n # Uncomment next line if you want to use stop token predictions\n finished = tf.reshape(tf.cast(tf.round(stop_prediction), tf.bool), [-1])\n finished = tf.reshape(finished, [-1])\n\n stop_token_logits = tf.concat(\n [state[\"outputs\"][\"stop_token_logits\"], stop_token_logits],\n axis=1\n )\n outputs[\"stop_token_logits\"] = stop_token_logits\n\n with tf.variable_scope(\"alignments\"):\n weights = []\n for index, attention in enumerate(self.attentions):\n if isinstance(attention, AttentionBlock):\n weights.append(attention.multiheaded_attention.attention_weights)\n\n weights = tf.stack(weights)\n outputs[\"alignments\"] = [weights]\n\n alignment_positions = tf.argmax(\n weights,\n axis=-1,\n output_type=tf.int32\n )[:, :, :, -1:]\n state[\"alignment_positions\"] = tf.concat(\n [state[\"alignment_positions\"], alignment_positions],\n axis=-1\n )\n\n state[\"iteration\"] = state[\"iteration\"] + 1\n state[\"inputs\"] = next_inputs\n state[\"finished\"] = finished\n state[\"outputs\"] = outputs\n\n return state","def infer_on_stream(args, client):\n count_current = 0\n count_last = 0\n count_last_last = 0\n total_count = 0\n duration = 0\n avg_duration = 0\n total_duration = 0\n start_time = 0\n active_person = 0\n net_input_shape = []\n frame_count = 0\n\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.load_model(model=args.model, device=args.device, cpu_extension=args.cpu_extension)\n\n ### TODO: Handle the input stream ###\n cap = cv2.VideoCapture(args.input)\n cap.open(args.input)\n\n # get the required shape for the network\n net_input_shape = infer_network.get_input_shape()\n\n # get the shape of the input image\n width = int(cap.get(3))\n height = int(cap.get(4))\n\n if net_input_shape != [1, 3, 600, 600]:\n #net_input_shape = [1, 3, 600, 600]\n #sometimes gives [1,3] and causes an error, so hard coded shape to match model\n sys.exit(\"Input shape error, forced exit. Please run again until this error does not appear.\")\n\n ### TODO: Loop until stream is over ###\n while cap.isOpened():\n\n ### TODO: Read from the video capture ###\n flag, frame = cap.read()\n frame_count += 1\n\n if not flag:\n #video stream ended, go to end and close out\n break\n\n ### TODO: Start asynchronous inference for specified request ###\n if frame_count%2 == 0: #check every other frame\n ### TODO: Pre-process the image as needed ###\n vid_frame = cv2.resize(frame, (net_input_shape[3], net_input_shape[2]))\n #save a copy of the input frame to use on output\n vid_frame_copy = vid_frame\n vid_frame = vid_frame.transpose((2, 0, 1))\n vid_frame = vid_frame.reshape(1, *vid_frame.shape)\n\n infer_network.exec_net(vid_frame)\n\n ### TODO: Wait for the result ###\n if infer_network.wait() == 0:\n\n ### TODO: Get the results of the inference request ###\n results = infer_network.get_output()\n\n # for this model, results should be shape [1, 1, N, 7]\n # N is number of hits, last is a 7 item list [image_id, label, conf, x_min,\n # y_min, x_max, y_max] where label is the predicted class\n\n ### TODO: Extract any desired stats from the results ###\n out_frame, count_current, box = draw_boxes(vid_frame_copy, results, args, net_input_shape[3], net_input_shape[2])\n #out_frame = cv2.putText(out_frame, \"Last Frame Analyzed = \"+str(frame_count), (10, 420), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\n\n ### TODO: Calculate and send relevant information on ###\n ### count_current, total_count and duration to the MQTT server ###\n ### Topic \"person\": keys of \"count\" and \"total\" ###\n ### Topic \"person/duration\": key of \"duration\" ###\n\n # This block of code from Mentor Help question 129845, some modifications by me\n # If both last and last_last are equal, positive ID for two frames.\n if count_current > count_last and count_last_last == count_last:\n start_time = time.time()\n total_count = total_count + count_current - count_last\n\n #client.publish(\"person\", json.dumps({\"total\": total_count}))\n client.publish(\"person\", json.dumps({\"count\": count_current}))\n\n #out_frame = cv2.putText(out_frame, \"Current Time = \"+str('% 6.2f' % time.time()), (10, 450), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\n out_frame = cv2.putText(out_frame, \"Person Entered Frame = \"+str(count_current), (10, 510), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\n out_frame = cv2.putText(out_frame, \"Total Counted = \"+str(total_count), (10, 540), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\n\n # Person duration in the video is calculated if two frames of no detect to account for skipped frame\n if count_current < count_last_last and count_last < count_last_last:\n duration = int(time.time() - start_time)\n total_duration += duration / 11 #frames per second and evaluating only every other frame\n avg_duration = int(total_duration / total_count)\n client.publish(\"person/duration\", json.dumps({\"duration\": avg_duration}))\n\n #out_frame = cv2.putText(out_frame, \"Duration = \"+str('% 6.2f' % duration), (10, 540), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\n out_frame = cv2.putText(out_frame, \"Average Duration = \" + str('% 4.2f' % avg_duration) + \" seconds.\", (10, 570), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\n\n # Set a double counter to review two frames at a time\n count_last_last = count_last\n count_last = count_current\n #End block of code from Mentor Help question 129845\n\n\n ### TODO: Send the frame to the FFMPEG server ###\n out_frame = out_frame.copy(order='C')\n out_frame = cv2.resize(out_frame, (width, height))\n np.ascontiguousarray(out_frame, dtype=np.float32)\n sys.stdout.buffer.write(out_frame)\n sys.stdout.flush()\n\n ### TODO: Write an output image if `single_image_mode` ###\n\n #Release the capture and destroy any OpenCV windows\n cap.release()\n cv2.destroyAllWindows()\n\n #Disconnect from MQTT\n client.disconnect()\n\n #Print final numbers for reference\n print(\"Video stream ended.\")\n print(\"Final count was \" + str(total_count))\n print(\"Average Duration was \" + str(avg_duration) + \" seconds.\")","def parallel_run():\n from IPython.parallel import Client\n\n c = Client() # here is where the client establishes the connection\n lv = c.load_balanced_view() # this object represents the engines (workers)\n\n\n rays = []\n maxs=25\n bounding = AABA(xmin=0, ymin=0, zmin=0, xmax=maxs, ymax=maxs, zmax=maxs,)\n gridd = np.zeros((maxs,maxs,maxs))\n # spectrum for red to nir leaves\n red_nir_leaves = spectrum(np.array([0.5, 0.85]), np.array([0.1, 0.6]), np.array([0.5, 0.1]))\n # spectrum for soil\n red_nir_soil = spectrum(np.array([0.5, 0.85]), np.array([0.3, 0.4]), np.array([0.0, 0.0]))\n\n\n # scattering setup\n scatt = BRDSF(red_nir_leaves, 0.0)\n lf = leaf(55.0, 0.8) # leaf angle distribution and leaf area density\n\n\n tasks = []\n for x in xrange(maxs):\n for y in xrange(maxs):\n tasks.append(lv.apply(prun, x,y, maxs, gridd, scatt, red_nir_soil, bounding, lf))\n\n result = [task.get() for task in tasks] # blocks until all results are back\n\n return results","def _do_infer(stream_manager_api, data_input):\n stream_name = b'segmentation'\n unique_id = stream_manager_api.SendData(\n stream_name, 0, data_input)\n if unique_id < 0:\n raise RuntimeError(\"Failed to send data to stream.\")\n\n keys = [b\"mxpi_tensorinfer0\"]\n keyVec = StringVector()\n for key in keys:\n keyVec.push_back(key)\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\n print(infer_result)\n if infer_result.size() == 0:\n print(\"infer_result is null\")\n exit()\n\n TensorList = MxpiDataType.MxpiTensorPackageList()\n TensorList.ParseFromString(infer_result[0].messageBuf)\n data = np.frombuffer(\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\n data = data.reshape(1, 19, 1024, 2048)\n return data","def single_inference_process_fn(inference_initializer, inference_mode_config, in_project_meta_json, request_queue,\n result_meta_queue, progress_queue, project):\n single_image_inference = inference_initializer()\n inference_mode = InferenceModeFactory.create(\n inference_mode_config, ProjectMeta.from_json(in_project_meta_json), single_image_inference)\n\n project_meta_sent = False\n req = ''\n while req is not None:\n req = request_queue.get()\n if req is not None:\n # Send the resulting project meta to the parent project to make sure we only write the meta JSON once.\n if not project_meta_sent:\n try:\n result_meta_queue.put(inference_mode.out_meta.to_json(), block=False)\n except queue.Full:\n pass\n project_meta_sent = True\n\n in_ann = Annotation.load_json_file(req.item_paths.ann_path, inference_mode.out_meta)\n ann = inference_mode.infer_annotate_image_file(req.item_paths.img_path, in_ann)\n out_dataset = project.datasets.get(req.ds_name)\n out_dataset.add_item_file(\n req.item_name, req.item_paths.img_path, ann=ann, _validate_item=False, _use_hardlink=True)\n progress_queue.put(1)","def create_inference_tasks(task_queue, image_layer_path, convnet_path, \n mask_layer_path, output_layer_path, output_block_start, output_block_size, \n grid_size, patch_size, patch_overlap, cropping_margin_size,\n output_key='output', num_output_channels=3, \n image_mip=1, output_mip=1, mask_mip=3):\n for z in tqdm(range(grid_size[0]), desc='z loop'):\n for y in range(grid_size[1]):\n for x in range(grid_size[2]):\n output_offset = tuple(s+x*b for (s, x, b) in \n zip(output_block_start, (z, y, x), \n output_block_size))\n task = InferenceTask(\n image_layer_path=image_layer_path,\n convnet_path=convnet_path,\n mask_layer_path=mask_layer_path,\n output_layer_path=output_layer_path,\n output_offset=output_offset,\n output_shape=output_block_size,\n patch_size=patch_size, \n patch_overlap=patch_overlap,\n cropping_margin_size=cropping_margin_size,\n output_key=output_key,\n num_output_channels=num_output_channels,\n image_mip=image_mip,\n output_mip=output_mip,\n mask_mip=mask_mip\n )\n task_queue.insert(task)\n task_queue.wait('Uploading InferenceTasks')\n\n vol = CloudVolume(output_layer_path, mip=output_mip)\n vol.provenance.processing.append({\n 'method': {\n 'task': 'InferenceTask',\n 'image_layer_path': image_layer_path,\n 'convnet_path': convnet_path,\n 'mask_layer_path': mask_layer_path,\n 'output_layer_path': output_layer_path,\n 'output_offset': output_offset,\n 'output_shape': output_block_size,\n 'patch_size': patch_size,\n 'patch_overlap': patch_overlap,\n 'cropping_margin_size': cropping_margin_size,\n 'output_key': output_key,\n 'num_output_channels': num_output_channels,\n 'image_mip': image_mip,\n 'output_mip': output_mip,\n 'mask_mip': mask_mip,\n },\n 'by': OPERATOR_CONTACT,\n 'date': strftime('%Y-%m-%d %H:%M %Z'),\n })\n vol.commit_provenance()","def greengrass_infinite_infer_run():\n try:\n model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width = init_greengrass()\n # Do inference until the lambda is killed.\n \n while True:\n t2 = Thread(target = upload_image)\n t1 = Thread(target = capture_img, args=[model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width])\n t1.start()\n t2.start()\n t1.join()\n t2.join()\n # capture_img(model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width)\n except Exception as ex:\n client.publish(topic=iot_topic, payload='Error in face detection lambda: {}'.format(ex))","def worker_train():\n #py_work = np.zeros(model.layer1_size, dtype=np.float32)\n\n while True:\n job = jobs.get(block=True)\n if job is None: # data finished, exit\n jobs.task_done()\n # print('thread %s break' % threading.current_thread().name)\n break\n \n #log.info(\"thread start!\")\n #lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\n lr = self.lr \n job_words = 0\n #pre=self.build_model(len(model.vocab), model.layer1_size, lamda = 0.0, learning_rate=lr)\n x1 = []\n x2 = []\n y = []\n #cur = 0\n for edge in job:\n if edge is not None:\n #cur+=1\n #if cur % 100 == 0:\n # log.info(\"edge[0].index = {}\".format(edge[0].index))\n #x.append([edge[0].index, edge[1].index)\n edge_0_emb = np.sum([G[model.vocab_t[edge[0].index]][nodeid]['weight'] *\n model.node_embedding[model.vocab[nodeid].index] \n for nodeid in G[model.vocab_t[edge[0].index]]], axis=0)\n #edge_0_emb = model.node_embedding[edge[0].index] \n edge_1_emb = np.sum([G[model.vocab_t[edge[1].index]][nodeid]['weight'] *\n model.node_embedding[model.vocab[nodeid].index] \n for nodeid in G[model.vocab_t[edge[1].index]]], axis=0)\n #edge_1_emb = model.node_embedding[edge[1].index]\n x1.append(edge_0_emb)\n #print(\"edge[0].index = \", edge[0].index)\n #print(\"0 nebor g = \", [nodeid for nodeid in G[model.vocab_t[edge[0].index]]])\n #print(\"edge[1].index = \", edge[1].index)\n #print(\"1 nebor g = \", [nodeid for nodeid in G[model.vocab_t[edge[1].index]]])\n #print(\"model.vocab_t = \", model.vocab_t)\n x2.append(edge_1_emb)\n \n #print(\"1 nebor g = \", G[model.vocab_t[edge[1].index]])\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n #y.append(weight)\n y.append(1.0)\n #for i in range(int(10 * (weight)) * self.negative):\n for i in range(self.negative):\n nodeidx = model.table[np.random.randint(model.table_size - 1)]\n if nodeidx != edge[0].index and \\\n (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[0].index]]\n or (model.connected_path[model.vocab_t[edge[0].index]][model.vocab_t[nodeidx]][0] < 0.1)):\n x1.append(edge_0_emb)\n x2.append(np.sum([G[model.vocab_t[nodeidx]][nodeid]['weight'] *\n model.node_embedding[model.vocab[nodeid].index] \n for nodeid in G[model.vocab_t[nodeidx]]], axis=0)\n )\n #x2.append(model.node_embedding[nodeidx]) \n y.append(0.0)\n else:\n i -= 1\n if nodeidx != edge[1].index and \\\n (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[1].index]]\n or (model.connected_path[model.vocab_t[edge[1].index]][model.vocab_t[nodeidx]][0] < 0.1)):\n x1.append(edge_1_emb)\n x2.append(np.sum([G[model.vocab_t[nodeidx]][nodeid]['weight'] *\n model.node_embedding[model.vocab[nodeid].index] \n for nodeid in G[model.vocab_t[nodeidx]]], axis=0)\n )\n #x2.append(model.node_embedding[nodeidx]) \n y.append(0.0)\n else:\n i-=1\n #log.info(\"edge end!\")\n #print(\"model.node_embedding = \", model.node_embedding)\n \n #for i in range(1):\n # feed_dict = {\n # pre.x1: x1,\n # pre.x2: x2,\n # pre.y: y,\n # pre.w2_init: model.w2\n # }\n #saver = tf.train.Saver()\n #print(\"model.w2 = \", model.w2)\n #_, loss, node_embeddings, w2 = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings, pre.w2],\n #_, loss, w2, mut, mut_ori = sess.run([pre.d_updates, pre.reg_loss, pre.w2, pre.mut, pre.mut_ori],\n # feed_dict=feed_dict)\n #log.info(\"iter = {}, loss = {}\".format(i, loss))\n #if i == loop - 1:\n # print(\"y = \", y)\n # print(\"mut = \", mut)\n # print(\"w2.T = \", w2.T)\n #print(\"mut_ori = \", mut_ori)\n #loop = 10\n #for i in range(loop):\n # for node in G.nodes():\n # #node_emb = tf.nn.embedding_lookup(self.node_embeddings, model.vocab[node])\n # tmp = np.zeros(model.layer1_size, dtype=np.float32)\n # for nnodeid in G[node]:\n # nodeidx = model.vocab[nnodeid].index\n # #print(\"nodeidx = \", nodeidx)\n # tmp = tmp + model.node_embedding[nodeidx]\n # #model.node_embedding[model.vocab[node].index] = np.maximum(0, np.matmul(tmp, w2.T))\n # #model.node_embedding[model.vocab[node].index] = np.exp(np.matmul(tmp, w2.T))\n # model.node_embedding[model.vocab[node].index] = np.matmul(tmp, w2.T)\n # #e_x = np.exp(np.matmul(tmp, w2.T) - np.max(np.matmul(tmp, w2.T)))\n # #model.node_embedding[model.vocab[node].index] = e_x / e_x.sum()\n # #model.node_embedding = node_embeddings\n #print(\"model.node_embedding_next = \", model.node_embedding)\n #model.w2 = w2\n #print(\"model.w2_next = \", model.w2)\n #x = []\n #y = []\n #x.append([edge[1].index, edge[0].index])\n #weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n #y.append(weight)\n #y.append(1.0)\n #for i in range(self.negative):\n # nodeidx = model.table[np.random.randint(model.table_size)]\n # if edge[1].index != nodeidx:\n # x.append([edge[1].index, nodeidx])\n # y.append(0.0)\n #feed_dict = {\n # pre.x: x,\n # pre.y: y,\n # pre.node_embeddings_init: model.node_embedding\n #}\n \n #saver = tf.train.Saver()\n #_, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\n # feed_dict=feed_dict)\n\n #model.node_embedding = node_embeddings\n #model.node_embedding[edge[1].index] = node_embeddings[edge[1].index]\n #log.info(\"thread end!\")\n job_words += len(y)\n \n #log.info(\"train_loss: {}, node_embeddings = {}\".format(loss, model.node_embedding))\n \n #saver.restore(sess, INNER_MODEL_FILE)\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\n #job_words = len(x)\n #log.info(\"train_jobs put!\")\n #log.info(\"train_jobs_full = {}\".format(train_jobs.full()))\n train_jobs.put([x1, x2, y])\n #train_jobs.put([x1, x2, y], block=False)\n #log.info(\"train_jobs put end!\")\n jobs.task_done()\n lock.acquire(timeout=30)\n try:\n node_count[0] += job_words\n\n elapsed = time.time() - start\n if elapsed >= next_report[0]:\n log.info(\"PROGRESS: at %.2f%% \\tnode_computed %d\\talpha %.05f\\t %.0f nodes/s\" %\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\n #log.info(\"jobs.qsize() = {}, train_jobs.qsize() = {}\".format(jobs.qsize(), train_jobs.qsize()))\n #train_jobs.put([x1, x2, y])\n finally:\n lock.release()","def main():\n args = get_arguments()\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n\n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(\n args.data_dir,\n args.data_list,\n None, # No defined input size.\n False, # No random scale.\n False, # No random mirror.\n args.ignore_label,\n IMG_MEAN,\n coord)\n image, label = reader.image, reader.label\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\n\n # Create network.\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\n\n # Which variables to load.\n restore_var = tf.global_variables()\n\n # Predictions.\n raw_output = net.layers['fc1_voc12']\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\n #raw_output = tf.argmax(raw_output, dimension=3)\n #pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\n pred = raw_output\n\n # Set up TF session and initialize variables.\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n\n sess.run(init)\n sess.run(tf.local_variables_initializer())\n\n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if args.restore_from is not None:\n load(loader, sess, args.restore_from)\n\n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n\n with open(args.data_list) as f:\n content = f.readlines()\n\n content = [x.strip() for x in content]\n\n\n \n for index, value in enumerate(content):\n print(\"outputting \"+str(index))\n \timg = tf.image.decode_png(tf.read_file(value.split()[0]), channels=3)\n raw_img = misc.imread(value.split()[0])\n print(type(raw_img))\n \t# Convert RGB to BGR.\n \timg_r, img_g, img_b = tf.split(axis=2, num_or_size_splits=3, value=img)\n \timg = tf.cast(tf.concat(axis=2, values=[img_b, img_g, img_r]), dtype=tf.float32)\n \t# Extract mean.\n \timg -= IMG_MEAN \n \t# Predictions.\n \traw_output = net.layers['fc1_voc12']\n\n \traw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(img)[0:2,])\n \t#pred = raw_output_up\n probabilities = tf.nn.softmax(raw_output_up)\n pred = tf.argmax(raw_output_up, dimension=3)\n \tpred = tf.expand_dims(pred, dim=3)\n \t# Perform inference.\n \tpreds, probs = sess.run([pred, probabilities])\n print(preds.shape)\n print(probs.shape)\n print(\"probs\")\n print(probs)\n softmax = probs[0, :, :, :]\n print(\"softmax\")\n print(softmax)\n print(softmax.shape)\n print(type(softmax))\n processed_probabilities = softmax.transpose((2, 0, 1))\n print(processed_probabilities.shape)\n print(type(processed_probabilities))\n crf_processed = performCRF(processed_probabilities, raw_img)\n\n im_preds = Image.fromarray(np.uint8(preds[0, :, :, 0]))\n\n print(\"preds shape\", preds.shape)\n \tmsk = decode_labels(preds, num_classes=args.num_classes)\n \tim = Image.fromarray(msk[0])\n\n print(\"crf_processed shape\", crf_processed.shape)\n crf_processed = crf_processed.reshape(1, crf_processed.shape[0], crf_processed.shape[1], 1)\n msk_crf = decode_labels(crf_processed, num_classes=args.num_classes)\n im_crf = Image.fromarray(msk_crf[0])\n\n \tif not os.path.exists(args.save_dir):\n os.makedirs(args.save_dir)\n #im_preds.save(args.save_dir +str(index).zfill(8) +'_predlabels_'+args.train_set+'.png')\n \tim.save(args.save_dir +str(index).zfill(8) +'_pred_'+args.train_set+'.png')\n im_crf.save(args.save_dir +str(index).zfill(8) +'_predcrf_'+args.train_set+'.png')","def _process(self):\n while True:\n with Timer() as data_timer:\n frame = self._frames_q.get()\n\n with Timer() as agent_timer:\n s, frame_metadata = self._unwrap_frame(frame)\n s = np.expand_dims(s, 0) # batch\n act = self.pred(s)[0][0].argmax()\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\n\n print('.', end='', flush=True)\n if self.verbose:\n print('Avg data wait time: %.3f' % data_timer.time())\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())","def inference(self, uInput):\n self.expose(uInput)\n for m in range(len(self.layers) - 1):\n self.layers[m].inference()\n self.propagate(m, m + 1)\n\n ## make inference on the output node\n self.layers[-1].pipes[0][0].send(\"inference\")\n self.layers[-1].pipes[0][0].recv()\n\n ## read its output\n self.layers[-1].pipes[0][0].send(\"get_output\")\n msg = self.layers[-1].pipes[0][0].recv()\n\n t = msg[1]['dtype']\n s = msg[1]['shape']\n output = recv_array(self.layers[-1].pipes[0][0], t, s)\n\n return output","def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.load_model(model=args.model,\n device=args.device,\n cpu_extension=args.cpu_extension)\n\n net_input_shape = infer_network.get_input_shape()\n\n ### TODO: Handle the input stream ###\n\n ### Handle image, video or webcam\n image_flag = False\n # Check if the input is a webcam\n if args.input == 'CAM':\n args.input = 0\n # Checks if the input is an image\n elif args.input.endswith('.jpg') or args.input.endswith('.bmp'):\n image_flag = True\n # else assume input is vedio file\n\n # Get and open video capture\n cap = cv2.VideoCapture(args.input)\n if args.input:\n cap.open(args.input)\n\n # Grab the shape of the input\n width = int(cap.get(3))\n height = int(cap.get(4))\n\n # iniatilize variables\n count_total = 0\n count_prev = 0\n count_curr = 0\n duration_curr = 0\n duration_prev = 0\n duration_total= 0\n frame_time = 0\n frame_count = 0\n timer_curr_start = 0\n request_id = 0\n\n ### TODO: Loop until stream is over ###\n while cap.isOpened():\n\n ### TODO: Read from the video capture ###\n flag, frame = cap.read()\n if not flag:\n break\n key_pressed = cv2.waitKey(60)\n\n\n ### TODO: Pre-process the image as needed ###\n p_frame = cv2.resize(frame, (net_input_shape[3], net_input_shape[2]))\n # Update layout\n p_frame = p_frame.transpose((2,0,1))\n p_frame = p_frame.reshape(1, *p_frame.shape)\n\n ### TODO: Start asynchronous inference for specified request ###\n timer_infer_start = time.time()\n infer_network.exec_net(p_frame, request_id)\n\n ### TODO: Wait for the result ###\n if infer_network.wait(request_id) == 0:\n\n ### TODO: Get the results of the inference request ###\n timer_infer_delay = time.time() - timer_infer_start\n result = infer_network.get_output(request_id)\n\n\n ### TODO: Extract any desired stats from the results ###\n\n # Draw bounding box\n conf = result[0, 0, :, 2]\n count_curr = 0\n for i, c in enumerate(conf):\n if c > prob_threshold:\n rect_box = result[0, 0, i, 3:]\n min_x = int(rect_box[0] * width)\n min_y = int(rect_box[1] * height)\n max_x = int(rect_box[2] * width)\n max_y = int(rect_box[3] * height)\n frame = cv2.rectangle(frame, (min_x, min_y), (max_x, max_y), (255,0, 0), 1)\n count_curr = count_curr + 1\n\n ### TODO: Calculate and send relevant information on ###\n\n ### current_count, total_count and duration to the MQTT server ###\n ### Topic \"person\": keys of \"count\" and \"total\" ###\n ### Topic \"person/duration\": key of \"duration\" ###\n\n # IF new person comes inside imapge\n if count_curr > count_prev:\n timer_curr_start = time.time()\n count_total = count_total + count_curr - count_prev\n client.publish('person', payload=json.dumps({'total': count_total}))\n\n # Calc Person Duration\n if count_curr < count_prev:\n timer_curr_delay = time.time() - timer_curr_start\n client.publish('person/duration', payload=json.dumps({'duration': timer_curr_delay}))\n\n # Write out information\n text_infer = \"Inference Delay: {:.3f}ms\".format(timer_infer_delay * 1000)\n text_counter = \"Current Counter: {}\".format(count_curr)\n cv2.putText(frame, text_infer, (10, 15),\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 0, 0), 1)\n cv2.putText(frame, text_counter, (10, 30),\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1)\n\n if count_curr > 0:\n text_duration = \"Current Duration: {:.1f}s\".format(time.time() - timer_curr_start)\n cv2.putText(frame, text_duration, (10, 45),\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\n\n count_prev = count_curr\n client.publish(\"person\", json.dumps({\"count\": count_curr}))\n\n\n ### TODO: Send the frame to the FFMPEG server ###\n sys.stdout.buffer.write(frame)\n sys.stdout.flush()\n # Break if escape key pressed\n if key_pressed == 27:\n break\n\n ### TODO: Write an output image if `single_image_mode` ###\n\n # Release the capture and destroy any OpenCV windows\n cap.release()\n cv2.destroyAllWindows()\n client.disconnect()","def postprocess(self,graph_output):\n (w,h,f) = self.rawinputformat()\n #print(w,h)\n #print(graph_output.shape)\n results = self.interpret_output(graph_output.astype(numpy.float32), w, h)\n print(results)\n #order = graph_output.argsort()\n #last = len(self.categories)-1\n #res = NcsResult();\n #print(len(results))\n #for i in range(0,len(results)):\n # res = results[i]\n #res.add( self.categories[order[last-i]], ( graph_output[order[last-i]] ) )\n return res\n\n # YOLO stuff","def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.exec_network = infer_network.load_model\\\n (args.model, args.device, args.cpu_extension)\n # extract information about model input layer\n (b, c, input_height, input_width) = infer_network.get_input_shape()\n\n ### TODO: Handle the input stream ###\n # extenstion of input file\n input_extension = os.path.splitext(args.input)[1].lower()\n supported_vid_exts = ['.mp4', '.mpeg', '.avi', '.mkv']\n supported_img_exts = [\".bmp\",\".dib\", \".jpeg\", \".jp2\", \".jpg\", \".jpe\",\\\n \".png\", \".pbm\", \".pgm\", \".ppm\", \".sr\", \".ras\", \".tiff\", \".tif\"]\n single_image_mode = False\n # if input is camera\n if args.input.upper() == 'CAM':\n capture = cv2.VideoCapture(0)\n \n # if input is video\n elif input_extension in supported_vid_exts:\n capture = cv2.VideoCapture(args.input)\n \n # if input is image\n elif input_extension in supported_img_exts:\n single_image_mode = True\n capture = cv2.VideoCapture(args.input) \n capture.open(args.input)\n else:\n sys.exit(\"FATAL ERROR : The format of your input file is not supported\" \\\n \"\\nsupported extensions are : \" + \", \".join(supported_exts))\n prev_count = 0\n total_persons = 0\n ### TODO: Loop until stream is over ###\n while (capture.isOpened()):\n ### TODO: Read from the video capture ###\n ret, frame = capture.read()\n if not ret:\n break\n ### TODO: Pre-process the image as needed ###\n image = preprocessing(frame, input_width, input_height)\n ### TODO: Start asynchronous inference for specified request ###\n start_time = time.time()\n # run inference\n infer_network.exec_net(image)\n ### TODO: Wait for the result ###\n if infer_network.wait() == 0:\n infer_time = time.time() - start_time\n ### TODO: Get the results of the inference request ###\n outputs = infer_network.get_output()[0][0]\n ### Take model output and extract number of detections with confidence exceeding threshold\n ### and draw bounding boxes around detections\n out_image, current_count = apply_threshold(outputs, frame, prob_threshold)\n \n # show inference time on image\n cv2.putText(out_image, \"inference time: {:.5f} ms\".format(infer_time), (30, 30),\\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\n \n ### TODO: Extract any desired stats from the results ###\n # when any person exit\n if current_count < prev_count:\n ### Topic \"person/duration\": key of \"duration\" ###\n # send duration to mqtt server client\n client.publish(\"person/duration\", json.dumps({\"duration\": time.time() - p_start}))\n\n # when new person enters\n if current_count > prev_count:\n total_persons += current_count - prev_count\n p_start = time.time()\n \n prev_count = current_count\n \n ### TODO: Calculate and send relevant information on ###\n ### current_count, total_count and duration to the MQTT server ###\n ### Topic \"person\": keys of \"count\" and \"total\" ###\n client.publish(\"person\", json.dumps({\"count\": current_count,\"total\": total_persons}))\n ### TODO: Send the frame to the FFMPEG server ###\n sys.stdout.buffer.write(out_image)\n sys.stdout.buffer.flush()\n ### TODO: Write an output image if `single_image_mode` ###\n if single_image_mode:\n cv2.imwrite(\"output_frame.png\", out_image)\n # release resources\n capture.release()\n cv2.destroyAllWindows()\n client.disconnect()\n del infer_network","def async_infer(self, data, req_id):\n\n input_data = {self.input_tensor_name: data}\n self.infer_queue.start_async(input_data, req_id)","def infinite_infer_run():\n try:\n # This cat-dog model is implemented as binary classifier, since the number\n # of labels is small, create a dictionary that converts the machine\n # labels to human readable labels.\n model_type = 'classification'\n output_map = {0: 'dog', 1: 'cat'}\n\n # Create an IoT client for sending to messages to the cloud.\n client = greengrasssdk.client('iot-data')\n iot_topic = '$aws/things/{}/infer'.format(os.environ['AWS_IOT_THING_NAME'])\n\n # Create a local display instance that will dump the image bytes to a FIFO\n # file that the image can be rendered locally.\n local_display = LocalDisplay('480p')\n local_display.start()\n\n # The sample projects come with optimized artifacts, hence only the artifact\n # path is required.\n model_path = '/opt/awscam/artifacts/mxnet_resnet18-catsvsdogs_FP32_FUSED.xml'\n\n # Load the model onto the GPU.\n client.publish(topic=iot_topic, payload='Loading action cat-dog model')\n model = awscam.Model(model_path, {'GPU': 1})\n client.publish(topic=iot_topic, payload='Cat-Dog model loaded')\n\n # Since this is a binary classifier only retrieve 2 classes.\n num_top_k = 2\n\n # The height and width of the training set images\n input_height = 224\n input_width = 224\n\n # Do inference until the lambda is killed.\n while True:\n # inference loop to add. See the next step \n ...\n\n\n except Exception as ex:\n client.publish(topic=iot_topic, payload='Error in cat-dog lambda: {}'.format(ex))\n# snippet-end:[deeplens.python.deeplens_inference_lambda.inference_loop]\n\n# snippet-start:[deeplens.python.deeplens_inference_lambda.inference_step]\n # Get a frame from the video stream\n ret, frame = awscam.getLastFrame()\n if not ret:\n raise Exception('Failed to get frame from the stream')\n # Resize frame to the same size as the training set.\n frame_resize = cv2.resize(frame, (input_height, input_width))\n # Run the images through the inference engine and parse the results using\n # the parser API, note it is possible to get the output of doInference\n # and do the parsing manually, but since it is a classification model,\n # a simple API is provided.\n parsed_inference_results = model.parseResult(model_type,\n model.doInference(frame_resize))\n # Get top k results with highest probabilities\n top_k = parsed_inference_results[model_type][0:num_top_k]\n # Add the label of the top result to the frame used by local display.\n # See https://docs.opencv.org/3.4.1/d6/d6e/group__imgproc__draw.html\n # for more information about the cv2.putText method.\n # Method signature: image, text, origin, font face, font scale, color, and thickness\n cv2.putText(frame, output_map[top_k[0]['label']], (10, 70),\n cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 165, 20), 8)\n # Set the next frame in the local display stream.\n local_display.set_frame_data(frame)\n # Send the top k results to the IoT console via MQTT\n cloud_output = {}\n for obj in top_k:\n cloud_output[output_map[obj['label']]] = obj['prob']\n client.publish(topic=iot_topic, payload=json.dumps(cloud_output))","def inference():\n if request.method == \"POST\":\n data = request.json #\n src_img = np.array(data[\"src\"]).astype(np.uint8) # Parsing data\n ref_img = np.array(data[\"ref\"]).astype(np.uint8) #\n ref_label = int(data[\"ref_label\"]) #\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\n return jsonify({\"result\": result.tolist()}) # Returning results into json","def inference_call(self, inputs):\n self.eval()\n\n with torch.no_grad():\n mid, downsampling_features = self.encoder(inputs)\n hd = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=0)\n pl = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=1)\n return hd, pl","def inference(self):\n raise NotImplementedError","def do_parallel_inference(args):\n from treehmm import random_params, do_inference, plot_params, plot_energy, load_params\n from treehmm.vb_mf import normalize_trans\n from treehmm.static import float_type\n\n _x = sp.load(args.observe_matrix[0])\n args.continuous_observations = _x.dtype != sp.int8\n args.I, _, args.L = _x.shape\n I = args.I\n K = args.K\n L = args.L\n args.T = 'all'\n args.free_energy = []\n args.observe = 'all.npy'\n args.last_free_energy = 0\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\n\n args.out_dir = args.out_dir.format(timestamp=time.strftime('%x_%X').replace('/', '-'), **args.__dict__)\n try:\n print 'making', args.out_dir\n os.makedirs(args.out_dir)\n except OSError:\n pass\n\n if args.warm_start:\n # args.last_free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(args)\n # args.warm_start = False\n print '# loading previous params for warm start from %s' % args.warm_start\n tmpargs = copy.deepcopy(args)\n tmpargs.out_dir = args.warm_start\n tmpargs.observe = 'all.npy'\n args.free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(tmpargs)\n\n try:\n args.free_energy = list(args.free_energy)\n except TypeError: # no previous free energy\n args.free_energy = []\n print 'done'\n args.warm_start = False\n else:\n (args.theta, args.alpha, args.beta, args.gamma, args.emit_probs) = \\\n random_params(args.I, args.K, args.L, args.separate_theta)\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'last_free_energy', 'emit_sum']:\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n\n \n args.iteration = 0\n plot_params(args)\n print '# setting up job arguments'\n # set up new versions of args for other jobs\n job_args = [copy.copy(args) for i in range(len(args.observe_matrix))]\n for j, a in enumerate(job_args):\n a.observe_matrix = args.observe_matrix[j]\n a.observe = os.path.split(args.observe_matrix[j])[1]\n a.subtask = True\n a.func = None\n a.iteration = 0\n a.max_iterations = 1\n a.quiet_mode = True\n if j % 1000 == 0:\n print j\n\n if args.run_local:\n pool = multiprocessing.Pool()\n else:\n pool = sge.SGEPool()\n #job_handle = pool.imap_unordered(do_inference, job_args)\n\n converged = False\n for args.iteration in range(args.max_iterations):\n # import ipdb; ipdb.set_trace()\n # fresh parameters-- to be aggregated after jobs are run\n print 'iteration', args.iteration\n total_free = 0\n if args.separate_theta:\n args.theta = sp.zeros((I - 1, K, K, K), dtype=float_type)\n else:\n args.theta = sp.zeros((K, K, K), dtype=float_type)\n\n args.alpha = sp.zeros((K, K), dtype=float_type)\n args.beta = sp.zeros((K, K), dtype=float_type)\n args.gamma = sp.zeros((K), dtype=float_type)\n args.emit_probs = sp.zeros((K, L), dtype=float_type)\n if True: # args.approx == 'clique':\n args.emit_sum = sp.zeros_like(args.emit_probs, dtype=float_type)\n else:\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\n\n if args.run_local:\n iterator = pool.imap_unordered(do_inference, job_args, chunksize=args.chunksize)\n # wait for jobs to finish\n for result in iterator:\n pass\n else:\n jobs_handle = pool.map_async(do_inference, job_args, chunksize=args.chunksize)\n # wait for all jobs to finish\n for j in jobs_handle:\n j.wait()\n\n # sum free energies and parameters from jobs\n for a in job_args:\n # print '# loading from %s' % a.observe\n free_energy, theta, alpha, beta, gamma, emit_probs, emit_sum = load_params(a)\n # print 'free energy for this part:', free_energy\n if len(free_energy) > 0:\n last_free_energy = free_energy[-1]\n else:\n last_free_energy = 0\n total_free += last_free_energy\n args.theta += theta\n args.alpha += alpha\n args.beta += beta\n args.gamma += gamma\n args.emit_probs += emit_probs\n args.emit_sum += emit_sum\n\n # renormalize and plot\n print 'normalize aggregation... total free energy is:', total_free\n args.free_energy.append(total_free)\n if len(args.free_energy) > 1 and args.free_energy[-1] != 0 and args.free_energy[-2] != 0 \\\n and abs((args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]) < args.epsilon:\n print 'converged. free energy diff:', args.free_energy, abs(args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]\n converged = True\n normalize_trans(args.theta, args.alpha, args.beta, args.gamma)\n # if True: #args.approx == 'clique':\n # #print 'clique emit renorm'\n # args.emit_probs[:] = args.emit_probs / args.emit_sum\n # else:\n # args.emit_probs[:] = sp.dot(sp.diag(1./args.emit_sum), args.emit_probs)\n args.emit_probs[:] = sp.dot(sp.diag(1. / args.emit_sum), args.emit_probs)\n for a in job_args:\n a.theta, a.alpha, a.beta, a.gamma, a.emit_probs, a.emit_sum = args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum\n\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'lmd', 'tau']:\n try:\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n except KeyError:\n pass\n plot_params(args)\n plot_energy(args)\n\n if args.save_Q >= 3:\n print '# reconstructing chromosomes from *chunk*',\n in_order = {}\n # Q_chr16_all.trimmed.chunk*.npy => Q_chr16_all.trimmed.npy\n all_chunks = glob.glob(os.path.join(args.out_dir, '*_Q_*chunk*.npy'))\n for chunk in all_chunks:\n print chunk\n chunk_num = int(re.search(r'chunk(\\d+)', chunk).groups()[0])\n chrom_out = re.sub('chunk(\\d+)\\.', '', chunk)\n if chrom_out not in in_order:\n in_order[chrom_out] = {}\n in_order[chrom_out][chunk_num] = sp.load(chunk)\n for chrom_out in in_order:\n print 'reconstructing chromosomes from', in_order[chrom_out]\n if len(in_order[chrom_out]) > 1:\n final_array = sp.concatenate((in_order[chrom_out][0], in_order[chrom_out][1]), axis=1)\n for i in range(2, max(in_order[chrom_out])):\n final_array = sp.concatenate((final_array, in_order[chrom_out][i]), axis=1)\n else:\n final_array = in_order[chrom_out][0]\n sp.save(chrom_out, final_array)\n\n if converged:\n break","def main():\n # Grab command line args\n args = build_argparser().parse_args()\n #print(\"finished argparser\")\n\n # Connect to the MQTT server\n client = connect_mqtt()\n #print(\"finished mqtt connect\")\n\n # Perform inference on the input stream\n infer_on_stream(args, client)","def worker(nums, out_q):\n outdict = {}\n print(threading.current_thread().name)\n print (\"pid:\", os.getpid())\n print (\"data size:\", nums)\n for n in nums:\n outdict[n] = factorize_naive(n)\n out_q.put(outdict)","def post_handler(_dev_idx, raw_res, _captured_frames_path):\n global CUR_IMAGE\n if CUR_IMAGE % 2:\n print(\"\\nFox classification\")\n else:\n print(\"\\nCat classification\")\n\n scores, _labels = postprocess(raw_res[0])\n top_indices(scores[0], 3)\n\n CUR_IMAGE += 1","def infinite_infer_run():\n try:\n # This cat-dog model is implemented as binary classifier, since the number\n # of labels is small, create a dictionary that converts the machine\n # labels to human readable labels.\n model_type = 'classification'\n output_map = {0: 'dog', 1: 'cat'}\n # Create an IoT client for sending to messages to the cloud.\n client = greengrasssdk.client('iot-data')\n iot_topic = '$aws/things/{}/infer'.format(os.environ['AWS_IOT_THING_NAME'])\n # Create a local display instance that will dump the image bytes to a FIFO\n # file that the image can be rendered locally.\n local_display = LocalDisplay('480p')\n local_display.start()\n # The sample projects come with optimized artifacts, hence only the artifact\n # path is required.\n model_path = '/opt/awscam/artifacts/mxnet_resnet18-catsvsdogs_FP32_FUSED.xml'\n # Load the model onto the GPU.\n client.publish(topic=iot_topic, payload='Loading action cat-dog model')\n model = awscam.Model(model_path, {'GPU': 1})\n client.publish(topic=iot_topic, payload='Cat-Dog model loaded')\n # Since this is a binary classifier only retrieve 2 classes.\n num_top_k = 2\n # The height and width of the training set images\n input_height = 224\n input_width = 224\n # Do inference until the lambda is killed.\n while True:\n # Get a frame from the video stream\n ret, frame = awscam.getLastFrame()\n if not ret:\n raise Exception('Failed to get frame from the stream')\n # Resize frame to the same size as the training set.\n frame_resize = cv2.resize(frame, (input_height, input_width))\n # Run the images through the inference engine and parse the results using\n # the parser API, note it is possible to get the output of doInference\n # and do the parsing manually, but since it is a classification model,\n # a simple API is provided.\n parsed_inference_results = model.parseResult(model_type,\n model.doInference(frame_resize))\n # Get top k results with highest probabilities\n top_k = parsed_inference_results[model_type][0:num_top_k]\n # Add the label of the top result to the frame used by local display.\n # See https://docs.opencv.org/3.4.1/d6/d6e/group__imgproc__draw.html\n # for more information about the cv2.putText method.\n # Method signature: image, text, origin, font face, font scale, color, and thickness\n cv2.putText(frame, output_map[top_k[0]['label']], (10, 70),\n cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 165, 20), 8)\n # Set the next frame in the local display stream.\n local_display.set_frame_data(frame)\n # Send the top k results to the IoT console via MQTT\n cloud_output = {}\n for obj in top_k:\n cloud_output[output_map[obj['label']]] = obj['prob']\n client.publish(topic=iot_topic, payload=json.dumps(cloud_output))\n except Exception as ex:\n client.publish(topic=iot_topic, payload='Error in cat-dog lambda: {}'.format(ex))","def inference(images, indication, flags):\r\n # We instantiate all variables using tf.get_variable() instead of\r\n # tf.Variable() in order to share variables across multiple GPU training runs.\r\n # If we only ran this model on a single GPU, we could simplify this function\r\n # by replacing all instances of tf.get_variable() with tf.Variable().\r\n \r\n # conv1\r\n with tf.variable_scope('conv1') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[7, 7, 3, 32],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(input=images, filter=kernel, strides=[1, 2, 2, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_1 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_1)\r\n\r\n \r\n # pool1\r\n pool_1 = tf.nn.max_pool(conv_1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\r\n padding='SAME', name='pool1') \r\n # conv2\r\n with tf.variable_scope('conv2') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 32, 32],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(pool_1, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases) \r\n conv_2 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_2)\r\n \r\n # conv3\r\n with tf.variable_scope('conv3') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 32, 32],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_2, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_3 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_3) \r\n \r\n \r\n # pool2\r\n pool_2 = tf.nn.max_pool(conv_3, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\r\n padding='SAME', name='pool2')\r\n \r\n # conv4\r\n with tf.variable_scope('conv4') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 32, 64],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(pool_2, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases) \r\n conv_4 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_4)\r\n \r\n # conv5\r\n with tf.variable_scope('conv5') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 64, 64],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_4, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_5 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_5) \r\n\r\n # conv6\r\n with tf.variable_scope('conv6') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 64, 64],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_5, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_6 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_6) \r\n \r\n # pool3\r\n pool_3 = tf.nn.max_pool(conv_6, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\r\n padding='SAME', name='pool3') \r\n # conv7\r\n with tf.variable_scope('conv7') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 64, 128],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(pool_3, kernel, [1, 1, 1, 1], padding='SAME')\r\n\r\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_7 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \r\n _activation_summary(conv_7)\r\n\r\n # conv8\r\n with tf.variable_scope('conv8') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 128, 128],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_7, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases) \r\n conv_8 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_8) \r\n \r\n # conv9\r\n with tf.variable_scope('conv9') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 128, 128],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_8, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_9 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_9) \r\n \r\n # conv10\r\n with tf.variable_scope('conv10') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 128, 128],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_9, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_10 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_10) \r\n \r\n # pool4\r\n pool_4 = tf.nn.max_pool(conv_10, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\r\n padding='SAME', name='pool4') \r\n # conv11\r\n with tf.variable_scope('conv11') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 128, 256],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(pool_4, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_11 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_11)\r\n \r\n # conv12\r\n with tf.variable_scope('conv12') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 256, 256],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_11, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_12 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \r\n _activation_summary(conv_12) \r\n \r\n # conv13\r\n with tf.variable_scope('conv13') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 256, 256],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_12, kernel, [1, 1, 1, 1], padding='SAME') \r\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_13 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \r\n _activation_summary(conv_13) \r\n \r\n # conv14\r\n with tf.variable_scope('conv14') as scope:\r\n kernel = _variable_with_weight_decay('weights',\r\n shape=[3, 3, 256, 256],\r\n init_parameter=0.001,\r\n wd=0.0,\r\n use_fp16=flags.use_fp16)\r\n conv = tf.nn.conv2d(conv_13, kernel, [1, 1, 1, 1], padding='SAME')\r\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\r\n pre_activation = tf.nn.bias_add(conv, biases)\r\n conv_14 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\r\n _activation_summary(conv_14) \r\n\r\n # pool5\r\n pool_5 = tf.nn.max_pool(conv_14, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\r\n padding='SAME', name='pool5') \r\n # dropout1\r\n dropout_1 = tf.nn.dropout(pool_5, keep_prob=0.25, name='dropout1') \r\n \r\n # maxout1\r\n with tf.variable_scope('maxout1') as scope:\r\n # reshape from convolution\r\n reshape = tf.reshape(dropout_1, [-1, 16384])\r\n weights = _variable_with_weight_decay('weights', shape=[16384, 512, 2],\r\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16) \r\n biases = _variable_on_cpu('biases', [512, 2], tf.constant_initializer(0.0), flags.use_fp16)\r\n maxout = tf.tensordot(reshape, weights, axes=1) + biases\r\n maxout_1 = tf.reduce_max(maxout, axis=2, name=scope.name)\r\n _activation_summary(maxout_1) \r\n \r\n # merge two eyes\r\n with tf.variable_scope('reshape1') as scope:\r\n # concat left and right lable\r\n concat_1 = tf.concat([maxout_1,indication], axis=-1)\r\n # reshape1(merge eyes)\r\n reshape_1 = tf.reshape(concat_1, [32,-1], name=scope.name)\r\n \r\n # dropout2\r\n dropout_2 = tf.nn.dropout(reshape_1, keep_prob=0.25, name='dropout2') \r\n \r\n # maxout2\r\n with tf.variable_scope('maxout2') as scope:\r\n reshape = tf.reshape(dropout_2, [-1, 1028])\r\n weights = _variable_with_weight_decay('weights', shape=[1028, 512, 2],\r\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16) \r\n biases = _variable_on_cpu('biases', [512, 2], tf.constant_initializer(0.0), flags.use_fp16)\r\n maxout = tf.tensordot(reshape, weights, axes=1) + biases\r\n maxout_2 = tf.reduce_max(maxout, axis=2, name='maxout2')\r\n _activation_summary(maxout_2) \r\n\r\n # dropout3\r\n dropout_3 = tf.nn.dropout(maxout_2, keep_prob=0.25, name='dropout3')\r\n \r\n # linear layer(WX + b),\r\n # We don't apply softmax here because\r\n # tf.nn.sparse_softmax_cross_entropy_with_logits accepts the unscaled logits\r\n # and performs the softmax internally for efficiency.\r\n with tf.variable_scope('softmax_linear') as scope:\r\n weights = _variable_with_weight_decay('weights', [512, 2*NUM_CLASSES],\r\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16)\r\n biases = _variable_on_cpu('biases', [2*NUM_CLASSES], tf.constant_initializer(0.0), flags.use_fp16)\r\n softmax_linear = tf.add(tf.matmul(dropout_3, weights), biases, name=scope.name)\r\n _activation_summary(softmax_linear)\r\n \r\n # back to one eye\r\n with tf.variable_scope('reshape2') as scope:\r\n reshape_2 = tf.reshape(softmax_linear,[64,5],name=scope.name)\r\n \r\n return reshape_2","def run_inference(dataset, model, executor_):\n for batch in dataset:\n results = model.inference(batch)\n for stats in model.worker_pool.imap(get_stats_from_code, zip(results, batch, [executor_]*len(batch))):\n if stats is not None:\n yield stats\n return","def main():\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n h, w = INPUT_SIZE\n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(DATA_DIRECTORY, DATA_LIST_PATH, None, False, False, coord)\n image = reader.image\n image_rev = tf.reverse(image, tf.stack([1]))\n image_list = reader.image_list\n\n image_batch_origin = tf.stack([image, image_rev])\n image_batch = tf.image.resize_images(image_batch_origin, [int(h), int(w)])\n image_batch075 = tf.image.resize_images(image_batch_origin, [int(h * 0.75), int(w * 0.75)])\n image_batch125 = tf.image.resize_images(image_batch_origin, [int(h * 1.25), int(w * 1.25)])\n \n # Create network.\n with tf.variable_scope('', reuse=False):\n net_100 = JPPNetModel({'data': image_batch}, is_training=False, n_classes=N_CLASSES)\n with tf.variable_scope('', reuse=True):\n net_075 = JPPNetModel({'data': image_batch075}, is_training=False, n_classes=N_CLASSES)\n with tf.variable_scope('', reuse=True):\n net_125 = JPPNetModel({'data': image_batch125}, is_training=False, n_classes=N_CLASSES)\n\n \n # parsing net\n parsing_fea1_100 = net_100.layers['res5d_branch2b_parsing']\n parsing_fea1_075 = net_075.layers['res5d_branch2b_parsing']\n parsing_fea1_125 = net_125.layers['res5d_branch2b_parsing']\n\n parsing_out1_100 = net_100.layers['fc1_human']\n parsing_out1_075 = net_075.layers['fc1_human']\n parsing_out1_125 = net_125.layers['fc1_human']\n\n # pose net\n resnet_fea_100 = net_100.layers['res4b22_relu']\n resnet_fea_075 = net_075.layers['res4b22_relu']\n resnet_fea_125 = net_125.layers['res4b22_relu']\n\n with tf.variable_scope('', reuse=False):\n pose_out1_100, pose_fea1_100 = pose_net(resnet_fea_100, 'fc1_pose')\n pose_out2_100, pose_fea2_100 = pose_refine(pose_out1_100, parsing_out1_100, pose_fea1_100, name='fc2_pose')\n parsing_out2_100, parsing_fea2_100 = parsing_refine(parsing_out1_100, pose_out1_100, parsing_fea1_100, name='fc2_parsing')\n parsing_out3_100, parsing_fea3_100 = parsing_refine(parsing_out2_100, pose_out2_100, parsing_fea2_100, name='fc3_parsing')\n\n with tf.variable_scope('', reuse=True):\n pose_out1_075, pose_fea1_075 = pose_net(resnet_fea_075, 'fc1_pose')\n pose_out2_075, pose_fea2_075 = pose_refine(pose_out1_075, parsing_out1_075, pose_fea1_075, name='fc2_pose')\n parsing_out2_075, parsing_fea2_075 = parsing_refine(parsing_out1_075, pose_out1_075, parsing_fea1_075, name='fc2_parsing')\n parsing_out3_075, parsing_fea3_075 = parsing_refine(parsing_out2_075, pose_out2_075, parsing_fea2_075, name='fc3_parsing')\n\n with tf.variable_scope('', reuse=True):\n pose_out1_125, pose_fea1_125 = pose_net(resnet_fea_125, 'fc1_pose')\n pose_out2_125, pose_fea2_125 = pose_refine(pose_out1_125, parsing_out1_125, pose_fea1_125, name='fc2_pose')\n parsing_out2_125, parsing_fea2_125 = parsing_refine(parsing_out1_125, pose_out1_125, parsing_fea1_125, name='fc2_parsing')\n parsing_out3_125, parsing_fea3_125 = parsing_refine(parsing_out2_125, pose_out2_125, parsing_fea2_125, name='fc3_parsing')\n\n\n parsing_out1 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out1_100, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out1_075, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out1_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\n parsing_out2 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out2_100, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out2_075, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out2_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\n parsing_out3 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out3_100, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out3_075, tf.shape(image_batch_origin)[1:3,]),\n tf.image.resize_images(parsing_out3_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\n\n raw_output = tf.reduce_mean(tf.stack([parsing_out1, parsing_out2, parsing_out3]), axis=0)\n head_output, tail_output = tf.unstack(raw_output, num=2, axis=0)\n tail_list = tf.unstack(tail_output, num=20, axis=2)\n tail_list_rev = [None] * 20\n for xx in range(14):\n tail_list_rev[xx] = tail_list[xx]\n tail_list_rev[14] = tail_list[15]\n tail_list_rev[15] = tail_list[14]\n tail_list_rev[16] = tail_list[17]\n tail_list_rev[17] = tail_list[16]\n tail_list_rev[18] = tail_list[19]\n tail_list_rev[19] = tail_list[18]\n tail_output_rev = tf.stack(tail_list_rev, axis=2)\n tail_output_rev = tf.reverse(tail_output_rev, tf.stack([1]))\n\n \n raw_output_all = tf.reduce_mean(tf.stack([head_output, tail_output_rev]), axis=0)\n raw_output_all = tf.expand_dims(raw_output_all, dim=0)\n raw_output_all = tf.argmax(raw_output_all, dimension=3)\n pred_all = tf.expand_dims(raw_output_all, dim=3) # Create 4-d tensor.\n\n # Which variables to load.\n restore_var = tf.global_variables()\n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n sess.run(tf.local_variables_initializer())\n \n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if RESTORE_FROM is not None:\n if load(loader, sess, RESTORE_FROM):\n print(\" [*] Load SUCCESS\")\n else:\n print(\" [!] Load failed...\")\n \n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n\n rand_int = [i/100 for i in random.sample(range(0, 100), NUM_STEPS)]\n # Iterate over training steps.\n for step in range(NUM_STEPS):\n parsing_ = sess.run(pred_all)\n if step % 100 == 0:\n print('step {:d}'.format(step))\n print (image_list[step])\n img_split = image_list[step].split('/')\n img_id = img_split[-1][:-4]\n mask_top = decode_labels(parsing_, [5,6,7,10], num_classes=N_CLASSES)\n mask_bottom = decode_labels(parsing_, [9, 12], num_classes=N_CLASSES)\n im_mask_top = Image.fromarray(mask_top[0]).convert('L')\n im_mask_bottom = Image.fromarray(mask_bottom[0]).convert('L')\n _mask_top = np.array(im_mask_top)\n _mask_top[_mask_top != 0 ] = 255\n _mask_bottom = np.array(im_mask_bottom)\n _mask_bottom[_mask_bottom != 0 ] = 255\n\n real_img = Image.open(image_list[step]).convert(\"RGB\")\n top_real_img = Image.open(image_list[step]).convert(\"RGB\")\n bottom_real_img = Image.open(image_list[step]).convert(\"RGB\")\n\n imgdata_top = reload_img(top_real_img)\n for i in range(0,len(imgdata_top)):\n # hsv code start\n (h,s,v) = rgb2hsv(imgdata_top[i])\n h += float(i)/len(imgdata_top)\n v += 0.005\n imgdata_top[i] = hsv2rgb((h,s,v))\n # hsv code end\n\n # hls code\n # (h,l,s) = rgb2hls(imgdata_top[i])\n # h = rand_int[step]\n # s = 0.3\n # imgdata_top[i] = hls2rgb((h,l,s))\n # hls code end\n top_real_img.putdata(imgdata_top)\n im = Image.composite(top_real_img, real_img, Image.fromarray(_mask_top).convert('L'))\n if _mask_bottom.size > 0:\n imgdata_bottom = reload_img(bottom_real_img)\n for i in range(0,len(imgdata_bottom)):\n # bottom part only use hsv to avoid not matching color with top parts\n (h,s,v) = rgb2hsv(imgdata_bottom[i])\n h += float(i)/len(imgdata_bottom)\n v += 0.005\n imgdata_bottom[i] = hsv2rgb((h,s,v))\n bottom_real_img.putdata(imgdata_bottom)\n im = Image.composite(bottom_real_img, im, Image.fromarray(_mask_bottom).convert('L'))\n Image.fromarray(_mask_bottom).save('{}/{}_bottom.png'.format(OUTPUT_DIR, img_id))\n im.save('{}/{}_hsl.png'.format(OUTPUT_DIR, img_id))\n Image.fromarray(_mask_top).save('{}/{}_top.png'.format(OUTPUT_DIR, img_id))\n \n # parsing_im.save('{}/{}_vis.png'.format(OUTPUT_DIR, img_id))\n # cv2.imwrite('{}/{}.png'.format(OUTPUT_DIR, img_id), parsing_[0,:,:,0])\n\n coord.request_stop()\n coord.join(threads)","def process():","def compute_output(api, args):\n\n fusion = None\n\n # variables from command-line options\n resume = args.resume_\n fusion_ids = args.fusion_ids_\n output = args.predictions\n # there's only one fusion to be generated at present\n args.max_parallel_fusions = 1\n # fusion cannot be published yet.\n args.public_fusion = False\n\n # It is compulsory to have a description to publish either datasets or\n # fusions\n if (not args.description_ and args.public_fusion):\n sys.exit(\"You should provide a description to publish.\")\n\n path = u.check_dir(output)\n session_file = \"%s%s%s\" % (path, os.sep, SESSIONS_LOG)\n csv_properties = {}\n # If logging is required set the file for logging\n log = None\n if args.log_file:\n u.check_dir(args.log_file)\n log = args.log_file\n # If --clear_logs the log files are cleared\n clear_log_files([log])\n\n if args.fusion_file:\n # fusion regression is retrieved from the contents of the given local\n # JSON file\n fusion, csv_properties, fields = u.read_local_resource(\n args.fusion_file,\n csv_properties=csv_properties)\n fusion_ids = [fusion]\n else:\n # fusion is retrieved from the remote object or created\n fusion, resume = \\\n pf.fusion_processing( \\\n fusion, fusion_ids, \\\n api, args, resume, \\\n session_file=session_file, path=path, log=log)\n\n # We update the fusion public state if needed\n if fusion:\n if isinstance(fusion, str):\n if not a.has_test(args):\n query_string = MINIMUM_MODEL\n elif args.export_fields:\n query_string = r.ALL_FIELDS_QS\n else:\n query_string = ''\n fusion = u.check_resource(fusion,\n api.get_fusion,\n query_string=query_string)\n if (args.public_fusion or\n (args.shared_flag and r.shared_changed(args.shared,\n fusion))):\n fusion_args = {}\n if args.shared_flag and r.shared_changed(args.shared,\n fusion):\n fusion_args.update(shared=args.shared)\n if args.public_fusion:\n fusion_args.update( \\\n rfus.set_publish_fusion_args(args))\n if fusion_args:\n fusion = rfus.update_fusion( \\\n fusion, fusion_args, args,\n api=api, path=path, \\\n session_file=session_file)\n\n # We get the fields of the fusion if we haven't got\n # them yet and need them\n if fusion and (args.test_set or args.evaluate):\n fields = pf.get_fusion_fields( \\\n fusion, csv_properties, args)\n\n\n # If predicting\n if fusion and (a.has_test(args) or \\\n args.remote):\n test_dataset = get_test_dataset(args)\n\n # Remote predictions: predictions are computed as batch predictions\n # in bigml.com except when --no-batch flag is set on\n if args.remote and not args.no_batch:\n # create test source from file\n test_name = \"%s - test\" % args.name\n if args.test_source is None:\n test_properties = ps.test_source_processing(\n api, args, resume, name=test_name,\n session_file=session_file, path=path, log=log)\n (test_source, resume,\n csv_properties, test_fields) = test_properties\n else:\n test_source_id = bigml.api.get_source_id(args.test_source)\n test_source = api.check_resource(test_source_id)\n if test_dataset is None:\n # create test dataset from test source\n dataset_args = set_basic_dataset_args(args, name=test_name)\n test_dataset, resume = pd.alternative_dataset_processing(\n test_source, \"test\", dataset_args, api, args,\n resume, session_file=session_file, path=path, log=log)\n else:\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\n test_dataset = api.check_resource(test_dataset_id)\n\n csv_properties.update(objective_field=None,\n objective_field_present=False)\n test_fields = pd.get_fields_structure(test_dataset,\n csv_properties)\n if not args.evaluate:\n batch_prediction_args = set_batch_prediction_args(\n args, fields=fields,\n dataset_fields=test_fields)\n\n remote_prediction(fusion, test_dataset, \\\n batch_prediction_args, args, \\\n api, resume, prediction_file=output, \\\n session_file=session_file, path=path, log=log)\n\n else:\n prediction([fusion], fields, args,\n session_file=session_file)\n\n\n # If evaluate flag is on, create remote evaluation and save results in\n # json and human-readable format.\n if args.evaluate:\n # When we resume evaluation and models were already completed, we\n # should use the datasets array as test datasets\n args.max_parallel_evaluations = 1 # only one evaluation at present\n args.cross_validation_rate = 0 # no cross-validation\n args.number_of_evaluations = 1 # only one evaluation\n if args.has_test_datasets_:\n test_dataset = get_test_dataset(args)\n dataset = test_dataset\n dataset = u.check_resource(dataset, api=api,\n query_string=r.ALL_FIELDS_QS)\n dataset_fields = pd.get_fields_structure(dataset, None)\n resume = evaluate([fusion], [dataset], api,\n args, resume,\n fields=fields, dataset_fields=dataset_fields,\n session_file=session_file, path=path,\n log=log,\n objective_field=args.objective_field)\n\n\n u.print_generated_files(path, log_file=session_file,\n verbosity=args.verbosity)\n if args.reports:\n clear_reports(path)\n if args.upload:\n upload_reports(args.reports, path)","def postprocess(self, inference_output):\n ret = []\n quantiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n # for each request\n for inference_output_request in inference_output:\n ret_request = []\n # for each time series\n for i in inference_output_request:\n l = {}\n l[\"item_id\"] = i.item_id\n l[\"quantiles\"] = {}\n for q in quantiles:\n l[\"quantiles\"][str(q)] = i.quantile(q).tolist()\n l[\"mean\"] = i.mean.tolist()\n ret_request.append(json.dumps(l))\n ret.append('\\n'.join(ret_request) + '\\n')\n return ret","def run():\n import numpy as np\n\n batch_size = 500\n discard_threshold = 50\n input_base = '/home/ubuntu/faces'\n model_dir = '/home/ubuntu/FaceNet/20170512-110547'\n\n with tf.Graph().as_default():\n with tf.Session() as sess:\n\n meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(model_dir))\n\n print('Metagraph file: %s' % meta_file)\n print('Checkpoint file: %s' % ckpt_file)\n load_model(model_dir, meta_file, ckpt_file)\n with open('/home/ubuntu/face_uploaded.txt', 'w') as upload_log:\n with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:\n futures = []\n img_cnt = 0\n ignored = 0\n for fam_id in os.listdir(input_base):\n input_dir = os.path.join(input_base, fam_id)\n image_paths = get_onedir(input_dir)\n # image_list, label_list = facenet.get_image_paths_and_labels(train_set)\n\n # Get input and output tensors\n images_placeholder = tf.get_default_graph().get_tensor_by_name(\"input:0\")\n embeddings = tf.get_default_graph().get_tensor_by_name(\"embeddings:0\")\n phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(\"phase_train:0\")\n\n image_size = images_placeholder.get_shape()[1]\n embedding_size = embeddings.get_shape()[1]\n\n nrof_images = len(image_paths)\n nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size))\n emb_array = np.zeros((nrof_images, embedding_size))\n facial_encodings = compute_facial_encodings(sess, images_placeholder, embeddings, phase_train_placeholder,\n image_size,\n embedding_size, nrof_images, nrof_batches, emb_array,\n batch_size, image_paths)\n sorted_clusters = cluster_facial_encodings(facial_encodings)\n if not sorted_clusters:\n ignored += 1\n continue\n\n sorted_clusters = data_cleaning(sorted_clusters, facial_encodings)\n\n # For those families dont have enought photos for child, ignore them\n # Or those families use mitene in unordinary way.\n if len(sorted_clusters[0]) < discard_threshold:\n ignored += 1\n continue\n\n print('Start zip upload for: {0}, contains {1} images!'.format(fam_id, len(sorted_clusters[0])))\n futures.append(executor.submit(zip_and_upload, sorted_clusters, fam_id))\n img_cnt += len(sorted_clusters[0])\n for img in sorted_clusters[0]:\n upload_log.write('{0},{1}\\n'.format(fam_id, os.path.basename(img)))\n\n cnt = 0\n for future in concurrent.futures.as_completed(futures):\n try:\n print('job is finished!: ' + future.result())\n cnt += 1\n except Exception as e:\n print('zip and upload job failed!: ' + str(e))\n\n print('Finished upload {0} images from {1} families! Ignored {2} families!'.format(img_cnt, cnt, ignored))","def run_inference(loop_op: tf.Operation, infeed_queue_initializer: tf.Operation, outfeed_op: tf.Operation,\n batch_size: int, batches_per_step: int, network_name: str,\n decode_predictions: Callable, ground_truth: Tuple[str], num_iterations: Optional[int] = 500,\n num_ipus: Optional[int] = 1, mode: Optional[str] = \"single_ipu\",\n data: Optional[str] = \"real\", available_memory_proportion: Optional[float] = 0.6) -> None:\n # Set compile and device options\n opts = IPUConfig()\n opts.matmuls.poplar_options = {'availableMemoryProportion': str(\n available_memory_proportion)}\n opts.convolutions.poplar_options = {'availableMemoryProportion': str(\n available_memory_proportion)}\n\n if mode == 'replicated':\n num_replicas = num_ipus\n os.environ[\"TF_POPLAR_FLAGS\"] += \" --force_replicated_mode\"\n else:\n num_replicas = 1\n opts.auto_select_ipus = num_ipus\n opts.configure_ipu_system()\n with tf.Session() as session:\n session.run(infeed_queue_initializer)\n fps = []\n for iter_count in range(num_iterations):\n start = time.time()\n session.run(loop_op)\n predictions = session.run(outfeed_op)\n stop = time.time()\n fps.append(batch_size * batches_per_step * num_replicas / (stop - start))\n logging.info(\n \"Iter {4}: {0} Throughput using {1} data = {2:.1f} imgs/sec at batch size = {3}\".format(network_name,\n data,\n fps[-1],\n batch_size,\n iter_count))\n duration = stop - start\n report_string = \"{:<7.3} sec/itr.\".format(duration)\n report_string += \" {:5f} images/sec.\".format(fps[-1])\n print(report_string)\n print(\"Total time: {}\".format(duration))\n\n # Decode a random prediction per step to check functional correctness.\n if data == 'real':\n predictions = np.reshape(predictions, (-1, predictions.shape[-1]))\n index = np.random.randint(0, len(predictions))\n if network_name in (\"inceptionv1\", \"efficientnet-s\", \"efficientnet-m\", \"efficientnet-l\"):\n # These models encode background in 0th index.\n decoded_predictions = decode_predictions(predictions[index: index + 1, 1:], top=3)\n else:\n decoded_predictions = decode_predictions(predictions[index: index + 1, :], top=3)\n labels_and_probs = [(label, prob) for _, label, prob in decoded_predictions[0]]\n print('Actual: ',\n ground_truth[\n (index + num_replicas * iter_count * batches_per_step * batch_size) % len(ground_truth)])\n print('Predicted: ', labels_and_probs)\n\n print(\"Average statistics excluding the 1st 20 iterations.\")\n print(\"-------------------------------------------------------------------------------------------\")\n fps = fps[20:]\n print(\"Throughput at bs={}, data_mode={}, data_type={}, mode={},\"\n \" num_ipus={}, of {}: min={}, max={}, mean={}, std={}.\".format(batch_size,\n data,\n predictions.dtype,\n mode,\n num_ipus,\n network_name,\n min(fps),\n max(fps),\n np.mean(fps),\n np.std(fps)))","def process(self, results):\n raise NotImplementedError","def worker_train():\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\n\n while True:\n job = jobs.get(block=True)\n if job is None: # data finished, exit\n jobs.task_done()\n # print('thread %s break' % threading.current_thread().name)\n break\n\n lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\n #lr = self.lr \n job_words = 0\n #pre=self.build_model(len(model.vocab), model.layer1_size, lamda = 0.0, learning_rate=lr)\n for edge in job:\n if edge is not None:\n x = []\n y = []\n x.append([edge[0].index, edge[1].index])\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n #y.append(weight)\n y.append(1.0)\n #for i in range(int(10 * (weight)) * self.negative):\n for i in range(self.negative):\n nodeidx = model.table[np.random.randint(model.table_size)]\n if nodeidx != edge[0].index:\n x.append([edge[0].index, nodeidx])\n y.append(0.0)\n feed_dict = {\n pre.x: x,\n pre.y: y,\n pre.node_embeddings_init: model.node_embedding\n }\n #saver = tf.train.Saver()\n _, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\n feed_dict=feed_dict)\n model.node_embedding[edge[0].index] = node_embeddings[edge[0].index]\n x = []\n y = []\n x.append([edge[1].index, edge[0].index])\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n #y.append(weight)\n y.append(1.0)\n for i in range(self.negative):\n nodeidx = model.table[np.random.randint(model.table_size)]\n if edge[1].index != nodeidx:\n x.append([edge[1].index, nodeidx])\n y.append(0.0)\n feed_dict = {\n pre.x: x,\n pre.y: y,\n pre.node_embeddings_init: model.node_embedding\n }\n \n #saver = tf.train.Saver()\n _, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\n feed_dict=feed_dict)\n\n #model.node_embedding = node_embeddings\n model.node_embedding[edge[1].index] = node_embeddings[edge[1].index]\n job_words += len(x)\n \n #log.info(\"train_loss: {}, node_embeddings = {}\".format(loss, model.node_embedding))\n \n #saver.restore(sess, INNER_MODEL_FILE)\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\n #job_words = len(x)\n jobs.task_done()\n lock.acquire(timeout=30)\n try:\n node_count[0] += job_words\n\n elapsed = time.time() - start\n if elapsed >= next_report[0]:\n log.info(\"PROGRESS: at %.2f%% \\tnode_computed %d\\talpha %.05f\\t %.0f nodes/s\" %\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\n finally:\n lock.release()","def do_inference(self, output_file = None):\n return","def worker(nums, outdict):\n print(threading.current_thread().name)\n print (\"pid:\", os.getpid())\n for n in nums:\n outdict[n] = factorize_naive(n)","def task_process(args):\n if args.mode == 'change model':\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n os.system('rm -rf ctpn_change_{}x{}.onnx'.format(h, w))\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n os.system('{} change_model.py --input_path={}/ctpn_{}x{}.onnx --output_path={}/ctpn_change_{}x{}.onnx' \\\n .format(args.interpreter, args.src_dir, h, w,args.res_dir, h, w)) \n if args.mode == 'preprocess':\n for i in range(config.center_len):\n os.system('mkdir -p {}_{}x{}'.format(args.res_dir, config.center_list[i][0], config.center_list[i][1]))\n os.system('{} ctpn_preprocess.py --src_dir={} --save_path={}' \\\n .format(args.interpreter, args.src_dir, args.res_dir))\n if args.mode == 'ais_infer':\n fps_all = 0\n os.system('mkdir -p {}/inf_output'.format(args.res_dir))\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n\n os.system('{} --model={} --input={}_{}x{} --dymHW {},{} --device {} --batchsize={} --output={}/inf_output' \\\n .format(args.interpreter, args.om_path, args.src_dir ,h , w, h, w,args.device, args.batch_size, args.res_dir))\n\n sumary_path = glob.glob('{}/inf_output/*ary.json'.format(args.res_dir))[0]\n with open(sumary_path, 'r') as f:\n output = json.load(f)\n throughput = output['throughput'] \n fps_all = fps_all + throughput * config.center_count[i]\n os.system('rm -f {}'.format(sumary_path))\n os.system('mv {}/inf_output/*/*.bin {}'.format(args.res_dir, args.res_dir))\n os.system('rm {}/inf_output -rf'.format(args.res_dir))\n fps_all = fps_all / config.imgs_len\n print(\"====performance data====\")\n print('CTPN bs{} models fps:{}'.format(args.batch_size, fps_all))","def _backend_run(self):\n results = None\n return results","def executor(self):","def worker_train():\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\n\n while True:\n job = jobs.get(block=True)\n if job is None: # data finished, exit\n jobs.task_done()\n # print('thread %s break' % threading.current_thread().name)\n break\n\n lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\n #lr = self.lr \n job_words = 0\n #out_i = 0\n for edge in job:\n if edge is not None:\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n neg_l = []\n #负样本node选取和主node不连通的点\n min_node0, min_conn_tup = sorted(model.connected_path[model.vocab_t[edge[0].index]].items(), key=lambda x:x[1][0])[0]\n min_conn0 = min_conn_tup[0]\n min_node1, min_conn_tup = sorted(model.connected_path[model.vocab_t[edge[1].index]].items(), key=lambda x:x[1][0])[0]\n min_conn1 = min_conn_tup[0]\n for i in range(self.negative):\n nodeidx = model.table[np.random.randint(model.table_size - 1)]\n if (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[0].index]]\n or (model.connected_path[model.vocab_t[edge[0].index]][model.vocab_t[nodeidx]][0] <= max(0.1,min_conn0))) \\\n and (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[1].index]]\n or (model.connected_path[model.vocab_t[edge[1].index]][model.vocab_t[nodeidx]][1] <= max(0.1,min_conn1))):\n neg_l.append(nodeidx)\n if len(neg_l) == 0:\n neg_l.append(model.vocab[min_node0].index)\n neg_l.append(model.vocab[min_node1].index)\n neg_np = np.asarray(neg_l)\n if weight >= 0.0:\n #job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, model.table,\n job_words += sum(train_o1(model.node_embedding, edge, lr, self.negative, neg_np,\n py_size=model.layer1_size, py_work=py_work) \n for i in range(1))\n #for i in range(int(10 * weight)))\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\n jobs.task_done()\n lock.acquire(timeout=30)\n try:\n node_count[0] += job_words\n\n elapsed = time.time() - start\n if elapsed >= next_report[0]:\n log.info(\"PROGRESS: at %.2f%% \\tnode_computed %d\\talpha %.05f\\t %.0f nodes/s\" %\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\n finally:\n lock.release()","def worker(self, q, return_dict):\n pid = os.getpid()\n while True:\n qqq = q.get()\n if qqq == 'DONE':\n # print('proc =', os.getpid())\n break\n\n (idx, d) = qqq\n mol_id = d[0]\n smi = d[1]\n # print screening processing in every pout step\n if self.pout != 0:\n if idx % self.pout == self.pout-1:\n print(\"processing: \", idx+1, flush=True)\n result_dict = self.simulation_process(idx, mol_id, smi, pid)\n return_dict[idx] = result_dict","def main_pipeline(self, image):\n # detection\n t0 = datetime.now()\n bbox_list, score_list, label_list = self.det.inference(image)\n t1 = datetime.now()\n logging.info('main pipeline (det): {}'.format(get_tdiff(t0, t1)))\n \n # estimation\n t0 = datetime.now()\n disp = self.est.inference(image)\n depth_list = self.est.calc_depth(bbox_list)\n t1 = datetime.now()\n logging.info('main pipeline (est): {}'.format(get_tdiff(t0, t1)))\n \n # tracker predict\n t0 = datetime.now()\n for t in self.t_list:\n t.predict()\n t1 = datetime.now()\n logging.info('main pipeline (trk_pred): {}'.format(get_tdiff(t0, t1)))\n \n # associate\n t0 = datetime.now()\n matched_pair, unmatched_bbox_list, _ = associate(bbox_list, label_list, self.t_list)\n t1 = datetime.now()\n logging.info('main pipeline (da_solver): {}'.format(get_tdiff(t0, t1)))\n \n t0 = datetime.now()\n # update trackers for matched_pair\n for m in matched_pair:\n t = self.t_list[m[1]]\n bbox = bbox_list[m[0]]\n depth = depth_list[m[0]]\n est_dict = {\n 'label': label_list[m[0]],\n 'score': score_list[m[0]]}\n t.update(self.frame_idx, bbox, depth, est_dict)\n \n # update in-track status of all trackers\n for t in self.t_list:\n t.update_status(self.frame_idx)\n \n # purge out dead trackers\n self.t_list = [t for t in self.t_list if t.get_status()]\n\n # create new trackers for unmatched_bbox_list\n for b_idx in unmatched_bbox_list:\n bbox = bbox_list[b_idx]\n depth = depth_list[b_idx]\n est_dict = {\n 'label': label_list[b_idx],\n 'score': score_list[b_idx]}\n self.t_list.append(tracker(self.t_cfg, self.tid_new, bbox, depth, est_dict))\n self.tid_new += 1\n\n t1 = datetime.now()\n logging.info('main pipeline (trk_upd): {}'.format(get_tdiff(t0, t1)))\n\n # disparity map for display\n return disp","def inference(self, image, score_threshold=None):\n h, w, c = image.shape\n image_batch = np.expand_dims(image, axis=0)\n # get operators from graph\n image_tensor = self.graph.get_tensor_by_name('image_tensor:0')\n detection_boxes = self.graph.get_tensor_by_name('detection_boxes:0')\n detection_scores = self.graph.get_tensor_by_name('detection_scores:0')\n detection_classes = self.graph.get_tensor_by_name('detection_classes:0')\n num_detections = self.graph.get_tensor_by_name('num_detections:0')\n # run inference\n with self.graph.as_default():\n t0 = datetime.now()\n (boxes, scores, classes, num) = self.sess.run(\n [detection_boxes, detection_scores, detection_classes, num_detections],\n feed_dict={image_tensor: image_batch})\n t1 = datetime.now()\n num = int(num)\n self._log_info('*TF Detection*: {}'.format(get_tdiff(t0, t1)))\n # post processing ...\n # purge useless dimension \n boxes, scores, classes = np.squeeze(boxes), np.squeeze(scores), np.squeeze(classes)\n # take only valid results\n boxes, scores, classes = boxes[:num,:], scores[:num], classes[:num]\n # score threshold\n if score_threshold is None:\n score_threshold = self.score_threshold\n boxes = boxes[scores>score_threshold,:]\n classes = classes[scores>score_threshold]\n scores = scores[scores>score_threshold]\n num = scores.shape[0]\n self._log_info('{} objects found'.format(num))\n # x-y reorder\n boxes = boxes[:,np.array([1,0,3,2])]\n # transform from 0-1 to 0-w and 0-h\n boxes = np.multiply(boxes, np.array([w,h,w,h])).astype(np.int32)\n return boxes, scores, classes","def post_postprocessor(result=None, **kw):\n logger.info(\"start post_postprocessor\")\n logger.info(result)\n logger.info(\"end post_postprocessor\")\n pass","async def train(self):","def main():\n # Grab command line args\n args = build_argparser().parse_args()\n #print(args)\n #Connect to the MQTT server\n client = connect_mqtt()\n #Perform inference on the input stream\n infer_on_stream(args, client)","def inference():\n data = request.get_json(force = True)\n\n with torch.no_grad():\n torch.cuda.empty_cache()\n image = ToTensor(Image.open(BytesIO(b64decode(data['image'])))).half().cuda().unsqueeze_(0)\n inputs = test_transform(image)\n model_id = model_usage.get(True)\n outputs = model[model_id](inputs)[0]\n model_usage.put(model_id, False)\n prediction = classes[outputs.argmax(0)]\n del inputs, outputs, image\n \n image_storage.put((data['esun_uuid'], data['image'], prediction), False)\n\n t = datetime.datetime.now()\n ts = str(int(t.utcnow().timestamp()))\n s = sha256()\n s.update((CAPTAIN_EMAIL + ts + SALT).encode(\"utf-8\"))\n server_uuid = s.hexdigest()\n\n return jsonify({'esun_uuid': data['esun_uuid'],\n 'server_uuid': server_uuid,\n 'answer': prediction,\n 'server_timestamp': time()})","def run_inference(wanted_words, sample_rate, clip_duration_ms,\n window_size_ms, window_stride_ms, dct_coefficient_count,\n model_architecture, model_size_info, use_mfcc,\n csv_writer):\n \n tf.logging.set_verbosity(tf.logging.INFO)\n sess = tf.InteractiveSession()\n words_list = input_data.prepare_words_list(wanted_words.split(','))\n model_settings = models.prepare_model_settings(\n len(words_list), sample_rate, clip_duration_ms, window_size_ms,\n window_stride_ms, dct_coefficient_count, use_mfcc)\n\n # audio_processor = input_data.AudioProcessor(\n audio_processor = AudioProcessor(\n FLAGS.data_url, FLAGS.data_dir, FLAGS.silence_percentage,\n FLAGS.unknown_percentage,\n FLAGS.wanted_words.split(','), FLAGS.validation_percentage,\n FLAGS.testing_percentage, model_settings)\n \n label_count = model_settings['label_count']\n fingerprint_size = model_settings['fingerprint_size']\n\n fingerprint_input = tf.placeholder(\n tf.float32, [None, fingerprint_size], name='fingerprint_input')\n\n logits = models.create_model(\n fingerprint_input,\n model_settings,\n FLAGS.model_architecture,\n FLAGS.model_size_info,\n is_training=False)\n\n # ground_truth_input = tf.placeholder(\n # tf.float32, [None, label_count], name='groundtruth_input')\n\n predicted_indices = tf.argmax(logits, 1)\n # expected_indices = tf.argmax(ground_truth_input, 1)\n # correct_prediction = tf.equal(predicted_indices, expected_indices)\n # confusion_matrix = tf.confusion_matrix(\n # expected_indices, predicted_indices, num_classes=label_count)\n # evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n models.load_variables_from_checkpoint(sess, FLAGS.checkpoint)\n\n # # training set\n # set_size = audio_processor.set_size('training')\n # tf.logging.info('set_size=%d', set_size)\n # total_accuracy = 0\n # total_conf_matrix = None\n # for i in xrange(0, set_size, FLAGS.batch_size):\n # training_fingerprints, training_ground_truth = (\n # audio_processor.get_data(FLAGS.batch_size, i, model_settings, 0.0,\n # 0.0, 0, 'training', sess))\n # training_accuracy, conf_matrix = sess.run(\n # [evaluation_step, confusion_matrix],\n # feed_dict={\n # fingerprint_input: training_fingerprints,\n # ground_truth_input: training_ground_truth,\n # })\n # batch_size = min(FLAGS.batch_size, set_size - i)\n # total_accuracy += (training_accuracy * batch_size) / set_size\n # if total_conf_matrix is None:\n # total_conf_matrix = conf_matrix\n # else:\n # total_conf_matrix += conf_matrix\n # tf.logging.info('Confusion Matrix:\\n %s' % (total_conf_matrix))\n # tf.logging.info('Training accuracy = %.2f%% (N=%d)' %\n # (total_accuracy * 100, set_size))\n #\n #\n # # validation set\n # set_size = audio_processor.set_size('validation')\n # tf.logging.info('set_size=%d', set_size)\n # total_accuracy = 0\n # total_conf_matrix = None\n # for i in xrange(0, set_size, FLAGS.batch_size):\n # validation_fingerprints, validation_ground_truth = (\n # audio_processor.get_data(FLAGS.batch_size, i, model_settings, 0.0,\n # 0.0, 0, 'validation', sess))\n # validation_accuracy, conf_matrix = sess.run(\n # [evaluation_step, confusion_matrix],\n # feed_dict={\n # fingerprint_input: validation_fingerprints,\n # ground_truth_input: validation_ground_truth,\n # })\n # batch_size = min(FLAGS.batch_size, set_size - i)\n # total_accuracy += (validation_accuracy * batch_size) / set_size\n # if total_conf_matrix is None:\n # total_conf_matrix = conf_matrix\n # else:\n # total_conf_matrix += conf_matrix\n # tf.logging.info('Confusion Matrix:\\n %s' % (total_conf_matrix))\n # tf.logging.info('Validation accuracy = %.2f%% (N=%d)' %\n # (total_accuracy * 100, set_size))\n \n # test set\n set_size = audio_processor.set_size('testing')\n tf.logging.info('set_size=%d', set_size)\n # total_accuracy = 0\n # total_conf_matrix = None\n expected_classes = []\n for i in xrange(0, set_size, FLAGS.batch_size):\n # test_fingerprints, test_ground_truth = audio_processor.get_data(\n # FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'testing', sess)\n # test_accuracy, conf_matrix = sess.run(\n # [evaluation_step, confusion_matrix],\n # feed_dict={\n # fingerprint_input: test_fingerprints,\n # ground_truth_input: test_ground_truth,\n # })\n test_fingerprints, test_fnames = audio_processor.get_data(\n FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'testing', sess)\n expected_classes = sess.run(\n predicted_indices,\n feed_dict={\n fingerprint_input: test_fingerprints,\n })\n # batch_size = min(FLAGS.batch_size, set_size - i)\n # print (\"i, len(expeceted_classes), len(test_fnames)=\", i, len(expected_classes), len(test_fnames))\n for j in range(min(FLAGS.batch_size, set_size - i)):\n csv_writer.writerow([test_fnames[j], class_labels[expected_classes[j]]])\n # total_accuracy += (test_accuracy * batch_size) / set_size\n # if total_conf_matrix is None:\n # total_conf_matrix = conf_matrix\n # else:\n # total_conf_matrix += conf_matrix\n # tf.logging.info('Confusion Matrix:\\n %s' % (total_conf_matrix))\n # tf.logging.info('Test accuracy = %.2f%% (N=%d)' % (total_accuracy * 100,\n # set_size))","def main():\n \n \n # Grab command line args\n args = build_argparser().parse_args()\n # Connect to the MQTT server\n client = connect_mqtt()\n # Perform inference on the input stream\n infer_on_stream(args, client)","def post_work(self, frames_rec: int, frames_proc: int, nooo: int):\r\n raise NotImplementedError","def postprocess(run_results, postprocess_func):\n G_LOGGER.start(f\"Applying post-processing to outputs: {postprocess_func.__name__}\")\n for _, iteration_results in run_results:\n for index, iter_res in enumerate(iteration_results):\n iteration_results[index] = postprocess_func(iter_res)\n G_LOGGER.finish(\"Finished applying post-processing\")\n return run_results","def main():\n args = get_arguments()\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n \n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(\n args.data_dir,\n args.data_list,\n None, # No defined input size.\n False, # No random scale.\n False, # No random mirror.\n args.ignore_label,\n IMG_MEAN,\n coord)\n image, label = reader.image, reader.label\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\n\n # Create network.\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\n\n # Which variables to load.\n restore_var = tf.global_variables()\n \n # Predictions.\n raw_output = net.layers['fc_out']\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\n raw_output = tf.argmax(raw_output, dimension=3)\n pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\n\n # mIoU\n\n pred_flatten = tf.reshape(pred, [-1,])\n gt = tf.reshape(label_batch, [-1,])\n weights = tf.cast(tf.less_equal(gt, args.num_classes - 1), tf.int32) # Ignoring all labels greater than or equal to n_classes.\n mIoU, update_op = tf.contrib.metrics.streaming_mean_iou(predictions=pred_flatten, labels=gt, num_classes=args.num_classes, weights=weights)\n \n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True \n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n sess.run(tf.local_variables_initializer())\n \n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n\n ckpt = tf.train.get_checkpoint_state(SNAPSHOT_DIR)\n\n if ckpt and ckpt.model_checkpoint_path:\n loader = tf.train.Saver(var_list=restore_var)\n load_step = int(os.path.basename(ckpt.model_checkpoint_path).split('-')[1])\n load(loader, sess, ckpt.model_checkpoint_path)\n else:\n print('No checkpoint file found.')\n load_step = 0\n\n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n\n if not os.path.exists(SAVE_DIR):\n os.makedirs(SAVE_DIR)\n\n for step in range(args.num_steps):\n preds, _ = sess.run([pred, update_op])\n\n if IS_SAVE == True:\n msk = decode_labels(preds, num_classes=args.num_classes)\n im = Image.fromarray(msk[0])\n filename = 'mask' + str(step) + '.png'\n im.save(SAVE_DIR + filename)\n\n if step % 10 == 0:\n print('step {0} mIoU: {1}'.format(step, mIoU.eval(session=sess)))\n\n coord.request_stop()\n coord.join(threads)","def process(self, sess):\n global send_counter\n \n #sess.run(self.sync) # copy weights from shared to local\n rollout = self.pull_batch_from_queue()\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\n\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\n\n if should_compute_summary:\n fetches = [self.summary_op, self.train_op]\n else:\n fetches = [self.train_op]\n\n\n feed_dict = {\n self.local_network.x: batch.si,\n self.ac: batch.a,\n self.adv: batch.adv,\n self.r: batch.r,\n self.local_network.state_in[0]: batch.features[0],\n self.local_network.state_in[1]: batch.features[1],\n }\n\n # Get current trainable variables\n # This is trainable variables\n fetched = sess.run(fetches, feed_dict=feed_dict)\n\n\n if self.num_workers > 1:\n sys.stdout.write('\\r' + str(self.local_steps))\n if self.local_steps % 100 == 0:\n global var0\n global var1\n var1 = sess.run(self.local_network.var_list) # After training\n if var0 != None:\n var_diff = [a - b for (a,b) in zip(var1, var0)]\n var_diff_data = pickle.dumps(var_diff, -1)\n print('Sync weights')\n self.msg_sent = socket_util.socket_send_data_chucks(self.sock, var_diff_data, self.mcast_destination, self.msg_sent)\n var0 = sess.run(self.local_network.var_list) # A list of numpy array\n\n # Handle each message in the socket queue\n while not self.inc_msg_q.empty():\n print('Apply remote gradients')\n # Process received grads_and_vars from other peers\n remote_var_diff_data = self.inc_msg_q.get(False)\n remote_var_diff = pickle.loads(remote_var_diff_data)\n\n add_op = [a+b for (a,b) in zip(self.local_network.var_list, remote_var_diff)]\n sess.run(add_op)\n\n if should_compute_summary:\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]))\n self.summary_writer.flush()\n self.local_steps += 1","def handle_predictions(predict_fn, request_queue, response_queue):\n loop_times = []\n queue_get_times = []\n handle_times = []\n handle_start_times = []\n # trial_start = datetime.now()\n pred_count = 0\n loop_count = 0\n\n # last_loop_start = datetime.now()\n # loop_dur_file = \"/logs/loop_duration.log\"\n # handle_dur_file = \"/logs/handle_duration.log\"\n # handle_dur_file = \"/logs/handle_duration.log\"\n\n # Field order: clock_time, user time, sys time\n # kernel_measures = False\n # if not os.path.exists(\"/logs\"):\n # os.makedirs(\"/logs\")\n #\n # kernel_instr_file = \"/logs/kernel_measures.csv\"\n\n # with open(loop_dur_file, \"w\") as ld, open(handle_dur_file, \"w\") as hd:\n\n # with open(kernel_instr_file, \"w\") as kd:\n # kd.write(\"wall_clock_secs, user_clock_ticks, kernel_clock_ticks\\n\")\n while True:\n # cur_loop_start = datetime.now()\n # loop_duration = (cur_loop_start - last_loop_start).microseconds\n # loop_times.append(loop_duration)\n # ld.write(\"{}\\n\".format(loop_duration))\n # last_loop_start = cur_loop_start\n\n # t1 = datetime.now()\n prediction_request, recv_time = request_queue.get(block=True)\n # t2 = datetime.now()\n # queue_get_times.append((t2 - t1).microseconds)\n\n # handle_start_times.append(time.time()*1000)\n before_predict_lineage_point = datetime.now()\n # proc_stat_before = check_output([\"cat\", \"/proc/1/stat\"]).strip().split()\n # user_before = int(proc_stat_before[13])\n # sys_before = int(proc_stat_before[14])\n\n\n outputs = predict_fn(prediction_request.inputs)\n # proc_stat_after = check_output([\"cat\", \"/proc/1/stat\"]).strip().split()\n # user_after = int(proc_stat_after[13])\n # sys_after = int(proc_stat_after[14])\n\n after_predict_lineage_point = datetime.now()\n # clock_time = (after_predict_lineage_point - before_predict_lineage_point).total_seconds()\n # user_time = user_after - user_before\n # sys_time = sys_after - sys_before\n # user_time = 0\n # sys_time = 0\n # kd.write(\"{clock},{user},{kernel}\\n\".format(clock=clock_time, user=user_time, kernel=sys_time))\n\n if loop_count <= 50 and loop_count % 10 == 0:\n print((after_predict_lineage_point - before_predict_lineage_point).total_seconds())\n\n pred_count += len(prediction_request.inputs)\n # t3 = datetime.now()\n # handle_times.append((t3 - t2).microseconds)\n # hd.write(\"{}\\n\".format((t3 - t2).microseconds))\n # Type check the outputs:\n if not type(outputs) == list:\n raise PredictionError(\"Model did not return a list\")\n if len(outputs) != len(prediction_request.inputs):\n raise PredictionError(\n \"Expected model to return %d outputs, found %d outputs\" %\n (len(prediction_request.inputs), len(outputs)))\n\n outputs_type = type(outputs[0])\n if outputs_type == np.ndarray:\n outputs_type = outputs[0].dtype\n if outputs_type not in SUPPORTED_OUTPUT_TYPES_MAPPING.keys():\n raise PredictionError(\n \"Model outputs list contains outputs of invalid type: {}!\".\n format(outputs_type))\n\n if outputs_type == str:\n for i in range(0, len(outputs)):\n outputs[i] = unicode(outputs[i], \"utf-8\").encode(\"utf-8\")\n else:\n for i in range(0, len(outputs)):\n outputs[i] = outputs[i].tobytes()\n\n total_length_elements = sum(len(o) for o in outputs)\n\n response = PredictionResponse(prediction_request.msg_id,\n len(outputs), total_length_elements,\n outputs_type)\n for output in outputs:\n response.add_output(output)\n\n response_queue.put((response, recv_time,\n before_predict_lineage_point,\n after_predict_lineage_point))\n # response_queue.put((response, recv_time,\n # None,\n # None))\n\n # if len(loop_times) > 1000:\n # print(\"\\nLoop duration: {} +- {}\".format(np.mean(loop_times), np.std(loop_times)))\n # print(\"Request dequeue duration: {} +- {}\".format(np.mean(queue_get_times), np.std(queue_get_times)))\n # print(\"Handle duration: {} +- {}\".format(np.mean(handle_times), np.std(handle_times)))\n # # throughput = float(pred_count) / (datetime.now() - trial_start).total_seconds()\n # # print(\"Throughput: {}\".format(throughput))\n # # ld.flush()\n # # hd.flush()\n # # kd.flush()\n #\n # loop_times = []\n # queue_get_times = []\n # handle_times = []\n # pred_count = 0\n # trial_start = datetime.now()\n\n # if len(handle_start_times) % 200 == 0:\n # print(json.dumps(handle_start_times))\n loop_count += 1\n sys.stdout.flush()\n sys.stderr.flush()","def run():\n if am_i_root():\n\n print(\"*** initializing...\")\n\n # Print parameters\n print(\"N_DIMS = \" + str(N_DIMS))\n print(\"LAMBDA_OVER_DX = \" + str(LAMBDA_OVER_DX))\n print(\"R_DT = \" + str(R_DT))\n print(\"MU0_POISSON = \" + str(MU0_POISSON))\n print(\"NORM_POISSON = \" + NORM_POISSON)\n print(\"N_GRID = \" + str(N_GRID))\n print(\"N_HITS = \" + str(N_HITS))\n print(\"POLICY = \" + str(POLICY))\n if POLICY == -1:\n print(\"MODEL_PATH = \" + str(MODEL_PATH))\n else:\n print(\"STEPS_AHEAD = \" + str(STEPS_AHEAD))\n print(\"EPSILON = \" + str(EPSILON))\n print(\"STOP_t = \" + str(STOP_t))\n print(\"STOP_p = \" + str(STOP_p))\n print(\"N_PARALLEL = \" + str(N_PARALLEL))\n print(\"WITH_MPI = \" + str(WITH_MPI))\n print(\"ADAPTIVE_N_RUNS = \" + str(ADAPTIVE_N_RUNS))\n print(\"REL_TOL = \" + str(REL_TOL))\n print(\"MAX_N_RUNS = \" + str(MAX_N_RUNS))\n print(\"N_RUNS(input) = \" + str(N_RUNS))\n sys.stdout.flush()\n\n # Perform runs\n if am_i_root():\n print(\"*** generating episodes...\")\n\n N_runs = N_RUNS\n if ADAPTIVE_N_RUNS or WITH_MPI:\n N_runs = int(N_PARALLEL * (np.ceil(N_runs / N_PARALLEL))) # make it multiple of N_PARALLEL\n if am_i_root():\n print(\"N_RUNS(current) = \" + str(N_runs))\n sys.stdout.flush()\n\n N_runso = 0\n\n if WITH_MPI:\n cdf_t_tot_loc = np.zeros(LEN_CDF_T, dtype=float)\n cdf_h_tot_loc = np.zeros(LEN_CDF_H, dtype=float)\n mean_t_loc = np.nan * np.ones(MAX_N_RUNS // N_PARALLEL, dtype=float)\n failed_loc = - np.ones(MAX_N_RUNS // N_PARALLEL, dtype=float)\n else:\n cdf_t_tot = np.zeros(LEN_CDF_T, dtype=float)\n cdf_h_tot = np.zeros(LEN_CDF_H, dtype=float)\n mean_t_episodes = np.nan * np.ones(MAX_N_RUNS, dtype=float)\n failed_episodes = - np.ones(MAX_N_RUNS, dtype=float)\n\n while True:\n if WITH_MPI: # MPI\n if N_runs % N_PARALLEL != 0:\n raise Exception(\"N_runs must be multiple of N_PARALLEL with MPI\")\n COMM.Barrier()\n # Decomposition\n Nepisodes = N_runs // N_PARALLEL\n episode_list = range(N_runso + ME, N_runs, N_PARALLEL)\n # Run episodes and reduce locally\n ind = N_runso // N_PARALLEL\n for episode in episode_list:\n cdf_t, cdf_h, mean_t_loc[ind], failed_loc[ind] = Worker(episode)\n cdf_t_tot_loc += cdf_t\n cdf_h_tot_loc += cdf_h\n ind += 1\n\n # Reduce globally the mean_t and failed\n mean_t_episodes = np.empty([N_runs], dtype=float)\n failed_episodes = np.empty([N_runs], dtype=float)\n COMM.Barrier()\n COMM.Allgather([mean_t_loc[:ind], Nepisodes, MPI.DOUBLE], [mean_t_episodes, Nepisodes, MPI.DOUBLE])\n COMM.Allgather([failed_loc[:ind], Nepisodes, MPI.DOUBLE], [failed_episodes, Nepisodes, MPI.DOUBLE])\n COMM.Barrier()\n elif N_PARALLEL > 1: # multiprocessing\n # Run episodes in parallel\n pool = multiprocessing.Pool(N_PARALLEL)\n result = pool.map(Worker, range(N_runso, N_runs))\n pool.close()\n pool.join()\n # Reduce\n ind = N_runso\n for cdf_t, cdf_h, mean_t, failed in result:\n cdf_t_tot += cdf_t\n cdf_h_tot += cdf_h\n mean_t_episodes[ind] = mean_t\n failed_episodes[ind] = failed\n ind += 1\n elif N_PARALLEL == 1: # sequential\n ind = N_runso\n for episode in range(N_runso, N_runs):\n cdf_t, cdf_h, mean_t, failed = Worker(episode)\n cdf_t_tot += cdf_t\n cdf_h_tot += cdf_h\n mean_t_episodes[ind] = mean_t\n failed_episodes[ind] = failed\n ind += 1\n else:\n raise Exception(\"Problem with N_PARALLEL: must be an int >= 1\")\n\n # estimate of the error\n mean_ep = np.mean(mean_t_episodes[:N_runs])\n sigma_ep = np.std(mean_t_episodes[:N_runs])\n std_error_mean = sigma_ep / np.sqrt(N_runs)\n rel_std_error_mean = std_error_mean / mean_ep\n\n # break clause\n if not ADAPTIVE_N_RUNS:\n break\n else:\n if rel_std_error_mean < REL_TOL:\n break\n elif N_runs >= MAX_N_RUNS:\n break\n else:\n N_runso = N_runs\n N_runs = int(np.ceil(1.05 * (sigma_ep / mean_ep / REL_TOL) ** 2))\n N_runs = min(N_runs, MAX_N_RUNS)\n N_runs = int(N_PARALLEL * (np.ceil(N_runs / N_PARALLEL))) # make it multiple of N_PARALLEL\n if am_i_root():\n print(\"N_RUNS(current) = \" + str(N_runs))\n sys.stdout.flush()\n\n if am_i_root():\n print(\"N_RUNS(performed) = \" + str(N_runs))\n sys.stdout.flush()\n\n # Reduce\n if am_i_root():\n print(\"*** post-processing...\")\n if WITH_MPI:\n # locally\n cdf_t_tot_loc /= N_runs\n cdf_h_tot_loc /= N_runs\n # Reduce globally\n cdf_t_tot = np.empty([LEN_CDF_T], dtype=float)\n cdf_h_tot = np.empty([LEN_CDF_H], dtype=float)\n COMM.Barrier()\n COMM.Allreduce(cdf_t_tot_loc, cdf_t_tot, op=MPI.SUM)\n COMM.Allreduce(cdf_h_tot_loc, cdf_h_tot, op=MPI.SUM)\n COMM.Barrier()\n else:\n cdf_t_tot /= N_runs\n cdf_h_tot /= N_runs\n mean_t_episodes = mean_t_episodes[:N_runs]\n failed_episodes = failed_episodes[:N_runs]\n\n # Further post-processing, save and plot\n if am_i_root():\n\n # from cdf to pdf\n pdf_t_tot = cdf_to_pdf(cdf_t_tot)\n pdf_h_tot = cdf_to_pdf(cdf_h_tot)\n\n # compute stats of number of steps and number of hits\n t_bins = np.arange(BIN_START_T, BIN_END_T, BIN_SIZE_T) + 0.5 * BIN_SIZE_T\n mean_t, sigma_t, skew_t, kurt_t, p_found = stats_from_pdf(t_bins, pdf_t_tot)\n p25_t, p50_t, p75_t, p90_t, p95_t, p99_t, _ = stats_from_cdf(t_bins, cdf_t_tot)\n\n h_bins = np.arange(BIN_START_H, BIN_END_H, BIN_SIZE_H) + 0.5 * BIN_SIZE_H\n mean_h, sigma_h, skew_h, kurt_h, _ = stats_from_pdf(h_bins, pdf_h_tot)\n p25_h, p50_h, p75_h, p90_h, p95_h, p99_h, _ = stats_from_cdf(h_bins, cdf_h_tot)\n\n print(\"probability that the source is never found : %.10f\" % (1.0 - p_found, ))\n print(\"mean number of steps to find the source : %.3f +/- %.3f\" % (mean_t, 1.96 * std_error_mean))\n print(\"number of steps to find the source with 50 %% probability: %.3f\" % p50_t)\n print(\"number of steps to find the source with 99 %% probability: %.3f\" % p99_t)\n nb_failed = np.sum(failed_episodes)\n if np.any(failed_episodes < 0):\n nb_failed = -1\n print(\"problem while recording failures\")\n else:\n print(\"number of failed episodes : %d / %d (%f %%)\"\n % (nb_failed, N_runs, nb_failed / N_runs * 100))\n sys.stdout.flush()\n\n # save all parameters to txt file\n inputs = {\n \"N_DIMS\": N_DIMS,\n \"LAMBDA_OVER_DX\": LAMBDA_OVER_DX,\n \"R_DT\": R_DT,\n \"MU0_POISSON\": MU0_POISSON,\n \"NORM_POISSON\": NORM_POISSON,\n \"N_GRID\": N_GRID,\n \"N_HITS\": N_HITS,\n \"POLICY\": POLICY,\n \"STEPS_AHEAD\": STEPS_AHEAD,\n \"MODEL_PATH\": MODEL_PATH,\n \"STOP_t\": STOP_t,\n \"STOP_p\": STOP_p,\n \"ADAPTIVE_N_RUNS\": ADAPTIVE_N_RUNS,\n \"REL_TOL\": REL_TOL,\n \"MAX_N_RUNS\": MAX_N_RUNS,\n \"N_RUNS_PERFORMED\": N_runs,\n \"BIN_START_T\": BIN_START_T,\n \"BIN_END_T\": BIN_END_T,\n \"BIN_SIZE_T\": BIN_SIZE_T,\n \"BIN_START_H\": BIN_START_H,\n \"BIN_END_H\": BIN_END_H,\n \"BIN_SIZE_H\": BIN_SIZE_H,\n \"EPSILON\": EPSILON,\n }\n param_txt_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_parameters\" + \".txt\"))\n with open(param_txt_file, 'w') as out:\n for key, val in inputs.items():\n print(key + \" = \" + str(val), file=out)\n\n # save stats\n stats_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_statistics\" + \".txt\"))\n with open(stats_file, \"w\") as sfile:\n sfile.write(\"p_not_found\\t%+.4e\\n\" % (1 - p_found,))\n for varname in \\\n ('mean_t', 'sigma_t', 'skew_t', 'kurt_t', 'p25_t', 'p50_t', 'p75_t', 'p90_t', 'p95_t', 'p99_t'):\n sfile.write(\"%s\\t\\t%+.4e\\n\" % (varname, locals()[varname]))\n for varname in \\\n ('mean_h', 'sigma_h', 'skew_h', 'kurt_h', 'p25_h', 'p50_h', 'p75_h', 'p90_h', 'p95_h', 'p99_h'):\n sfile.write(\"%s\\t\\t%+.4e\\n\" % (varname, locals()[varname]))\n\n # save CDF of number of steps\n table_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_table_CDF_nsteps\" + \".npy\"))\n np.save(table_file, np.vstack((t_bins, cdf_t_tot)))\n\n # save CDF of number of hits\n table_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_table_CDF_nhits\" + \".npy\"))\n np.save(table_file, np.vstack((h_bins, cdf_h_tot)))\n\n # create and save figures\n if POLICY == -1:\n specifics = \"MODEL = \" + os.path.basename(MODEL_PATH)\n else:\n specifics = \"STEPS_AHEAD = \" + str(STEPS_AHEAD)\n subtitle = (\n \"N_DIMS = \"\n + str(N_DIMS)\n + \", \"\n + \"LAMBDA_OVER_DX = \"\n + str(LAMBDA_OVER_DX)\n + \", \"\n + \"R_DT = \"\n + str(R_DT)\n + \", \"\n + \"POLICY = \"\n + str(POLICY)\n + \", \"\n + specifics\n + \", \"\n + \"N_GRID = \"\n + str(N_GRID)\n + \", \"\n + \"N_HITS = \"\n + str(N_HITS)\n + \", \"\n + \"N_RUNS = \"\n + str(N_runs)\n + \"\\n\"\n )\n\n # plot PDF(nsteps), CDF(nsteps), PDF(nhits), CDF(nhits)\n fig, ax = plt.subplots(2, 2, figsize=(12, 10))\n plt.subplots_adjust(left=0.08, bottom=0.06, right=0.96, top=0.92, hspace=0.35, wspace=0.30)\n kwargs = {'xycoords': 'axes fraction', 'fontsize': 8, 'ha': \"right\"}\n for row, varname in enumerate([\"number of steps\", \"number of hits\"]):\n if varname == \"number of steps\":\n bins = t_bins\n cdf_tot = cdf_t_tot\n pdf_tot = pdf_t_tot\n mean = mean_t\n sigma = sigma_t\n skew = skew_t\n kurt = kurt_t\n p50 = p50_t\n p75 = p75_t\n p90 = p90_t\n p99 = p99_t\n filesuffix = 'nsteps'\n color = \"tab:blue\"\n else:\n bins = h_bins\n cdf_tot = cdf_h_tot\n pdf_tot = pdf_h_tot\n mean = mean_h\n sigma = sigma_h\n skew = skew_h\n kurt = kurt_h\n p50 = p50_h\n p75 = p75_h\n p90 = p90_h\n p99 = p99_h\n filesuffix = 'nhits'\n color = \"tab:orange\"\n max_x = bins[np.nonzero(pdf_tot)[0][-1]]\n for col, fct in enumerate([\"PDF\", \"CDF\"]):\n if fct == \"PDF\":\n ydata = pdf_tot\n ylim = (0.0, 1.02 * np.max(pdf_tot))\n elif fct == \"CDF\":\n ydata = cdf_tot\n ylim = (0.0, 1.0)\n\n ax[row, col].plot(bins, ydata, \"-o\", color=color, markersize=2, linewidth=1)\n ax[row, col].set_title(fct + \" of \" + varname)\n ax[row, col].set_xlabel(varname + \" to find the source\")\n ax[row, col].set_xlim((0, max_x))\n ax[row, col].set_ylim(ylim)\n\n if fct == \"PDF\":\n ax[row, col].annotate(\"p_not_found = \" + \"{:.3e}\".format(1.0 - p_found), xy=(0.98, 0.60), **kwargs)\n ax[row, col].annotate(\"mean = \" + \"{:.3e}\".format(mean), xy=(0.98, 0.56), **kwargs)\n ax[row, col].annotate(\"std = \" + \"{:.3e}\".format(sigma), xy=(0.98, 0.52), **kwargs)\n ax[row, col].annotate(\"skew = \" + \"{:.3e}\".format(skew), xy=(0.98, 0.48), **kwargs)\n ax[row, col].annotate(\"ex. kurt = \" + \"{:.3e}\".format(kurt), xy=(0.98, 0.44), **kwargs)\n elif fct == \"CDF\":\n ax[row, col].annotate(\"p_not_found = \" + \"{:.3e}\".format(1.0 - p_found), xy=(0.98, 0.60), **kwargs)\n ax[row, col].annotate(\"P50 = \" + \"{:.3e}\".format(p50), xy=(0.98, 0.56), **kwargs)\n ax[row, col].annotate(\"P75 = \" + \"{:.3e}\".format(p75), xy=(0.98, 0.52), **kwargs)\n ax[row, col].annotate(\"P90 = \" + \"{:.3e}\".format(p90), xy=(0.98, 0.48), **kwargs)\n ax[row, col].annotate(\"P99 = \" + \"{:.3e}\".format(p99), xy=(0.98, 0.44), **kwargs)\n plt.grid(False)\n plt.figtext(0.5, 0.985, subtitle, fontsize=7, ha=\"center\", va=\"top\")\n plt.draw()\n figure_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_figure_distributions.pdf\"))\n fig.savefig(figure_file)\n plt.close(fig)\n\n # plot mean nb steps vs number of episodes\n number_episodes = range(1, N_runs + 1)\n cum_mean_t_episodes = np.cumsum(mean_t_episodes) / number_episodes\n if N_runs >= 100:\n number_episodes = number_episodes[20:]\n cum_mean_t_episodes = cum_mean_t_episodes[20:]\n fig, ax = plt.subplots()\n ax.plot(number_episodes, cum_mean_t_episodes, color=\"r\")\n ax.set_title(\"Convergence of the mean number of steps\")\n ax.set_xlabel(\"number of episodes\")\n ax.set_ylabel(\"mean number of steps\")\n plt.figtext(0.5, 0.985, subtitle, fontsize=5, ha=\"center\", va=\"top\")\n plt.grid(False)\n plt.draw()\n figure_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_figure_convergence.pdf\"))\n fig.savefig(figure_file)\n plt.close(fig)\n\n # save monitoring information (concatenate episodes files)\n monitoring_episodes_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_monitoring_episodes.txt\"))\n filenames = [os.path.join(DIR_TMP, str(\"monitoring_episode_\" + str(episode) + \".txt\")) for episode in range(N_runs)]\n with open(monitoring_episodes_file, \"w\") as mfile:\n mfile.write(\"# episode\\thit_init\\tstop_flag\\tboundary_flag\\t\"\n \"p_not_found\\t\\tmean_nsteps\\t\\ttime_elapsed(sec)\\n\")\n for fname in filenames:\n if os.path.isfile(fname):\n with open(fname) as infile:\n mfile.write(infile.read())\n os.remove(fname)\n else:\n print(\"Unexpected: Missing episode file: \" + str(fname))\n\n # clean up tmp dirs\n if len(os.listdir(DIR_TMP)) != 0:\n print(\"Unexpected: The directory '\" + DIR_TMP\n + \"' is not removed, because it should be empty but is not.\")\n else:\n os.rmdir(DIR_TMP)\n if len(os.listdir(PARENT_DIR_TMP)) == 0:\n os.rmdir(PARENT_DIR_TMP)\n\n # summary\n monitoring_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \"_monitoring_summary\" + \".txt\"))\n with open(monitoring_file, \"w\") as mfile:\n mfile.write(\"*** initial hit ***\\n\")\n first_hit = np.loadtxt(monitoring_episodes_file, usecols=1, dtype='int')\n hit_max = np.max(first_hit)\n hit_hist, _ = np.histogram(first_hit, bins=np.arange(0.5, hit_max + 1.5), density=True)\n for h in range(1, hit_max + 1):\n mfile.write(\"hit=%1d: %6.2f %% \\n\" % (h, hit_hist[h - 1] * 100))\n\n mfile.write(\"\\n*** stats convergence ***\\n\")\n mfile.write(\"number of episodes simulated : %d\\n\" % N_runs)\n mfile.write(\"standard error of the mean (estimate): %.4e = %5.2f %%\\n\"\n % (std_error_mean, rel_std_error_mean * 100))\n\n stopping_reason = np.loadtxt(monitoring_episodes_file, usecols=2, dtype='int')\n stop_max = np.max(stopping_reason)\n stopping_hist, _ = np.histogram(stopping_reason, bins=np.arange(0.5, stop_max + 1.5), density=True)\n mfile.write(\"\\n*** reason for stopping (1 is success, anything else is failure) ***\\n\")\n for stop in range(1, stop_max + 1):\n mfile.write(\"stop=%1d: %6.2f %% \\n\" % (stop, stopping_hist[stop - 1] * 100))\n\n mfile.write(\"\\n*** probability that the source is not found at the end of the episodes ***\\n\")\n p_not_found = np.loadtxt(monitoring_episodes_file, usecols=4)\n p_gtr_stop = p_not_found[p_not_found > STOP_p]\n p_not_found_max = np.max(p_not_found)\n mfile.write(\"criteria (STOP_p): %.5e\\n\" % STOP_p)\n mfile.write(\"max(p) : %.5e\\n\" % p_not_found_max)\n mfile.write(\"number of episodes where p > STOP_p: %7d (%8.4f %%)\\n\"\n % (len(p_gtr_stop), len(p_gtr_stop) / N_runs * 100))\n\n near_boundaries = np.loadtxt(monitoring_episodes_file, usecols=3, dtype='int')\n near_boundaries = np.count_nonzero(near_boundaries)\n mfile.write(\"\\n*** agent near boundaries ***\\n\")\n mfile.write(\"number of episodes where it happened: %7d (%8.4f %%)\\n\"\n % (near_boundaries, near_boundaries / N_runs * 100))\n\n episode_elapsed = np.loadtxt(monitoring_episodes_file, usecols=5)\n mfile.write(\"\\n*** computational cost per episode ***\\n\")\n mfile.write(\"avg elapsed seconds per episode: %.5e\\n\" % (np.mean(episode_elapsed)))\n mfile.write(\"max elapsed seconds per episode: %.5e\\n\" % (np.max(episode_elapsed)))\n\n elapsed_time_0 = (time.monotonic() - start_time_0) / 3600.0\n mfile.write(\"\\n*** computational cost ***\\n\")\n mfile.write(\"N_PARALLEL = %d\\n\" % N_PARALLEL)\n mfile.write(\"total elapsed hours : %.5e\\n\" % elapsed_time_0)\n mfile.write(\"cost in hours = total elapsed time * N_PARALLEL: %.5e\\n\" % (elapsed_time_0 * N_PARALLEL))\n\n print(\">>> Results saved in the directory: \" + DIR_OUTPUTS)\n\n sys.stdout.flush()","def worker_train():\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\n\n while True:\n job = jobs.get(block=True)\n if job is None: # data finished, exit\n jobs.task_done()\n # print('thread %s break' % threading.current_thread().name)\n break\n\n #lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\n lr = self.lr \n job_words = 0\n for edge in job:\n if edge is not None:\n if cluster_negtivate:\n node_set = set()\n if model.vocab_t[edge[0].index] not in nodeid2cluster:\n cls1 = -1\n else:\n cls1 = nodeid2cluster[model.vocab_t[edge[0].index]]\n node_set.add(cls1)\n if model.vocab_t[edge[1].index] not in nodeid2cluster:\n cls2 = -1\n else:\n cls2 = nodeid2cluster[model.vocab_t[edge[1].index]]\n node_set.add(cls2)\n neg_l = []\n #选择的负样本的node必须是有明确类别归属的\n for i in range(self.negative):\n nodeidx = model.table[np.random.randint(model.table_size)]\n if model.vocab_t[nodeidx] not in nodeid2cluster:\n i-=1\n continue\n else:\n cls_n = nodeid2cluster[model.vocab_t[nodeidx]]\n #加入不同边限制 G 里存放的是nodeid，不是idx\n if cls_n not in node_set and model.vocab_t[nodeidx] not in G[model.vocab_t[edge[0].index]] \\\n and model.vocab_t[nodeidx] not in G[model.vocab_t[edge[1].index]]:\n neg_l.append(nodeidx)\n neg_np = np.asarray(neg_l)\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n if weight > 0.0 and len(neg_np) > 0:\n #job_words += sum(train_o1(model.node_embedding, edge, lr, int(10 * (weight)) * self.negative, neg_np,\n # py_size=model.layer1_size, py_work=py_work) \n # for i in range(1))\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, neg_np,\n py_size=model.layer1_size, py_work=py_work) \n for i in range(1))\n elif len(neg_np) == 0:\n #job_words += sum(train_o1(model.node_embedding, edge, lr, 0, neg_np,\n # py_size=model.layer1_size, py_work=py_work) \n # for i in range(1))\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, 0, neg_np,\n py_size=model.layer1_size, py_work=py_work) \n for i in range(1))\n else:\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\n if weight >= 0.1:\n #job_words += sum(train_o1(model.node_embedding, edge, lr, int(10 * (weight)) * self.negative, model.table,\n # py_size=model.layer1_size, py_work=py_work) \n # for i in range(1))\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, model.table,\n py_size=model.layer1_size, py_work=py_work) \n for i in range(1))\n #for i in range(int(10 * weight)))\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\n jobs.task_done()\n lock.acquire(timeout=30)\n try:\n node_count[0] += job_words\n\n elapsed = time.time() - start\n if elapsed >= next_report[0]:\n log.info(\"PROGRESS: at %.2f%% \\tnode_computed %d\\talpha %.05f\\t %.0f nodes/s\" %\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\n finally:\n lock.release()","def main():\n #global comm, rank, args\n #comm = MPI.COMM_WORLD\n #rank = comm.Get_rank()\n rank = 0\n\n parser = argparse.ArgumentParser(description=\"Receive data and dispatch\" +\n \"analysis tasks to a mpi queue\")\n parser.add_argument('--config', type=str, help='Lists the configuration file',\n default='configs/config-middle.json')\n parser.add_argument(\"--transport_rx\", help=\"Specifies the name of the transport section that is used to configure the reader\",\n default=\"transport_rx\")\n parser.add_argument(\"--transport_tx\", help=\"Specifies the name of the transport section that is used to configure the writer\",\n default=\"transport_tx\")\n args = parser.parse_args()\n\n with open(args.config, \"r\") as df:\n cfg = json.load(df)\n timeout = 120\n\n # The middleman uses both a reader and a writer. Each is configured with using\n # their respective section of the config file. Therefore some keys are duplicated,\n # such as channel_range. Make sure that these items are the same in both sections\n\n with open(\"configs/logger.yaml\", \"r\") as f:\n log_cfg = yaml.safe_load(f.read())\n logging.config.dictConfig(log_cfg)\n logger = logging.getLogger('middleman')\n\n # Create ADIOS reader object\n reader = reader_gen(cfg[args.transport_rx], gen_channel_name(cfg[\"diagnostic\"]))\n reader.Open()\n stream_attrs = None\n stream_varname = gen_var_name(cfg)[rank]\n logger.info(f\"Main: Stream varname: {stream_varname}\")\n\n dq = queue.Queue()\n msg = None\n worker = threading.Thread(target=forward, args=(dq, cfg, args, timeout))\n worker.start()\n\n rx_list = []\n stream_data = None\n while True:\n stepStatus = reader.BeginStep()\n logger.info(f\"Main: stepStatus = {stepStatus}, currentStep = {reader.CurrentStep()}\")\n if stepStatus:\n # Read data\n stream_data = reader.Get(stream_varname, save=False)\n if stream_attrs is None:\n if reader.InquireAttribute(\"stream_attrs\"):\n stream_attrs = reader.get_attrs(\"stream_attrs\")\n\n stream_data = reader.Get(stream_varname, save=False)\n rx_list.append(reader.CurrentStep())\n\n # Generate message id and publish is\n msg = AdiosMessage(tstep_idx=reader.CurrentStep(), data=stream_data, attrs=stream_attrs)\n dq.put_nowait(msg)\n logger.info(f\"Main: Published message {msg}\")\n reader.EndStep()\n else:\n logger.info(f\"Main: Exiting: StepStatus={stepStatus}\")\n break\n\n # last_step = reader.CurrentStep()\n\n logger.info(\"Main: Exiting main loop\")\n worker.join()\n logger.info(\"Main: Workers have joined\")\n dq.join()\n logger.info(\"Main: Queue joined\")\n logger.info(\"Main: Finished\")","def inference(self, g, x):\n\n for l, layer in enumerate(self.layers):\n y = torch.zeros(g.num_nodes(), self.n_hidden if l != len(self.layers) - 1 else self.n_classes)\n\n sampler = dgl.dataloading.MultiLayerFullNeighborSampler(1)\n dataloader = dgl.dataloading.NodeDataLoader(\n g,\n torch.arange(g.num_nodes()),\n sampler,\n batch_size=args.batch_size,\n shuffle=True,\n drop_last=False,\n num_workers=args.num_workers)\n\n for input_nodes, output_nodes, blocks in tqdm.tqdm(dataloader):\n block = blocks[0]\n\n block = block.int()\n h = x[input_nodes]\n h = layer(block, h)\n if l != len(self.layers) - 1:\n h = self.activation(h)\n h = self.dropout(h)\n\n y[output_nodes] = h\n\n x = y\n return y","def process(self, sess):\n sess.run(self.p_sync) # copy weights from shared to local\n\n rollout = self.pull_batch_from_queue()\n\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\n\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\n\n if should_compute_summary:\n fetches = [self.summary_op, self.p_train_op, self.global_step]\n else:\n fetches = [self.p_train_op, self.global_step]\n\n feed_dict = {\n self.local_network.x: batch.si,\n self.ac: batch.a,\n self.adv: batch.adv,\n self.r: batch.r,\n self.local_network.p_state_in[0]: batch.features[0],\n self.local_network.p_state_in[1]: batch.features[1],\n }\n fetched = sess.run(fetches, feed_dict=feed_dict)\n\n if should_compute_summary:\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]), fetched[-1])\n self.summary_writer.flush()\n\n # Update the distctiminator\n sess = tf.get_default_session()\n self.local_steps += 1","def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass","def infer_on_stream(args, client):\n # Initialize the network\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n # Load the model through `infer_network`\n infer_network.load_model(args.model, args.device, args.cpu_extension)\n\n # Handle the input stream\n # expand the tilde\n input_fpath = os.path.expanduser(args.input)\n f_name, f_extn = os.path.splitext(input_fpath)\n\n is_image_input = False\n\n # add the file extensions as you like\n if f_extn in ['.mp4', '.avi', '.mpeg']:\n pass\n elif f_extn in ['.png', '.jpg', 'jpeg']:\n is_image_input = True\n else:\n assert False, f'unsupported input data extension: {f_extn}'\n\n # Get and open video capture\n cap = cv2.VideoCapture(input_fpath)\n cap.open(input_fpath)\n # [1, 3, 320, 544] (BCHW)\n net_input_dims = infer_network.get_input_shape()\n logger.debug('* DNN input dims: {}'.format(net_input_dims))\n\n width = int(cap.get(3))\n height = int(cap.get(4))\n # * Video dims: [height:432, width:768]\n logger.debug('* Video dims: [height:{}, width:{}]'.format(height, width))\n\n logger.debug('platform: {}'.format(platform))\n out_video = cv2.VideoWriter('out_result.mp4', CODEC, 30, (width, height))\n\n # Loop until stream is over\n frame_num = 0\n last_valid_pers_num = 0\n total_valid_pers_num = 0\n duration_time_sec = 0\n miss_detect_cnt = 0\n start_tracking = False\n all_infer_time = []\n\n while cap.isOpened():\n # Read the next frame\n flag, frame = cap.read()\n if not flag:\n break\n key_pressed = cv2.waitKey(60)\n\n # for debug\n if frame[0].size > 0:\n logger.debug(frame)\n logger.debug(f'saved the frame into img_{frame_num}.png !!!')\n cv2.imwrite(f'resources/images/img_{frame_num}.png', frame)\n cv2.imshow('win', frame)\n\n # Pre-processing the image\n # cv2.resize(src, dsize=(width, height))\n p_frame = cv2.resize(frame, (net_input_dims[3], net_input_dims[2]))\n p_frame = p_frame.transpose((2,0,1))\n # reshape (3, 320, 544) to (1, 3, 320, 544)\n p_frame = p_frame.reshape(1, *p_frame.shape)\n logger.debug('+ frame %d' % (frame_num))\n logger.debug(' - shape: {}'.format(p_frame.shape))\n\n # Start asynchronous inference for specified request\n infer_start = time.time()\n infer_network.exec_net(p_frame)\n\n # Wait for the result\n if infer_network.wait() == 0: # when the inference per frame finishes\n infer_stop = time.time()\n infer_time_ms = (infer_stop-infer_start) * 1e3\n\n # Get the results of the inference request\n infer_result = infer_network.get_output()\n\n # Filter the valid object\n valid_object = extract_valid_object(infer_result)\n\n # draw bounding box of detected person on the image\n out_frame, valid_pers_num = draw_boundingbox(frame, valid_object, width, height, prob_threshold)\n\n def add_text_on_image(image, insert_text=None, loc=(10,10), tsize=0.4, tcolr=(209, 130, 0, 255), tbold=1):\n # add a text\n cv2.putText(image, insert_text, loc, cv2.FONT_HERSHEY_SIMPLEX, tsize, tcolr, tbold)\n logger.debug(' - [add the text on image] %s' % (insert_text))\n return\n\n logger.debug(' - total number of people: %d' % total_valid_pers_num)\n\n logger.debug(f'[#check#] valid person number: {valid_pers_num}')\n logger.debug(f'[#check#] last valid person number: {last_valid_pers_num}')\n logger.debug(f'[#check#] total count ({total_valid_pers_num})')\n\n # p1: 0-0-0-0-0-0-0-0-0-0 (F)\n # p2: 0-0-1-1-1-0-0-0-0-1 (F)\n # p3: 0-0-1-1-1-0-0-0-0-0 (F)\n # p4: 0-0-1-0-1-1-1-1-1-1 (F)\n if start_tracking: # if a person disappears for a sec\n miss_detect_cnt += 1\n logger.debug(f'[#check#] miss count ({miss_detect_cnt})')\n if miss_detect_cnt == 5: # if miss detection continues for the consecutive 5 frames, we think a person disappeared\n duration_time_sec = time.time() - emerge_time\n total_valid_pers_num += 1\n\n # Topic \"person/duration\": key of \"duration\"\n client.publish(\"person/duration\", json.dumps({\"duration\": duration_time_sec}))\n # Topic \"person\": keys of \"count\" and \"total\"\n client.publish(\"person\", json.dumps({\"total\": total_valid_pers_num}))\n\n logger.debug(f'[#check#] a person is disappeared')\n logger.debug(f'[#check#] total count ({total_valid_pers_num})')\n logger.debug(f'[#check#] duration ({duration_time_sec})')\n # initialize\n start_tracking = False\n miss_detect_cnt = 0\n elif valid_pers_num > last_valid_pers_num:\n # initialize\n start_tracking = False\n miss_detect_cnt = 0\n\n else:\n if valid_pers_num > last_valid_pers_num: # 0->1\n emerge_time = time.time()\n elif valid_pers_num < last_valid_pers_num: # 1->0\n start_tracking = True\n else: #0->0\n pass\n\n # add duration time on the image\n insert_text = 'duration time: %d sec' % (duration_time_sec)\n add_text_on_image(out_frame, insert_text, (10,60))\n\n # add total count of people on the image\n insert_text = 'total count of people: %d' % (total_valid_pers_num)\n add_text_on_image(out_frame, insert_text, (10,40))\n\n # add inference time on the image\n insert_text = \"inference time(without post-process): %.2fms\" % (infer_time_ms)\n add_text_on_image(out_frame, insert_text, (10,20))\n all_infer_time.append(infer_time_ms)\n\n # save a current valid person number into the last valid person number\n last_valid_pers_num = valid_pers_num\n\n if is_image_input:\n path = '.'\n f_name = f'output_{frame_num}{f_extn}'\n cv2.imwrite(os.path.join(path, f_name), out_frame)\n else:\n # write into a movie\n out_video.write(out_frame)\n\n # Send current_count, total_count and duration to the MQTT server ###\n client.publish(\"person\", json.dumps({\"count\": valid_pers_num}))\n\n\n # Send the frame to the FFMPEG server\n sys.stdout.buffer.write(out_frame)\n sys.stdout.flush()\n\n # Break if escape key pressed\n if key_pressed == 27:\n break\n# if frame_num > 500:\n# break\n\n # count up the frame number\n frame_num += 1\n\n # Release the capture and destroy any OpenCV windows\n cap.release()\n out_video.release()\n cv2.destroyAllWindows()\n\n # close the MTQQ server connection\n client.disconnect()\n\n logger.info(f'* average inference time: {sum(all_infer_time)/frame_num} ms')\n logger.info(f'* total count of people: {total_valid_pers_num}')","def evaluate():\n\n # seed provides the mechanism to control the shuffling which takes place reading input\n seed = tf.placeholder(tf.int64, shape=())\n \n # Generate placeholders for the images and labels.\n iterator = input_data.input_pipeline_binary(FLAGS.data_dir,\n FLAGS.batch_size,\n fake_data=FLAGS.fake_data,\n num_epochs=1,\n read_threads=FLAGS.read_threads,\n shuffle_size=FLAGS.shuffle_size,\n num_expected_examples=FLAGS.num_examples,\n seed=seed)\n image_path, label_path, images, labels = iterator.get_next()\n\n if FLAGS.verbose:\n print_op = tf.print(\"images and labels this batch: \", \n image_path, label_path, labels)\n else:\n print_op = tf.constant('No printing')\n\n if FLAGS.random_rotation:\n images, labels = harmonics.apply_random_rotation(images, labels)\n\n # Build a Graph that computes predictions from the inference model.\n logits = topology.inference(images, FLAGS.network_pattern)\n \n # Add to the Graph the Ops for loss calculation.\n loss = topology.binary_loss(logits, labels)\n \n # Set up some prediction statistics\n predicted = tf.round(tf.nn.sigmoid(logits))\n correct_pred = tf.equal(predicted, labels)\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n \n while True:\n eval_once(sess, iterator, saver, seed, labels, loss, accuracy, predicted)\n if FLAGS.run_once:\n break\n time.sleep(FLAGS.eval_interval_secs)","def loop_threaded():\n nonlocal index, total\n nonlocal d_tree\n nonlocal fn_inputReadCallback\n nonlocal fn_analysisCallback\n nonlocal fn_outputWriteCallback\n nonlocal dret_inputSet\n nonlocal dret_analyze\n nonlocal dret_outputSet\n nonlocal str_desc\n\n def thread_createOnFunction(path, data, str_namePrefix, fn_thread):\n \"\"\"\n Simply create a thread function and return it.\n \"\"\"\n nonlocal index\n ta = threading.Thread(\n name = '%s-%04d.%d' % (str_namePrefix, index, self.numThreads),\n target = fn_thread,\n args = (path, data, index),\n kwargs = kwargs\n )\n return ta\n\n def threadsInBatches_run(l_threadAnalysis):\n \"\"\"\n Run threads in batches of self.numThreads\n and also handle any remaining threads.\n \"\"\"\n index = 1\n if self.numThreads > total:\n self.numThreads = total\n threadFullLoops = int(total / self.numThreads)\n threadRem = total % self.numThreads\n alreadyRunCount = thread_batch(\n l_threadAnalysis,\n threadFullLoops,\n self.numThreads,\n 0)\n nextRunCount = thread_batch(\n l_threadAnalysis,\n 1,\n threadRem,\n alreadyRunCount)\n\n if int(self.verbosityLevel) and self.toConsole():\n iterator = tqdm( self.d_inputTree.items(),\n desc = str_desc)\n else:\n iterator = self.d_inputTree.items()\n\n # Read\n if fn_inputReadCallback:\n index = 1\n for path, data in iterator:\n dret_inputSet = inputSet_read(path, data)\n # filesRead += dret_inputSet['filesRead']\n index += 1\n\n # Analyze\n if fn_analysisCallback:\n index = 1\n l_threadAnalysis = []\n for path, data in iterator:\n l_threadAnalysis.append(thread_createOnFunction(\n path, data,\n 'analysisThread',\n # t_analyze\n analysis_do\n )\n )\n index += 1\n\n # And now batch them in groups\n threadsInBatches_run(l_threadAnalysis)\n tree_removeDeadBranches()\n # Write\n if fn_outputWriteCallback:\n index = 1\n for path, data in iterator:\n dret_outputSet = outputSet_write(path, d_tree[path])\n # filesSaved += dret_outputSet['filesSaved']\n index += 1","def main():\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True # pylint: disable=E1101\n\n comm = MPI.COMM_WORLD\n\n # Use MPI for parallel evaluation\n rank = comm.Get_rank()\n size = comm.Get_size()\n\n env_fns, env_names = create_eval_envs()\n\n env = AllowBacktracking(env_fns[rank](stack=False, scale_rew=False))\n env = BatchedFrameStack(BatchedGymEnv([[env]]), num_images=4, concat=False)\n with tf.Session(config=config) as sess:\n dqn = DQN(*rainbow_models(sess,\n env.action_space.n,\n gym_space_vectorizer(env.observation_space),\n min_val=-200,\n max_val=200))\n player = NStepPlayer(BatchedPlayer(env, dqn.online_net), 3)\n optimize = dqn.optimize(learning_rate=1e-4)\n sess.run(tf.global_variables_initializer())\n\n reward_hist = []\n total_steps = 0\n def _handle_ep(steps, rew, env_rewards):\n nonlocal total_steps\n total_steps += steps\n reward_hist.append(rew)\n if total_steps % 1 == 0:\n avg_score = sum(reward_hist[-100:]) / len(reward_hist[-100:])\n\n\t\t\t# Global Score\n global_score = np.zeros(1)\n local_score = np.array(avg_score)\n print(\"Local Score for \" + env_names[rank] + \" at episode \" + str(len(reward_hist)) + \" with timesteps: \" + str(total_steps) + \": \" + str(local_score))\n comm.Allreduce(local_score, global_score, op=MPI.SUM)\n global_score /= size\n if rank == 0:\n print(\"Global Average Score at episode: \" + str(len(reward_hist)) + \": \" + str(global_score))\n\n\n dqn.train(num_steps=2000000, # Make sure an exception arrives before we stop.\n player=player,\n replay_buffer=PrioritizedReplayBuffer(500000, 0.5, 0.4, epsilon=0.1),\n optimize_op=optimize,\n train_interval=1,\n target_interval=8192,\n batch_size=32,\n min_buffer_size=20000,\n handle_ep=_handle_ep,\n save_interval=None,\n restore_path='./checkpoints_rainbow/model-10' # Model to be evaluated\n )","def main():\n # Grab command line args\n args = build_argparser().parse_args()\n # Connect to the MQTT server\n client = connect_mqtt()\n # Perform inference on the input stream\n infer_on_stream(args, client)","def main():\n # Grab command line args\n args = build_argparser().parse_args()\n # Connect to the MQTT server\n client = connect_mqtt()\n # Perform inference on the input stream\n infer_on_stream(args, client)","def inference(self, x, inference_args, spemb=None, dur=None, f0=None, energy=None,\r\n utt_id=None, *args, **kwargs):\r\n # inference\r\n h = self.enc.inference(x) # Tmax x h-dim\r\n \r\n if self.spk_embed_dim is not None:\r\n spemb = F.normalize(spemb, dim=0).unsqueeze(0).expand(h.size(0), -1)\r\n h = torch.cat([h, spemb], dim=-1)\r\n \r\n ilens = torch.LongTensor([h.shape[0]]).to(h.device)\r\n d_masks = make_pad_mask(ilens).to(h.device)\r\n if dur is not None:\r\n d_outs = dur.reshape(-1).long()\r\n else:\r\n d_outs = self.duration_predictor.inference(h.unsqueeze(0), d_masks) # B x Tmax\r\n d_outs = d_outs.squeeze(0).long()\r\n \r\n if self.use_fe_condition:\r\n if f0 is not None:\r\n p_outs = f0.unsqueeze(0)\r\n e_outs = energy.unsqueeze(0)\r\n else:\r\n expand_hs = h.unsqueeze(0)\r\n fe_masks = d_masks\r\n p_outs = self.pitch_predictor(expand_hs, fe_masks.unsqueeze(-1))\r\n e_outs = self.energy_predictor(expand_hs, fe_masks.unsqueeze(-1))\r\n p_embs = self.pitch_embed(p_outs.transpose(1,2)).transpose(1,2).squeeze(0)\r\n e_embs = self.energy_embed(e_outs.transpose(1,2)).transpose(1,2).squeeze(0)\r\n else:\r\n p_outs = None\r\n e_outs = None\r\n p_embs = None\r\n e_embs = None\r\n \r\n if self.append_position:\r\n position = []\r\n for iid in range(d_outs.shape[0]):\r\n if d_outs[iid] != 0:\r\n position.append(torch.FloatTensor(list(range(d_outs[iid].long())))/d_outs[iid])\r\n position = pad_list(position, 0)\r\n position = position.to(h.device)\r\n else:\r\n position = None\r\n \r\n outs = self.dec.inference(\r\n h,\r\n d_outs,\r\n position,\r\n p_embs,\r\n e_embs,\r\n )\r\n \r\n return outs","def step(self, observation, last_state):\n # We are omitting the details of network inference here.\n # ...\n feature_screen = observation[3]['feature_screen']\n feature_minimap = observation[3]['feature_minimap']\n feature_units = observation[3]['feature_units']\n feature_player = observation[3]['player']\n available_actions = observation[3]['available_actions']\n score_by_category = observation[3]['score_by_category']\n game_loop = observation[3]['game_loop']\n\n unit_type = feature_screen.unit_type\n empty_space = np.where(unit_type == 0)\n empty_space = np.vstack((empty_space[0], empty_space[1])).T\n random_point = random.choice(empty_space)\n #target = [random_point[0], random_point[1]]\n #action = [actions.FunctionCall(_BUILD_SUPPLY_DEPOT, [_NOT_QUEUED, target])]\n policy_logits = None\n new_state = None\n\n spatial_encoder_output = self.spatial_encoder(np.reshape(feature_screen, [1,128,128,27]))\n\n agent_statistics = get_agent_statistics(score_by_category)\n\n home_race = 'Terran'\n away_race = 'Terran'\n race = get_race_onehot(home_race, away_race)\n\n time = get_gameloop_obs(game_loop)\n\n upgrade_value = get_upgrade_obs(feature_units)\n if upgrade_value != -1:\n self.home_upgrade_array[np.where(upgrade_value[0] == 1)] = 1\n self.away_upgrade_array[np.where(upgrade_value[1] == 1)] = 1\n\n embedded_scalar = np.concatenate((agent_statistics, race, time, self.home_upgrade_array, self.away_upgrade_array), axis=0)\n scalar_encoder_output = self.scalar_encoder(np.reshape(embedded_scalar, [1,307]))\n embedded_feature_units = get_entity_obs(feature_units)\n entity_encoder_output = self.entity_encoder(np.reshape(embedded_feature_units, [1,512,464]))\n encoder_input = np.concatenate((spatial_encoder_output, scalar_encoder_output, entity_encoder_output), axis=1)\n\n core_input = np.reshape(encoder_input, [16, 8, 131])\n whole_seq_output, final_memory_state, final_carry_state = self.core(core_input)\n print(whole_seq_output.shape)\n print(final_memory_state.shape)\n print(final_carry_state.shape)\n\n action = [actions.FUNCTIONS.no_op()]\n\n return action, policy_logits, new_state","def inference(self, x, data):\n\n ## Global features concatenated\n if self.u_dim > 0:\n u = data.u.view(-1, self.u_dim)\n x = torch.cat((x, u), 1)\n\n ## Final MLP map\n \n # Edge level inference\n if 'edge' in self.task:\n x = self.forward_2pt(x, data.edge_index)\n\n # Node or graph level inference\n else:\n x = self.mlp_final(x)\n\n return x","def print_stats(exec_net, input_data, n_channels, batch_size, input_blob, out_blob, args):\n\n # Start sync inference\n print(\"Starting inference ({} iterations)\".format(args.number_iter))\n infer_time = []\n\n for i in range(args.number_iter):\n input_data_transposed_1=input_data[0:batch_size].transpose(0,3,1,2)\n t0 = time.time()\n res = exec_net.infer(inputs={input_blob: input_data_transposed_1[:,:n_channels]})\n infer_time.append((time.time() - t0) * 1000)\n\n\n average_inference = np.average(np.asarray(infer_time))\n print(\"Average running time of one batch: {:.5f} ms\".format(average_inference))\n print(\"Images per second = {:.3f}\".format(batch_size * 1000.0 / average_inference))\n\n perf_counts = exec_net.requests[0].get_perf_counts()\n log.info(\"Performance counters:\")\n log.info(\"{:<70} {:<15} {:<15} {:<15} {:<10}\".format(\"name\",\n \"layer_type\",\n \"exec_type\",\n \"status\",\n \"real_time, us\"))\n for layer, stats in perf_counts.items():\n log.info(\"{:<70} {:<15} {:<15} {:<15} {:<10}\".format(layer,\n stats[\"layer_type\"],\n stats[\"exec_type\"],\n stats[\"status\"],\n stats[\"real_time\"]))","def run(self, context):\n self.start()\n while not context.is_finished():\n self.update_predictions(context)\n new_results, instances = self.evaluate()\n if new_results:\n self.write_results(new_results, instances)\n self.update_plot(new_results, instances)\n\n if self.plot_file:\n self.visualizer.savefig(self.plot_file)\n if self.show_plot:\n self.visualizer.show()\n self.end()","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--allData', default='', action='store', nargs='+',\n help=\"add train test validation dataset together\")\n parser.add_argument('--topic', default='', help=\"target topic\")\n parser.add_argument('--contentWordNumber', default='', help=\"threshold for content Word Number\")\n parser.add_argument('--returnNSents', default='', help=\"top N sentences\")\n\n args = parser.parse_args()\n data = loadData(args.allData, args.topic, args.contentWordNumber)\n allDataDic, targetTweets = data.readData()\n \"\"\"\n ##modify at def_processing, re-run below line##\n outputDB = data.processing(allDataDic)\n with open(ROOT.DATA_ROOT+'/'+'allDataDic.txt', 'w') as file:\n file.write(json.dumps(outputDB))\n \"\"\"\n\n targData = data.processing(targetTweets)\n outputDB = json.load(open(ROOT.DATA_ROOT + '/allDataDic.txt'))\n contentWords = data.tfidf(outputDB, targData)\n return targetTweets,targData, contentWords","def process(self, sess):\n\n sess.run(self.sync) # copy weights from shared to local\n rollout = self.pull_batch_from_queue()\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\n\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\n\n if should_compute_summary:\n fetches = [self.summary_op, self.train_op, self.global_step]\n else:\n fetches = [self.train_op, self.global_step]\n\n feed_dict = {\n self.local_network.x: batch.si,\n self.ac: batch.a,\n self.adv: batch.adv,\n self.r: batch.r,\n self.local_network.state_in[0]: batch.features[0],\n self.local_network.state_in[1]: batch.features[1],\n }\n\n fetched = sess.run(fetches, feed_dict=feed_dict)\n\n if should_compute_summary:\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]), fetched[-1])\n self.summary_writer.flush()\n self.local_steps += 1","def _RunPostProcess(self, threadpool, step, decode_out_obj, dec_metrics,\n global_step, buffered_decode_out, postprocess_futures):\n if threadpool:\n # Run postprocess on separate CPU thread.\n postprocess_futures.append(\n threadpool.apply_async(\n self._PostProcessStep,\n args=(step, decode_out_obj, dec_metrics, global_step,\n buffered_decode_out)))\n else:\n self._PostProcessStep(step, decode_out_obj, dec_metrics, global_step,\n buffered_decode_out)","def inference(self):\r\n\t\tfor partition, loader in self.loaders.items():\r\n\t\t\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\r\n\t\t\t\tloader)\r\n\t\t\tself.preds[partition] = {\r\n\t\t\t\t'tag': tags,\r\n\t\t\t\t'y': y,\r\n\t\t\t\t'y_hat': y_hat,\r\n\t\t\t\t# 'posteriors': post,\r\n\t\t\t\t# 'attentions': attentions\r\n\t\t\t}","def extract_async(self, frame, tlbrs):\n imgs = multi_crop(frame, tlbrs)\n self.embeddings, cur_imgs = [], []\n # pipeline inference and preprocessing the next batch in parallel\n for offset in range(0, len(imgs), self.batch_size):\n cur_imgs = imgs[offset:offset + self.batch_size]\n self.pool.starmap(self._preprocess, enumerate(cur_imgs))\n if offset > 0:\n embedding_out = self.backend.synchronize()[0]\n self.embeddings.append(embedding_out)\n self.backend.infer_async()\n self.last_num_features = len(cur_imgs)","def test_3():\n \n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n multiplicand=2, addend=1)\n\n def g(in_streams, out_streams):\n t = Stream('t')\n filter_then_square(in_streams[0], t,\n filter_threshold=20)\n print_stream(t, name='p1')\n\n def sums(in_streams, out_streams):\n s = Stream('s')\n sum_window(in_streams[0], s, window_size=3, step_size=3)\n print_stream(s, name=' p2')\n\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n }\n },\n 'process_1':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': g,\n 'sources': {}\n },\n 'process_2':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': sums,\n 'sources': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'process_1':\n {\n },\n 'process_2':\n {\n }\n }\n\n multicore(processes, connections)","def main():\n args = get_arguments()\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n \n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader_MultiClass_Loss(\n args.data_dir,\n args.data_list,\n None, # No defined input size.\n RANDOM_SEED,\n False, # No random scale.\n False, # No random mirror.\n coord)\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\n image_batch = tf.expand_dims(image, dim=0)\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\n\n # Create network.\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\n\n # Which variables to load.\n restore_var = tf.global_variables()\n \n # Predictions.\n raw_output = net.layers['fc1_voc12']\n\n # Do the global average pooling\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\n pred = tf.nn.softmax(g_avg_pool_sqzd)\n\n # Get the class activation map\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\n\n cam_batch = tf.expand_dims(cam, dim=3)\n\n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n sess.run(tf.local_variables_initializer())\n \n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if args.restore_from is not None:\n load(loader, sess, args.restore_from)\n \n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n \n # Iterate over training steps.\n for step in range(args.num_steps):\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\n \"\"\"\n print(bin_catg)\n print(np.unique(np.unique(cams)))\n \"\"\"\n img = inv_preprocess(images)\n attMap = decode_labels(cams)\n output_dir = './output_maps_binary_without_norm/'\n img_name = output_dir + str(step) + '.jpg'\n map_name = output_dir + str(step) + '.png'\n misc.imsave(img_name, img[0,:,:,:])\n misc.imsave(map_name, attMap[0,:,:,:])\n coord.request_stop()\n coord.join(threads)","def exec_attention(self,curr_step): \n\n assert(self.curr_step_idx > 0 and self.dlist is not None), \"Step Error: Must call init before combine\" \n \n detectType = curr_step[\"detectionNetwork\"]\n paramsFile = curr_step[\"paramsFile\"]\n funclist = curr_step[\"funclist\"]\n\n #verify raw data & dlist\n # self.B_VER(self.sess_path, self.dlist)\n raw_datadir = self.sess_path\n dest_datadir = self.sess_path \n\n model_dict = {\"detectType\": detectType, \"paramsFile\" : paramsFile} \n\n for i, folder in enumerate(self.dlist):\n flist = funclist[i]\n self.data_utils.DETECT(raw_datadir, folder, dest_datadir, model_dict, flist=[], preview=False)\n self.default_vis(curr_step)","def _FetchDecodeOut(tpu_outs: Union[List[tf.Tensor], Callable[..., tf.Tensor]],\n sess=None):\n if py_utils.IsEagerMode():\n # The CPU pass through data will be from the infeed function.\n # Here we will get an empty `cpu_pt`.\n decode_out_dict, cpu_pt = tpu_outs()\n decode_out_dict = py_utils.Transform(lambda x: x.numpy(), decode_out_dict)\n else:\n decode_tensors, cpu_passthrough_tensors = tpu_outs\n if cpu_passthrough_tensors is not None:\n decode_out_dict, cpu_pt = sess.run(\n [decode_tensors, cpu_passthrough_tensors])\n else:\n decode_out_dict = sess.run(decode_tensors)\n cpu_pt = {}\n return _UpdateCpuPassThroughData(decode_out_dict, cpu_pt)","def run_inference(self, schema_params):\n # Log distributed execution context, which includes cluster configuration\n logger.info(\"Commencing {} inference\".format(self.effect_name))\n logger.info(\"Execution context : {}\".format(self.execution_context))\n\n logger.info('Creating dirs recursively at: {0}'.format(\n self.base_training_params.validation_score_dir))\n\n if self.execution_context[constants.TASK_TYPE] != constants.TASK_TYPE_WORKER:\n logger.info(\"Only workers should run inference. Exiting\")\n return\n\n # Create partition_index_list\n partition_index_list = self._get_partition_list()\n\n for partition_index in partition_index_list:\n logger.info(\n \"Commencing {} inference for partition index : {}\".format(self.effect_name, partition_index))\n\n self.execution_context[constants.PARTITION_INDEX] = partition_index\n for input_path, output_path in ((self.model.training_data_dir, self.base_training_params.training_score_dir),\n (self.model.validation_data_dir, self.base_training_params.validation_score_dir)):\n if input_path and output_path:\n # Resolve partitioned data path from raw path params from user\n data_path = self._anchor_directory(input_path, partition_index)\n output_dir = os.path.join(self._anchor_directory(output_path, partition_index))\n\n if is_empty_directory(input_path):\n logger.info(f\"{input_path} is empty, no dataset to inference on.\")\n continue\n # Run inference\n self.model.predict(output_dir=output_dir,\n input_data_path=data_path,\n metadata_file=self.model.metadata_file,\n checkpoint_path=self.model.checkpoint_path,\n execution_context=self.execution_context,\n schema_params=schema_params)\n logger.info(\n \"Inference for partition index : {} complete\".format(partition_index))\n\n logger.info(\"Inference complete\")","def execute(self, requests):\n responses = []\n for request in requests:\n infer_outputs = pb_utils.get_input_tensor_by_name(\n request, self.input_names[0])\n im_infos = pb_utils.get_input_tensor_by_name(request,\n self.input_names[1])\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\n self.input_names[2])\n\n infer_outputs = infer_outputs.as_numpy()\n im_infos = im_infos.as_numpy()\n ori_imgs = ori_imgs.as_numpy()\n\n results = self.postprocessor.run([infer_outputs], im_infos)\n batch_rec_texts = []\n batch_rec_scores = []\n batch_box_list = []\n for i_batch in range(len(results)):\n\n cls_labels = []\n cls_scores = []\n rec_texts = []\n rec_scores = []\n\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\n image_list = []\n if len(box_list) == 0:\n image_list.append(ori_imgs[i_batch])\n else:\n for box in box_list:\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\n image_list.append(crop_img)\n\n batch_box_list.append(box_list)\n\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", cls_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='cls_pp',\n requested_output_names=['cls_labels', 'cls_scores'],\n inputs=[cls_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n cls_labels = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_labels')\n cls_labels = cls_labels.as_numpy()\n\n cls_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'cls_scores')\n cls_scores = cls_scores.as_numpy()\n\n for index in range(len(image_list)):\n if cls_labels[index] == 1 and cls_scores[\n index] > self.cls_threshold:\n image_list[index] = cv2.rotate(\n image_list[index].astype(np.float32), 1)\n image_list[index] = np.astype(np.uint8)\n\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\n \"x\", rec_dlpack_tensor)\n\n inference_request = pb_utils.InferenceRequest(\n model_name='rec_pp',\n requested_output_names=['rec_texts', 'rec_scores'],\n inputs=[rec_input_tensor])\n inference_response = inference_request.exec()\n if inference_response.has_error():\n raise pb_utils.TritonModelException(\n inference_response.error().message())\n else:\n # Extract the output tensors from the inference response.\n rec_texts = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_texts')\n rec_texts = rec_texts.as_numpy()\n\n rec_scores = pb_utils.get_output_tensor_by_name(\n inference_response, 'rec_scores')\n rec_scores = rec_scores.as_numpy()\n\n batch_rec_texts.append(rec_texts)\n batch_rec_scores.append(rec_scores)\n\n out_tensor_0 = pb_utils.Tensor(\n self.output_names[0],\n np.array(\n batch_rec_texts, dtype=np.object_))\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\n np.array(batch_rec_scores))\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\n np.array(batch_box_list))\n inference_response = pb_utils.InferenceResponse(\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\n responses.append(inference_response)\n return responses","def run_inference_on_image(image):\n if not tf.gfile.Exists(image):\n tf.logging.fatal('File does not exist %s', image)\n image_data = tf.gfile.FastGFile(image, 'rb').read()\n\n\n\n with tf.Session() as sess:\n # Some useful tensors:\n # 'softmax:0': A tensor containing the normalized prediction across\n # 1000 labels.\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\n # float description of the image.\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\n # encoding of the image.\n # Runs the softmax tensor by feeding the image_data as input to the graph.\n\n # Creates node ID --> English string lookup.\n node_lookup = NodeLookup()\n\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n predictions = sess.run(softmax_tensor,\n {'DecodeJpeg/contents:0': image_data})\n predictions = np.squeeze(predictions)\n\n\n\n top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\n result =[]\n for node_id in top_k:\n human_string = node_lookup.id_to_string(node_id)\n score = predictions[node_id]\n\n point = collections.namedtuple('Point', ['humanString', 'score'])\n point.humanString = human_string\n point.score = score\n result.append(point)\n return result","def inference(self, data_loader):\n\n # Handling inference for Multiclass classification\n outputs_list = []\n with torch.no_grad():\n for bi, d in enumerate(data_loader):\n ids = d['ids']\n mask = d['mask']\n\n # send them to the cpu\n ids = ids.to(self.device, dtype=torch.long)\n mask = mask.to(self.device, dtype=torch.long)\n\n outputs = self.model(\n input_ids=ids,\n attention_mask=mask\n )\n outputs_list.extend(torch.softmax(outputs, dim=1).cpu().detach().numpy().tolist())\n\n print(\"This the output from the Multiclass classification model\", outputs_list[0])\n\n inferences = np.argmax(outputs_list, axis=1)\n inferences = [self.mapping[str(pred)] for pred in inferences]\n\n return inferences","def post_apply(self): #pragma no cover\n for e in self.obs_queue:\n\n # translate operation wire labels to the device's wire labels\n device_wires = self.map_wires(e.wires)\n\n self.measure += \"set resultArray w/= {wires[0]} <- \".format(wires=device_wires.tolist())\n self.measure += self._observable_map[e.name].format(wires=device_wires.tolist())\n self.measure += \" \"\n\n self._source_code = PROGRAM.format(wires=self.num_wires, operations=self.prog, measurements=self.measure)\n self.qs = qsharp.compile(self._source_code)","def network_inference(self, points):\r\n\r\n # Ensure no gradient is computed\r\n with torch.no_grad():\r\n\r\n #####################\r\n # Input preparation #\r\n #####################\r\n\r\n # t = [time.time()]\r\n\r\n # Create batch from the frame points\r\n batch = OnlineBatch(points, self.config, self.data_handler)\r\n\r\n # t += [time.time()]\r\n\r\n # Convert batch to a cuda\r\n batch.to(self.device)\r\n # t += [time.time()]\r\n torch.cuda.synchronize(self.device)\r\n\r\n #####################\r\n # Network inference #\r\n #####################\r\n\r\n # Forward pass\r\n outputs = self.net(batch, self.config)\r\n torch.cuda.synchronize(self.device)\r\n # t += [time.time()]\r\n\r\n # Get probs and labels\r\n predicted_probs = self.softmax(outputs).cpu().detach().numpy()\r\n torch.cuda.synchronize(self.device)\r\n # t += [time.time()]\r\n\r\n # Insert false columns for ignored labels\r\n for l_ind, label_value in enumerate(self.data_handler.label_values):\r\n if label_value in self.data_handler.ignored_labels:\r\n predicted_probs = np.insert(predicted_probs, l_ind, 0, axis=1)\r\n\r\n # Get predicted labels\r\n predictions = self.data_handler.label_values[np.argmax(predicted_probs, axis=1)].astype(np.int32)\r\n # t += [time.time()]\r\n\r\n # print('\\n************************\\n')\r\n # print('Timings:')\r\n # i = 0\r\n # print('Batch ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\r\n # i += 1\r\n # print('ToGPU ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\r\n # i += 1\r\n # print('Forward .... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\r\n # i += 1\r\n # print('Softmax .... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\r\n # i += 1\r\n # print('Preds ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\r\n # print('-----------------------')\r\n # print('TOTAL ..... {:7.1f} ms'.format(1000*(t[-1] - t[0])))\r\n # print('\\n************************\\n')\r\n\r\n return predictions, batch.points[0].cpu().numpy()","def main():\n dataset_idx = [11]\n network_idx = [0]\n reshape_input = [False]\n output_idxs = [0, 1]\n lrs = [0, 1, 2]\n dataset_ft_idx = [0,1,2,3]\n counter_exp = 0\n freeze = [0]\n percentages = [12]\n for dts in range(len(dataset_idx)):\n for nt in range(len(network_idx)):\n for opt in output_idxs:\n for dft in dataset_ft_idx:\n for pr in percentages:\n for rsi in range(len(reshape_input)):\n for fr in freeze:\n for lr in lrs:\n config = configuration(dataset_idx=dataset_idx[dts],\n network_idx=network_idx[nt],\n output_idx=opt,\n usage_modus_idx=5,\n dataset_fine_tuning_idx=dft,\n reshape_input=reshape_input[rsi],\n learning_rates_idx=lr,\n name_counter=counter_exp,\n freeze=fr,\n percentage_idx=pr,\n fully_convolutional=False)\n\n setup_experiment_logger(logging_level=logging.DEBUG,\n filename=config['folder_exp'] + \"logger.txt\")\n\n logging.info('Finished')\n\n modus = Modus_Selecter(config)\n\n # Starting process\n modus.net_modus()\n counter_exp += 1\n\n\n return","def threadWorker(self):\n while True:\n row = self.queue.get() #get a row of data\n if row is None: #ending criterium\n break\n self.similarityQuestions(row) #the actual working function\n self.queue.task_done() #inform the queue one task is done"],"string":"[\n \"def inference(self):\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].send(\\\"inference\\\")\\n \\n ## wait for the finalization to be completed\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].recv()\",\n \"def serve_inference_requests():\\n global image_queue\\n\\n with tf.Session() as sess:\\n while True:\\n image_data = image_queue.get()\\n\\n tensor = sess.graph.get_tensor_by_name('final_result:0')\\n predictions = sess.run(tensor, {'DecodeJpeg/contents:0': image_data})\\n predictions = np.squeeze(predictions)\\n\\n top_k = predictions.argsort()[-NUM_PREDICTIONS:][::-1]\\n\\n human_string = labels[top_k[0]]\\n score = predictions[top_k[0]]\\n logging.info('%s classified with score %.5f', human_string, score)\\n\\n emit_image = False\\n if human_string != 'nothing':\\n emit_image = True\\n logging.debug('emitting image cause %s was detected', human_string)\\n elif score <= config['inference']['threshold']:\\n emit_image = True\\n logging.debug('emitting image cause score %.5f is below threshold of %s',\\n score, config['inference']['threshold'])\\n else:\\n logging.debug('image not emitted, cause nothing was detected with a probability of %.5f',\\n score)\\n\\n if emit_image:\\n mqtt_publish(image_data)\\n else:\\n save_image(image_data)\",\n \"def postprocess(self, inference_output):\\n logger.info(inference_output)\\n return inference_output\",\n \"def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None,goal='IC',save_path_dir=None): #b/c it is single, models_list contains one model only\\n running_loss = 0.0\\n \\n# outputs_list = []\\n# representations_list = []\\n# labels_list = []\\n# modality_list = []\\n# indices_list = []\\n# task_names_list = []\\n# attn_coefs_list = []\\n# sentence_lens_list = []\\n# class_labels_list = []\\n# class_predictions_list = []\\n \\n \\\"\\\"\\\" Initialize Dictionaries to Store Results \\\"\\\"\\\" \\n outputs_dict = dict()\\n representations_dict = dict()\\n attn_coefs_dict = dict()\\n labels_dict = dict()\\n sentence_lens_dict = dict()\\n class_labels_dict = dict()\\n class_predictions_dict = dict()\\n epoch_bleu = dict()\\n epoch_rouge = dict()\\n epoch_meteor = dict()\\n\\n for dest_lang in token2id_dict.keys():\\n outputs_dict[dest_lang] = list()\\n attn_coefs_dict[dest_lang] = list()\\n representations_dict[dest_lang] = list()\\n labels_dict[dest_lang] = list()\\n sentence_lens_dict[dest_lang] = list()\\n class_labels_dict[dest_lang] = list()\\n class_predictions_dict[dest_lang] = list()\\n epoch_bleu[dest_lang] = 0\\n epoch_rouge[dest_lang] = 0\\n epoch_meteor[dest_lang] = 0\\n\\n batch_num = 0\\n batch = 0\\n #class label is that in IC setting, but class label is answer in VQA setting\\n for inputs, text_indices, sentence_lens, class_labels, languages, document_level_text_indices, document_level_sentence_lens in tqdm(dataloaders[phase]):\\n \\\"\\\"\\\" Weaning Off of Teacher Forcing in a Linear Manner \\\"\\\"\\\"\\n #sampling_prob = (0.4/30000)*(batch+1)*(epoch_count+1)\\n #uniform_value = np.random.uniform(0,1)\\n #sampling = True if uniform_value < sampling_prob else False\\n sampling = False\\n batch += 1\\n \\\"\\\"\\\" Send Data to Device \\\"\\\"\\\"\\n inputs = inputs.to(device)\\n class_labels = class_labels.to(device)\\n #print(text_indices)\\n with torch.set_grad_enabled('train1' in phase):# and inference == False): #('train' in phase and inference == False)\\n \\\"\\\"\\\" Image Captioning Path \\\"\\\"\\\"\\n if goal == 'IC':\\n \\\"\\\"\\\" Perform Forward Pass i.e. Encoder and Decoder \\\"\\\"\\\"\\n current_labels_dict = dict() #text\\n# current_class_labels_dict = dict()\\n# current_class_predictions_dict = dict()\\n current_outputs_dict = dict()\\n# current_attn_coefs_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, representations = model(inputs,current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n #current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n if phase == 'train1':\\n attn_coefs = 5\\n class_predictions = 6\\n loss = calculate_IC_loss(criterion,outputs,current_text_indices[:,1:],class_predictions,class_labels,attn_coefs,auxiliary_loss,attn_loss)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n current_labels_dict[dest_lang] = current_text_indices[:,1:].cpu().detach().numpy()\\n# current_class_labels_dict[dest_lang] = class_labels\\n# current_class_predictions_dict[dest_lang] = class_predictions\\n current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n# current_attn_coefs_dict[dest_lang] = attn_coefs\\n# current_representations_dict[dest_lang] = representations\\n #\\\"\\\"\\\" Detach Outputs and Attn Coefs To Avoid Memory Leakage \\\"\\\"\\\"\\n #outputs = outputs.detach()\\n #attn_coefs = attn_coefs.detach()\\n current_text_indices.detach()\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Perform Forward Pass and Get Answers \\\"\\\"\\\"\\n outputs, representations, attn_coefs, class_predictions = model(inputs,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Calculate MSE Loss \\\"\\\"\\\"\\n #criterion = nn.MSELoss()\\n #class_labels = class_labels.type(torch.float)\\n \\\"\\\"\\\" Calculate CrossEntropyLoss \\\"\\\"\\\"\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n #print(outputs,outputs.shape)\\n loss = criterion(outputs,class_labels)\\n elif goal == 'Supervised': #encoder supervised pre-training\\n h, representations, class_predictions = model(inputs)#,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n loss = criterion(class_predictions,class_labels)\\n elif goal == 'Text_Supervised':\\n #h, class_predictions = model.supervised_forward(text_indices,sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n class_predictions = model.supervised_forward(current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],phase,device)\\n loss = criterion(class_predictions,class_labels)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n\\n current_class_labels_dict[dest_lang] = class_labels.cpu().detach().numpy()\\n current_class_predictions_dict[dest_lang] = class_predictions.cpu().detach().numpy()\\n# current_representations_dict[dest_lang] = h\\n #loss = criterion(class_predictions,class_labels)\\n #print(loss)\\n elif goal == 'Language_Change_Detection':\\n criterion = nn.BCEWithLogitsLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_change_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.float) #needed for BCELoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n loss = 0\\n for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n current_loss = criterion(replacement_prediction,replacement_label)\\n loss = loss + current_loss\\n if i == len(replacement_predictions)-1:\\n loss = loss / len(replacement_predictions)\\n #loss = torch.mean(torch.tensor([criterion(replacement_prediction,replacement_label) for replacement_prediction,replacement_label in zip(replacement_predictions,replacement_labels)]))\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h \\n elif goal == 'Language_Detection':\\n criterion = nn.CrossEntropyLoss(ignore_index=0)\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.long) #needed for CrossEntropyLoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n# loss = 0\\n# for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n# replacement_label = replacement_label.type(torch.long)\\n# current_loss = criterion(replacement_prediction,replacement_label)\\n# loss = loss + current_loss\\n# if i == len(replacement_predictions)-1:\\n# loss = loss / len(replacement_predictions)\\n #print(replacement_predictions.shape,replacement_labels.shape)\\n loss = criterion(replacement_predictions.permute(0,2,1),replacement_labels)\\n #print(loss)\\n total_loss = total_loss + loss\\n #print(dest_lang,total_loss)\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h\\n elif goal == 'MLM':\\n criterion = nn.CrossEntropyLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, replacement_predictions = model.MLM_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Obtain Applicable Loss Locations (i.e., Where Token Was Masked) \\\"\\\"\\\"\\n token_loss_mask = torch.where(replacement_predictions == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n #print(outputs.shape)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n token_loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n \\\"\\\"\\\" Retrieve Only Relevant Losses (Masked) \\\"\\\"\\\"\\n loss = torch.mean(token_loss.masked_select(token_loss_mask))\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n del current_text_indices\\n del token_loss\\n del token_loss_mask\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n elif goal == 'ELECTRA':\\n generator_criterion = nn.CrossEntropyLoss(reduction='none')\\n discriminator_criterion = nn.BCEWithLogitsLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Perform Forward Pass Through ELECTRA \\\"\\\"\\\"\\n generator_outputs, generator_labels, discriminator_outputs, discriminator_labels = model.ELECTRA_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Generator Loss Mask (i.e., Only Consider Originally Masked Tokens ) \\\"\\\"\\\"\\n generator_token_loss_mask = torch.where(generator_labels == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n \\\"\\\"\\\" Discrimiantor Loss Mask (i.e., Do Not Consider Padded Regions ) \\\"\\\"\\\"\\n discriminator_labels = discriminator_labels.view_as(discriminator_outputs) \\n discriminator_token_loss_mask = torch.ones_like(discriminator_labels)\\n for i,sentence_len in zip(range(discriminator_token_loss_mask.shape[0]),current_sentence_lens):\\n discriminator_token_loss_mask[i,sentence_len:] = 0\\n \\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Generator Token's Loss \\\"\\\"\\\"\\n generator_token_loss = generator_criterion(generator_outputs.permute(0,2,1),current_text_indices) # B x S\\n #print(generator_token_loss.shape,generator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n generator_loss = torch.mean(generator_token_loss.masked_select(generator_token_loss_mask)) #scalar\\n \\n \\\"\\\"\\\" Obtain Each Discriminator Token's Loss \\\"\\\"\\\" \\n discriminator_token_loss = discriminator_criterion(discriminator_outputs,discriminator_labels) # B x S\\n #print(discriminator_token_loss.shape,discriminator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n discriminator_loss = torch.mean(discriminator_token_loss.masked_select(discriminator_token_loss_mask.type(torch.bool))) #scalar\\n \\n #print(generator_loss,discriminator_loss)\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + generator_loss + discriminator_loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = discriminator_labels.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = discriminator_outputs.cpu().detach().numpy() #text\\n elif goal == 'MARGE':\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n #total_loss = 0\\n #for (dest_lang,current_text_indices),current_sentence_lens,current_languages in zip(text_indices.items(),sentence_lens.values(),languages.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Randomly Choose Target Lang for This Mini-Batch \\\"\\\"\\\"\\n #lang_list = list(text_indices.keys())\\n #target_lang = random.sample(lang_list,1).item()\\n #target_lang = 'de' #option to change based on dataset (MUST CHANGE IN PAD COLLATE)\\n outputs, target_lang = model(text_indices,sentence_lens,languages,document_level_text_indices,document_level_sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = text_indices[target_lang].to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n #print(loss)\\n #\\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n #total_loss = total_loss + loss\\n #\\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n #if dest_lang == list(text_indices.keys())[-1]:\\n # loss = total_loss / len(text_indices)\\n# print(loss)\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[target_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[target_lang] = outputs.cpu().detach().numpy() #text\\n \\n\\n \\\"\\\"\\\" Backpropagation and Update Step \\\"\\\"\\\"\\n if phase == 'train1': #only perform backprop for train1 phase \\n loss.backward()\\n \\n \\\"\\\"\\\" Network Parameters \\\"\\\"\\\"\\n if isinstance(optimizer,tuple):\\n optimizer[0].step()\\n \\\"\\\"\\\" Task-Instance Parameters \\\"\\\"\\\"\\n optimizer[1].step() \\n optimizer[0].zero_grad()\\n optimizer[1].zero_grad()\\n else:\\n optimizer.step()\\n optimizer.zero_grad()\\n \\n \\\"\\\"\\\" Calculate Metrics \\\"\\\"\\\"\\n if goal == 'IC':\\n if phase == 'train1':\\n running_loss += loss.item() * inputs.shape[0]\\n elif goal == 'VQA':\\n running_loss += loss.item() * inputs.shape[0] \\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n running_loss += loss.item() * inputs.shape[0] \\n \\n# \\\"\\\"\\\" These Need to be Language Specific \\\"\\\"\\\"\\n \\n if goal in ['IC']:\\n batch_bleu = calculate_bleu_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_rouge = calculate_rouge_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_meteor = calculate_meteor_score(current_outputs_dict,current_labels_dict,token2id_dict) \\n \\n for dest_lang in batch_bleu.keys():\\n epoch_bleu[dest_lang] = epoch_bleu[dest_lang] + (1/batch)*(batch_bleu[dest_lang] - epoch_bleu[dest_lang])\\n epoch_rouge[dest_lang] = epoch_rouge[dest_lang] + (1/batch)*(batch_rouge[dest_lang] - epoch_rouge[dest_lang])\\n epoch_meteor[dest_lang] = epoch_meteor[dest_lang] + (1/batch)*(batch_meteor[dest_lang] - epoch_meteor[dest_lang])\\n \\n if phase in ['val']:\\n for dest_lang in text_indices.keys():\\n predicted_sentences = convert_predicted_ids_to_sentences(current_outputs_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n target_sentences = convert_target_ids_to_sentences(current_labels_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n outputs_dict[dest_lang].extend(predicted_sentences)\\n labels_dict[dest_lang].extend(target_sentences)\\n \\n elif goal in ['Language_Change_Detection','Language_Detection']:\\n for dest_lang in text_indices.keys():\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n \\n# elif goal in ['Text_Supervised']:\\n## current_class_labels = current_class_labels_dict[dest_lang]\\n## current_class_predictions = current_class_predictions_dict[dest_lang]\\n## current_class_labels = current_class_labels.cpu().detach().numpy()\\n## current_class_predictions = current_class_predictions.cpu().detach().numpy()\\n# \\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n# #sentence_lens_dict[dest_lang].extend(current_sentence_lens)\\n# class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n#\\n# elif goal in ['MARGE']:\\n# labels_dict[target_lang].extend(current_labels_dict[target_lang]) #.cpu().detach().numpy())\\n# outputs_dict[target_lang].extend(current_outputs_dict[target_lang]) #.cpu().detach().numpy())\\n# break # because only one target language per minibatch \\n# if goal not in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n## if current_labels_dict[dest_lang].data.dtype != torch.long:\\n## current_labels_dict[dest_lang].data = current_labels_dict[dest_lang].data.type(torch.long)\\n# \\n## current_text_indices = current_labels_dict[dest_lang]\\n## current_outputs = current_outputs_dict[dest_lang]\\n## current_attn_coefs = current_attn_coefs_dict[dest_lang]\\n## current_representations = current_representations_dict[dest_lang]\\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\" \\n# labels_dict[dest_lang].extend(current_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# outputs_dict[dest_lang].extend(current_outputs_dict[dest_lang]) #.cpu().detach().numpy())\\n## attn_coefs_dict[dest_lang].extend(current_attn_coefs.cpu().detach().numpy())\\n## representations_dict[dest_lang].extend(current_representations.cpu().detach().numpy())\\n## elif goal in ['Text_Supervised']:\\n## current_representations = current_representations_dict[dest_lang]\\n## representations_dict[dest_lang].extend(current_representations.squeeze().cpu().detach().numpy()) \\n## else:\\n## current_representations = current_representations_dict[dest_lang]\\n## if goal in ['Language_Change_Detection','Language_Detection']:\\n## current_representations = [representations.cpu().detach().numpy() for representations in current_representations]\\n## else:\\n## current_representations = current_representations.cpu().detach().numpy()\\n## representations_dict[dest_lang].extend(current_representations) \\n# \\n## modality_list.append(modality)\\n## indices_list.append(indices)\\n## task_names_list.append(task_names)\\n \\n batch_num += 1\\n #if batch_num == 2:\\n # break\\n \\n #outputs_list, labels_list, modality_list, indices_list, task_names_list, pids_list = flatten_arrays(outputs_list,labels_list,modality_list,indices_list,task_names_list,pids_list)\\n if goal == 'IC':\\n if phase == 'train1':\\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\\n else:\\n epoch_loss = 0 #filler\\n elif goal in ['VQA','Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n epoch_loss = running_loss / len(dataloaders[phase].dataset) \\n \\n \\\"\\\"\\\" Removed Recently \\\"\\\"\\\"\\n #representations_list = np.concatenate(representations_list)\\n \\n if goal == 'IC':\\n \\\"\\\"\\\" BLEU Score Evaluation \\\"\\\"\\\"\\n# epoch_bleu = calculate_bleu_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_rouge = calculate_rouge_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_meteor = calculate_meteor_score(outputs_dict,labels_dict,token2id_dict) \\n return epoch_loss, epoch_bleu, epoch_rouge, epoch_meteor, outputs_dict, labels_dict #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(outputs_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n epoch_acc = calculate_language_detection_accuracy(class_predictions_dict,class_labels_dict,goal)\\n else:\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(class_predictions_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['MLM','ELECTRA','MARGE']:\\n return epoch_loss#, outputs_dict, labels_dict #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\",\n \"def infer():\\n\\n # Create StreamManagerApi object\\n stream_manager_api = StreamManagerApi()\\n # Use InitManager method init StreamManagerApi\\n ret = stream_manager_api.InitManager()\\n if ret != 0:\\n print(\\\"Failed to init Stream manager, ret=%s\\\" % str(ret))\\n exit()\\n\\n # create streams by pipeline config file\\n with open(args.pipeline_path, \\\"rb\\\") as f:\\n pipeline_str = f.read()\\n\\n # Configuring a stream\\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\\n if ret != 0:\\n print(\\\"Failed to create Stream, ret=%s\\\" % str(ret))\\n exit()\\n\\n # Construct the input of the stream\\n data_input = MxDataInput()\\n # Stream_name encoded in UTF-8\\n stream_name = args.stream_name.encode()\\n print(stream_name)\\n predictions = []\\n with open(args.label_path, 'rt') as f:\\n val_cls = f.read().rstrip(\\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(args.instances_path)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n for file_name in os.listdir(args.img_path):\\n pred_data = []\\n # Gets the Address of each image\\n img_id = int(file_name.split('.')[0])\\n file_path = args.img_path + file_name\\n size = (cv2.imread(file_path)).shape\\n\\n # Read each photo in turn\\n with open(file_path, \\\"rb\\\") as f:\\n img_data = f.read()\\n if not img_data:\\n print(f\\\"read empty data from img:{file_name}\\\")\\n continue\\n # The element value img_data\\n data_input.data = img_data\\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\\n pred_data.append({\\\"boxes\\\": boxes_output,\\n \\\"box_scores\\\": scores_output,\\n \\\"img_id\\\": img_id,\\n \\\"image_shape\\\": size})\\n\\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\\n print(f\\\"Inferred image:{file_name} success!\\\")\\n\\n # Save the result in JSON format\\n if not os.path.exists(args.res_path):\\n os.makedirs(args.res_path)\\n with open(args.res_path + 'predictions_test.json', 'w') as f:\\n json.dump(predictions, f)\\n stream_manager_api.DestroyAllStreams()\",\n \"def main():\\n args, config = parse_args()\\n\\n \\\"\\\"\\\"\\n Log on wandb for track of experiments\\n \\\"\\\"\\\"\\n wandb.init(project=\\\"adaptive-finetuning-resnet\\\", name=f'Inference_{config.VERSION}', config=config)\\n\\n \\\"\\\"\\\"\\n Set config GPUs and torch cuda device\\n \\\"\\\"\\\"\\n config.GPUS = str(0)\\n torch.cuda.set_device(0)\\n\\n \\\"\\\"\\\"\\n Create the model, put it to GPU and then create dataloader\\n \\\"\\\"\\\"\\n model = eval(config.MODULE)(config=config.NETWORK)\\n model = model.cuda()\\n\\n val_loader = make_dataloader(config, mode='val', distributed=False)\\n\\n \\\"\\\"\\\"\\n Load the model with pretrained weights\\n \\\"\\\"\\\"\\n assert config.NETWORK.PRETRAINED_MODEL != '', \\\"For inference, there must be pre-trained weights\\\"\\n\\n pretrain_state_dict = torch.load(config.NETWORK.PRETRAINED_MODEL, map_location = lambda storage, loc: storage)['net_state_dict']\\n smart_model_load(model, pretrain_state_dict, loading_method=config.NETWORK.PRETRAINED_LOADING_METHOD)\\n\\n \\\"\\\"\\\"\\n Pass the model and val loader for validation\\n \\\"\\\"\\\"\\n print(\\\"Inference started!!\\\")\\n val_accuracy = do_validation(config, model, val_loader)\\n print(f\\\"Inference complete!!\\\\nAccuracy:{val_accuracy}\\\")\\n\\n wandb.log({'Accuracy': val_accuracy})\",\n \"def thread_main(self, sess):\\n for x_h, x_m, y in self.data_iterator():\\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m})\",\n \"def inference_end(self, inputs, results):\\n return\",\n \"def process_thread(self):\",\n \"def thread_main(self, sess):\\n for x_h, x_m, y in self.data_iterator():\\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m, self.y:y})\",\n \"def inference():\\n inf_dataset = dataset\\n net.eval()\\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\\n \\n num_crop = args.test_crops\\n length = 3\\n if args.modality == 'Flow':\\n length = 10\\n elif args.modality == 'RGBDiff':\\n length = 18\\n \\n # First get the base_out outputs\\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\\n volatile=True)\\n cnt = 0\\n for frames in frames_gen:\\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\\n # frame_batch_size is 4 by default\\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\\n volatile=True)\\n base_out = net(input_var, None, None, None, None)\\n bsc = base_out.view(num_crop, -1, base_out_dim)\\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\\n cnt += bsc.size(1)\\n\\n n_frames = base_output.size(1)\\n assert frame_cnt == n_frames\\n # GLCU\\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\\n gate, glcu_task_pred = net.glcu(step_features)\\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\\n if net.additive_glcu:\\n base_output = base_output + gate\\n else:\\n base_output = base_output * gate\\n\\n # output.shape == [num_frames, 7791]\\n output = torch.zeros((frame_cnt, output_dim)).cuda()\\n cnt = 0\\n for i in range(0, frame_cnt, 4):\\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\\n rst = net.test_fc(base_out)\\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\\n output[cnt: cnt + sc.size(0), :] = sc\\n cnt += sc.size(0)\\n base_output = base_output.mean(dim=0).data\\n\\n # act_scores.shape == [num_proposals, K+1]\\n # comp_scores.shape == [num_proposals, K]\\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\\n\\n # Task Head\\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\\n\\n act_scores = act_scores.data\\n comp_scores = comp_scores.data\\n\\n if reg_scores is not None:\\n reg_scores = reg_scores.view(-1, num_class, 2)\\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\\n\\n torch.cuda.empty_cache() # To empty the cache from previous iterations\\n\\n # perform stpp on scores\\n return ((inf_dataset.video_list[index].id,\\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \\n glcu_task_pred, task_pred),\\n output.cpu().numpy(),\\n base_output.cpu().numpy()))\",\n \"def get_inference_result(self, dataset_file: dir):\\n tf.reset_default_graph()\\n with tf.Graph().as_default():\\n global_step = tf.contrib.framework.get_or_create_global_step()\\n # global_step_tensor = tf.Variable(1, trainable=False, name='global_step')\\n\\n pic_batch, label_batch, enqueue_op, enq_image, enq_label, examples_in_queue = self.readOnTheFly()\\n\\n # logits, tiles = self.inference(pic_batch)\\n logits = self.inference(pic_batch)\\n\\n \\\"\\\"\\\"\\n label_batch_filtered = tf.boolean_mask(\\n label_batch,\\n tf.cast(label_batch[:,:,4], dtype=tf.bool))\\n label_batch_filtered = tf.Print(label_batch_filtered, [label_batch_filtered], \\\"\\\\n\\\\nLABEL BATCH FILTERED: \\\", summarize=250)\\n label_batch_filtered = tf.Print(label_batch_filtered, [label_batch], \\\"\\\\n\\\\nLABEL BATCH: \\\", summarize=250)\\n \\\"\\\"\\\"\\n number_of_boxes = tf.cast(tf.count_nonzero(label_batch[:, :, 4], 1), dtype=tf.int32)\\n # number_of_boxes = tf.Print(number_of_boxes, [number_of_boxes], \\\"\\\\n\\\\nNumber of boxes: \\\",\\n # summarize=10)\\n self.network.loss, _ = self.loss(logits, label_batch, number_of_boxes)\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(extra_update_ops):\\n self.network.train_op, grads = self.train(self.network.loss, global_step)\\n\\n coord = tf.train.Coordinator()\\n\\n samples_iter = get_samples()\\n\\n with tf.Session().as_default() as sess:\\n sess.run(tf.local_variables_initializer())\\n sess.run(tf.global_variables_initializer())\\n # tf.train.global_step(sess, global_step_tensor)\\n\\n threads = []\\n for i in range(self.num_of_preprocess_threads):\\n # print(\\\"Creating thread %i\\\" % i)\\n t = threading.Thread(target=load_preproc_enqueue_thread, args=(\\n sess, coord, enqueue_op, enq_image, enq_label, samples_iter\\n ))\\n\\n t.setDaemon(True)\\n t.start()\\n threads.append(t)\\n coord.register_thread(t)\\n time.sleep(0.5)\\n\\n num_examples_in_queue = sess.run(examples_in_queue)\\n while num_examples_in_queue < self.min_queue_examples:\\n num_examples_in_queue = sess.run(examples_in_queue)\\n for t in threads:\\n if not t.isAlive():\\n coord.request_stop()\\n raise ValueError(\\\"One or more enqueuing threads crashed...\\\")\\n time.sleep(0.1)\\n\\n print(\\\"# of examples in queue: %i\\\" % num_examples_in_queue)\\n\\n # Create a coordinator and run all QueueRunner objects\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(coord=coord)\\n\\n last_time = time.time()\\n saver = tf.train.Saver()\\n # saver = tf.train.import_meta_graph(join(self..checkpoint_dir, \\\"my_model.meta\\\"))\\n checkpoint_file = join(self.checkpoint_dir, \\\"my_model\\\")\\n if isfile(join(self.checkpoint_dir, \\\"checkpoint\\\")):\\n # saver.restore(sess,tf.train.latest_checkpoint(self.checkpoint_dir))\\n optimistic_restore(sess, checkpoint_file)\\n initialize_uninitialized_vars(sess)\\n print(\\\"Model loaded.\\\")\\n\\n sum_writer = tf.summary.FileWriter(self.log_dir, graph=tf.get_default_graph())\\n merged = tf.summary.merge_all()\\n\\n collected_grads = {g: g[1].name for g in grads if g[0] is not None}\\n loss_result, logit_result, label_result, pic_result, collected_grad_result, _ = (\\n sess.run([self.network.loss, logits, label_batch, pic_batch,\\n collected_grads, self.network.train_op]))\\n\\n # return sess.run(list(collected_grads.keys())), list(collected_grads.values())\\n\\n coord.request_stop()\\n coord.join(threads)\\n\\n return loss_result, logit_result, label_result, pic_result, collected_grad_result\",\n \"def _inference_step(self, state):\\n\\n decoder_inputs = state[\\\"inputs\\\"]\\n encoder_outputs = state[\\\"encoder_outputs\\\"]\\n attention_bias = state[\\\"encoder_decoder_attention_bias\\\"]\\n alignment_positions = state[\\\"alignment_positions\\\"]\\n\\n outputs = self._decode_pass(\\n decoder_inputs=decoder_inputs,\\n encoder_outputs=encoder_outputs,\\n enc_dec_attention_bias=attention_bias,\\n alignment_positions=alignment_positions\\n )\\n\\n with tf.variable_scope(\\\"inference_step\\\"):\\n next_inputs_mel = outputs[\\\"post_net_spec\\\"][:, -1:, :]\\n next_inputs_mel = self._expand(next_inputs_mel, self.reduction_factor)\\n next_inputs_mag = outputs[\\\"mag_spec\\\"][:, -1:, :]\\n next_inputs_mag = self._expand(next_inputs_mag, self.reduction_factor)\\n next_inputs = tf.concat([next_inputs_mel, next_inputs_mag], axis=-1)\\n\\n n_features = self.num_mels + self.num_freq\\n next_inputs = self._shrink(next_inputs, n_features, self.reduction_factor)\\n\\n # Set zero if sequence is finished\\n next_inputs = tf.where(\\n state[\\\"finished\\\"],\\n tf.zeros_like(next_inputs),\\n next_inputs\\n )\\n next_inputs = tf.concat([decoder_inputs, next_inputs], 1)\\n\\n # Update lengths\\n lengths = state[\\\"outputs\\\"][\\\"lengths\\\"]\\n lengths = tf.where(\\n state[\\\"finished\\\"],\\n lengths,\\n lengths + 1 * self.reduction_factor\\n )\\n outputs[\\\"lengths\\\"] = lengths\\n\\n # Update spec, post_net_spec and mag_spec\\n for key in [\\\"spec\\\", \\\"post_net_spec\\\", \\\"mag_spec\\\"]:\\n output = outputs[key][:, -1:, :]\\n output = tf.where(state[\\\"finished\\\"], tf.zeros_like(output), output)\\n outputs[key] = tf.concat([state[\\\"outputs\\\"][key], output], 1)\\n\\n # Update stop token logits\\n stop_token_logits = outputs[\\\"stop_token_logits\\\"][:, -1:, :]\\n stop_token_logits = tf.where(\\n state[\\\"finished\\\"],\\n tf.zeros_like(stop_token_logits) + 1e9,\\n stop_token_logits\\n )\\n stop_prediction = tf.sigmoid(stop_token_logits)\\n stop_prediction = tf.reduce_max(stop_prediction, axis=-1)\\n\\n # Uncomment next line if you want to use stop token predictions\\n finished = tf.reshape(tf.cast(tf.round(stop_prediction), tf.bool), [-1])\\n finished = tf.reshape(finished, [-1])\\n\\n stop_token_logits = tf.concat(\\n [state[\\\"outputs\\\"][\\\"stop_token_logits\\\"], stop_token_logits],\\n axis=1\\n )\\n outputs[\\\"stop_token_logits\\\"] = stop_token_logits\\n\\n with tf.variable_scope(\\\"alignments\\\"):\\n weights = []\\n for index, attention in enumerate(self.attentions):\\n if isinstance(attention, AttentionBlock):\\n weights.append(attention.multiheaded_attention.attention_weights)\\n\\n weights = tf.stack(weights)\\n outputs[\\\"alignments\\\"] = [weights]\\n\\n alignment_positions = tf.argmax(\\n weights,\\n axis=-1,\\n output_type=tf.int32\\n )[:, :, :, -1:]\\n state[\\\"alignment_positions\\\"] = tf.concat(\\n [state[\\\"alignment_positions\\\"], alignment_positions],\\n axis=-1\\n )\\n\\n state[\\\"iteration\\\"] = state[\\\"iteration\\\"] + 1\\n state[\\\"inputs\\\"] = next_inputs\\n state[\\\"finished\\\"] = finished\\n state[\\\"outputs\\\"] = outputs\\n\\n return state\",\n \"def infer_on_stream(args, client):\\n count_current = 0\\n count_last = 0\\n count_last_last = 0\\n total_count = 0\\n duration = 0\\n avg_duration = 0\\n total_duration = 0\\n start_time = 0\\n active_person = 0\\n net_input_shape = []\\n frame_count = 0\\n\\n # Initialise the class\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n ### TODO: Load the model through `infer_network` ###\\n infer_network.load_model(model=args.model, device=args.device, cpu_extension=args.cpu_extension)\\n\\n ### TODO: Handle the input stream ###\\n cap = cv2.VideoCapture(args.input)\\n cap.open(args.input)\\n\\n # get the required shape for the network\\n net_input_shape = infer_network.get_input_shape()\\n\\n # get the shape of the input image\\n width = int(cap.get(3))\\n height = int(cap.get(4))\\n\\n if net_input_shape != [1, 3, 600, 600]:\\n #net_input_shape = [1, 3, 600, 600]\\n #sometimes gives [1,3] and causes an error, so hard coded shape to match model\\n sys.exit(\\\"Input shape error, forced exit. Please run again until this error does not appear.\\\")\\n\\n ### TODO: Loop until stream is over ###\\n while cap.isOpened():\\n\\n ### TODO: Read from the video capture ###\\n flag, frame = cap.read()\\n frame_count += 1\\n\\n if not flag:\\n #video stream ended, go to end and close out\\n break\\n\\n ### TODO: Start asynchronous inference for specified request ###\\n if frame_count%2 == 0: #check every other frame\\n ### TODO: Pre-process the image as needed ###\\n vid_frame = cv2.resize(frame, (net_input_shape[3], net_input_shape[2]))\\n #save a copy of the input frame to use on output\\n vid_frame_copy = vid_frame\\n vid_frame = vid_frame.transpose((2, 0, 1))\\n vid_frame = vid_frame.reshape(1, *vid_frame.shape)\\n\\n infer_network.exec_net(vid_frame)\\n\\n ### TODO: Wait for the result ###\\n if infer_network.wait() == 0:\\n\\n ### TODO: Get the results of the inference request ###\\n results = infer_network.get_output()\\n\\n # for this model, results should be shape [1, 1, N, 7]\\n # N is number of hits, last is a 7 item list [image_id, label, conf, x_min,\\n # y_min, x_max, y_max] where label is the predicted class\\n\\n ### TODO: Extract any desired stats from the results ###\\n out_frame, count_current, box = draw_boxes(vid_frame_copy, results, args, net_input_shape[3], net_input_shape[2])\\n #out_frame = cv2.putText(out_frame, \\\"Last Frame Analyzed = \\\"+str(frame_count), (10, 420), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\\n\\n ### TODO: Calculate and send relevant information on ###\\n ### count_current, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n\\n # This block of code from Mentor Help question 129845, some modifications by me\\n # If both last and last_last are equal, positive ID for two frames.\\n if count_current > count_last and count_last_last == count_last:\\n start_time = time.time()\\n total_count = total_count + count_current - count_last\\n\\n #client.publish(\\\"person\\\", json.dumps({\\\"total\\\": total_count}))\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": count_current}))\\n\\n #out_frame = cv2.putText(out_frame, \\\"Current Time = \\\"+str('% 6.2f' % time.time()), (10, 450), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\\n out_frame = cv2.putText(out_frame, \\\"Person Entered Frame = \\\"+str(count_current), (10, 510), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\\n out_frame = cv2.putText(out_frame, \\\"Total Counted = \\\"+str(total_count), (10, 540), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\\n\\n # Person duration in the video is calculated if two frames of no detect to account for skipped frame\\n if count_current < count_last_last and count_last < count_last_last:\\n duration = int(time.time() - start_time)\\n total_duration += duration / 11 #frames per second and evaluating only every other frame\\n avg_duration = int(total_duration / total_count)\\n client.publish(\\\"person/duration\\\", json.dumps({\\\"duration\\\": avg_duration}))\\n\\n #out_frame = cv2.putText(out_frame, \\\"Duration = \\\"+str('% 6.2f' % duration), (10, 540), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 0), 1, cv2.LINE_AA)\\n out_frame = cv2.putText(out_frame, \\\"Average Duration = \\\" + str('% 4.2f' % avg_duration) + \\\" seconds.\\\", (10, 570), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 0), 1, cv2.LINE_AA)\\n\\n # Set a double counter to review two frames at a time\\n count_last_last = count_last\\n count_last = count_current\\n #End block of code from Mentor Help question 129845\\n\\n\\n ### TODO: Send the frame to the FFMPEG server ###\\n out_frame = out_frame.copy(order='C')\\n out_frame = cv2.resize(out_frame, (width, height))\\n np.ascontiguousarray(out_frame, dtype=np.float32)\\n sys.stdout.buffer.write(out_frame)\\n sys.stdout.flush()\\n\\n ### TODO: Write an output image if `single_image_mode` ###\\n\\n #Release the capture and destroy any OpenCV windows\\n cap.release()\\n cv2.destroyAllWindows()\\n\\n #Disconnect from MQTT\\n client.disconnect()\\n\\n #Print final numbers for reference\\n print(\\\"Video stream ended.\\\")\\n print(\\\"Final count was \\\" + str(total_count))\\n print(\\\"Average Duration was \\\" + str(avg_duration) + \\\" seconds.\\\")\",\n \"def parallel_run():\\n from IPython.parallel import Client\\n\\n c = Client() # here is where the client establishes the connection\\n lv = c.load_balanced_view() # this object represents the engines (workers)\\n\\n\\n rays = []\\n maxs=25\\n bounding = AABA(xmin=0, ymin=0, zmin=0, xmax=maxs, ymax=maxs, zmax=maxs,)\\n gridd = np.zeros((maxs,maxs,maxs))\\n # spectrum for red to nir leaves\\n red_nir_leaves = spectrum(np.array([0.5, 0.85]), np.array([0.1, 0.6]), np.array([0.5, 0.1]))\\n # spectrum for soil\\n red_nir_soil = spectrum(np.array([0.5, 0.85]), np.array([0.3, 0.4]), np.array([0.0, 0.0]))\\n\\n\\n # scattering setup\\n scatt = BRDSF(red_nir_leaves, 0.0)\\n lf = leaf(55.0, 0.8) # leaf angle distribution and leaf area density\\n\\n\\n tasks = []\\n for x in xrange(maxs):\\n for y in xrange(maxs):\\n tasks.append(lv.apply(prun, x,y, maxs, gridd, scatt, red_nir_soil, bounding, lf))\\n\\n result = [task.get() for task in tasks] # blocks until all results are back\\n\\n return results\",\n \"def _do_infer(stream_manager_api, data_input):\\n stream_name = b'segmentation'\\n unique_id = stream_manager_api.SendData(\\n stream_name, 0, data_input)\\n if unique_id < 0:\\n raise RuntimeError(\\\"Failed to send data to stream.\\\")\\n\\n keys = [b\\\"mxpi_tensorinfer0\\\"]\\n keyVec = StringVector()\\n for key in keys:\\n keyVec.push_back(key)\\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\\n print(infer_result)\\n if infer_result.size() == 0:\\n print(\\\"infer_result is null\\\")\\n exit()\\n\\n TensorList = MxpiDataType.MxpiTensorPackageList()\\n TensorList.ParseFromString(infer_result[0].messageBuf)\\n data = np.frombuffer(\\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\\n data = data.reshape(1, 19, 1024, 2048)\\n return data\",\n \"def single_inference_process_fn(inference_initializer, inference_mode_config, in_project_meta_json, request_queue,\\n result_meta_queue, progress_queue, project):\\n single_image_inference = inference_initializer()\\n inference_mode = InferenceModeFactory.create(\\n inference_mode_config, ProjectMeta.from_json(in_project_meta_json), single_image_inference)\\n\\n project_meta_sent = False\\n req = ''\\n while req is not None:\\n req = request_queue.get()\\n if req is not None:\\n # Send the resulting project meta to the parent project to make sure we only write the meta JSON once.\\n if not project_meta_sent:\\n try:\\n result_meta_queue.put(inference_mode.out_meta.to_json(), block=False)\\n except queue.Full:\\n pass\\n project_meta_sent = True\\n\\n in_ann = Annotation.load_json_file(req.item_paths.ann_path, inference_mode.out_meta)\\n ann = inference_mode.infer_annotate_image_file(req.item_paths.img_path, in_ann)\\n out_dataset = project.datasets.get(req.ds_name)\\n out_dataset.add_item_file(\\n req.item_name, req.item_paths.img_path, ann=ann, _validate_item=False, _use_hardlink=True)\\n progress_queue.put(1)\",\n \"def create_inference_tasks(task_queue, image_layer_path, convnet_path, \\n mask_layer_path, output_layer_path, output_block_start, output_block_size, \\n grid_size, patch_size, patch_overlap, cropping_margin_size,\\n output_key='output', num_output_channels=3, \\n image_mip=1, output_mip=1, mask_mip=3):\\n for z in tqdm(range(grid_size[0]), desc='z loop'):\\n for y in range(grid_size[1]):\\n for x in range(grid_size[2]):\\n output_offset = tuple(s+x*b for (s, x, b) in \\n zip(output_block_start, (z, y, x), \\n output_block_size))\\n task = InferenceTask(\\n image_layer_path=image_layer_path,\\n convnet_path=convnet_path,\\n mask_layer_path=mask_layer_path,\\n output_layer_path=output_layer_path,\\n output_offset=output_offset,\\n output_shape=output_block_size,\\n patch_size=patch_size, \\n patch_overlap=patch_overlap,\\n cropping_margin_size=cropping_margin_size,\\n output_key=output_key,\\n num_output_channels=num_output_channels,\\n image_mip=image_mip,\\n output_mip=output_mip,\\n mask_mip=mask_mip\\n )\\n task_queue.insert(task)\\n task_queue.wait('Uploading InferenceTasks')\\n\\n vol = CloudVolume(output_layer_path, mip=output_mip)\\n vol.provenance.processing.append({\\n 'method': {\\n 'task': 'InferenceTask',\\n 'image_layer_path': image_layer_path,\\n 'convnet_path': convnet_path,\\n 'mask_layer_path': mask_layer_path,\\n 'output_layer_path': output_layer_path,\\n 'output_offset': output_offset,\\n 'output_shape': output_block_size,\\n 'patch_size': patch_size,\\n 'patch_overlap': patch_overlap,\\n 'cropping_margin_size': cropping_margin_size,\\n 'output_key': output_key,\\n 'num_output_channels': num_output_channels,\\n 'image_mip': image_mip,\\n 'output_mip': output_mip,\\n 'mask_mip': mask_mip,\\n },\\n 'by': OPERATOR_CONTACT,\\n 'date': strftime('%Y-%m-%d %H:%M %Z'),\\n })\\n vol.commit_provenance()\",\n \"def greengrass_infinite_infer_run():\\n try:\\n model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width = init_greengrass()\\n # Do inference until the lambda is killed.\\n \\n while True:\\n t2 = Thread(target = upload_image)\\n t1 = Thread(target = capture_img, args=[model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width])\\n t1.start()\\n t2.start()\\n t1.join()\\n t2.join()\\n # capture_img(model_type, output_map, client, iot_topic, local_display, model_path, model, detection_threshold, input_height, input_width)\\n except Exception as ex:\\n client.publish(topic=iot_topic, payload='Error in face detection lambda: {}'.format(ex))\",\n \"def worker_train():\\n #py_work = np.zeros(model.layer1_size, dtype=np.float32)\\n\\n while True:\\n job = jobs.get(block=True)\\n if job is None: # data finished, exit\\n jobs.task_done()\\n # print('thread %s break' % threading.current_thread().name)\\n break\\n \\n #log.info(\\\"thread start!\\\")\\n #lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\\n lr = self.lr \\n job_words = 0\\n #pre=self.build_model(len(model.vocab), model.layer1_size, lamda = 0.0, learning_rate=lr)\\n x1 = []\\n x2 = []\\n y = []\\n #cur = 0\\n for edge in job:\\n if edge is not None:\\n #cur+=1\\n #if cur % 100 == 0:\\n # log.info(\\\"edge[0].index = {}\\\".format(edge[0].index))\\n #x.append([edge[0].index, edge[1].index)\\n edge_0_emb = np.sum([G[model.vocab_t[edge[0].index]][nodeid]['weight'] *\\n model.node_embedding[model.vocab[nodeid].index] \\n for nodeid in G[model.vocab_t[edge[0].index]]], axis=0)\\n #edge_0_emb = model.node_embedding[edge[0].index] \\n edge_1_emb = np.sum([G[model.vocab_t[edge[1].index]][nodeid]['weight'] *\\n model.node_embedding[model.vocab[nodeid].index] \\n for nodeid in G[model.vocab_t[edge[1].index]]], axis=0)\\n #edge_1_emb = model.node_embedding[edge[1].index]\\n x1.append(edge_0_emb)\\n #print(\\\"edge[0].index = \\\", edge[0].index)\\n #print(\\\"0 nebor g = \\\", [nodeid for nodeid in G[model.vocab_t[edge[0].index]]])\\n #print(\\\"edge[1].index = \\\", edge[1].index)\\n #print(\\\"1 nebor g = \\\", [nodeid for nodeid in G[model.vocab_t[edge[1].index]]])\\n #print(\\\"model.vocab_t = \\\", model.vocab_t)\\n x2.append(edge_1_emb)\\n \\n #print(\\\"1 nebor g = \\\", G[model.vocab_t[edge[1].index]])\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n #y.append(weight)\\n y.append(1.0)\\n #for i in range(int(10 * (weight)) * self.negative):\\n for i in range(self.negative):\\n nodeidx = model.table[np.random.randint(model.table_size - 1)]\\n if nodeidx != edge[0].index and \\\\\\n (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[0].index]]\\n or (model.connected_path[model.vocab_t[edge[0].index]][model.vocab_t[nodeidx]][0] < 0.1)):\\n x1.append(edge_0_emb)\\n x2.append(np.sum([G[model.vocab_t[nodeidx]][nodeid]['weight'] *\\n model.node_embedding[model.vocab[nodeid].index] \\n for nodeid in G[model.vocab_t[nodeidx]]], axis=0)\\n )\\n #x2.append(model.node_embedding[nodeidx]) \\n y.append(0.0)\\n else:\\n i -= 1\\n if nodeidx != edge[1].index and \\\\\\n (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[1].index]]\\n or (model.connected_path[model.vocab_t[edge[1].index]][model.vocab_t[nodeidx]][0] < 0.1)):\\n x1.append(edge_1_emb)\\n x2.append(np.sum([G[model.vocab_t[nodeidx]][nodeid]['weight'] *\\n model.node_embedding[model.vocab[nodeid].index] \\n for nodeid in G[model.vocab_t[nodeidx]]], axis=0)\\n )\\n #x2.append(model.node_embedding[nodeidx]) \\n y.append(0.0)\\n else:\\n i-=1\\n #log.info(\\\"edge end!\\\")\\n #print(\\\"model.node_embedding = \\\", model.node_embedding)\\n \\n #for i in range(1):\\n # feed_dict = {\\n # pre.x1: x1,\\n # pre.x2: x2,\\n # pre.y: y,\\n # pre.w2_init: model.w2\\n # }\\n #saver = tf.train.Saver()\\n #print(\\\"model.w2 = \\\", model.w2)\\n #_, loss, node_embeddings, w2 = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings, pre.w2],\\n #_, loss, w2, mut, mut_ori = sess.run([pre.d_updates, pre.reg_loss, pre.w2, pre.mut, pre.mut_ori],\\n # feed_dict=feed_dict)\\n #log.info(\\\"iter = {}, loss = {}\\\".format(i, loss))\\n #if i == loop - 1:\\n # print(\\\"y = \\\", y)\\n # print(\\\"mut = \\\", mut)\\n # print(\\\"w2.T = \\\", w2.T)\\n #print(\\\"mut_ori = \\\", mut_ori)\\n #loop = 10\\n #for i in range(loop):\\n # for node in G.nodes():\\n # #node_emb = tf.nn.embedding_lookup(self.node_embeddings, model.vocab[node])\\n # tmp = np.zeros(model.layer1_size, dtype=np.float32)\\n # for nnodeid in G[node]:\\n # nodeidx = model.vocab[nnodeid].index\\n # #print(\\\"nodeidx = \\\", nodeidx)\\n # tmp = tmp + model.node_embedding[nodeidx]\\n # #model.node_embedding[model.vocab[node].index] = np.maximum(0, np.matmul(tmp, w2.T))\\n # #model.node_embedding[model.vocab[node].index] = np.exp(np.matmul(tmp, w2.T))\\n # model.node_embedding[model.vocab[node].index] = np.matmul(tmp, w2.T)\\n # #e_x = np.exp(np.matmul(tmp, w2.T) - np.max(np.matmul(tmp, w2.T)))\\n # #model.node_embedding[model.vocab[node].index] = e_x / e_x.sum()\\n # #model.node_embedding = node_embeddings\\n #print(\\\"model.node_embedding_next = \\\", model.node_embedding)\\n #model.w2 = w2\\n #print(\\\"model.w2_next = \\\", model.w2)\\n #x = []\\n #y = []\\n #x.append([edge[1].index, edge[0].index])\\n #weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n #y.append(weight)\\n #y.append(1.0)\\n #for i in range(self.negative):\\n # nodeidx = model.table[np.random.randint(model.table_size)]\\n # if edge[1].index != nodeidx:\\n # x.append([edge[1].index, nodeidx])\\n # y.append(0.0)\\n #feed_dict = {\\n # pre.x: x,\\n # pre.y: y,\\n # pre.node_embeddings_init: model.node_embedding\\n #}\\n \\n #saver = tf.train.Saver()\\n #_, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\\n # feed_dict=feed_dict)\\n\\n #model.node_embedding = node_embeddings\\n #model.node_embedding[edge[1].index] = node_embeddings[edge[1].index]\\n #log.info(\\\"thread end!\\\")\\n job_words += len(y)\\n \\n #log.info(\\\"train_loss: {}, node_embeddings = {}\\\".format(loss, model.node_embedding))\\n \\n #saver.restore(sess, INNER_MODEL_FILE)\\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\\n #job_words = len(x)\\n #log.info(\\\"train_jobs put!\\\")\\n #log.info(\\\"train_jobs_full = {}\\\".format(train_jobs.full()))\\n train_jobs.put([x1, x2, y])\\n #train_jobs.put([x1, x2, y], block=False)\\n #log.info(\\\"train_jobs put end!\\\")\\n jobs.task_done()\\n lock.acquire(timeout=30)\\n try:\\n node_count[0] += job_words\\n\\n elapsed = time.time() - start\\n if elapsed >= next_report[0]:\\n log.info(\\\"PROGRESS: at %.2f%% \\\\tnode_computed %d\\\\talpha %.05f\\\\t %.0f nodes/s\\\" %\\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\\n #log.info(\\\"jobs.qsize() = {}, train_jobs.qsize() = {}\\\".format(jobs.qsize(), train_jobs.qsize()))\\n #train_jobs.put([x1, x2, y])\\n finally:\\n lock.release()\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n\\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n False, # No random scale.\\n False, # No random mirror.\\n args.ignore_label,\\n IMG_MEAN,\\n coord)\\n image, label = reader.image, reader.label\\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n\\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\\n #raw_output = tf.argmax(raw_output, dimension=3)\\n #pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\\n pred = raw_output\\n\\n # Set up TF session and initialize variables.\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n\\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n\\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n\\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n\\n with open(args.data_list) as f:\\n content = f.readlines()\\n\\n content = [x.strip() for x in content]\\n\\n\\n \\n for index, value in enumerate(content):\\n print(\\\"outputting \\\"+str(index))\\n \\timg = tf.image.decode_png(tf.read_file(value.split()[0]), channels=3)\\n raw_img = misc.imread(value.split()[0])\\n print(type(raw_img))\\n \\t# Convert RGB to BGR.\\n \\timg_r, img_g, img_b = tf.split(axis=2, num_or_size_splits=3, value=img)\\n \\timg = tf.cast(tf.concat(axis=2, values=[img_b, img_g, img_r]), dtype=tf.float32)\\n \\t# Extract mean.\\n \\timg -= IMG_MEAN \\n \\t# Predictions.\\n \\traw_output = net.layers['fc1_voc12']\\n\\n \\traw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(img)[0:2,])\\n \\t#pred = raw_output_up\\n probabilities = tf.nn.softmax(raw_output_up)\\n pred = tf.argmax(raw_output_up, dimension=3)\\n \\tpred = tf.expand_dims(pred, dim=3)\\n \\t# Perform inference.\\n \\tpreds, probs = sess.run([pred, probabilities])\\n print(preds.shape)\\n print(probs.shape)\\n print(\\\"probs\\\")\\n print(probs)\\n softmax = probs[0, :, :, :]\\n print(\\\"softmax\\\")\\n print(softmax)\\n print(softmax.shape)\\n print(type(softmax))\\n processed_probabilities = softmax.transpose((2, 0, 1))\\n print(processed_probabilities.shape)\\n print(type(processed_probabilities))\\n crf_processed = performCRF(processed_probabilities, raw_img)\\n\\n im_preds = Image.fromarray(np.uint8(preds[0, :, :, 0]))\\n\\n print(\\\"preds shape\\\", preds.shape)\\n \\tmsk = decode_labels(preds, num_classes=args.num_classes)\\n \\tim = Image.fromarray(msk[0])\\n\\n print(\\\"crf_processed shape\\\", crf_processed.shape)\\n crf_processed = crf_processed.reshape(1, crf_processed.shape[0], crf_processed.shape[1], 1)\\n msk_crf = decode_labels(crf_processed, num_classes=args.num_classes)\\n im_crf = Image.fromarray(msk_crf[0])\\n\\n \\tif not os.path.exists(args.save_dir):\\n os.makedirs(args.save_dir)\\n #im_preds.save(args.save_dir +str(index).zfill(8) +'_predlabels_'+args.train_set+'.png')\\n \\tim.save(args.save_dir +str(index).zfill(8) +'_pred_'+args.train_set+'.png')\\n im_crf.save(args.save_dir +str(index).zfill(8) +'_predcrf_'+args.train_set+'.png')\",\n \"def _process(self):\\n while True:\\n with Timer() as data_timer:\\n frame = self._frames_q.get()\\n\\n with Timer() as agent_timer:\\n s, frame_metadata = self._unwrap_frame(frame)\\n s = np.expand_dims(s, 0) # batch\\n act = self.pred(s)[0][0].argmax()\\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\\n\\n print('.', end='', flush=True)\\n if self.verbose:\\n print('Avg data wait time: %.3f' % data_timer.time())\\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())\",\n \"def inference(self, uInput):\\n self.expose(uInput)\\n for m in range(len(self.layers) - 1):\\n self.layers[m].inference()\\n self.propagate(m, m + 1)\\n\\n ## make inference on the output node\\n self.layers[-1].pipes[0][0].send(\\\"inference\\\")\\n self.layers[-1].pipes[0][0].recv()\\n\\n ## read its output\\n self.layers[-1].pipes[0][0].send(\\\"get_output\\\")\\n msg = self.layers[-1].pipes[0][0].recv()\\n\\n t = msg[1]['dtype']\\n s = msg[1]['shape']\\n output = recv_array(self.layers[-1].pipes[0][0], t, s)\\n\\n return output\",\n \"def infer_on_stream(args, client):\\n # Initialise the class\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n ### TODO: Load the model through `infer_network` ###\\n infer_network.load_model(model=args.model,\\n device=args.device,\\n cpu_extension=args.cpu_extension)\\n\\n net_input_shape = infer_network.get_input_shape()\\n\\n ### TODO: Handle the input stream ###\\n\\n ### Handle image, video or webcam\\n image_flag = False\\n # Check if the input is a webcam\\n if args.input == 'CAM':\\n args.input = 0\\n # Checks if the input is an image\\n elif args.input.endswith('.jpg') or args.input.endswith('.bmp'):\\n image_flag = True\\n # else assume input is vedio file\\n\\n # Get and open video capture\\n cap = cv2.VideoCapture(args.input)\\n if args.input:\\n cap.open(args.input)\\n\\n # Grab the shape of the input\\n width = int(cap.get(3))\\n height = int(cap.get(4))\\n\\n # iniatilize variables\\n count_total = 0\\n count_prev = 0\\n count_curr = 0\\n duration_curr = 0\\n duration_prev = 0\\n duration_total= 0\\n frame_time = 0\\n frame_count = 0\\n timer_curr_start = 0\\n request_id = 0\\n\\n ### TODO: Loop until stream is over ###\\n while cap.isOpened():\\n\\n ### TODO: Read from the video capture ###\\n flag, frame = cap.read()\\n if not flag:\\n break\\n key_pressed = cv2.waitKey(60)\\n\\n\\n ### TODO: Pre-process the image as needed ###\\n p_frame = cv2.resize(frame, (net_input_shape[3], net_input_shape[2]))\\n # Update layout\\n p_frame = p_frame.transpose((2,0,1))\\n p_frame = p_frame.reshape(1, *p_frame.shape)\\n\\n ### TODO: Start asynchronous inference for specified request ###\\n timer_infer_start = time.time()\\n infer_network.exec_net(p_frame, request_id)\\n\\n ### TODO: Wait for the result ###\\n if infer_network.wait(request_id) == 0:\\n\\n ### TODO: Get the results of the inference request ###\\n timer_infer_delay = time.time() - timer_infer_start\\n result = infer_network.get_output(request_id)\\n\\n\\n ### TODO: Extract any desired stats from the results ###\\n\\n # Draw bounding box\\n conf = result[0, 0, :, 2]\\n count_curr = 0\\n for i, c in enumerate(conf):\\n if c > prob_threshold:\\n rect_box = result[0, 0, i, 3:]\\n min_x = int(rect_box[0] * width)\\n min_y = int(rect_box[1] * height)\\n max_x = int(rect_box[2] * width)\\n max_y = int(rect_box[3] * height)\\n frame = cv2.rectangle(frame, (min_x, min_y), (max_x, max_y), (255,0, 0), 1)\\n count_curr = count_curr + 1\\n\\n ### TODO: Calculate and send relevant information on ###\\n\\n ### current_count, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n\\n # IF new person comes inside imapge\\n if count_curr > count_prev:\\n timer_curr_start = time.time()\\n count_total = count_total + count_curr - count_prev\\n client.publish('person', payload=json.dumps({'total': count_total}))\\n\\n # Calc Person Duration\\n if count_curr < count_prev:\\n timer_curr_delay = time.time() - timer_curr_start\\n client.publish('person/duration', payload=json.dumps({'duration': timer_curr_delay}))\\n\\n # Write out information\\n text_infer = \\\"Inference Delay: {:.3f}ms\\\".format(timer_infer_delay * 1000)\\n text_counter = \\\"Current Counter: {}\\\".format(count_curr)\\n cv2.putText(frame, text_infer, (10, 15),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 0, 0), 1)\\n cv2.putText(frame, text_counter, (10, 30),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1)\\n\\n if count_curr > 0:\\n text_duration = \\\"Current Duration: {:.1f}s\\\".format(time.time() - timer_curr_start)\\n cv2.putText(frame, text_duration, (10, 45),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\\n\\n count_prev = count_curr\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": count_curr}))\\n\\n\\n ### TODO: Send the frame to the FFMPEG server ###\\n sys.stdout.buffer.write(frame)\\n sys.stdout.flush()\\n # Break if escape key pressed\\n if key_pressed == 27:\\n break\\n\\n ### TODO: Write an output image if `single_image_mode` ###\\n\\n # Release the capture and destroy any OpenCV windows\\n cap.release()\\n cv2.destroyAllWindows()\\n client.disconnect()\",\n \"def postprocess(self,graph_output):\\n (w,h,f) = self.rawinputformat()\\n #print(w,h)\\n #print(graph_output.shape)\\n results = self.interpret_output(graph_output.astype(numpy.float32), w, h)\\n print(results)\\n #order = graph_output.argsort()\\n #last = len(self.categories)-1\\n #res = NcsResult();\\n #print(len(results))\\n #for i in range(0,len(results)):\\n # res = results[i]\\n #res.add( self.categories[order[last-i]], ( graph_output[order[last-i]] ) )\\n return res\\n\\n # YOLO stuff\",\n \"def infer_on_stream(args, client):\\n # Initialise the class\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n ### TODO: Load the model through `infer_network` ###\\n infer_network.exec_network = infer_network.load_model\\\\\\n (args.model, args.device, args.cpu_extension)\\n # extract information about model input layer\\n (b, c, input_height, input_width) = infer_network.get_input_shape()\\n\\n ### TODO: Handle the input stream ###\\n # extenstion of input file\\n input_extension = os.path.splitext(args.input)[1].lower()\\n supported_vid_exts = ['.mp4', '.mpeg', '.avi', '.mkv']\\n supported_img_exts = [\\\".bmp\\\",\\\".dib\\\", \\\".jpeg\\\", \\\".jp2\\\", \\\".jpg\\\", \\\".jpe\\\",\\\\\\n \\\".png\\\", \\\".pbm\\\", \\\".pgm\\\", \\\".ppm\\\", \\\".sr\\\", \\\".ras\\\", \\\".tiff\\\", \\\".tif\\\"]\\n single_image_mode = False\\n # if input is camera\\n if args.input.upper() == 'CAM':\\n capture = cv2.VideoCapture(0)\\n \\n # if input is video\\n elif input_extension in supported_vid_exts:\\n capture = cv2.VideoCapture(args.input)\\n \\n # if input is image\\n elif input_extension in supported_img_exts:\\n single_image_mode = True\\n capture = cv2.VideoCapture(args.input) \\n capture.open(args.input)\\n else:\\n sys.exit(\\\"FATAL ERROR : The format of your input file is not supported\\\" \\\\\\n \\\"\\\\nsupported extensions are : \\\" + \\\", \\\".join(supported_exts))\\n prev_count = 0\\n total_persons = 0\\n ### TODO: Loop until stream is over ###\\n while (capture.isOpened()):\\n ### TODO: Read from the video capture ###\\n ret, frame = capture.read()\\n if not ret:\\n break\\n ### TODO: Pre-process the image as needed ###\\n image = preprocessing(frame, input_width, input_height)\\n ### TODO: Start asynchronous inference for specified request ###\\n start_time = time.time()\\n # run inference\\n infer_network.exec_net(image)\\n ### TODO: Wait for the result ###\\n if infer_network.wait() == 0:\\n infer_time = time.time() - start_time\\n ### TODO: Get the results of the inference request ###\\n outputs = infer_network.get_output()[0][0]\\n ### Take model output and extract number of detections with confidence exceeding threshold\\n ### and draw bounding boxes around detections\\n out_image, current_count = apply_threshold(outputs, frame, prob_threshold)\\n \\n # show inference time on image\\n cv2.putText(out_image, \\\"inference time: {:.5f} ms\\\".format(infer_time), (30, 30),\\\\\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\\n \\n ### TODO: Extract any desired stats from the results ###\\n # when any person exit\\n if current_count < prev_count:\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n # send duration to mqtt server client\\n client.publish(\\\"person/duration\\\", json.dumps({\\\"duration\\\": time.time() - p_start}))\\n\\n # when new person enters\\n if current_count > prev_count:\\n total_persons += current_count - prev_count\\n p_start = time.time()\\n \\n prev_count = current_count\\n \\n ### TODO: Calculate and send relevant information on ###\\n ### current_count, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": current_count,\\\"total\\\": total_persons}))\\n ### TODO: Send the frame to the FFMPEG server ###\\n sys.stdout.buffer.write(out_image)\\n sys.stdout.buffer.flush()\\n ### TODO: Write an output image if `single_image_mode` ###\\n if single_image_mode:\\n cv2.imwrite(\\\"output_frame.png\\\", out_image)\\n # release resources\\n capture.release()\\n cv2.destroyAllWindows()\\n client.disconnect()\\n del infer_network\",\n \"def async_infer(self, data, req_id):\\n\\n input_data = {self.input_tensor_name: data}\\n self.infer_queue.start_async(input_data, req_id)\",\n \"def infinite_infer_run():\\n try:\\n # This cat-dog model is implemented as binary classifier, since the number\\n # of labels is small, create a dictionary that converts the machine\\n # labels to human readable labels.\\n model_type = 'classification'\\n output_map = {0: 'dog', 1: 'cat'}\\n\\n # Create an IoT client for sending to messages to the cloud.\\n client = greengrasssdk.client('iot-data')\\n iot_topic = '$aws/things/{}/infer'.format(os.environ['AWS_IOT_THING_NAME'])\\n\\n # Create a local display instance that will dump the image bytes to a FIFO\\n # file that the image can be rendered locally.\\n local_display = LocalDisplay('480p')\\n local_display.start()\\n\\n # The sample projects come with optimized artifacts, hence only the artifact\\n # path is required.\\n model_path = '/opt/awscam/artifacts/mxnet_resnet18-catsvsdogs_FP32_FUSED.xml'\\n\\n # Load the model onto the GPU.\\n client.publish(topic=iot_topic, payload='Loading action cat-dog model')\\n model = awscam.Model(model_path, {'GPU': 1})\\n client.publish(topic=iot_topic, payload='Cat-Dog model loaded')\\n\\n # Since this is a binary classifier only retrieve 2 classes.\\n num_top_k = 2\\n\\n # The height and width of the training set images\\n input_height = 224\\n input_width = 224\\n\\n # Do inference until the lambda is killed.\\n while True:\\n # inference loop to add. See the next step \\n ...\\n\\n\\n except Exception as ex:\\n client.publish(topic=iot_topic, payload='Error in cat-dog lambda: {}'.format(ex))\\n# snippet-end:[deeplens.python.deeplens_inference_lambda.inference_loop]\\n\\n# snippet-start:[deeplens.python.deeplens_inference_lambda.inference_step]\\n # Get a frame from the video stream\\n ret, frame = awscam.getLastFrame()\\n if not ret:\\n raise Exception('Failed to get frame from the stream')\\n # Resize frame to the same size as the training set.\\n frame_resize = cv2.resize(frame, (input_height, input_width))\\n # Run the images through the inference engine and parse the results using\\n # the parser API, note it is possible to get the output of doInference\\n # and do the parsing manually, but since it is a classification model,\\n # a simple API is provided.\\n parsed_inference_results = model.parseResult(model_type,\\n model.doInference(frame_resize))\\n # Get top k results with highest probabilities\\n top_k = parsed_inference_results[model_type][0:num_top_k]\\n # Add the label of the top result to the frame used by local display.\\n # See https://docs.opencv.org/3.4.1/d6/d6e/group__imgproc__draw.html\\n # for more information about the cv2.putText method.\\n # Method signature: image, text, origin, font face, font scale, color, and thickness\\n cv2.putText(frame, output_map[top_k[0]['label']], (10, 70),\\n cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 165, 20), 8)\\n # Set the next frame in the local display stream.\\n local_display.set_frame_data(frame)\\n # Send the top k results to the IoT console via MQTT\\n cloud_output = {}\\n for obj in top_k:\\n cloud_output[output_map[obj['label']]] = obj['prob']\\n client.publish(topic=iot_topic, payload=json.dumps(cloud_output))\",\n \"def inference():\\n if request.method == \\\"POST\\\":\\n data = request.json #\\n src_img = np.array(data[\\\"src\\\"]).astype(np.uint8) # Parsing data\\n ref_img = np.array(data[\\\"ref\\\"]).astype(np.uint8) #\\n ref_label = int(data[\\\"ref_label\\\"]) #\\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\\n return jsonify({\\\"result\\\": result.tolist()}) # Returning results into json\",\n \"def inference_call(self, inputs):\\n self.eval()\\n\\n with torch.no_grad():\\n mid, downsampling_features = self.encoder(inputs)\\n hd = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=0)\\n pl = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=1)\\n return hd, pl\",\n \"def inference(self):\\n raise NotImplementedError\",\n \"def do_parallel_inference(args):\\n from treehmm import random_params, do_inference, plot_params, plot_energy, load_params\\n from treehmm.vb_mf import normalize_trans\\n from treehmm.static import float_type\\n\\n _x = sp.load(args.observe_matrix[0])\\n args.continuous_observations = _x.dtype != sp.int8\\n args.I, _, args.L = _x.shape\\n I = args.I\\n K = args.K\\n L = args.L\\n args.T = 'all'\\n args.free_energy = []\\n args.observe = 'all.npy'\\n args.last_free_energy = 0\\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\\n\\n args.out_dir = args.out_dir.format(timestamp=time.strftime('%x_%X').replace('/', '-'), **args.__dict__)\\n try:\\n print 'making', args.out_dir\\n os.makedirs(args.out_dir)\\n except OSError:\\n pass\\n\\n if args.warm_start:\\n # args.last_free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(args)\\n # args.warm_start = False\\n print '# loading previous params for warm start from %s' % args.warm_start\\n tmpargs = copy.deepcopy(args)\\n tmpargs.out_dir = args.warm_start\\n tmpargs.observe = 'all.npy'\\n args.free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(tmpargs)\\n\\n try:\\n args.free_energy = list(args.free_energy)\\n except TypeError: # no previous free energy\\n args.free_energy = []\\n print 'done'\\n args.warm_start = False\\n else:\\n (args.theta, args.alpha, args.beta, args.gamma, args.emit_probs) = \\\\\\n random_params(args.I, args.K, args.L, args.separate_theta)\\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'last_free_energy', 'emit_sum']:\\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\\n args.__dict__[p])\\n\\n \\n args.iteration = 0\\n plot_params(args)\\n print '# setting up job arguments'\\n # set up new versions of args for other jobs\\n job_args = [copy.copy(args) for i in range(len(args.observe_matrix))]\\n for j, a in enumerate(job_args):\\n a.observe_matrix = args.observe_matrix[j]\\n a.observe = os.path.split(args.observe_matrix[j])[1]\\n a.subtask = True\\n a.func = None\\n a.iteration = 0\\n a.max_iterations = 1\\n a.quiet_mode = True\\n if j % 1000 == 0:\\n print j\\n\\n if args.run_local:\\n pool = multiprocessing.Pool()\\n else:\\n pool = sge.SGEPool()\\n #job_handle = pool.imap_unordered(do_inference, job_args)\\n\\n converged = False\\n for args.iteration in range(args.max_iterations):\\n # import ipdb; ipdb.set_trace()\\n # fresh parameters-- to be aggregated after jobs are run\\n print 'iteration', args.iteration\\n total_free = 0\\n if args.separate_theta:\\n args.theta = sp.zeros((I - 1, K, K, K), dtype=float_type)\\n else:\\n args.theta = sp.zeros((K, K, K), dtype=float_type)\\n\\n args.alpha = sp.zeros((K, K), dtype=float_type)\\n args.beta = sp.zeros((K, K), dtype=float_type)\\n args.gamma = sp.zeros((K), dtype=float_type)\\n args.emit_probs = sp.zeros((K, L), dtype=float_type)\\n if True: # args.approx == 'clique':\\n args.emit_sum = sp.zeros_like(args.emit_probs, dtype=float_type)\\n else:\\n args.emit_sum = sp.zeros((K, L), dtype=float_type)\\n\\n if args.run_local:\\n iterator = pool.imap_unordered(do_inference, job_args, chunksize=args.chunksize)\\n # wait for jobs to finish\\n for result in iterator:\\n pass\\n else:\\n jobs_handle = pool.map_async(do_inference, job_args, chunksize=args.chunksize)\\n # wait for all jobs to finish\\n for j in jobs_handle:\\n j.wait()\\n\\n # sum free energies and parameters from jobs\\n for a in job_args:\\n # print '# loading from %s' % a.observe\\n free_energy, theta, alpha, beta, gamma, emit_probs, emit_sum = load_params(a)\\n # print 'free energy for this part:', free_energy\\n if len(free_energy) > 0:\\n last_free_energy = free_energy[-1]\\n else:\\n last_free_energy = 0\\n total_free += last_free_energy\\n args.theta += theta\\n args.alpha += alpha\\n args.beta += beta\\n args.gamma += gamma\\n args.emit_probs += emit_probs\\n args.emit_sum += emit_sum\\n\\n # renormalize and plot\\n print 'normalize aggregation... total free energy is:', total_free\\n args.free_energy.append(total_free)\\n if len(args.free_energy) > 1 and args.free_energy[-1] != 0 and args.free_energy[-2] != 0 \\\\\\n and abs((args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]) < args.epsilon:\\n print 'converged. free energy diff:', args.free_energy, abs(args.free_energy[-2] - args.free_energy[-1]) / args.free_energy[-2]\\n converged = True\\n normalize_trans(args.theta, args.alpha, args.beta, args.gamma)\\n # if True: #args.approx == 'clique':\\n # #print 'clique emit renorm'\\n # args.emit_probs[:] = args.emit_probs / args.emit_sum\\n # else:\\n # args.emit_probs[:] = sp.dot(sp.diag(1./args.emit_sum), args.emit_probs)\\n args.emit_probs[:] = sp.dot(sp.diag(1. / args.emit_sum), args.emit_probs)\\n for a in job_args:\\n a.theta, a.alpha, a.beta, a.gamma, a.emit_probs, a.emit_sum = args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum\\n\\n for p in ['free_energy', 'theta', 'alpha', 'beta', 'gamma', 'emit_probs', 'lmd', 'tau']:\\n try:\\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\\n args.__dict__[p])\\n except KeyError:\\n pass\\n plot_params(args)\\n plot_energy(args)\\n\\n if args.save_Q >= 3:\\n print '# reconstructing chromosomes from *chunk*',\\n in_order = {}\\n # Q_chr16_all.trimmed.chunk*.npy => Q_chr16_all.trimmed.npy\\n all_chunks = glob.glob(os.path.join(args.out_dir, '*_Q_*chunk*.npy'))\\n for chunk in all_chunks:\\n print chunk\\n chunk_num = int(re.search(r'chunk(\\\\d+)', chunk).groups()[0])\\n chrom_out = re.sub('chunk(\\\\d+)\\\\.', '', chunk)\\n if chrom_out not in in_order:\\n in_order[chrom_out] = {}\\n in_order[chrom_out][chunk_num] = sp.load(chunk)\\n for chrom_out in in_order:\\n print 'reconstructing chromosomes from', in_order[chrom_out]\\n if len(in_order[chrom_out]) > 1:\\n final_array = sp.concatenate((in_order[chrom_out][0], in_order[chrom_out][1]), axis=1)\\n for i in range(2, max(in_order[chrom_out])):\\n final_array = sp.concatenate((final_array, in_order[chrom_out][i]), axis=1)\\n else:\\n final_array = in_order[chrom_out][0]\\n sp.save(chrom_out, final_array)\\n\\n if converged:\\n break\",\n \"def main():\\n # Grab command line args\\n args = build_argparser().parse_args()\\n #print(\\\"finished argparser\\\")\\n\\n # Connect to the MQTT server\\n client = connect_mqtt()\\n #print(\\\"finished mqtt connect\\\")\\n\\n # Perform inference on the input stream\\n infer_on_stream(args, client)\",\n \"def worker(nums, out_q):\\n outdict = {}\\n print(threading.current_thread().name)\\n print (\\\"pid:\\\", os.getpid())\\n print (\\\"data size:\\\", nums)\\n for n in nums:\\n outdict[n] = factorize_naive(n)\\n out_q.put(outdict)\",\n \"def post_handler(_dev_idx, raw_res, _captured_frames_path):\\n global CUR_IMAGE\\n if CUR_IMAGE % 2:\\n print(\\\"\\\\nFox classification\\\")\\n else:\\n print(\\\"\\\\nCat classification\\\")\\n\\n scores, _labels = postprocess(raw_res[0])\\n top_indices(scores[0], 3)\\n\\n CUR_IMAGE += 1\",\n \"def infinite_infer_run():\\n try:\\n # This cat-dog model is implemented as binary classifier, since the number\\n # of labels is small, create a dictionary that converts the machine\\n # labels to human readable labels.\\n model_type = 'classification'\\n output_map = {0: 'dog', 1: 'cat'}\\n # Create an IoT client for sending to messages to the cloud.\\n client = greengrasssdk.client('iot-data')\\n iot_topic = '$aws/things/{}/infer'.format(os.environ['AWS_IOT_THING_NAME'])\\n # Create a local display instance that will dump the image bytes to a FIFO\\n # file that the image can be rendered locally.\\n local_display = LocalDisplay('480p')\\n local_display.start()\\n # The sample projects come with optimized artifacts, hence only the artifact\\n # path is required.\\n model_path = '/opt/awscam/artifacts/mxnet_resnet18-catsvsdogs_FP32_FUSED.xml'\\n # Load the model onto the GPU.\\n client.publish(topic=iot_topic, payload='Loading action cat-dog model')\\n model = awscam.Model(model_path, {'GPU': 1})\\n client.publish(topic=iot_topic, payload='Cat-Dog model loaded')\\n # Since this is a binary classifier only retrieve 2 classes.\\n num_top_k = 2\\n # The height and width of the training set images\\n input_height = 224\\n input_width = 224\\n # Do inference until the lambda is killed.\\n while True:\\n # Get a frame from the video stream\\n ret, frame = awscam.getLastFrame()\\n if not ret:\\n raise Exception('Failed to get frame from the stream')\\n # Resize frame to the same size as the training set.\\n frame_resize = cv2.resize(frame, (input_height, input_width))\\n # Run the images through the inference engine and parse the results using\\n # the parser API, note it is possible to get the output of doInference\\n # and do the parsing manually, but since it is a classification model,\\n # a simple API is provided.\\n parsed_inference_results = model.parseResult(model_type,\\n model.doInference(frame_resize))\\n # Get top k results with highest probabilities\\n top_k = parsed_inference_results[model_type][0:num_top_k]\\n # Add the label of the top result to the frame used by local display.\\n # See https://docs.opencv.org/3.4.1/d6/d6e/group__imgproc__draw.html\\n # for more information about the cv2.putText method.\\n # Method signature: image, text, origin, font face, font scale, color, and thickness\\n cv2.putText(frame, output_map[top_k[0]['label']], (10, 70),\\n cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 165, 20), 8)\\n # Set the next frame in the local display stream.\\n local_display.set_frame_data(frame)\\n # Send the top k results to the IoT console via MQTT\\n cloud_output = {}\\n for obj in top_k:\\n cloud_output[output_map[obj['label']]] = obj['prob']\\n client.publish(topic=iot_topic, payload=json.dumps(cloud_output))\\n except Exception as ex:\\n client.publish(topic=iot_topic, payload='Error in cat-dog lambda: {}'.format(ex))\",\n \"def inference(images, indication, flags):\\r\\n # We instantiate all variables using tf.get_variable() instead of\\r\\n # tf.Variable() in order to share variables across multiple GPU training runs.\\r\\n # If we only ran this model on a single GPU, we could simplify this function\\r\\n # by replacing all instances of tf.get_variable() with tf.Variable().\\r\\n \\r\\n # conv1\\r\\n with tf.variable_scope('conv1') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[7, 7, 3, 32],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(input=images, filter=kernel, strides=[1, 2, 2, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_1 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_1)\\r\\n\\r\\n \\r\\n # pool1\\r\\n pool_1 = tf.nn.max_pool(conv_1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\r\\n padding='SAME', name='pool1') \\r\\n # conv2\\r\\n with tf.variable_scope('conv2') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 32, 32],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(pool_1, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases) \\r\\n conv_2 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_2)\\r\\n \\r\\n # conv3\\r\\n with tf.variable_scope('conv3') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 32, 32],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_2, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [32], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_3 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_3) \\r\\n \\r\\n \\r\\n # pool2\\r\\n pool_2 = tf.nn.max_pool(conv_3, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\r\\n padding='SAME', name='pool2')\\r\\n \\r\\n # conv4\\r\\n with tf.variable_scope('conv4') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 32, 64],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(pool_2, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases) \\r\\n conv_4 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_4)\\r\\n \\r\\n # conv5\\r\\n with tf.variable_scope('conv5') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 64, 64],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_4, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_5 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_5) \\r\\n\\r\\n # conv6\\r\\n with tf.variable_scope('conv6') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 64, 64],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_5, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_6 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_6) \\r\\n \\r\\n # pool3\\r\\n pool_3 = tf.nn.max_pool(conv_6, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\r\\n padding='SAME', name='pool3') \\r\\n # conv7\\r\\n with tf.variable_scope('conv7') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 64, 128],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(pool_3, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n\\r\\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_7 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \\r\\n _activation_summary(conv_7)\\r\\n\\r\\n # conv8\\r\\n with tf.variable_scope('conv8') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 128, 128],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_7, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases) \\r\\n conv_8 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_8) \\r\\n \\r\\n # conv9\\r\\n with tf.variable_scope('conv9') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 128, 128],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_8, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_9 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_9) \\r\\n \\r\\n # conv10\\r\\n with tf.variable_scope('conv10') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 128, 128],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_9, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [128], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_10 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_10) \\r\\n \\r\\n # pool4\\r\\n pool_4 = tf.nn.max_pool(conv_10, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\r\\n padding='SAME', name='pool4') \\r\\n # conv11\\r\\n with tf.variable_scope('conv11') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 128, 256],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(pool_4, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_11 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_11)\\r\\n \\r\\n # conv12\\r\\n with tf.variable_scope('conv12') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 256, 256],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_11, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_12 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \\r\\n _activation_summary(conv_12) \\r\\n \\r\\n # conv13\\r\\n with tf.variable_scope('conv13') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 256, 256],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_12, kernel, [1, 1, 1, 1], padding='SAME') \\r\\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_13 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name) \\r\\n _activation_summary(conv_13) \\r\\n \\r\\n # conv14\\r\\n with tf.variable_scope('conv14') as scope:\\r\\n kernel = _variable_with_weight_decay('weights',\\r\\n shape=[3, 3, 256, 256],\\r\\n init_parameter=0.001,\\r\\n wd=0.0,\\r\\n use_fp16=flags.use_fp16)\\r\\n conv = tf.nn.conv2d(conv_13, kernel, [1, 1, 1, 1], padding='SAME')\\r\\n biases = _variable_on_cpu('biases', [256], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n pre_activation = tf.nn.bias_add(conv, biases)\\r\\n conv_14 = tf.nn.leaky_relu(pre_activation, alpha=0.5 ,name=scope.name)\\r\\n _activation_summary(conv_14) \\r\\n\\r\\n # pool5\\r\\n pool_5 = tf.nn.max_pool(conv_14, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\r\\n padding='SAME', name='pool5') \\r\\n # dropout1\\r\\n dropout_1 = tf.nn.dropout(pool_5, keep_prob=0.25, name='dropout1') \\r\\n \\r\\n # maxout1\\r\\n with tf.variable_scope('maxout1') as scope:\\r\\n # reshape from convolution\\r\\n reshape = tf.reshape(dropout_1, [-1, 16384])\\r\\n weights = _variable_with_weight_decay('weights', shape=[16384, 512, 2],\\r\\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16) \\r\\n biases = _variable_on_cpu('biases', [512, 2], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n maxout = tf.tensordot(reshape, weights, axes=1) + biases\\r\\n maxout_1 = tf.reduce_max(maxout, axis=2, name=scope.name)\\r\\n _activation_summary(maxout_1) \\r\\n \\r\\n # merge two eyes\\r\\n with tf.variable_scope('reshape1') as scope:\\r\\n # concat left and right lable\\r\\n concat_1 = tf.concat([maxout_1,indication], axis=-1)\\r\\n # reshape1(merge eyes)\\r\\n reshape_1 = tf.reshape(concat_1, [32,-1], name=scope.name)\\r\\n \\r\\n # dropout2\\r\\n dropout_2 = tf.nn.dropout(reshape_1, keep_prob=0.25, name='dropout2') \\r\\n \\r\\n # maxout2\\r\\n with tf.variable_scope('maxout2') as scope:\\r\\n reshape = tf.reshape(dropout_2, [-1, 1028])\\r\\n weights = _variable_with_weight_decay('weights', shape=[1028, 512, 2],\\r\\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16) \\r\\n biases = _variable_on_cpu('biases', [512, 2], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n maxout = tf.tensordot(reshape, weights, axes=1) + biases\\r\\n maxout_2 = tf.reduce_max(maxout, axis=2, name='maxout2')\\r\\n _activation_summary(maxout_2) \\r\\n\\r\\n # dropout3\\r\\n dropout_3 = tf.nn.dropout(maxout_2, keep_prob=0.25, name='dropout3')\\r\\n \\r\\n # linear layer(WX + b),\\r\\n # We don't apply softmax here because\\r\\n # tf.nn.sparse_softmax_cross_entropy_with_logits accepts the unscaled logits\\r\\n # and performs the softmax internally for efficiency.\\r\\n with tf.variable_scope('softmax_linear') as scope:\\r\\n weights = _variable_with_weight_decay('weights', [512, 2*NUM_CLASSES],\\r\\n init_parameter=0.001, wd=0.0, use_fp16=flags.use_fp16)\\r\\n biases = _variable_on_cpu('biases', [2*NUM_CLASSES], tf.constant_initializer(0.0), flags.use_fp16)\\r\\n softmax_linear = tf.add(tf.matmul(dropout_3, weights), biases, name=scope.name)\\r\\n _activation_summary(softmax_linear)\\r\\n \\r\\n # back to one eye\\r\\n with tf.variable_scope('reshape2') as scope:\\r\\n reshape_2 = tf.reshape(softmax_linear,[64,5],name=scope.name)\\r\\n \\r\\n return reshape_2\",\n \"def run_inference(dataset, model, executor_):\\n for batch in dataset:\\n results = model.inference(batch)\\n for stats in model.worker_pool.imap(get_stats_from_code, zip(results, batch, [executor_]*len(batch))):\\n if stats is not None:\\n yield stats\\n return\",\n \"def main():\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n h, w = INPUT_SIZE\\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(DATA_DIRECTORY, DATA_LIST_PATH, None, False, False, coord)\\n image = reader.image\\n image_rev = tf.reverse(image, tf.stack([1]))\\n image_list = reader.image_list\\n\\n image_batch_origin = tf.stack([image, image_rev])\\n image_batch = tf.image.resize_images(image_batch_origin, [int(h), int(w)])\\n image_batch075 = tf.image.resize_images(image_batch_origin, [int(h * 0.75), int(w * 0.75)])\\n image_batch125 = tf.image.resize_images(image_batch_origin, [int(h * 1.25), int(w * 1.25)])\\n \\n # Create network.\\n with tf.variable_scope('', reuse=False):\\n net_100 = JPPNetModel({'data': image_batch}, is_training=False, n_classes=N_CLASSES)\\n with tf.variable_scope('', reuse=True):\\n net_075 = JPPNetModel({'data': image_batch075}, is_training=False, n_classes=N_CLASSES)\\n with tf.variable_scope('', reuse=True):\\n net_125 = JPPNetModel({'data': image_batch125}, is_training=False, n_classes=N_CLASSES)\\n\\n \\n # parsing net\\n parsing_fea1_100 = net_100.layers['res5d_branch2b_parsing']\\n parsing_fea1_075 = net_075.layers['res5d_branch2b_parsing']\\n parsing_fea1_125 = net_125.layers['res5d_branch2b_parsing']\\n\\n parsing_out1_100 = net_100.layers['fc1_human']\\n parsing_out1_075 = net_075.layers['fc1_human']\\n parsing_out1_125 = net_125.layers['fc1_human']\\n\\n # pose net\\n resnet_fea_100 = net_100.layers['res4b22_relu']\\n resnet_fea_075 = net_075.layers['res4b22_relu']\\n resnet_fea_125 = net_125.layers['res4b22_relu']\\n\\n with tf.variable_scope('', reuse=False):\\n pose_out1_100, pose_fea1_100 = pose_net(resnet_fea_100, 'fc1_pose')\\n pose_out2_100, pose_fea2_100 = pose_refine(pose_out1_100, parsing_out1_100, pose_fea1_100, name='fc2_pose')\\n parsing_out2_100, parsing_fea2_100 = parsing_refine(parsing_out1_100, pose_out1_100, parsing_fea1_100, name='fc2_parsing')\\n parsing_out3_100, parsing_fea3_100 = parsing_refine(parsing_out2_100, pose_out2_100, parsing_fea2_100, name='fc3_parsing')\\n\\n with tf.variable_scope('', reuse=True):\\n pose_out1_075, pose_fea1_075 = pose_net(resnet_fea_075, 'fc1_pose')\\n pose_out2_075, pose_fea2_075 = pose_refine(pose_out1_075, parsing_out1_075, pose_fea1_075, name='fc2_pose')\\n parsing_out2_075, parsing_fea2_075 = parsing_refine(parsing_out1_075, pose_out1_075, parsing_fea1_075, name='fc2_parsing')\\n parsing_out3_075, parsing_fea3_075 = parsing_refine(parsing_out2_075, pose_out2_075, parsing_fea2_075, name='fc3_parsing')\\n\\n with tf.variable_scope('', reuse=True):\\n pose_out1_125, pose_fea1_125 = pose_net(resnet_fea_125, 'fc1_pose')\\n pose_out2_125, pose_fea2_125 = pose_refine(pose_out1_125, parsing_out1_125, pose_fea1_125, name='fc2_pose')\\n parsing_out2_125, parsing_fea2_125 = parsing_refine(parsing_out1_125, pose_out1_125, parsing_fea1_125, name='fc2_parsing')\\n parsing_out3_125, parsing_fea3_125 = parsing_refine(parsing_out2_125, pose_out2_125, parsing_fea2_125, name='fc3_parsing')\\n\\n\\n parsing_out1 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out1_100, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out1_075, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out1_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\\n parsing_out2 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out2_100, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out2_075, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out2_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\\n parsing_out3 = tf.reduce_mean(tf.stack([tf.image.resize_images(parsing_out3_100, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out3_075, tf.shape(image_batch_origin)[1:3,]),\\n tf.image.resize_images(parsing_out3_125, tf.shape(image_batch_origin)[1:3,])]), axis=0)\\n\\n raw_output = tf.reduce_mean(tf.stack([parsing_out1, parsing_out2, parsing_out3]), axis=0)\\n head_output, tail_output = tf.unstack(raw_output, num=2, axis=0)\\n tail_list = tf.unstack(tail_output, num=20, axis=2)\\n tail_list_rev = [None] * 20\\n for xx in range(14):\\n tail_list_rev[xx] = tail_list[xx]\\n tail_list_rev[14] = tail_list[15]\\n tail_list_rev[15] = tail_list[14]\\n tail_list_rev[16] = tail_list[17]\\n tail_list_rev[17] = tail_list[16]\\n tail_list_rev[18] = tail_list[19]\\n tail_list_rev[19] = tail_list[18]\\n tail_output_rev = tf.stack(tail_list_rev, axis=2)\\n tail_output_rev = tf.reverse(tail_output_rev, tf.stack([1]))\\n\\n \\n raw_output_all = tf.reduce_mean(tf.stack([head_output, tail_output_rev]), axis=0)\\n raw_output_all = tf.expand_dims(raw_output_all, dim=0)\\n raw_output_all = tf.argmax(raw_output_all, dimension=3)\\n pred_all = tf.expand_dims(raw_output_all, dim=3) # Create 4-d tensor.\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if RESTORE_FROM is not None:\\n if load(loader, sess, RESTORE_FROM):\\n print(\\\" [*] Load SUCCESS\\\")\\n else:\\n print(\\\" [!] Load failed...\\\")\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n\\n rand_int = [i/100 for i in random.sample(range(0, 100), NUM_STEPS)]\\n # Iterate over training steps.\\n for step in range(NUM_STEPS):\\n parsing_ = sess.run(pred_all)\\n if step % 100 == 0:\\n print('step {:d}'.format(step))\\n print (image_list[step])\\n img_split = image_list[step].split('/')\\n img_id = img_split[-1][:-4]\\n mask_top = decode_labels(parsing_, [5,6,7,10], num_classes=N_CLASSES)\\n mask_bottom = decode_labels(parsing_, [9, 12], num_classes=N_CLASSES)\\n im_mask_top = Image.fromarray(mask_top[0]).convert('L')\\n im_mask_bottom = Image.fromarray(mask_bottom[0]).convert('L')\\n _mask_top = np.array(im_mask_top)\\n _mask_top[_mask_top != 0 ] = 255\\n _mask_bottom = np.array(im_mask_bottom)\\n _mask_bottom[_mask_bottom != 0 ] = 255\\n\\n real_img = Image.open(image_list[step]).convert(\\\"RGB\\\")\\n top_real_img = Image.open(image_list[step]).convert(\\\"RGB\\\")\\n bottom_real_img = Image.open(image_list[step]).convert(\\\"RGB\\\")\\n\\n imgdata_top = reload_img(top_real_img)\\n for i in range(0,len(imgdata_top)):\\n # hsv code start\\n (h,s,v) = rgb2hsv(imgdata_top[i])\\n h += float(i)/len(imgdata_top)\\n v += 0.005\\n imgdata_top[i] = hsv2rgb((h,s,v))\\n # hsv code end\\n\\n # hls code\\n # (h,l,s) = rgb2hls(imgdata_top[i])\\n # h = rand_int[step]\\n # s = 0.3\\n # imgdata_top[i] = hls2rgb((h,l,s))\\n # hls code end\\n top_real_img.putdata(imgdata_top)\\n im = Image.composite(top_real_img, real_img, Image.fromarray(_mask_top).convert('L'))\\n if _mask_bottom.size > 0:\\n imgdata_bottom = reload_img(bottom_real_img)\\n for i in range(0,len(imgdata_bottom)):\\n # bottom part only use hsv to avoid not matching color with top parts\\n (h,s,v) = rgb2hsv(imgdata_bottom[i])\\n h += float(i)/len(imgdata_bottom)\\n v += 0.005\\n imgdata_bottom[i] = hsv2rgb((h,s,v))\\n bottom_real_img.putdata(imgdata_bottom)\\n im = Image.composite(bottom_real_img, im, Image.fromarray(_mask_bottom).convert('L'))\\n Image.fromarray(_mask_bottom).save('{}/{}_bottom.png'.format(OUTPUT_DIR, img_id))\\n im.save('{}/{}_hsl.png'.format(OUTPUT_DIR, img_id))\\n Image.fromarray(_mask_top).save('{}/{}_top.png'.format(OUTPUT_DIR, img_id))\\n \\n # parsing_im.save('{}/{}_vis.png'.format(OUTPUT_DIR, img_id))\\n # cv2.imwrite('{}/{}.png'.format(OUTPUT_DIR, img_id), parsing_[0,:,:,0])\\n\\n coord.request_stop()\\n coord.join(threads)\",\n \"def process():\",\n \"def compute_output(api, args):\\n\\n fusion = None\\n\\n # variables from command-line options\\n resume = args.resume_\\n fusion_ids = args.fusion_ids_\\n output = args.predictions\\n # there's only one fusion to be generated at present\\n args.max_parallel_fusions = 1\\n # fusion cannot be published yet.\\n args.public_fusion = False\\n\\n # It is compulsory to have a description to publish either datasets or\\n # fusions\\n if (not args.description_ and args.public_fusion):\\n sys.exit(\\\"You should provide a description to publish.\\\")\\n\\n path = u.check_dir(output)\\n session_file = \\\"%s%s%s\\\" % (path, os.sep, SESSIONS_LOG)\\n csv_properties = {}\\n # If logging is required set the file for logging\\n log = None\\n if args.log_file:\\n u.check_dir(args.log_file)\\n log = args.log_file\\n # If --clear_logs the log files are cleared\\n clear_log_files([log])\\n\\n if args.fusion_file:\\n # fusion regression is retrieved from the contents of the given local\\n # JSON file\\n fusion, csv_properties, fields = u.read_local_resource(\\n args.fusion_file,\\n csv_properties=csv_properties)\\n fusion_ids = [fusion]\\n else:\\n # fusion is retrieved from the remote object or created\\n fusion, resume = \\\\\\n pf.fusion_processing( \\\\\\n fusion, fusion_ids, \\\\\\n api, args, resume, \\\\\\n session_file=session_file, path=path, log=log)\\n\\n # We update the fusion public state if needed\\n if fusion:\\n if isinstance(fusion, str):\\n if not a.has_test(args):\\n query_string = MINIMUM_MODEL\\n elif args.export_fields:\\n query_string = r.ALL_FIELDS_QS\\n else:\\n query_string = ''\\n fusion = u.check_resource(fusion,\\n api.get_fusion,\\n query_string=query_string)\\n if (args.public_fusion or\\n (args.shared_flag and r.shared_changed(args.shared,\\n fusion))):\\n fusion_args = {}\\n if args.shared_flag and r.shared_changed(args.shared,\\n fusion):\\n fusion_args.update(shared=args.shared)\\n if args.public_fusion:\\n fusion_args.update( \\\\\\n rfus.set_publish_fusion_args(args))\\n if fusion_args:\\n fusion = rfus.update_fusion( \\\\\\n fusion, fusion_args, args,\\n api=api, path=path, \\\\\\n session_file=session_file)\\n\\n # We get the fields of the fusion if we haven't got\\n # them yet and need them\\n if fusion and (args.test_set or args.evaluate):\\n fields = pf.get_fusion_fields( \\\\\\n fusion, csv_properties, args)\\n\\n\\n # If predicting\\n if fusion and (a.has_test(args) or \\\\\\n args.remote):\\n test_dataset = get_test_dataset(args)\\n\\n # Remote predictions: predictions are computed as batch predictions\\n # in bigml.com except when --no-batch flag is set on\\n if args.remote and not args.no_batch:\\n # create test source from file\\n test_name = \\\"%s - test\\\" % args.name\\n if args.test_source is None:\\n test_properties = ps.test_source_processing(\\n api, args, resume, name=test_name,\\n session_file=session_file, path=path, log=log)\\n (test_source, resume,\\n csv_properties, test_fields) = test_properties\\n else:\\n test_source_id = bigml.api.get_source_id(args.test_source)\\n test_source = api.check_resource(test_source_id)\\n if test_dataset is None:\\n # create test dataset from test source\\n dataset_args = set_basic_dataset_args(args, name=test_name)\\n test_dataset, resume = pd.alternative_dataset_processing(\\n test_source, \\\"test\\\", dataset_args, api, args,\\n resume, session_file=session_file, path=path, log=log)\\n else:\\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\\n test_dataset = api.check_resource(test_dataset_id)\\n\\n csv_properties.update(objective_field=None,\\n objective_field_present=False)\\n test_fields = pd.get_fields_structure(test_dataset,\\n csv_properties)\\n if not args.evaluate:\\n batch_prediction_args = set_batch_prediction_args(\\n args, fields=fields,\\n dataset_fields=test_fields)\\n\\n remote_prediction(fusion, test_dataset, \\\\\\n batch_prediction_args, args, \\\\\\n api, resume, prediction_file=output, \\\\\\n session_file=session_file, path=path, log=log)\\n\\n else:\\n prediction([fusion], fields, args,\\n session_file=session_file)\\n\\n\\n # If evaluate flag is on, create remote evaluation and save results in\\n # json and human-readable format.\\n if args.evaluate:\\n # When we resume evaluation and models were already completed, we\\n # should use the datasets array as test datasets\\n args.max_parallel_evaluations = 1 # only one evaluation at present\\n args.cross_validation_rate = 0 # no cross-validation\\n args.number_of_evaluations = 1 # only one evaluation\\n if args.has_test_datasets_:\\n test_dataset = get_test_dataset(args)\\n dataset = test_dataset\\n dataset = u.check_resource(dataset, api=api,\\n query_string=r.ALL_FIELDS_QS)\\n dataset_fields = pd.get_fields_structure(dataset, None)\\n resume = evaluate([fusion], [dataset], api,\\n args, resume,\\n fields=fields, dataset_fields=dataset_fields,\\n session_file=session_file, path=path,\\n log=log,\\n objective_field=args.objective_field)\\n\\n\\n u.print_generated_files(path, log_file=session_file,\\n verbosity=args.verbosity)\\n if args.reports:\\n clear_reports(path)\\n if args.upload:\\n upload_reports(args.reports, path)\",\n \"def postprocess(self, inference_output):\\n ret = []\\n quantiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\\n # for each request\\n for inference_output_request in inference_output:\\n ret_request = []\\n # for each time series\\n for i in inference_output_request:\\n l = {}\\n l[\\\"item_id\\\"] = i.item_id\\n l[\\\"quantiles\\\"] = {}\\n for q in quantiles:\\n l[\\\"quantiles\\\"][str(q)] = i.quantile(q).tolist()\\n l[\\\"mean\\\"] = i.mean.tolist()\\n ret_request.append(json.dumps(l))\\n ret.append('\\\\n'.join(ret_request) + '\\\\n')\\n return ret\",\n \"def run():\\n import numpy as np\\n\\n batch_size = 500\\n discard_threshold = 50\\n input_base = '/home/ubuntu/faces'\\n model_dir = '/home/ubuntu/FaceNet/20170512-110547'\\n\\n with tf.Graph().as_default():\\n with tf.Session() as sess:\\n\\n meta_file, ckpt_file = facenet.get_model_filenames(os.path.expanduser(model_dir))\\n\\n print('Metagraph file: %s' % meta_file)\\n print('Checkpoint file: %s' % ckpt_file)\\n load_model(model_dir, meta_file, ckpt_file)\\n with open('/home/ubuntu/face_uploaded.txt', 'w') as upload_log:\\n with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:\\n futures = []\\n img_cnt = 0\\n ignored = 0\\n for fam_id in os.listdir(input_base):\\n input_dir = os.path.join(input_base, fam_id)\\n image_paths = get_onedir(input_dir)\\n # image_list, label_list = facenet.get_image_paths_and_labels(train_set)\\n\\n # Get input and output tensors\\n images_placeholder = tf.get_default_graph().get_tensor_by_name(\\\"input:0\\\")\\n embeddings = tf.get_default_graph().get_tensor_by_name(\\\"embeddings:0\\\")\\n phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(\\\"phase_train:0\\\")\\n\\n image_size = images_placeholder.get_shape()[1]\\n embedding_size = embeddings.get_shape()[1]\\n\\n nrof_images = len(image_paths)\\n nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size))\\n emb_array = np.zeros((nrof_images, embedding_size))\\n facial_encodings = compute_facial_encodings(sess, images_placeholder, embeddings, phase_train_placeholder,\\n image_size,\\n embedding_size, nrof_images, nrof_batches, emb_array,\\n batch_size, image_paths)\\n sorted_clusters = cluster_facial_encodings(facial_encodings)\\n if not sorted_clusters:\\n ignored += 1\\n continue\\n\\n sorted_clusters = data_cleaning(sorted_clusters, facial_encodings)\\n\\n # For those families dont have enought photos for child, ignore them\\n # Or those families use mitene in unordinary way.\\n if len(sorted_clusters[0]) < discard_threshold:\\n ignored += 1\\n continue\\n\\n print('Start zip upload for: {0}, contains {1} images!'.format(fam_id, len(sorted_clusters[0])))\\n futures.append(executor.submit(zip_and_upload, sorted_clusters, fam_id))\\n img_cnt += len(sorted_clusters[0])\\n for img in sorted_clusters[0]:\\n upload_log.write('{0},{1}\\\\n'.format(fam_id, os.path.basename(img)))\\n\\n cnt = 0\\n for future in concurrent.futures.as_completed(futures):\\n try:\\n print('job is finished!: ' + future.result())\\n cnt += 1\\n except Exception as e:\\n print('zip and upload job failed!: ' + str(e))\\n\\n print('Finished upload {0} images from {1} families! Ignored {2} families!'.format(img_cnt, cnt, ignored))\",\n \"def run_inference(loop_op: tf.Operation, infeed_queue_initializer: tf.Operation, outfeed_op: tf.Operation,\\n batch_size: int, batches_per_step: int, network_name: str,\\n decode_predictions: Callable, ground_truth: Tuple[str], num_iterations: Optional[int] = 500,\\n num_ipus: Optional[int] = 1, mode: Optional[str] = \\\"single_ipu\\\",\\n data: Optional[str] = \\\"real\\\", available_memory_proportion: Optional[float] = 0.6) -> None:\\n # Set compile and device options\\n opts = IPUConfig()\\n opts.matmuls.poplar_options = {'availableMemoryProportion': str(\\n available_memory_proportion)}\\n opts.convolutions.poplar_options = {'availableMemoryProportion': str(\\n available_memory_proportion)}\\n\\n if mode == 'replicated':\\n num_replicas = num_ipus\\n os.environ[\\\"TF_POPLAR_FLAGS\\\"] += \\\" --force_replicated_mode\\\"\\n else:\\n num_replicas = 1\\n opts.auto_select_ipus = num_ipus\\n opts.configure_ipu_system()\\n with tf.Session() as session:\\n session.run(infeed_queue_initializer)\\n fps = []\\n for iter_count in range(num_iterations):\\n start = time.time()\\n session.run(loop_op)\\n predictions = session.run(outfeed_op)\\n stop = time.time()\\n fps.append(batch_size * batches_per_step * num_replicas / (stop - start))\\n logging.info(\\n \\\"Iter {4}: {0} Throughput using {1} data = {2:.1f} imgs/sec at batch size = {3}\\\".format(network_name,\\n data,\\n fps[-1],\\n batch_size,\\n iter_count))\\n duration = stop - start\\n report_string = \\\"{:<7.3} sec/itr.\\\".format(duration)\\n report_string += \\\" {:5f} images/sec.\\\".format(fps[-1])\\n print(report_string)\\n print(\\\"Total time: {}\\\".format(duration))\\n\\n # Decode a random prediction per step to check functional correctness.\\n if data == 'real':\\n predictions = np.reshape(predictions, (-1, predictions.shape[-1]))\\n index = np.random.randint(0, len(predictions))\\n if network_name in (\\\"inceptionv1\\\", \\\"efficientnet-s\\\", \\\"efficientnet-m\\\", \\\"efficientnet-l\\\"):\\n # These models encode background in 0th index.\\n decoded_predictions = decode_predictions(predictions[index: index + 1, 1:], top=3)\\n else:\\n decoded_predictions = decode_predictions(predictions[index: index + 1, :], top=3)\\n labels_and_probs = [(label, prob) for _, label, prob in decoded_predictions[0]]\\n print('Actual: ',\\n ground_truth[\\n (index + num_replicas * iter_count * batches_per_step * batch_size) % len(ground_truth)])\\n print('Predicted: ', labels_and_probs)\\n\\n print(\\\"Average statistics excluding the 1st 20 iterations.\\\")\\n print(\\\"-------------------------------------------------------------------------------------------\\\")\\n fps = fps[20:]\\n print(\\\"Throughput at bs={}, data_mode={}, data_type={}, mode={},\\\"\\n \\\" num_ipus={}, of {}: min={}, max={}, mean={}, std={}.\\\".format(batch_size,\\n data,\\n predictions.dtype,\\n mode,\\n num_ipus,\\n network_name,\\n min(fps),\\n max(fps),\\n np.mean(fps),\\n np.std(fps)))\",\n \"def process(self, results):\\n raise NotImplementedError\",\n \"def worker_train():\\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\\n\\n while True:\\n job = jobs.get(block=True)\\n if job is None: # data finished, exit\\n jobs.task_done()\\n # print('thread %s break' % threading.current_thread().name)\\n break\\n\\n lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\\n #lr = self.lr \\n job_words = 0\\n #pre=self.build_model(len(model.vocab), model.layer1_size, lamda = 0.0, learning_rate=lr)\\n for edge in job:\\n if edge is not None:\\n x = []\\n y = []\\n x.append([edge[0].index, edge[1].index])\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n #y.append(weight)\\n y.append(1.0)\\n #for i in range(int(10 * (weight)) * self.negative):\\n for i in range(self.negative):\\n nodeidx = model.table[np.random.randint(model.table_size)]\\n if nodeidx != edge[0].index:\\n x.append([edge[0].index, nodeidx])\\n y.append(0.0)\\n feed_dict = {\\n pre.x: x,\\n pre.y: y,\\n pre.node_embeddings_init: model.node_embedding\\n }\\n #saver = tf.train.Saver()\\n _, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\\n feed_dict=feed_dict)\\n model.node_embedding[edge[0].index] = node_embeddings[edge[0].index]\\n x = []\\n y = []\\n x.append([edge[1].index, edge[0].index])\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n #y.append(weight)\\n y.append(1.0)\\n for i in range(self.negative):\\n nodeidx = model.table[np.random.randint(model.table_size)]\\n if edge[1].index != nodeidx:\\n x.append([edge[1].index, nodeidx])\\n y.append(0.0)\\n feed_dict = {\\n pre.x: x,\\n pre.y: y,\\n pre.node_embeddings_init: model.node_embedding\\n }\\n \\n #saver = tf.train.Saver()\\n _, loss, node_embeddings = sess.run([pre.d_updates, pre.reg_loss, pre.node_embeddings_n1],\\n feed_dict=feed_dict)\\n\\n #model.node_embedding = node_embeddings\\n model.node_embedding[edge[1].index] = node_embeddings[edge[1].index]\\n job_words += len(x)\\n \\n #log.info(\\\"train_loss: {}, node_embeddings = {}\\\".format(loss, model.node_embedding))\\n \\n #saver.restore(sess, INNER_MODEL_FILE)\\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\\n #job_words = len(x)\\n jobs.task_done()\\n lock.acquire(timeout=30)\\n try:\\n node_count[0] += job_words\\n\\n elapsed = time.time() - start\\n if elapsed >= next_report[0]:\\n log.info(\\\"PROGRESS: at %.2f%% \\\\tnode_computed %d\\\\talpha %.05f\\\\t %.0f nodes/s\\\" %\\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\\n finally:\\n lock.release()\",\n \"def do_inference(self, output_file = None):\\n return\",\n \"def worker(nums, outdict):\\n print(threading.current_thread().name)\\n print (\\\"pid:\\\", os.getpid())\\n for n in nums:\\n outdict[n] = factorize_naive(n)\",\n \"def task_process(args):\\n if args.mode == 'change model':\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n os.system('rm -rf ctpn_change_{}x{}.onnx'.format(h, w))\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n os.system('{} change_model.py --input_path={}/ctpn_{}x{}.onnx --output_path={}/ctpn_change_{}x{}.onnx' \\\\\\n .format(args.interpreter, args.src_dir, h, w,args.res_dir, h, w)) \\n if args.mode == 'preprocess':\\n for i in range(config.center_len):\\n os.system('mkdir -p {}_{}x{}'.format(args.res_dir, config.center_list[i][0], config.center_list[i][1]))\\n os.system('{} ctpn_preprocess.py --src_dir={} --save_path={}' \\\\\\n .format(args.interpreter, args.src_dir, args.res_dir))\\n if args.mode == 'ais_infer':\\n fps_all = 0\\n os.system('mkdir -p {}/inf_output'.format(args.res_dir))\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n\\n os.system('{} --model={} --input={}_{}x{} --dymHW {},{} --device {} --batchsize={} --output={}/inf_output' \\\\\\n .format(args.interpreter, args.om_path, args.src_dir ,h , w, h, w,args.device, args.batch_size, args.res_dir))\\n\\n sumary_path = glob.glob('{}/inf_output/*ary.json'.format(args.res_dir))[0]\\n with open(sumary_path, 'r') as f:\\n output = json.load(f)\\n throughput = output['throughput'] \\n fps_all = fps_all + throughput * config.center_count[i]\\n os.system('rm -f {}'.format(sumary_path))\\n os.system('mv {}/inf_output/*/*.bin {}'.format(args.res_dir, args.res_dir))\\n os.system('rm {}/inf_output -rf'.format(args.res_dir))\\n fps_all = fps_all / config.imgs_len\\n print(\\\"====performance data====\\\")\\n print('CTPN bs{} models fps:{}'.format(args.batch_size, fps_all))\",\n \"def _backend_run(self):\\n results = None\\n return results\",\n \"def executor(self):\",\n \"def worker_train():\\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\\n\\n while True:\\n job = jobs.get(block=True)\\n if job is None: # data finished, exit\\n jobs.task_done()\\n # print('thread %s break' % threading.current_thread().name)\\n break\\n\\n lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\\n #lr = self.lr \\n job_words = 0\\n #out_i = 0\\n for edge in job:\\n if edge is not None:\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n neg_l = []\\n #负样本node选取和主node不连通的点\\n min_node0, min_conn_tup = sorted(model.connected_path[model.vocab_t[edge[0].index]].items(), key=lambda x:x[1][0])[0]\\n min_conn0 = min_conn_tup[0]\\n min_node1, min_conn_tup = sorted(model.connected_path[model.vocab_t[edge[1].index]].items(), key=lambda x:x[1][0])[0]\\n min_conn1 = min_conn_tup[0]\\n for i in range(self.negative):\\n nodeidx = model.table[np.random.randint(model.table_size - 1)]\\n if (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[0].index]]\\n or (model.connected_path[model.vocab_t[edge[0].index]][model.vocab_t[nodeidx]][0] <= max(0.1,min_conn0))) \\\\\\n and (model.vocab_t[nodeidx] not in model.connected_path[model.vocab_t[edge[1].index]]\\n or (model.connected_path[model.vocab_t[edge[1].index]][model.vocab_t[nodeidx]][1] <= max(0.1,min_conn1))):\\n neg_l.append(nodeidx)\\n if len(neg_l) == 0:\\n neg_l.append(model.vocab[min_node0].index)\\n neg_l.append(model.vocab[min_node1].index)\\n neg_np = np.asarray(neg_l)\\n if weight >= 0.0:\\n #job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, model.table,\\n job_words += sum(train_o1(model.node_embedding, edge, lr, self.negative, neg_np,\\n py_size=model.layer1_size, py_work=py_work) \\n for i in range(1))\\n #for i in range(int(10 * weight)))\\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\\n jobs.task_done()\\n lock.acquire(timeout=30)\\n try:\\n node_count[0] += job_words\\n\\n elapsed = time.time() - start\\n if elapsed >= next_report[0]:\\n log.info(\\\"PROGRESS: at %.2f%% \\\\tnode_computed %d\\\\talpha %.05f\\\\t %.0f nodes/s\\\" %\\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\\n finally:\\n lock.release()\",\n \"def worker(self, q, return_dict):\\n pid = os.getpid()\\n while True:\\n qqq = q.get()\\n if qqq == 'DONE':\\n # print('proc =', os.getpid())\\n break\\n\\n (idx, d) = qqq\\n mol_id = d[0]\\n smi = d[1]\\n # print screening processing in every pout step\\n if self.pout != 0:\\n if idx % self.pout == self.pout-1:\\n print(\\\"processing: \\\", idx+1, flush=True)\\n result_dict = self.simulation_process(idx, mol_id, smi, pid)\\n return_dict[idx] = result_dict\",\n \"def main_pipeline(self, image):\\n # detection\\n t0 = datetime.now()\\n bbox_list, score_list, label_list = self.det.inference(image)\\n t1 = datetime.now()\\n logging.info('main pipeline (det): {}'.format(get_tdiff(t0, t1)))\\n \\n # estimation\\n t0 = datetime.now()\\n disp = self.est.inference(image)\\n depth_list = self.est.calc_depth(bbox_list)\\n t1 = datetime.now()\\n logging.info('main pipeline (est): {}'.format(get_tdiff(t0, t1)))\\n \\n # tracker predict\\n t0 = datetime.now()\\n for t in self.t_list:\\n t.predict()\\n t1 = datetime.now()\\n logging.info('main pipeline (trk_pred): {}'.format(get_tdiff(t0, t1)))\\n \\n # associate\\n t0 = datetime.now()\\n matched_pair, unmatched_bbox_list, _ = associate(bbox_list, label_list, self.t_list)\\n t1 = datetime.now()\\n logging.info('main pipeline (da_solver): {}'.format(get_tdiff(t0, t1)))\\n \\n t0 = datetime.now()\\n # update trackers for matched_pair\\n for m in matched_pair:\\n t = self.t_list[m[1]]\\n bbox = bbox_list[m[0]]\\n depth = depth_list[m[0]]\\n est_dict = {\\n 'label': label_list[m[0]],\\n 'score': score_list[m[0]]}\\n t.update(self.frame_idx, bbox, depth, est_dict)\\n \\n # update in-track status of all trackers\\n for t in self.t_list:\\n t.update_status(self.frame_idx)\\n \\n # purge out dead trackers\\n self.t_list = [t for t in self.t_list if t.get_status()]\\n\\n # create new trackers for unmatched_bbox_list\\n for b_idx in unmatched_bbox_list:\\n bbox = bbox_list[b_idx]\\n depth = depth_list[b_idx]\\n est_dict = {\\n 'label': label_list[b_idx],\\n 'score': score_list[b_idx]}\\n self.t_list.append(tracker(self.t_cfg, self.tid_new, bbox, depth, est_dict))\\n self.tid_new += 1\\n\\n t1 = datetime.now()\\n logging.info('main pipeline (trk_upd): {}'.format(get_tdiff(t0, t1)))\\n\\n # disparity map for display\\n return disp\",\n \"def inference(self, image, score_threshold=None):\\n h, w, c = image.shape\\n image_batch = np.expand_dims(image, axis=0)\\n # get operators from graph\\n image_tensor = self.graph.get_tensor_by_name('image_tensor:0')\\n detection_boxes = self.graph.get_tensor_by_name('detection_boxes:0')\\n detection_scores = self.graph.get_tensor_by_name('detection_scores:0')\\n detection_classes = self.graph.get_tensor_by_name('detection_classes:0')\\n num_detections = self.graph.get_tensor_by_name('num_detections:0')\\n # run inference\\n with self.graph.as_default():\\n t0 = datetime.now()\\n (boxes, scores, classes, num) = self.sess.run(\\n [detection_boxes, detection_scores, detection_classes, num_detections],\\n feed_dict={image_tensor: image_batch})\\n t1 = datetime.now()\\n num = int(num)\\n self._log_info('*TF Detection*: {}'.format(get_tdiff(t0, t1)))\\n # post processing ...\\n # purge useless dimension \\n boxes, scores, classes = np.squeeze(boxes), np.squeeze(scores), np.squeeze(classes)\\n # take only valid results\\n boxes, scores, classes = boxes[:num,:], scores[:num], classes[:num]\\n # score threshold\\n if score_threshold is None:\\n score_threshold = self.score_threshold\\n boxes = boxes[scores>score_threshold,:]\\n classes = classes[scores>score_threshold]\\n scores = scores[scores>score_threshold]\\n num = scores.shape[0]\\n self._log_info('{} objects found'.format(num))\\n # x-y reorder\\n boxes = boxes[:,np.array([1,0,3,2])]\\n # transform from 0-1 to 0-w and 0-h\\n boxes = np.multiply(boxes, np.array([w,h,w,h])).astype(np.int32)\\n return boxes, scores, classes\",\n \"def post_postprocessor(result=None, **kw):\\n logger.info(\\\"start post_postprocessor\\\")\\n logger.info(result)\\n logger.info(\\\"end post_postprocessor\\\")\\n pass\",\n \"async def train(self):\",\n \"def main():\\n # Grab command line args\\n args = build_argparser().parse_args()\\n #print(args)\\n #Connect to the MQTT server\\n client = connect_mqtt()\\n #Perform inference on the input stream\\n infer_on_stream(args, client)\",\n \"def inference():\\n data = request.get_json(force = True)\\n\\n with torch.no_grad():\\n torch.cuda.empty_cache()\\n image = ToTensor(Image.open(BytesIO(b64decode(data['image'])))).half().cuda().unsqueeze_(0)\\n inputs = test_transform(image)\\n model_id = model_usage.get(True)\\n outputs = model[model_id](inputs)[0]\\n model_usage.put(model_id, False)\\n prediction = classes[outputs.argmax(0)]\\n del inputs, outputs, image\\n \\n image_storage.put((data['esun_uuid'], data['image'], prediction), False)\\n\\n t = datetime.datetime.now()\\n ts = str(int(t.utcnow().timestamp()))\\n s = sha256()\\n s.update((CAPTAIN_EMAIL + ts + SALT).encode(\\\"utf-8\\\"))\\n server_uuid = s.hexdigest()\\n\\n return jsonify({'esun_uuid': data['esun_uuid'],\\n 'server_uuid': server_uuid,\\n 'answer': prediction,\\n 'server_timestamp': time()})\",\n \"def run_inference(wanted_words, sample_rate, clip_duration_ms,\\n window_size_ms, window_stride_ms, dct_coefficient_count,\\n model_architecture, model_size_info, use_mfcc,\\n csv_writer):\\n \\n tf.logging.set_verbosity(tf.logging.INFO)\\n sess = tf.InteractiveSession()\\n words_list = input_data.prepare_words_list(wanted_words.split(','))\\n model_settings = models.prepare_model_settings(\\n len(words_list), sample_rate, clip_duration_ms, window_size_ms,\\n window_stride_ms, dct_coefficient_count, use_mfcc)\\n\\n # audio_processor = input_data.AudioProcessor(\\n audio_processor = AudioProcessor(\\n FLAGS.data_url, FLAGS.data_dir, FLAGS.silence_percentage,\\n FLAGS.unknown_percentage,\\n FLAGS.wanted_words.split(','), FLAGS.validation_percentage,\\n FLAGS.testing_percentage, model_settings)\\n \\n label_count = model_settings['label_count']\\n fingerprint_size = model_settings['fingerprint_size']\\n\\n fingerprint_input = tf.placeholder(\\n tf.float32, [None, fingerprint_size], name='fingerprint_input')\\n\\n logits = models.create_model(\\n fingerprint_input,\\n model_settings,\\n FLAGS.model_architecture,\\n FLAGS.model_size_info,\\n is_training=False)\\n\\n # ground_truth_input = tf.placeholder(\\n # tf.float32, [None, label_count], name='groundtruth_input')\\n\\n predicted_indices = tf.argmax(logits, 1)\\n # expected_indices = tf.argmax(ground_truth_input, 1)\\n # correct_prediction = tf.equal(predicted_indices, expected_indices)\\n # confusion_matrix = tf.confusion_matrix(\\n # expected_indices, predicted_indices, num_classes=label_count)\\n # evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\\n models.load_variables_from_checkpoint(sess, FLAGS.checkpoint)\\n\\n # # training set\\n # set_size = audio_processor.set_size('training')\\n # tf.logging.info('set_size=%d', set_size)\\n # total_accuracy = 0\\n # total_conf_matrix = None\\n # for i in xrange(0, set_size, FLAGS.batch_size):\\n # training_fingerprints, training_ground_truth = (\\n # audio_processor.get_data(FLAGS.batch_size, i, model_settings, 0.0,\\n # 0.0, 0, 'training', sess))\\n # training_accuracy, conf_matrix = sess.run(\\n # [evaluation_step, confusion_matrix],\\n # feed_dict={\\n # fingerprint_input: training_fingerprints,\\n # ground_truth_input: training_ground_truth,\\n # })\\n # batch_size = min(FLAGS.batch_size, set_size - i)\\n # total_accuracy += (training_accuracy * batch_size) / set_size\\n # if total_conf_matrix is None:\\n # total_conf_matrix = conf_matrix\\n # else:\\n # total_conf_matrix += conf_matrix\\n # tf.logging.info('Confusion Matrix:\\\\n %s' % (total_conf_matrix))\\n # tf.logging.info('Training accuracy = %.2f%% (N=%d)' %\\n # (total_accuracy * 100, set_size))\\n #\\n #\\n # # validation set\\n # set_size = audio_processor.set_size('validation')\\n # tf.logging.info('set_size=%d', set_size)\\n # total_accuracy = 0\\n # total_conf_matrix = None\\n # for i in xrange(0, set_size, FLAGS.batch_size):\\n # validation_fingerprints, validation_ground_truth = (\\n # audio_processor.get_data(FLAGS.batch_size, i, model_settings, 0.0,\\n # 0.0, 0, 'validation', sess))\\n # validation_accuracy, conf_matrix = sess.run(\\n # [evaluation_step, confusion_matrix],\\n # feed_dict={\\n # fingerprint_input: validation_fingerprints,\\n # ground_truth_input: validation_ground_truth,\\n # })\\n # batch_size = min(FLAGS.batch_size, set_size - i)\\n # total_accuracy += (validation_accuracy * batch_size) / set_size\\n # if total_conf_matrix is None:\\n # total_conf_matrix = conf_matrix\\n # else:\\n # total_conf_matrix += conf_matrix\\n # tf.logging.info('Confusion Matrix:\\\\n %s' % (total_conf_matrix))\\n # tf.logging.info('Validation accuracy = %.2f%% (N=%d)' %\\n # (total_accuracy * 100, set_size))\\n \\n # test set\\n set_size = audio_processor.set_size('testing')\\n tf.logging.info('set_size=%d', set_size)\\n # total_accuracy = 0\\n # total_conf_matrix = None\\n expected_classes = []\\n for i in xrange(0, set_size, FLAGS.batch_size):\\n # test_fingerprints, test_ground_truth = audio_processor.get_data(\\n # FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'testing', sess)\\n # test_accuracy, conf_matrix = sess.run(\\n # [evaluation_step, confusion_matrix],\\n # feed_dict={\\n # fingerprint_input: test_fingerprints,\\n # ground_truth_input: test_ground_truth,\\n # })\\n test_fingerprints, test_fnames = audio_processor.get_data(\\n FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'testing', sess)\\n expected_classes = sess.run(\\n predicted_indices,\\n feed_dict={\\n fingerprint_input: test_fingerprints,\\n })\\n # batch_size = min(FLAGS.batch_size, set_size - i)\\n # print (\\\"i, len(expeceted_classes), len(test_fnames)=\\\", i, len(expected_classes), len(test_fnames))\\n for j in range(min(FLAGS.batch_size, set_size - i)):\\n csv_writer.writerow([test_fnames[j], class_labels[expected_classes[j]]])\\n # total_accuracy += (test_accuracy * batch_size) / set_size\\n # if total_conf_matrix is None:\\n # total_conf_matrix = conf_matrix\\n # else:\\n # total_conf_matrix += conf_matrix\\n # tf.logging.info('Confusion Matrix:\\\\n %s' % (total_conf_matrix))\\n # tf.logging.info('Test accuracy = %.2f%% (N=%d)' % (total_accuracy * 100,\\n # set_size))\",\n \"def main():\\n \\n \\n # Grab command line args\\n args = build_argparser().parse_args()\\n # Connect to the MQTT server\\n client = connect_mqtt()\\n # Perform inference on the input stream\\n infer_on_stream(args, client)\",\n \"def post_work(self, frames_rec: int, frames_proc: int, nooo: int):\\r\\n raise NotImplementedError\",\n \"def postprocess(run_results, postprocess_func):\\n G_LOGGER.start(f\\\"Applying post-processing to outputs: {postprocess_func.__name__}\\\")\\n for _, iteration_results in run_results:\\n for index, iter_res in enumerate(iteration_results):\\n iteration_results[index] = postprocess_func(iter_res)\\n G_LOGGER.finish(\\\"Finished applying post-processing\\\")\\n return run_results\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n False, # No random scale.\\n False, # No random mirror.\\n args.ignore_label,\\n IMG_MEAN,\\n coord)\\n image, label = reader.image, reader.label\\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n \\n # Predictions.\\n raw_output = net.layers['fc_out']\\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\\n raw_output = tf.argmax(raw_output, dimension=3)\\n pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\\n\\n # mIoU\\n\\n pred_flatten = tf.reshape(pred, [-1,])\\n gt = tf.reshape(label_batch, [-1,])\\n weights = tf.cast(tf.less_equal(gt, args.num_classes - 1), tf.int32) # Ignoring all labels greater than or equal to n_classes.\\n mIoU, update_op = tf.contrib.metrics.streaming_mean_iou(predictions=pred_flatten, labels=gt, num_classes=args.num_classes, weights=weights)\\n \\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True \\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n\\n ckpt = tf.train.get_checkpoint_state(SNAPSHOT_DIR)\\n\\n if ckpt and ckpt.model_checkpoint_path:\\n loader = tf.train.Saver(var_list=restore_var)\\n load_step = int(os.path.basename(ckpt.model_checkpoint_path).split('-')[1])\\n load(loader, sess, ckpt.model_checkpoint_path)\\n else:\\n print('No checkpoint file found.')\\n load_step = 0\\n\\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n\\n if not os.path.exists(SAVE_DIR):\\n os.makedirs(SAVE_DIR)\\n\\n for step in range(args.num_steps):\\n preds, _ = sess.run([pred, update_op])\\n\\n if IS_SAVE == True:\\n msk = decode_labels(preds, num_classes=args.num_classes)\\n im = Image.fromarray(msk[0])\\n filename = 'mask' + str(step) + '.png'\\n im.save(SAVE_DIR + filename)\\n\\n if step % 10 == 0:\\n print('step {0} mIoU: {1}'.format(step, mIoU.eval(session=sess)))\\n\\n coord.request_stop()\\n coord.join(threads)\",\n \"def process(self, sess):\\n global send_counter\\n \\n #sess.run(self.sync) # copy weights from shared to local\\n rollout = self.pull_batch_from_queue()\\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\\n\\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\\n\\n if should_compute_summary:\\n fetches = [self.summary_op, self.train_op]\\n else:\\n fetches = [self.train_op]\\n\\n\\n feed_dict = {\\n self.local_network.x: batch.si,\\n self.ac: batch.a,\\n self.adv: batch.adv,\\n self.r: batch.r,\\n self.local_network.state_in[0]: batch.features[0],\\n self.local_network.state_in[1]: batch.features[1],\\n }\\n\\n # Get current trainable variables\\n # This is trainable variables\\n fetched = sess.run(fetches, feed_dict=feed_dict)\\n\\n\\n if self.num_workers > 1:\\n sys.stdout.write('\\\\r' + str(self.local_steps))\\n if self.local_steps % 100 == 0:\\n global var0\\n global var1\\n var1 = sess.run(self.local_network.var_list) # After training\\n if var0 != None:\\n var_diff = [a - b for (a,b) in zip(var1, var0)]\\n var_diff_data = pickle.dumps(var_diff, -1)\\n print('Sync weights')\\n self.msg_sent = socket_util.socket_send_data_chucks(self.sock, var_diff_data, self.mcast_destination, self.msg_sent)\\n var0 = sess.run(self.local_network.var_list) # A list of numpy array\\n\\n # Handle each message in the socket queue\\n while not self.inc_msg_q.empty():\\n print('Apply remote gradients')\\n # Process received grads_and_vars from other peers\\n remote_var_diff_data = self.inc_msg_q.get(False)\\n remote_var_diff = pickle.loads(remote_var_diff_data)\\n\\n add_op = [a+b for (a,b) in zip(self.local_network.var_list, remote_var_diff)]\\n sess.run(add_op)\\n\\n if should_compute_summary:\\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]))\\n self.summary_writer.flush()\\n self.local_steps += 1\",\n \"def handle_predictions(predict_fn, request_queue, response_queue):\\n loop_times = []\\n queue_get_times = []\\n handle_times = []\\n handle_start_times = []\\n # trial_start = datetime.now()\\n pred_count = 0\\n loop_count = 0\\n\\n # last_loop_start = datetime.now()\\n # loop_dur_file = \\\"/logs/loop_duration.log\\\"\\n # handle_dur_file = \\\"/logs/handle_duration.log\\\"\\n # handle_dur_file = \\\"/logs/handle_duration.log\\\"\\n\\n # Field order: clock_time, user time, sys time\\n # kernel_measures = False\\n # if not os.path.exists(\\\"/logs\\\"):\\n # os.makedirs(\\\"/logs\\\")\\n #\\n # kernel_instr_file = \\\"/logs/kernel_measures.csv\\\"\\n\\n # with open(loop_dur_file, \\\"w\\\") as ld, open(handle_dur_file, \\\"w\\\") as hd:\\n\\n # with open(kernel_instr_file, \\\"w\\\") as kd:\\n # kd.write(\\\"wall_clock_secs, user_clock_ticks, kernel_clock_ticks\\\\n\\\")\\n while True:\\n # cur_loop_start = datetime.now()\\n # loop_duration = (cur_loop_start - last_loop_start).microseconds\\n # loop_times.append(loop_duration)\\n # ld.write(\\\"{}\\\\n\\\".format(loop_duration))\\n # last_loop_start = cur_loop_start\\n\\n # t1 = datetime.now()\\n prediction_request, recv_time = request_queue.get(block=True)\\n # t2 = datetime.now()\\n # queue_get_times.append((t2 - t1).microseconds)\\n\\n # handle_start_times.append(time.time()*1000)\\n before_predict_lineage_point = datetime.now()\\n # proc_stat_before = check_output([\\\"cat\\\", \\\"/proc/1/stat\\\"]).strip().split()\\n # user_before = int(proc_stat_before[13])\\n # sys_before = int(proc_stat_before[14])\\n\\n\\n outputs = predict_fn(prediction_request.inputs)\\n # proc_stat_after = check_output([\\\"cat\\\", \\\"/proc/1/stat\\\"]).strip().split()\\n # user_after = int(proc_stat_after[13])\\n # sys_after = int(proc_stat_after[14])\\n\\n after_predict_lineage_point = datetime.now()\\n # clock_time = (after_predict_lineage_point - before_predict_lineage_point).total_seconds()\\n # user_time = user_after - user_before\\n # sys_time = sys_after - sys_before\\n # user_time = 0\\n # sys_time = 0\\n # kd.write(\\\"{clock},{user},{kernel}\\\\n\\\".format(clock=clock_time, user=user_time, kernel=sys_time))\\n\\n if loop_count <= 50 and loop_count % 10 == 0:\\n print((after_predict_lineage_point - before_predict_lineage_point).total_seconds())\\n\\n pred_count += len(prediction_request.inputs)\\n # t3 = datetime.now()\\n # handle_times.append((t3 - t2).microseconds)\\n # hd.write(\\\"{}\\\\n\\\".format((t3 - t2).microseconds))\\n # Type check the outputs:\\n if not type(outputs) == list:\\n raise PredictionError(\\\"Model did not return a list\\\")\\n if len(outputs) != len(prediction_request.inputs):\\n raise PredictionError(\\n \\\"Expected model to return %d outputs, found %d outputs\\\" %\\n (len(prediction_request.inputs), len(outputs)))\\n\\n outputs_type = type(outputs[0])\\n if outputs_type == np.ndarray:\\n outputs_type = outputs[0].dtype\\n if outputs_type not in SUPPORTED_OUTPUT_TYPES_MAPPING.keys():\\n raise PredictionError(\\n \\\"Model outputs list contains outputs of invalid type: {}!\\\".\\n format(outputs_type))\\n\\n if outputs_type == str:\\n for i in range(0, len(outputs)):\\n outputs[i] = unicode(outputs[i], \\\"utf-8\\\").encode(\\\"utf-8\\\")\\n else:\\n for i in range(0, len(outputs)):\\n outputs[i] = outputs[i].tobytes()\\n\\n total_length_elements = sum(len(o) for o in outputs)\\n\\n response = PredictionResponse(prediction_request.msg_id,\\n len(outputs), total_length_elements,\\n outputs_type)\\n for output in outputs:\\n response.add_output(output)\\n\\n response_queue.put((response, recv_time,\\n before_predict_lineage_point,\\n after_predict_lineage_point))\\n # response_queue.put((response, recv_time,\\n # None,\\n # None))\\n\\n # if len(loop_times) > 1000:\\n # print(\\\"\\\\nLoop duration: {} +- {}\\\".format(np.mean(loop_times), np.std(loop_times)))\\n # print(\\\"Request dequeue duration: {} +- {}\\\".format(np.mean(queue_get_times), np.std(queue_get_times)))\\n # print(\\\"Handle duration: {} +- {}\\\".format(np.mean(handle_times), np.std(handle_times)))\\n # # throughput = float(pred_count) / (datetime.now() - trial_start).total_seconds()\\n # # print(\\\"Throughput: {}\\\".format(throughput))\\n # # ld.flush()\\n # # hd.flush()\\n # # kd.flush()\\n #\\n # loop_times = []\\n # queue_get_times = []\\n # handle_times = []\\n # pred_count = 0\\n # trial_start = datetime.now()\\n\\n # if len(handle_start_times) % 200 == 0:\\n # print(json.dumps(handle_start_times))\\n loop_count += 1\\n sys.stdout.flush()\\n sys.stderr.flush()\",\n \"def run():\\n if am_i_root():\\n\\n print(\\\"*** initializing...\\\")\\n\\n # Print parameters\\n print(\\\"N_DIMS = \\\" + str(N_DIMS))\\n print(\\\"LAMBDA_OVER_DX = \\\" + str(LAMBDA_OVER_DX))\\n print(\\\"R_DT = \\\" + str(R_DT))\\n print(\\\"MU0_POISSON = \\\" + str(MU0_POISSON))\\n print(\\\"NORM_POISSON = \\\" + NORM_POISSON)\\n print(\\\"N_GRID = \\\" + str(N_GRID))\\n print(\\\"N_HITS = \\\" + str(N_HITS))\\n print(\\\"POLICY = \\\" + str(POLICY))\\n if POLICY == -1:\\n print(\\\"MODEL_PATH = \\\" + str(MODEL_PATH))\\n else:\\n print(\\\"STEPS_AHEAD = \\\" + str(STEPS_AHEAD))\\n print(\\\"EPSILON = \\\" + str(EPSILON))\\n print(\\\"STOP_t = \\\" + str(STOP_t))\\n print(\\\"STOP_p = \\\" + str(STOP_p))\\n print(\\\"N_PARALLEL = \\\" + str(N_PARALLEL))\\n print(\\\"WITH_MPI = \\\" + str(WITH_MPI))\\n print(\\\"ADAPTIVE_N_RUNS = \\\" + str(ADAPTIVE_N_RUNS))\\n print(\\\"REL_TOL = \\\" + str(REL_TOL))\\n print(\\\"MAX_N_RUNS = \\\" + str(MAX_N_RUNS))\\n print(\\\"N_RUNS(input) = \\\" + str(N_RUNS))\\n sys.stdout.flush()\\n\\n # Perform runs\\n if am_i_root():\\n print(\\\"*** generating episodes...\\\")\\n\\n N_runs = N_RUNS\\n if ADAPTIVE_N_RUNS or WITH_MPI:\\n N_runs = int(N_PARALLEL * (np.ceil(N_runs / N_PARALLEL))) # make it multiple of N_PARALLEL\\n if am_i_root():\\n print(\\\"N_RUNS(current) = \\\" + str(N_runs))\\n sys.stdout.flush()\\n\\n N_runso = 0\\n\\n if WITH_MPI:\\n cdf_t_tot_loc = np.zeros(LEN_CDF_T, dtype=float)\\n cdf_h_tot_loc = np.zeros(LEN_CDF_H, dtype=float)\\n mean_t_loc = np.nan * np.ones(MAX_N_RUNS // N_PARALLEL, dtype=float)\\n failed_loc = - np.ones(MAX_N_RUNS // N_PARALLEL, dtype=float)\\n else:\\n cdf_t_tot = np.zeros(LEN_CDF_T, dtype=float)\\n cdf_h_tot = np.zeros(LEN_CDF_H, dtype=float)\\n mean_t_episodes = np.nan * np.ones(MAX_N_RUNS, dtype=float)\\n failed_episodes = - np.ones(MAX_N_RUNS, dtype=float)\\n\\n while True:\\n if WITH_MPI: # MPI\\n if N_runs % N_PARALLEL != 0:\\n raise Exception(\\\"N_runs must be multiple of N_PARALLEL with MPI\\\")\\n COMM.Barrier()\\n # Decomposition\\n Nepisodes = N_runs // N_PARALLEL\\n episode_list = range(N_runso + ME, N_runs, N_PARALLEL)\\n # Run episodes and reduce locally\\n ind = N_runso // N_PARALLEL\\n for episode in episode_list:\\n cdf_t, cdf_h, mean_t_loc[ind], failed_loc[ind] = Worker(episode)\\n cdf_t_tot_loc += cdf_t\\n cdf_h_tot_loc += cdf_h\\n ind += 1\\n\\n # Reduce globally the mean_t and failed\\n mean_t_episodes = np.empty([N_runs], dtype=float)\\n failed_episodes = np.empty([N_runs], dtype=float)\\n COMM.Barrier()\\n COMM.Allgather([mean_t_loc[:ind], Nepisodes, MPI.DOUBLE], [mean_t_episodes, Nepisodes, MPI.DOUBLE])\\n COMM.Allgather([failed_loc[:ind], Nepisodes, MPI.DOUBLE], [failed_episodes, Nepisodes, MPI.DOUBLE])\\n COMM.Barrier()\\n elif N_PARALLEL > 1: # multiprocessing\\n # Run episodes in parallel\\n pool = multiprocessing.Pool(N_PARALLEL)\\n result = pool.map(Worker, range(N_runso, N_runs))\\n pool.close()\\n pool.join()\\n # Reduce\\n ind = N_runso\\n for cdf_t, cdf_h, mean_t, failed in result:\\n cdf_t_tot += cdf_t\\n cdf_h_tot += cdf_h\\n mean_t_episodes[ind] = mean_t\\n failed_episodes[ind] = failed\\n ind += 1\\n elif N_PARALLEL == 1: # sequential\\n ind = N_runso\\n for episode in range(N_runso, N_runs):\\n cdf_t, cdf_h, mean_t, failed = Worker(episode)\\n cdf_t_tot += cdf_t\\n cdf_h_tot += cdf_h\\n mean_t_episodes[ind] = mean_t\\n failed_episodes[ind] = failed\\n ind += 1\\n else:\\n raise Exception(\\\"Problem with N_PARALLEL: must be an int >= 1\\\")\\n\\n # estimate of the error\\n mean_ep = np.mean(mean_t_episodes[:N_runs])\\n sigma_ep = np.std(mean_t_episodes[:N_runs])\\n std_error_mean = sigma_ep / np.sqrt(N_runs)\\n rel_std_error_mean = std_error_mean / mean_ep\\n\\n # break clause\\n if not ADAPTIVE_N_RUNS:\\n break\\n else:\\n if rel_std_error_mean < REL_TOL:\\n break\\n elif N_runs >= MAX_N_RUNS:\\n break\\n else:\\n N_runso = N_runs\\n N_runs = int(np.ceil(1.05 * (sigma_ep / mean_ep / REL_TOL) ** 2))\\n N_runs = min(N_runs, MAX_N_RUNS)\\n N_runs = int(N_PARALLEL * (np.ceil(N_runs / N_PARALLEL))) # make it multiple of N_PARALLEL\\n if am_i_root():\\n print(\\\"N_RUNS(current) = \\\" + str(N_runs))\\n sys.stdout.flush()\\n\\n if am_i_root():\\n print(\\\"N_RUNS(performed) = \\\" + str(N_runs))\\n sys.stdout.flush()\\n\\n # Reduce\\n if am_i_root():\\n print(\\\"*** post-processing...\\\")\\n if WITH_MPI:\\n # locally\\n cdf_t_tot_loc /= N_runs\\n cdf_h_tot_loc /= N_runs\\n # Reduce globally\\n cdf_t_tot = np.empty([LEN_CDF_T], dtype=float)\\n cdf_h_tot = np.empty([LEN_CDF_H], dtype=float)\\n COMM.Barrier()\\n COMM.Allreduce(cdf_t_tot_loc, cdf_t_tot, op=MPI.SUM)\\n COMM.Allreduce(cdf_h_tot_loc, cdf_h_tot, op=MPI.SUM)\\n COMM.Barrier()\\n else:\\n cdf_t_tot /= N_runs\\n cdf_h_tot /= N_runs\\n mean_t_episodes = mean_t_episodes[:N_runs]\\n failed_episodes = failed_episodes[:N_runs]\\n\\n # Further post-processing, save and plot\\n if am_i_root():\\n\\n # from cdf to pdf\\n pdf_t_tot = cdf_to_pdf(cdf_t_tot)\\n pdf_h_tot = cdf_to_pdf(cdf_h_tot)\\n\\n # compute stats of number of steps and number of hits\\n t_bins = np.arange(BIN_START_T, BIN_END_T, BIN_SIZE_T) + 0.5 * BIN_SIZE_T\\n mean_t, sigma_t, skew_t, kurt_t, p_found = stats_from_pdf(t_bins, pdf_t_tot)\\n p25_t, p50_t, p75_t, p90_t, p95_t, p99_t, _ = stats_from_cdf(t_bins, cdf_t_tot)\\n\\n h_bins = np.arange(BIN_START_H, BIN_END_H, BIN_SIZE_H) + 0.5 * BIN_SIZE_H\\n mean_h, sigma_h, skew_h, kurt_h, _ = stats_from_pdf(h_bins, pdf_h_tot)\\n p25_h, p50_h, p75_h, p90_h, p95_h, p99_h, _ = stats_from_cdf(h_bins, cdf_h_tot)\\n\\n print(\\\"probability that the source is never found : %.10f\\\" % (1.0 - p_found, ))\\n print(\\\"mean number of steps to find the source : %.3f +/- %.3f\\\" % (mean_t, 1.96 * std_error_mean))\\n print(\\\"number of steps to find the source with 50 %% probability: %.3f\\\" % p50_t)\\n print(\\\"number of steps to find the source with 99 %% probability: %.3f\\\" % p99_t)\\n nb_failed = np.sum(failed_episodes)\\n if np.any(failed_episodes < 0):\\n nb_failed = -1\\n print(\\\"problem while recording failures\\\")\\n else:\\n print(\\\"number of failed episodes : %d / %d (%f %%)\\\"\\n % (nb_failed, N_runs, nb_failed / N_runs * 100))\\n sys.stdout.flush()\\n\\n # save all parameters to txt file\\n inputs = {\\n \\\"N_DIMS\\\": N_DIMS,\\n \\\"LAMBDA_OVER_DX\\\": LAMBDA_OVER_DX,\\n \\\"R_DT\\\": R_DT,\\n \\\"MU0_POISSON\\\": MU0_POISSON,\\n \\\"NORM_POISSON\\\": NORM_POISSON,\\n \\\"N_GRID\\\": N_GRID,\\n \\\"N_HITS\\\": N_HITS,\\n \\\"POLICY\\\": POLICY,\\n \\\"STEPS_AHEAD\\\": STEPS_AHEAD,\\n \\\"MODEL_PATH\\\": MODEL_PATH,\\n \\\"STOP_t\\\": STOP_t,\\n \\\"STOP_p\\\": STOP_p,\\n \\\"ADAPTIVE_N_RUNS\\\": ADAPTIVE_N_RUNS,\\n \\\"REL_TOL\\\": REL_TOL,\\n \\\"MAX_N_RUNS\\\": MAX_N_RUNS,\\n \\\"N_RUNS_PERFORMED\\\": N_runs,\\n \\\"BIN_START_T\\\": BIN_START_T,\\n \\\"BIN_END_T\\\": BIN_END_T,\\n \\\"BIN_SIZE_T\\\": BIN_SIZE_T,\\n \\\"BIN_START_H\\\": BIN_START_H,\\n \\\"BIN_END_H\\\": BIN_END_H,\\n \\\"BIN_SIZE_H\\\": BIN_SIZE_H,\\n \\\"EPSILON\\\": EPSILON,\\n }\\n param_txt_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_parameters\\\" + \\\".txt\\\"))\\n with open(param_txt_file, 'w') as out:\\n for key, val in inputs.items():\\n print(key + \\\" = \\\" + str(val), file=out)\\n\\n # save stats\\n stats_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_statistics\\\" + \\\".txt\\\"))\\n with open(stats_file, \\\"w\\\") as sfile:\\n sfile.write(\\\"p_not_found\\\\t%+.4e\\\\n\\\" % (1 - p_found,))\\n for varname in \\\\\\n ('mean_t', 'sigma_t', 'skew_t', 'kurt_t', 'p25_t', 'p50_t', 'p75_t', 'p90_t', 'p95_t', 'p99_t'):\\n sfile.write(\\\"%s\\\\t\\\\t%+.4e\\\\n\\\" % (varname, locals()[varname]))\\n for varname in \\\\\\n ('mean_h', 'sigma_h', 'skew_h', 'kurt_h', 'p25_h', 'p50_h', 'p75_h', 'p90_h', 'p95_h', 'p99_h'):\\n sfile.write(\\\"%s\\\\t\\\\t%+.4e\\\\n\\\" % (varname, locals()[varname]))\\n\\n # save CDF of number of steps\\n table_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_table_CDF_nsteps\\\" + \\\".npy\\\"))\\n np.save(table_file, np.vstack((t_bins, cdf_t_tot)))\\n\\n # save CDF of number of hits\\n table_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_table_CDF_nhits\\\" + \\\".npy\\\"))\\n np.save(table_file, np.vstack((h_bins, cdf_h_tot)))\\n\\n # create and save figures\\n if POLICY == -1:\\n specifics = \\\"MODEL = \\\" + os.path.basename(MODEL_PATH)\\n else:\\n specifics = \\\"STEPS_AHEAD = \\\" + str(STEPS_AHEAD)\\n subtitle = (\\n \\\"N_DIMS = \\\"\\n + str(N_DIMS)\\n + \\\", \\\"\\n + \\\"LAMBDA_OVER_DX = \\\"\\n + str(LAMBDA_OVER_DX)\\n + \\\", \\\"\\n + \\\"R_DT = \\\"\\n + str(R_DT)\\n + \\\", \\\"\\n + \\\"POLICY = \\\"\\n + str(POLICY)\\n + \\\", \\\"\\n + specifics\\n + \\\", \\\"\\n + \\\"N_GRID = \\\"\\n + str(N_GRID)\\n + \\\", \\\"\\n + \\\"N_HITS = \\\"\\n + str(N_HITS)\\n + \\\", \\\"\\n + \\\"N_RUNS = \\\"\\n + str(N_runs)\\n + \\\"\\\\n\\\"\\n )\\n\\n # plot PDF(nsteps), CDF(nsteps), PDF(nhits), CDF(nhits)\\n fig, ax = plt.subplots(2, 2, figsize=(12, 10))\\n plt.subplots_adjust(left=0.08, bottom=0.06, right=0.96, top=0.92, hspace=0.35, wspace=0.30)\\n kwargs = {'xycoords': 'axes fraction', 'fontsize': 8, 'ha': \\\"right\\\"}\\n for row, varname in enumerate([\\\"number of steps\\\", \\\"number of hits\\\"]):\\n if varname == \\\"number of steps\\\":\\n bins = t_bins\\n cdf_tot = cdf_t_tot\\n pdf_tot = pdf_t_tot\\n mean = mean_t\\n sigma = sigma_t\\n skew = skew_t\\n kurt = kurt_t\\n p50 = p50_t\\n p75 = p75_t\\n p90 = p90_t\\n p99 = p99_t\\n filesuffix = 'nsteps'\\n color = \\\"tab:blue\\\"\\n else:\\n bins = h_bins\\n cdf_tot = cdf_h_tot\\n pdf_tot = pdf_h_tot\\n mean = mean_h\\n sigma = sigma_h\\n skew = skew_h\\n kurt = kurt_h\\n p50 = p50_h\\n p75 = p75_h\\n p90 = p90_h\\n p99 = p99_h\\n filesuffix = 'nhits'\\n color = \\\"tab:orange\\\"\\n max_x = bins[np.nonzero(pdf_tot)[0][-1]]\\n for col, fct in enumerate([\\\"PDF\\\", \\\"CDF\\\"]):\\n if fct == \\\"PDF\\\":\\n ydata = pdf_tot\\n ylim = (0.0, 1.02 * np.max(pdf_tot))\\n elif fct == \\\"CDF\\\":\\n ydata = cdf_tot\\n ylim = (0.0, 1.0)\\n\\n ax[row, col].plot(bins, ydata, \\\"-o\\\", color=color, markersize=2, linewidth=1)\\n ax[row, col].set_title(fct + \\\" of \\\" + varname)\\n ax[row, col].set_xlabel(varname + \\\" to find the source\\\")\\n ax[row, col].set_xlim((0, max_x))\\n ax[row, col].set_ylim(ylim)\\n\\n if fct == \\\"PDF\\\":\\n ax[row, col].annotate(\\\"p_not_found = \\\" + \\\"{:.3e}\\\".format(1.0 - p_found), xy=(0.98, 0.60), **kwargs)\\n ax[row, col].annotate(\\\"mean = \\\" + \\\"{:.3e}\\\".format(mean), xy=(0.98, 0.56), **kwargs)\\n ax[row, col].annotate(\\\"std = \\\" + \\\"{:.3e}\\\".format(sigma), xy=(0.98, 0.52), **kwargs)\\n ax[row, col].annotate(\\\"skew = \\\" + \\\"{:.3e}\\\".format(skew), xy=(0.98, 0.48), **kwargs)\\n ax[row, col].annotate(\\\"ex. kurt = \\\" + \\\"{:.3e}\\\".format(kurt), xy=(0.98, 0.44), **kwargs)\\n elif fct == \\\"CDF\\\":\\n ax[row, col].annotate(\\\"p_not_found = \\\" + \\\"{:.3e}\\\".format(1.0 - p_found), xy=(0.98, 0.60), **kwargs)\\n ax[row, col].annotate(\\\"P50 = \\\" + \\\"{:.3e}\\\".format(p50), xy=(0.98, 0.56), **kwargs)\\n ax[row, col].annotate(\\\"P75 = \\\" + \\\"{:.3e}\\\".format(p75), xy=(0.98, 0.52), **kwargs)\\n ax[row, col].annotate(\\\"P90 = \\\" + \\\"{:.3e}\\\".format(p90), xy=(0.98, 0.48), **kwargs)\\n ax[row, col].annotate(\\\"P99 = \\\" + \\\"{:.3e}\\\".format(p99), xy=(0.98, 0.44), **kwargs)\\n plt.grid(False)\\n plt.figtext(0.5, 0.985, subtitle, fontsize=7, ha=\\\"center\\\", va=\\\"top\\\")\\n plt.draw()\\n figure_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_figure_distributions.pdf\\\"))\\n fig.savefig(figure_file)\\n plt.close(fig)\\n\\n # plot mean nb steps vs number of episodes\\n number_episodes = range(1, N_runs + 1)\\n cum_mean_t_episodes = np.cumsum(mean_t_episodes) / number_episodes\\n if N_runs >= 100:\\n number_episodes = number_episodes[20:]\\n cum_mean_t_episodes = cum_mean_t_episodes[20:]\\n fig, ax = plt.subplots()\\n ax.plot(number_episodes, cum_mean_t_episodes, color=\\\"r\\\")\\n ax.set_title(\\\"Convergence of the mean number of steps\\\")\\n ax.set_xlabel(\\\"number of episodes\\\")\\n ax.set_ylabel(\\\"mean number of steps\\\")\\n plt.figtext(0.5, 0.985, subtitle, fontsize=5, ha=\\\"center\\\", va=\\\"top\\\")\\n plt.grid(False)\\n plt.draw()\\n figure_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_figure_convergence.pdf\\\"))\\n fig.savefig(figure_file)\\n plt.close(fig)\\n\\n # save monitoring information (concatenate episodes files)\\n monitoring_episodes_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_monitoring_episodes.txt\\\"))\\n filenames = [os.path.join(DIR_TMP, str(\\\"monitoring_episode_\\\" + str(episode) + \\\".txt\\\")) for episode in range(N_runs)]\\n with open(monitoring_episodes_file, \\\"w\\\") as mfile:\\n mfile.write(\\\"# episode\\\\thit_init\\\\tstop_flag\\\\tboundary_flag\\\\t\\\"\\n \\\"p_not_found\\\\t\\\\tmean_nsteps\\\\t\\\\ttime_elapsed(sec)\\\\n\\\")\\n for fname in filenames:\\n if os.path.isfile(fname):\\n with open(fname) as infile:\\n mfile.write(infile.read())\\n os.remove(fname)\\n else:\\n print(\\\"Unexpected: Missing episode file: \\\" + str(fname))\\n\\n # clean up tmp dirs\\n if len(os.listdir(DIR_TMP)) != 0:\\n print(\\\"Unexpected: The directory '\\\" + DIR_TMP\\n + \\\"' is not removed, because it should be empty but is not.\\\")\\n else:\\n os.rmdir(DIR_TMP)\\n if len(os.listdir(PARENT_DIR_TMP)) == 0:\\n os.rmdir(PARENT_DIR_TMP)\\n\\n # summary\\n monitoring_file = os.path.join(DIR_OUTPUTS, str(RUN_NAME + \\\"_monitoring_summary\\\" + \\\".txt\\\"))\\n with open(monitoring_file, \\\"w\\\") as mfile:\\n mfile.write(\\\"*** initial hit ***\\\\n\\\")\\n first_hit = np.loadtxt(monitoring_episodes_file, usecols=1, dtype='int')\\n hit_max = np.max(first_hit)\\n hit_hist, _ = np.histogram(first_hit, bins=np.arange(0.5, hit_max + 1.5), density=True)\\n for h in range(1, hit_max + 1):\\n mfile.write(\\\"hit=%1d: %6.2f %% \\\\n\\\" % (h, hit_hist[h - 1] * 100))\\n\\n mfile.write(\\\"\\\\n*** stats convergence ***\\\\n\\\")\\n mfile.write(\\\"number of episodes simulated : %d\\\\n\\\" % N_runs)\\n mfile.write(\\\"standard error of the mean (estimate): %.4e = %5.2f %%\\\\n\\\"\\n % (std_error_mean, rel_std_error_mean * 100))\\n\\n stopping_reason = np.loadtxt(monitoring_episodes_file, usecols=2, dtype='int')\\n stop_max = np.max(stopping_reason)\\n stopping_hist, _ = np.histogram(stopping_reason, bins=np.arange(0.5, stop_max + 1.5), density=True)\\n mfile.write(\\\"\\\\n*** reason for stopping (1 is success, anything else is failure) ***\\\\n\\\")\\n for stop in range(1, stop_max + 1):\\n mfile.write(\\\"stop=%1d: %6.2f %% \\\\n\\\" % (stop, stopping_hist[stop - 1] * 100))\\n\\n mfile.write(\\\"\\\\n*** probability that the source is not found at the end of the episodes ***\\\\n\\\")\\n p_not_found = np.loadtxt(monitoring_episodes_file, usecols=4)\\n p_gtr_stop = p_not_found[p_not_found > STOP_p]\\n p_not_found_max = np.max(p_not_found)\\n mfile.write(\\\"criteria (STOP_p): %.5e\\\\n\\\" % STOP_p)\\n mfile.write(\\\"max(p) : %.5e\\\\n\\\" % p_not_found_max)\\n mfile.write(\\\"number of episodes where p > STOP_p: %7d (%8.4f %%)\\\\n\\\"\\n % (len(p_gtr_stop), len(p_gtr_stop) / N_runs * 100))\\n\\n near_boundaries = np.loadtxt(monitoring_episodes_file, usecols=3, dtype='int')\\n near_boundaries = np.count_nonzero(near_boundaries)\\n mfile.write(\\\"\\\\n*** agent near boundaries ***\\\\n\\\")\\n mfile.write(\\\"number of episodes where it happened: %7d (%8.4f %%)\\\\n\\\"\\n % (near_boundaries, near_boundaries / N_runs * 100))\\n\\n episode_elapsed = np.loadtxt(monitoring_episodes_file, usecols=5)\\n mfile.write(\\\"\\\\n*** computational cost per episode ***\\\\n\\\")\\n mfile.write(\\\"avg elapsed seconds per episode: %.5e\\\\n\\\" % (np.mean(episode_elapsed)))\\n mfile.write(\\\"max elapsed seconds per episode: %.5e\\\\n\\\" % (np.max(episode_elapsed)))\\n\\n elapsed_time_0 = (time.monotonic() - start_time_0) / 3600.0\\n mfile.write(\\\"\\\\n*** computational cost ***\\\\n\\\")\\n mfile.write(\\\"N_PARALLEL = %d\\\\n\\\" % N_PARALLEL)\\n mfile.write(\\\"total elapsed hours : %.5e\\\\n\\\" % elapsed_time_0)\\n mfile.write(\\\"cost in hours = total elapsed time * N_PARALLEL: %.5e\\\\n\\\" % (elapsed_time_0 * N_PARALLEL))\\n\\n print(\\\">>> Results saved in the directory: \\\" + DIR_OUTPUTS)\\n\\n sys.stdout.flush()\",\n \"def worker_train():\\n py_work = np.zeros(model.layer1_size, dtype=np.float32)\\n\\n while True:\\n job = jobs.get(block=True)\\n if job is None: # data finished, exit\\n jobs.task_done()\\n # print('thread %s break' % threading.current_thread().name)\\n break\\n\\n #lr = max(self.min_lr, self.lr * (1 - 1.0 * node_count[0]/total_node))\\n lr = self.lr \\n job_words = 0\\n for edge in job:\\n if edge is not None:\\n if cluster_negtivate:\\n node_set = set()\\n if model.vocab_t[edge[0].index] not in nodeid2cluster:\\n cls1 = -1\\n else:\\n cls1 = nodeid2cluster[model.vocab_t[edge[0].index]]\\n node_set.add(cls1)\\n if model.vocab_t[edge[1].index] not in nodeid2cluster:\\n cls2 = -1\\n else:\\n cls2 = nodeid2cluster[model.vocab_t[edge[1].index]]\\n node_set.add(cls2)\\n neg_l = []\\n #选择的负样本的node必须是有明确类别归属的\\n for i in range(self.negative):\\n nodeidx = model.table[np.random.randint(model.table_size)]\\n if model.vocab_t[nodeidx] not in nodeid2cluster:\\n i-=1\\n continue\\n else:\\n cls_n = nodeid2cluster[model.vocab_t[nodeidx]]\\n #加入不同边限制 G 里存放的是nodeid，不是idx\\n if cls_n not in node_set and model.vocab_t[nodeidx] not in G[model.vocab_t[edge[0].index]] \\\\\\n and model.vocab_t[nodeidx] not in G[model.vocab_t[edge[1].index]]:\\n neg_l.append(nodeidx)\\n neg_np = np.asarray(neg_l)\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n if weight > 0.0 and len(neg_np) > 0:\\n #job_words += sum(train_o1(model.node_embedding, edge, lr, int(10 * (weight)) * self.negative, neg_np,\\n # py_size=model.layer1_size, py_work=py_work) \\n # for i in range(1))\\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, neg_np,\\n py_size=model.layer1_size, py_work=py_work) \\n for i in range(1))\\n elif len(neg_np) == 0:\\n #job_words += sum(train_o1(model.node_embedding, edge, lr, 0, neg_np,\\n # py_size=model.layer1_size, py_work=py_work) \\n # for i in range(1))\\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, 0, neg_np,\\n py_size=model.layer1_size, py_work=py_work) \\n for i in range(1))\\n else:\\n weight = G[model.vocab_t[edge[0].index]][model.vocab_t[edge[1].index]]['weight']\\n if weight >= 0.1:\\n #job_words += sum(train_o1(model.node_embedding, edge, lr, int(10 * (weight)) * self.negative, model.table,\\n # py_size=model.layer1_size, py_work=py_work) \\n # for i in range(1))\\n job_words += sum(train_o1(model.node_embedding, edge, weight, lr, self.negative, model.table,\\n py_size=model.layer1_size, py_work=py_work) \\n for i in range(1))\\n #for i in range(int(10 * weight)))\\n #job_words = sum(train_o1(model.node_embedding, edge, lr, self.negative, model.table,\\n # py_size=model.layer1_size, py_work=py_work) for edge in job if edge is not None)\\n jobs.task_done()\\n lock.acquire(timeout=30)\\n try:\\n node_count[0] += job_words\\n\\n elapsed = time.time() - start\\n if elapsed >= next_report[0]:\\n log.info(\\\"PROGRESS: at %.2f%% \\\\tnode_computed %d\\\\talpha %.05f\\\\t %.0f nodes/s\\\" %\\n (100.0 * node_count[0] / total_node, node_count[0], lr, node_count[0] / elapsed if elapsed else 0.0))\\n next_report[0] = elapsed + 5.0 # don't flood the log, wait at least a second between progress reports\\n finally:\\n lock.release()\",\n \"def main():\\n #global comm, rank, args\\n #comm = MPI.COMM_WORLD\\n #rank = comm.Get_rank()\\n rank = 0\\n\\n parser = argparse.ArgumentParser(description=\\\"Receive data and dispatch\\\" +\\n \\\"analysis tasks to a mpi queue\\\")\\n parser.add_argument('--config', type=str, help='Lists the configuration file',\\n default='configs/config-middle.json')\\n parser.add_argument(\\\"--transport_rx\\\", help=\\\"Specifies the name of the transport section that is used to configure the reader\\\",\\n default=\\\"transport_rx\\\")\\n parser.add_argument(\\\"--transport_tx\\\", help=\\\"Specifies the name of the transport section that is used to configure the writer\\\",\\n default=\\\"transport_tx\\\")\\n args = parser.parse_args()\\n\\n with open(args.config, \\\"r\\\") as df:\\n cfg = json.load(df)\\n timeout = 120\\n\\n # The middleman uses both a reader and a writer. Each is configured with using\\n # their respective section of the config file. Therefore some keys are duplicated,\\n # such as channel_range. Make sure that these items are the same in both sections\\n\\n with open(\\\"configs/logger.yaml\\\", \\\"r\\\") as f:\\n log_cfg = yaml.safe_load(f.read())\\n logging.config.dictConfig(log_cfg)\\n logger = logging.getLogger('middleman')\\n\\n # Create ADIOS reader object\\n reader = reader_gen(cfg[args.transport_rx], gen_channel_name(cfg[\\\"diagnostic\\\"]))\\n reader.Open()\\n stream_attrs = None\\n stream_varname = gen_var_name(cfg)[rank]\\n logger.info(f\\\"Main: Stream varname: {stream_varname}\\\")\\n\\n dq = queue.Queue()\\n msg = None\\n worker = threading.Thread(target=forward, args=(dq, cfg, args, timeout))\\n worker.start()\\n\\n rx_list = []\\n stream_data = None\\n while True:\\n stepStatus = reader.BeginStep()\\n logger.info(f\\\"Main: stepStatus = {stepStatus}, currentStep = {reader.CurrentStep()}\\\")\\n if stepStatus:\\n # Read data\\n stream_data = reader.Get(stream_varname, save=False)\\n if stream_attrs is None:\\n if reader.InquireAttribute(\\\"stream_attrs\\\"):\\n stream_attrs = reader.get_attrs(\\\"stream_attrs\\\")\\n\\n stream_data = reader.Get(stream_varname, save=False)\\n rx_list.append(reader.CurrentStep())\\n\\n # Generate message id and publish is\\n msg = AdiosMessage(tstep_idx=reader.CurrentStep(), data=stream_data, attrs=stream_attrs)\\n dq.put_nowait(msg)\\n logger.info(f\\\"Main: Published message {msg}\\\")\\n reader.EndStep()\\n else:\\n logger.info(f\\\"Main: Exiting: StepStatus={stepStatus}\\\")\\n break\\n\\n # last_step = reader.CurrentStep()\\n\\n logger.info(\\\"Main: Exiting main loop\\\")\\n worker.join()\\n logger.info(\\\"Main: Workers have joined\\\")\\n dq.join()\\n logger.info(\\\"Main: Queue joined\\\")\\n logger.info(\\\"Main: Finished\\\")\",\n \"def inference(self, g, x):\\n\\n for l, layer in enumerate(self.layers):\\n y = torch.zeros(g.num_nodes(), self.n_hidden if l != len(self.layers) - 1 else self.n_classes)\\n\\n sampler = dgl.dataloading.MultiLayerFullNeighborSampler(1)\\n dataloader = dgl.dataloading.NodeDataLoader(\\n g,\\n torch.arange(g.num_nodes()),\\n sampler,\\n batch_size=args.batch_size,\\n shuffle=True,\\n drop_last=False,\\n num_workers=args.num_workers)\\n\\n for input_nodes, output_nodes, blocks in tqdm.tqdm(dataloader):\\n block = blocks[0]\\n\\n block = block.int()\\n h = x[input_nodes]\\n h = layer(block, h)\\n if l != len(self.layers) - 1:\\n h = self.activation(h)\\n h = self.dropout(h)\\n\\n y[output_nodes] = h\\n\\n x = y\\n return y\",\n \"def process(self, sess):\\n sess.run(self.p_sync) # copy weights from shared to local\\n\\n rollout = self.pull_batch_from_queue()\\n\\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\\n\\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\\n\\n if should_compute_summary:\\n fetches = [self.summary_op, self.p_train_op, self.global_step]\\n else:\\n fetches = [self.p_train_op, self.global_step]\\n\\n feed_dict = {\\n self.local_network.x: batch.si,\\n self.ac: batch.a,\\n self.adv: batch.adv,\\n self.r: batch.r,\\n self.local_network.p_state_in[0]: batch.features[0],\\n self.local_network.p_state_in[1]: batch.features[1],\\n }\\n fetched = sess.run(fetches, feed_dict=feed_dict)\\n\\n if should_compute_summary:\\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]), fetched[-1])\\n self.summary_writer.flush()\\n\\n # Update the distctiminator\\n sess = tf.get_default_session()\\n self.local_steps += 1\",\n \"def inference(model, data, diagnostics, seed, extra_fitting_args):\\n pass\",\n \"def infer_on_stream(args, client):\\n # Initialize the network\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n # Load the model through `infer_network`\\n infer_network.load_model(args.model, args.device, args.cpu_extension)\\n\\n # Handle the input stream\\n # expand the tilde\\n input_fpath = os.path.expanduser(args.input)\\n f_name, f_extn = os.path.splitext(input_fpath)\\n\\n is_image_input = False\\n\\n # add the file extensions as you like\\n if f_extn in ['.mp4', '.avi', '.mpeg']:\\n pass\\n elif f_extn in ['.png', '.jpg', 'jpeg']:\\n is_image_input = True\\n else:\\n assert False, f'unsupported input data extension: {f_extn}'\\n\\n # Get and open video capture\\n cap = cv2.VideoCapture(input_fpath)\\n cap.open(input_fpath)\\n # [1, 3, 320, 544] (BCHW)\\n net_input_dims = infer_network.get_input_shape()\\n logger.debug('* DNN input dims: {}'.format(net_input_dims))\\n\\n width = int(cap.get(3))\\n height = int(cap.get(4))\\n # * Video dims: [height:432, width:768]\\n logger.debug('* Video dims: [height:{}, width:{}]'.format(height, width))\\n\\n logger.debug('platform: {}'.format(platform))\\n out_video = cv2.VideoWriter('out_result.mp4', CODEC, 30, (width, height))\\n\\n # Loop until stream is over\\n frame_num = 0\\n last_valid_pers_num = 0\\n total_valid_pers_num = 0\\n duration_time_sec = 0\\n miss_detect_cnt = 0\\n start_tracking = False\\n all_infer_time = []\\n\\n while cap.isOpened():\\n # Read the next frame\\n flag, frame = cap.read()\\n if not flag:\\n break\\n key_pressed = cv2.waitKey(60)\\n\\n # for debug\\n if frame[0].size > 0:\\n logger.debug(frame)\\n logger.debug(f'saved the frame into img_{frame_num}.png !!!')\\n cv2.imwrite(f'resources/images/img_{frame_num}.png', frame)\\n cv2.imshow('win', frame)\\n\\n # Pre-processing the image\\n # cv2.resize(src, dsize=(width, height))\\n p_frame = cv2.resize(frame, (net_input_dims[3], net_input_dims[2]))\\n p_frame = p_frame.transpose((2,0,1))\\n # reshape (3, 320, 544) to (1, 3, 320, 544)\\n p_frame = p_frame.reshape(1, *p_frame.shape)\\n logger.debug('+ frame %d' % (frame_num))\\n logger.debug(' - shape: {}'.format(p_frame.shape))\\n\\n # Start asynchronous inference for specified request\\n infer_start = time.time()\\n infer_network.exec_net(p_frame)\\n\\n # Wait for the result\\n if infer_network.wait() == 0: # when the inference per frame finishes\\n infer_stop = time.time()\\n infer_time_ms = (infer_stop-infer_start) * 1e3\\n\\n # Get the results of the inference request\\n infer_result = infer_network.get_output()\\n\\n # Filter the valid object\\n valid_object = extract_valid_object(infer_result)\\n\\n # draw bounding box of detected person on the image\\n out_frame, valid_pers_num = draw_boundingbox(frame, valid_object, width, height, prob_threshold)\\n\\n def add_text_on_image(image, insert_text=None, loc=(10,10), tsize=0.4, tcolr=(209, 130, 0, 255), tbold=1):\\n # add a text\\n cv2.putText(image, insert_text, loc, cv2.FONT_HERSHEY_SIMPLEX, tsize, tcolr, tbold)\\n logger.debug(' - [add the text on image] %s' % (insert_text))\\n return\\n\\n logger.debug(' - total number of people: %d' % total_valid_pers_num)\\n\\n logger.debug(f'[#check#] valid person number: {valid_pers_num}')\\n logger.debug(f'[#check#] last valid person number: {last_valid_pers_num}')\\n logger.debug(f'[#check#] total count ({total_valid_pers_num})')\\n\\n # p1: 0-0-0-0-0-0-0-0-0-0 (F)\\n # p2: 0-0-1-1-1-0-0-0-0-1 (F)\\n # p3: 0-0-1-1-1-0-0-0-0-0 (F)\\n # p4: 0-0-1-0-1-1-1-1-1-1 (F)\\n if start_tracking: # if a person disappears for a sec\\n miss_detect_cnt += 1\\n logger.debug(f'[#check#] miss count ({miss_detect_cnt})')\\n if miss_detect_cnt == 5: # if miss detection continues for the consecutive 5 frames, we think a person disappeared\\n duration_time_sec = time.time() - emerge_time\\n total_valid_pers_num += 1\\n\\n # Topic \\\"person/duration\\\": key of \\\"duration\\\"\\n client.publish(\\\"person/duration\\\", json.dumps({\\\"duration\\\": duration_time_sec}))\\n # Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\"\\n client.publish(\\\"person\\\", json.dumps({\\\"total\\\": total_valid_pers_num}))\\n\\n logger.debug(f'[#check#] a person is disappeared')\\n logger.debug(f'[#check#] total count ({total_valid_pers_num})')\\n logger.debug(f'[#check#] duration ({duration_time_sec})')\\n # initialize\\n start_tracking = False\\n miss_detect_cnt = 0\\n elif valid_pers_num > last_valid_pers_num:\\n # initialize\\n start_tracking = False\\n miss_detect_cnt = 0\\n\\n else:\\n if valid_pers_num > last_valid_pers_num: # 0->1\\n emerge_time = time.time()\\n elif valid_pers_num < last_valid_pers_num: # 1->0\\n start_tracking = True\\n else: #0->0\\n pass\\n\\n # add duration time on the image\\n insert_text = 'duration time: %d sec' % (duration_time_sec)\\n add_text_on_image(out_frame, insert_text, (10,60))\\n\\n # add total count of people on the image\\n insert_text = 'total count of people: %d' % (total_valid_pers_num)\\n add_text_on_image(out_frame, insert_text, (10,40))\\n\\n # add inference time on the image\\n insert_text = \\\"inference time(without post-process): %.2fms\\\" % (infer_time_ms)\\n add_text_on_image(out_frame, insert_text, (10,20))\\n all_infer_time.append(infer_time_ms)\\n\\n # save a current valid person number into the last valid person number\\n last_valid_pers_num = valid_pers_num\\n\\n if is_image_input:\\n path = '.'\\n f_name = f'output_{frame_num}{f_extn}'\\n cv2.imwrite(os.path.join(path, f_name), out_frame)\\n else:\\n # write into a movie\\n out_video.write(out_frame)\\n\\n # Send current_count, total_count and duration to the MQTT server ###\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": valid_pers_num}))\\n\\n\\n # Send the frame to the FFMPEG server\\n sys.stdout.buffer.write(out_frame)\\n sys.stdout.flush()\\n\\n # Break if escape key pressed\\n if key_pressed == 27:\\n break\\n# if frame_num > 500:\\n# break\\n\\n # count up the frame number\\n frame_num += 1\\n\\n # Release the capture and destroy any OpenCV windows\\n cap.release()\\n out_video.release()\\n cv2.destroyAllWindows()\\n\\n # close the MTQQ server connection\\n client.disconnect()\\n\\n logger.info(f'* average inference time: {sum(all_infer_time)/frame_num} ms')\\n logger.info(f'* total count of people: {total_valid_pers_num}')\",\n \"def evaluate():\\n\\n # seed provides the mechanism to control the shuffling which takes place reading input\\n seed = tf.placeholder(tf.int64, shape=())\\n \\n # Generate placeholders for the images and labels.\\n iterator = input_data.input_pipeline_binary(FLAGS.data_dir,\\n FLAGS.batch_size,\\n fake_data=FLAGS.fake_data,\\n num_epochs=1,\\n read_threads=FLAGS.read_threads,\\n shuffle_size=FLAGS.shuffle_size,\\n num_expected_examples=FLAGS.num_examples,\\n seed=seed)\\n image_path, label_path, images, labels = iterator.get_next()\\n\\n if FLAGS.verbose:\\n print_op = tf.print(\\\"images and labels this batch: \\\", \\n image_path, label_path, labels)\\n else:\\n print_op = tf.constant('No printing')\\n\\n if FLAGS.random_rotation:\\n images, labels = harmonics.apply_random_rotation(images, labels)\\n\\n # Build a Graph that computes predictions from the inference model.\\n logits = topology.inference(images, FLAGS.network_pattern)\\n \\n # Add to the Graph the Ops for loss calculation.\\n loss = topology.binary_loss(logits, labels)\\n \\n # Set up some prediction statistics\\n predicted = tf.round(tf.nn.sigmoid(logits))\\n correct_pred = tf.equal(predicted, labels)\\n accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\\n\\n saver = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n \\n while True:\\n eval_once(sess, iterator, saver, seed, labels, loss, accuracy, predicted)\\n if FLAGS.run_once:\\n break\\n time.sleep(FLAGS.eval_interval_secs)\",\n \"def loop_threaded():\\n nonlocal index, total\\n nonlocal d_tree\\n nonlocal fn_inputReadCallback\\n nonlocal fn_analysisCallback\\n nonlocal fn_outputWriteCallback\\n nonlocal dret_inputSet\\n nonlocal dret_analyze\\n nonlocal dret_outputSet\\n nonlocal str_desc\\n\\n def thread_createOnFunction(path, data, str_namePrefix, fn_thread):\\n \\\"\\\"\\\"\\n Simply create a thread function and return it.\\n \\\"\\\"\\\"\\n nonlocal index\\n ta = threading.Thread(\\n name = '%s-%04d.%d' % (str_namePrefix, index, self.numThreads),\\n target = fn_thread,\\n args = (path, data, index),\\n kwargs = kwargs\\n )\\n return ta\\n\\n def threadsInBatches_run(l_threadAnalysis):\\n \\\"\\\"\\\"\\n Run threads in batches of self.numThreads\\n and also handle any remaining threads.\\n \\\"\\\"\\\"\\n index = 1\\n if self.numThreads > total:\\n self.numThreads = total\\n threadFullLoops = int(total / self.numThreads)\\n threadRem = total % self.numThreads\\n alreadyRunCount = thread_batch(\\n l_threadAnalysis,\\n threadFullLoops,\\n self.numThreads,\\n 0)\\n nextRunCount = thread_batch(\\n l_threadAnalysis,\\n 1,\\n threadRem,\\n alreadyRunCount)\\n\\n if int(self.verbosityLevel) and self.toConsole():\\n iterator = tqdm( self.d_inputTree.items(),\\n desc = str_desc)\\n else:\\n iterator = self.d_inputTree.items()\\n\\n # Read\\n if fn_inputReadCallback:\\n index = 1\\n for path, data in iterator:\\n dret_inputSet = inputSet_read(path, data)\\n # filesRead += dret_inputSet['filesRead']\\n index += 1\\n\\n # Analyze\\n if fn_analysisCallback:\\n index = 1\\n l_threadAnalysis = []\\n for path, data in iterator:\\n l_threadAnalysis.append(thread_createOnFunction(\\n path, data,\\n 'analysisThread',\\n # t_analyze\\n analysis_do\\n )\\n )\\n index += 1\\n\\n # And now batch them in groups\\n threadsInBatches_run(l_threadAnalysis)\\n tree_removeDeadBranches()\\n # Write\\n if fn_outputWriteCallback:\\n index = 1\\n for path, data in iterator:\\n dret_outputSet = outputSet_write(path, d_tree[path])\\n # filesSaved += dret_outputSet['filesSaved']\\n index += 1\",\n \"def main():\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True # pylint: disable=E1101\\n\\n comm = MPI.COMM_WORLD\\n\\n # Use MPI for parallel evaluation\\n rank = comm.Get_rank()\\n size = comm.Get_size()\\n\\n env_fns, env_names = create_eval_envs()\\n\\n env = AllowBacktracking(env_fns[rank](stack=False, scale_rew=False))\\n env = BatchedFrameStack(BatchedGymEnv([[env]]), num_images=4, concat=False)\\n with tf.Session(config=config) as sess:\\n dqn = DQN(*rainbow_models(sess,\\n env.action_space.n,\\n gym_space_vectorizer(env.observation_space),\\n min_val=-200,\\n max_val=200))\\n player = NStepPlayer(BatchedPlayer(env, dqn.online_net), 3)\\n optimize = dqn.optimize(learning_rate=1e-4)\\n sess.run(tf.global_variables_initializer())\\n\\n reward_hist = []\\n total_steps = 0\\n def _handle_ep(steps, rew, env_rewards):\\n nonlocal total_steps\\n total_steps += steps\\n reward_hist.append(rew)\\n if total_steps % 1 == 0:\\n avg_score = sum(reward_hist[-100:]) / len(reward_hist[-100:])\\n\\n\\t\\t\\t# Global Score\\n global_score = np.zeros(1)\\n local_score = np.array(avg_score)\\n print(\\\"Local Score for \\\" + env_names[rank] + \\\" at episode \\\" + str(len(reward_hist)) + \\\" with timesteps: \\\" + str(total_steps) + \\\": \\\" + str(local_score))\\n comm.Allreduce(local_score, global_score, op=MPI.SUM)\\n global_score /= size\\n if rank == 0:\\n print(\\\"Global Average Score at episode: \\\" + str(len(reward_hist)) + \\\": \\\" + str(global_score))\\n\\n\\n dqn.train(num_steps=2000000, # Make sure an exception arrives before we stop.\\n player=player,\\n replay_buffer=PrioritizedReplayBuffer(500000, 0.5, 0.4, epsilon=0.1),\\n optimize_op=optimize,\\n train_interval=1,\\n target_interval=8192,\\n batch_size=32,\\n min_buffer_size=20000,\\n handle_ep=_handle_ep,\\n save_interval=None,\\n restore_path='./checkpoints_rainbow/model-10' # Model to be evaluated\\n )\",\n \"def main():\\n # Grab command line args\\n args = build_argparser().parse_args()\\n # Connect to the MQTT server\\n client = connect_mqtt()\\n # Perform inference on the input stream\\n infer_on_stream(args, client)\",\n \"def main():\\n # Grab command line args\\n args = build_argparser().parse_args()\\n # Connect to the MQTT server\\n client = connect_mqtt()\\n # Perform inference on the input stream\\n infer_on_stream(args, client)\",\n \"def inference(self, x, inference_args, spemb=None, dur=None, f0=None, energy=None,\\r\\n utt_id=None, *args, **kwargs):\\r\\n # inference\\r\\n h = self.enc.inference(x) # Tmax x h-dim\\r\\n \\r\\n if self.spk_embed_dim is not None:\\r\\n spemb = F.normalize(spemb, dim=0).unsqueeze(0).expand(h.size(0), -1)\\r\\n h = torch.cat([h, spemb], dim=-1)\\r\\n \\r\\n ilens = torch.LongTensor([h.shape[0]]).to(h.device)\\r\\n d_masks = make_pad_mask(ilens).to(h.device)\\r\\n if dur is not None:\\r\\n d_outs = dur.reshape(-1).long()\\r\\n else:\\r\\n d_outs = self.duration_predictor.inference(h.unsqueeze(0), d_masks) # B x Tmax\\r\\n d_outs = d_outs.squeeze(0).long()\\r\\n \\r\\n if self.use_fe_condition:\\r\\n if f0 is not None:\\r\\n p_outs = f0.unsqueeze(0)\\r\\n e_outs = energy.unsqueeze(0)\\r\\n else:\\r\\n expand_hs = h.unsqueeze(0)\\r\\n fe_masks = d_masks\\r\\n p_outs = self.pitch_predictor(expand_hs, fe_masks.unsqueeze(-1))\\r\\n e_outs = self.energy_predictor(expand_hs, fe_masks.unsqueeze(-1))\\r\\n p_embs = self.pitch_embed(p_outs.transpose(1,2)).transpose(1,2).squeeze(0)\\r\\n e_embs = self.energy_embed(e_outs.transpose(1,2)).transpose(1,2).squeeze(0)\\r\\n else:\\r\\n p_outs = None\\r\\n e_outs = None\\r\\n p_embs = None\\r\\n e_embs = None\\r\\n \\r\\n if self.append_position:\\r\\n position = []\\r\\n for iid in range(d_outs.shape[0]):\\r\\n if d_outs[iid] != 0:\\r\\n position.append(torch.FloatTensor(list(range(d_outs[iid].long())))/d_outs[iid])\\r\\n position = pad_list(position, 0)\\r\\n position = position.to(h.device)\\r\\n else:\\r\\n position = None\\r\\n \\r\\n outs = self.dec.inference(\\r\\n h,\\r\\n d_outs,\\r\\n position,\\r\\n p_embs,\\r\\n e_embs,\\r\\n )\\r\\n \\r\\n return outs\",\n \"def step(self, observation, last_state):\\n # We are omitting the details of network inference here.\\n # ...\\n feature_screen = observation[3]['feature_screen']\\n feature_minimap = observation[3]['feature_minimap']\\n feature_units = observation[3]['feature_units']\\n feature_player = observation[3]['player']\\n available_actions = observation[3]['available_actions']\\n score_by_category = observation[3]['score_by_category']\\n game_loop = observation[3]['game_loop']\\n\\n unit_type = feature_screen.unit_type\\n empty_space = np.where(unit_type == 0)\\n empty_space = np.vstack((empty_space[0], empty_space[1])).T\\n random_point = random.choice(empty_space)\\n #target = [random_point[0], random_point[1]]\\n #action = [actions.FunctionCall(_BUILD_SUPPLY_DEPOT, [_NOT_QUEUED, target])]\\n policy_logits = None\\n new_state = None\\n\\n spatial_encoder_output = self.spatial_encoder(np.reshape(feature_screen, [1,128,128,27]))\\n\\n agent_statistics = get_agent_statistics(score_by_category)\\n\\n home_race = 'Terran'\\n away_race = 'Terran'\\n race = get_race_onehot(home_race, away_race)\\n\\n time = get_gameloop_obs(game_loop)\\n\\n upgrade_value = get_upgrade_obs(feature_units)\\n if upgrade_value != -1:\\n self.home_upgrade_array[np.where(upgrade_value[0] == 1)] = 1\\n self.away_upgrade_array[np.where(upgrade_value[1] == 1)] = 1\\n\\n embedded_scalar = np.concatenate((agent_statistics, race, time, self.home_upgrade_array, self.away_upgrade_array), axis=0)\\n scalar_encoder_output = self.scalar_encoder(np.reshape(embedded_scalar, [1,307]))\\n embedded_feature_units = get_entity_obs(feature_units)\\n entity_encoder_output = self.entity_encoder(np.reshape(embedded_feature_units, [1,512,464]))\\n encoder_input = np.concatenate((spatial_encoder_output, scalar_encoder_output, entity_encoder_output), axis=1)\\n\\n core_input = np.reshape(encoder_input, [16, 8, 131])\\n whole_seq_output, final_memory_state, final_carry_state = self.core(core_input)\\n print(whole_seq_output.shape)\\n print(final_memory_state.shape)\\n print(final_carry_state.shape)\\n\\n action = [actions.FUNCTIONS.no_op()]\\n\\n return action, policy_logits, new_state\",\n \"def inference(self, x, data):\\n\\n ## Global features concatenated\\n if self.u_dim > 0:\\n u = data.u.view(-1, self.u_dim)\\n x = torch.cat((x, u), 1)\\n\\n ## Final MLP map\\n \\n # Edge level inference\\n if 'edge' in self.task:\\n x = self.forward_2pt(x, data.edge_index)\\n\\n # Node or graph level inference\\n else:\\n x = self.mlp_final(x)\\n\\n return x\",\n \"def print_stats(exec_net, input_data, n_channels, batch_size, input_blob, out_blob, args):\\n\\n # Start sync inference\\n print(\\\"Starting inference ({} iterations)\\\".format(args.number_iter))\\n infer_time = []\\n\\n for i in range(args.number_iter):\\n input_data_transposed_1=input_data[0:batch_size].transpose(0,3,1,2)\\n t0 = time.time()\\n res = exec_net.infer(inputs={input_blob: input_data_transposed_1[:,:n_channels]})\\n infer_time.append((time.time() - t0) * 1000)\\n\\n\\n average_inference = np.average(np.asarray(infer_time))\\n print(\\\"Average running time of one batch: {:.5f} ms\\\".format(average_inference))\\n print(\\\"Images per second = {:.3f}\\\".format(batch_size * 1000.0 / average_inference))\\n\\n perf_counts = exec_net.requests[0].get_perf_counts()\\n log.info(\\\"Performance counters:\\\")\\n log.info(\\\"{:<70} {:<15} {:<15} {:<15} {:<10}\\\".format(\\\"name\\\",\\n \\\"layer_type\\\",\\n \\\"exec_type\\\",\\n \\\"status\\\",\\n \\\"real_time, us\\\"))\\n for layer, stats in perf_counts.items():\\n log.info(\\\"{:<70} {:<15} {:<15} {:<15} {:<10}\\\".format(layer,\\n stats[\\\"layer_type\\\"],\\n stats[\\\"exec_type\\\"],\\n stats[\\\"status\\\"],\\n stats[\\\"real_time\\\"]))\",\n \"def run(self, context):\\n self.start()\\n while not context.is_finished():\\n self.update_predictions(context)\\n new_results, instances = self.evaluate()\\n if new_results:\\n self.write_results(new_results, instances)\\n self.update_plot(new_results, instances)\\n\\n if self.plot_file:\\n self.visualizer.savefig(self.plot_file)\\n if self.show_plot:\\n self.visualizer.show()\\n self.end()\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--allData', default='', action='store', nargs='+',\\n help=\\\"add train test validation dataset together\\\")\\n parser.add_argument('--topic', default='', help=\\\"target topic\\\")\\n parser.add_argument('--contentWordNumber', default='', help=\\\"threshold for content Word Number\\\")\\n parser.add_argument('--returnNSents', default='', help=\\\"top N sentences\\\")\\n\\n args = parser.parse_args()\\n data = loadData(args.allData, args.topic, args.contentWordNumber)\\n allDataDic, targetTweets = data.readData()\\n \\\"\\\"\\\"\\n ##modify at def_processing, re-run below line##\\n outputDB = data.processing(allDataDic)\\n with open(ROOT.DATA_ROOT+'/'+'allDataDic.txt', 'w') as file:\\n file.write(json.dumps(outputDB))\\n \\\"\\\"\\\"\\n\\n targData = data.processing(targetTweets)\\n outputDB = json.load(open(ROOT.DATA_ROOT + '/allDataDic.txt'))\\n contentWords = data.tfidf(outputDB, targData)\\n return targetTweets,targData, contentWords\",\n \"def process(self, sess):\\n\\n sess.run(self.sync) # copy weights from shared to local\\n rollout = self.pull_batch_from_queue()\\n batch = process_rollout(rollout, gamma=0.99, lambda_=1.0)\\n\\n should_compute_summary = self.task == 0 and self.local_steps % 11 == 0\\n\\n if should_compute_summary:\\n fetches = [self.summary_op, self.train_op, self.global_step]\\n else:\\n fetches = [self.train_op, self.global_step]\\n\\n feed_dict = {\\n self.local_network.x: batch.si,\\n self.ac: batch.a,\\n self.adv: batch.adv,\\n self.r: batch.r,\\n self.local_network.state_in[0]: batch.features[0],\\n self.local_network.state_in[1]: batch.features[1],\\n }\\n\\n fetched = sess.run(fetches, feed_dict=feed_dict)\\n\\n if should_compute_summary:\\n self.summary_writer.add_summary(tf.Summary.FromString(fetched[0]), fetched[-1])\\n self.summary_writer.flush()\\n self.local_steps += 1\",\n \"def _RunPostProcess(self, threadpool, step, decode_out_obj, dec_metrics,\\n global_step, buffered_decode_out, postprocess_futures):\\n if threadpool:\\n # Run postprocess on separate CPU thread.\\n postprocess_futures.append(\\n threadpool.apply_async(\\n self._PostProcessStep,\\n args=(step, decode_out_obj, dec_metrics, global_step,\\n buffered_decode_out)))\\n else:\\n self._PostProcessStep(step, decode_out_obj, dec_metrics, global_step,\\n buffered_decode_out)\",\n \"def inference(self):\\r\\n\\t\\tfor partition, loader in self.loaders.items():\\r\\n\\t\\t\\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\\r\\n\\t\\t\\t\\tloader)\\r\\n\\t\\t\\tself.preds[partition] = {\\r\\n\\t\\t\\t\\t'tag': tags,\\r\\n\\t\\t\\t\\t'y': y,\\r\\n\\t\\t\\t\\t'y_hat': y_hat,\\r\\n\\t\\t\\t\\t# 'posteriors': post,\\r\\n\\t\\t\\t\\t# 'attentions': attentions\\r\\n\\t\\t\\t}\",\n \"def extract_async(self, frame, tlbrs):\\n imgs = multi_crop(frame, tlbrs)\\n self.embeddings, cur_imgs = [], []\\n # pipeline inference and preprocessing the next batch in parallel\\n for offset in range(0, len(imgs), self.batch_size):\\n cur_imgs = imgs[offset:offset + self.batch_size]\\n self.pool.starmap(self._preprocess, enumerate(cur_imgs))\\n if offset > 0:\\n embedding_out = self.backend.synchronize()[0]\\n self.embeddings.append(embedding_out)\\n self.backend.infer_async()\\n self.last_num_features = len(cur_imgs)\",\n \"def test_3():\\n \\n\\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n multiply_and_add(in_streams[0], out_streams[0],\\n multiplicand=2, addend=1)\\n\\n def g(in_streams, out_streams):\\n t = Stream('t')\\n filter_then_square(in_streams[0], t,\\n filter_threshold=20)\\n print_stream(t, name='p1')\\n\\n def sums(in_streams, out_streams):\\n s = Stream('s')\\n sum_window(in_streams[0], s, window_size=3, step_size=3)\\n print_stream(s, name=' p2')\\n\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n }\\n },\\n 'process_1':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': g,\\n 'sources': {}\\n },\\n 'process_2':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': sums,\\n 'sources': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'process_1':\\n {\\n },\\n 'process_2':\\n {\\n }\\n }\\n\\n multicore(processes, connections)\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader_MultiClass_Loss(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n RANDOM_SEED,\\n False, # No random scale.\\n False, # No random mirror.\\n coord)\\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\\n image_batch = tf.expand_dims(image, dim=0)\\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n \\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n\\n # Do the global average pooling\\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\\n pred = tf.nn.softmax(g_avg_pool_sqzd)\\n\\n # Get the class activation map\\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\\n\\n cam_batch = tf.expand_dims(cam, dim=3)\\n\\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n \\n # Iterate over training steps.\\n for step in range(args.num_steps):\\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\\n \\\"\\\"\\\"\\n print(bin_catg)\\n print(np.unique(np.unique(cams)))\\n \\\"\\\"\\\"\\n img = inv_preprocess(images)\\n attMap = decode_labels(cams)\\n output_dir = './output_maps_binary_without_norm/'\\n img_name = output_dir + str(step) + '.jpg'\\n map_name = output_dir + str(step) + '.png'\\n misc.imsave(img_name, img[0,:,:,:])\\n misc.imsave(map_name, attMap[0,:,:,:])\\n coord.request_stop()\\n coord.join(threads)\",\n \"def exec_attention(self,curr_step): \\n\\n assert(self.curr_step_idx > 0 and self.dlist is not None), \\\"Step Error: Must call init before combine\\\" \\n \\n detectType = curr_step[\\\"detectionNetwork\\\"]\\n paramsFile = curr_step[\\\"paramsFile\\\"]\\n funclist = curr_step[\\\"funclist\\\"]\\n\\n #verify raw data & dlist\\n # self.B_VER(self.sess_path, self.dlist)\\n raw_datadir = self.sess_path\\n dest_datadir = self.sess_path \\n\\n model_dict = {\\\"detectType\\\": detectType, \\\"paramsFile\\\" : paramsFile} \\n\\n for i, folder in enumerate(self.dlist):\\n flist = funclist[i]\\n self.data_utils.DETECT(raw_datadir, folder, dest_datadir, model_dict, flist=[], preview=False)\\n self.default_vis(curr_step)\",\n \"def _FetchDecodeOut(tpu_outs: Union[List[tf.Tensor], Callable[..., tf.Tensor]],\\n sess=None):\\n if py_utils.IsEagerMode():\\n # The CPU pass through data will be from the infeed function.\\n # Here we will get an empty `cpu_pt`.\\n decode_out_dict, cpu_pt = tpu_outs()\\n decode_out_dict = py_utils.Transform(lambda x: x.numpy(), decode_out_dict)\\n else:\\n decode_tensors, cpu_passthrough_tensors = tpu_outs\\n if cpu_passthrough_tensors is not None:\\n decode_out_dict, cpu_pt = sess.run(\\n [decode_tensors, cpu_passthrough_tensors])\\n else:\\n decode_out_dict = sess.run(decode_tensors)\\n cpu_pt = {}\\n return _UpdateCpuPassThroughData(decode_out_dict, cpu_pt)\",\n \"def run_inference(self, schema_params):\\n # Log distributed execution context, which includes cluster configuration\\n logger.info(\\\"Commencing {} inference\\\".format(self.effect_name))\\n logger.info(\\\"Execution context : {}\\\".format(self.execution_context))\\n\\n logger.info('Creating dirs recursively at: {0}'.format(\\n self.base_training_params.validation_score_dir))\\n\\n if self.execution_context[constants.TASK_TYPE] != constants.TASK_TYPE_WORKER:\\n logger.info(\\\"Only workers should run inference. Exiting\\\")\\n return\\n\\n # Create partition_index_list\\n partition_index_list = self._get_partition_list()\\n\\n for partition_index in partition_index_list:\\n logger.info(\\n \\\"Commencing {} inference for partition index : {}\\\".format(self.effect_name, partition_index))\\n\\n self.execution_context[constants.PARTITION_INDEX] = partition_index\\n for input_path, output_path in ((self.model.training_data_dir, self.base_training_params.training_score_dir),\\n (self.model.validation_data_dir, self.base_training_params.validation_score_dir)):\\n if input_path and output_path:\\n # Resolve partitioned data path from raw path params from user\\n data_path = self._anchor_directory(input_path, partition_index)\\n output_dir = os.path.join(self._anchor_directory(output_path, partition_index))\\n\\n if is_empty_directory(input_path):\\n logger.info(f\\\"{input_path} is empty, no dataset to inference on.\\\")\\n continue\\n # Run inference\\n self.model.predict(output_dir=output_dir,\\n input_data_path=data_path,\\n metadata_file=self.model.metadata_file,\\n checkpoint_path=self.model.checkpoint_path,\\n execution_context=self.execution_context,\\n schema_params=schema_params)\\n logger.info(\\n \\\"Inference for partition index : {} complete\\\".format(partition_index))\\n\\n logger.info(\\\"Inference complete\\\")\",\n \"def execute(self, requests):\\n responses = []\\n for request in requests:\\n infer_outputs = pb_utils.get_input_tensor_by_name(\\n request, self.input_names[0])\\n im_infos = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[1])\\n ori_imgs = pb_utils.get_input_tensor_by_name(request,\\n self.input_names[2])\\n\\n infer_outputs = infer_outputs.as_numpy()\\n im_infos = im_infos.as_numpy()\\n ori_imgs = ori_imgs.as_numpy()\\n\\n results = self.postprocessor.run([infer_outputs], im_infos)\\n batch_rec_texts = []\\n batch_rec_scores = []\\n batch_box_list = []\\n for i_batch in range(len(results)):\\n\\n cls_labels = []\\n cls_scores = []\\n rec_texts = []\\n rec_scores = []\\n\\n box_list = fd.vision.ocr.sort_boxes(results[i_batch])\\n image_list = []\\n if len(box_list) == 0:\\n image_list.append(ori_imgs[i_batch])\\n else:\\n for box in box_list:\\n crop_img = get_rotate_crop_image(ori_imgs[i_batch], box)\\n image_list.append(crop_img)\\n\\n batch_box_list.append(box_list)\\n\\n cls_pre_tensors = self.cls_preprocessor.run(image_list)\\n cls_dlpack_tensor = cls_pre_tensors[0].to_dlpack()\\n cls_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", cls_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='cls_pp',\\n requested_output_names=['cls_labels', 'cls_scores'],\\n inputs=[cls_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n cls_labels = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_labels')\\n cls_labels = cls_labels.as_numpy()\\n\\n cls_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'cls_scores')\\n cls_scores = cls_scores.as_numpy()\\n\\n for index in range(len(image_list)):\\n if cls_labels[index] == 1 and cls_scores[\\n index] > self.cls_threshold:\\n image_list[index] = cv2.rotate(\\n image_list[index].astype(np.float32), 1)\\n image_list[index] = np.astype(np.uint8)\\n\\n rec_pre_tensors = self.rec_preprocessor.run(image_list)\\n rec_dlpack_tensor = rec_pre_tensors[0].to_dlpack()\\n rec_input_tensor = pb_utils.Tensor.from_dlpack(\\n \\\"x\\\", rec_dlpack_tensor)\\n\\n inference_request = pb_utils.InferenceRequest(\\n model_name='rec_pp',\\n requested_output_names=['rec_texts', 'rec_scores'],\\n inputs=[rec_input_tensor])\\n inference_response = inference_request.exec()\\n if inference_response.has_error():\\n raise pb_utils.TritonModelException(\\n inference_response.error().message())\\n else:\\n # Extract the output tensors from the inference response.\\n rec_texts = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_texts')\\n rec_texts = rec_texts.as_numpy()\\n\\n rec_scores = pb_utils.get_output_tensor_by_name(\\n inference_response, 'rec_scores')\\n rec_scores = rec_scores.as_numpy()\\n\\n batch_rec_texts.append(rec_texts)\\n batch_rec_scores.append(rec_scores)\\n\\n out_tensor_0 = pb_utils.Tensor(\\n self.output_names[0],\\n np.array(\\n batch_rec_texts, dtype=np.object_))\\n out_tensor_1 = pb_utils.Tensor(self.output_names[1],\\n np.array(batch_rec_scores))\\n out_tensor_2 = pb_utils.Tensor(self.output_names[2],\\n np.array(batch_box_list))\\n inference_response = pb_utils.InferenceResponse(\\n output_tensors=[out_tensor_0, out_tensor_1, out_tensor_2])\\n responses.append(inference_response)\\n return responses\",\n \"def run_inference_on_image(image):\\n if not tf.gfile.Exists(image):\\n tf.logging.fatal('File does not exist %s', image)\\n image_data = tf.gfile.FastGFile(image, 'rb').read()\\n\\n\\n\\n with tf.Session() as sess:\\n # Some useful tensors:\\n # 'softmax:0': A tensor containing the normalized prediction across\\n # 1000 labels.\\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\\n # float description of the image.\\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\\n # encoding of the image.\\n # Runs the softmax tensor by feeding the image_data as input to the graph.\\n\\n # Creates node ID --> English string lookup.\\n node_lookup = NodeLookup()\\n\\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\\n predictions = sess.run(softmax_tensor,\\n {'DecodeJpeg/contents:0': image_data})\\n predictions = np.squeeze(predictions)\\n\\n\\n\\n top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\\n result =[]\\n for node_id in top_k:\\n human_string = node_lookup.id_to_string(node_id)\\n score = predictions[node_id]\\n\\n point = collections.namedtuple('Point', ['humanString', 'score'])\\n point.humanString = human_string\\n point.score = score\\n result.append(point)\\n return result\",\n \"def inference(self, data_loader):\\n\\n # Handling inference for Multiclass classification\\n outputs_list = []\\n with torch.no_grad():\\n for bi, d in enumerate(data_loader):\\n ids = d['ids']\\n mask = d['mask']\\n\\n # send them to the cpu\\n ids = ids.to(self.device, dtype=torch.long)\\n mask = mask.to(self.device, dtype=torch.long)\\n\\n outputs = self.model(\\n input_ids=ids,\\n attention_mask=mask\\n )\\n outputs_list.extend(torch.softmax(outputs, dim=1).cpu().detach().numpy().tolist())\\n\\n print(\\\"This the output from the Multiclass classification model\\\", outputs_list[0])\\n\\n inferences = np.argmax(outputs_list, axis=1)\\n inferences = [self.mapping[str(pred)] for pred in inferences]\\n\\n return inferences\",\n \"def post_apply(self): #pragma no cover\\n for e in self.obs_queue:\\n\\n # translate operation wire labels to the device's wire labels\\n device_wires = self.map_wires(e.wires)\\n\\n self.measure += \\\"set resultArray w/= {wires[0]} <- \\\".format(wires=device_wires.tolist())\\n self.measure += self._observable_map[e.name].format(wires=device_wires.tolist())\\n self.measure += \\\" \\\"\\n\\n self._source_code = PROGRAM.format(wires=self.num_wires, operations=self.prog, measurements=self.measure)\\n self.qs = qsharp.compile(self._source_code)\",\n \"def network_inference(self, points):\\r\\n\\r\\n # Ensure no gradient is computed\\r\\n with torch.no_grad():\\r\\n\\r\\n #####################\\r\\n # Input preparation #\\r\\n #####################\\r\\n\\r\\n # t = [time.time()]\\r\\n\\r\\n # Create batch from the frame points\\r\\n batch = OnlineBatch(points, self.config, self.data_handler)\\r\\n\\r\\n # t += [time.time()]\\r\\n\\r\\n # Convert batch to a cuda\\r\\n batch.to(self.device)\\r\\n # t += [time.time()]\\r\\n torch.cuda.synchronize(self.device)\\r\\n\\r\\n #####################\\r\\n # Network inference #\\r\\n #####################\\r\\n\\r\\n # Forward pass\\r\\n outputs = self.net(batch, self.config)\\r\\n torch.cuda.synchronize(self.device)\\r\\n # t += [time.time()]\\r\\n\\r\\n # Get probs and labels\\r\\n predicted_probs = self.softmax(outputs).cpu().detach().numpy()\\r\\n torch.cuda.synchronize(self.device)\\r\\n # t += [time.time()]\\r\\n\\r\\n # Insert false columns for ignored labels\\r\\n for l_ind, label_value in enumerate(self.data_handler.label_values):\\r\\n if label_value in self.data_handler.ignored_labels:\\r\\n predicted_probs = np.insert(predicted_probs, l_ind, 0, axis=1)\\r\\n\\r\\n # Get predicted labels\\r\\n predictions = self.data_handler.label_values[np.argmax(predicted_probs, axis=1)].astype(np.int32)\\r\\n # t += [time.time()]\\r\\n\\r\\n # print('\\\\n************************\\\\n')\\r\\n # print('Timings:')\\r\\n # i = 0\\r\\n # print('Batch ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\\r\\n # i += 1\\r\\n # print('ToGPU ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\\r\\n # i += 1\\r\\n # print('Forward .... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\\r\\n # i += 1\\r\\n # print('Softmax .... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\\r\\n # i += 1\\r\\n # print('Preds ...... {:7.1f} ms'.format(1000*(t[i+1] - t[i])))\\r\\n # print('-----------------------')\\r\\n # print('TOTAL ..... {:7.1f} ms'.format(1000*(t[-1] - t[0])))\\r\\n # print('\\\\n************************\\\\n')\\r\\n\\r\\n return predictions, batch.points[0].cpu().numpy()\",\n \"def main():\\n dataset_idx = [11]\\n network_idx = [0]\\n reshape_input = [False]\\n output_idxs = [0, 1]\\n lrs = [0, 1, 2]\\n dataset_ft_idx = [0,1,2,3]\\n counter_exp = 0\\n freeze = [0]\\n percentages = [12]\\n for dts in range(len(dataset_idx)):\\n for nt in range(len(network_idx)):\\n for opt in output_idxs:\\n for dft in dataset_ft_idx:\\n for pr in percentages:\\n for rsi in range(len(reshape_input)):\\n for fr in freeze:\\n for lr in lrs:\\n config = configuration(dataset_idx=dataset_idx[dts],\\n network_idx=network_idx[nt],\\n output_idx=opt,\\n usage_modus_idx=5,\\n dataset_fine_tuning_idx=dft,\\n reshape_input=reshape_input[rsi],\\n learning_rates_idx=lr,\\n name_counter=counter_exp,\\n freeze=fr,\\n percentage_idx=pr,\\n fully_convolutional=False)\\n\\n setup_experiment_logger(logging_level=logging.DEBUG,\\n filename=config['folder_exp'] + \\\"logger.txt\\\")\\n\\n logging.info('Finished')\\n\\n modus = Modus_Selecter(config)\\n\\n # Starting process\\n modus.net_modus()\\n counter_exp += 1\\n\\n\\n return\",\n \"def threadWorker(self):\\n while True:\\n row = self.queue.get() #get a row of data\\n if row is None: #ending criterium\\n break\\n self.similarityQuestions(row) #the actual working function\\n self.queue.task_done() #inform the queue one task is done\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7058547","0.6675076","0.63437945","0.61934835","0.60070735","0.59801656","0.59527904","0.59318507","0.59288776","0.5920665","0.5890297","0.5875667","0.58533645","0.58358604","0.5832103","0.5815753","0.58027357","0.5774473","0.5759439","0.57552284","0.57476985","0.5736861","0.5728658","0.5725133","0.5705608","0.5694656","0.5671758","0.5663901","0.5634226","0.5628365","0.5616078","0.56058747","0.5597788","0.5565742","0.5564275","0.5552479","0.5551999","0.55496585","0.5540868","0.5529873","0.5506693","0.54847515","0.54777956","0.54690707","0.54577273","0.54520696","0.5448038","0.54437417","0.5433665","0.5415925","0.5413313","0.5410253","0.54091996","0.5397428","0.5389301","0.5387143","0.5378734","0.5371948","0.5366035","0.5363192","0.53590286","0.5350079","0.5343199","0.53336626","0.5324577","0.53157777","0.530927","0.529526","0.5289153","0.52886915","0.52862567","0.52817774","0.5281332","0.5268225","0.52675945","0.5264453","0.52623165","0.52623165","0.5258736","0.52521175","0.52519387","0.5244071","0.52331203","0.52264774","0.5224947","0.5223979","0.5218395","0.5215232","0.5212087","0.52076465","0.52040327","0.52010775","0.51935697","0.51916265","0.5190868","0.5189183","0.5188752","0.51885015","0.5187853","0.5184201"],"string":"[\n \"0.7058547\",\n \"0.6675076\",\n \"0.63437945\",\n \"0.61934835\",\n \"0.60070735\",\n \"0.59801656\",\n \"0.59527904\",\n \"0.59318507\",\n \"0.59288776\",\n \"0.5920665\",\n \"0.5890297\",\n \"0.5875667\",\n \"0.58533645\",\n \"0.58358604\",\n \"0.5832103\",\n \"0.5815753\",\n \"0.58027357\",\n \"0.5774473\",\n \"0.5759439\",\n \"0.57552284\",\n \"0.57476985\",\n \"0.5736861\",\n \"0.5728658\",\n \"0.5725133\",\n \"0.5705608\",\n \"0.5694656\",\n \"0.5671758\",\n \"0.5663901\",\n \"0.5634226\",\n \"0.5628365\",\n \"0.5616078\",\n \"0.56058747\",\n \"0.5597788\",\n \"0.5565742\",\n \"0.5564275\",\n \"0.5552479\",\n \"0.5551999\",\n \"0.55496585\",\n \"0.5540868\",\n \"0.5529873\",\n \"0.5506693\",\n \"0.54847515\",\n \"0.54777956\",\n \"0.54690707\",\n \"0.54577273\",\n \"0.54520696\",\n \"0.5448038\",\n \"0.54437417\",\n \"0.5433665\",\n \"0.5415925\",\n \"0.5413313\",\n \"0.5410253\",\n \"0.54091996\",\n \"0.5397428\",\n \"0.5389301\",\n \"0.5387143\",\n \"0.5378734\",\n \"0.5371948\",\n \"0.5366035\",\n \"0.5363192\",\n \"0.53590286\",\n \"0.5350079\",\n \"0.5343199\",\n \"0.53336626\",\n \"0.5324577\",\n \"0.53157777\",\n \"0.530927\",\n \"0.529526\",\n \"0.5289153\",\n \"0.52886915\",\n \"0.52862567\",\n \"0.52817774\",\n \"0.5281332\",\n \"0.5268225\",\n \"0.52675945\",\n \"0.5264453\",\n \"0.52623165\",\n \"0.52623165\",\n \"0.5258736\",\n \"0.52521175\",\n \"0.52519387\",\n \"0.5244071\",\n \"0.52331203\",\n \"0.52264774\",\n \"0.5224947\",\n \"0.5223979\",\n \"0.5218395\",\n \"0.5215232\",\n \"0.5212087\",\n \"0.52076465\",\n \"0.52040327\",\n \"0.52010775\",\n \"0.51935697\",\n \"0.51916265\",\n \"0.5190868\",\n \"0.5189183\",\n \"0.5188752\",\n \"0.51885015\",\n \"0.5187853\",\n \"0.5184201\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75303006"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93076,"cells":{"query":{"kind":"string","value":"get a preprocessed frame to be pushed to the graph"},"document":{"kind":"string","value":"def get_sample():\n global counter\n counter = counter + 1 \n \n # capture frames from the camera;\n \n frame=picamera.array.PiRGBArray(camera)\n camera.capture(frame, 'bgr', use_video_port=True)\n\t# grab the raw NumPy array representing the image, then initialize the timestamp\n\t# and occupied/unoccupied text\n image = frame.array\n preprocessed_image_buffer=preprocess(image)\n\t# show the frame\n cv2.imshow(\"Frame0\", image)\n key = cv2.waitKey(1) & 0xFF\n return preprocessed_image_buffer"},"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 process_frame(self, frame):\n\t\treturn frame","def preprocess_frame(self, frame):\n state = torch.Tensor(frame)\n return gpuify(state, self.gpu_id)","def frame_pre_process(self, frame):\n assert len(frame.shape) == 3, \\\n \"Expected input frame in (H, W, C) format proposed\"\n assert frame.shape[2] in [3, 4], \\\n \"Expected BGR or BGRA input process\"\n # setup the frame in the original format\n \n #orig_image = frame.copy()\n original_image = frame.copy()\n \n # creating the frame transpose conversion\n frame = frame.transpose((2, 0, 1)) # Converting from HWC to CHW\n \n # creating the frame dimensions\n frame = np.expand_dims(frame, axis=0)\n \n # return the frames outcome\n return (frame)","def display_preprocessed(env,frame):\n env.reset()\n\n #Plot the figure\n plt.figure()\n\n #Show the pre processed frame\n plt.imshow(preprocess_frame(env.reset(), (0, 0, 0, 0), 84), cmap=\"gray\")\n\n #Add title\n plt.title('Pre Processed image')\n\n #Show the plot\n plt.show()","def frame(self):\n return self.head","def step(self, frame):\n if not self._stack:\n # Fill stack with copies of first frame if empty.\n self._stack.extend([frame] * (self._num_frames - 1))\n self._stack.append(frame)\n # Match BCAgent's stacking along axis 2.\n stacked_frames = np.stack(self._stack, axis=2)\n\n if not self._flatten:\n return stacked_frames\n else:\n new_shape = stacked_frames.shape[:-2] + (-1,)\n return stacked_frames.reshape(*new_shape)","def get_input_frame(self, frame):\n self._scale_factor = min(self._input_shape[1] / frame.shape[0],\n self._input_shape[0] / frame.shape[1])\n scaled = cv2.resize(frame, (int(frame.shape[1] * self._scale_factor),\n int(frame.shape[0] * self._scale_factor)))\n pad_width = (self._input_shape[0] - scaled.shape[1]) / 2\n pad_height = (self._input_shape[1] - scaled.shape[0]) / 2\n # floor&ceil values to account for possibly odd amount of padding\n self._pad_top = int(np.floor(pad_height))\n self._pad_left = int(np.floor(pad_width))\n self._pad_bottom = int(np.ceil(pad_height))\n self._pad_right = int(np.ceil(pad_width))\n nn_frame = cv2.copyMakeBorder(scaled, self._pad_top, self._pad_bottom,\n self._pad_left, self._pad_right,\n cv2.BORDER_CONSTANT)\n return nn_frame.transpose(2, 0, 1)","def pre_process(self, frame: pd.DataFrame) -> pd.DataFrame:\n # frame = rows_filtering(frame)\n # frame = feature_dropping(frame)\n # frame = feature_values_fixing(frame)\n\n # frame = extreme_values_handling(frame, [])\n # missing_value_imputation(frame, [])\n\n # data_type_conversion(frame)\n # frame = feature_engineering(frame, self.GENERATE_USER_FEATURES)\n # feature_renaming(frame)\n\n return frame","def calculate_frame(self):\n frame = self.stream.read()\n self.keypoints, self.image = self.openpose.forward(frame, True)","def preprocess(self, frame: np.ndarray) -> torch.TensorType:\n tensor = cv.resize(frame, (self.IMGSZ, self.IMGSZ)) \n tensor = tensor.transpose(2, 0, 1)\n tensor = torch.from_numpy(tensor)\n tensor = torch.unsqueeze(tensor, 0)\n tensor = tensor.half() if self.half else tensor.float()\n tensor = tensor / 255.0\n tensor = tensor.to(self.device)\n\n return tensor","def _prepare_frame(self, frame):\n\n initial_h, initial_w = frame.shape[:2]\n scale_h, scale_w = initial_h / float(self.input_height), initial_w / float(self.input_width)\n\n in_frame = cv2.resize(frame, (self.input_width, self.input_height))\n in_frame = in_frame.transpose((2, 0, 1))\n in_frame = in_frame.reshape(self.input_size)\n\n return in_frame, scale_h, scale_w","def get_frame(self, frame: int) -> BaseImage:\n return self.sequence[frame]","def preprocess(self):","def vid2tensor( self, current_frame):","def annotated_frame(self):\n frame = self.frame.copy()\n if self.pupils_located:\n color = (0, 255, 0)\n x_left, y_left = self.pupil_left_coords()\n x_right, y_right = self.pupil_right_coords()\n # cv2.line(frame, (x_left - 5, y_left), (x_left + 5, y_left), color)\n # cv2.line(frame, (x_left, y_left - 5), (x_left, y_left + 5), color)\n # cv2.line(frame, (x_right - 5, y_right), (x_right + 5, y_right), color)\n # cv2.line(frame, (x_right, y_right - 5), (x_right, y_right + 5), color)\n return frame","def forward(self, frames):\n # global low_level_representation, semantic_representation\n reduce_frames = gap_frames(frames) # (128, 1, 224, 224, 3)\n project_frames = cnn_2d_inference(reduce_frames, name='pre_conv') # (128, 1, 512)\n content_code = tf.layers.dense(project_frames, self.hidden_units, activation=tf.nn.relu)\n reduce_reconstruction = cnn_2d_decode_inference(content_code)\n\n content_code = tf.expand_dims(content_code, axis=1)\n content_code = tf.tile(content_code, [1, 16, 1])\n\n return content_code, reduce_frames, reduce_reconstruction","def preprocess_frame(self, frame):\n # Greyscale frame\n img = np.mean(frame,-1)\n\n # Remove black bar at the bottom\n cropped_img = img[:-12, :]\n\n # Normalize Pixel Values\n normalized_frame = cropped_img/255.0\n\n return normalized_frame","def pre_handler(frame):\n img_data, _im0 = preprocess(frame, IMAGE_HEIGHT, IMAGE_WIDTH, False)\n return kdp_wrapper.convert_float_to_rgba(img_data, 8, 520, True)","def gen():\n global dataFrame\n while True:\n frame = vs.read()\n # frame = imutils.resize(frame, width=400)\n \n (flag, encodedImage) = cv2.imencode(\".jpg\", frame.copy())\n if not flag: continue\n # print (encodedImage)\n dataFrame = yield (b'--frame\\r\\n'\n b'Content-Type: image/jpeg\\r\\n\\r\\n' + bytearray(encodedImage) + b'\\r\\n')","def get_frame(self):\n\t\tframe = None\n\t\twhile not frame:","def getFrame(self):\n s, image = self.capture.read()\n return image","def pretrain_forward(self, inp):\n return self.pre_fc(self.encoder(inp))","def _process(self, frame, **kwargs):\n raise NotImplementedError()","def annotated_frame(self, original_frame):\n frame = original_frame.copy()\n\n if self.pupils_located:\n color = (0, 255, 0)\n x_left, y_left = self.pupil_left_coords()\n x_right, y_right = self.pupil_right_coords()\n cv2.line(frame, (x_left - 5, y_left), (x_left + 5, y_left), color)\n cv2.line(frame, (x_left, y_left - 5), (x_left, y_left + 5), color)\n cv2.line(frame, (x_right - 5, y_right), (x_right + 5, y_right), color)\n cv2.line(frame, (x_right, y_right - 5), (x_right, y_right + 5), color)\n\n return frame","def store_frame(self, frame):\n if self.obs is None:\n self.obs = np.empty([self.size] + list(frame.shape), dtype=np.uint8)\n self.action = np.empty([self.size], dtype=np.int32)\n self.reward = np.empty([self.size], dtype=np.float32)\n self.done = np.empty([self.size], dtype=np.bool)\n self.obs[self.next_idx] = frame\n\n ret = self.next_idx\n self.next_idx = (self.next_idx + 1) % self.size\n self.num_in_buffer = min(self.size, self.num_in_buffer + 1)\n\n return ret","def PrePush(self, image):\n pass","def input_frame(self):\n if self._pipeline:\n frame = self._pipeline[0].frame\n if not isinstance(frame, str):\n frame = frame.name\n return getattr(self, frame)\n else:\n return None","def get_initial_frame(self, memory):\n B = memory.size(0)\n decoder_input = Variable(memory.data.new(\n B, self.n_mel_channels).zero_())\n # print(decoder_input.size())\n return decoder_input","def get_frame(stream, is_pre_captured):\n frame = stream.read()\n if is_pre_captured:\n return frame[1]\n else:\n return frame","def convertFrame(self):\n try:\n height,width=self.currentFrame.shape[:2]\n img=QtGui.QImage(self.currentFrame,\n width,\n height,\n QtGui.QImage.Format_RGB888)\n img=QtGui.QPixmap.fromImage(img)\n self.previousFrame = self.currentFrame\n return img\n except:\n return None","def preprocessed(self):\n return self._preprocessed","def pretrain_forward(self, inp):\n return self.encoder(inp)","def convertFrame(self):\r\n try:\r\n height, width = self.currentFrame.shape[:2]\r\n img = QtGui.QImage(self.currentFrame,\r\n width,\r\n height,\r\n QtGui.QImage.Format_RGB888)\r\n img = QtGui.QPixmap.fromImage(img)\r\n self.previousFrame = self.currentFrame\r\n return img\r\n except:\r\n return None","def get_original_frame(self, frame):\n if self._pad_top is not None:\n frame = frame[self._pad_top:frame.shape[0] - self._pad_bottom,\n self._pad_left:frame.shape[1] - self._pad_right]\n if self._scale_factor is not None and self._scale_factor != 1:\n frame = cv2.resize(frame,\n (int(frame.shape[1] / self._scale_factor),\n int(frame.shape[0] / self._scale_factor)))\n return frame","def frame(self):","def decodeFrame(self, image):\n return image","def grab_next_frame(self):\n if Rescue_PI.input_video_file_path is None:\n self.orig_frame = self.vs.read()\n self.frame = self.orig_frame.copy()\n else:\n _, self.frame = self.vs.read()\n # self.frame = cv2.rotate(self.frame, cv2.ROTATE_180)\n if self.frame is None:\n pass\n else:\n self.frame = imutils.resize(self.frame, width=frame_width_in_pixels)","def assemble_frame(self):\n frame = None\n if self._active_effect._dirty:\n frame = np.clip(self._active_effect.pixels * self._config['max_brightness'], 0, 255)\n self._active_effect._dirty = self._config['force_refresh']\n self._latest_frame = frame\n\n return frame","def pre_forward(self, *args, **kwargs):\n batch_size = args[0].shape[0]\n if not self.instantiated:\n self.hidden_dim = args[0].shape[-1]\n self.instantiate(hidden_dim=self.hidden_dim)\n if self.past_key_reparam is None:\n past_key = self.past_key\n else:\n past_key = self.past_key_reparam\n if self.past_value_reparam is None:\n past_value = self.past_value\n else:\n past_value = self.past_value_reparam\n\n def expand_batchsize(x):\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\n return x\n\n\n if kwargs['layer_past'] is None:\n kwargs['layer_past'] = (expand_batchsize(past_key), expand_batchsize(past_value))\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\n return args, kwargs","def get_frame(self, frame):\n return self.frames[frame]","def _preprocess_image(self, sess, image, is_first_frame):\n features, self.cropped_input_image = sess.run([self.features, self.image_after_crop], feed_dict = {\n self.image_ph: image,\n self.cropbox_ph: self.cropbox,\n })\n #by default should be [8, 8, 512]\n feature_dim = features.shape\n #logging.debug(feature_dim)\n num_features, num_channels = feature_dim\n\n if is_first_frame:\n #pad [num_features, 1]\n pad = np.zeros((num_features, 1))\n features = np.concatenate([features, pad], 1)\n #generate gt\n #gt shape: [num_features, 1]\n gt = np.reshape(preprocess.generate_gt(\n preprocess.apply_transformation(self.normalized_bbox,\n self.transformation),\n FLAGS.cropbox_grid, FLAGS.bbox_grid), [-1, 1])\n features = np.concatenate([features, gt], 1)\n else:\n #this pad contains pad and dummy gt\n pad = np.zeros((num_features, 2))\n features = np.concatenate([features, pad], 1)\n #[...,0,1,0]\n frame_delimiter = np.concatenate([\n np.zeros((1, num_channels)),\n np.ones((1, 1)),\n np.zeros((1, 1))], 1)\n features = np.concatenate([frame_delimiter, features], 0)\n return features","def pre_process_frame(frame, crop_at_constr=True, blur_im=True, invert=True):\r\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n # remove gray border\r\n crop_locs = np.where((np.logical_or(frame == np.amin(frame),\r\n frame == np.amax(frame))))\r\n r1 = crop_locs[0][0]\r\n r2 = crop_locs[0][-1] + 1\r\n c1 = crop_locs[1][0]\r\n c2 = crop_locs[1][-1] + 1\r\n frame = frame[r1:r2, c1:c2]\r\n if crop_at_constr is True:\r\n constr_loc = 120# data_utils.find_constriction(frame) # 120 for last set\r\n frame = data_utils.crop_my_frame(frame,[0,constr_loc,0,frame.shape[0]])\r\n if blur_im is True:\r\n frame = cv2.blur(frame,(3,3))\r\n # expect the pixel values to be 0 or 255 (some max) so...\r\n frame = np.uint8(frame)\r\n if invert is True:\r\n frame = np.invert(frame)\r\n return frame","def captureNextFrame(self):\r\n mainls = []\r\n\r\n\r\n ret, readFrame = self.capture.read()\r\n\r\n if (ret == True):\r\n self.currentFrame = cv2.cvtColor(readFrame, cv2.COLOR_BGR2RGB)\r\n self.faceDetection(self.currentFrame)\r\n self.currentFrame = self.bbFrame","def preprocess(self):\n pass","def preprocess(self):\n pass","def preprocess(self):\n pass","def prepareFrameCache(self, frame, cacheType): # real signature unknown; restored from __doc__\n pass","def read(self):\r\n frame = self.last_frame\r\n return frame","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def dispatch_frame(self, frame):","def get_frame(self, ind):\n pass","def read_frame(self):\n return self.decode_frame(self.grab_frame())","def observation(self, frame):\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\n return frame","def on_pre_render(self, event, signal):\n t = ppb.get_time() - self.start_time\n self.frames += 1\n print(f\"Frame {self.frames} rendered at {t}\")","def get_image(self):\n self.flush_buffer()\n _, frame = self.cam.read()\n shift_frame = self.perspective_shift(frame)\n #shift_frame = None\n return frame, shift_frame","def processFrame(frame, shape=(84, 84)):\n frame = frame.astype(np.uint8) # cv2 requires np.uint8\n # Apply a rgb filter to convert RGB to Gray Scale\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\n # crop image OpenCv2 function to format img[y:y + h, x:x + w]\n frame = frame[34:34+160, :160] # crop image\n frame = cv2.resize(frame, shape, interpolation=cv2.INTER_NEAREST)\n frame = frame.reshape((*shape, 1))\n #cv2.imshow('Cropped Image', frame)\n\n return frame","def add_frame(R):\n\n x_frames.append(copy.copy(R[0]))\n y_frames.append(copy.copy(R[1]))\n z_frames.append(copy.copy(R[2]))","def _make_process_op(self):\n\n with tf.variable_scope(\"state_preprocess\"):\n self.input_state = tf.placeholder(shape=[210, 160, 3], dtype=tf.uint8)\n output = tf.image.rgb_to_grayscale(self.input_state)\n output = tf.image.crop_to_bounding_box(output, 34, 0, 160, 160)\n output = tf.image.resize_images(output, [84, 84], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n output = tf.to_float(output) / 255.0\n output = tf.transpose(output, perm=[2, 1, 0])\n\n return output","def create_frame_blob(self):\n # self.image_blob = cv2.dnn.blobFromImage(\n # cv2.resize(self.frame, (300, 300)), 1.0, (300, 300),\n # (104.0, 177.0, 123.0), swapRB=False, crop=False)\n self.image_blob = cv2.dnn.blobFromImage(cv2.resize(self.frame, (300, 300)),\n 0.007843, (300, 300), 127.5)","def registerDepthFrame(self, frame):\n h, w = frame.shape[:2]\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\n\n return frame","def gen_prologue(self, frame): # pragma: no cover\n raise NotImplementedError(\"Implement this!\")","def preprocess_dataframe(self, dataframe):\n return dataframe","def get_frame(self):\n return opencv.highgui.cvQueryFrame(self.capture)","def captureNextFrame(self):\n ret, readFrame=self.capture.read()\n if(ret==True):\n self.currentFrame=cv2.cvtColor(readFrame,cv2.COLOR_BGR2RGB)","def style_transfer_postprocess(preprocessed_frame: np.ndarray, image_shape: tuple):\n\n postprocessed_frame = np.squeeze(preprocessed_frame, axis=0)\n # select original height and width from image_shape\n frame_height = image_shape[0]\n frame_width = image_shape[1]\n postprocessed_frame = cv2.resize(postprocessed_frame, (frame_width, frame_height)).astype(\"float32\") * 255\n postprocessed_frame = cv2.cvtColor(postprocessed_frame, cv2.COLOR_RGB2BGR)\n\n return postprocessed_frame","def training_frame(self):\n return self._parms.get(\"training_frame\")","def run_frame(self, image):\n self.frame_idx += 1\n # run main pipeline\n t0 = datetime.now()\n disp = self.main_pipeline(image)\n t1 = datetime.now()\n logging.info('main pipeline: {}'.format(get_tdiff(t0, t1)))\n \n # prepare image sequence of 3 for trajectory pipeline\n t0 = datetime.now()\n self.image_seq.append(image)\n if len(self.image_seq) > 3:\n del self.image_seq[0]\n t1 = datetime.now()\n logging.info('image stack: {}'.format(get_tdiff(t0, t1)))\n\n # run trajectory pipeline\n t0 = datetime.now()\n if len(self.image_seq) >= 3:\n self.egomo_trmat = self.traj_pipeline(prev_trmat=self.egomo_trmat)\n t1 = datetime.now()\n logging.info('traj pipeline: {}'.format(get_tdiff(t0, t1)))\n return self.frame_idx, disp, self.egomo_trmat, self.t_list","def _preprocess(self, data):\n transformed_data = _copy(data)\n for name, step in self._transformers[:-1]:\n transformed_data = step.fit_transform(transformed_data)\n if type(transformed_data) != _tc.SFrame:\n raise RuntimeError(\"The transform function in step '%s' did not\"\n \" return an SFrame (got %s instead).\" % (name,\n type(transformed_data).__name__))\n return transformed_data","def process(self, data) :\n rData = Core.Processlib.Data()\n rData.frameNumber = data.frameNumber\n rData.buffer = self._worker.process(data.buffer)\n if self._writer: #optional HDF5 writer\n self._writer.write(rData.buffer, rData.frameNumber)\n return rData","def observation(self, frame):\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\n return frame[:, :, None]","def observation(self, frame):\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\n return frame[:, :, None]","def new_frame(self):\n self.eyes_frame = numpy.zeros(self.shape, numpy.uint8)","def fit_transform(self, pgframe):\n self.fit(pgframe)\n return self.transform(pgframe)","def test_preprocess_capture():\n X = preprocess_capture(\"capture.pcapng\")\n X.fillna(0, inplace=True)\n print(X.head())\n print(X.axes)","def frame(self):\n return self._frame","def frame(self):\n return self._frame","def frame(self):\n return self._frame","def get_frame_data(self):\n # FrameObject is a dictionary of slot names and values.\n frameObject = self.pgdb.sendPgdbFnCall('get-frame-object', self.frameid)\n if not frameObject:\n raise PythonCycError(\"Could not retrieve frame \"+self.frameid+\" from organism (orgid) \"+self.pgdb._orgid)\n else:\n self._gotframe = True\n # Modify slot names to allow Python's syntax (e.g., '_' instead of '-').\n for slot in frameObject:\n self.__dict__[convertLispIdtoPythonId(slot)] = frameObject[slot]\n return self","def get_frame(self):\n return self.frame","def genFrame(self):\n # generate frame-specific data\n frameData = self._genFrameData()\n\n # call parent function to create the complete frame (as bytearray)\n frame = self._genDigiMeshFrame(frameData)\n\n # OBS: never escape-sequence local msg\n return frame","def preprocess_graph(self):\n image = tf.placeholder(\n tf.float32,\n shape=[self.img_h, self.img_w, self.col_channels])\n patches = self.create_patches(image)\n return {'image': image,\n 'patches': patches}","def process(self, frame):\n frame = preprocess(frame)\n\n edges = find_edges(frame)\n circles = find_circles(frame, self.frame_count, edges)\n\n points = find_points(circles, self.points, self.frame_count)\n self.points = points\n\n acceptable = filter(lambda p: p.quality > 0.25, self.points)\n\n dead_clusters = []\n for cluster in self.clusters:\n cluster.clean(self.frame_count)\n\n if cluster.is_dead:\n dead_clusters.append(cluster)\n\n for cluster in dead_clusters:\n self.clusters.remove(cluster)\n\n clusters = find_clusters(acceptable, self.clusters, max_length = 3)\n self.clusters = clusters\n\n self.frame_count += 1\n\n self.frames.put((self.name, self.frame_count, frame, points, clusters))","def __init__(self, x: tf.Tensor):\n self.__frame = x","def process(frame, bgModel):\n \n # subtract background if background object has been saved. Otherwise, just resize image \n if bgModel != 0:\n frame_nobg = remove_background(frame, bgModel)\n\n # resize image\n frame_nobg = cv2.resize(frame_nobg, dsize=(256,144), interpolation=cv2.INTER_LINEAR)\n\n # turn non-black pixels white\n frame_processed = np.zeros(frame_nobg.shape, dtype=np.uint8)\n frame_processed[frame_nobg>0] = 255 \n else:\n frame_processed = cv2.resize(frame, dsize=(256,144), interpolation=cv2.INTER_LINEAR)\n\n # convert the image into binary image to reduce file size\n frame_processed = cv2.cvtColor(frame_processed, cv2.COLOR_BGR2GRAY)\n\n # Expand dimensions since the model expects images to have shape: [1, 144, 256, 3]\n frame_prediction = frame_processed.astype(np.float)\n frame_prediction = np.stack((frame_prediction,)*3, axis=-1)\n frame_prediction /= 255\n frame_prediction = np.expand_dims(frame_prediction, axis=0)\n\n return [frame_processed, frame_prediction]","def _create_pgframe(nodes=None, edges=None):\n pass","def classical_preprocessing(*args, **kwargs):\r\n qnode.construct(args, kwargs)\r\n return qml.math.stack(qnode.qtape.get_parameters())","def grabRawFrame(self):\r\n \r\n self.surface = self.capture.get_image(self.surface)\r\n width, height = self.surface.get_size()\r\n return pygame.image.tostring(self.surface, 'RGB'), width, height, 1","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def pre_process(self):\n pass","def convertFrame(self):\n try:\n img = QImage(self.currentVideoFrame,\n self.currentVideoFrame.shape[1],\n self.currentVideoFrame.shape[0],\n QImage.Format_RGB888\n )\n return img\n except:\n return None","def convertFrame(self):\n try:\n img = QImage(self.currentVideoFrame,\n self.currentVideoFrame.shape[1],\n self.currentVideoFrame.shape[0],\n QImage.Format_RGB888\n )\n return img\n except:\n return None","def get_frame(self, row):\n\n if row not in self.frames:\n if not self.write:\n d = self.memmap[row, :, :]\n if self.file.metadata['interleave'] == 'bil':\n d = d.T\n self.frames[row] = d.copy()\n else:\n self.frames[row] = s.nan * s.zeros((self.n_cols, self.n_bands))\n return self.frames[row]","def _getframe(depth=None): # real signature unknown; restored from __doc__\n pass"],"string":"[\n \"def process_frame(self, frame):\\n\\t\\treturn frame\",\n \"def preprocess_frame(self, frame):\\n state = torch.Tensor(frame)\\n return gpuify(state, self.gpu_id)\",\n \"def frame_pre_process(self, frame):\\n assert len(frame.shape) == 3, \\\\\\n \\\"Expected input frame in (H, W, C) format proposed\\\"\\n assert frame.shape[2] in [3, 4], \\\\\\n \\\"Expected BGR or BGRA input process\\\"\\n # setup the frame in the original format\\n \\n #orig_image = frame.copy()\\n original_image = frame.copy()\\n \\n # creating the frame transpose conversion\\n frame = frame.transpose((2, 0, 1)) # Converting from HWC to CHW\\n \\n # creating the frame dimensions\\n frame = np.expand_dims(frame, axis=0)\\n \\n # return the frames outcome\\n return (frame)\",\n \"def display_preprocessed(env,frame):\\n env.reset()\\n\\n #Plot the figure\\n plt.figure()\\n\\n #Show the pre processed frame\\n plt.imshow(preprocess_frame(env.reset(), (0, 0, 0, 0), 84), cmap=\\\"gray\\\")\\n\\n #Add title\\n plt.title('Pre Processed image')\\n\\n #Show the plot\\n plt.show()\",\n \"def frame(self):\\n return self.head\",\n \"def step(self, frame):\\n if not self._stack:\\n # Fill stack with copies of first frame if empty.\\n self._stack.extend([frame] * (self._num_frames - 1))\\n self._stack.append(frame)\\n # Match BCAgent's stacking along axis 2.\\n stacked_frames = np.stack(self._stack, axis=2)\\n\\n if not self._flatten:\\n return stacked_frames\\n else:\\n new_shape = stacked_frames.shape[:-2] + (-1,)\\n return stacked_frames.reshape(*new_shape)\",\n \"def get_input_frame(self, frame):\\n self._scale_factor = min(self._input_shape[1] / frame.shape[0],\\n self._input_shape[0] / frame.shape[1])\\n scaled = cv2.resize(frame, (int(frame.shape[1] * self._scale_factor),\\n int(frame.shape[0] * self._scale_factor)))\\n pad_width = (self._input_shape[0] - scaled.shape[1]) / 2\\n pad_height = (self._input_shape[1] - scaled.shape[0]) / 2\\n # floor&ceil values to account for possibly odd amount of padding\\n self._pad_top = int(np.floor(pad_height))\\n self._pad_left = int(np.floor(pad_width))\\n self._pad_bottom = int(np.ceil(pad_height))\\n self._pad_right = int(np.ceil(pad_width))\\n nn_frame = cv2.copyMakeBorder(scaled, self._pad_top, self._pad_bottom,\\n self._pad_left, self._pad_right,\\n cv2.BORDER_CONSTANT)\\n return nn_frame.transpose(2, 0, 1)\",\n \"def pre_process(self, frame: pd.DataFrame) -> pd.DataFrame:\\n # frame = rows_filtering(frame)\\n # frame = feature_dropping(frame)\\n # frame = feature_values_fixing(frame)\\n\\n # frame = extreme_values_handling(frame, [])\\n # missing_value_imputation(frame, [])\\n\\n # data_type_conversion(frame)\\n # frame = feature_engineering(frame, self.GENERATE_USER_FEATURES)\\n # feature_renaming(frame)\\n\\n return frame\",\n \"def calculate_frame(self):\\n frame = self.stream.read()\\n self.keypoints, self.image = self.openpose.forward(frame, True)\",\n \"def preprocess(self, frame: np.ndarray) -> torch.TensorType:\\n tensor = cv.resize(frame, (self.IMGSZ, self.IMGSZ)) \\n tensor = tensor.transpose(2, 0, 1)\\n tensor = torch.from_numpy(tensor)\\n tensor = torch.unsqueeze(tensor, 0)\\n tensor = tensor.half() if self.half else tensor.float()\\n tensor = tensor / 255.0\\n tensor = tensor.to(self.device)\\n\\n return tensor\",\n \"def _prepare_frame(self, frame):\\n\\n initial_h, initial_w = frame.shape[:2]\\n scale_h, scale_w = initial_h / float(self.input_height), initial_w / float(self.input_width)\\n\\n in_frame = cv2.resize(frame, (self.input_width, self.input_height))\\n in_frame = in_frame.transpose((2, 0, 1))\\n in_frame = in_frame.reshape(self.input_size)\\n\\n return in_frame, scale_h, scale_w\",\n \"def get_frame(self, frame: int) -> BaseImage:\\n return self.sequence[frame]\",\n \"def preprocess(self):\",\n \"def vid2tensor( self, current_frame):\",\n \"def annotated_frame(self):\\n frame = self.frame.copy()\\n if self.pupils_located:\\n color = (0, 255, 0)\\n x_left, y_left = self.pupil_left_coords()\\n x_right, y_right = self.pupil_right_coords()\\n # cv2.line(frame, (x_left - 5, y_left), (x_left + 5, y_left), color)\\n # cv2.line(frame, (x_left, y_left - 5), (x_left, y_left + 5), color)\\n # cv2.line(frame, (x_right - 5, y_right), (x_right + 5, y_right), color)\\n # cv2.line(frame, (x_right, y_right - 5), (x_right, y_right + 5), color)\\n return frame\",\n \"def forward(self, frames):\\n # global low_level_representation, semantic_representation\\n reduce_frames = gap_frames(frames) # (128, 1, 224, 224, 3)\\n project_frames = cnn_2d_inference(reduce_frames, name='pre_conv') # (128, 1, 512)\\n content_code = tf.layers.dense(project_frames, self.hidden_units, activation=tf.nn.relu)\\n reduce_reconstruction = cnn_2d_decode_inference(content_code)\\n\\n content_code = tf.expand_dims(content_code, axis=1)\\n content_code = tf.tile(content_code, [1, 16, 1])\\n\\n return content_code, reduce_frames, reduce_reconstruction\",\n \"def preprocess_frame(self, frame):\\n # Greyscale frame\\n img = np.mean(frame,-1)\\n\\n # Remove black bar at the bottom\\n cropped_img = img[:-12, :]\\n\\n # Normalize Pixel Values\\n normalized_frame = cropped_img/255.0\\n\\n return normalized_frame\",\n \"def pre_handler(frame):\\n img_data, _im0 = preprocess(frame, IMAGE_HEIGHT, IMAGE_WIDTH, False)\\n return kdp_wrapper.convert_float_to_rgba(img_data, 8, 520, True)\",\n \"def gen():\\n global dataFrame\\n while True:\\n frame = vs.read()\\n # frame = imutils.resize(frame, width=400)\\n \\n (flag, encodedImage) = cv2.imencode(\\\".jpg\\\", frame.copy())\\n if not flag: continue\\n # print (encodedImage)\\n dataFrame = yield (b'--frame\\\\r\\\\n'\\n b'Content-Type: image/jpeg\\\\r\\\\n\\\\r\\\\n' + bytearray(encodedImage) + b'\\\\r\\\\n')\",\n \"def get_frame(self):\\n\\t\\tframe = None\\n\\t\\twhile not frame:\",\n \"def getFrame(self):\\n s, image = self.capture.read()\\n return image\",\n \"def pretrain_forward(self, inp):\\n return self.pre_fc(self.encoder(inp))\",\n \"def _process(self, frame, **kwargs):\\n raise NotImplementedError()\",\n \"def annotated_frame(self, original_frame):\\n frame = original_frame.copy()\\n\\n if self.pupils_located:\\n color = (0, 255, 0)\\n x_left, y_left = self.pupil_left_coords()\\n x_right, y_right = self.pupil_right_coords()\\n cv2.line(frame, (x_left - 5, y_left), (x_left + 5, y_left), color)\\n cv2.line(frame, (x_left, y_left - 5), (x_left, y_left + 5), color)\\n cv2.line(frame, (x_right - 5, y_right), (x_right + 5, y_right), color)\\n cv2.line(frame, (x_right, y_right - 5), (x_right, y_right + 5), color)\\n\\n return frame\",\n \"def store_frame(self, frame):\\n if self.obs is None:\\n self.obs = np.empty([self.size] + list(frame.shape), dtype=np.uint8)\\n self.action = np.empty([self.size], dtype=np.int32)\\n self.reward = np.empty([self.size], dtype=np.float32)\\n self.done = np.empty([self.size], dtype=np.bool)\\n self.obs[self.next_idx] = frame\\n\\n ret = self.next_idx\\n self.next_idx = (self.next_idx + 1) % self.size\\n self.num_in_buffer = min(self.size, self.num_in_buffer + 1)\\n\\n return ret\",\n \"def PrePush(self, image):\\n pass\",\n \"def input_frame(self):\\n if self._pipeline:\\n frame = self._pipeline[0].frame\\n if not isinstance(frame, str):\\n frame = frame.name\\n return getattr(self, frame)\\n else:\\n return None\",\n \"def get_initial_frame(self, memory):\\n B = memory.size(0)\\n decoder_input = Variable(memory.data.new(\\n B, self.n_mel_channels).zero_())\\n # print(decoder_input.size())\\n return decoder_input\",\n \"def get_frame(stream, is_pre_captured):\\n frame = stream.read()\\n if is_pre_captured:\\n return frame[1]\\n else:\\n return frame\",\n \"def convertFrame(self):\\n try:\\n height,width=self.currentFrame.shape[:2]\\n img=QtGui.QImage(self.currentFrame,\\n width,\\n height,\\n QtGui.QImage.Format_RGB888)\\n img=QtGui.QPixmap.fromImage(img)\\n self.previousFrame = self.currentFrame\\n return img\\n except:\\n return None\",\n \"def preprocessed(self):\\n return self._preprocessed\",\n \"def pretrain_forward(self, inp):\\n return self.encoder(inp)\",\n \"def convertFrame(self):\\r\\n try:\\r\\n height, width = self.currentFrame.shape[:2]\\r\\n img = QtGui.QImage(self.currentFrame,\\r\\n width,\\r\\n height,\\r\\n QtGui.QImage.Format_RGB888)\\r\\n img = QtGui.QPixmap.fromImage(img)\\r\\n self.previousFrame = self.currentFrame\\r\\n return img\\r\\n except:\\r\\n return None\",\n \"def get_original_frame(self, frame):\\n if self._pad_top is not None:\\n frame = frame[self._pad_top:frame.shape[0] - self._pad_bottom,\\n self._pad_left:frame.shape[1] - self._pad_right]\\n if self._scale_factor is not None and self._scale_factor != 1:\\n frame = cv2.resize(frame,\\n (int(frame.shape[1] / self._scale_factor),\\n int(frame.shape[0] / self._scale_factor)))\\n return frame\",\n \"def frame(self):\",\n \"def decodeFrame(self, image):\\n return image\",\n \"def grab_next_frame(self):\\n if Rescue_PI.input_video_file_path is None:\\n self.orig_frame = self.vs.read()\\n self.frame = self.orig_frame.copy()\\n else:\\n _, self.frame = self.vs.read()\\n # self.frame = cv2.rotate(self.frame, cv2.ROTATE_180)\\n if self.frame is None:\\n pass\\n else:\\n self.frame = imutils.resize(self.frame, width=frame_width_in_pixels)\",\n \"def assemble_frame(self):\\n frame = None\\n if self._active_effect._dirty:\\n frame = np.clip(self._active_effect.pixels * self._config['max_brightness'], 0, 255)\\n self._active_effect._dirty = self._config['force_refresh']\\n self._latest_frame = frame\\n\\n return frame\",\n \"def pre_forward(self, *args, **kwargs):\\n batch_size = args[0].shape[0]\\n if not self.instantiated:\\n self.hidden_dim = args[0].shape[-1]\\n self.instantiate(hidden_dim=self.hidden_dim)\\n if self.past_key_reparam is None:\\n past_key = self.past_key\\n else:\\n past_key = self.past_key_reparam\\n if self.past_value_reparam is None:\\n past_value = self.past_value\\n else:\\n past_value = self.past_value_reparam\\n\\n def expand_batchsize(x):\\n x = x.reshape(self.prefix_token_num, self.num_heads, -1).transpose(0,1)\\n x = x.unsqueeze(0).expand(batch_size, *x.shape)\\n return x\\n\\n\\n if kwargs['layer_past'] is None:\\n kwargs['layer_past'] = (expand_batchsize(past_key), expand_batchsize(past_value))\\n if 'attention_mask' in kwargs and kwargs['attention_mask'] is not None:\\n am = kwargs['attention_mask'] # Should check the format of the attention_mask when moving to a new plm.\\n kwargs['attention_mask'] = torch.cat([-torch.zeros((*am.shape[:-1],self.prefix_token_num), dtype = am.dtype,device=am.device), am], dim=-1)\\n return args, kwargs\",\n \"def get_frame(self, frame):\\n return self.frames[frame]\",\n \"def _preprocess_image(self, sess, image, is_first_frame):\\n features, self.cropped_input_image = sess.run([self.features, self.image_after_crop], feed_dict = {\\n self.image_ph: image,\\n self.cropbox_ph: self.cropbox,\\n })\\n #by default should be [8, 8, 512]\\n feature_dim = features.shape\\n #logging.debug(feature_dim)\\n num_features, num_channels = feature_dim\\n\\n if is_first_frame:\\n #pad [num_features, 1]\\n pad = np.zeros((num_features, 1))\\n features = np.concatenate([features, pad], 1)\\n #generate gt\\n #gt shape: [num_features, 1]\\n gt = np.reshape(preprocess.generate_gt(\\n preprocess.apply_transformation(self.normalized_bbox,\\n self.transformation),\\n FLAGS.cropbox_grid, FLAGS.bbox_grid), [-1, 1])\\n features = np.concatenate([features, gt], 1)\\n else:\\n #this pad contains pad and dummy gt\\n pad = np.zeros((num_features, 2))\\n features = np.concatenate([features, pad], 1)\\n #[...,0,1,0]\\n frame_delimiter = np.concatenate([\\n np.zeros((1, num_channels)),\\n np.ones((1, 1)),\\n np.zeros((1, 1))], 1)\\n features = np.concatenate([frame_delimiter, features], 0)\\n return features\",\n \"def pre_process_frame(frame, crop_at_constr=True, blur_im=True, invert=True):\\r\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\r\\n # remove gray border\\r\\n crop_locs = np.where((np.logical_or(frame == np.amin(frame),\\r\\n frame == np.amax(frame))))\\r\\n r1 = crop_locs[0][0]\\r\\n r2 = crop_locs[0][-1] + 1\\r\\n c1 = crop_locs[1][0]\\r\\n c2 = crop_locs[1][-1] + 1\\r\\n frame = frame[r1:r2, c1:c2]\\r\\n if crop_at_constr is True:\\r\\n constr_loc = 120# data_utils.find_constriction(frame) # 120 for last set\\r\\n frame = data_utils.crop_my_frame(frame,[0,constr_loc,0,frame.shape[0]])\\r\\n if blur_im is True:\\r\\n frame = cv2.blur(frame,(3,3))\\r\\n # expect the pixel values to be 0 or 255 (some max) so...\\r\\n frame = np.uint8(frame)\\r\\n if invert is True:\\r\\n frame = np.invert(frame)\\r\\n return frame\",\n \"def captureNextFrame(self):\\r\\n mainls = []\\r\\n\\r\\n\\r\\n ret, readFrame = self.capture.read()\\r\\n\\r\\n if (ret == True):\\r\\n self.currentFrame = cv2.cvtColor(readFrame, cv2.COLOR_BGR2RGB)\\r\\n self.faceDetection(self.currentFrame)\\r\\n self.currentFrame = self.bbFrame\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def preprocess(self):\\n pass\",\n \"def prepareFrameCache(self, frame, cacheType): # real signature unknown; restored from __doc__\\n pass\",\n \"def read(self):\\r\\n frame = self.last_frame\\r\\n return frame\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def dispatch_frame(self, frame):\",\n \"def get_frame(self, ind):\\n pass\",\n \"def read_frame(self):\\n return self.decode_frame(self.grab_frame())\",\n \"def observation(self, frame):\\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\\n return frame\",\n \"def on_pre_render(self, event, signal):\\n t = ppb.get_time() - self.start_time\\n self.frames += 1\\n print(f\\\"Frame {self.frames} rendered at {t}\\\")\",\n \"def get_image(self):\\n self.flush_buffer()\\n _, frame = self.cam.read()\\n shift_frame = self.perspective_shift(frame)\\n #shift_frame = None\\n return frame, shift_frame\",\n \"def processFrame(frame, shape=(84, 84)):\\n frame = frame.astype(np.uint8) # cv2 requires np.uint8\\n # Apply a rgb filter to convert RGB to Gray Scale\\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\\n # crop image OpenCv2 function to format img[y:y + h, x:x + w]\\n frame = frame[34:34+160, :160] # crop image\\n frame = cv2.resize(frame, shape, interpolation=cv2.INTER_NEAREST)\\n frame = frame.reshape((*shape, 1))\\n #cv2.imshow('Cropped Image', frame)\\n\\n return frame\",\n \"def add_frame(R):\\n\\n x_frames.append(copy.copy(R[0]))\\n y_frames.append(copy.copy(R[1]))\\n z_frames.append(copy.copy(R[2]))\",\n \"def _make_process_op(self):\\n\\n with tf.variable_scope(\\\"state_preprocess\\\"):\\n self.input_state = tf.placeholder(shape=[210, 160, 3], dtype=tf.uint8)\\n output = tf.image.rgb_to_grayscale(self.input_state)\\n output = tf.image.crop_to_bounding_box(output, 34, 0, 160, 160)\\n output = tf.image.resize_images(output, [84, 84], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n output = tf.to_float(output) / 255.0\\n output = tf.transpose(output, perm=[2, 1, 0])\\n\\n return output\",\n \"def create_frame_blob(self):\\n # self.image_blob = cv2.dnn.blobFromImage(\\n # cv2.resize(self.frame, (300, 300)), 1.0, (300, 300),\\n # (104.0, 177.0, 123.0), swapRB=False, crop=False)\\n self.image_blob = cv2.dnn.blobFromImage(cv2.resize(self.frame, (300, 300)),\\n 0.007843, (300, 300), 127.5)\",\n \"def registerDepthFrame(self, frame):\\n h, w = frame.shape[:2]\\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\\n\\n return frame\",\n \"def gen_prologue(self, frame): # pragma: no cover\\n raise NotImplementedError(\\\"Implement this!\\\")\",\n \"def preprocess_dataframe(self, dataframe):\\n return dataframe\",\n \"def get_frame(self):\\n return opencv.highgui.cvQueryFrame(self.capture)\",\n \"def captureNextFrame(self):\\n ret, readFrame=self.capture.read()\\n if(ret==True):\\n self.currentFrame=cv2.cvtColor(readFrame,cv2.COLOR_BGR2RGB)\",\n \"def style_transfer_postprocess(preprocessed_frame: np.ndarray, image_shape: tuple):\\n\\n postprocessed_frame = np.squeeze(preprocessed_frame, axis=0)\\n # select original height and width from image_shape\\n frame_height = image_shape[0]\\n frame_width = image_shape[1]\\n postprocessed_frame = cv2.resize(postprocessed_frame, (frame_width, frame_height)).astype(\\\"float32\\\") * 255\\n postprocessed_frame = cv2.cvtColor(postprocessed_frame, cv2.COLOR_RGB2BGR)\\n\\n return postprocessed_frame\",\n \"def training_frame(self):\\n return self._parms.get(\\\"training_frame\\\")\",\n \"def run_frame(self, image):\\n self.frame_idx += 1\\n # run main pipeline\\n t0 = datetime.now()\\n disp = self.main_pipeline(image)\\n t1 = datetime.now()\\n logging.info('main pipeline: {}'.format(get_tdiff(t0, t1)))\\n \\n # prepare image sequence of 3 for trajectory pipeline\\n t0 = datetime.now()\\n self.image_seq.append(image)\\n if len(self.image_seq) > 3:\\n del self.image_seq[0]\\n t1 = datetime.now()\\n logging.info('image stack: {}'.format(get_tdiff(t0, t1)))\\n\\n # run trajectory pipeline\\n t0 = datetime.now()\\n if len(self.image_seq) >= 3:\\n self.egomo_trmat = self.traj_pipeline(prev_trmat=self.egomo_trmat)\\n t1 = datetime.now()\\n logging.info('traj pipeline: {}'.format(get_tdiff(t0, t1)))\\n return self.frame_idx, disp, self.egomo_trmat, self.t_list\",\n \"def _preprocess(self, data):\\n transformed_data = _copy(data)\\n for name, step in self._transformers[:-1]:\\n transformed_data = step.fit_transform(transformed_data)\\n if type(transformed_data) != _tc.SFrame:\\n raise RuntimeError(\\\"The transform function in step '%s' did not\\\"\\n \\\" return an SFrame (got %s instead).\\\" % (name,\\n type(transformed_data).__name__))\\n return transformed_data\",\n \"def process(self, data) :\\n rData = Core.Processlib.Data()\\n rData.frameNumber = data.frameNumber\\n rData.buffer = self._worker.process(data.buffer)\\n if self._writer: #optional HDF5 writer\\n self._writer.write(rData.buffer, rData.frameNumber)\\n return rData\",\n \"def observation(self, frame):\\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\\n return frame[:, :, None]\",\n \"def observation(self, frame):\\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\\n frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\\n return frame[:, :, None]\",\n \"def new_frame(self):\\n self.eyes_frame = numpy.zeros(self.shape, numpy.uint8)\",\n \"def fit_transform(self, pgframe):\\n self.fit(pgframe)\\n return self.transform(pgframe)\",\n \"def test_preprocess_capture():\\n X = preprocess_capture(\\\"capture.pcapng\\\")\\n X.fillna(0, inplace=True)\\n print(X.head())\\n print(X.axes)\",\n \"def frame(self):\\n return self._frame\",\n \"def frame(self):\\n return self._frame\",\n \"def frame(self):\\n return self._frame\",\n \"def get_frame_data(self):\\n # FrameObject is a dictionary of slot names and values.\\n frameObject = self.pgdb.sendPgdbFnCall('get-frame-object', self.frameid)\\n if not frameObject:\\n raise PythonCycError(\\\"Could not retrieve frame \\\"+self.frameid+\\\" from organism (orgid) \\\"+self.pgdb._orgid)\\n else:\\n self._gotframe = True\\n # Modify slot names to allow Python's syntax (e.g., '_' instead of '-').\\n for slot in frameObject:\\n self.__dict__[convertLispIdtoPythonId(slot)] = frameObject[slot]\\n return self\",\n \"def get_frame(self):\\n return self.frame\",\n \"def genFrame(self):\\n # generate frame-specific data\\n frameData = self._genFrameData()\\n\\n # call parent function to create the complete frame (as bytearray)\\n frame = self._genDigiMeshFrame(frameData)\\n\\n # OBS: never escape-sequence local msg\\n return frame\",\n \"def preprocess_graph(self):\\n image = tf.placeholder(\\n tf.float32,\\n shape=[self.img_h, self.img_w, self.col_channels])\\n patches = self.create_patches(image)\\n return {'image': image,\\n 'patches': patches}\",\n \"def process(self, frame):\\n frame = preprocess(frame)\\n\\n edges = find_edges(frame)\\n circles = find_circles(frame, self.frame_count, edges)\\n\\n points = find_points(circles, self.points, self.frame_count)\\n self.points = points\\n\\n acceptable = filter(lambda p: p.quality > 0.25, self.points)\\n\\n dead_clusters = []\\n for cluster in self.clusters:\\n cluster.clean(self.frame_count)\\n\\n if cluster.is_dead:\\n dead_clusters.append(cluster)\\n\\n for cluster in dead_clusters:\\n self.clusters.remove(cluster)\\n\\n clusters = find_clusters(acceptable, self.clusters, max_length = 3)\\n self.clusters = clusters\\n\\n self.frame_count += 1\\n\\n self.frames.put((self.name, self.frame_count, frame, points, clusters))\",\n \"def __init__(self, x: tf.Tensor):\\n self.__frame = x\",\n \"def process(frame, bgModel):\\n \\n # subtract background if background object has been saved. Otherwise, just resize image \\n if bgModel != 0:\\n frame_nobg = remove_background(frame, bgModel)\\n\\n # resize image\\n frame_nobg = cv2.resize(frame_nobg, dsize=(256,144), interpolation=cv2.INTER_LINEAR)\\n\\n # turn non-black pixels white\\n frame_processed = np.zeros(frame_nobg.shape, dtype=np.uint8)\\n frame_processed[frame_nobg>0] = 255 \\n else:\\n frame_processed = cv2.resize(frame, dsize=(256,144), interpolation=cv2.INTER_LINEAR)\\n\\n # convert the image into binary image to reduce file size\\n frame_processed = cv2.cvtColor(frame_processed, cv2.COLOR_BGR2GRAY)\\n\\n # Expand dimensions since the model expects images to have shape: [1, 144, 256, 3]\\n frame_prediction = frame_processed.astype(np.float)\\n frame_prediction = np.stack((frame_prediction,)*3, axis=-1)\\n frame_prediction /= 255\\n frame_prediction = np.expand_dims(frame_prediction, axis=0)\\n\\n return [frame_processed, frame_prediction]\",\n \"def _create_pgframe(nodes=None, edges=None):\\n pass\",\n \"def classical_preprocessing(*args, **kwargs):\\r\\n qnode.construct(args, kwargs)\\r\\n return qml.math.stack(qnode.qtape.get_parameters())\",\n \"def grabRawFrame(self):\\r\\n \\r\\n self.surface = self.capture.get_image(self.surface)\\r\\n width, height = self.surface.get_size()\\r\\n return pygame.image.tostring(self.surface, 'RGB'), width, height, 1\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def pre_process(self):\\n pass\",\n \"def convertFrame(self):\\n try:\\n img = QImage(self.currentVideoFrame,\\n self.currentVideoFrame.shape[1],\\n self.currentVideoFrame.shape[0],\\n QImage.Format_RGB888\\n )\\n return img\\n except:\\n return None\",\n \"def convertFrame(self):\\n try:\\n img = QImage(self.currentVideoFrame,\\n self.currentVideoFrame.shape[1],\\n self.currentVideoFrame.shape[0],\\n QImage.Format_RGB888\\n )\\n return img\\n except:\\n return None\",\n \"def get_frame(self, row):\\n\\n if row not in self.frames:\\n if not self.write:\\n d = self.memmap[row, :, :]\\n if self.file.metadata['interleave'] == 'bil':\\n d = d.T\\n self.frames[row] = d.copy()\\n else:\\n self.frames[row] = s.nan * s.zeros((self.n_cols, self.n_bands))\\n return self.frames[row]\",\n \"def _getframe(depth=None): # real signature unknown; restored from __doc__\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7119568","0.6751297","0.67064327","0.6306198","0.6134869","0.6000026","0.5978636","0.59715766","0.59634686","0.5920147","0.5843046","0.58087265","0.57635844","0.5748316","0.5747666","0.57154405","0.5696114","0.56948686","0.5672049","0.56586546","0.56557393","0.5631645","0.5622552","0.55870837","0.5578154","0.55507666","0.5548948","0.5548778","0.5524303","0.5509201","0.54998285","0.5484497","0.5475242","0.5462567","0.5450457","0.5426465","0.5416499","0.54160166","0.5407831","0.54028803","0.5397196","0.5392446","0.53916746","0.53834575","0.53834575","0.53834575","0.5374916","0.53661436","0.5365089","0.5365089","0.5365089","0.5365089","0.5365089","0.5365026","0.5361406","0.5360967","0.5357866","0.5341887","0.5328269","0.53214717","0.53214544","0.53211904","0.5317872","0.5309569","0.53031534","0.5302839","0.5299585","0.5296317","0.5296153","0.5292539","0.52895284","0.5282028","0.5279851","0.5273841","0.5273841","0.52616525","0.52598226","0.5253911","0.5250991","0.5250991","0.5250991","0.5243838","0.52398425","0.5230763","0.5219121","0.5218299","0.5215393","0.5215145","0.5214665","0.5214649","0.52138746","0.5208141","0.5208141","0.5208141","0.5208141","0.5208141","0.52053195","0.52053195","0.5203812","0.51839644"],"string":"[\n \"0.7119568\",\n \"0.6751297\",\n \"0.67064327\",\n \"0.6306198\",\n \"0.6134869\",\n \"0.6000026\",\n \"0.5978636\",\n \"0.59715766\",\n \"0.59634686\",\n \"0.5920147\",\n \"0.5843046\",\n \"0.58087265\",\n \"0.57635844\",\n \"0.5748316\",\n \"0.5747666\",\n \"0.57154405\",\n \"0.5696114\",\n \"0.56948686\",\n \"0.5672049\",\n \"0.56586546\",\n \"0.56557393\",\n \"0.5631645\",\n \"0.5622552\",\n \"0.55870837\",\n \"0.5578154\",\n \"0.55507666\",\n \"0.5548948\",\n \"0.5548778\",\n \"0.5524303\",\n \"0.5509201\",\n \"0.54998285\",\n \"0.5484497\",\n \"0.5475242\",\n \"0.5462567\",\n \"0.5450457\",\n \"0.5426465\",\n \"0.5416499\",\n \"0.54160166\",\n \"0.5407831\",\n \"0.54028803\",\n \"0.5397196\",\n \"0.5392446\",\n \"0.53916746\",\n \"0.53834575\",\n \"0.53834575\",\n \"0.53834575\",\n \"0.5374916\",\n \"0.53661436\",\n \"0.5365089\",\n \"0.5365089\",\n \"0.5365089\",\n \"0.5365089\",\n \"0.5365089\",\n \"0.5365026\",\n \"0.5361406\",\n \"0.5360967\",\n \"0.5357866\",\n \"0.5341887\",\n \"0.5328269\",\n \"0.53214717\",\n \"0.53214544\",\n \"0.53211904\",\n \"0.5317872\",\n \"0.5309569\",\n \"0.53031534\",\n \"0.5302839\",\n \"0.5299585\",\n \"0.5296317\",\n \"0.5296153\",\n \"0.5292539\",\n \"0.52895284\",\n \"0.5282028\",\n \"0.5279851\",\n \"0.5273841\",\n \"0.5273841\",\n \"0.52616525\",\n \"0.52598226\",\n \"0.5253911\",\n \"0.5250991\",\n \"0.5250991\",\n \"0.5250991\",\n \"0.5243838\",\n \"0.52398425\",\n \"0.5230763\",\n \"0.5219121\",\n \"0.5218299\",\n \"0.5215393\",\n \"0.5215145\",\n \"0.5214665\",\n \"0.5214649\",\n \"0.52138746\",\n \"0.5208141\",\n \"0.5208141\",\n \"0.5208141\",\n \"0.5208141\",\n \"0.5208141\",\n \"0.52053195\",\n \"0.52053195\",\n \"0.5203812\",\n \"0.51839644\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5511134"},"document_rank":{"kind":"string","value":"29"}}},{"rowIdx":93077,"cells":{"query":{"kind":"string","value":"preprocess a video frame input in the format specified by rawinputformat() method output in the format required by the graph"},"document":{"kind":"string","value":"def preprocess(img):\n dim=(227,227)\n resize_width = 224\n resize_height = 224\n\n img=cv2.resize(img,dim)\n #img=cv2.normalize(img,None,alpha=0,beta=1,norm_type=cv2.NORM_MINMAX,dtype=cv2.CV_32F)\n img = img.astype(numpy.float32)\n\n #Preprocess image changing the RGB pixel values to\t the values the network needs\n # to do this we subtract the mean and multiply the std for each channel (R, G and B)\n # these mean and std values come from the stat.txt file that must accompany the\n # graph file for the network.\n \n img[:,:,0] = (img[:,:,0] - gNetworkMean[0])\n img[:,:,1] = (img[:,:,1] - gNetworkMean[1])\n img[:,:,2] = (img[:,:,2] - gNetworkMean[2])\n \n\n # Finally we return the values as Float16 rather than Float32 as that is what the network expects.\n cv2.imshow(\"Frame\", img)\n return img.astype('float16') #age_float_array.astype(numpy.float16)"},"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 process_video(input_file, output_file):\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\n video = VideoFileClip(input_file)\n annotated_video = video.fl_image(process_pipeline)\n annotated_video.write_videofile(output_file, audio=False)","def process_video(input_file, output_file):\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\n video = VideoFileClip(input_file)\n annotated_video = video.fl_image(process_pipeline)\n annotated_video.write_videofile(output_file, audio=False)","def process_video(input_file, output_file):\n with open('all-features-rbf-svm.p', 'rb') as svm_fd:\n clf = pickle.load(svm_fd)\n with open('all-features-scaler.p', 'rb') as scaler_fd:\n hog_scaler = pickle.load(scaler_fd)\n hog_parameters = HogParameters(orientations=18, pixels_per_cell=8, cells_per_block=2)\n clip = VideoFileClip(input_file)\n test_clip = clip.fl_image(\n lambda frame: process_frame(frame, clf=clf, norm_scaler=hog_scaler, hog_parameters=hog_parameters, spatial_size=(16, 16), hist_bins=32))\n test_clip.write_videofile(output_file, audio=False)","def preprocess_sample(file, params):\n\n videoFile = file + \".mp4\"\n audioFile = file + \".wav\"\n roiFile = file + \".png\"\n visualFeaturesFile = file + \".npy\"\n\n roiSize = params[\"roiSize\"]\n normMean = params[\"normMean\"]\n normStd = params[\"normStd\"]\n vf = params[\"vf\"]\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\n #Extract the audio from the video file using the FFmpeg utility and save it to a wav file.\n v2aCommand = \"ffmpeg -y -v quiet -i \" + videoFile + \" -ac 1 -ar 16000 -vn \" + audioFile\n os.system(v2aCommand)\n\n\n #for each frame, resize to 224x224 and crop the central 112x112 region\n captureObj = cv.VideoCapture(videoFile)\n roiSequence = list()\n while (captureObj.isOpened()):\n ret, frame = captureObj.read()\n if ret == True:\n grayed = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\n grayed = grayed/255\n grayed = cv.resize(grayed, (224,224))\n roi = grayed[int(112-(roiSize/2)):int(112+(roiSize/2)), int(112-(roiSize/2)):int(112+(roiSize/2))]\n roiSequence.append(roi)\n else:\n break\n captureObj.release()\n cv.imwrite(roiFile, np.floor(255*np.concatenate(roiSequence, axis=1)).astype(np.int))\n\n\n #normalise the frames and extract features for each frame using the visual frontend\n #save the visual features to a .npy file\n inp = np.stack(roiSequence, axis=0)\n inp = np.expand_dims(inp, axis=[1,2])\n inp = (inp - normMean)/normStd\n inputBatch = torch.from_numpy(inp)\n inputBatch = (inputBatch.float()).to(device)\n vf.eval()\n with torch.no_grad():\n outputBatch = vf(inputBatch)\n out = torch.squeeze(outputBatch, dim=1)\n out = out.cpu().numpy()\n np.save(visualFeaturesFile, out)\n return","def make_video(data,\n xdim, ydim, sample_read_rows, sample_read_cols, image_write_rows, image_write_cols,\n directory, filename, fps = 24.0, start_frame = 1, end_frame = None, timestamp = False, fontsize = 30, ts_pos = (0,0), save_raw = False):\n\n #Command to send via the command prompt which specifies the pipe parameters\n # command = ['ffmpeg',\n # '-y', # (optional) overwrite output file if it exists\n # '-f', 'image2pipe',\n # '-vcodec', 'mjpeg', #'mjpeg',\n # '-r', '1',\n # '-r', str(fps), # frames per second\n # '-i', '-', # The input comes from a pipe\n # '-an', # Tells FFMPEG not to expect any audio\n # '-vcodec', 'mpeg4',\n # '-b:v', '5000k',\n # directory + filename + \"/\"+filename+\".mp4\",\n # '-hide_banner',\n # '-loglevel', 'panic']\n\n # Create directories if they don't exist\n if not os.path.exists(os.path.join(directory, filename, 'frames/')):\n os.makedirs(os.path.join(directory, filename, 'frames/'))\n if save_raw and not os.path.exists(os.path.join(directory, filename, 'frames-raw/')):\n os.makedirs(os.path.join(directory, filename, 'frames-raw/'))\n\n if end_frame == None:\n end_frame = data.FrameCount\n\n cm = colormap.get_cmap('viridis')\n\n for i, frame_offset in enumerate(tqdm.tqdm(range(start_frame, end_frame))):\n frame = FrameRead(data, frame_offset)\n frame_image = np.zeros([ydim, xdim], dtype=np.uint8)\n frame_image[image_write_rows, image_write_cols] = frame.frame_data[sample_read_rows, sample_read_cols]\n\n rgb_im = Image.fromarray(cm(frame_image, bytes=True)).convert('RGB')\n rgb_im.save(os.path.join(directory, filename, 'frames/', f'{i}.jpg'), 'JPEG')\n\n if save_raw:\n Image.fromarray(np.uint8(frame.frame_data), mode='L').save(os.path.join(directory, filename, 'frames-raw/', f'{i}.jpg'), 'JPEG')","def preprocess(self, data):\n (w,h,f) = self.rawinputformat()\n dt = numpy.dtype(numpy.uint8)\n nb = numpy.frombuffer(data,dt,-1,0)\n actual_stream_width = (w&1)+w # hack, rather get this from the app sink\n if(actual_stream_width != self.reqsize):\n nb = nb.reshape(h,actual_stream_width,3)\n nb = nb[0:h,0:w,0:3] # crop to network input size\n else:\n nb = nb.reshape((actual_stream_width,actual_stream_width,3))\n img = nb.astype('float32')\n #Preprocess image\n #for i in range(3):\n # img[:,:,i] = (img[:,:,i] - self.mean[i]) * self.std[i]\n #img = resize(img/255.0,(w,h),1)\n img = img/255.0\n print(img.shape)\n #print(img[0,0,:])\n return img.astype(numpy.float16)","def process_group(pattern, params):\n # check subdirectory according to filter options\n subdir = params['label']\n # and the parameters label\n print 'Processing:', subdir\n\n # search for videos matching the pattern\n search = os.path.join(ROOT_RAWDATA_DIR, pattern)\n print 'Search pattern:', search\n flist = sorted(glob.glob(search))\n\n # for each matching video\n for f in flist:\n # video structures (copied from LEGOS FTP) is yyyymmdd/HH/MM.mp4\n # and we want to store frames as yyyymmdd/yyyymmdd_HH/yyyymmdd_HHMM/yyyymmdd_HHMM_<index>.<format>\n # so: recursively split to extract basename, hour and date\n p, fname = os.path.split(f)\n p, hour = os.path.split(p)\n p, date = os.path.split(p)\n minute, _ = os.path.splitext(fname)\n # compute output dir, and prefix for frames\n outdir = os.path.join(ROOT_PREPROC_DIR,\n subdir, # according to parameters\n date,\n '{}_{}'.format(date, hour),\n '{}_{}{}'.format(date, hour, minute),\n )\n prefix = '{}_{}{}_'.format(date, hour, minute)\n # create output directory if neeeded\n if not os.path.exists(outdir):\n print 'Creating output directory', outdir\n os.makedirs(outdir, 0755)\n # call decoder\n command = ['python', '-u', 'decoder.py',\n f,\n '-o', outdir,\n '-p', prefix,\n '-l', params['label'],\n '-f', str(params['image_format']),\n '-m', str(params['median_length']),\n '-r', str(params['resolution']),\n '-O', str(params['origin'][0]), str(params['origin'][1]),\n '-d', str(params['dimensions'][0]), str(params['dimensions'][1]),\n '-a', str(params['rotation']),\n ]\n subprocess.call(command)","def preprocess(image):\n image = rgb2yuv(image)\n return image","def main(_):\n print('argument to expand', ARGS.video_in)\n print('argument expanded', glob.glob(ARGS.video_in))\n video_count = 0\n for video_filename in glob.glob(ARGS.video_in):\n print('start parsing', video_filename)\n data = skvideo.io.ffprobe(video_filename)['video']\n rate_str = six.ensure_str(data['@r_frame_rate']).split('/')\n rate = float(rate_str[0]) / float(rate_str[1])\n print('detected frame rate:', rate)\n\n print('load frames:')\n video = skvideo.io.vreader(video_filename)\n frame_count = 0\n file_count = 0\n for frame in video:\n if (frame_count > ARGS.offset) and \\\n ((frame_count-ARGS.offset)%ARGS.skip == 0) and \\\n (frame_count/rate >= ARGS.from_s) and \\\n (frame_count/rate <= ARGS.to_s or ARGS.to_s == -1):\n print(frame_count,)\n img = Image.fromarray(frame)\n if ARGS.crop:\n img = crop(img, ARGS.size)\n # save file\n file_number = file_count + video_count * ARGS.multiple + ARGS.start\n if ARGS.format_ext.lower() == 'jpg':\n file_out = os.path.join(ARGS.path_out,\n 'f{:07d}.jpg'.format(file_number))\n img.save(file_out, 'JPEG')\n elif ARGS.format_ext.lower() == 'png':\n file_out = os.path.join(ARGS.path_out,\n 'f{:07d}.png'.format(file_number))\n img.save(file_out, 'PNG')\n else:\n print('unrecognize format', ARGS.format_ext)\n sys.exit()\n file_count += 1\n frame_count += 1\n video_count += 1","def transcode(self) -> None:\n # Get source mediainfo to use in validation\n source_media_info = self.get_media_info(self.source)\n\n # Common ffmpeg flags\n ff = FFMPEG(overwrite=True, loglevel='repeat+level+info')\n # Init source file\n ff < SourceFile(self.source)\n # Scaling\n fc = ff.init_filter_complex()\n fc.video | Scale(**TRANSCODING_OPTIONS[SCALE]) | fc.get_video_dest(0)\n\n # set group of pixels length to segment size\n gop = math.floor(source_media_info[VIDEO_FRAME_RATE] * GOP_DURATION)\n # preserve source audio sampling rate\n arate = source_media_info[AUDIO_SAMPLING_RATE]\n # preserve original video FPS\n vrate = source_media_info[VIDEO_FRAME_RATE]\n # codecs, muxer and output path\n\n cv0 = VideoCodec(\n gop=gop,\n vrate=vrate,\n **TRANSCODING_OPTIONS[VIDEO_CODEC])\n ca0 = AudioCodec(\n arate=arate,\n **TRANSCODING_OPTIONS[AUDIO_CODEC])\n out0 = Muxer(self.destination, format='mp4')\n\n # Add output file to ffmpeg\n ff.add_output(out0, cv0, ca0)\n\n # Run ffmpeg\n self.run(ff)\n\n # Get result mediainfo\n dest_media_info = self.get_media_info(self.destination)\n\n # Validate ffmpeg result\n self.validate(source_media_info, dest_media_info)","def vid2tensor( self, current_frame):","def process_video(data_info, name, mode, is_training=True):\r\n data = Action_Dataset(name, mode, [data_info])\r\n if is_training:\r\n clip_seq, label_seq = data.next_batch(1, _CLIP_SIZE)\r\n else:\r\n clip_seq, label_seq = data.next_batch(\r\n 1, _EACH_VIDEO_TEST_SIZE+1, shuffle=False, data_augment=False)\r\n clip_seq = 2*(clip_seq/255) - 1\r\n clip_seq = np.array(clip_seq, dtype='float32')\r\n return clip_seq, label_seq","def _preprocess(self, ob):\n # Take the max over prev and current frames.\n if self.last_frame is not None:\n ob_comb = np.maximum(ob, self.last_frame)\n else:\n ob_comb = ob\n self.last_frame = ob\n\n # Convert to YUV, extract Y, resize, and crop.\n r, g, b = ob_comb[:, :, 0], ob_comb[:, :, 1], ob_comb[:, :, 2]\n y = 0.299 * r + 0.587 * g + 0.114 * b\n y_resized = cv2.resize(y, (84, 110), interpolation=cv2.INTER_LINEAR)\n y_cropped = y_resized[13:-13, :]\n return y_cropped","def process_video(self):\n if os.path.isfile(self.source):\n self.cap = cv2.VideoCapture(self.source)\n else:\n try:\n file_name = \"input.mp4\"\n self.source = self.source.replace('open', 'uc')\n print( \"\\nDownloading video file from drive link to %s\\n\"%file_name)\n gdown.download(self.source, file_name, quiet=False)\n print( \"%s downloaded!\\n\"%file_name )\n self.cap = cv2.VideoCapture(file_name)\n except Exception:\n raise RuntimeError(\"Invalid source input, please specify a Google drive link or a downloaded local file as input \\n\")\n\n\n assert self.cap.isOpened(), \"Failed to open %s\" % self.source\n\n self.w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n self.h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n self.fps = self.cap.get(cv2.CAP_PROP_FPS) \n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\n return","def __init__(self, input_file_path, convert_to_bgr=False):\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\n print('After INSTANTIATION')\n self.__yuv_video.start()","def reencode(filepath, loglevel='panic'):\n try:\n import ffmpeg\n except ImportError:\n logger.error(\n 'Import Error! Cant import ffmpeg. '\n 'Annotations operations will be limited. import manually and fix errors')\n raise\n if not os.path.isfile(filepath):\n raise IOError('File doesnt exists: {}'.format(filepath))\n # re encode video without b frame and as mp4\n basename, ext = os.path.splitext(filepath)\n output_filepath = os.path.join(basename, os.path.basename(filepath).replace(ext, '.mp4'))\n if not os.path.isdir(os.path.dirname(output_filepath)):\n os.makedirs(os.path.dirname(output_filepath))\n try:\n stream = ffmpeg.input(filepath, **{'loglevel': loglevel}).output(output_filepath,\n **{'x264opts': 'bframes=0',\n 'f': 'mp4'})\n ffmpeg.overwrite_output(stream).run()\n except Exception as e:\n logger.exception('ffmpeg error in disassemble:')\n raise\n\n output_probe = Videos.get_info(output_filepath)\n start_time = eval(output_probe['streams'][0]['start_time'])\n fps = eval(output_probe['streams'][0]['avg_frame_rate'])\n has_b_frames = output_probe['streams'][0]['has_b_frames']\n start_frame = fps * start_time\n if start_time != 0:\n logger.warning('Video start_time is not 0!')\n if has_b_frames != 0:\n logger.warning('Video still has b frames!')\n return output_filepath","def video_process(threshold=THRESHOLD, inputpath=INPUTPATH, file=FILE):\n #create video capture object\n cap = cv2.VideoCapture(f'{inputpath}{file}')\n name = file.split('/')[-1].split('.')[0]\n frame_sqrs_list = []\n if (cap.isOpened()==False):\n logging.error('Error opening video stream or file')\n model = load_model()\n frame_n = 1\n print('model loaded')\n while(cap.isOpened()):\n #capture frame-by-frame\n ret, frame = cap.read()\n if ret == True:\n squares_list = img_preprocess(frame)\n frame_n = frame_n+1\n print(f'enter video file, frame{frame_n}')\n x_list = []\n y_list = []\n for sq in squares_list:\n predict = predict_hot_pxl(sq.sq, model)\n if predict > threshold:\n pred = 1\n print('ERROR')\n x_list.append(sq.y)\n y_list.append(sq.x)\n # draw square around error in frame:\n # FIXME: save a square to a list of squares\n continue\n else:\n pred = 0\n print('no error')\n # FIXME: draw_sqr(name, frame, frame_n, !!! PASS LIST INSTEAD !!! and rewrite the draw func to draw several squares sq.y, sq.x) \n sq = sq._replace(pred_float = predict)\n sq = sq._replace(pred_int = pred)\n # dict element sq is now obsolete, remove it\n sq = sq._replace(sq = None)\n # save single frame with squares marking errors as png to disc:\n draw_sqr(name, frame, frame_n, x_list, y_list)\n frame_sqrs_list.append(sq)\n # Break the loop\n else:\n break\n return name, frame_sqrs_list","def get_videoinput_bin(self):\r\n raise NotImplementedError","def run(input_video_file, output_video_file):\n print(\"Debut de la transformation du format de la video\")\n #récupération de la vidéo\n video = cv2.VideoCapture(input_video_file)\n #fps de la vidéo\n fps = video.get(cv2.CAP_PROP_FPS)\n #largeur des images de la vidéo\n width_video = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))\n #hauteur des images de la vidéo\n height_video = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))\n #nombre d'images dans la vidéo\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\n #durée de la vidéo\n duration = frame_count/fps\n #nouvelle durée de la vidéo (on arrondi)\n new_duration = math.floor(duration)\n #nouveau fps de la vidéo\n new_fps = float(round(fps))\n #appliquer le nouveau fps\n video.set(cv2.CAP_PROP_FPS,new_fps)\n #appliquer la nouvelle durée\n print(new_duration)\n print(new_fps)\n print(new_duration*new_fps)\n new_frame_count = new_duration*new_fps\n video.set(cv2.CAP_PROP_FRAME_COUNT,new_duration*new_fps)\n #déffinition du format de la vidéo en sortie\n video_out = cv2.VideoWriter(output_video_file,0x7634706d,new_fps,(width_video,height_video),True)\n \n count = 0\n #ouverture de la vidéo\n while(video.isOpened()):\n #lecture image par image\n ret, frame = video.read()\n if ret==True:\n\n #ecriture de l'image dans la vidéo en sortie\n video_out.write(frame)\n count = count + 1\n \n if (count > (new_frame_count-1)):\n # Libérer la vidéo\n video.release()\n break\n else:\n break\n\n print(\"fin de la transformation\")\n #fermer les vidéos\n video.release()\n video_out.release()","def create_video(input_file, output_file):\n input_video = VideoFileClip(input_file)\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\n output_video.write_videofile(output_file, audio=False)","def check_video_format(movie_file, desired_format='.mp4', original_format='.avi'):\n\n if not os.path.isfile(movie_file+original_format):\n print 'Error. avi file does not exist:'+movie_file+'.avi'\n if not os.path.isfile(movie_file+desired_format):\n cmd = ['ffmpeg']\n cmd += ['-i', movie_file+original_format]\n cmd += [movie_file+desired_format]\n cmd_string = ''.join([\"%s \" % el for el in cmd])\n #print '-->Running: ', cmd_string\n p = subprocess.Popen(cmd, shell=False)\n p.wait()","def model_callback(self, output_sample_timestamp, frames):\n logger.debug(\"Output score at timestamp \" + str(output_sample_timestamp))\n output_sample_index = [i for i, f in enumerate(frames) if f[\"dts\"] < output_sample_timestamp][-1]\n\n # only get the relevant frames from the chunk\n frames = utils.get_chunk(frames, output_sample_index, type=\"video\")\n\n first_frame = frames[0]\n if self.mode == 0:\n # average the bitrate for all of the segments\n bitrate = np.mean([f[\"bitrate\"] for f in frames])\n score = P1203Pv.video_model_function_mode0(\n utils.resolution_to_number(first_frame[\"resolution\"]),\n utils.resolution_to_number(self.display_res),\n bitrate,\n first_frame[\"fps\"]\n )\n self.o22.append(score)\n return\n\n elif self.mode == 1:\n # average the bitrate based on the frame sizes, as implemented\n # in submitted model code\n compensated_sizes = [\n utils.calculate_compensated_size(f[\"type\"], f[\"size\"], f[\"dts\"]) for f in frames\n ]\n duration = np.sum([f[\"duration\"] for f in frames])\n bitrate = np.sum(compensated_sizes) * 8 / duration / 1000\n score = P1203Pv.video_model_function_mode1(\n utils.resolution_to_number(first_frame[\"resolution\"]),\n utils.resolution_to_number(self.display_res),\n bitrate,\n first_frame[\"fps\"],\n frames\n )\n self.o22.append(score)\n return\n\n elif self.mode == 2:\n score = P1203Pv.video_model_function_mode2(\n utils.resolution_to_number(first_frame[\"resolution\"]),\n utils.resolution_to_number(self.display_res),\n first_frame[\"fps\"],\n frames\n )\n self.o22.append(score)\n return\n\n elif self.mode == 3:\n score = P1203Pv.video_model_function_mode3(\n utils.resolution_to_number(first_frame[\"resolution\"]),\n utils.resolution_to_number(self.display_res),\n first_frame[\"fps\"],\n frames\n )\n self.o22.append(score)\n return\n\n else:\n raise P1203StandaloneError(\"Unsupported mode: {}\".format(self.mode))","def tagVideo(modelpath, videopath, outputPath=None): \n model = get_model_instance_segmentation(3)\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n # model.load_state_dict(torch.load(modelpath, map_location=device), strict=False)\n model.load_state_dict(torch.load(modelpath, map_location=device))\n model = model.to(device)\n model.eval()\n\n \n data_transform = transforms.Compose([\n ToPILImage(),\n transforms.ToTensor(), \n ])\n\n\n if outputPath:\n writer = FFmpegWriter(str(outputPath))\n \n font = cv2.FONT_HERSHEY_SIMPLEX\n cv2.namedWindow('main', cv2.WINDOW_NORMAL)\n labels = ['No mask', 'Mask']\n labelColor = [(10, 0, 255), (10, 255, 0)]\n img_count = 0\n outputDir = os.path.dirname(os.path.realpath(outputPath))\n frame_count = 0\n boundingBoxes = []\n for frame in vreader(str(videopath)):\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n print('Frame:', frame_count)\n\n if frame_count%30==0:\n frameTensor = data_transform(frame)\n frameTensor = torch.unsqueeze(frameTensor, 0).to(device)\n output = model(frameTensor)\n boundingBoxes = plot_image_new(frame, frameTensor[0], output[0]) \n \n if len(boundingBoxes)>0:\n for bb in boundingBoxes:\n cv2.rectangle(frame,\n (bb[0], bb[1]),\n (bb[2], bb[3]),\n (54, 66, 227),\n thickness=2)\n\n cv2.imshow('main', frame)\n if outputPath:\n writer.writeFrame(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n frame_count += 1\n if outputPath:\n writer.close()\n cv2.destroyAllWindows()","def extract_vob(in_vob, guid):\n\t#Detect interlacing.\n\tmediainfo_command = \"mediainfo --Inform='Video;%ScanType%,%ScanOrder%' \" + in_vob\n\tprint(mediainfo_command)\n\tprocess = subprocess.Popen(mediainfo_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\t(cout, cerr) = process.communicate()\n\texit_code = process.wait()\n\tif exit_code != 0:\n\t\traise Exception(\"Calling Mediainfo on {in_vob} failed with exit code {exit_code}.\".format(in_vob=in_vob, exit_code=exit_code))\n\tmediainfo_parts = cout.decode(\"utf-8\").split(\",\")\n\tis_interlaced = mediainfo_parts[0] == \"Interlaced\"\n\tfield_order = mediainfo_parts[1].lower().strip()\n\tprint(\"Interlace detection:\", is_interlaced, field_order, \"(\", mediainfo_parts, \")\")\n\n\tffmpeg_command = [\"ffmpeg\", \"-i\", in_vob]\n\tprint(ffmpeg_command)\n\tprocess = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n\t(cout, cerr) = process.communicate()\n\tprocess.wait() #Ignore the exit code. It always fails.\n\tvobinfo = cerr.decode(\"utf-8\")\n\ttracks = []\n\tfor match in re.finditer(r\" Stream #0:(\\d+)\\[0x[0-9a-f]+\\]: (\\w+): ([^\\n]+)\", vobinfo):\n\t\ttrack_nr = match.group(1)\n\t\ttrack_type = match.group(2)\n\t\ttrack_codec = match.group(3)\n\t\tnew_track = track.Track()\n\t\tnew_track.from_vob(track_nr, track_type, track_codec, is_interlaced, field_order)\n\t\tnew_track.file_name = guid + \"-T\" + str(new_track.track_nr) + \".\" + new_track.codec\n\t\tif new_track.type != \"unknown\":\n\t\t\ttracks.append(new_track)\n\n\t#Generate the parameters to pass to ffmpeg.\n\ttrack_params = [\"-i\", in_vob]\n\tfor track_metadata in tracks:\n\t\ttrack_params.append(\"-map\")\n\t\ttrack_params.append(\"0:\" + str(track_metadata.track_nr))\n\t\ttrack_params.append(\"-c\")\n\t\ttrack_params.append(\"copy\")\n\t\ttrack_params.append(track_metadata.file_name)\n\n\t#Extract all tracks.\n\tprint(\"---- Extracting tracks...\")\n\tffmpeg(*track_params)\n\n\treturn tracks","def compute_video_encoding(video):\n\n video_points = []\n while True:\n ret, frame = video.read()\n if not ret:\n break\n\n # Find landmarks/points in frame.\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n rects = face_detector(gray, 1)\n if (len(rects) == 0):\n break # No face found.\n landmarks = face_predictor(gray, rects[0])\n\n # Convert landmarks to a numpy array.\n points = []\n for i in range(0, landmarks.num_parts):\n if i == 60 or i == 64:\n continue\n point = landmarks.part(i)\n points.append([point.x, point.y])\n points = np.array(points)\n\n img, maps, pts = gann_utils.process_image(frame, points)\n video_points.append(pts)\n\n video_points = np.array(video_points).transpose().swapaxes(0, 1)\n return video_points","def convert_video(video_file, output_file_name):\n video_stream = cv2.VideoCapture(video_file)\n total_frames = video_stream.get(cv2.CAP_PROP_FRAME_COUNT)\n background = get_median_frame(video_stream)\n video_stream.release()\n #reopen for processing:\n video_stream = cv2.VideoCapture(video_file)\n #ready an output writer\n writer = cv2.VideoWriter(output_file_name, \n cv2.VideoWriter_fourcc(*\"MP4V\"), fps,(1080,1920)) #(1920,1080))\n frameCnt=0\n pos = [] #Array for the coordinates\n while(frameCnt < total_frames-1):\n frameCnt+=1\n ret, frame = video_stream.read()\n dframe = background_subtraction(frame,background)\n cnts = find_contours(dframe)\n x,y = find_lowest_contour(cnts)\n pos.append([x,y])\n if len(pos): \n cv2.polylines(frame,np.int32([pos]),False,(0, 255, 0),2)\n writer.write(cv2.resize(frame, (1080,1920))) ## size probably shoudn't be fixed.\n writer.release()\n video_stream.release()\n return pos","def analyze_movie(\n video_path, aspect_ratio=0, palette_size=32, frames=-1, step=1, show_frames=False, show_last_frame=False, color_format='hex'\n):\n\n # Parse video frame-by-frame\n vidcap = cv2.VideoCapture(video_path)\n success, image = vidcap.read()\n pil_img = None\n count = 0\n while success and frames == -1 or count < frames:\n if count % step == 0:\n # Convert to PIL image\n img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n pil_img = Image.fromarray(img)\n\n # Crop frame to remove border\n if aspect_ratio != 0:\n width, height = pil_img.size\n left = 0\n right = width\n content_height = 1/aspect_ratio * width\n border = (height - content_height) * 0.5\n top = border\n bottom = border + content_height\n pil_img = pil_img.crop((left, top, right, bottom))\n\n # Get primary color\n main_color = get_primary_color(\n pil_img, palette_size, show_img=show_frames)\n\n if color_format == 'hex':\n main_color = rgbToHex(main_color)\n \n print(main_color)\n\n # Attempt to read next frame\n success, image = vidcap.read()\n count += 1\n\n if show_last_frame:\n pil_img.show()","def process_video(lane, fname, output):\n\tclip = VideoFileClip(fname)\n\toutput_name = output\n\toutput_clip = clip.fl_image(lane.pipeline)\n\toutput_clip.write_videofile(output_name, audio=False)\n\tprint ('Video processed successfully')","def split_into_frames(filename_raw, thr_var_per_event=5e-4, downsampling_factor=2, disable_display=False,\n filename_output_video=None):\n\n assert downsampling_factor == int(downsampling_factor), \"Error: downsampling_factor must be an integer\"\n assert downsampling_factor >= 0, \"Error: downsampling_factor must be >= 0\"\n\n mv_adaptive_rate_iterator = AdaptiveRateEventsIterator(input_path=filename_raw,\n thr_var_per_event=thr_var_per_event,\n downsampling_factor=downsampling_factor)\n\n height, width = mv_adaptive_rate_iterator.get_size()\n\n if filename_output_video == None:\n video_process = None\n else:\n assert not os.path.exists(filename_output_video)\n video_process = FFmpegWriter(filename_output_video)\n\n if video_process or not disable_display:\n img_bgr = np.zeros((height, width, 3), dtype=np.uint8)\n\n cv2.namedWindow(\"img\", cv2.WINDOW_NORMAL)\n\n for events in mv_adaptive_rate_iterator:\n assert events.size > 0\n start_ts = events[0][\"t\"]\n end_ts = events[-1][\"t\"]\n print(\"frame: {} -> {} delta_t: {} fps: {} nb_ev: {}\".format(start_ts, end_ts,\n end_ts - start_ts,\n 1e6 / (end_ts - start_ts),\n events.size))\n if video_process or not disable_display:\n img = events_to_diff_image(events, sensor_size=(height, width))\n img_bgr[...] = 0\n img_bgr[img < 0, 0] = 255\n img_bgr[img > 0, 1] = 255\n\n chunk_start_ts = events[0][\"t\"]\n chunk_end_ts = events[-1][\"t\"]\n delta_t_frame = chunk_end_ts - chunk_start_ts + 1\n frame_txt = \"ts: {} -> {} delta_t: {} fps: {} (nb_ev): {}\".format(chunk_start_ts, chunk_end_ts,\n delta_t_frame,\n int(1.e6/delta_t_frame),\n events.size)\n img_bgr[20:45, ...] = 0\n cv2.putText(img_bgr,\n frame_txt,\n (int(0.05 * width), 40),\n cv2.FONT_HERSHEY_PLAIN, 1.0, (200, 200, 100))\n\n if video_process:\n video_process.writeFrame(img_bgr.astype(np.uint8)[..., ::-1])\n if not disable_display:\n cv2.imshow(\"img\", img_bgr)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n\n if video_process:\n video_process.close()\n if not disable_display:\n cv2.destroyAllWindows()","def start_video_feed_parsing(img_processor='hog'):\n\n video_capture = cv2.VideoCapture(0)\n\n while True:\n _, frame = video_capture.read()\n\n frame = IMG_PROCESSORS[img_processor].mark_up_faces(frame)\n cv2.imshow('Video', frame)\n\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n\n # When everything is done, release the capture\n video_capture.release()\n cv2.destroyAllWindows()","def check_video_timestamps(movie_file, desired_format='.mp4', desired_framerate=30):\n\n check_video_format(movie_file, desired_format='.mp4', original_format='.avi')\n\n new_movie_file = movie_file+'_tt'+desired_format\n if not os.path.isfile(new_movie_file):\n #Convert file to 30 fps\n cmd = ['ffmpeg', '-i', movie_file+desired_format]\n cmd += ['-r', str(desired_framerate)]\n cmd += ['-y', movie_file+'_t'+desired_format]\n cmd_string = ''.join([\"%s \" % el for el in cmd]) \n #print '-->Running: ', cmd_string\n p = subprocess.Popen(cmd, shell=False)\n p.wait()\n\n #Add timecode text to video\n cmd = 'ffmpeg -i '+movie_file+'_t'+desired_format+' -vf drawtext=\\\"fontfile=/opt/X11/share/fonts/TTF/VeraMoBd.ttf: timecode=\\'00\\:00\\:00\\:00\\':rate=30: fontcolor=white@0.8: x=7: y=460\\\" -an -y '+movie_file+'_tt'+desired_format\n args = shlex.split(cmd)\n #print args\n p = subprocess.Popen(args, shell=False)\n p.wait()\n\n os.remove(movie_file+'_t'+desired_format)\n\n return new_movie_file","def stream_frames(video_capture):","def process_video(proc_state):\n entry = proc_state.entry\n workbench = proc_state.workbench\n video_config = mgg.global_config['media_type:mediagoblin.media_types.video']\n\n queued_filepath = entry.queued_media_file\n queued_filename = proc_state.get_queued_filename()\n name_builder = FilenameBuilder(queued_filename)\n\n medium_filepath = create_pub_filepath(\n entry, name_builder.fill('{basename}-640p.webm'))\n\n thumbnail_filepath = create_pub_filepath(\n entry, name_builder.fill('{basename}.thumbnail.jpg'))\n\n # Create a temporary file for the video destination (cleaned up with workbench)\n tmp_dst = NamedTemporaryFile(dir=workbench.dir, delete=False)\n with tmp_dst:\n # Transcode queued file to a VP8/vorbis file that fits in a 640x640 square\n progress_callback = ProgressCallback(entry)\n\n dimensions = (\n mgg.global_config['media:medium']['max_width'],\n mgg.global_config['media:medium']['max_height'])\n\n # Extract metadata and keep a record of it\n metadata = transcoders.VideoTranscoder().discover(queued_filename)\n store_metadata(entry, metadata)\n\n # Figure out whether or not we need to transcode this video or\n # if we can skip it\n if skip_transcode(metadata):\n _log.debug('Skipping transcoding')\n\n dst_dimensions = metadata['videowidth'], metadata['videoheight']\n\n # Push original file to public storage\n _log.debug('Saving original...')\n proc_state.copy_original(queued_filepath[-1])\n\n did_transcode = False\n else:\n transcoder = transcoders.VideoTranscoder()\n\n transcoder.transcode(queued_filename, tmp_dst.name,\n vp8_quality=video_config['vp8_quality'],\n vp8_threads=video_config['vp8_threads'],\n vorbis_quality=video_config['vorbis_quality'],\n progress_callback=progress_callback,\n dimensions=dimensions)\n\n dst_dimensions = transcoder.dst_data.videowidth,\\\n transcoder.dst_data.videoheight\n\n # Push transcoded video to public storage\n _log.debug('Saving medium...')\n mgg.public_store.copy_local_to_storage(tmp_dst.name, medium_filepath)\n _log.debug('Saved medium')\n\n entry.media_files['webm_640'] = medium_filepath\n\n did_transcode = True\n\n # Save the width and height of the transcoded video\n entry.media_data_init(\n width=dst_dimensions[0],\n height=dst_dimensions[1])\n\n # Temporary file for the video thumbnail (cleaned up with workbench)\n tmp_thumb = NamedTemporaryFile(dir=workbench.dir, suffix='.jpg', delete=False)\n\n with tmp_thumb:\n # Create a thumbnail.jpg that fits in a 180x180 square\n transcoders.VideoThumbnailerMarkII(\n queued_filename,\n tmp_thumb.name,\n 180)\n\n # Push the thumbnail to public storage\n _log.debug('Saving thumbnail...')\n mgg.public_store.copy_local_to_storage(tmp_thumb.name, thumbnail_filepath)\n entry.media_files['thumb'] = thumbnail_filepath\n\n # save the original... but only if we did a transcoding\n # (if we skipped transcoding and just kept the original anyway as the main\n # media, then why would we save the original twice?)\n if video_config['keep_original'] and did_transcode:\n # Push original file to public storage\n _log.debug('Saving original...')\n proc_state.copy_original(queued_filepath[-1])\n\n # Remove queued media file from storage and database\n proc_state.delete_queue_file()","def frame_pre_process(self, frame):\n assert len(frame.shape) == 3, \\\n \"Expected input frame in (H, W, C) format proposed\"\n assert frame.shape[2] in [3, 4], \\\n \"Expected BGR or BGRA input process\"\n # setup the frame in the original format\n \n #orig_image = frame.copy()\n original_image = frame.copy()\n \n # creating the frame transpose conversion\n frame = frame.transpose((2, 0, 1)) # Converting from HWC to CHW\n \n # creating the frame dimensions\n frame = np.expand_dims(frame, axis=0)\n \n # return the frames outcome\n return (frame)","def parse_args():\n parser = argparse.ArgumentParser(description = 'Transform Video Right format')\n parser.add_argument(\n \"--input_video_file\", help=\"Path to video file\",\n default=None, required=True)\n parser.add_argument(\n \"--output_video_file\", help=\"Path to the right format video file '.mp4'\",\n default=None, required=True)\n return parser.parse_args()","def visualize_flow(src, flow_comp_func):\n\n # Flag specifying whether this is the first frame or not.\n first_frame = True\n \n # Initialize video stream.\n video_capture = cv2.VideoCapture(src)\n if not video_capture.isOpened():\n raise RuntimeError(\"Error opening video stream.\")\n \n # Previous frame buffer and results array.\n prev = None\n res = []\n \n # Set frame counter.\n count = 0\n FRAME_LIM = 200\n \n # While there is video and while below frame index limit.\n while video_capture.isOpened() and count < FRAME_LIM:\n\n # Increment frame count.\n count += 1\n print(\"Processing frame {0}/{1}\".format(count, FRAME_LIM))\n\n # Get next frame.\n ret, frame = video_capture.read()\n if ret:\n frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n \n # If first frame ...\n if first_frame:\n \n # Set frame as previous frame.\n prev = frame_gray\n prev_original = frame\n \n # Set first frame flag to false.\n first_frame = False\n\n else:\n\n # Compute flow using current frame and frame\n # in previous buffer.\n u, v = flow_comp_func(prev.astype(float)/255.0, frame_gray.astype(float)/255.0)\n \n\n ### TODO - remove ###\n # import pdb\n # pdb.set_trace()\n # fig2, ((ax2_11, ax2_12), (ax2_21, ax2_22)) = plt.subplots(2, 2)\n # ax2_11.imshow(prev)\n # ax2_12.imshow(frame_gray)\n # show_flow(u, v, ax2_21, type='angle')\n # show_flow(u, v, ax2_22, type='field', set_aspect=True)\n # fig2.suptitle('Horn−Schunck Optical Flow')\n ######\n\n # Add optical flow visualization to image in prev buffer.\n vis_nxt = superimpose_field(u, v, prev_original)\n\n prev = frame_gray\n prev_original = frame\n\n # Store visualization in results buffer\n res.append(vis_nxt)\n\n else:\n break\n \n # Release stream.\n video_capture.release()\n\n # Create gif file from images.\n imageio.mimsave('roundabout_hs.gif', res)","def __call__(self, video_path, per_frames = 1 , offset = None):\n \n cap = cv2.VideoCapture(video_path)\n \n if not cap.isOpened():\n raise Exception(\"Video file does not exist or is invalid\")\n\n \n if offset:\n cap.set(cv2.CAP_PROP_POS_MSEC, offset)\n \n \n info = []\n\n while cap.isOpened():\n ret, frame = cap.read()\n if ret:\n if cap.get(cv2.CAP_PROP_POS_FRAMES) % per_frames == 0:\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n faces_info = self.detect_faces_from_image(frame,\n desired_width=224, desired_height=224) \n if faces_info:\n for element in faces_info:\n face_img = image.img_to_array(element[1])\n\n face_img = utils.preprocess_input(face_img, version=1)\n face_img = np.expand_dims(face_img, axis=0)\n\n features = self.vgg_feature_extractor.predict(face_img)\n label = self.gender_svm.predict(features)[0]\n decision_value = round(self.gender_svm.decision_function(features)[0], 3)\n\n bounding_box = element[0][0]\n detection_score = round(element[5], 3)\n bbox_length = bounding_box.bottom() - bounding_box.top()\n\n info.append([\n cap.get(cv2.CAP_PROP_POS_FRAMES), bounding_box, (bbox_length, bbox_length), label,\n decision_value, detection_score\n ])\n\n else:\n break\n cap.release()\n info = pd.DataFrame.from_records(info, columns = ['frame', 'bb', 'size','label', 'decision', 'conf'])\n return info","def convert(processed_dir: str, video_file: str):\n\n video_name = osp.splitext(osp.basename(video_file))[0]\n out_dir = processed_dir + video_name\n\n # create img dir\n if not osp.exists(processed_dir):\n os.mkdir(processed_dir)\n\n # Create dir for video file if not existent\n # this is where we save our images\n if not osp.exists(out_dir):\n os.mkdir(out_dir)\n\n if osp.exists(out_dir):\n os.mkdir(out_dir + \"/kermit/\")\n os.mkdir(out_dir + \"/not_kermit/\")\n\n # open video file for processing\n cap = cv.VideoCapture(video_file)\n frame_rate = cap.get(5) # frame rate\n\n sec = 0\n total_count = (60*25)+50 # just an approximation\n pbar = tqdm.tqdm(total=total_count, leave=False)\n\n count = 0\n while (cap.isOpened()):\n frame_id = cap.get(1) # current frame number\n frame_exists, curr_frame = cap.read()\n\n if not frame_exists:\n break\n else:\n if (frame_id % math.floor(frame_rate) == 0):\n # output is : video_file/<video_file>_frameNr.jpg\n cv.imwrite(osp.join(out_dir, '{}_{}.jpg'.format(video_name,count)), curr_frame)\n count = count + 1\n pbar.update(1)\n\n pbar.close()\n # release resources\n cap.release()","def _unroll_video(self, video: int) -> None:\n video_file = self.dataset_name + '_' + str(video).zfill(2) + '.mp4'\n\n # Create camera directory to store all frames\n camera = 'camera' + str(video).zfill(2)\n camera_dir = os.path.join(self.videos_dir, camera)\n os.mkdir(camera_dir)\n\n if self.image_format == 'jpeg':\n unroll = subprocess.run([\"ffmpeg\", \"-i\", os.path.join(self.dataset_dir, video_file), \"-qscale:v\", \"2\", \"-vf\", \"scale=1280:720\",\n os.path.join(camera_dir, self.frame_format + \".\" + self.image_format)])\n else:\n unroll = subprocess.run([\"ffmpeg\", \"-i\", os.path.join(self.dataset_dir, video_file), \"-vf\", \"scale=1280:720\",\n os.path.join(camera_dir, self.frame_format + \".\" + self.image_format)])\n # print(\"The exit code was: %d\" % unroll.returncode)","def __init__(self,vid_path:str,num_frames:int=None,vid_flow_direction:str='left'):\n \n self.num_frames=num_frames\n if vid_path.split('.')[-1]=='cine' or vid_flow_direction!='left':\n #This is a cine file or needs to be rotated, convert to mp4\n print('Converting .cine file to mp4 (lossless)')\n #detect platform so we can correct file paths for ffmpeg\n is_win=re.compile('.*[Ww]in.*')\n if is_win.match(sys.platform):\n corrected_vid_path='\"'+vid_path+'\"'\n else:\n #Put escape characters in front of spaces in file name\n corrected_vid_path=[]\n for c in vid_path:\n if c==' ':\n corrected_vid_path.append('\\\\')\n corrected_vid_path.append(c)\n corrected_vid_path=''.join(corrected_vid_path)\n if vid_flow_direction=='up':\n rotate='-vf \"transpose=2\" '\n elif vid_flow_direction=='left':\n rotate=''\n elif vid_flow_direction=='right':\n rotate='-vf \"transpose=2,transpose=2\" '\n else:\n raise Exception(\"vid_flow_direction must be 'up', 'left' or 'right'\")\n if num_frames!=None:\n frames='-frames:v {0} '.format(num_frames)\n else:\n frames=''\n os_handle,new_file_path=tempfile.mkstemp(suffix='.mp4')\n #close file, we don't work with it directly\n os.close(os_handle)\n ffmpeg_command='ffmpeg -y -i {orig_file} {frames}{rotate}-f mp4 -crf 0 {new_file}'.format(orig_file=corrected_vid_path,rotate=rotate,new_file=new_file_path,frames=frames)\n print(ffmpeg_command)\n list(os.popen(ffmpeg_command))\n self.vid_path=new_file_path\n self.delete_file=True\n stats=os.stat(new_file_path)\n if stats.st_size==0:\n raise Exception('File conversion failed, check that ffmpeg is on PATH')\n else:\n #Not a cine\n self.vid_path=vid_path\n self.delete_file=False","def process(self, inputs, n_frame_skips=5, **kwargs):\n # Convert all supported data types to Pillow\n inputs = self.ensure_loaded(inputs)\n\n # Check if video -> Use video process\n is_video = self.check_is_video(inputs)\n if is_video:\n return self.process_video(inputs, n_frame_skips, **kwargs)\n\n # Else return single frame output\n return self._process(inputs, **kwargs)","def detect_from_video(config: Dict):\n video = config['inference']['video_input']['video_input_path']\n vp = VideoProcessing(video=video)\n vp.generate_frames(export_path=config['inference']['video_input']['video_to_frames_export_path'])\n if config['inference']['video_input']['video_to_frames_export_path'] == config['inference']['predicted_frames_export_path']:\n print(\"[Warning]... You have given Video to frame path same as prediction output path /nPredicted output will overwrite video to frame\")\n img_height = config['inference']['img_height']\n img_width = config['inference']['img_width']\n model = ssd_300(image_size=(img_height, img_width, 3),\n n_classes=config['inference']['n_classes'],\n mode='inference',\n l2_regularization=0.0005,\n scales=[0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05], # The scales for MS COCO are [0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05]\n aspect_ratios_per_layer=[[1.0, 2.0, 0.5],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n [1.0, 2.0, 0.5],\n [1.0, 2.0, 0.5]],\n two_boxes_for_ar1=True,\n steps=[8, 16, 32, 64, 100, 300],\n offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n clip_boxes=False,\n variances=[0.1, 0.1, 0.2, 0.2],\n normalize_coords=True,\n subtract_mean=[123, 117, 104],\n swap_channels=[2, 1, 0],\n confidence_thresh=0.5,\n iou_threshold=0.45,\n top_k=200,\n nms_max_output_size=400)\n\n # Load the trained weights into the model.\n weights_path = config['inference']['weights_path']\n\n model.load_weights(weights_path, by_name=True)\n \n # Working with image\n all_images = glob.glob(f\"{config['inference']['video_input']['video_to_frames_export_path']}/*/*\")\n \n # Setting Up Prediction Threshold\n confidence_threshold = config['inference']['confidence_threshold']\n \n # Setting Up Classes (Note Should be in same order as in training)\n classes = config['inference']['classes']\n \n vp.existsFolder(f\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}\")\n # Working with image\n for current_img in tqdm(all_images):\n current_img_name = current_img.split('/')[-1]\n orig_image = cv2.imread(current_img)\n input_images = [] # Store resized versions of the images here\n img = image.load_img(current_img, target_size=(img_height, img_width))\n img = image.img_to_array(img) \n input_images.append(img)\n input_images = np.array(input_images)\n \n # Prediction\n y_pred = model.predict(input_images)\n\n # Using threshold\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\n \n # Drawing Boxes\n for box in y_pred_thresh[0]:\n xmin = box[2] * orig_image.shape[1] / img_width\n ymin = box[3] * orig_image.shape[0] / img_height\n xmax = box[4] * orig_image.shape[1] / img_width\n ymax = box[5] * orig_image.shape[0] / img_height\n \n label = f\"{classes[int(box[0])]}: {box[1]:.2f}\"\n cv2.rectangle(orig_image, (int(xmin), int(ymin)), (int(xmax),int(ymax)), (255, 0, 0), 2)\n cv2.putText(orig_image, label, (int(xmin), int(ymin)), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2, cv2.LINE_AA)\n cv2.imwrite(f\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}/{current_img_name}\", orig_image)\n \n # Creating video\n vp.generate_video(import_path=config['inference']['predicted_frames_export_path'],\n export_path=config['inference']['video_input']['video_output_path'])","def testSetVideoFrame():\n\n\t# create output\n\toutputFileName = \"testSetVideoFrame.mov\"\n\touputFile = av.OutputFile( outputFileName )\n\n\t# create video frame and codec\n\timageDesc = av.VideoFrameDesc()\n\timageDesc.setWidth( 1920 )\n\timageDesc.setHeight( 1080 )\n\timageDesc.setDar( 1920, 1080 )\n\n\tinputPixel = av.Pixel()\n\tinputPixel.setColorComponents( av.eComponentRgb );\n\tinputPixel.setPlanar( False );\n\n\timageDesc.setPixel( inputPixel );\n\n\tinputVideoCodec = av.VideoCodec( av.eCodecTypeEncoder, \"mpeg2video\" );\n\tinputVideoCodec.setImageParameters( imageDesc );\n\n\t# create transcoder and add a video stream\n\ttranscoder = av.Transcoder( ouputFile )\n\ttranscoder.add( \"\", 0, \"xdcamhd422\", inputVideoCodec )\n\tvideoEssence = transcoder.getStreamTranscoder( 0 ).getCurrentEssence()\n\n\t# start process\n\ttranscoder.init()\n\touputFile.beginWrap()\n\n\t# process 255 frames\n\tfor i in range(0,255):\n\t\ttranscoder.processFrame()\n\t\t# set video frame\n\t\tframe = av.VideoFrame( imageDesc )\n\t\tframe.getBuffer().assign(frame.getBuffer().size(), i)\n\t\tvideoEssence.setFrame( frame )\n\n\t# end process\n\touputFile.endWrap()\n\n\t# get dst file of transcode\n\tdst_inputFile = av.InputFile( outputFileName )\n\tprogress = av.NoDisplayProgress()\n\tdst_inputFile.analyse( progress, av.InputFile.eAnalyseLevelFast )\n\tdst_properties = dst_inputFile.getProperties()\n\tdst_videoStream = dst_properties.videoStreams[0]\n\n\tassert_equals( \"mpeg2video\", dst_videoStream.codecName )\n\tassert_equals( \"MPEG-2 video\", dst_videoStream.codecLongName )\n\tassert_equals( 1920, dst_videoStream.width )\n\tassert_equals( 1080, dst_videoStream.height )\n\tassert_equals( 16, dst_videoStream.dar.num )\n\tassert_equals( 9, dst_videoStream.dar.den )","def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\n return x","def video_encoding(self):\n self.output_file = outputs_filenames(self.input, self.output_file)\n\n if self.resume and (self.temp / 'done.json').exists():\n set_logging(self.logging, self.temp)\n else:\n setup(self.temp, self.resume)\n set_logging(self.logging, self.temp)\n print(self.queue)\n framenums = split_routine(self.input, self.scenes, self.split_method, self.temp, self.min_scene_len, self.queue, self.threshold)\n\n if self.extra_split:\n framenums = extra_splits(input, framenums, self.extra_split)\n\n segment(self.input, self.temp, framenums)\n extract_audio(input, self.temp, self.audio_params)\n\n chunk = get_video_queue(self.temp, self.resume)\n\n # Make encode queue\n commands, self.video_params = compose_encoding_queue(chunk, self.temp, self.encoder, self.video_params, self.ffmpeg_pipe, self.passes)\n log(f'Encoding Queue Composed\\n'\n f'Encoder: {self.encoder.upper()} Queue Size: {len(commands)} Passes: {self.passes}\\n'\n f'Params: {self.video_params}\\n\\n')\n\n self.workers = determine_resources(self.encoder, self.workers)\n\n self.encoding_loop(commands)\n\n try:\n concatenate_video(self.temp, self.output_file, keep=self.keep)\n\n except Exception as e:\n _, _, exc_tb = sys.exc_info()\n print(f'Concatenation failed, FFmpeg error\\nAt line: {exc_tb.tb_lineno}\\nError:{str(e)}')\n log(f'Concatenation failed, aborting, error: {e}\\n')\n terminate()\n\n if self.vmaf:\n plot_vmaf(self.input, self.output_file, model=self.vmaf_path)","def _prepare_frame(self, frame):\n\n initial_h, initial_w = frame.shape[:2]\n scale_h, scale_w = initial_h / float(self.input_height), initial_w / float(self.input_width)\n\n in_frame = cv2.resize(frame, (self.input_width, self.input_height))\n in_frame = in_frame.transpose((2, 0, 1))\n in_frame = in_frame.reshape(self.input_size)\n\n return in_frame, scale_h, scale_w","def loadVideo( iFileName, iFrameSize = (576, 720) ):\n import sys\n import subprocess as sp\n # ustvari klic ffmpeg in preusmeri izhod v cevovod\n command = [ 'ffmpeg',\n '-i', iFileName,\n '-f', 'image2pipe',\n '-pix_fmt', 'rgb24',\n '-vcodec', 'rawvideo', '-']\n pipe = sp.Popen(command, stdout = sp.PIPE, bufsize=10**8)\n # definiraj novo spremeljivko\n oVideo = np.array([])\n iFrameSize = np.asarray( iFrameSize )\n frameCount = 0\n # zacni neskoncno zanko\n while True:\n frameCount += 1\n# print( 'Berem okvir %d ...' % frameCount )\n print(\"\\rBerem okvir %d ...\" % frameCount, end=\"\")\n # preberi Y*X*3 bajtov (= 1 okvir)\n raw_frame = pipe.stdout.read(np.prod(iFrameSize)*3)\n # pretvori prebrane podatke v numpy polje\n frame = np.fromstring(raw_frame, dtype='uint8') \n # preveri ce je velikost ustrezna, sicer prekini zanko\n if frame.size != (np.prod(iFrameSize)*3):\n print(\" koncano!\\n\")\n break;\n # preoblikuj dimenzije in pretvori v sivinsko sliko\n frame = colorToGray( frame.reshape((iFrameSize[0],iFrameSize[1],3)) )\n # sprazni medpomnilnik \n pipe.stdout.flush() \n # vnesi okvir v izhodno sprememnljivko\n if oVideo.size == 0:\n oVideo = frame\n oVideo = oVideo[...,None]\n else:\n oVideo = np.concatenate((oVideo,frame[...,None]), axis=2)\n # zapri cevovod\n pipe.terminate()\n # vrni izhodno spremenljivko\n return oVideo","def process_video(filename, args, cfg, net):\n # Split video into frames\n images = split_video(filename)\n # Set output dir\n output_dir = args.output\n # Add brackets and extension to filename\n output_path = create_video_output_path(output_dir, cfg)\n # Get height and width of 1st image\n height, width, _ = check_img_size(images[0]).shape\n # Create VideoWriter object\n video = cv2.VideoWriter(output_path, \n cv2.VideoWriter_fourcc(*'FMP4'), \n cfg['video']['fps'], \n (width, height))\n for image in images:\n # Process frames\n img_steps = process_image(image, cfg, net)\n # Check for --show-detections flag\n output_img = check_if_adding_bboxes(args, img_steps) \n # Write to video\n video.write(output_img) \n # Release video writer object\n video.release()","def seqIo_toVid(fName, ext='avi'):\n\n assert fName[-3:]=='seq', 'Not a seq file'\n sr = seqIo_reader(fName)\n N = sr.header['numFrames']\n h = sr.header['height']\n w = sr.header['width']\n fps = sr.header['fps']\n\n out = fName[:-3]+ext\n sw = skvideo.io.FFmpegWriter(out)\n # sw = cv2.VideoWriter(out, -1, fps, (w, h))\n timer = pb.ProgressBar(widgets=['Converting ', pb.Percentage(), ' -- ',\n pb.FormatLabel('Frame %(value)d'), '/',\n pb.FormatLabel('%(max)d'), ' [', pb.Timer(), '] ',\n pb.Bar(), ' (', pb.ETA(), ') '], maxval=N)\n\n for f in range(N):\n I, ts = sr.getFrame(f)\n sw.writeFrame(Image.fromarray(I))\n # sw.write(I)\n timer.update(f)\n timer.finish()\n # cv2.destroyAllWindows()\n # sw.release()\n sw.close()\n sr.close()\n print(out + ' converted')","def preprocess_frame(frame, v_crop=(0, 0), h_crop=(0, 0)):\n\n # heigth, width, _ = frame.shape\n # frame = np.mean(frame, axis=2) / 255.0\n # frame = frame[v_crop[0]:heigth - v_crop[1], h_crop[0]:width - h_crop[1]]\n # frame = imresize(frame, size=(80, 80), interp='nearest')\n\n frame = frame[::2, ::2]\n frame = np.mean(frame, axis = 2).astype(np.uint8)\n return frame","def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.load_model(args.model,args.cpu_extension,args.device)\n input_shape = infer_network.get_input_shape()\n input_image_width = input_shape[3]\n input_image_height=input_shape[2]\n \n ### TODO: Handle the input stream ###\n try: # try opening input file as image if file is not image, if it throw exception then try opening as video. \n frame=cv2.imread(args.input)\n IS_IMAGE = True\n hasFrame =True\n out_image_file = os.path.splitext(args.input)[0] + \"_inferred\" + \".jpg\"\n #print(\"Successfully Opened Image\")\n fps=0\n frame_height = frame.shape[0]\n frame_width = frame.shape[1]\n except :\n try: # Trying opening as video if it throw exception it means input is neither valid video nor image file.\n if(args.input =='0'): # check if input is webcam\n #print('input is webcam')\n args.input =int(args.input) \n video=cv2.VideoCapture(args.input) #Open video stream\n if (video.isOpened()): # check video stream is successfully opened\n hasFrame,frame=video.read()\n IS_IMAGE = False\n fps=int(video.get(cv2.CAP_PROP_FPS))\n \n #print (\"FPS is {}\".format(fps))\n frame_height = frame.shape[0]\n frame_width = frame.shape[1]\n \n if(args.input): \n out_video_file = os.path.splitext(args.input)[0] + \"_inferred\" + \".avi\"\n else: # if webcam input fixed output filename\n out_video_file = 'webcam_inferred.avi'\n \n out_video=cv2.VideoWriter(out_video_file,cv2.CAP_OPENCV_MJPEG,cv2.VideoWriter_fourcc('M','J','P','G'), fps, (frame_width,frame_height))\n \n else: # Video stream is failed to open\n print('Video capture is not opened properly, Exiting')\n video.release()\n exit()\n except: # Both try to open input as video or image failed , exiting \n \n print(\" Error Opening input!!! ,Input is neither valid image nor video file, please provide right input. Exiting !!!\")\n exit()\n \n # initialize video stats variables \n last_stat_person_in_frame =-1\n last_stat_total_count =-1\n THREESHOLD_NO_OF_SECONDS_FOR_PERSON_LEFT_SCENE = 1.5\n THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE = int(THREESHOLD_NO_OF_SECONDS_FOR_PERSON_LEFT_SCENE*fps)\n frame_no =1\n video_stats ={'video_state' : 'first_frame' , 'person_in_frame' : 0, 'person_time_spent_in_frame' :0 ,'no_person_in_consecutive_frames' :0 ,'total_count':0, 'person_exited_frame' : False,'Box_coordinate' :[None,None,None,None]} # Video statistics dictionary which will be updated as frames by get processed by analyze_frame() function\n \n decision_param = {'THRESHOLD_PROB' : prob_threshold , 'THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE' :THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE} # Decision threshold parameters\n \n ### TODO: Read from the video capture ###\n while(hasFrame and cv2.waitKey(1)<0): #Read video frame by frame\n \n ### TODO: Pre-process the image as needed ###\n input_image = cv2.resize(frame,(input_image_width, input_image_height))\n input_image = input_image.transpose((2,0,1))\n input_image = input_image.reshape(1, 3, input_image_height, input_image_width)\n \n ### TODO: Start asynchronous inference for specified request ###\n t0=time.time()\n async_infer_req_handle=infer_network.exec_net(input_image,0)\n \n ### TODO: Wait for the result ###\n infer_network.wait(async_infer_req_handle)\n t1=time.time()\n infer_time =round((t1-t0)*1000)\n #print(\"For frame no. {} , infer taken {} miliseconds\".format(frame_no, infer_time)) \n \n ### TODO: Get the results of the inference request ###\n obj_det_out=infer_network.get_output(async_infer_req_handle)['DetectionOutput']\n \n ### TODO: Extract any desired stats from the results ###\n #Function to analyze frame and update video statistics \n person_detected = analyze_frame(obj_det_out,video_stats,decision_param)\n \n \n \n # if person detected draw box on image frame\n if(person_detected):\n x1 =int(video_stats['Box_coordinate'][0] *frame_width)\n y1 = int(video_stats['Box_coordinate'][1]*frame_height)\n x2 =int(video_stats['Box_coordinate'][2]*frame_width)\n y2 = int(video_stats['Box_coordinate'][3]*frame_height)\n frame=cv2.rectangle(frame, (x1,y1), (x2,y2), (0,0,255), int(round(frame_height/150)), 8)\n cv2.putText(frame,'Person :' + str(video_stats['total_count']),(x2,y2+5), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2, cv2.LINE_AA)\n \n # put frame_no , frame inference time, person in frame and total person stats in frame \n cv2.putText(frame,'Frame No. ' + str(frame_no) +' Infer Time in ms: ' +str(infer_time),(10,20), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \n cv2.putText(frame,'Current Count:' + str(video_stats['person_in_frame']),(10,40), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \n cv2.putText(frame,'Total No. of Person:' + str(video_stats['total_count']),(10,60), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \n \n if(not IS_IMAGE): # if input is video put current person duration stat in frame\n cv2.putText(frame,'Current person duration' + str(video_stats['person_time_spent_in_frame']/fps),(10,80), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,255,0), 1, cv2.LINE_AA)\n \n ### TODO: Calculate and send relevant information on ###\n ### current_count, total_count and duration to the MQTT server ###\n ### Topic \"person\": keys of \"count\" and \"total\" ###\n ### Topic \"person/duration\": key of \"duration\" ###\n #Here statistics send over MQTT \n \n #sending personduration to MQTT server whenever person exit frame\n if(video_stats['person_exited_frame'] and (not IS_IMAGE)): # if person exited frame and input is video then send last exited person duration to MQTT server.\n json_last_person_time_spent =json.dumps({'duration': video_stats['person_time_spent_in_frame']/fps})\n client.publish('person/duration',json_last_person_time_spent)\n video_stats['person_exited_frame'] =False\n #print('Person duration :{}'.format(json_last_person_time_spent))\n \n #sending current count to MQTT server\n if((last_stat_person_in_frame !=video_stats['person_in_frame']) or (last_stat_counter >9)): # Instead of sending current count every frame , send current count when it is updated or after every 10 frames. Network data saving!!! \n count_data = {'count' :video_stats['person_in_frame']}\n json_count_data = json.dumps(count_data)\n client.publish('person',json_count_data)\n last_stat_person_in_frame = video_stats['person_in_frame']\n #print('Current Count {}'.format(json_count_data))\n last_stat_counter = -1\n last_stat_counter+=1 \n \n #sending total count to MQTT server\n if(last_stat_total_count !=video_stats['total_count']): # Instead of sending total count every frame , send total count when it is updated. Network data saving!!! \n total_count_data = {'total':video_stats['total_count']}\n json_total_count_data = json.dumps(total_count_data)\n client.publish('person',json_total_count_data)\n last_stat_total_count =video_stats['total_count']\n # print('Total Count {}'.format(json_total_count_data))\n \n \n ### TODO: Send the frame to the FFMPEG server ###\n if ( not IS_IMAGE):\n sys.stdout.buffer.write(frame) \n sys.stdout.flush()\n \n \n #show frame (only for local pc) \n #frame1 = cv2.resize(frame,(frame_width,frame_height))\n #cv2.imshow('Inferred Image' ,frame1)\n \n ### TODO: Write an output image if `single_image_mode` ###\n if (IS_IMAGE):\n cv2.imwrite(out_image_file,frame)\n cv2.waitKey(0)\n break\n else:\n out_video.write(frame)\n hasFrame,frame=video.read()\n frame_no+=1\n \n # Sending person duration if last frame ended in 'missing_person_in_frame' or 'person_in_frame' state\n if((video_stats['video_state']=='missing_person_in_frame' or video_stats['video_state']=='person_in_frame' )and (not IS_IMAGE)):\n json_person_time_spent =json.dumps({'duration': video_stats['person_time_spent_in_frame']/fps})\n client.publish('person/duration',json_person_time_spent)\n client.disconnect()\n if (not IS_IMAGE): \n video.release()\n out_video.release()\n cv2.destroyAllWindows()","def preprocess(self, frame: np.ndarray) -> torch.TensorType:\n tensor = cv.resize(frame, (self.IMGSZ, self.IMGSZ)) \n tensor = tensor.transpose(2, 0, 1)\n tensor = torch.from_numpy(tensor)\n tensor = torch.unsqueeze(tensor, 0)\n tensor = tensor.half() if self.half else tensor.float()\n tensor = tensor / 255.0\n tensor = tensor.to(self.device)\n\n return tensor","def process_video(self, input_path, output_path, debug=False):\n clip = VideoFileClip(input_path)\n if debug:\n test_clip = clip.fl_image(self.process_image_debug)\n else:\n test_clip = clip.fl_image(self.process_image)\n test_clip.write_videofile(output_path)","def process_data(self, clip_name) -> Preprocessor:\n\n config: Config = Config.get_config()\n\n folder_name = config.video_data\n video_data_file = ''.join(clip_name.split('.')[:-1]) + '.json'\n video = Video.from_json(os.path.join(folder_name, video_data_file))\n\n # Convert to usable data type period_running_person division, alle fragment soorten\n preprocessor = Preprocessor(video)\n\n return preprocessor","def __init__(self, data_path, batch_size, video_size, mode=\"first80\"):\n self._batch_size = batch_size\n self._video_size = video_size\n\n\n # KTH video splits \n splits = [[11, 12, 13, 14, 15, 16, 17, 18], # train\n [19, 20, 21, 23, 24, 25, 1, 4], # validation\n [22, 2, 3, 5, 6, 7, 8, 9, 10]] # test\n \n label_mapping = {\"boxing\":0,\n \"handclapping\":1, \n \"handwaving\":2,\n \"jogging\":3,\n \"running\":4,\n \"walking\":5}\n self._num_classes = len(label_mapping)\n\n # file containing KTH video frame clip intervals\n sequence_list = os.path.join(data_path, \"00sequences.txt\")\n sequences = self._read_sequence_list(sequence_list)\n \n \n # clip and labels for each split, will be converted into [np.arrays()] format\n self._clips = [[] for _ in range(3)] # resized videos\n self._labels = [[] for _ in range(3)] # labels\n self._fns = [[] for _ in range(3)] # file names\n # read video into np array and create label according to splits \n for video_file in glob.glob(os.path.join(data_path, \"*.avi\")):\n fn = os.path.basename(video_file)\n fn = fn[0:len(fn) - 4]\n \n video = load_video(video_file, self._video_size)\n person_index = int(fn.split(\"_\")[0][-2:len(fn.split(\"_\")[0])])\n split = [i for i, j in enumerate(splits) if person_index in j][0]\n label = label_mapping[fn.split(\"_\")[1]]\n\n # obtain clips from video\n video_key_in_sequences = \"_\".join(fn.split(\"_\")[0:len(fn.split(\"_\")) - 1])\n print video_key_in_sequences\n\n if mode == \"episodes\":\n for clip_index, clip_range in enumerate(sequences[video_key_in_sequences]):\n self._labels[split].append(np.eye(len(label_mapping))[label]) \n self._clips[split].append(video[clip_range[0] - 1:clip_range[1] - 1, :, :, :])\n self._fns[split].append(fn + \"_\" + str(clip_index))\n elif mode == \"first80\":\n self._labels[split].append(np.eye(len(label_mapping))[label]) \n self._clips[split].append(video[0:80, :, :, :])\n self._fns[split].append(fn) \n else:\n raise NotImplementedError(\"Unknown preprocess mode.\")\n\n # maximum length for all clips, limit for padding\n self._clip_length = np.array(\\\n reduce(lambda a, b: a + [elem.shape[0] for elem in b], \n self._clips, [])).max() \n\n for split in range(3):\n for clip_index, (clip, label) in \\\n enumerate(zip(self._clips[split], self._labels[split])):\n self._clips[split][clip_index] = np.pad(clip, \\\n ((0, self._clip_length - clip.shape[0]), (0, 0), (0, 0), (0, 0)),\\\n mode=\"constant\", constant_values=0)\n # shuffling\n shuffle_index = range(len(self._clips[split]))\n random.shuffle(shuffle_index)\n self._clips[split] = [self._clips[split][i] for i in shuffle_index]\n self._labels[split] = [self._labels[split][i] for i in shuffle_index]\n self._fns[split] = [self._fns[split][i] for i in shuffle_index]\n \n self._clips[split] = np.concatenate(\\\n [np.expand_dims(i, axis=0) for i in self._clips[split]]) \n self._labels[split] = np.concatenate(\\\n [np.expand_dims(i, axis=0) for i in self._labels[split]])\n\n print self._clips[0].shape\n print self._labels[0].shape\n self._batch_index = [0 for _ in range(3)]","def local_video(**kwargs):\n output_dir = run_video_preprocess(\n video_file=input_video,\n roi_locations=kwargs[\"roi_locations\"],\n preprocess_analysis=kwargs[\"preprocess_analysis\"],\n database=False\n )\n\n run_analysis_pipeline(\n preprocess_analysis=kwargs[\"preprocess_analysis\"],\n json_filepath=output_dir,\n )","def video_to_frames(video_filename,output_dir):\n cap = cv2.VideoCapture(video_filename)\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\n vid_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n vid_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n vid_fps = int(cap.get(cv2.CAP_PROP_FPS))\n print(\"vid_res=%d x %d, fps=%d\\n\" % (vid_width, vid_height,vid_fps))\n crop_width=int(vid_width/128)*128\n crop_height=int(vid_height/128)*128\n grab_step=int(vid_fps/2)\n if cap.isOpened() and video_length > 0:\n count = 0\n frame_id=0\n success, image = cap.read()\n while success and frame_id <= 9999:\n if count%grab_step==0:\n crop_img = image[0:crop_width, 0:crop_height]\n resized_img = cv2.resize(crop_img, (128, 128)) \n cv2.imwrite(output_dir+\"/frame%05d.jpg\" % frame_id, resized_img)\n frame_id+=1\n success, image = cap.read()\n count += 1\n return 0","def preprocess_frame(self, frame):\n state = torch.Tensor(frame)\n return gpuify(state, self.gpu_id)","def preprocess_raw(self):\n pass","def process_vid_file(vid_file):\n # dict that holds params for matching\n params = {}\n # scale for motion estimation\n params['fScale'] = 1.0\n # number of descriptors\n params['nFeat'] = 2000\n # minimal number of descriptors\n params['nMinKp'] = 50\n # minimal number of matched descriptors\n params['nMinMatch'] = 30\n # maximum offset in flow \n params['fVhThresh'] = 32.0\n # params for image quality (motion blur)\n params['fQualityThresh'] = 5.0\n params['fQualityRatio'] = 0.2\n\n # get video stats\n video_name = os.path.basename(vid_file[:-4])\n video_name.replace(' ', '')\n output_frame_list = []\n output_homography = []\n frame_index = 0\n\n # open video file\n cap = cv2.VideoCapture(vid_file)\n if not cap.isOpened():\n print \"Can not open video file: {:s}\".format(vid_file)\n return frame_pairs\n \n # fetch the first frame\n ret, prev_frame = cap.read()\n if (not ret) or (prev_frame is None):\n print \"Can not read video file: {:s}\".format(vid_file)\n\n start = time.time()\n\n # loop over all frames\n while(True):\n\n # increase the counter\n frame_index += 1\n\n # read current frame\n ret, frame = cap.read()\n\n # end of file?\n if (not ret) or (prev_frame is None):\n break\n\n # match the frames\n M = match_frames(prev_frame, frame, params)\n\n # copy to previous frame\n prev_frame = frame.copy()\n\n # save the frame number and the homography\n if len(M) > 0:\n output_frame_list.append(frame_index)\n output_homography.append(M)\n if len(output_homography) == 1:\n output_homography.append(M)\n # timing\n end = time.time()\n print \"Averge time per frame: {:2f} s. \".format(float(end-start)/frame_index)\n print \"{:2d} valid frame pairs out of {:2d} total pairs\".format(len(output_frame_list), frame_index-1)\n \n return output_frame_list, output_homography","def process_video(self, tmp_output_folder, video_name, video_num, total_videos):\n vidcap = cv2.VideoCapture(join(tmp_output_folder, video_name))\n print(f\"Processing video {video_num}/{total_videos} with name {video_name} \\n\")\n\n input_length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\n frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n fps = int(vidcap.get(cv2.CAP_PROP_FPS))\n\n metadata = []\n faces_all_frames = []\n success, image = vidcap.read()\n count = 0\n frame = 0\n while success:\n if count % self.sample_every == 0:\n height, width = image.shape[:2]\n image = cv2.resize(image, (self.width, self.height), interpolation=cv2.INTER_CUBIC)\n\n # Convert from BGR color (OpenCV) to RGB color (face_recognition)\n rgb_image = image[:, :, ::-1]\n\n # Find all the faces in the current frame of video\n face_locations = face_recognition.face_locations(rgb_image)\n faces = []\n face_num = 0\n # Display the results\n for top, right, bottom, left in face_locations:\n # Draw a box around the face\n faces.append(image[top:bottom, left:right, :].copy())\n metadata.append(\n f\"{video_name},frame-{count}.face-{face_num}.jpg,{count},{face_num},{input_length},{fps},{frame_width},{frame_height},{top},{right},{bottom},{left}\\n\")\n face_num += 1\n faces_all_frames.append(faces)\n\n frame += 1\n success, image = vidcap.read()\n count += 1\n video_num += 1\n vidcap.release()\n\n with open(f\"{self.output_folder}/faces-pickle/{video_name}.pkl\", \"wb\") as f_out:\n pickle.dump(faces_all_frames, f_out)\n return metadata","def generate_ffmpeg_node_structure(parser):\n type_getters = {bool : parser.getboolean, float : parser.getfloat,\n int : parser.getint}\n create_stream = lambda: {'inputs' : {}, 'filters' : {}}\n stream_dict = {'audio' : create_stream(),\n 'video' : create_stream()}\n outputs = []\n global_option = None\n audio_structure = None\n video_structure = None\n\n def get_options(node_name):\n options = parser.options(node_name)\n for unwanted in 'name', 'type', 'layer', 'stream':\n try:\n options.remove(unwanted)\n except ValueError:\n pass\n\n return options\n\n def create_node(element, *args, **kwargs):\n factory = factory_type_dict()[element['type']]\n parameters = parameter_type_dict()[element['type']]\n\n try:\n kwargs.update({option:type_getters.setdefault(parameters()[option], parser.get)\n (element['node'], option) for option in get_options(element['node'])})\n except: # pylint:disable=bare-except\n logging.error(f'Unable to instantiate node {element[\"node\"]} with arguments {kwargs}!')\n logging.info(traceback.format_exc())\n\n return\n\n try:\n node = factory(element['name'], *args, **kwargs)\n except: # pylint:disable=bare-except\n logging.error(f'Unable to instantiate node {element[\"node\"]} with arguments {kwargs}!')\n logging.info(traceback.format_exc())\n\n return\n if node is None:\n logging.warning((f'Node {element[\"node\"]} has not been instantiated'))\n\n return node\n\n def preprocess_filters(stream):\n new_filters = {}\n all_inputs = []\n all_outputs = list(stream['inputs'])\n for layer, filter_element in stream['filters'].items():\n skip = False\n logging.debug(f'Preprocessing filter {filter_element[\"node\"]} (layer={layer}).')\n inputs = parser.get(filter_element['node'], 'input_layer_string', fallback='')\n logging.debug(f'Input layer string: {inputs}.')\n inputs = filters.process_layer_string(inputs)\n logging.info(f'Input layers: {inputs}.')\n if len(inputs) == 0:\n logging.warning((f'No input layers found for node {filter_element[\"node\"]}, '\n 'removing!'))\n continue\n for input_layer in inputs:\n if input_layer in all_inputs:\n logging.warning(f'Removing node {filter_element[\"node\"]}, input collision!')\n skip = True\n outputs = parser.get(filter_element['node'], 'output_layer_string', fallback='')\n logging.debug(f'Output layer string: {outputs}.')\n outputs = filters.process_layer_string(outputs)\n outputs.append(layer)\n logging.info(f'Output layers: {outputs}.')\n for output_layer in outputs:\n if output_layer in all_outputs:\n logging.warning(f'Removing node {filter_element[\"node\"]}, output collision!')\n skip = True\n if skip:\n all_inputs.extend(outputs)\n all_outputs.extend(inputs)\n all_inputs.extend(inputs)\n all_outputs.extend(outputs)\n if skip:\n continue\n new_filters[layer] = filter_element\n\n stream['filters'] = new_filters\n\n def process_filters(stream):\n new_filters = stream['filters'].copy()\n for layer, filter_element in stream['filters'].items():\n logging.debug(f'Processing filter {filter_element[\"node\"]} (layer={layer}).')\n inputs = parser.get(filter_element['node'], 'input_layer_string')\n logging.debug(f'Input layer string: {inputs}.')\n inputs = filters.process_layer_string(inputs)\n logging.info(f'Input layers: {inputs}.')\n if all([i in stream['inputs'] for i in inputs]):\n filter_ = create_node(filter_element, stream['inputs'])\n logging.info(f'Instantiated filter {filter_element[\"node\"]} (layer={layer})!')\n new_filters.pop(layer)\n if filter_ is None:\n continue\n\n filter_ffmpeg, filter_outputs, _ = filter_\n for i in inputs:\n stream['inputs'].pop(i)\n stream['inputs'][layer] = filter_ffmpeg\n stream['inputs'].update(filter_outputs)\n logging.debug(f'Current inputs: {stream[\"inputs\"]}')\n\n stream['filters'] = new_filters\n logging.debug(f'Remaining filters: {stream[\"filters\"]}.')\n logging.debug(f'Current inputs: {stream[\"inputs\"]}.')\n if len(new_filters) > 0:\n process_filters(stream)\n\n for section_name in parser.sections():\n logging.info(f'Looking through node \\'{section_name}\\'.')\n\n section = parser[section_name]\n\n element_name = section.get('name', fallback='')\n element_type = section.get('type', fallback='')\n element_stream = section.get('stream', fallback='')\n element_layer = section.getint('layer', fallback=-1)\n element = {'node' : section_name, 'name' : element_name, 'type' : element_type,\n 'layer' : element_layer, 'stream' : element_stream}\n\n logging.debug((f'Section details: (name={element_name}, type={element_type}, layer='\n f'{element_layer}, stream={element_stream}).'))\n\n if element_name == '' or element_type == '' or element_stream == '' or element_layer == -1:\n logging.warning(f'Skipping section {section_name}! Insufficient metadata.')\n continue\n\n if element_stream not in ['audio', 'video']:\n logging.warning(f'Skipping section {section_name}! Incorrect metadata.')\n continue\n\n del element_name, element_type, element_layer, element_stream\n\n flag = base_type_dict().get(element['type'], utils.NoType)._flag\n stream = stream_dict.get(element['stream'], 'video')\n if flag == utils.FfSpec.FILTER:\n stream['filters'][element['layer']] = element\n elif flag == utils.FfSpec.GLOBAL:\n if global_option is None:\n global_option = element\n else:\n logging.warning(f'Skipping section {section_name}! Global options already found.')\n continue\n elif flag == utils.FfSpec.INPUT:\n stream['inputs'][element['layer']] = create_node(element)\n elif flag == utils.FfSpec.OUTPUT:\n outputs.append(element)\n else:\n logging.warning(f'Unable to determine specifier of type \\'{element[\"type\"]}\\'!')\n\n for stream in stream_dict.values():\n preprocess_filters(stream)\n try:\n process_filters(stream)\n except RecursionError:\n logging.error(f'Unable to process filters!')\n logging.info(traceback.format_exc())\n logging.debug(f'Foremost layers: {list(stream[\"inputs\"])}.')\n # check_disjoint(stream_name)\n\n #if len(stream_dict['video']['inputs']) == 1:\n # video_structure = list(stream_dict['video']['inputs'].values())[0]\n if len(stream_dict['audio']['inputs']) == 1:\n audio_structure = list(stream_dict['audio']['inputs'].values())[0]\n\n for layer, input_node in stream_dict['video']['inputs'].items():\n if video_structure is None:\n video_structure = input_node\n logging.debug(f'Video structure has been set to node {input_node}(layer={layer})!')\n continue\n result = filters.generate_filter('overlay', {0:video_structure, 1:input_node},\n input_layer_string='0,1')\n if result is not None:\n video_structure, _, _ = result\n\n if audio_structure is None:\n inputs = stream_dict['audio']['inputs']\n input_layer_string = ','.join((str(i) for i in range(len(inputs))))\n result = filters.generate_filter('amix',\n {i:layer for i, layer in enumerate(inputs.values())},\n argument_string=f'input_count={len(inputs)}',\n input_layer_string=input_layer_string)\n if result is not None:\n audio_structure, _, _ = result\n \n structures = []\n if audio_structure is not None:\n structures.append(audio_structure.filter_multi_output('asplit'))\n if video_structure is not None:\n structures.append(video_structure.filter_multi_output('split'))\n\n output_nodes = []\n for i, output in enumerate(outputs): \n output_nodes.append(create_node(output, *[structure[i] for structure in structures]))\n\n output_nodes = [node for node in output_nodes if node is not None]\n\n if len(output_nodes) == 0:\n logging.error('Unable to generate ffmpeg node structure! No outputs!')\n return None, False\n\n node_structure = ffmpeg.merge_outputs(*output_nodes)\n if global_option is not None:\n global_node = create_node(global_option, node_structure)\n if global_node is not None:\n logging.info(f'Applied global options to node structure!')\n return global_node, 'sudo' in get_options(global_option['node'])\n logging.error(f'Failed to apply global options to node structure!')\n\n return node_structure, False","def src_process(state, input_data, output_data, ratio, end_of_input=0):\n input_frames, _ = _check_data(input_data)\n output_frames, _ = _check_data(output_data)\n data = ffi.new('SRC_DATA*')\n data.input_frames = input_frames\n data.output_frames = output_frames\n data.src_ratio = ratio\n data.data_in = ffi.cast('float*', ffi.from_buffer(input_data))\n data.data_out = ffi.cast('float*', ffi.from_buffer(output_data))\n data.end_of_input = end_of_input\n error = _lib.src_process(state, data)\n return error, data.input_frames_used, data.output_frames_gen","def convert_video_path_and_save(video_path, output_path=\"output.mp4\", temp_folder = \"./temp\",\n frame_frequency=24, image_reducer=100, fontSize=10, spacing=1.1, maxsize=None, chars=\" .*:+%S0#@\",\n logs=False, processes=4, progress_tracker=None):\n\n if logs:\n start_time = time.time()\n print (\"Converting video...\")\n \n # set up a capture temporarily so we can grab some basic info about it\n capture = cv2.VideoCapture(video_path)\n if not capture.isOpened():\n print (\"Could not read video. Please enter a valid video file!\")\n exit(0)\n\n fps = capture.get(cv2.CAP_PROP_FPS)\n bitrate = int(capture.get(cv2.CAP_PROP_BITRATE))\n total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\n frames_included = int(total_frames / frame_frequency)\n # total_frames / fps gives us our video duration.\n video_duration = total_frames / fps\n # frames included / video duration gives new fps\n new_fps = (total_frames / frame_frequency) / video_duration\n\n capture.release()\n\n # First, we grab all the frames we need and store them in a temp folder\n # After that, we convert all the image frames in the temp folder, and save them back in the temp folder\n # Then, we write them to video and save to disk\n # To utilize mutli processing, we separate grabbing frames and converting the frames into batches\n\n while os.path.isdir(temp_folder):\n temp_folder += \"_\"\n temp_folder += \"/\"\n os.mkdir(temp_folder)\n\n # initial setup\n # we divide our work into batches\n batches = processes\n frames_per_batch = int(total_frames / batches / frame_frequency)\n if progress_tracker is None:\n progress_tracker = Value(\"f\", 0, lock=True)\n # progress: saved frames + converted frames + written frames\n progress_step = 100 / (frames_included * 3)\n\n # grab the frames, and write to separate batch folders\n save_frames_processes = []\n for batch in range(batches):\n starting_frame = batch * frames_per_batch * frame_frequency\n batch_folder = temp_folder + str(batch) + \"/\"\n os.mkdir(batch_folder)\n args = (\n starting_frame,\n starting_frame + frames_per_batch * frame_frequency,\n video_path,\n batch_folder,\n frame_frequency,\n logs,\n progress_tracker,\n progress_step\n )\n p = Process(target=_save_frames, args=args)\n p.daemon = True\n p.start()\n save_frames_processes.append(p)\n for p in save_frames_processes:\n p.join()\n\n # convert all the frames in each batch folder\n convert_processes = []\n for batch in range(batches):\n batch_folder = temp_folder + str(batch) + \"/\"\n args = (\n batch_folder,\n frames_per_batch,\n image_reducer,\n fontSize, spacing, maxsize, chars,\n logs, progress_tracker, progress_step\n )\n p = Process(target=_convert_batch, args=args)\n p.daemon = True\n p.start()\n convert_processes.append(p)\n for p in convert_processes:\n p.join()\n\n # if no extension was assigned, automatically assign .mp4\n output_name, output_ext = os.path.splitext(output_path)\n if output_ext == \"\":\n output_ext = \".mp4\"\n # if final output path was specified, then modify it (append _Copy to it)\n final_output_path = output_name + output_ext\n while os.path.isfile(final_output_path):\n if logs : print (final_output_path, \"already exists!\")\n final_output_path = os.path.splitext(final_output_path)[0] + \"_Copy\" + output_ext\n\n # video settings\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n video_out = imageio.get_writer(final_output_path, fps=new_fps, quality=None, bitrate=(bitrate * 1024 * 2.5))\n size = None\n\n # write images to new video\n for batch in range(1, batches + 1):\n batch_folder = temp_folder + str(batch - 1) + \"/\"\n for i in range(1, frames_per_batch + 1):\n img = cv2.imread(batch_folder + str(i) + \".jpg\", 2)\n if size is None:\n height, width = img.shape\n size = (width, height)\n video_out.append_data(img)\n with progress_tracker.get_lock():\n progress_tracker.value += progress_step\n if logs : print (\"Progress: %.4f%%\" % progress_tracker.value, end=\"\\r\")\n video_out.close()\n shutil.rmtree(temp_folder)\n\n # when we are done, there might be some rounding errors when converting some stuff to integers, thus it doesn't appear to be done\n # So we just simply set it to 100\n with progress_tracker.get_lock():\n progress_tracker.value = 100\n\n if logs:\n print (\"=\" * 30)\n print (\"SUMMARY:\")\n print (\"-\" * 20)\n print (\"Progress: %.4f%%\" % progress_tracker.value)\n print (\"Total frames found:\", str(total_frames))\n print (\"Frames included and converted:\", str(frames_per_batch * batches))\n print (\"Original FPS:\", str(fps))\n print(\"New FPS:\", str(new_fps))\n print (\"Resolution:\", str(size))\n print (\"Saved to\", final_output_path)\n print (\"Time took: %.4f secs\" % (time.time() - start_time))","def main(data_dir):\n\n face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)\n orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)\n base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)\n output_enc_dir = '{}/encodings'.format(base_dir)\n output_vid_dir = '{}/{}/videos'.format(base_dir, COMPRESSION_LEVEL)\n\n pairs = get_seq_combos(face2face_dir)\n\n # Compute all video encodings and save them to disk.\n # We precompute these because they take roughly 10 times as long to compute\n # as the reenactments, and we may want to recompute the reenactments with\n # different images later.\n print('Computing video encodings...')\n if not os.path.exists(output_enc_dir):\n os.makedirs(output_enc_dir)\n enc_count = 0\n for source_id, _ in pairs:\n encoding_path = get_encoding_path(output_enc_dir, source_id)\n if os.path.exists(encoding_path):\n continue # Encoding already calculated for this video sequence.\n print('Computing encoding for sequence {}...'.format(source_id))\n video_path = '{}/{}.mp4'.format(orig_dir, source_id)\n cap = cv2.VideoCapture(video_path)\n points = compute_video_encoding(cap)\n cap.release()\n try:\n np.savetxt(encoding_path, points.reshape((132,-1)).transpose())\n except KeyboardInterrupt as e:\n # Safely handle premature termination.\n # Remove unfinished file.\n if os.exists(encoding_path):\n os.remove(encoding_path)\n raise e\n enc_count += 1\n\n if enc_count == 0:\n print('No encodings were calculated')\n else:\n print('{} video sequences encoded'.format(enc_count))\n\n print()\n print('Computing reenactments...')\n\n # Load pre-trained model.\n gann_path = os.path.join(dirname, 'models/myGEN.pth')\n my_gann = GANnotation.GANnotation(path_to_model=gann_path)\n\n image_dir = '{}/original_sequences_images/{}/images'.format(data_dir, COMPRESSION_LEVEL)\n if not os.path.exists(output_vid_dir):\n os.makedirs(output_vid_dir)\n reenact_count = 0\n for source_id, driver_id in pairs:\n output_path = '{}/{}_{}.mp4'.format(output_vid_dir, source_id, driver_id)\n if os.path.exists(output_path):\n # Do not recreate a video if it already exists.\n # If the user wants to recreated a video\n # the existing video must be deleted first.\n continue\n\n print('Computing reenactment for {} onto {}...'.format(driver_id, source_id))\n # Validate that input files exist.\n encoding_path = get_encoding_path(output_enc_dir, driver_id)\n if not os.path.isfile(encoding_path):\n print('Failed to find encoding for video sequence {}'.format(driver_id),\n file=stderr)\n continue\n image_path = '{}/{}.png'.format(image_dir, source_id)\n if not os.path.isfile(image_path):\n print('Failed to find image for sequence {}'.format(source_id),\n file=stderr)\n continue\n\n points = np.loadtxt(encoding_path).transpose().reshape(66, 2, -1)\n\n # Load and transform image for inputting.\n image = cv2.imread(image_path)\n cropped = get_gann_cropped_face(image)\n\n # Compute reenactment.\n frames, _ = my_gann.reenactment(cropped, points)\n\n output_path = os.path.abspath(output_path)\n print('Writing video to \"{}\"'.format(output_path))\n try:\n write_video(frames, FPS, (128, 128), output_path)\n except KeyboardInterrupt as e:\n # Safely handle premature termination.\n # Remove unfinished file.\n if os.exists(output_path):\n os.remove(output_path)\n raise e\n reenact_count += 1\n\n if reenact_count == 0:\n print('No reenactments were created')\n else:\n print('{} reenactments created'.format(reenact_count))","def __sanitize_input(self):\n self.__check_for_video_file()\n self.__manage_output_folder()","def processVideo(inputRootFolder='/home/pi/Logging/UnprocessedVideo',\n outputFolder='/home/pi/Logging/Unsent',\n cam_framerate=10,\n delay=15):\n logging.info('Processing videos')\n sleep(delay) # hardcoded sleep function to ensure that the video has finished saving\n # Create directories if necessary\n try:\n os.makedirs(inputRootFolder)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise # This was not a \"directory exists\" error\n try:\n os.makedirs(outputFolder)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise # This was not a \"directory exists\" error\n # Get the list of subdirectories\n f = []\n for (dirpath, dirnames, filenames) in os.walk(inputRootFolder):\n f.extend(dirnames)\n # Go through each subdirectory\n for folder in f:\n folderName = os.path.join(inputRootFolder,folder)\n videoListName = '%s/videoList.txt' % folderName #file that will contain list of videos\n videoList = io.open(videoListName, 'w')\n for fileName in sorted(os.listdir(folderName)): #add each video in the folder to the file\n if (fileName.startswith('Video')):\n videoString = (\"file '%s/%s'\\n\" % (folderName, fileName))\n videoList.write(videoString)\n videoList.close()\n outputFile = '%s/%s.mp4' % (outputFolder, folder)\n #concatenate the videos\n subprocess.call(['ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i',\n videoListName, '-c', 'copy', outputFile], shell=False)\n shutil.rmtree(folderName, ignore_errors=True) #delete the folder\n logging.info('Processed videos')","def compress_video(x: np.ndarray, video_format: str, constant_rate_factor: int, dir_: str = \"\"):\n import ffmpeg\n\n video_path = os.path.join(dir_, f\"tmp_video.{video_format}\")\n _, height, width, _ = x.shape\n\n # numpy to local video file\n process = (\n ffmpeg.input(\"pipe:\", format=\"rawvideo\", pix_fmt=\"rgb24\", s=f\"{width}x{height}\")\n .output(video_path, pix_fmt=\"yuv420p\", vcodec=\"libx264\", crf=constant_rate_factor)\n .overwrite_output()\n .run_async(pipe_stdin=True, quiet=True)\n )\n process.stdin.write(x.flatten().astype(np.uint8).tobytes())\n process.stdin.close()\n process.wait()\n\n # local video file to numpy\n stdout, _ = (\n ffmpeg.input(video_path)\n .output(\"pipe:\", format=\"rawvideo\", pix_fmt=\"rgb24\")\n .run(capture_stdout=True, quiet=True)\n )\n return np.frombuffer(stdout, np.uint8).reshape(x.shape)","def video_to_frames(input_loc, output_loc, frame_skip):\n try:\n os.mkdir(output_loc)\n except OSError as e:\n print(e)\n pass\n # Log the time\n time_start = time.time()\n # Start capturing the feed\n cap = cv2.VideoCapture(input_loc)\n # Find the number of frames\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\n print (\"Number of frames: \", video_length)\n count = 0\n actual_frames = 0\n print (\"Converting video..\\n\")\n # Start converting the video\n while cap.isOpened():\n # Extract the frame\n ret, frame = (None, None)\n for i in range(frame_skip):\n ret, frame = cap.read()\n actual_frames += 1\n cv2.imwrite(output_loc + \"/%#05d.jpg\" % (actual_frames), frame)\n count += 1\n # Write the results back to output location.\n # If there are no more frames left\n if (actual_frames > (video_length) - frame_skip):\n # Log the time again\n time_end = time.time()\n # Release the feed\n cap.release()\n # Print stats\n print (\"Done extracting frames.\\n%d frames extracted\" % count)\n print (\"It took %d seconds forconversion.\" % (time_end-time_start))\n break","def filter_video_data(encode_video, image_file_path, encoded_text, encode_label):\n video_frame_number = tf.shape(encode_video)[0]\n return tf.math.equal(video_frame_number, max_video_frame_number)","def decode(decode_format):\n return output_from_decode","def parse():\n all_players = list(FACE_IMAGE_LOCATIONS.keys())\n face_encodings = VideoParser.__load_faces_encodings(all_players)\n player_occurrences = VideoParser.__get_player_occurrences(all_players, face_encodings)\n VideoParser.__save_parsed_video(player_occurrences)","def video_model(video_frames=None, audio_frames=None):\n\n with tf.variable_scope(\"video_model\"):\n batch_size, seq_length, height, width, channels = video_frames.get_shape().as_list()\n\n video_input = tf.reshape(video_frames, (batch_size * seq_length, height, width, channels))\n video_input = tf.cast(video_input, tf.float32)\n\n features, end_points = resnet_v1.resnet_v1_50(video_input, None)\n features = tf.reshape(features, (batch_size, seq_length, int(features.get_shape()[3])))\n\n return features","def convert(inputpath, targetformat):\n outputpath = os.path.splitext(inputpath)[0] + targetformat\n print(\"converting {0} to {1}\".format(inputpath, outputpath))\n\n reader = imageio.get_reader(inputpath)\n fps = reader.get_meta_data()['fps']\n\n writer = imageio.get_writer(outputpath, fps=fps)\n for i, im in enumerate(reader):\n sys.stdout.write(\"\\rframe {0}\".format(i))\n sys.stdout.flush()\n writer.append_data(im)\n print(\"Finalizing...\")\n writer.close()\n print(\"Done.\")","def preprocess_frame(self, frame):\n # Greyscale frame\n img = np.mean(frame,-1)\n\n # Remove black bar at the bottom\n cropped_img = img[:-12, :]\n\n # Normalize Pixel Values\n normalized_frame = cropped_img/255.0\n\n return normalized_frame","def get_frame(self, in_grayscale=False):\n _, frame = self.video.read()\n\n if in_grayscale:\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n\n return frame","def format_det_result():\n test_results = load(args.test_result)\n annos = load(args.anno_path)\n test_videos = annos['test_videos'][0]\n resolutions = annos['resolution']\n frm_dets = []\n for pred in track(test_results, description='formating...'):\n video_key = pred['video_id'].split('.mp4')[0]\n frm_num = pred['timestamp']\n bboxes = pred['pred_instances']['bboxes']\n cls_scores = pred['pred_instances']['scores']\n for bbox, cls_score in zip(bboxes, cls_scores):\n video_idx = test_videos.index(video_key)\n pred_label = np.argmax(cls_score)\n score = cls_score[pred_label]\n h, w = resolutions[video_key]\n bbox *= np.array([w, h, w, h])\n instance_result = np.array(\n [video_idx, frm_num, pred_label, score, *bbox])\n frm_dets.append(instance_result)\n frm_dets = np.array(frm_dets)\n video_tubes = link_tubes(annos, frm_dets, K=1)\n dump(frm_dets, args.frm_out_path)\n dump(video_tubes, args.tube_out_path)","def main(path):\n logger.info(f'Processing video file {path}')\n # Extract audio\n audio_file = extract_audio(path, pipeline_config.audio_target_dir)\n\n # Generate sound classification results and speech recogniser results\n sound_results = SoundRecogniser().process_file(audio_file)\n sound_results = process_overlap(sound_results)\n speech_results = SpeechRecogniser().process_file(audio_file)\n\n # NLP\n wrds = get_words(speech_results)\n nlp = SpaCyNaturalLanguageProcessor(pipeline_config.spacy_model)\n custom_nlp = SpaCyNaturalLanguageProcessor(pipeline_config.custom_spacy_model)\n processor = nlp.get_spacy_results_processor(wrds, speech_results)\n custom_processor = custom_nlp.get_spacy_results_processor(wrds, speech_results)\n chunk_results = processor.process_speech_results_chunk()\n ner_results = processor.process_speech_results_ner()\n ner_results.extend(custom_processor.process_speech_results_ner())\n match_results = processor.process_speech_results_match()\n speech_results = nlp.process_spurious_words(speech_results, chunk_results)\n\n # Add Speech recogniser results, sound classification results and NLP results to a subtitle file\n subs_1 = save_to_subtitles(speech_results,\n lambda speech_result: speech_result['word'])\n subs_1 = compress_subs(subs_1)\n subs_2 = save_to_subtitles(sound_results,\n lambda sound_result: sound_result['class'])\n subs_2 = flatten_subs(subs_2)\n subs_3 = save_to_subtitles(chunk_results,\n lambda chunk_result: f'{chunk_result[\"word\"]} ({chunk_result[\"head\"]})')\n subs_4 = save_to_subtitles(ner_results,\n lambda ner_result: f'{ner_result[\"type\"]} {ner_result[\"word\"]}')\n subs_5 = save_to_subtitles(match_results,\n lambda match_result: match_result[\"word\"])\n\n combined_subs = append_subs(None, subs_1, style='bottom')\n combined_subs = append_subs(combined_subs, subs_2, exclude=['bottom'], style='top', formatter=lambda x: f'({x})')\n combined_subs = append_subs(combined_subs, subs_3, style='left')\n combined_subs = append_subs(combined_subs, subs_4, style='right')\n combined_subs = append_subs(combined_subs, subs_5, style='bottom_left_pred')\n combined_subs = remove_tiny_subs(combined_subs, duration_millis=1000, left_millis=None,\n right_millis=None, style='top')\n subtitle_file_name = os.path.splitext(path)[0] + '.ass'\n create_styles(combined_subs)\n combined_subs.save(subtitle_file_name)\n\n # Burn to a video\n burn_subtitles_into_video(path, subtitle_file_name, pipeline_config.audio_target_dir)\n logger.info(f'Done processing {audio_file}')","def preprocess_output(self, face_box, frame):\n if face_box is None or frame is None or frame.size < 1:\n return None, None\n else:\n face_box = helpers.fit(face_box, frame)\n face_img = helpers.crop(frame, face_box)\n return face_img, face_box","def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\n transform='', oldfile=False):\n\n import pylab as plt\n\n datadir = os.path.expanduser(datadir)\n if proc < 0:\n filename = datadir + '/slice_' + field + '.' + extension\n else:\n filename = datadir + '/proc' + \\\n str(proc) + '/slice_' + field + '.' + extension\n\n # Read the global dimensions.\n dim = read_dim(datadir, proc)\n if dim.precision == 'D':\n precision = 'd'\n else:\n precision = 'f'\n\n # Set up slice plane.\n if extension == 'xy' or extension == 'Xy':\n hsize = dim.nx\n vsize = dim.ny\n if extension == 'xz':\n hsize = dim.nx\n vsize = dim.nz\n if extension == 'yz':\n hsize = dim.ny\n vsize = dim.nz\n plane = np.zeros((vsize, hsize), dtype=precision)\n\n infile = npfile(filename, endian=format)\n\n files = []\n fig = plt.figure(figsize=(5, 10))\n ax = fig.add_subplot(111)\n\n ifirst = True\n islice = 0\n while True:\n try:\n raw_data = infile.fort_read(precision)\n except ValueError:\n break\n except TypeError:\n break\n\n if oldfile:\n t = raw_data[-1]\n plane = raw_data[:-1].reshape(vsize, hsize)\n else:\n t = raw_data[-2]\n plane = raw_data[:-2].reshape(vsize, hsize)\n\n if transform:\n exec('plane = plane' + transform)\n\n if t > tmin and t < tmax:\n ax.cla()\n ax.imshow(plane, vmin=amin, vmax=amax)\n fname = '_tmp%03d.png' % islice\n print('Saving frame' + fname)\n fig.savefig(fname)\n files.append(fname)\n\n if ifirst:\n #print \"----islice----------t---------min-------max-------delta\" # Python 2\n print(\"----islice----------t---------min-------max-------delta\")\n #print \"%10i %10.3e %10.3e %10.3e %10.3e\" % \\ # Python 2\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\n print(\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\n\n ifirst = False\n islice += 1\n\n #print 'Making movie animation.mpg - this make take a while'\n print('Making movie animation.mpg - this make take a while')\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\n os.system(\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\")\n os.system(\"rm _tmp*.png\")\n infile.close()","def analyze_video(vidNum_iter, config, pointInds_toUse, pts_spaced, session): # function needed for multiprocessing\n\n optic = config['Optic']\n\n numVids = session['num_vids']\n path_vid_allFiles = session['videos']\n lk_names = [key for key in optic.keys() if 'lk_' in key]\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\n for k in lk_names}\n\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\n # metadata = vid.get_meta_data()\n\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\n numFrames = int(video.get(\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\n\n frameToSet = 0\n frame = vid.get_data(\n frameToSet) # Get a single frame to use as the first 'previous frame' in calculating optic flow\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n old_frame = new_frame_gray\n\n displacements_tmp = np.zeros((pts_spaced.shape[0], 2, np.uint64(numFrames + (numVids * 1000)))) * np.nan\n\n print(' ', end='', flush=True)\n text = \"progresser #{}\".format(vidNum_iter)\n print(f'\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\n\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames, desc=text, position=vidNum_iter)):\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\n\n ##calculate optical flow\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\n\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter)\n if iter_frame == 0:\n displacements_tmp[:, :, iter_frame] = np.zeros((pts_spaced.shape[0], 2))\n else:\n displacements_tmp[:, :, iter_frame] = np.single(np.squeeze((\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\n\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\n\n return displacements_tmp","def preprocess(x):\n if x.shape[-1] < 16000 * 8:\n raise ValueError(\n \"Cannot preprocess tensor less than 8 seconds in duration.\"\n )\n vad = VadChunk(*get_vad(\"both\"))\n return vad(x)","def video_segment(video_filename, images_data_path, opticalflow_data_path, spatial_cnn_model, motion_cnn_model, \n spatial_motion_svm_model, device, num_flow_channel=10, feature_dimension=2048, child_gesture_duration=45,\n batch_size=2, num_workers=2, image_file_format='jpg', feature_pool='max'):\n \n num_frames = len(glob.glob('' .join([opticalflow_data_path, 'u/', video_filename, '/*.', image_file_format])))\n\n dict_video_file = {video_filename: 1}# here just put 1 for dummy labels as it will not used for segmentation\n min_num_extra_frames = num_frames - child_gesture_duration\n gesture_int_frame_ids = list(range(1, min_num_extra_frames, child_gesture_duration))\n gesture_int_frame_ids.append(min_num_extra_frames+1)\n\n gesture_segmentation_results = np.ones((3, len(gesture_int_frame_ids)))\n gesture_segmentation_labels = -np.ones(num_frames)\n for i, nf in enumerate(tqdm(gesture_int_frame_ids)):\n\n int_frame_id = {video_filename: nf}\n end_frame_id = {video_filename: nf+child_gesture_duration-1}\n # print(int_frame_id, end_frame_id)\n\n # calculate spatial feature\n temp_spatial_feature, _ = spatial_feature_score_frames(spatial_cnn_model, feature_dimension, dict_video_file, int_frame_id, end_frame_id, images_data_path, num_flow_channel=num_flow_channel, feature_pool=feature_pool, batch_size=batch_size, num_workers=num_workers, device=device)\n # feature pooling\n temp_spatial_feature = feature_pooling(temp_spatial_feature.T, feature_pool)\n temp_spatial_feature = temp_spatial_feature.reshape(-1, 1)\n #feature normalize\n temp_spatial_feature = lp_normalize_feature(temp_spatial_feature, 'l2')\n\n # calculate motion feature\n temp_motion_feature, _ = motion_feature_score_frames(motion_cnn_model, feature_dimension, dict_video_file, int_frame_id, end_frame_id, opticalflow_data_path, num_flow_channel=num_flow_channel, feature_pool=feature_pool, batch_size=batch_size, num_workers=num_workers, device=device)\n # feature pooling\n temp_motion_feature = feature_pooling(temp_motion_feature.T, feature_pool)\n temp_motion_feature = temp_motion_feature.reshape(-1, 1)\n #feature normalize\n temp_motion_feature = lp_normalize_feature(temp_motion_feature, 'l2')\n\n temp_combined_feature = np.concatenate((temp_spatial_feature, temp_motion_feature), axis=0)\n non_zeros_feat_ids = np.abs(temp_combined_feature).sum(axis=0)>0.0\n temp_combined_feature = temp_combined_feature[:,non_zeros_feat_ids]\n\n # classify gesture using SVM\n if temp_combined_feature.size:\n temp_pred_label = thundersvm_test_1v1_genrl(spatial_motion_svm_model, temp_combined_feature.reshape(-1, 1))\n gesture_segmentation_labels[int_frame_id[video_filename]:end_frame_id[video_filename]+1] = temp_pred_label\n gesture_segmentation_results[:, i] = np.array([int_frame_id[video_filename], end_frame_id[video_filename], temp_pred_label])\n \n \n return gesture_segmentation_results, gesture_segmentation_labels","def process_input(self,r,g,b):\n pass","def parse_fn(serialized_example):\n\n features = {\n 'video': tf.io.FixedLenFeature([], tf.string),\n 'label': tf.io.FixedLenFeature([], tf.int64),\n 'seq_len': tf.io.FixedLenFeature([], tf.int64),\n 'height': tf.io.FixedLenFeature([], tf.int64),\n 'width': tf.io.FixedLenFeature([], tf.int64),\n 'channels': tf.io.FixedLenFeature([], tf.int64)\n }\n\n # Parse the input tf.Example proto using the dictionary above.\n parsed = tf.io.parse_single_example(serialized_example, features)\n\n # Decodes and reshapes video\n seq_len = tf.cast(parsed['seq_len'], tf.uint32)\n height = tf.cast(parsed['height'], tf.uint32)\n width = tf.cast(parsed['width'], tf.uint32)\n channels = tf.cast(parsed['channels'], tf.uint32)\n video = tf.io.decode_raw(parsed['video'], tf.uint8)\n video = tf.reshape(video, shape=[seq_len, height, width, channels])\n\n # Normalizes video frames, label\n video = tf.cast(video, tf.float32) / 255\n label = tf.cast(parsed['label'], tf.float32)\n return video, label","def make_video(input_files, width=0, height=0, frame_rate=24, crf=20, output_path=\"video.mp4\"):\n if isinstance(input_files, list):\n from PIL import Image # pylint: disable=C0415\n\n with Image.open(input_files[0]) as img:\n width, height = img.size\n tmp_dir = \"tmp_ffmpeg_dir\"\n os.mkdir(tmp_dir)\n if width % 2 != 0:\n print(f\"Width ({width}) not divisible by 2\")\n width -= 1\n if height % 2 != 0:\n print(f\"Height ({width}) not divisible by 2\")\n height -= 1\n for i, inp in enumerate(input_files):\n shutil.copy(inp, os.path.join(tmp_dir, f\"{i:06d}.png\"))\n inputs = f\"{tmp_dir}/%06d.png\"\n command = ffmpeg_common_args(frame_rate, inputs, width, height, crf, output_path)\n ret = os.system(command)\n assert ret == 0, \"ffmpeg failed to generate video file.\"\n for i in range(len(input_files)):\n os.remove(os.path.join(tmp_dir, f\"{i:06d}.png\"))\n os.rmdir(tmp_dir)\n elif isinstance(input_files, str):\n assert width != 0 and height != 0\n command = ffmpeg_common_args(frame_rate, input_files, width, height, crf, output_path)\n ret = os.system(command)\n assert ret == 0, \"ffmpeg failed to generate video file.\"\n else:\n assert (\n False\n ), f'input_files should be list (of files) or str (of file template, e.g., \"%04d.png\") instead of {type(input_files)}'","def main_func_video(param_list: list = None) -> bool:\r\n # index of param\r\n # noinspection PyPep8Naming\r\n PORT_RAW_PICT = 0\r\n\r\n # check if param OK\r\n if len(param_list) != 1:\r\n log_error_to_console(\"GET FRAME VIDEO MAIN FUNCTION PARAM NOK\", str(len(param_list)))\r\n return False\r\n else:\r\n port_image = get_port_from_wave(name=param_list[PORT_RAW_PICT])\r\n\r\n try:\r\n # noinspection PyUnresolvedReferences\r\n success, port_image.arr[:] = global_var_handler.VIDEO.read()\r\n if success is True:\r\n port_image.set_valid()\r\n except BaseException as error:\r\n is_error()\r\n # noinspection PyUnresolvedReferences\r\n log_error_to_console('RAW PICTURE NOK TO READ: ' + str(global_var_handler.VIDEO.__str__()), str(error))\r\n port_image.set_invalid()\r\n pass\r\n\r\n # noinspection PyUnresolvedReferences\r\n log_to_file(str(global_var_handler.FRAME))\r\n # noinspection PyUnresolvedReferences\r\n log_to_file(global_var_handler.STR_L0_SIZE)\r\n\r\n return True","def main_func_from_txt(param_list: list = None) -> bool:\r\n # index of param\r\n # noinspection PyPep8Naming\r\n PORT_RAW_PICT = 0\r\n # noinspection PyPep8Naming\r\n PORT_LINE_SEPARATOR = 1\r\n # noinspection PyPep8Naming\r\n PORT_PX_SEPARATOR = 2\r\n\r\n # check if param OK\r\n if len(param_list) != 3:\r\n log_error_to_console(\"GET FRAME FROM TXT MAIN FUNCTION PARAM NOK\", str(len(param_list)))\r\n return False\r\n else:\r\n img = open(file=os.path.join(config_main.APPL_INPUT_DIR, config_main.APPL_INPUT_IMG_DIR[global_var_handler.FRAME]),\r\n mode='r').read()\r\n\r\n port_image = get_port_from_wave(name=param_list[PORT_RAW_PICT])\r\n\r\n tmp = []\r\n\r\n lines = img.split(param_list[PORT_LINE_SEPARATOR])\r\n for line in lines[:-1]:\r\n t = line.split(param_list[PORT_PX_SEPARATOR])\r\n tmp.append(list(map(int, t)))\r\n\r\n tmp = np.array(tmp)\r\n\r\n height, width = tmp.shape[:2]\r\n\r\n if width != global_var_handler.WIDTH_L0 or height != global_var_handler.HEIGHT_L0:\r\n new_size = \"({w}x{h})\".format(w=width, h=height)\r\n USED_SIZED.add(new_size)\r\n log_to_console(\"RAW PICTURE SIZE NOT OK! PICTURE SIZE REDONE: \" + new_size)\r\n global_var_handler.HEIGHT_L0 = height\r\n global_var_handler.WIDTH_L0 = width\r\n global_var_handler.recalculate_pyramid_level_values()\r\n # noinspection PyUnresolvedReferences\r\n reshape_ports(size_array=global_var_handler.SIZE_ARRAY)\r\n\r\n port_image.arr[:] = tmp\r\n port_image.set_valid()\r\n\r\n global_var_handler.PICT_NAME = config_main.APPL_INPUT_IMG_DIR[global_var_handler.FRAME]\r\n\r\n log_to_file(str(global_var_handler.FRAME))\r\n log_to_file(global_var_handler.PICT_NAME)\r\n log_to_file(global_var_handler.STR_L0_SIZE)\r\n\r\n return True","def __init__(self, channel_id, width, height, entype, ctx,\n output_format=const.PIXEL_FORMAT_YUV_SEMIPLANAR_420):\n self._channel_id = channel_id\n self._width = width\n self._height = height\n self._run_flag = True\n self._callbak_tid = None\n self._channel_desc = None\n self._ctx = ctx\n self._entype = entype\n self._format = output_format\n self._decode_complete_cnt = 0\n self._decode_cnt = 0\n self._output_pic_size = (self._width * self._height * 3) // 2\n self._frame_queue = queue.Queue()\n self._frame_config = None","def decode(p):\n #assert p.endswith('.' + EXTENSION)\n p2 = os.path.basename(p).replace('baseline.png', '.png')\n p2p = os.path.join('/mnt/Volume0/test/clic2020-devkit/result/', p2) #add by me\n pp = os.path.join('/mnt/Volume0/test/clic2020-devkit/targets',p2)\n p2 = os.path.join('/mnt/Volume0/test/clic2020-devkit/inputs/', p2) #add by me\n p1 = pframe_dataset_shared.get_previous_frame_path(p2)\n #p1 = os.path.join('/mnt/Volume0/test/clic2020-devkit/test_data/inputs/', p1)\n #assert os.path.isfile(p1), (p2, p1, p, len(glob.glob('*.png')))\n b = Image.open(p).convert('L')\n f2_reconstructed = decoder(np.array(Image.open(p1)), b)\n Image.fromarray(f2_reconstructed).save(p2p)\n return f2_reconstructed, np.array(Image.open(pp))","def video_handle_for_demo():\n frame = cv2.imread(\"vision.png\")\n\n return frame","def analyze_video(queue, video_file, settings):\n # get video\n video = cv2.VideoCapture(video_file) # input VideoCapture object\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) # number of frames in input video\n # initialize models\n net = models.detection_dnn_model() # detection model\n face_encoder = models.face_encoder() # face recognition encoding model\n pose_predictor = models.pose_predictor() # pose predictor model for finding face landmarks\n # get settings\n track_period = settings[\"track_period\"] # track period from settings\n resamples = settings[\"resamples\"] # number of resamples from settings\n tolerance = settings[\"tolerance\"] # face matching tolerance from settings\n # initialize lists\n face_locations = [] # list of face locations for each frame\n face_encodings = [] # list of face encodings for each frame\n unique_frames = [] # list of frame images including unique faces\n unique_face_locations = [] # list of unique faces' locations\n unique_encodings = [] # list of unique faces' encodings\n for i in range(frame_count):\n ret, img = video.read() # ret indicates if frame was read correctly, img is last read frame\n if i % track_period == 0: # frame for detection\n rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # frame in rgb format\n face_locations.append(detection.detect_faces(img, net))\n face_encodings.append(recognition.encode_faces(rgb, face_locations[-1], pose_predictor, face_encoder, resamples))\n new_indices, new_encodings = recognition.exclude_faces(face_encodings[-1], np.array(unique_encodings), tolerance) # indices and encodings of new faces found\n for k in range(len(new_indices)): # for each new face found\n unique_frames.append(rgb)\n unique_face_locations.append(face_locations[-1][k])\n unique_encodings.append(new_encodings[k])\n send_data(queue, [face_locations, face_encodings, unique_frames, unique_face_locations, unique_encodings])","def extract_frame(vid_item):\n full_path, subdir, save_path = vid_item\n\n out_full_path = save_path\n\n vr = wmli.VideoReader(full_path)\n print(f\"{full_path} fps {vr.fps}.\")\n sys.stdout.flush()\n # for i in range(len(vr)):\n all_frames = []\n try:\n for i, vr_frame in enumerate(vr):\n if vr_frame is not None:\n if img_process_fn is not None:\n vr_frame = img_process_fn(vr_frame)\n w, h, _ = np.shape(vr_frame)\n if args.new_short == 0:\n if args.new_width == 0 or args.new_height == 0:\n # Keep original shape\n out_img = vr_frame\n else:\n out_img = mmcv.imresize(vr_frame,\n (args.new_width,\n args.new_height))\n else:\n if min(h, w) == h:\n new_h = args.new_short\n new_w = int((new_h / h) * w)\n else:\n new_w = args.new_short\n new_h = int((new_w / w) * h)\n out_img = mmcv.imresize(vr_frame, (new_h, new_w))\n all_frames.append(wmli.encode_img(out_img))\n else:\n warnings.warn(\n 'Length inconsistent!'\n f'Early stop with {i + 1} out of {len(vr)} frames.')\n break\n\n out_full_path = out_full_path+f\"_{len(all_frames)}.np\"\n with open(out_full_path,\"wb\") as f:\n pickle.dump(all_frames,f)\n except Exception as e:\n print(f\"Process {full_path} faild, {e}\")\n\n print(f'{full_path} -> {out_full_path} done')\n sys.stdout.flush()\n return True","def __convert_frames(self, frames):\n f = frames\n fragment = sppasChannelFrames(f)\n\n # Convert the sample width if it needs to\n if self._channel.get_sampwidth() != self._sampwidth:\n fragment.change_sampwidth(self._channel.get_sampwidth(), self._sampwidth)\n\n # Convert the self._framerate if it needs to\n if self._channel.get_framerate() != self._framerate:\n fragment.resample(self._sampwidth, self._channel.get_framerate(), self._framerate)\n\n return fragment.get_frames()","def model(inputs, is_training):\n\n tf.logging.info(FLAGS.model_structure)\n tf.logging.info(FLAGS.model_edge_weights)\n structure = json.loads(FLAGS.model_structure)\n\n if FLAGS.use_object_input:\n feature_shape = inputs[0].shape\n original_inputs = inputs[0]\n object_inputs = inputs[1]\n else:\n feature_shape = inputs.shape\n original_inputs = inputs\n object_inputs = None\n\n batch_size = feature_shape[0] // FLAGS.num_frames\n original_num_frames = FLAGS.num_frames\n num_frames = original_num_frames\n\n grouping = {-3: [], -2: [], -1: [], 0: [], 1: [], 2: [], 3: []}\n for i in range(len(structure)):\n grouping[structure[i][0]].append(i)\n\n stem_count = len(grouping[-3]) + len(grouping[-2]) + len(grouping[-1])\n\n assert stem_count != 0\n stem_filters = 128 // stem_count\n\n if grouping[-2]:\n # Instead of loading optical flows as inputs from data pipeline, we are\n # applying the \"Representation Flow\" to RGB frames so that we can compute\n # the flow within TPU/GPU on fly. It's essentially optical flow since we\n # do it with RGBs.\n flow_inputs = rf.rep_flow(\n original_inputs,\n batch_size,\n original_num_frames,\n num_iter=40,\n is_training=is_training,\n bottleneck=1,\n scope='rep_flow')\n streams = []\n\n for i in range(len(structure)):\n with tf.variable_scope('Node_' + str(i)):\n if structure[i][0] == -1:\n inputs = asn.rgb_conv_stem(original_inputs,\n original_num_frames,\n stem_filters,\n structure[i][1],\n is_training,\n data_format)\n streams.append(inputs)\n elif structure[i][0] == -2:\n inputs = asn.flow_conv_stem(flow_inputs,\n stem_filters,\n structure[i][1],\n is_training,\n data_format)\n streams.append(inputs)\n elif structure[i][0] == -3:\n # In order to use the object inputs, you need to feed your object\n # input tensor here.\n inputs = object_conv_stem(object_inputs,\n data_format)\n streams.append(inputs)\n else:\n block_number = structure[i][0]\n\n combined_inputs = [streams[structure[i][1][j]]\n for j in range(0, len(structure[i][1]))]\n\n tf.logging.info(grouping)\n nodes_below = []\n for k in range(-3, structure[i][0]):\n nodes_below = nodes_below + grouping[k]\n\n peers = []\n if FLAGS.attention_mode:\n lg_channel = -1\n tf.logging.info(nodes_below)\n for k in nodes_below:\n tf.logging.info(streams[k].shape)\n lg_channel = max(streams[k].shape[3], lg_channel)\n\n for node_index in nodes_below:\n attn = tf.reduce_mean(streams[node_index], [1, 2])\n\n attn = tf.layers.dense(\n inputs=attn,\n units=lg_channel,\n kernel_initializer=tf.random_normal_initializer(stddev=.01))\n peers.append(attn)\n\n combined_inputs = fusion_with_peer_attention(\n combined_inputs,\n index=i,\n attention_mode=FLAGS.attention_mode,\n attention_in=peers,\n use_5d_mode=False,\n data_format=data_format)\n\n graph = asn.block_group(\n inputs=combined_inputs,\n filters=structure[i][2],\n block_fn=block_fn,\n blocks=layers[block_number],\n strides=structure[i][4],\n is_training=is_training,\n name='block_group' + str(i),\n block_level=structure[i][0],\n num_frames=num_frames,\n temporal_dilation=structure[i][3],\n data_format=data_format)\n\n streams.append(graph)\n\n outputs = asn.multi_stream_heads(streams,\n grouping[3],\n original_num_frames,\n num_classes,\n data_format)\n\n return outputs","def process_videos(chapter_info):\n\n print(\"Processing chapter_info:\", chapter_info)\n\n # getting creation time of the first chapter\n # TODO update when adding multiple directory proccessing\n os.chdir(DIR_VIDEO_FILES)\n print(\"1st chapter\", chapter_info[1][0])\n chap1_time = time.strftime(\n r\"%Y-%m-%d_%H-%M\", time.localtime(os.path.getctime(chapter_info[1][0])))\n print(\"1st chapter creation\", chap1_time)\n\n # output_file = f\"M_GH00{chapter_info[0]}_{chap1_time}.MP4\"\n output_file = f\"{chap1_time}_GH00{chapter_info[0]}_MRG.MP4\"\n if os.path.isfile(output_file):\n print(f\"Chapter already processed, found file: {output_file}\")\n return\n\n # preparing text file containing file list for merging (for ffmpeg)\n video_list_file = chapter_info[0] + \"_merge.txt\"\n with open(video_list_file, \"w\") as f:\n for video_chapter in chapter_info[1]:\n f.write(f\"file {video_chapter}\\n\")\n\n command = f\"{FFMPEG_EXE} -f concat -i {video_list_file} -c copy {DIR_OUTPUT}{output_file}\"\n print(\"command =\", command)\n # p = subprocess.run(\"dir\", shell=True, capture_output=True)\n # p = subprocess.run(\"dir\", shell=True, stdout=subprocess.PIPE, text=True)\n p = subprocess.run(command, stdout=subprocess.PIPE, text=True)\n print(\"returncode =\", p.returncode)\n # print(\"stdout =\", p.stdout)\n os.remove(video_list_file) # remove file list after merging\n # rename original chapters after processing\n for video_chapter in chapter_info[1]:\n os.rename(video_chapter, f\"OK_{video_chapter}\")","def read(self, ifDrawAxis=None, ifDrawSquare=None):\n if(self.isLoaded() == False):\n return\n self.ret, frame = self.video.read()\n if (self.ret == True):\n \n # Draw frame\n self.currentFrame = frame\n self.currentFrameNumber = int(self.video.get(cv2.CAP_PROP_POS_FRAMES))\n \n else: # If the video is end\n self.isPlaying = False\n \n return self.frame(ifDrawAxis, ifDrawSquare)","def main():\n # Initialize so we can use it later\n last_user = None\n videos = []\n\n for line in _in:\n if not line:\n continue\n\n line = line.rstrip().split(\"\\t\")\n if len(line) != 3:\n sys.stderr.write(\"Malformed input: '%s'!\\n\" % \"\\t\".join(line))\n return\n\n (user, video, timestamp) = line\n\n if last_user == user:\n videos.append((video, timestamp))\n else:\n emit_reducer_output(videos) # If len(videos) <= 1, this is no-op\n videos = [(video, timestamp)]\n last_user = user\n\n emit_reducer_output(videos) # Make sure we emit for the last user","def _decode_frames_by_av_module(\n full_path,\n video_start_pts=0,\n video_end_pts=None,\n audio_start_pts=0,\n audio_end_pts=None,\n):\n if video_end_pts is None:\n video_end_pts = float(\"inf\")\n if audio_end_pts is None:\n audio_end_pts = float(\"inf\")\n container = av.open(full_path)\n\n video_frames = []\n vtimebase = torch.zeros([0], dtype=torch.int32)\n if container.streams.video:\n video_frames = _read_from_stream(\n container,\n video_start_pts,\n video_end_pts,\n container.streams.video[0],\n {\"video\": 0},\n )\n # container.streams.video[0].average_rate is not a reliable estimator of\n # frame rate. It can be wrong for certain codec, such as VP80\n # So we do not return video fps here\n vtimebase = _fraction_to_tensor(container.streams.video[0].time_base)\n\n audio_frames = []\n atimebase = torch.zeros([0], dtype=torch.int32)\n if container.streams.audio:\n audio_frames = _read_from_stream(\n container,\n audio_start_pts,\n audio_end_pts,\n container.streams.audio[0],\n {\"audio\": 0},\n )\n atimebase = _fraction_to_tensor(container.streams.audio[0].time_base)\n\n container.close()\n vframes = [frame.to_rgb().to_ndarray() for frame in video_frames]\n vframes = torch.as_tensor(np.stack(vframes))\n\n vframe_pts = torch.tensor([frame.pts for frame in video_frames], dtype=torch.int64)\n\n aframes = [frame.to_ndarray() for frame in audio_frames]\n if aframes:\n aframes = np.transpose(np.concatenate(aframes, axis=1))\n aframes = torch.as_tensor(aframes)\n else:\n aframes = torch.empty((1, 0), dtype=torch.float32)\n\n aframe_pts = torch.tensor([audio_frame.pts for audio_frame in audio_frames], dtype=torch.int64)\n\n return DecoderResult(\n vframes=vframes,\n vframe_pts=vframe_pts,\n vtimebase=vtimebase,\n aframes=aframes,\n aframe_pts=aframe_pts,\n atimebase=atimebase,\n )","def next_frame(self):\n while True:\n if self.grabbed:\n buffer = self.__get_next_yuv_frame()\n if len(buffer) != self.__frame_raw_data_size:\n self.frame = False, False\n self.stopped = True\n break\n\n y, u, v = self.__extract_yuv_planes(buffer)\n\n # Save YUV planes now because they will be reshaped from (height, width) to (height, width, 1)\n\n converted_frame = self.__concatenate_planes_to_444yuv_frame(y, u, v)\n\n self.frame = True, converted_frame\n self.grabbed = False\n\n if self.stopped:\n break\n\n time.sleep(1/1000)"],"string":"[\n \"def process_video(input_file, output_file):\\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\\n video = VideoFileClip(input_file)\\n annotated_video = video.fl_image(process_pipeline)\\n annotated_video.write_videofile(output_file, audio=False)\",\n \"def process_video(input_file, output_file):\\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\\n video = VideoFileClip(input_file)\\n annotated_video = video.fl_image(process_pipeline)\\n annotated_video.write_videofile(output_file, audio=False)\",\n \"def process_video(input_file, output_file):\\n with open('all-features-rbf-svm.p', 'rb') as svm_fd:\\n clf = pickle.load(svm_fd)\\n with open('all-features-scaler.p', 'rb') as scaler_fd:\\n hog_scaler = pickle.load(scaler_fd)\\n hog_parameters = HogParameters(orientations=18, pixels_per_cell=8, cells_per_block=2)\\n clip = VideoFileClip(input_file)\\n test_clip = clip.fl_image(\\n lambda frame: process_frame(frame, clf=clf, norm_scaler=hog_scaler, hog_parameters=hog_parameters, spatial_size=(16, 16), hist_bins=32))\\n test_clip.write_videofile(output_file, audio=False)\",\n \"def preprocess_sample(file, params):\\n\\n videoFile = file + \\\".mp4\\\"\\n audioFile = file + \\\".wav\\\"\\n roiFile = file + \\\".png\\\"\\n visualFeaturesFile = file + \\\".npy\\\"\\n\\n roiSize = params[\\\"roiSize\\\"]\\n normMean = params[\\\"normMean\\\"]\\n normStd = params[\\\"normStd\\\"]\\n vf = params[\\\"vf\\\"]\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n\\n #Extract the audio from the video file using the FFmpeg utility and save it to a wav file.\\n v2aCommand = \\\"ffmpeg -y -v quiet -i \\\" + videoFile + \\\" -ac 1 -ar 16000 -vn \\\" + audioFile\\n os.system(v2aCommand)\\n\\n\\n #for each frame, resize to 224x224 and crop the central 112x112 region\\n captureObj = cv.VideoCapture(videoFile)\\n roiSequence = list()\\n while (captureObj.isOpened()):\\n ret, frame = captureObj.read()\\n if ret == True:\\n grayed = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)\\n grayed = grayed/255\\n grayed = cv.resize(grayed, (224,224))\\n roi = grayed[int(112-(roiSize/2)):int(112+(roiSize/2)), int(112-(roiSize/2)):int(112+(roiSize/2))]\\n roiSequence.append(roi)\\n else:\\n break\\n captureObj.release()\\n cv.imwrite(roiFile, np.floor(255*np.concatenate(roiSequence, axis=1)).astype(np.int))\\n\\n\\n #normalise the frames and extract features for each frame using the visual frontend\\n #save the visual features to a .npy file\\n inp = np.stack(roiSequence, axis=0)\\n inp = np.expand_dims(inp, axis=[1,2])\\n inp = (inp - normMean)/normStd\\n inputBatch = torch.from_numpy(inp)\\n inputBatch = (inputBatch.float()).to(device)\\n vf.eval()\\n with torch.no_grad():\\n outputBatch = vf(inputBatch)\\n out = torch.squeeze(outputBatch, dim=1)\\n out = out.cpu().numpy()\\n np.save(visualFeaturesFile, out)\\n return\",\n \"def make_video(data,\\n xdim, ydim, sample_read_rows, sample_read_cols, image_write_rows, image_write_cols,\\n directory, filename, fps = 24.0, start_frame = 1, end_frame = None, timestamp = False, fontsize = 30, ts_pos = (0,0), save_raw = False):\\n\\n #Command to send via the command prompt which specifies the pipe parameters\\n # command = ['ffmpeg',\\n # '-y', # (optional) overwrite output file if it exists\\n # '-f', 'image2pipe',\\n # '-vcodec', 'mjpeg', #'mjpeg',\\n # '-r', '1',\\n # '-r', str(fps), # frames per second\\n # '-i', '-', # The input comes from a pipe\\n # '-an', # Tells FFMPEG not to expect any audio\\n # '-vcodec', 'mpeg4',\\n # '-b:v', '5000k',\\n # directory + filename + \\\"/\\\"+filename+\\\".mp4\\\",\\n # '-hide_banner',\\n # '-loglevel', 'panic']\\n\\n # Create directories if they don't exist\\n if not os.path.exists(os.path.join(directory, filename, 'frames/')):\\n os.makedirs(os.path.join(directory, filename, 'frames/'))\\n if save_raw and not os.path.exists(os.path.join(directory, filename, 'frames-raw/')):\\n os.makedirs(os.path.join(directory, filename, 'frames-raw/'))\\n\\n if end_frame == None:\\n end_frame = data.FrameCount\\n\\n cm = colormap.get_cmap('viridis')\\n\\n for i, frame_offset in enumerate(tqdm.tqdm(range(start_frame, end_frame))):\\n frame = FrameRead(data, frame_offset)\\n frame_image = np.zeros([ydim, xdim], dtype=np.uint8)\\n frame_image[image_write_rows, image_write_cols] = frame.frame_data[sample_read_rows, sample_read_cols]\\n\\n rgb_im = Image.fromarray(cm(frame_image, bytes=True)).convert('RGB')\\n rgb_im.save(os.path.join(directory, filename, 'frames/', f'{i}.jpg'), 'JPEG')\\n\\n if save_raw:\\n Image.fromarray(np.uint8(frame.frame_data), mode='L').save(os.path.join(directory, filename, 'frames-raw/', f'{i}.jpg'), 'JPEG')\",\n \"def preprocess(self, data):\\n (w,h,f) = self.rawinputformat()\\n dt = numpy.dtype(numpy.uint8)\\n nb = numpy.frombuffer(data,dt,-1,0)\\n actual_stream_width = (w&1)+w # hack, rather get this from the app sink\\n if(actual_stream_width != self.reqsize):\\n nb = nb.reshape(h,actual_stream_width,3)\\n nb = nb[0:h,0:w,0:3] # crop to network input size\\n else:\\n nb = nb.reshape((actual_stream_width,actual_stream_width,3))\\n img = nb.astype('float32')\\n #Preprocess image\\n #for i in range(3):\\n # img[:,:,i] = (img[:,:,i] - self.mean[i]) * self.std[i]\\n #img = resize(img/255.0,(w,h),1)\\n img = img/255.0\\n print(img.shape)\\n #print(img[0,0,:])\\n return img.astype(numpy.float16)\",\n \"def process_group(pattern, params):\\n # check subdirectory according to filter options\\n subdir = params['label']\\n # and the parameters label\\n print 'Processing:', subdir\\n\\n # search for videos matching the pattern\\n search = os.path.join(ROOT_RAWDATA_DIR, pattern)\\n print 'Search pattern:', search\\n flist = sorted(glob.glob(search))\\n\\n # for each matching video\\n for f in flist:\\n # video structures (copied from LEGOS FTP) is yyyymmdd/HH/MM.mp4\\n # and we want to store frames as yyyymmdd/yyyymmdd_HH/yyyymmdd_HHMM/yyyymmdd_HHMM_<index>.<format>\\n # so: recursively split to extract basename, hour and date\\n p, fname = os.path.split(f)\\n p, hour = os.path.split(p)\\n p, date = os.path.split(p)\\n minute, _ = os.path.splitext(fname)\\n # compute output dir, and prefix for frames\\n outdir = os.path.join(ROOT_PREPROC_DIR,\\n subdir, # according to parameters\\n date,\\n '{}_{}'.format(date, hour),\\n '{}_{}{}'.format(date, hour, minute),\\n )\\n prefix = '{}_{}{}_'.format(date, hour, minute)\\n # create output directory if neeeded\\n if not os.path.exists(outdir):\\n print 'Creating output directory', outdir\\n os.makedirs(outdir, 0755)\\n # call decoder\\n command = ['python', '-u', 'decoder.py',\\n f,\\n '-o', outdir,\\n '-p', prefix,\\n '-l', params['label'],\\n '-f', str(params['image_format']),\\n '-m', str(params['median_length']),\\n '-r', str(params['resolution']),\\n '-O', str(params['origin'][0]), str(params['origin'][1]),\\n '-d', str(params['dimensions'][0]), str(params['dimensions'][1]),\\n '-a', str(params['rotation']),\\n ]\\n subprocess.call(command)\",\n \"def preprocess(image):\\n image = rgb2yuv(image)\\n return image\",\n \"def main(_):\\n print('argument to expand', ARGS.video_in)\\n print('argument expanded', glob.glob(ARGS.video_in))\\n video_count = 0\\n for video_filename in glob.glob(ARGS.video_in):\\n print('start parsing', video_filename)\\n data = skvideo.io.ffprobe(video_filename)['video']\\n rate_str = six.ensure_str(data['@r_frame_rate']).split('/')\\n rate = float(rate_str[0]) / float(rate_str[1])\\n print('detected frame rate:', rate)\\n\\n print('load frames:')\\n video = skvideo.io.vreader(video_filename)\\n frame_count = 0\\n file_count = 0\\n for frame in video:\\n if (frame_count > ARGS.offset) and \\\\\\n ((frame_count-ARGS.offset)%ARGS.skip == 0) and \\\\\\n (frame_count/rate >= ARGS.from_s) and \\\\\\n (frame_count/rate <= ARGS.to_s or ARGS.to_s == -1):\\n print(frame_count,)\\n img = Image.fromarray(frame)\\n if ARGS.crop:\\n img = crop(img, ARGS.size)\\n # save file\\n file_number = file_count + video_count * ARGS.multiple + ARGS.start\\n if ARGS.format_ext.lower() == 'jpg':\\n file_out = os.path.join(ARGS.path_out,\\n 'f{:07d}.jpg'.format(file_number))\\n img.save(file_out, 'JPEG')\\n elif ARGS.format_ext.lower() == 'png':\\n file_out = os.path.join(ARGS.path_out,\\n 'f{:07d}.png'.format(file_number))\\n img.save(file_out, 'PNG')\\n else:\\n print('unrecognize format', ARGS.format_ext)\\n sys.exit()\\n file_count += 1\\n frame_count += 1\\n video_count += 1\",\n \"def transcode(self) -> None:\\n # Get source mediainfo to use in validation\\n source_media_info = self.get_media_info(self.source)\\n\\n # Common ffmpeg flags\\n ff = FFMPEG(overwrite=True, loglevel='repeat+level+info')\\n # Init source file\\n ff < SourceFile(self.source)\\n # Scaling\\n fc = ff.init_filter_complex()\\n fc.video | Scale(**TRANSCODING_OPTIONS[SCALE]) | fc.get_video_dest(0)\\n\\n # set group of pixels length to segment size\\n gop = math.floor(source_media_info[VIDEO_FRAME_RATE] * GOP_DURATION)\\n # preserve source audio sampling rate\\n arate = source_media_info[AUDIO_SAMPLING_RATE]\\n # preserve original video FPS\\n vrate = source_media_info[VIDEO_FRAME_RATE]\\n # codecs, muxer and output path\\n\\n cv0 = VideoCodec(\\n gop=gop,\\n vrate=vrate,\\n **TRANSCODING_OPTIONS[VIDEO_CODEC])\\n ca0 = AudioCodec(\\n arate=arate,\\n **TRANSCODING_OPTIONS[AUDIO_CODEC])\\n out0 = Muxer(self.destination, format='mp4')\\n\\n # Add output file to ffmpeg\\n ff.add_output(out0, cv0, ca0)\\n\\n # Run ffmpeg\\n self.run(ff)\\n\\n # Get result mediainfo\\n dest_media_info = self.get_media_info(self.destination)\\n\\n # Validate ffmpeg result\\n self.validate(source_media_info, dest_media_info)\",\n \"def vid2tensor( self, current_frame):\",\n \"def process_video(data_info, name, mode, is_training=True):\\r\\n data = Action_Dataset(name, mode, [data_info])\\r\\n if is_training:\\r\\n clip_seq, label_seq = data.next_batch(1, _CLIP_SIZE)\\r\\n else:\\r\\n clip_seq, label_seq = data.next_batch(\\r\\n 1, _EACH_VIDEO_TEST_SIZE+1, shuffle=False, data_augment=False)\\r\\n clip_seq = 2*(clip_seq/255) - 1\\r\\n clip_seq = np.array(clip_seq, dtype='float32')\\r\\n return clip_seq, label_seq\",\n \"def _preprocess(self, ob):\\n # Take the max over prev and current frames.\\n if self.last_frame is not None:\\n ob_comb = np.maximum(ob, self.last_frame)\\n else:\\n ob_comb = ob\\n self.last_frame = ob\\n\\n # Convert to YUV, extract Y, resize, and crop.\\n r, g, b = ob_comb[:, :, 0], ob_comb[:, :, 1], ob_comb[:, :, 2]\\n y = 0.299 * r + 0.587 * g + 0.114 * b\\n y_resized = cv2.resize(y, (84, 110), interpolation=cv2.INTER_LINEAR)\\n y_cropped = y_resized[13:-13, :]\\n return y_cropped\",\n \"def process_video(self):\\n if os.path.isfile(self.source):\\n self.cap = cv2.VideoCapture(self.source)\\n else:\\n try:\\n file_name = \\\"input.mp4\\\"\\n self.source = self.source.replace('open', 'uc')\\n print( \\\"\\\\nDownloading video file from drive link to %s\\\\n\\\"%file_name)\\n gdown.download(self.source, file_name, quiet=False)\\n print( \\\"%s downloaded!\\\\n\\\"%file_name )\\n self.cap = cv2.VideoCapture(file_name)\\n except Exception:\\n raise RuntimeError(\\\"Invalid source input, please specify a Google drive link or a downloaded local file as input \\\\n\\\")\\n\\n\\n assert self.cap.isOpened(), \\\"Failed to open %s\\\" % self.source\\n\\n self.w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n self.h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n self.fps = self.cap.get(cv2.CAP_PROP_FPS) \\n self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\\n return\",\n \"def __init__(self, input_file_path, convert_to_bgr=False):\\n self.__yuv_video = YuvDecoder(input_file_path, convert_to_bgr=True)\\n print('After INSTANTIATION')\\n self.__yuv_video.start()\",\n \"def reencode(filepath, loglevel='panic'):\\n try:\\n import ffmpeg\\n except ImportError:\\n logger.error(\\n 'Import Error! Cant import ffmpeg. '\\n 'Annotations operations will be limited. import manually and fix errors')\\n raise\\n if not os.path.isfile(filepath):\\n raise IOError('File doesnt exists: {}'.format(filepath))\\n # re encode video without b frame and as mp4\\n basename, ext = os.path.splitext(filepath)\\n output_filepath = os.path.join(basename, os.path.basename(filepath).replace(ext, '.mp4'))\\n if not os.path.isdir(os.path.dirname(output_filepath)):\\n os.makedirs(os.path.dirname(output_filepath))\\n try:\\n stream = ffmpeg.input(filepath, **{'loglevel': loglevel}).output(output_filepath,\\n **{'x264opts': 'bframes=0',\\n 'f': 'mp4'})\\n ffmpeg.overwrite_output(stream).run()\\n except Exception as e:\\n logger.exception('ffmpeg error in disassemble:')\\n raise\\n\\n output_probe = Videos.get_info(output_filepath)\\n start_time = eval(output_probe['streams'][0]['start_time'])\\n fps = eval(output_probe['streams'][0]['avg_frame_rate'])\\n has_b_frames = output_probe['streams'][0]['has_b_frames']\\n start_frame = fps * start_time\\n if start_time != 0:\\n logger.warning('Video start_time is not 0!')\\n if has_b_frames != 0:\\n logger.warning('Video still has b frames!')\\n return output_filepath\",\n \"def video_process(threshold=THRESHOLD, inputpath=INPUTPATH, file=FILE):\\n #create video capture object\\n cap = cv2.VideoCapture(f'{inputpath}{file}')\\n name = file.split('/')[-1].split('.')[0]\\n frame_sqrs_list = []\\n if (cap.isOpened()==False):\\n logging.error('Error opening video stream or file')\\n model = load_model()\\n frame_n = 1\\n print('model loaded')\\n while(cap.isOpened()):\\n #capture frame-by-frame\\n ret, frame = cap.read()\\n if ret == True:\\n squares_list = img_preprocess(frame)\\n frame_n = frame_n+1\\n print(f'enter video file, frame{frame_n}')\\n x_list = []\\n y_list = []\\n for sq in squares_list:\\n predict = predict_hot_pxl(sq.sq, model)\\n if predict > threshold:\\n pred = 1\\n print('ERROR')\\n x_list.append(sq.y)\\n y_list.append(sq.x)\\n # draw square around error in frame:\\n # FIXME: save a square to a list of squares\\n continue\\n else:\\n pred = 0\\n print('no error')\\n # FIXME: draw_sqr(name, frame, frame_n, !!! PASS LIST INSTEAD !!! and rewrite the draw func to draw several squares sq.y, sq.x) \\n sq = sq._replace(pred_float = predict)\\n sq = sq._replace(pred_int = pred)\\n # dict element sq is now obsolete, remove it\\n sq = sq._replace(sq = None)\\n # save single frame with squares marking errors as png to disc:\\n draw_sqr(name, frame, frame_n, x_list, y_list)\\n frame_sqrs_list.append(sq)\\n # Break the loop\\n else:\\n break\\n return name, frame_sqrs_list\",\n \"def get_videoinput_bin(self):\\r\\n raise NotImplementedError\",\n \"def run(input_video_file, output_video_file):\\n print(\\\"Debut de la transformation du format de la video\\\")\\n #récupération de la vidéo\\n video = cv2.VideoCapture(input_video_file)\\n #fps de la vidéo\\n fps = video.get(cv2.CAP_PROP_FPS)\\n #largeur des images de la vidéo\\n width_video = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))\\n #hauteur des images de la vidéo\\n height_video = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n #nombre d'images dans la vidéo\\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))\\n #durée de la vidéo\\n duration = frame_count/fps\\n #nouvelle durée de la vidéo (on arrondi)\\n new_duration = math.floor(duration)\\n #nouveau fps de la vidéo\\n new_fps = float(round(fps))\\n #appliquer le nouveau fps\\n video.set(cv2.CAP_PROP_FPS,new_fps)\\n #appliquer la nouvelle durée\\n print(new_duration)\\n print(new_fps)\\n print(new_duration*new_fps)\\n new_frame_count = new_duration*new_fps\\n video.set(cv2.CAP_PROP_FRAME_COUNT,new_duration*new_fps)\\n #déffinition du format de la vidéo en sortie\\n video_out = cv2.VideoWriter(output_video_file,0x7634706d,new_fps,(width_video,height_video),True)\\n \\n count = 0\\n #ouverture de la vidéo\\n while(video.isOpened()):\\n #lecture image par image\\n ret, frame = video.read()\\n if ret==True:\\n\\n #ecriture de l'image dans la vidéo en sortie\\n video_out.write(frame)\\n count = count + 1\\n \\n if (count > (new_frame_count-1)):\\n # Libérer la vidéo\\n video.release()\\n break\\n else:\\n break\\n\\n print(\\\"fin de la transformation\\\")\\n #fermer les vidéos\\n video.release()\\n video_out.release()\",\n \"def create_video(input_file, output_file):\\n input_video = VideoFileClip(input_file)\\n output_video = input_video.fl_image(detect_lane.fit_and_plot)\\n output_video.write_videofile(output_file, audio=False)\",\n \"def check_video_format(movie_file, desired_format='.mp4', original_format='.avi'):\\n\\n if not os.path.isfile(movie_file+original_format):\\n print 'Error. avi file does not exist:'+movie_file+'.avi'\\n if not os.path.isfile(movie_file+desired_format):\\n cmd = ['ffmpeg']\\n cmd += ['-i', movie_file+original_format]\\n cmd += [movie_file+desired_format]\\n cmd_string = ''.join([\\\"%s \\\" % el for el in cmd])\\n #print '-->Running: ', cmd_string\\n p = subprocess.Popen(cmd, shell=False)\\n p.wait()\",\n \"def model_callback(self, output_sample_timestamp, frames):\\n logger.debug(\\\"Output score at timestamp \\\" + str(output_sample_timestamp))\\n output_sample_index = [i for i, f in enumerate(frames) if f[\\\"dts\\\"] < output_sample_timestamp][-1]\\n\\n # only get the relevant frames from the chunk\\n frames = utils.get_chunk(frames, output_sample_index, type=\\\"video\\\")\\n\\n first_frame = frames[0]\\n if self.mode == 0:\\n # average the bitrate for all of the segments\\n bitrate = np.mean([f[\\\"bitrate\\\"] for f in frames])\\n score = P1203Pv.video_model_function_mode0(\\n utils.resolution_to_number(first_frame[\\\"resolution\\\"]),\\n utils.resolution_to_number(self.display_res),\\n bitrate,\\n first_frame[\\\"fps\\\"]\\n )\\n self.o22.append(score)\\n return\\n\\n elif self.mode == 1:\\n # average the bitrate based on the frame sizes, as implemented\\n # in submitted model code\\n compensated_sizes = [\\n utils.calculate_compensated_size(f[\\\"type\\\"], f[\\\"size\\\"], f[\\\"dts\\\"]) for f in frames\\n ]\\n duration = np.sum([f[\\\"duration\\\"] for f in frames])\\n bitrate = np.sum(compensated_sizes) * 8 / duration / 1000\\n score = P1203Pv.video_model_function_mode1(\\n utils.resolution_to_number(first_frame[\\\"resolution\\\"]),\\n utils.resolution_to_number(self.display_res),\\n bitrate,\\n first_frame[\\\"fps\\\"],\\n frames\\n )\\n self.o22.append(score)\\n return\\n\\n elif self.mode == 2:\\n score = P1203Pv.video_model_function_mode2(\\n utils.resolution_to_number(first_frame[\\\"resolution\\\"]),\\n utils.resolution_to_number(self.display_res),\\n first_frame[\\\"fps\\\"],\\n frames\\n )\\n self.o22.append(score)\\n return\\n\\n elif self.mode == 3:\\n score = P1203Pv.video_model_function_mode3(\\n utils.resolution_to_number(first_frame[\\\"resolution\\\"]),\\n utils.resolution_to_number(self.display_res),\\n first_frame[\\\"fps\\\"],\\n frames\\n )\\n self.o22.append(score)\\n return\\n\\n else:\\n raise P1203StandaloneError(\\\"Unsupported mode: {}\\\".format(self.mode))\",\n \"def tagVideo(modelpath, videopath, outputPath=None): \\n model = get_model_instance_segmentation(3)\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n # model.load_state_dict(torch.load(modelpath, map_location=device), strict=False)\\n model.load_state_dict(torch.load(modelpath, map_location=device))\\n model = model.to(device)\\n model.eval()\\n\\n \\n data_transform = transforms.Compose([\\n ToPILImage(),\\n transforms.ToTensor(), \\n ])\\n\\n\\n if outputPath:\\n writer = FFmpegWriter(str(outputPath))\\n \\n font = cv2.FONT_HERSHEY_SIMPLEX\\n cv2.namedWindow('main', cv2.WINDOW_NORMAL)\\n labels = ['No mask', 'Mask']\\n labelColor = [(10, 0, 255), (10, 255, 0)]\\n img_count = 0\\n outputDir = os.path.dirname(os.path.realpath(outputPath))\\n frame_count = 0\\n boundingBoxes = []\\n for frame in vreader(str(videopath)):\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n print('Frame:', frame_count)\\n\\n if frame_count%30==0:\\n frameTensor = data_transform(frame)\\n frameTensor = torch.unsqueeze(frameTensor, 0).to(device)\\n output = model(frameTensor)\\n boundingBoxes = plot_image_new(frame, frameTensor[0], output[0]) \\n \\n if len(boundingBoxes)>0:\\n for bb in boundingBoxes:\\n cv2.rectangle(frame,\\n (bb[0], bb[1]),\\n (bb[2], bb[3]),\\n (54, 66, 227),\\n thickness=2)\\n\\n cv2.imshow('main', frame)\\n if outputPath:\\n writer.writeFrame(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n frame_count += 1\\n if outputPath:\\n writer.close()\\n cv2.destroyAllWindows()\",\n \"def extract_vob(in_vob, guid):\\n\\t#Detect interlacing.\\n\\tmediainfo_command = \\\"mediainfo --Inform='Video;%ScanType%,%ScanOrder%' \\\" + in_vob\\n\\tprint(mediainfo_command)\\n\\tprocess = subprocess.Popen(mediainfo_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\t(cout, cerr) = process.communicate()\\n\\texit_code = process.wait()\\n\\tif exit_code != 0:\\n\\t\\traise Exception(\\\"Calling Mediainfo on {in_vob} failed with exit code {exit_code}.\\\".format(in_vob=in_vob, exit_code=exit_code))\\n\\tmediainfo_parts = cout.decode(\\\"utf-8\\\").split(\\\",\\\")\\n\\tis_interlaced = mediainfo_parts[0] == \\\"Interlaced\\\"\\n\\tfield_order = mediainfo_parts[1].lower().strip()\\n\\tprint(\\\"Interlace detection:\\\", is_interlaced, field_order, \\\"(\\\", mediainfo_parts, \\\")\\\")\\n\\n\\tffmpeg_command = [\\\"ffmpeg\\\", \\\"-i\\\", in_vob]\\n\\tprint(ffmpeg_command)\\n\\tprocess = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n\\t(cout, cerr) = process.communicate()\\n\\tprocess.wait() #Ignore the exit code. It always fails.\\n\\tvobinfo = cerr.decode(\\\"utf-8\\\")\\n\\ttracks = []\\n\\tfor match in re.finditer(r\\\" Stream #0:(\\\\d+)\\\\[0x[0-9a-f]+\\\\]: (\\\\w+): ([^\\\\n]+)\\\", vobinfo):\\n\\t\\ttrack_nr = match.group(1)\\n\\t\\ttrack_type = match.group(2)\\n\\t\\ttrack_codec = match.group(3)\\n\\t\\tnew_track = track.Track()\\n\\t\\tnew_track.from_vob(track_nr, track_type, track_codec, is_interlaced, field_order)\\n\\t\\tnew_track.file_name = guid + \\\"-T\\\" + str(new_track.track_nr) + \\\".\\\" + new_track.codec\\n\\t\\tif new_track.type != \\\"unknown\\\":\\n\\t\\t\\ttracks.append(new_track)\\n\\n\\t#Generate the parameters to pass to ffmpeg.\\n\\ttrack_params = [\\\"-i\\\", in_vob]\\n\\tfor track_metadata in tracks:\\n\\t\\ttrack_params.append(\\\"-map\\\")\\n\\t\\ttrack_params.append(\\\"0:\\\" + str(track_metadata.track_nr))\\n\\t\\ttrack_params.append(\\\"-c\\\")\\n\\t\\ttrack_params.append(\\\"copy\\\")\\n\\t\\ttrack_params.append(track_metadata.file_name)\\n\\n\\t#Extract all tracks.\\n\\tprint(\\\"---- Extracting tracks...\\\")\\n\\tffmpeg(*track_params)\\n\\n\\treturn tracks\",\n \"def compute_video_encoding(video):\\n\\n video_points = []\\n while True:\\n ret, frame = video.read()\\n if not ret:\\n break\\n\\n # Find landmarks/points in frame.\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n rects = face_detector(gray, 1)\\n if (len(rects) == 0):\\n break # No face found.\\n landmarks = face_predictor(gray, rects[0])\\n\\n # Convert landmarks to a numpy array.\\n points = []\\n for i in range(0, landmarks.num_parts):\\n if i == 60 or i == 64:\\n continue\\n point = landmarks.part(i)\\n points.append([point.x, point.y])\\n points = np.array(points)\\n\\n img, maps, pts = gann_utils.process_image(frame, points)\\n video_points.append(pts)\\n\\n video_points = np.array(video_points).transpose().swapaxes(0, 1)\\n return video_points\",\n \"def convert_video(video_file, output_file_name):\\n video_stream = cv2.VideoCapture(video_file)\\n total_frames = video_stream.get(cv2.CAP_PROP_FRAME_COUNT)\\n background = get_median_frame(video_stream)\\n video_stream.release()\\n #reopen for processing:\\n video_stream = cv2.VideoCapture(video_file)\\n #ready an output writer\\n writer = cv2.VideoWriter(output_file_name, \\n cv2.VideoWriter_fourcc(*\\\"MP4V\\\"), fps,(1080,1920)) #(1920,1080))\\n frameCnt=0\\n pos = [] #Array for the coordinates\\n while(frameCnt < total_frames-1):\\n frameCnt+=1\\n ret, frame = video_stream.read()\\n dframe = background_subtraction(frame,background)\\n cnts = find_contours(dframe)\\n x,y = find_lowest_contour(cnts)\\n pos.append([x,y])\\n if len(pos): \\n cv2.polylines(frame,np.int32([pos]),False,(0, 255, 0),2)\\n writer.write(cv2.resize(frame, (1080,1920))) ## size probably shoudn't be fixed.\\n writer.release()\\n video_stream.release()\\n return pos\",\n \"def analyze_movie(\\n video_path, aspect_ratio=0, palette_size=32, frames=-1, step=1, show_frames=False, show_last_frame=False, color_format='hex'\\n):\\n\\n # Parse video frame-by-frame\\n vidcap = cv2.VideoCapture(video_path)\\n success, image = vidcap.read()\\n pil_img = None\\n count = 0\\n while success and frames == -1 or count < frames:\\n if count % step == 0:\\n # Convert to PIL image\\n img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n pil_img = Image.fromarray(img)\\n\\n # Crop frame to remove border\\n if aspect_ratio != 0:\\n width, height = pil_img.size\\n left = 0\\n right = width\\n content_height = 1/aspect_ratio * width\\n border = (height - content_height) * 0.5\\n top = border\\n bottom = border + content_height\\n pil_img = pil_img.crop((left, top, right, bottom))\\n\\n # Get primary color\\n main_color = get_primary_color(\\n pil_img, palette_size, show_img=show_frames)\\n\\n if color_format == 'hex':\\n main_color = rgbToHex(main_color)\\n \\n print(main_color)\\n\\n # Attempt to read next frame\\n success, image = vidcap.read()\\n count += 1\\n\\n if show_last_frame:\\n pil_img.show()\",\n \"def process_video(lane, fname, output):\\n\\tclip = VideoFileClip(fname)\\n\\toutput_name = output\\n\\toutput_clip = clip.fl_image(lane.pipeline)\\n\\toutput_clip.write_videofile(output_name, audio=False)\\n\\tprint ('Video processed successfully')\",\n \"def split_into_frames(filename_raw, thr_var_per_event=5e-4, downsampling_factor=2, disable_display=False,\\n filename_output_video=None):\\n\\n assert downsampling_factor == int(downsampling_factor), \\\"Error: downsampling_factor must be an integer\\\"\\n assert downsampling_factor >= 0, \\\"Error: downsampling_factor must be >= 0\\\"\\n\\n mv_adaptive_rate_iterator = AdaptiveRateEventsIterator(input_path=filename_raw,\\n thr_var_per_event=thr_var_per_event,\\n downsampling_factor=downsampling_factor)\\n\\n height, width = mv_adaptive_rate_iterator.get_size()\\n\\n if filename_output_video == None:\\n video_process = None\\n else:\\n assert not os.path.exists(filename_output_video)\\n video_process = FFmpegWriter(filename_output_video)\\n\\n if video_process or not disable_display:\\n img_bgr = np.zeros((height, width, 3), dtype=np.uint8)\\n\\n cv2.namedWindow(\\\"img\\\", cv2.WINDOW_NORMAL)\\n\\n for events in mv_adaptive_rate_iterator:\\n assert events.size > 0\\n start_ts = events[0][\\\"t\\\"]\\n end_ts = events[-1][\\\"t\\\"]\\n print(\\\"frame: {} -> {} delta_t: {} fps: {} nb_ev: {}\\\".format(start_ts, end_ts,\\n end_ts - start_ts,\\n 1e6 / (end_ts - start_ts),\\n events.size))\\n if video_process or not disable_display:\\n img = events_to_diff_image(events, sensor_size=(height, width))\\n img_bgr[...] = 0\\n img_bgr[img < 0, 0] = 255\\n img_bgr[img > 0, 1] = 255\\n\\n chunk_start_ts = events[0][\\\"t\\\"]\\n chunk_end_ts = events[-1][\\\"t\\\"]\\n delta_t_frame = chunk_end_ts - chunk_start_ts + 1\\n frame_txt = \\\"ts: {} -> {} delta_t: {} fps: {} (nb_ev): {}\\\".format(chunk_start_ts, chunk_end_ts,\\n delta_t_frame,\\n int(1.e6/delta_t_frame),\\n events.size)\\n img_bgr[20:45, ...] = 0\\n cv2.putText(img_bgr,\\n frame_txt,\\n (int(0.05 * width), 40),\\n cv2.FONT_HERSHEY_PLAIN, 1.0, (200, 200, 100))\\n\\n if video_process:\\n video_process.writeFrame(img_bgr.astype(np.uint8)[..., ::-1])\\n if not disable_display:\\n cv2.imshow(\\\"img\\\", img_bgr)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n\\n if video_process:\\n video_process.close()\\n if not disable_display:\\n cv2.destroyAllWindows()\",\n \"def start_video_feed_parsing(img_processor='hog'):\\n\\n video_capture = cv2.VideoCapture(0)\\n\\n while True:\\n _, frame = video_capture.read()\\n\\n frame = IMG_PROCESSORS[img_processor].mark_up_faces(frame)\\n cv2.imshow('Video', frame)\\n\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n\\n # When everything is done, release the capture\\n video_capture.release()\\n cv2.destroyAllWindows()\",\n \"def check_video_timestamps(movie_file, desired_format='.mp4', desired_framerate=30):\\n\\n check_video_format(movie_file, desired_format='.mp4', original_format='.avi')\\n\\n new_movie_file = movie_file+'_tt'+desired_format\\n if not os.path.isfile(new_movie_file):\\n #Convert file to 30 fps\\n cmd = ['ffmpeg', '-i', movie_file+desired_format]\\n cmd += ['-r', str(desired_framerate)]\\n cmd += ['-y', movie_file+'_t'+desired_format]\\n cmd_string = ''.join([\\\"%s \\\" % el for el in cmd]) \\n #print '-->Running: ', cmd_string\\n p = subprocess.Popen(cmd, shell=False)\\n p.wait()\\n\\n #Add timecode text to video\\n cmd = 'ffmpeg -i '+movie_file+'_t'+desired_format+' -vf drawtext=\\\\\\\"fontfile=/opt/X11/share/fonts/TTF/VeraMoBd.ttf: timecode=\\\\'00\\\\:00\\\\:00\\\\:00\\\\':rate=30: fontcolor=white@0.8: x=7: y=460\\\\\\\" -an -y '+movie_file+'_tt'+desired_format\\n args = shlex.split(cmd)\\n #print args\\n p = subprocess.Popen(args, shell=False)\\n p.wait()\\n\\n os.remove(movie_file+'_t'+desired_format)\\n\\n return new_movie_file\",\n \"def stream_frames(video_capture):\",\n \"def process_video(proc_state):\\n entry = proc_state.entry\\n workbench = proc_state.workbench\\n video_config = mgg.global_config['media_type:mediagoblin.media_types.video']\\n\\n queued_filepath = entry.queued_media_file\\n queued_filename = proc_state.get_queued_filename()\\n name_builder = FilenameBuilder(queued_filename)\\n\\n medium_filepath = create_pub_filepath(\\n entry, name_builder.fill('{basename}-640p.webm'))\\n\\n thumbnail_filepath = create_pub_filepath(\\n entry, name_builder.fill('{basename}.thumbnail.jpg'))\\n\\n # Create a temporary file for the video destination (cleaned up with workbench)\\n tmp_dst = NamedTemporaryFile(dir=workbench.dir, delete=False)\\n with tmp_dst:\\n # Transcode queued file to a VP8/vorbis file that fits in a 640x640 square\\n progress_callback = ProgressCallback(entry)\\n\\n dimensions = (\\n mgg.global_config['media:medium']['max_width'],\\n mgg.global_config['media:medium']['max_height'])\\n\\n # Extract metadata and keep a record of it\\n metadata = transcoders.VideoTranscoder().discover(queued_filename)\\n store_metadata(entry, metadata)\\n\\n # Figure out whether or not we need to transcode this video or\\n # if we can skip it\\n if skip_transcode(metadata):\\n _log.debug('Skipping transcoding')\\n\\n dst_dimensions = metadata['videowidth'], metadata['videoheight']\\n\\n # Push original file to public storage\\n _log.debug('Saving original...')\\n proc_state.copy_original(queued_filepath[-1])\\n\\n did_transcode = False\\n else:\\n transcoder = transcoders.VideoTranscoder()\\n\\n transcoder.transcode(queued_filename, tmp_dst.name,\\n vp8_quality=video_config['vp8_quality'],\\n vp8_threads=video_config['vp8_threads'],\\n vorbis_quality=video_config['vorbis_quality'],\\n progress_callback=progress_callback,\\n dimensions=dimensions)\\n\\n dst_dimensions = transcoder.dst_data.videowidth,\\\\\\n transcoder.dst_data.videoheight\\n\\n # Push transcoded video to public storage\\n _log.debug('Saving medium...')\\n mgg.public_store.copy_local_to_storage(tmp_dst.name, medium_filepath)\\n _log.debug('Saved medium')\\n\\n entry.media_files['webm_640'] = medium_filepath\\n\\n did_transcode = True\\n\\n # Save the width and height of the transcoded video\\n entry.media_data_init(\\n width=dst_dimensions[0],\\n height=dst_dimensions[1])\\n\\n # Temporary file for the video thumbnail (cleaned up with workbench)\\n tmp_thumb = NamedTemporaryFile(dir=workbench.dir, suffix='.jpg', delete=False)\\n\\n with tmp_thumb:\\n # Create a thumbnail.jpg that fits in a 180x180 square\\n transcoders.VideoThumbnailerMarkII(\\n queued_filename,\\n tmp_thumb.name,\\n 180)\\n\\n # Push the thumbnail to public storage\\n _log.debug('Saving thumbnail...')\\n mgg.public_store.copy_local_to_storage(tmp_thumb.name, thumbnail_filepath)\\n entry.media_files['thumb'] = thumbnail_filepath\\n\\n # save the original... but only if we did a transcoding\\n # (if we skipped transcoding and just kept the original anyway as the main\\n # media, then why would we save the original twice?)\\n if video_config['keep_original'] and did_transcode:\\n # Push original file to public storage\\n _log.debug('Saving original...')\\n proc_state.copy_original(queued_filepath[-1])\\n\\n # Remove queued media file from storage and database\\n proc_state.delete_queue_file()\",\n \"def frame_pre_process(self, frame):\\n assert len(frame.shape) == 3, \\\\\\n \\\"Expected input frame in (H, W, C) format proposed\\\"\\n assert frame.shape[2] in [3, 4], \\\\\\n \\\"Expected BGR or BGRA input process\\\"\\n # setup the frame in the original format\\n \\n #orig_image = frame.copy()\\n original_image = frame.copy()\\n \\n # creating the frame transpose conversion\\n frame = frame.transpose((2, 0, 1)) # Converting from HWC to CHW\\n \\n # creating the frame dimensions\\n frame = np.expand_dims(frame, axis=0)\\n \\n # return the frames outcome\\n return (frame)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description = 'Transform Video Right format')\\n parser.add_argument(\\n \\\"--input_video_file\\\", help=\\\"Path to video file\\\",\\n default=None, required=True)\\n parser.add_argument(\\n \\\"--output_video_file\\\", help=\\\"Path to the right format video file '.mp4'\\\",\\n default=None, required=True)\\n return parser.parse_args()\",\n \"def visualize_flow(src, flow_comp_func):\\n\\n # Flag specifying whether this is the first frame or not.\\n first_frame = True\\n \\n # Initialize video stream.\\n video_capture = cv2.VideoCapture(src)\\n if not video_capture.isOpened():\\n raise RuntimeError(\\\"Error opening video stream.\\\")\\n \\n # Previous frame buffer and results array.\\n prev = None\\n res = []\\n \\n # Set frame counter.\\n count = 0\\n FRAME_LIM = 200\\n \\n # While there is video and while below frame index limit.\\n while video_capture.isOpened() and count < FRAME_LIM:\\n\\n # Increment frame count.\\n count += 1\\n print(\\\"Processing frame {0}/{1}\\\".format(count, FRAME_LIM))\\n\\n # Get next frame.\\n ret, frame = video_capture.read()\\n if ret:\\n frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n \\n # If first frame ...\\n if first_frame:\\n \\n # Set frame as previous frame.\\n prev = frame_gray\\n prev_original = frame\\n \\n # Set first frame flag to false.\\n first_frame = False\\n\\n else:\\n\\n # Compute flow using current frame and frame\\n # in previous buffer.\\n u, v = flow_comp_func(prev.astype(float)/255.0, frame_gray.astype(float)/255.0)\\n \\n\\n ### TODO - remove ###\\n # import pdb\\n # pdb.set_trace()\\n # fig2, ((ax2_11, ax2_12), (ax2_21, ax2_22)) = plt.subplots(2, 2)\\n # ax2_11.imshow(prev)\\n # ax2_12.imshow(frame_gray)\\n # show_flow(u, v, ax2_21, type='angle')\\n # show_flow(u, v, ax2_22, type='field', set_aspect=True)\\n # fig2.suptitle('Horn−Schunck Optical Flow')\\n ######\\n\\n # Add optical flow visualization to image in prev buffer.\\n vis_nxt = superimpose_field(u, v, prev_original)\\n\\n prev = frame_gray\\n prev_original = frame\\n\\n # Store visualization in results buffer\\n res.append(vis_nxt)\\n\\n else:\\n break\\n \\n # Release stream.\\n video_capture.release()\\n\\n # Create gif file from images.\\n imageio.mimsave('roundabout_hs.gif', res)\",\n \"def __call__(self, video_path, per_frames = 1 , offset = None):\\n \\n cap = cv2.VideoCapture(video_path)\\n \\n if not cap.isOpened():\\n raise Exception(\\\"Video file does not exist or is invalid\\\")\\n\\n \\n if offset:\\n cap.set(cv2.CAP_PROP_POS_MSEC, offset)\\n \\n \\n info = []\\n\\n while cap.isOpened():\\n ret, frame = cap.read()\\n if ret:\\n if cap.get(cv2.CAP_PROP_POS_FRAMES) % per_frames == 0:\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\\n faces_info = self.detect_faces_from_image(frame,\\n desired_width=224, desired_height=224) \\n if faces_info:\\n for element in faces_info:\\n face_img = image.img_to_array(element[1])\\n\\n face_img = utils.preprocess_input(face_img, version=1)\\n face_img = np.expand_dims(face_img, axis=0)\\n\\n features = self.vgg_feature_extractor.predict(face_img)\\n label = self.gender_svm.predict(features)[0]\\n decision_value = round(self.gender_svm.decision_function(features)[0], 3)\\n\\n bounding_box = element[0][0]\\n detection_score = round(element[5], 3)\\n bbox_length = bounding_box.bottom() - bounding_box.top()\\n\\n info.append([\\n cap.get(cv2.CAP_PROP_POS_FRAMES), bounding_box, (bbox_length, bbox_length), label,\\n decision_value, detection_score\\n ])\\n\\n else:\\n break\\n cap.release()\\n info = pd.DataFrame.from_records(info, columns = ['frame', 'bb', 'size','label', 'decision', 'conf'])\\n return info\",\n \"def convert(processed_dir: str, video_file: str):\\n\\n video_name = osp.splitext(osp.basename(video_file))[0]\\n out_dir = processed_dir + video_name\\n\\n # create img dir\\n if not osp.exists(processed_dir):\\n os.mkdir(processed_dir)\\n\\n # Create dir for video file if not existent\\n # this is where we save our images\\n if not osp.exists(out_dir):\\n os.mkdir(out_dir)\\n\\n if osp.exists(out_dir):\\n os.mkdir(out_dir + \\\"/kermit/\\\")\\n os.mkdir(out_dir + \\\"/not_kermit/\\\")\\n\\n # open video file for processing\\n cap = cv.VideoCapture(video_file)\\n frame_rate = cap.get(5) # frame rate\\n\\n sec = 0\\n total_count = (60*25)+50 # just an approximation\\n pbar = tqdm.tqdm(total=total_count, leave=False)\\n\\n count = 0\\n while (cap.isOpened()):\\n frame_id = cap.get(1) # current frame number\\n frame_exists, curr_frame = cap.read()\\n\\n if not frame_exists:\\n break\\n else:\\n if (frame_id % math.floor(frame_rate) == 0):\\n # output is : video_file/<video_file>_frameNr.jpg\\n cv.imwrite(osp.join(out_dir, '{}_{}.jpg'.format(video_name,count)), curr_frame)\\n count = count + 1\\n pbar.update(1)\\n\\n pbar.close()\\n # release resources\\n cap.release()\",\n \"def _unroll_video(self, video: int) -> None:\\n video_file = self.dataset_name + '_' + str(video).zfill(2) + '.mp4'\\n\\n # Create camera directory to store all frames\\n camera = 'camera' + str(video).zfill(2)\\n camera_dir = os.path.join(self.videos_dir, camera)\\n os.mkdir(camera_dir)\\n\\n if self.image_format == 'jpeg':\\n unroll = subprocess.run([\\\"ffmpeg\\\", \\\"-i\\\", os.path.join(self.dataset_dir, video_file), \\\"-qscale:v\\\", \\\"2\\\", \\\"-vf\\\", \\\"scale=1280:720\\\",\\n os.path.join(camera_dir, self.frame_format + \\\".\\\" + self.image_format)])\\n else:\\n unroll = subprocess.run([\\\"ffmpeg\\\", \\\"-i\\\", os.path.join(self.dataset_dir, video_file), \\\"-vf\\\", \\\"scale=1280:720\\\",\\n os.path.join(camera_dir, self.frame_format + \\\".\\\" + self.image_format)])\\n # print(\\\"The exit code was: %d\\\" % unroll.returncode)\",\n \"def __init__(self,vid_path:str,num_frames:int=None,vid_flow_direction:str='left'):\\n \\n self.num_frames=num_frames\\n if vid_path.split('.')[-1]=='cine' or vid_flow_direction!='left':\\n #This is a cine file or needs to be rotated, convert to mp4\\n print('Converting .cine file to mp4 (lossless)')\\n #detect platform so we can correct file paths for ffmpeg\\n is_win=re.compile('.*[Ww]in.*')\\n if is_win.match(sys.platform):\\n corrected_vid_path='\\\"'+vid_path+'\\\"'\\n else:\\n #Put escape characters in front of spaces in file name\\n corrected_vid_path=[]\\n for c in vid_path:\\n if c==' ':\\n corrected_vid_path.append('\\\\\\\\')\\n corrected_vid_path.append(c)\\n corrected_vid_path=''.join(corrected_vid_path)\\n if vid_flow_direction=='up':\\n rotate='-vf \\\"transpose=2\\\" '\\n elif vid_flow_direction=='left':\\n rotate=''\\n elif vid_flow_direction=='right':\\n rotate='-vf \\\"transpose=2,transpose=2\\\" '\\n else:\\n raise Exception(\\\"vid_flow_direction must be 'up', 'left' or 'right'\\\")\\n if num_frames!=None:\\n frames='-frames:v {0} '.format(num_frames)\\n else:\\n frames=''\\n os_handle,new_file_path=tempfile.mkstemp(suffix='.mp4')\\n #close file, we don't work with it directly\\n os.close(os_handle)\\n ffmpeg_command='ffmpeg -y -i {orig_file} {frames}{rotate}-f mp4 -crf 0 {new_file}'.format(orig_file=corrected_vid_path,rotate=rotate,new_file=new_file_path,frames=frames)\\n print(ffmpeg_command)\\n list(os.popen(ffmpeg_command))\\n self.vid_path=new_file_path\\n self.delete_file=True\\n stats=os.stat(new_file_path)\\n if stats.st_size==0:\\n raise Exception('File conversion failed, check that ffmpeg is on PATH')\\n else:\\n #Not a cine\\n self.vid_path=vid_path\\n self.delete_file=False\",\n \"def process(self, inputs, n_frame_skips=5, **kwargs):\\n # Convert all supported data types to Pillow\\n inputs = self.ensure_loaded(inputs)\\n\\n # Check if video -> Use video process\\n is_video = self.check_is_video(inputs)\\n if is_video:\\n return self.process_video(inputs, n_frame_skips, **kwargs)\\n\\n # Else return single frame output\\n return self._process(inputs, **kwargs)\",\n \"def detect_from_video(config: Dict):\\n video = config['inference']['video_input']['video_input_path']\\n vp = VideoProcessing(video=video)\\n vp.generate_frames(export_path=config['inference']['video_input']['video_to_frames_export_path'])\\n if config['inference']['video_input']['video_to_frames_export_path'] == config['inference']['predicted_frames_export_path']:\\n print(\\\"[Warning]... You have given Video to frame path same as prediction output path /nPredicted output will overwrite video to frame\\\")\\n img_height = config['inference']['img_height']\\n img_width = config['inference']['img_width']\\n model = ssd_300(image_size=(img_height, img_width, 3),\\n n_classes=config['inference']['n_classes'],\\n mode='inference',\\n l2_regularization=0.0005,\\n scales=[0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05], # The scales for MS COCO are [0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05]\\n aspect_ratios_per_layer=[[1.0, 2.0, 0.5],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\\n [1.0, 2.0, 0.5],\\n [1.0, 2.0, 0.5]],\\n two_boxes_for_ar1=True,\\n steps=[8, 16, 32, 64, 100, 300],\\n offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\\n clip_boxes=False,\\n variances=[0.1, 0.1, 0.2, 0.2],\\n normalize_coords=True,\\n subtract_mean=[123, 117, 104],\\n swap_channels=[2, 1, 0],\\n confidence_thresh=0.5,\\n iou_threshold=0.45,\\n top_k=200,\\n nms_max_output_size=400)\\n\\n # Load the trained weights into the model.\\n weights_path = config['inference']['weights_path']\\n\\n model.load_weights(weights_path, by_name=True)\\n \\n # Working with image\\n all_images = glob.glob(f\\\"{config['inference']['video_input']['video_to_frames_export_path']}/*/*\\\")\\n \\n # Setting Up Prediction Threshold\\n confidence_threshold = config['inference']['confidence_threshold']\\n \\n # Setting Up Classes (Note Should be in same order as in training)\\n classes = config['inference']['classes']\\n \\n vp.existsFolder(f\\\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}\\\")\\n # Working with image\\n for current_img in tqdm(all_images):\\n current_img_name = current_img.split('/')[-1]\\n orig_image = cv2.imread(current_img)\\n input_images = [] # Store resized versions of the images here\\n img = image.load_img(current_img, target_size=(img_height, img_width))\\n img = image.img_to_array(img) \\n input_images.append(img)\\n input_images = np.array(input_images)\\n \\n # Prediction\\n y_pred = model.predict(input_images)\\n\\n # Using threshold\\n y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\\n \\n # Drawing Boxes\\n for box in y_pred_thresh[0]:\\n xmin = box[2] * orig_image.shape[1] / img_width\\n ymin = box[3] * orig_image.shape[0] / img_height\\n xmax = box[4] * orig_image.shape[1] / img_width\\n ymax = box[5] * orig_image.shape[0] / img_height\\n \\n label = f\\\"{classes[int(box[0])]}: {box[1]:.2f}\\\"\\n cv2.rectangle(orig_image, (int(xmin), int(ymin)), (int(xmax),int(ymax)), (255, 0, 0), 2)\\n cv2.putText(orig_image, label, (int(xmin), int(ymin)), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 2, cv2.LINE_AA)\\n cv2.imwrite(f\\\"{config['inference']['predicted_frames_export_path']}/{video.split('.')[0]}/{current_img_name}\\\", orig_image)\\n \\n # Creating video\\n vp.generate_video(import_path=config['inference']['predicted_frames_export_path'],\\n export_path=config['inference']['video_input']['video_output_path'])\",\n \"def testSetVideoFrame():\\n\\n\\t# create output\\n\\toutputFileName = \\\"testSetVideoFrame.mov\\\"\\n\\touputFile = av.OutputFile( outputFileName )\\n\\n\\t# create video frame and codec\\n\\timageDesc = av.VideoFrameDesc()\\n\\timageDesc.setWidth( 1920 )\\n\\timageDesc.setHeight( 1080 )\\n\\timageDesc.setDar( 1920, 1080 )\\n\\n\\tinputPixel = av.Pixel()\\n\\tinputPixel.setColorComponents( av.eComponentRgb );\\n\\tinputPixel.setPlanar( False );\\n\\n\\timageDesc.setPixel( inputPixel );\\n\\n\\tinputVideoCodec = av.VideoCodec( av.eCodecTypeEncoder, \\\"mpeg2video\\\" );\\n\\tinputVideoCodec.setImageParameters( imageDesc );\\n\\n\\t# create transcoder and add a video stream\\n\\ttranscoder = av.Transcoder( ouputFile )\\n\\ttranscoder.add( \\\"\\\", 0, \\\"xdcamhd422\\\", inputVideoCodec )\\n\\tvideoEssence = transcoder.getStreamTranscoder( 0 ).getCurrentEssence()\\n\\n\\t# start process\\n\\ttranscoder.init()\\n\\touputFile.beginWrap()\\n\\n\\t# process 255 frames\\n\\tfor i in range(0,255):\\n\\t\\ttranscoder.processFrame()\\n\\t\\t# set video frame\\n\\t\\tframe = av.VideoFrame( imageDesc )\\n\\t\\tframe.getBuffer().assign(frame.getBuffer().size(), i)\\n\\t\\tvideoEssence.setFrame( frame )\\n\\n\\t# end process\\n\\touputFile.endWrap()\\n\\n\\t# get dst file of transcode\\n\\tdst_inputFile = av.InputFile( outputFileName )\\n\\tprogress = av.NoDisplayProgress()\\n\\tdst_inputFile.analyse( progress, av.InputFile.eAnalyseLevelFast )\\n\\tdst_properties = dst_inputFile.getProperties()\\n\\tdst_videoStream = dst_properties.videoStreams[0]\\n\\n\\tassert_equals( \\\"mpeg2video\\\", dst_videoStream.codecName )\\n\\tassert_equals( \\\"MPEG-2 video\\\", dst_videoStream.codecLongName )\\n\\tassert_equals( 1920, dst_videoStream.width )\\n\\tassert_equals( 1080, dst_videoStream.height )\\n\\tassert_equals( 16, dst_videoStream.dar.num )\\n\\tassert_equals( 9, dst_videoStream.dar.den )\",\n \"def preprocess_input(x, data_format=None): # pylint: disable=unused-argument\\n return x\",\n \"def video_encoding(self):\\n self.output_file = outputs_filenames(self.input, self.output_file)\\n\\n if self.resume and (self.temp / 'done.json').exists():\\n set_logging(self.logging, self.temp)\\n else:\\n setup(self.temp, self.resume)\\n set_logging(self.logging, self.temp)\\n print(self.queue)\\n framenums = split_routine(self.input, self.scenes, self.split_method, self.temp, self.min_scene_len, self.queue, self.threshold)\\n\\n if self.extra_split:\\n framenums = extra_splits(input, framenums, self.extra_split)\\n\\n segment(self.input, self.temp, framenums)\\n extract_audio(input, self.temp, self.audio_params)\\n\\n chunk = get_video_queue(self.temp, self.resume)\\n\\n # Make encode queue\\n commands, self.video_params = compose_encoding_queue(chunk, self.temp, self.encoder, self.video_params, self.ffmpeg_pipe, self.passes)\\n log(f'Encoding Queue Composed\\\\n'\\n f'Encoder: {self.encoder.upper()} Queue Size: {len(commands)} Passes: {self.passes}\\\\n'\\n f'Params: {self.video_params}\\\\n\\\\n')\\n\\n self.workers = determine_resources(self.encoder, self.workers)\\n\\n self.encoding_loop(commands)\\n\\n try:\\n concatenate_video(self.temp, self.output_file, keep=self.keep)\\n\\n except Exception as e:\\n _, _, exc_tb = sys.exc_info()\\n print(f'Concatenation failed, FFmpeg error\\\\nAt line: {exc_tb.tb_lineno}\\\\nError:{str(e)}')\\n log(f'Concatenation failed, aborting, error: {e}\\\\n')\\n terminate()\\n\\n if self.vmaf:\\n plot_vmaf(self.input, self.output_file, model=self.vmaf_path)\",\n \"def _prepare_frame(self, frame):\\n\\n initial_h, initial_w = frame.shape[:2]\\n scale_h, scale_w = initial_h / float(self.input_height), initial_w / float(self.input_width)\\n\\n in_frame = cv2.resize(frame, (self.input_width, self.input_height))\\n in_frame = in_frame.transpose((2, 0, 1))\\n in_frame = in_frame.reshape(self.input_size)\\n\\n return in_frame, scale_h, scale_w\",\n \"def loadVideo( iFileName, iFrameSize = (576, 720) ):\\n import sys\\n import subprocess as sp\\n # ustvari klic ffmpeg in preusmeri izhod v cevovod\\n command = [ 'ffmpeg',\\n '-i', iFileName,\\n '-f', 'image2pipe',\\n '-pix_fmt', 'rgb24',\\n '-vcodec', 'rawvideo', '-']\\n pipe = sp.Popen(command, stdout = sp.PIPE, bufsize=10**8)\\n # definiraj novo spremeljivko\\n oVideo = np.array([])\\n iFrameSize = np.asarray( iFrameSize )\\n frameCount = 0\\n # zacni neskoncno zanko\\n while True:\\n frameCount += 1\\n# print( 'Berem okvir %d ...' % frameCount )\\n print(\\\"\\\\rBerem okvir %d ...\\\" % frameCount, end=\\\"\\\")\\n # preberi Y*X*3 bajtov (= 1 okvir)\\n raw_frame = pipe.stdout.read(np.prod(iFrameSize)*3)\\n # pretvori prebrane podatke v numpy polje\\n frame = np.fromstring(raw_frame, dtype='uint8') \\n # preveri ce je velikost ustrezna, sicer prekini zanko\\n if frame.size != (np.prod(iFrameSize)*3):\\n print(\\\" koncano!\\\\n\\\")\\n break;\\n # preoblikuj dimenzije in pretvori v sivinsko sliko\\n frame = colorToGray( frame.reshape((iFrameSize[0],iFrameSize[1],3)) )\\n # sprazni medpomnilnik \\n pipe.stdout.flush() \\n # vnesi okvir v izhodno sprememnljivko\\n if oVideo.size == 0:\\n oVideo = frame\\n oVideo = oVideo[...,None]\\n else:\\n oVideo = np.concatenate((oVideo,frame[...,None]), axis=2)\\n # zapri cevovod\\n pipe.terminate()\\n # vrni izhodno spremenljivko\\n return oVideo\",\n \"def process_video(filename, args, cfg, net):\\n # Split video into frames\\n images = split_video(filename)\\n # Set output dir\\n output_dir = args.output\\n # Add brackets and extension to filename\\n output_path = create_video_output_path(output_dir, cfg)\\n # Get height and width of 1st image\\n height, width, _ = check_img_size(images[0]).shape\\n # Create VideoWriter object\\n video = cv2.VideoWriter(output_path, \\n cv2.VideoWriter_fourcc(*'FMP4'), \\n cfg['video']['fps'], \\n (width, height))\\n for image in images:\\n # Process frames\\n img_steps = process_image(image, cfg, net)\\n # Check for --show-detections flag\\n output_img = check_if_adding_bboxes(args, img_steps) \\n # Write to video\\n video.write(output_img) \\n # Release video writer object\\n video.release()\",\n \"def seqIo_toVid(fName, ext='avi'):\\n\\n assert fName[-3:]=='seq', 'Not a seq file'\\n sr = seqIo_reader(fName)\\n N = sr.header['numFrames']\\n h = sr.header['height']\\n w = sr.header['width']\\n fps = sr.header['fps']\\n\\n out = fName[:-3]+ext\\n sw = skvideo.io.FFmpegWriter(out)\\n # sw = cv2.VideoWriter(out, -1, fps, (w, h))\\n timer = pb.ProgressBar(widgets=['Converting ', pb.Percentage(), ' -- ',\\n pb.FormatLabel('Frame %(value)d'), '/',\\n pb.FormatLabel('%(max)d'), ' [', pb.Timer(), '] ',\\n pb.Bar(), ' (', pb.ETA(), ') '], maxval=N)\\n\\n for f in range(N):\\n I, ts = sr.getFrame(f)\\n sw.writeFrame(Image.fromarray(I))\\n # sw.write(I)\\n timer.update(f)\\n timer.finish()\\n # cv2.destroyAllWindows()\\n # sw.release()\\n sw.close()\\n sr.close()\\n print(out + ' converted')\",\n \"def preprocess_frame(frame, v_crop=(0, 0), h_crop=(0, 0)):\\n\\n # heigth, width, _ = frame.shape\\n # frame = np.mean(frame, axis=2) / 255.0\\n # frame = frame[v_crop[0]:heigth - v_crop[1], h_crop[0]:width - h_crop[1]]\\n # frame = imresize(frame, size=(80, 80), interp='nearest')\\n\\n frame = frame[::2, ::2]\\n frame = np.mean(frame, axis = 2).astype(np.uint8)\\n return frame\",\n \"def infer_on_stream(args, client):\\n # Initialise the class\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n ### TODO: Load the model through `infer_network` ###\\n infer_network.load_model(args.model,args.cpu_extension,args.device)\\n input_shape = infer_network.get_input_shape()\\n input_image_width = input_shape[3]\\n input_image_height=input_shape[2]\\n \\n ### TODO: Handle the input stream ###\\n try: # try opening input file as image if file is not image, if it throw exception then try opening as video. \\n frame=cv2.imread(args.input)\\n IS_IMAGE = True\\n hasFrame =True\\n out_image_file = os.path.splitext(args.input)[0] + \\\"_inferred\\\" + \\\".jpg\\\"\\n #print(\\\"Successfully Opened Image\\\")\\n fps=0\\n frame_height = frame.shape[0]\\n frame_width = frame.shape[1]\\n except :\\n try: # Trying opening as video if it throw exception it means input is neither valid video nor image file.\\n if(args.input =='0'): # check if input is webcam\\n #print('input is webcam')\\n args.input =int(args.input) \\n video=cv2.VideoCapture(args.input) #Open video stream\\n if (video.isOpened()): # check video stream is successfully opened\\n hasFrame,frame=video.read()\\n IS_IMAGE = False\\n fps=int(video.get(cv2.CAP_PROP_FPS))\\n \\n #print (\\\"FPS is {}\\\".format(fps))\\n frame_height = frame.shape[0]\\n frame_width = frame.shape[1]\\n \\n if(args.input): \\n out_video_file = os.path.splitext(args.input)[0] + \\\"_inferred\\\" + \\\".avi\\\"\\n else: # if webcam input fixed output filename\\n out_video_file = 'webcam_inferred.avi'\\n \\n out_video=cv2.VideoWriter(out_video_file,cv2.CAP_OPENCV_MJPEG,cv2.VideoWriter_fourcc('M','J','P','G'), fps, (frame_width,frame_height))\\n \\n else: # Video stream is failed to open\\n print('Video capture is not opened properly, Exiting')\\n video.release()\\n exit()\\n except: # Both try to open input as video or image failed , exiting \\n \\n print(\\\" Error Opening input!!! ,Input is neither valid image nor video file, please provide right input. Exiting !!!\\\")\\n exit()\\n \\n # initialize video stats variables \\n last_stat_person_in_frame =-1\\n last_stat_total_count =-1\\n THREESHOLD_NO_OF_SECONDS_FOR_PERSON_LEFT_SCENE = 1.5\\n THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE = int(THREESHOLD_NO_OF_SECONDS_FOR_PERSON_LEFT_SCENE*fps)\\n frame_no =1\\n video_stats ={'video_state' : 'first_frame' , 'person_in_frame' : 0, 'person_time_spent_in_frame' :0 ,'no_person_in_consecutive_frames' :0 ,'total_count':0, 'person_exited_frame' : False,'Box_coordinate' :[None,None,None,None]} # Video statistics dictionary which will be updated as frames by get processed by analyze_frame() function\\n \\n decision_param = {'THRESHOLD_PROB' : prob_threshold , 'THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE' :THREESHOLD_NO_OF_FRAMES_FOR_PERSON_LEFT_SCENE} # Decision threshold parameters\\n \\n ### TODO: Read from the video capture ###\\n while(hasFrame and cv2.waitKey(1)<0): #Read video frame by frame\\n \\n ### TODO: Pre-process the image as needed ###\\n input_image = cv2.resize(frame,(input_image_width, input_image_height))\\n input_image = input_image.transpose((2,0,1))\\n input_image = input_image.reshape(1, 3, input_image_height, input_image_width)\\n \\n ### TODO: Start asynchronous inference for specified request ###\\n t0=time.time()\\n async_infer_req_handle=infer_network.exec_net(input_image,0)\\n \\n ### TODO: Wait for the result ###\\n infer_network.wait(async_infer_req_handle)\\n t1=time.time()\\n infer_time =round((t1-t0)*1000)\\n #print(\\\"For frame no. {} , infer taken {} miliseconds\\\".format(frame_no, infer_time)) \\n \\n ### TODO: Get the results of the inference request ###\\n obj_det_out=infer_network.get_output(async_infer_req_handle)['DetectionOutput']\\n \\n ### TODO: Extract any desired stats from the results ###\\n #Function to analyze frame and update video statistics \\n person_detected = analyze_frame(obj_det_out,video_stats,decision_param)\\n \\n \\n \\n # if person detected draw box on image frame\\n if(person_detected):\\n x1 =int(video_stats['Box_coordinate'][0] *frame_width)\\n y1 = int(video_stats['Box_coordinate'][1]*frame_height)\\n x2 =int(video_stats['Box_coordinate'][2]*frame_width)\\n y2 = int(video_stats['Box_coordinate'][3]*frame_height)\\n frame=cv2.rectangle(frame, (x1,y1), (x2,y2), (0,0,255), int(round(frame_height/150)), 8)\\n cv2.putText(frame,'Person :' + str(video_stats['total_count']),(x2,y2+5), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2, cv2.LINE_AA)\\n \\n # put frame_no , frame inference time, person in frame and total person stats in frame \\n cv2.putText(frame,'Frame No. ' + str(frame_no) +' Infer Time in ms: ' +str(infer_time),(10,20), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \\n cv2.putText(frame,'Current Count:' + str(video_stats['person_in_frame']),(10,40), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \\n cv2.putText(frame,'Total No. of Person:' + str(video_stats['total_count']),(10,60), cv2.FONT_HERSHEY_SIMPLEX,0.7, (0,255,0), 1, cv2.LINE_AA) \\n \\n if(not IS_IMAGE): # if input is video put current person duration stat in frame\\n cv2.putText(frame,'Current person duration' + str(video_stats['person_time_spent_in_frame']/fps),(10,80), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,255,0), 1, cv2.LINE_AA)\\n \\n ### TODO: Calculate and send relevant information on ###\\n ### current_count, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n #Here statistics send over MQTT \\n \\n #sending personduration to MQTT server whenever person exit frame\\n if(video_stats['person_exited_frame'] and (not IS_IMAGE)): # if person exited frame and input is video then send last exited person duration to MQTT server.\\n json_last_person_time_spent =json.dumps({'duration': video_stats['person_time_spent_in_frame']/fps})\\n client.publish('person/duration',json_last_person_time_spent)\\n video_stats['person_exited_frame'] =False\\n #print('Person duration :{}'.format(json_last_person_time_spent))\\n \\n #sending current count to MQTT server\\n if((last_stat_person_in_frame !=video_stats['person_in_frame']) or (last_stat_counter >9)): # Instead of sending current count every frame , send current count when it is updated or after every 10 frames. Network data saving!!! \\n count_data = {'count' :video_stats['person_in_frame']}\\n json_count_data = json.dumps(count_data)\\n client.publish('person',json_count_data)\\n last_stat_person_in_frame = video_stats['person_in_frame']\\n #print('Current Count {}'.format(json_count_data))\\n last_stat_counter = -1\\n last_stat_counter+=1 \\n \\n #sending total count to MQTT server\\n if(last_stat_total_count !=video_stats['total_count']): # Instead of sending total count every frame , send total count when it is updated. Network data saving!!! \\n total_count_data = {'total':video_stats['total_count']}\\n json_total_count_data = json.dumps(total_count_data)\\n client.publish('person',json_total_count_data)\\n last_stat_total_count =video_stats['total_count']\\n # print('Total Count {}'.format(json_total_count_data))\\n \\n \\n ### TODO: Send the frame to the FFMPEG server ###\\n if ( not IS_IMAGE):\\n sys.stdout.buffer.write(frame) \\n sys.stdout.flush()\\n \\n \\n #show frame (only for local pc) \\n #frame1 = cv2.resize(frame,(frame_width,frame_height))\\n #cv2.imshow('Inferred Image' ,frame1)\\n \\n ### TODO: Write an output image if `single_image_mode` ###\\n if (IS_IMAGE):\\n cv2.imwrite(out_image_file,frame)\\n cv2.waitKey(0)\\n break\\n else:\\n out_video.write(frame)\\n hasFrame,frame=video.read()\\n frame_no+=1\\n \\n # Sending person duration if last frame ended in 'missing_person_in_frame' or 'person_in_frame' state\\n if((video_stats['video_state']=='missing_person_in_frame' or video_stats['video_state']=='person_in_frame' )and (not IS_IMAGE)):\\n json_person_time_spent =json.dumps({'duration': video_stats['person_time_spent_in_frame']/fps})\\n client.publish('person/duration',json_person_time_spent)\\n client.disconnect()\\n if (not IS_IMAGE): \\n video.release()\\n out_video.release()\\n cv2.destroyAllWindows()\",\n \"def preprocess(self, frame: np.ndarray) -> torch.TensorType:\\n tensor = cv.resize(frame, (self.IMGSZ, self.IMGSZ)) \\n tensor = tensor.transpose(2, 0, 1)\\n tensor = torch.from_numpy(tensor)\\n tensor = torch.unsqueeze(tensor, 0)\\n tensor = tensor.half() if self.half else tensor.float()\\n tensor = tensor / 255.0\\n tensor = tensor.to(self.device)\\n\\n return tensor\",\n \"def process_video(self, input_path, output_path, debug=False):\\n clip = VideoFileClip(input_path)\\n if debug:\\n test_clip = clip.fl_image(self.process_image_debug)\\n else:\\n test_clip = clip.fl_image(self.process_image)\\n test_clip.write_videofile(output_path)\",\n \"def process_data(self, clip_name) -> Preprocessor:\\n\\n config: Config = Config.get_config()\\n\\n folder_name = config.video_data\\n video_data_file = ''.join(clip_name.split('.')[:-1]) + '.json'\\n video = Video.from_json(os.path.join(folder_name, video_data_file))\\n\\n # Convert to usable data type period_running_person division, alle fragment soorten\\n preprocessor = Preprocessor(video)\\n\\n return preprocessor\",\n \"def __init__(self, data_path, batch_size, video_size, mode=\\\"first80\\\"):\\n self._batch_size = batch_size\\n self._video_size = video_size\\n\\n\\n # KTH video splits \\n splits = [[11, 12, 13, 14, 15, 16, 17, 18], # train\\n [19, 20, 21, 23, 24, 25, 1, 4], # validation\\n [22, 2, 3, 5, 6, 7, 8, 9, 10]] # test\\n \\n label_mapping = {\\\"boxing\\\":0,\\n \\\"handclapping\\\":1, \\n \\\"handwaving\\\":2,\\n \\\"jogging\\\":3,\\n \\\"running\\\":4,\\n \\\"walking\\\":5}\\n self._num_classes = len(label_mapping)\\n\\n # file containing KTH video frame clip intervals\\n sequence_list = os.path.join(data_path, \\\"00sequences.txt\\\")\\n sequences = self._read_sequence_list(sequence_list)\\n \\n \\n # clip and labels for each split, will be converted into [np.arrays()] format\\n self._clips = [[] for _ in range(3)] # resized videos\\n self._labels = [[] for _ in range(3)] # labels\\n self._fns = [[] for _ in range(3)] # file names\\n # read video into np array and create label according to splits \\n for video_file in glob.glob(os.path.join(data_path, \\\"*.avi\\\")):\\n fn = os.path.basename(video_file)\\n fn = fn[0:len(fn) - 4]\\n \\n video = load_video(video_file, self._video_size)\\n person_index = int(fn.split(\\\"_\\\")[0][-2:len(fn.split(\\\"_\\\")[0])])\\n split = [i for i, j in enumerate(splits) if person_index in j][0]\\n label = label_mapping[fn.split(\\\"_\\\")[1]]\\n\\n # obtain clips from video\\n video_key_in_sequences = \\\"_\\\".join(fn.split(\\\"_\\\")[0:len(fn.split(\\\"_\\\")) - 1])\\n print video_key_in_sequences\\n\\n if mode == \\\"episodes\\\":\\n for clip_index, clip_range in enumerate(sequences[video_key_in_sequences]):\\n self._labels[split].append(np.eye(len(label_mapping))[label]) \\n self._clips[split].append(video[clip_range[0] - 1:clip_range[1] - 1, :, :, :])\\n self._fns[split].append(fn + \\\"_\\\" + str(clip_index))\\n elif mode == \\\"first80\\\":\\n self._labels[split].append(np.eye(len(label_mapping))[label]) \\n self._clips[split].append(video[0:80, :, :, :])\\n self._fns[split].append(fn) \\n else:\\n raise NotImplementedError(\\\"Unknown preprocess mode.\\\")\\n\\n # maximum length for all clips, limit for padding\\n self._clip_length = np.array(\\\\\\n reduce(lambda a, b: a + [elem.shape[0] for elem in b], \\n self._clips, [])).max() \\n\\n for split in range(3):\\n for clip_index, (clip, label) in \\\\\\n enumerate(zip(self._clips[split], self._labels[split])):\\n self._clips[split][clip_index] = np.pad(clip, \\\\\\n ((0, self._clip_length - clip.shape[0]), (0, 0), (0, 0), (0, 0)),\\\\\\n mode=\\\"constant\\\", constant_values=0)\\n # shuffling\\n shuffle_index = range(len(self._clips[split]))\\n random.shuffle(shuffle_index)\\n self._clips[split] = [self._clips[split][i] for i in shuffle_index]\\n self._labels[split] = [self._labels[split][i] for i in shuffle_index]\\n self._fns[split] = [self._fns[split][i] for i in shuffle_index]\\n \\n self._clips[split] = np.concatenate(\\\\\\n [np.expand_dims(i, axis=0) for i in self._clips[split]]) \\n self._labels[split] = np.concatenate(\\\\\\n [np.expand_dims(i, axis=0) for i in self._labels[split]])\\n\\n print self._clips[0].shape\\n print self._labels[0].shape\\n self._batch_index = [0 for _ in range(3)]\",\n \"def local_video(**kwargs):\\n output_dir = run_video_preprocess(\\n video_file=input_video,\\n roi_locations=kwargs[\\\"roi_locations\\\"],\\n preprocess_analysis=kwargs[\\\"preprocess_analysis\\\"],\\n database=False\\n )\\n\\n run_analysis_pipeline(\\n preprocess_analysis=kwargs[\\\"preprocess_analysis\\\"],\\n json_filepath=output_dir,\\n )\",\n \"def video_to_frames(video_filename,output_dir):\\n cap = cv2.VideoCapture(video_filename)\\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\\n vid_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n vid_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n vid_fps = int(cap.get(cv2.CAP_PROP_FPS))\\n print(\\\"vid_res=%d x %d, fps=%d\\\\n\\\" % (vid_width, vid_height,vid_fps))\\n crop_width=int(vid_width/128)*128\\n crop_height=int(vid_height/128)*128\\n grab_step=int(vid_fps/2)\\n if cap.isOpened() and video_length > 0:\\n count = 0\\n frame_id=0\\n success, image = cap.read()\\n while success and frame_id <= 9999:\\n if count%grab_step==0:\\n crop_img = image[0:crop_width, 0:crop_height]\\n resized_img = cv2.resize(crop_img, (128, 128)) \\n cv2.imwrite(output_dir+\\\"/frame%05d.jpg\\\" % frame_id, resized_img)\\n frame_id+=1\\n success, image = cap.read()\\n count += 1\\n return 0\",\n \"def preprocess_frame(self, frame):\\n state = torch.Tensor(frame)\\n return gpuify(state, self.gpu_id)\",\n \"def preprocess_raw(self):\\n pass\",\n \"def process_vid_file(vid_file):\\n # dict that holds params for matching\\n params = {}\\n # scale for motion estimation\\n params['fScale'] = 1.0\\n # number of descriptors\\n params['nFeat'] = 2000\\n # minimal number of descriptors\\n params['nMinKp'] = 50\\n # minimal number of matched descriptors\\n params['nMinMatch'] = 30\\n # maximum offset in flow \\n params['fVhThresh'] = 32.0\\n # params for image quality (motion blur)\\n params['fQualityThresh'] = 5.0\\n params['fQualityRatio'] = 0.2\\n\\n # get video stats\\n video_name = os.path.basename(vid_file[:-4])\\n video_name.replace(' ', '')\\n output_frame_list = []\\n output_homography = []\\n frame_index = 0\\n\\n # open video file\\n cap = cv2.VideoCapture(vid_file)\\n if not cap.isOpened():\\n print \\\"Can not open video file: {:s}\\\".format(vid_file)\\n return frame_pairs\\n \\n # fetch the first frame\\n ret, prev_frame = cap.read()\\n if (not ret) or (prev_frame is None):\\n print \\\"Can not read video file: {:s}\\\".format(vid_file)\\n\\n start = time.time()\\n\\n # loop over all frames\\n while(True):\\n\\n # increase the counter\\n frame_index += 1\\n\\n # read current frame\\n ret, frame = cap.read()\\n\\n # end of file?\\n if (not ret) or (prev_frame is None):\\n break\\n\\n # match the frames\\n M = match_frames(prev_frame, frame, params)\\n\\n # copy to previous frame\\n prev_frame = frame.copy()\\n\\n # save the frame number and the homography\\n if len(M) > 0:\\n output_frame_list.append(frame_index)\\n output_homography.append(M)\\n if len(output_homography) == 1:\\n output_homography.append(M)\\n # timing\\n end = time.time()\\n print \\\"Averge time per frame: {:2f} s. \\\".format(float(end-start)/frame_index)\\n print \\\"{:2d} valid frame pairs out of {:2d} total pairs\\\".format(len(output_frame_list), frame_index-1)\\n \\n return output_frame_list, output_homography\",\n \"def process_video(self, tmp_output_folder, video_name, video_num, total_videos):\\n vidcap = cv2.VideoCapture(join(tmp_output_folder, video_name))\\n print(f\\\"Processing video {video_num}/{total_videos} with name {video_name} \\\\n\\\")\\n\\n input_length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\\n frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n fps = int(vidcap.get(cv2.CAP_PROP_FPS))\\n\\n metadata = []\\n faces_all_frames = []\\n success, image = vidcap.read()\\n count = 0\\n frame = 0\\n while success:\\n if count % self.sample_every == 0:\\n height, width = image.shape[:2]\\n image = cv2.resize(image, (self.width, self.height), interpolation=cv2.INTER_CUBIC)\\n\\n # Convert from BGR color (OpenCV) to RGB color (face_recognition)\\n rgb_image = image[:, :, ::-1]\\n\\n # Find all the faces in the current frame of video\\n face_locations = face_recognition.face_locations(rgb_image)\\n faces = []\\n face_num = 0\\n # Display the results\\n for top, right, bottom, left in face_locations:\\n # Draw a box around the face\\n faces.append(image[top:bottom, left:right, :].copy())\\n metadata.append(\\n f\\\"{video_name},frame-{count}.face-{face_num}.jpg,{count},{face_num},{input_length},{fps},{frame_width},{frame_height},{top},{right},{bottom},{left}\\\\n\\\")\\n face_num += 1\\n faces_all_frames.append(faces)\\n\\n frame += 1\\n success, image = vidcap.read()\\n count += 1\\n video_num += 1\\n vidcap.release()\\n\\n with open(f\\\"{self.output_folder}/faces-pickle/{video_name}.pkl\\\", \\\"wb\\\") as f_out:\\n pickle.dump(faces_all_frames, f_out)\\n return metadata\",\n \"def generate_ffmpeg_node_structure(parser):\\n type_getters = {bool : parser.getboolean, float : parser.getfloat,\\n int : parser.getint}\\n create_stream = lambda: {'inputs' : {}, 'filters' : {}}\\n stream_dict = {'audio' : create_stream(),\\n 'video' : create_stream()}\\n outputs = []\\n global_option = None\\n audio_structure = None\\n video_structure = None\\n\\n def get_options(node_name):\\n options = parser.options(node_name)\\n for unwanted in 'name', 'type', 'layer', 'stream':\\n try:\\n options.remove(unwanted)\\n except ValueError:\\n pass\\n\\n return options\\n\\n def create_node(element, *args, **kwargs):\\n factory = factory_type_dict()[element['type']]\\n parameters = parameter_type_dict()[element['type']]\\n\\n try:\\n kwargs.update({option:type_getters.setdefault(parameters()[option], parser.get)\\n (element['node'], option) for option in get_options(element['node'])})\\n except: # pylint:disable=bare-except\\n logging.error(f'Unable to instantiate node {element[\\\"node\\\"]} with arguments {kwargs}!')\\n logging.info(traceback.format_exc())\\n\\n return\\n\\n try:\\n node = factory(element['name'], *args, **kwargs)\\n except: # pylint:disable=bare-except\\n logging.error(f'Unable to instantiate node {element[\\\"node\\\"]} with arguments {kwargs}!')\\n logging.info(traceback.format_exc())\\n\\n return\\n if node is None:\\n logging.warning((f'Node {element[\\\"node\\\"]} has not been instantiated'))\\n\\n return node\\n\\n def preprocess_filters(stream):\\n new_filters = {}\\n all_inputs = []\\n all_outputs = list(stream['inputs'])\\n for layer, filter_element in stream['filters'].items():\\n skip = False\\n logging.debug(f'Preprocessing filter {filter_element[\\\"node\\\"]} (layer={layer}).')\\n inputs = parser.get(filter_element['node'], 'input_layer_string', fallback='')\\n logging.debug(f'Input layer string: {inputs}.')\\n inputs = filters.process_layer_string(inputs)\\n logging.info(f'Input layers: {inputs}.')\\n if len(inputs) == 0:\\n logging.warning((f'No input layers found for node {filter_element[\\\"node\\\"]}, '\\n 'removing!'))\\n continue\\n for input_layer in inputs:\\n if input_layer in all_inputs:\\n logging.warning(f'Removing node {filter_element[\\\"node\\\"]}, input collision!')\\n skip = True\\n outputs = parser.get(filter_element['node'], 'output_layer_string', fallback='')\\n logging.debug(f'Output layer string: {outputs}.')\\n outputs = filters.process_layer_string(outputs)\\n outputs.append(layer)\\n logging.info(f'Output layers: {outputs}.')\\n for output_layer in outputs:\\n if output_layer in all_outputs:\\n logging.warning(f'Removing node {filter_element[\\\"node\\\"]}, output collision!')\\n skip = True\\n if skip:\\n all_inputs.extend(outputs)\\n all_outputs.extend(inputs)\\n all_inputs.extend(inputs)\\n all_outputs.extend(outputs)\\n if skip:\\n continue\\n new_filters[layer] = filter_element\\n\\n stream['filters'] = new_filters\\n\\n def process_filters(stream):\\n new_filters = stream['filters'].copy()\\n for layer, filter_element in stream['filters'].items():\\n logging.debug(f'Processing filter {filter_element[\\\"node\\\"]} (layer={layer}).')\\n inputs = parser.get(filter_element['node'], 'input_layer_string')\\n logging.debug(f'Input layer string: {inputs}.')\\n inputs = filters.process_layer_string(inputs)\\n logging.info(f'Input layers: {inputs}.')\\n if all([i in stream['inputs'] for i in inputs]):\\n filter_ = create_node(filter_element, stream['inputs'])\\n logging.info(f'Instantiated filter {filter_element[\\\"node\\\"]} (layer={layer})!')\\n new_filters.pop(layer)\\n if filter_ is None:\\n continue\\n\\n filter_ffmpeg, filter_outputs, _ = filter_\\n for i in inputs:\\n stream['inputs'].pop(i)\\n stream['inputs'][layer] = filter_ffmpeg\\n stream['inputs'].update(filter_outputs)\\n logging.debug(f'Current inputs: {stream[\\\"inputs\\\"]}')\\n\\n stream['filters'] = new_filters\\n logging.debug(f'Remaining filters: {stream[\\\"filters\\\"]}.')\\n logging.debug(f'Current inputs: {stream[\\\"inputs\\\"]}.')\\n if len(new_filters) > 0:\\n process_filters(stream)\\n\\n for section_name in parser.sections():\\n logging.info(f'Looking through node \\\\'{section_name}\\\\'.')\\n\\n section = parser[section_name]\\n\\n element_name = section.get('name', fallback='')\\n element_type = section.get('type', fallback='')\\n element_stream = section.get('stream', fallback='')\\n element_layer = section.getint('layer', fallback=-1)\\n element = {'node' : section_name, 'name' : element_name, 'type' : element_type,\\n 'layer' : element_layer, 'stream' : element_stream}\\n\\n logging.debug((f'Section details: (name={element_name}, type={element_type}, layer='\\n f'{element_layer}, stream={element_stream}).'))\\n\\n if element_name == '' or element_type == '' or element_stream == '' or element_layer == -1:\\n logging.warning(f'Skipping section {section_name}! Insufficient metadata.')\\n continue\\n\\n if element_stream not in ['audio', 'video']:\\n logging.warning(f'Skipping section {section_name}! Incorrect metadata.')\\n continue\\n\\n del element_name, element_type, element_layer, element_stream\\n\\n flag = base_type_dict().get(element['type'], utils.NoType)._flag\\n stream = stream_dict.get(element['stream'], 'video')\\n if flag == utils.FfSpec.FILTER:\\n stream['filters'][element['layer']] = element\\n elif flag == utils.FfSpec.GLOBAL:\\n if global_option is None:\\n global_option = element\\n else:\\n logging.warning(f'Skipping section {section_name}! Global options already found.')\\n continue\\n elif flag == utils.FfSpec.INPUT:\\n stream['inputs'][element['layer']] = create_node(element)\\n elif flag == utils.FfSpec.OUTPUT:\\n outputs.append(element)\\n else:\\n logging.warning(f'Unable to determine specifier of type \\\\'{element[\\\"type\\\"]}\\\\'!')\\n\\n for stream in stream_dict.values():\\n preprocess_filters(stream)\\n try:\\n process_filters(stream)\\n except RecursionError:\\n logging.error(f'Unable to process filters!')\\n logging.info(traceback.format_exc())\\n logging.debug(f'Foremost layers: {list(stream[\\\"inputs\\\"])}.')\\n # check_disjoint(stream_name)\\n\\n #if len(stream_dict['video']['inputs']) == 1:\\n # video_structure = list(stream_dict['video']['inputs'].values())[0]\\n if len(stream_dict['audio']['inputs']) == 1:\\n audio_structure = list(stream_dict['audio']['inputs'].values())[0]\\n\\n for layer, input_node in stream_dict['video']['inputs'].items():\\n if video_structure is None:\\n video_structure = input_node\\n logging.debug(f'Video structure has been set to node {input_node}(layer={layer})!')\\n continue\\n result = filters.generate_filter('overlay', {0:video_structure, 1:input_node},\\n input_layer_string='0,1')\\n if result is not None:\\n video_structure, _, _ = result\\n\\n if audio_structure is None:\\n inputs = stream_dict['audio']['inputs']\\n input_layer_string = ','.join((str(i) for i in range(len(inputs))))\\n result = filters.generate_filter('amix',\\n {i:layer for i, layer in enumerate(inputs.values())},\\n argument_string=f'input_count={len(inputs)}',\\n input_layer_string=input_layer_string)\\n if result is not None:\\n audio_structure, _, _ = result\\n \\n structures = []\\n if audio_structure is not None:\\n structures.append(audio_structure.filter_multi_output('asplit'))\\n if video_structure is not None:\\n structures.append(video_structure.filter_multi_output('split'))\\n\\n output_nodes = []\\n for i, output in enumerate(outputs): \\n output_nodes.append(create_node(output, *[structure[i] for structure in structures]))\\n\\n output_nodes = [node for node in output_nodes if node is not None]\\n\\n if len(output_nodes) == 0:\\n logging.error('Unable to generate ffmpeg node structure! No outputs!')\\n return None, False\\n\\n node_structure = ffmpeg.merge_outputs(*output_nodes)\\n if global_option is not None:\\n global_node = create_node(global_option, node_structure)\\n if global_node is not None:\\n logging.info(f'Applied global options to node structure!')\\n return global_node, 'sudo' in get_options(global_option['node'])\\n logging.error(f'Failed to apply global options to node structure!')\\n\\n return node_structure, False\",\n \"def src_process(state, input_data, output_data, ratio, end_of_input=0):\\n input_frames, _ = _check_data(input_data)\\n output_frames, _ = _check_data(output_data)\\n data = ffi.new('SRC_DATA*')\\n data.input_frames = input_frames\\n data.output_frames = output_frames\\n data.src_ratio = ratio\\n data.data_in = ffi.cast('float*', ffi.from_buffer(input_data))\\n data.data_out = ffi.cast('float*', ffi.from_buffer(output_data))\\n data.end_of_input = end_of_input\\n error = _lib.src_process(state, data)\\n return error, data.input_frames_used, data.output_frames_gen\",\n \"def convert_video_path_and_save(video_path, output_path=\\\"output.mp4\\\", temp_folder = \\\"./temp\\\",\\n frame_frequency=24, image_reducer=100, fontSize=10, spacing=1.1, maxsize=None, chars=\\\" .*:+%S0#@\\\",\\n logs=False, processes=4, progress_tracker=None):\\n\\n if logs:\\n start_time = time.time()\\n print (\\\"Converting video...\\\")\\n \\n # set up a capture temporarily so we can grab some basic info about it\\n capture = cv2.VideoCapture(video_path)\\n if not capture.isOpened():\\n print (\\\"Could not read video. Please enter a valid video file!\\\")\\n exit(0)\\n\\n fps = capture.get(cv2.CAP_PROP_FPS)\\n bitrate = int(capture.get(cv2.CAP_PROP_BITRATE))\\n total_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))\\n frames_included = int(total_frames / frame_frequency)\\n # total_frames / fps gives us our video duration.\\n video_duration = total_frames / fps\\n # frames included / video duration gives new fps\\n new_fps = (total_frames / frame_frequency) / video_duration\\n\\n capture.release()\\n\\n # First, we grab all the frames we need and store them in a temp folder\\n # After that, we convert all the image frames in the temp folder, and save them back in the temp folder\\n # Then, we write them to video and save to disk\\n # To utilize mutli processing, we separate grabbing frames and converting the frames into batches\\n\\n while os.path.isdir(temp_folder):\\n temp_folder += \\\"_\\\"\\n temp_folder += \\\"/\\\"\\n os.mkdir(temp_folder)\\n\\n # initial setup\\n # we divide our work into batches\\n batches = processes\\n frames_per_batch = int(total_frames / batches / frame_frequency)\\n if progress_tracker is None:\\n progress_tracker = Value(\\\"f\\\", 0, lock=True)\\n # progress: saved frames + converted frames + written frames\\n progress_step = 100 / (frames_included * 3)\\n\\n # grab the frames, and write to separate batch folders\\n save_frames_processes = []\\n for batch in range(batches):\\n starting_frame = batch * frames_per_batch * frame_frequency\\n batch_folder = temp_folder + str(batch) + \\\"/\\\"\\n os.mkdir(batch_folder)\\n args = (\\n starting_frame,\\n starting_frame + frames_per_batch * frame_frequency,\\n video_path,\\n batch_folder,\\n frame_frequency,\\n logs,\\n progress_tracker,\\n progress_step\\n )\\n p = Process(target=_save_frames, args=args)\\n p.daemon = True\\n p.start()\\n save_frames_processes.append(p)\\n for p in save_frames_processes:\\n p.join()\\n\\n # convert all the frames in each batch folder\\n convert_processes = []\\n for batch in range(batches):\\n batch_folder = temp_folder + str(batch) + \\\"/\\\"\\n args = (\\n batch_folder,\\n frames_per_batch,\\n image_reducer,\\n fontSize, spacing, maxsize, chars,\\n logs, progress_tracker, progress_step\\n )\\n p = Process(target=_convert_batch, args=args)\\n p.daemon = True\\n p.start()\\n convert_processes.append(p)\\n for p in convert_processes:\\n p.join()\\n\\n # if no extension was assigned, automatically assign .mp4\\n output_name, output_ext = os.path.splitext(output_path)\\n if output_ext == \\\"\\\":\\n output_ext = \\\".mp4\\\"\\n # if final output path was specified, then modify it (append _Copy to it)\\n final_output_path = output_name + output_ext\\n while os.path.isfile(final_output_path):\\n if logs : print (final_output_path, \\\"already exists!\\\")\\n final_output_path = os.path.splitext(final_output_path)[0] + \\\"_Copy\\\" + output_ext\\n\\n # video settings\\n fourcc = cv2.VideoWriter_fourcc(*'mp4v')\\n video_out = imageio.get_writer(final_output_path, fps=new_fps, quality=None, bitrate=(bitrate * 1024 * 2.5))\\n size = None\\n\\n # write images to new video\\n for batch in range(1, batches + 1):\\n batch_folder = temp_folder + str(batch - 1) + \\\"/\\\"\\n for i in range(1, frames_per_batch + 1):\\n img = cv2.imread(batch_folder + str(i) + \\\".jpg\\\", 2)\\n if size is None:\\n height, width = img.shape\\n size = (width, height)\\n video_out.append_data(img)\\n with progress_tracker.get_lock():\\n progress_tracker.value += progress_step\\n if logs : print (\\\"Progress: %.4f%%\\\" % progress_tracker.value, end=\\\"\\\\r\\\")\\n video_out.close()\\n shutil.rmtree(temp_folder)\\n\\n # when we are done, there might be some rounding errors when converting some stuff to integers, thus it doesn't appear to be done\\n # So we just simply set it to 100\\n with progress_tracker.get_lock():\\n progress_tracker.value = 100\\n\\n if logs:\\n print (\\\"=\\\" * 30)\\n print (\\\"SUMMARY:\\\")\\n print (\\\"-\\\" * 20)\\n print (\\\"Progress: %.4f%%\\\" % progress_tracker.value)\\n print (\\\"Total frames found:\\\", str(total_frames))\\n print (\\\"Frames included and converted:\\\", str(frames_per_batch * batches))\\n print (\\\"Original FPS:\\\", str(fps))\\n print(\\\"New FPS:\\\", str(new_fps))\\n print (\\\"Resolution:\\\", str(size))\\n print (\\\"Saved to\\\", final_output_path)\\n print (\\\"Time took: %.4f secs\\\" % (time.time() - start_time))\",\n \"def main(data_dir):\\n\\n face2face_dir = '{}/manipulated_sequences/Face2Face/c0/videos'.format(data_dir)\\n orig_dir = '{}/original_sequences/c0/videos'.format(data_dir)\\n base_dir = '{}/manipulated_sequences/GANnotation'.format(data_dir)\\n output_enc_dir = '{}/encodings'.format(base_dir)\\n output_vid_dir = '{}/{}/videos'.format(base_dir, COMPRESSION_LEVEL)\\n\\n pairs = get_seq_combos(face2face_dir)\\n\\n # Compute all video encodings and save them to disk.\\n # We precompute these because they take roughly 10 times as long to compute\\n # as the reenactments, and we may want to recompute the reenactments with\\n # different images later.\\n print('Computing video encodings...')\\n if not os.path.exists(output_enc_dir):\\n os.makedirs(output_enc_dir)\\n enc_count = 0\\n for source_id, _ in pairs:\\n encoding_path = get_encoding_path(output_enc_dir, source_id)\\n if os.path.exists(encoding_path):\\n continue # Encoding already calculated for this video sequence.\\n print('Computing encoding for sequence {}...'.format(source_id))\\n video_path = '{}/{}.mp4'.format(orig_dir, source_id)\\n cap = cv2.VideoCapture(video_path)\\n points = compute_video_encoding(cap)\\n cap.release()\\n try:\\n np.savetxt(encoding_path, points.reshape((132,-1)).transpose())\\n except KeyboardInterrupt as e:\\n # Safely handle premature termination.\\n # Remove unfinished file.\\n if os.exists(encoding_path):\\n os.remove(encoding_path)\\n raise e\\n enc_count += 1\\n\\n if enc_count == 0:\\n print('No encodings were calculated')\\n else:\\n print('{} video sequences encoded'.format(enc_count))\\n\\n print()\\n print('Computing reenactments...')\\n\\n # Load pre-trained model.\\n gann_path = os.path.join(dirname, 'models/myGEN.pth')\\n my_gann = GANnotation.GANnotation(path_to_model=gann_path)\\n\\n image_dir = '{}/original_sequences_images/{}/images'.format(data_dir, COMPRESSION_LEVEL)\\n if not os.path.exists(output_vid_dir):\\n os.makedirs(output_vid_dir)\\n reenact_count = 0\\n for source_id, driver_id in pairs:\\n output_path = '{}/{}_{}.mp4'.format(output_vid_dir, source_id, driver_id)\\n if os.path.exists(output_path):\\n # Do not recreate a video if it already exists.\\n # If the user wants to recreated a video\\n # the existing video must be deleted first.\\n continue\\n\\n print('Computing reenactment for {} onto {}...'.format(driver_id, source_id))\\n # Validate that input files exist.\\n encoding_path = get_encoding_path(output_enc_dir, driver_id)\\n if not os.path.isfile(encoding_path):\\n print('Failed to find encoding for video sequence {}'.format(driver_id),\\n file=stderr)\\n continue\\n image_path = '{}/{}.png'.format(image_dir, source_id)\\n if not os.path.isfile(image_path):\\n print('Failed to find image for sequence {}'.format(source_id),\\n file=stderr)\\n continue\\n\\n points = np.loadtxt(encoding_path).transpose().reshape(66, 2, -1)\\n\\n # Load and transform image for inputting.\\n image = cv2.imread(image_path)\\n cropped = get_gann_cropped_face(image)\\n\\n # Compute reenactment.\\n frames, _ = my_gann.reenactment(cropped, points)\\n\\n output_path = os.path.abspath(output_path)\\n print('Writing video to \\\"{}\\\"'.format(output_path))\\n try:\\n write_video(frames, FPS, (128, 128), output_path)\\n except KeyboardInterrupt as e:\\n # Safely handle premature termination.\\n # Remove unfinished file.\\n if os.exists(output_path):\\n os.remove(output_path)\\n raise e\\n reenact_count += 1\\n\\n if reenact_count == 0:\\n print('No reenactments were created')\\n else:\\n print('{} reenactments created'.format(reenact_count))\",\n \"def __sanitize_input(self):\\n self.__check_for_video_file()\\n self.__manage_output_folder()\",\n \"def processVideo(inputRootFolder='/home/pi/Logging/UnprocessedVideo',\\n outputFolder='/home/pi/Logging/Unsent',\\n cam_framerate=10,\\n delay=15):\\n logging.info('Processing videos')\\n sleep(delay) # hardcoded sleep function to ensure that the video has finished saving\\n # Create directories if necessary\\n try:\\n os.makedirs(inputRootFolder)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise # This was not a \\\"directory exists\\\" error\\n try:\\n os.makedirs(outputFolder)\\n except OSError as e:\\n if e.errno != errno.EEXIST:\\n raise # This was not a \\\"directory exists\\\" error\\n # Get the list of subdirectories\\n f = []\\n for (dirpath, dirnames, filenames) in os.walk(inputRootFolder):\\n f.extend(dirnames)\\n # Go through each subdirectory\\n for folder in f:\\n folderName = os.path.join(inputRootFolder,folder)\\n videoListName = '%s/videoList.txt' % folderName #file that will contain list of videos\\n videoList = io.open(videoListName, 'w')\\n for fileName in sorted(os.listdir(folderName)): #add each video in the folder to the file\\n if (fileName.startswith('Video')):\\n videoString = (\\\"file '%s/%s'\\\\n\\\" % (folderName, fileName))\\n videoList.write(videoString)\\n videoList.close()\\n outputFile = '%s/%s.mp4' % (outputFolder, folder)\\n #concatenate the videos\\n subprocess.call(['ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i',\\n videoListName, '-c', 'copy', outputFile], shell=False)\\n shutil.rmtree(folderName, ignore_errors=True) #delete the folder\\n logging.info('Processed videos')\",\n \"def compress_video(x: np.ndarray, video_format: str, constant_rate_factor: int, dir_: str = \\\"\\\"):\\n import ffmpeg\\n\\n video_path = os.path.join(dir_, f\\\"tmp_video.{video_format}\\\")\\n _, height, width, _ = x.shape\\n\\n # numpy to local video file\\n process = (\\n ffmpeg.input(\\\"pipe:\\\", format=\\\"rawvideo\\\", pix_fmt=\\\"rgb24\\\", s=f\\\"{width}x{height}\\\")\\n .output(video_path, pix_fmt=\\\"yuv420p\\\", vcodec=\\\"libx264\\\", crf=constant_rate_factor)\\n .overwrite_output()\\n .run_async(pipe_stdin=True, quiet=True)\\n )\\n process.stdin.write(x.flatten().astype(np.uint8).tobytes())\\n process.stdin.close()\\n process.wait()\\n\\n # local video file to numpy\\n stdout, _ = (\\n ffmpeg.input(video_path)\\n .output(\\\"pipe:\\\", format=\\\"rawvideo\\\", pix_fmt=\\\"rgb24\\\")\\n .run(capture_stdout=True, quiet=True)\\n )\\n return np.frombuffer(stdout, np.uint8).reshape(x.shape)\",\n \"def video_to_frames(input_loc, output_loc, frame_skip):\\n try:\\n os.mkdir(output_loc)\\n except OSError as e:\\n print(e)\\n pass\\n # Log the time\\n time_start = time.time()\\n # Start capturing the feed\\n cap = cv2.VideoCapture(input_loc)\\n # Find the number of frames\\n video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - 1\\n print (\\\"Number of frames: \\\", video_length)\\n count = 0\\n actual_frames = 0\\n print (\\\"Converting video..\\\\n\\\")\\n # Start converting the video\\n while cap.isOpened():\\n # Extract the frame\\n ret, frame = (None, None)\\n for i in range(frame_skip):\\n ret, frame = cap.read()\\n actual_frames += 1\\n cv2.imwrite(output_loc + \\\"/%#05d.jpg\\\" % (actual_frames), frame)\\n count += 1\\n # Write the results back to output location.\\n # If there are no more frames left\\n if (actual_frames > (video_length) - frame_skip):\\n # Log the time again\\n time_end = time.time()\\n # Release the feed\\n cap.release()\\n # Print stats\\n print (\\\"Done extracting frames.\\\\n%d frames extracted\\\" % count)\\n print (\\\"It took %d seconds forconversion.\\\" % (time_end-time_start))\\n break\",\n \"def filter_video_data(encode_video, image_file_path, encoded_text, encode_label):\\n video_frame_number = tf.shape(encode_video)[0]\\n return tf.math.equal(video_frame_number, max_video_frame_number)\",\n \"def decode(decode_format):\\n return output_from_decode\",\n \"def parse():\\n all_players = list(FACE_IMAGE_LOCATIONS.keys())\\n face_encodings = VideoParser.__load_faces_encodings(all_players)\\n player_occurrences = VideoParser.__get_player_occurrences(all_players, face_encodings)\\n VideoParser.__save_parsed_video(player_occurrences)\",\n \"def video_model(video_frames=None, audio_frames=None):\\n\\n with tf.variable_scope(\\\"video_model\\\"):\\n batch_size, seq_length, height, width, channels = video_frames.get_shape().as_list()\\n\\n video_input = tf.reshape(video_frames, (batch_size * seq_length, height, width, channels))\\n video_input = tf.cast(video_input, tf.float32)\\n\\n features, end_points = resnet_v1.resnet_v1_50(video_input, None)\\n features = tf.reshape(features, (batch_size, seq_length, int(features.get_shape()[3])))\\n\\n return features\",\n \"def convert(inputpath, targetformat):\\n outputpath = os.path.splitext(inputpath)[0] + targetformat\\n print(\\\"converting {0} to {1}\\\".format(inputpath, outputpath))\\n\\n reader = imageio.get_reader(inputpath)\\n fps = reader.get_meta_data()['fps']\\n\\n writer = imageio.get_writer(outputpath, fps=fps)\\n for i, im in enumerate(reader):\\n sys.stdout.write(\\\"\\\\rframe {0}\\\".format(i))\\n sys.stdout.flush()\\n writer.append_data(im)\\n print(\\\"Finalizing...\\\")\\n writer.close()\\n print(\\\"Done.\\\")\",\n \"def preprocess_frame(self, frame):\\n # Greyscale frame\\n img = np.mean(frame,-1)\\n\\n # Remove black bar at the bottom\\n cropped_img = img[:-12, :]\\n\\n # Normalize Pixel Values\\n normalized_frame = cropped_img/255.0\\n\\n return normalized_frame\",\n \"def get_frame(self, in_grayscale=False):\\n _, frame = self.video.read()\\n\\n if in_grayscale:\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n\\n return frame\",\n \"def format_det_result():\\n test_results = load(args.test_result)\\n annos = load(args.anno_path)\\n test_videos = annos['test_videos'][0]\\n resolutions = annos['resolution']\\n frm_dets = []\\n for pred in track(test_results, description='formating...'):\\n video_key = pred['video_id'].split('.mp4')[0]\\n frm_num = pred['timestamp']\\n bboxes = pred['pred_instances']['bboxes']\\n cls_scores = pred['pred_instances']['scores']\\n for bbox, cls_score in zip(bboxes, cls_scores):\\n video_idx = test_videos.index(video_key)\\n pred_label = np.argmax(cls_score)\\n score = cls_score[pred_label]\\n h, w = resolutions[video_key]\\n bbox *= np.array([w, h, w, h])\\n instance_result = np.array(\\n [video_idx, frm_num, pred_label, score, *bbox])\\n frm_dets.append(instance_result)\\n frm_dets = np.array(frm_dets)\\n video_tubes = link_tubes(annos, frm_dets, K=1)\\n dump(frm_dets, args.frm_out_path)\\n dump(video_tubes, args.tube_out_path)\",\n \"def main(path):\\n logger.info(f'Processing video file {path}')\\n # Extract audio\\n audio_file = extract_audio(path, pipeline_config.audio_target_dir)\\n\\n # Generate sound classification results and speech recogniser results\\n sound_results = SoundRecogniser().process_file(audio_file)\\n sound_results = process_overlap(sound_results)\\n speech_results = SpeechRecogniser().process_file(audio_file)\\n\\n # NLP\\n wrds = get_words(speech_results)\\n nlp = SpaCyNaturalLanguageProcessor(pipeline_config.spacy_model)\\n custom_nlp = SpaCyNaturalLanguageProcessor(pipeline_config.custom_spacy_model)\\n processor = nlp.get_spacy_results_processor(wrds, speech_results)\\n custom_processor = custom_nlp.get_spacy_results_processor(wrds, speech_results)\\n chunk_results = processor.process_speech_results_chunk()\\n ner_results = processor.process_speech_results_ner()\\n ner_results.extend(custom_processor.process_speech_results_ner())\\n match_results = processor.process_speech_results_match()\\n speech_results = nlp.process_spurious_words(speech_results, chunk_results)\\n\\n # Add Speech recogniser results, sound classification results and NLP results to a subtitle file\\n subs_1 = save_to_subtitles(speech_results,\\n lambda speech_result: speech_result['word'])\\n subs_1 = compress_subs(subs_1)\\n subs_2 = save_to_subtitles(sound_results,\\n lambda sound_result: sound_result['class'])\\n subs_2 = flatten_subs(subs_2)\\n subs_3 = save_to_subtitles(chunk_results,\\n lambda chunk_result: f'{chunk_result[\\\"word\\\"]} ({chunk_result[\\\"head\\\"]})')\\n subs_4 = save_to_subtitles(ner_results,\\n lambda ner_result: f'{ner_result[\\\"type\\\"]} {ner_result[\\\"word\\\"]}')\\n subs_5 = save_to_subtitles(match_results,\\n lambda match_result: match_result[\\\"word\\\"])\\n\\n combined_subs = append_subs(None, subs_1, style='bottom')\\n combined_subs = append_subs(combined_subs, subs_2, exclude=['bottom'], style='top', formatter=lambda x: f'({x})')\\n combined_subs = append_subs(combined_subs, subs_3, style='left')\\n combined_subs = append_subs(combined_subs, subs_4, style='right')\\n combined_subs = append_subs(combined_subs, subs_5, style='bottom_left_pred')\\n combined_subs = remove_tiny_subs(combined_subs, duration_millis=1000, left_millis=None,\\n right_millis=None, style='top')\\n subtitle_file_name = os.path.splitext(path)[0] + '.ass'\\n create_styles(combined_subs)\\n combined_subs.save(subtitle_file_name)\\n\\n # Burn to a video\\n burn_subtitles_into_video(path, subtitle_file_name, pipeline_config.audio_target_dir)\\n logger.info(f'Done processing {audio_file}')\",\n \"def preprocess_output(self, face_box, frame):\\n if face_box is None or frame is None or frame.size < 1:\\n return None, None\\n else:\\n face_box = helpers.fit(face_box, frame)\\n face_img = helpers.crop(frame, face_box)\\n return face_img, face_box\",\n \"def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',\\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\\n transform='', oldfile=False):\\n\\n import pylab as plt\\n\\n datadir = os.path.expanduser(datadir)\\n if proc < 0:\\n filename = datadir + '/slice_' + field + '.' + extension\\n else:\\n filename = datadir + '/proc' + \\\\\\n str(proc) + '/slice_' + field + '.' + extension\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane = np.zeros((vsize, hsize), dtype=precision)\\n\\n infile = npfile(filename, endian=format)\\n\\n files = []\\n fig = plt.figure(figsize=(5, 10))\\n ax = fig.add_subplot(111)\\n\\n ifirst = True\\n islice = 0\\n while True:\\n try:\\n raw_data = infile.fort_read(precision)\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[-1]\\n plane = raw_data[:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[-2]\\n plane = raw_data[:-2].reshape(vsize, hsize)\\n\\n if transform:\\n exec('plane = plane' + transform)\\n\\n if t > tmin and t < tmax:\\n ax.cla()\\n ax.imshow(plane, vmin=amin, vmax=amax)\\n fname = '_tmp%03d.png' % islice\\n print('Saving frame' + fname)\\n fig.savefig(fname)\\n files.append(fname)\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % \\\\ # Python 2\\n #(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))\\n\\n ifirst = False\\n islice += 1\\n\\n #print 'Making movie animation.mpg - this make take a while'\\n print('Making movie animation.mpg - this make take a while')\\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\\n os.system(\\\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\\\")\\n os.system(\\\"rm _tmp*.png\\\")\\n infile.close()\",\n \"def analyze_video(vidNum_iter, config, pointInds_toUse, pts_spaced, session): # function needed for multiprocessing\\n\\n optic = config['Optic']\\n\\n numVids = session['num_vids']\\n path_vid_allFiles = session['videos']\\n lk_names = [key for key in optic.keys() if 'lk_' in key]\\n lk_params = {k.split('lk_')[1]: (tuple(optic[k]) if type(optic[k]) is list else optic[k]) \\\\\\n for k in lk_names}\\n\\n vid = imageio.get_reader(path_vid_allFiles[vidNum_iter], 'ffmpeg')\\n # metadata = vid.get_meta_data()\\n\\n path_vid = path_vid_allFiles[vidNum_iter] # get path of the current vid\\n video = cv2.VideoCapture(path_vid) # open the video object with openCV\\n numFrames = int(video.get(\\n cv2.CAP_PROP_FRAME_COUNT)) # get frame count of this vid GENERALLY INACCURATE. OFF BY AROUND -25 frames\\n\\n frameToSet = 0\\n frame = vid.get_data(\\n frameToSet) # Get a single frame to use as the first 'previous frame' in calculating optic flow\\n new_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n old_frame = new_frame_gray\\n\\n displacements_tmp = np.zeros((pts_spaced.shape[0], 2, np.uint64(numFrames + (numVids * 1000)))) * np.nan\\n\\n print(' ', end='', flush=True)\\n text = \\\"progresser #{}\\\".format(vidNum_iter)\\n print(f'\\\\n Calculating displacement field: video # {vidNum_iter + 1}/{numVids}')\\n\\n for iter_frame, new_frame in enumerate(tqdm(vid, total=numFrames, desc=text, position=vidNum_iter)):\\n new_frame_gray = cv2.cvtColor(new_frame, cv2.COLOR_BGR2GRAY) # convert to grayscale\\n\\n ##calculate optical flow\\n pointInds_new, status, error = cv2.calcOpticalFlowPyrLK(old_frame, new_frame_gray, pointInds_toUse, None,\\n **lk_params) # Calculate displacement distance between STATIC/ANCHORED points and the calculated new points. Also note the excluded 'NextPts' parameter. Could be used for fancier tracking\\n\\n ## Calculate displacement and place into variable 'displacements' (changes in size every iter)\\n if iter_frame == 0:\\n displacements_tmp[:, :, iter_frame] = np.zeros((pts_spaced.shape[0], 2))\\n else:\\n displacements_tmp[:, :, iter_frame] = np.single(np.squeeze((\\n pointInds_new - pointInds_toUse))) # this is the important variable. Simply the difference in the estimate\\n\\n old_frame = new_frame_gray # make current frame the 'old_frame' for the next iteration\\n\\n return displacements_tmp\",\n \"def preprocess(x):\\n if x.shape[-1] < 16000 * 8:\\n raise ValueError(\\n \\\"Cannot preprocess tensor less than 8 seconds in duration.\\\"\\n )\\n vad = VadChunk(*get_vad(\\\"both\\\"))\\n return vad(x)\",\n \"def video_segment(video_filename, images_data_path, opticalflow_data_path, spatial_cnn_model, motion_cnn_model, \\n spatial_motion_svm_model, device, num_flow_channel=10, feature_dimension=2048, child_gesture_duration=45,\\n batch_size=2, num_workers=2, image_file_format='jpg', feature_pool='max'):\\n \\n num_frames = len(glob.glob('' .join([opticalflow_data_path, 'u/', video_filename, '/*.', image_file_format])))\\n\\n dict_video_file = {video_filename: 1}# here just put 1 for dummy labels as it will not used for segmentation\\n min_num_extra_frames = num_frames - child_gesture_duration\\n gesture_int_frame_ids = list(range(1, min_num_extra_frames, child_gesture_duration))\\n gesture_int_frame_ids.append(min_num_extra_frames+1)\\n\\n gesture_segmentation_results = np.ones((3, len(gesture_int_frame_ids)))\\n gesture_segmentation_labels = -np.ones(num_frames)\\n for i, nf in enumerate(tqdm(gesture_int_frame_ids)):\\n\\n int_frame_id = {video_filename: nf}\\n end_frame_id = {video_filename: nf+child_gesture_duration-1}\\n # print(int_frame_id, end_frame_id)\\n\\n # calculate spatial feature\\n temp_spatial_feature, _ = spatial_feature_score_frames(spatial_cnn_model, feature_dimension, dict_video_file, int_frame_id, end_frame_id, images_data_path, num_flow_channel=num_flow_channel, feature_pool=feature_pool, batch_size=batch_size, num_workers=num_workers, device=device)\\n # feature pooling\\n temp_spatial_feature = feature_pooling(temp_spatial_feature.T, feature_pool)\\n temp_spatial_feature = temp_spatial_feature.reshape(-1, 1)\\n #feature normalize\\n temp_spatial_feature = lp_normalize_feature(temp_spatial_feature, 'l2')\\n\\n # calculate motion feature\\n temp_motion_feature, _ = motion_feature_score_frames(motion_cnn_model, feature_dimension, dict_video_file, int_frame_id, end_frame_id, opticalflow_data_path, num_flow_channel=num_flow_channel, feature_pool=feature_pool, batch_size=batch_size, num_workers=num_workers, device=device)\\n # feature pooling\\n temp_motion_feature = feature_pooling(temp_motion_feature.T, feature_pool)\\n temp_motion_feature = temp_motion_feature.reshape(-1, 1)\\n #feature normalize\\n temp_motion_feature = lp_normalize_feature(temp_motion_feature, 'l2')\\n\\n temp_combined_feature = np.concatenate((temp_spatial_feature, temp_motion_feature), axis=0)\\n non_zeros_feat_ids = np.abs(temp_combined_feature).sum(axis=0)>0.0\\n temp_combined_feature = temp_combined_feature[:,non_zeros_feat_ids]\\n\\n # classify gesture using SVM\\n if temp_combined_feature.size:\\n temp_pred_label = thundersvm_test_1v1_genrl(spatial_motion_svm_model, temp_combined_feature.reshape(-1, 1))\\n gesture_segmentation_labels[int_frame_id[video_filename]:end_frame_id[video_filename]+1] = temp_pred_label\\n gesture_segmentation_results[:, i] = np.array([int_frame_id[video_filename], end_frame_id[video_filename], temp_pred_label])\\n \\n \\n return gesture_segmentation_results, gesture_segmentation_labels\",\n \"def process_input(self,r,g,b):\\n pass\",\n \"def parse_fn(serialized_example):\\n\\n features = {\\n 'video': tf.io.FixedLenFeature([], tf.string),\\n 'label': tf.io.FixedLenFeature([], tf.int64),\\n 'seq_len': tf.io.FixedLenFeature([], tf.int64),\\n 'height': tf.io.FixedLenFeature([], tf.int64),\\n 'width': tf.io.FixedLenFeature([], tf.int64),\\n 'channels': tf.io.FixedLenFeature([], tf.int64)\\n }\\n\\n # Parse the input tf.Example proto using the dictionary above.\\n parsed = tf.io.parse_single_example(serialized_example, features)\\n\\n # Decodes and reshapes video\\n seq_len = tf.cast(parsed['seq_len'], tf.uint32)\\n height = tf.cast(parsed['height'], tf.uint32)\\n width = tf.cast(parsed['width'], tf.uint32)\\n channels = tf.cast(parsed['channels'], tf.uint32)\\n video = tf.io.decode_raw(parsed['video'], tf.uint8)\\n video = tf.reshape(video, shape=[seq_len, height, width, channels])\\n\\n # Normalizes video frames, label\\n video = tf.cast(video, tf.float32) / 255\\n label = tf.cast(parsed['label'], tf.float32)\\n return video, label\",\n \"def make_video(input_files, width=0, height=0, frame_rate=24, crf=20, output_path=\\\"video.mp4\\\"):\\n if isinstance(input_files, list):\\n from PIL import Image # pylint: disable=C0415\\n\\n with Image.open(input_files[0]) as img:\\n width, height = img.size\\n tmp_dir = \\\"tmp_ffmpeg_dir\\\"\\n os.mkdir(tmp_dir)\\n if width % 2 != 0:\\n print(f\\\"Width ({width}) not divisible by 2\\\")\\n width -= 1\\n if height % 2 != 0:\\n print(f\\\"Height ({width}) not divisible by 2\\\")\\n height -= 1\\n for i, inp in enumerate(input_files):\\n shutil.copy(inp, os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n inputs = f\\\"{tmp_dir}/%06d.png\\\"\\n command = ffmpeg_common_args(frame_rate, inputs, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n for i in range(len(input_files)):\\n os.remove(os.path.join(tmp_dir, f\\\"{i:06d}.png\\\"))\\n os.rmdir(tmp_dir)\\n elif isinstance(input_files, str):\\n assert width != 0 and height != 0\\n command = ffmpeg_common_args(frame_rate, input_files, width, height, crf, output_path)\\n ret = os.system(command)\\n assert ret == 0, \\\"ffmpeg failed to generate video file.\\\"\\n else:\\n assert (\\n False\\n ), f'input_files should be list (of files) or str (of file template, e.g., \\\"%04d.png\\\") instead of {type(input_files)}'\",\n \"def main_func_video(param_list: list = None) -> bool:\\r\\n # index of param\\r\\n # noinspection PyPep8Naming\\r\\n PORT_RAW_PICT = 0\\r\\n\\r\\n # check if param OK\\r\\n if len(param_list) != 1:\\r\\n log_error_to_console(\\\"GET FRAME VIDEO MAIN FUNCTION PARAM NOK\\\", str(len(param_list)))\\r\\n return False\\r\\n else:\\r\\n port_image = get_port_from_wave(name=param_list[PORT_RAW_PICT])\\r\\n\\r\\n try:\\r\\n # noinspection PyUnresolvedReferences\\r\\n success, port_image.arr[:] = global_var_handler.VIDEO.read()\\r\\n if success is True:\\r\\n port_image.set_valid()\\r\\n except BaseException as error:\\r\\n is_error()\\r\\n # noinspection PyUnresolvedReferences\\r\\n log_error_to_console('RAW PICTURE NOK TO READ: ' + str(global_var_handler.VIDEO.__str__()), str(error))\\r\\n port_image.set_invalid()\\r\\n pass\\r\\n\\r\\n # noinspection PyUnresolvedReferences\\r\\n log_to_file(str(global_var_handler.FRAME))\\r\\n # noinspection PyUnresolvedReferences\\r\\n log_to_file(global_var_handler.STR_L0_SIZE)\\r\\n\\r\\n return True\",\n \"def main_func_from_txt(param_list: list = None) -> bool:\\r\\n # index of param\\r\\n # noinspection PyPep8Naming\\r\\n PORT_RAW_PICT = 0\\r\\n # noinspection PyPep8Naming\\r\\n PORT_LINE_SEPARATOR = 1\\r\\n # noinspection PyPep8Naming\\r\\n PORT_PX_SEPARATOR = 2\\r\\n\\r\\n # check if param OK\\r\\n if len(param_list) != 3:\\r\\n log_error_to_console(\\\"GET FRAME FROM TXT MAIN FUNCTION PARAM NOK\\\", str(len(param_list)))\\r\\n return False\\r\\n else:\\r\\n img = open(file=os.path.join(config_main.APPL_INPUT_DIR, config_main.APPL_INPUT_IMG_DIR[global_var_handler.FRAME]),\\r\\n mode='r').read()\\r\\n\\r\\n port_image = get_port_from_wave(name=param_list[PORT_RAW_PICT])\\r\\n\\r\\n tmp = []\\r\\n\\r\\n lines = img.split(param_list[PORT_LINE_SEPARATOR])\\r\\n for line in lines[:-1]:\\r\\n t = line.split(param_list[PORT_PX_SEPARATOR])\\r\\n tmp.append(list(map(int, t)))\\r\\n\\r\\n tmp = np.array(tmp)\\r\\n\\r\\n height, width = tmp.shape[:2]\\r\\n\\r\\n if width != global_var_handler.WIDTH_L0 or height != global_var_handler.HEIGHT_L0:\\r\\n new_size = \\\"({w}x{h})\\\".format(w=width, h=height)\\r\\n USED_SIZED.add(new_size)\\r\\n log_to_console(\\\"RAW PICTURE SIZE NOT OK! PICTURE SIZE REDONE: \\\" + new_size)\\r\\n global_var_handler.HEIGHT_L0 = height\\r\\n global_var_handler.WIDTH_L0 = width\\r\\n global_var_handler.recalculate_pyramid_level_values()\\r\\n # noinspection PyUnresolvedReferences\\r\\n reshape_ports(size_array=global_var_handler.SIZE_ARRAY)\\r\\n\\r\\n port_image.arr[:] = tmp\\r\\n port_image.set_valid()\\r\\n\\r\\n global_var_handler.PICT_NAME = config_main.APPL_INPUT_IMG_DIR[global_var_handler.FRAME]\\r\\n\\r\\n log_to_file(str(global_var_handler.FRAME))\\r\\n log_to_file(global_var_handler.PICT_NAME)\\r\\n log_to_file(global_var_handler.STR_L0_SIZE)\\r\\n\\r\\n return True\",\n \"def __init__(self, channel_id, width, height, entype, ctx,\\n output_format=const.PIXEL_FORMAT_YUV_SEMIPLANAR_420):\\n self._channel_id = channel_id\\n self._width = width\\n self._height = height\\n self._run_flag = True\\n self._callbak_tid = None\\n self._channel_desc = None\\n self._ctx = ctx\\n self._entype = entype\\n self._format = output_format\\n self._decode_complete_cnt = 0\\n self._decode_cnt = 0\\n self._output_pic_size = (self._width * self._height * 3) // 2\\n self._frame_queue = queue.Queue()\\n self._frame_config = None\",\n \"def decode(p):\\n #assert p.endswith('.' + EXTENSION)\\n p2 = os.path.basename(p).replace('baseline.png', '.png')\\n p2p = os.path.join('/mnt/Volume0/test/clic2020-devkit/result/', p2) #add by me\\n pp = os.path.join('/mnt/Volume0/test/clic2020-devkit/targets',p2)\\n p2 = os.path.join('/mnt/Volume0/test/clic2020-devkit/inputs/', p2) #add by me\\n p1 = pframe_dataset_shared.get_previous_frame_path(p2)\\n #p1 = os.path.join('/mnt/Volume0/test/clic2020-devkit/test_data/inputs/', p1)\\n #assert os.path.isfile(p1), (p2, p1, p, len(glob.glob('*.png')))\\n b = Image.open(p).convert('L')\\n f2_reconstructed = decoder(np.array(Image.open(p1)), b)\\n Image.fromarray(f2_reconstructed).save(p2p)\\n return f2_reconstructed, np.array(Image.open(pp))\",\n \"def video_handle_for_demo():\\n frame = cv2.imread(\\\"vision.png\\\")\\n\\n return frame\",\n \"def analyze_video(queue, video_file, settings):\\n # get video\\n video = cv2.VideoCapture(video_file) # input VideoCapture object\\n frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) # number of frames in input video\\n # initialize models\\n net = models.detection_dnn_model() # detection model\\n face_encoder = models.face_encoder() # face recognition encoding model\\n pose_predictor = models.pose_predictor() # pose predictor model for finding face landmarks\\n # get settings\\n track_period = settings[\\\"track_period\\\"] # track period from settings\\n resamples = settings[\\\"resamples\\\"] # number of resamples from settings\\n tolerance = settings[\\\"tolerance\\\"] # face matching tolerance from settings\\n # initialize lists\\n face_locations = [] # list of face locations for each frame\\n face_encodings = [] # list of face encodings for each frame\\n unique_frames = [] # list of frame images including unique faces\\n unique_face_locations = [] # list of unique faces' locations\\n unique_encodings = [] # list of unique faces' encodings\\n for i in range(frame_count):\\n ret, img = video.read() # ret indicates if frame was read correctly, img is last read frame\\n if i % track_period == 0: # frame for detection\\n rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # frame in rgb format\\n face_locations.append(detection.detect_faces(img, net))\\n face_encodings.append(recognition.encode_faces(rgb, face_locations[-1], pose_predictor, face_encoder, resamples))\\n new_indices, new_encodings = recognition.exclude_faces(face_encodings[-1], np.array(unique_encodings), tolerance) # indices and encodings of new faces found\\n for k in range(len(new_indices)): # for each new face found\\n unique_frames.append(rgb)\\n unique_face_locations.append(face_locations[-1][k])\\n unique_encodings.append(new_encodings[k])\\n send_data(queue, [face_locations, face_encodings, unique_frames, unique_face_locations, unique_encodings])\",\n \"def extract_frame(vid_item):\\n full_path, subdir, save_path = vid_item\\n\\n out_full_path = save_path\\n\\n vr = wmli.VideoReader(full_path)\\n print(f\\\"{full_path} fps {vr.fps}.\\\")\\n sys.stdout.flush()\\n # for i in range(len(vr)):\\n all_frames = []\\n try:\\n for i, vr_frame in enumerate(vr):\\n if vr_frame is not None:\\n if img_process_fn is not None:\\n vr_frame = img_process_fn(vr_frame)\\n w, h, _ = np.shape(vr_frame)\\n if args.new_short == 0:\\n if args.new_width == 0 or args.new_height == 0:\\n # Keep original shape\\n out_img = vr_frame\\n else:\\n out_img = mmcv.imresize(vr_frame,\\n (args.new_width,\\n args.new_height))\\n else:\\n if min(h, w) == h:\\n new_h = args.new_short\\n new_w = int((new_h / h) * w)\\n else:\\n new_w = args.new_short\\n new_h = int((new_w / w) * h)\\n out_img = mmcv.imresize(vr_frame, (new_h, new_w))\\n all_frames.append(wmli.encode_img(out_img))\\n else:\\n warnings.warn(\\n 'Length inconsistent!'\\n f'Early stop with {i + 1} out of {len(vr)} frames.')\\n break\\n\\n out_full_path = out_full_path+f\\\"_{len(all_frames)}.np\\\"\\n with open(out_full_path,\\\"wb\\\") as f:\\n pickle.dump(all_frames,f)\\n except Exception as e:\\n print(f\\\"Process {full_path} faild, {e}\\\")\\n\\n print(f'{full_path} -> {out_full_path} done')\\n sys.stdout.flush()\\n return True\",\n \"def __convert_frames(self, frames):\\n f = frames\\n fragment = sppasChannelFrames(f)\\n\\n # Convert the sample width if it needs to\\n if self._channel.get_sampwidth() != self._sampwidth:\\n fragment.change_sampwidth(self._channel.get_sampwidth(), self._sampwidth)\\n\\n # Convert the self._framerate if it needs to\\n if self._channel.get_framerate() != self._framerate:\\n fragment.resample(self._sampwidth, self._channel.get_framerate(), self._framerate)\\n\\n return fragment.get_frames()\",\n \"def model(inputs, is_training):\\n\\n tf.logging.info(FLAGS.model_structure)\\n tf.logging.info(FLAGS.model_edge_weights)\\n structure = json.loads(FLAGS.model_structure)\\n\\n if FLAGS.use_object_input:\\n feature_shape = inputs[0].shape\\n original_inputs = inputs[0]\\n object_inputs = inputs[1]\\n else:\\n feature_shape = inputs.shape\\n original_inputs = inputs\\n object_inputs = None\\n\\n batch_size = feature_shape[0] // FLAGS.num_frames\\n original_num_frames = FLAGS.num_frames\\n num_frames = original_num_frames\\n\\n grouping = {-3: [], -2: [], -1: [], 0: [], 1: [], 2: [], 3: []}\\n for i in range(len(structure)):\\n grouping[structure[i][0]].append(i)\\n\\n stem_count = len(grouping[-3]) + len(grouping[-2]) + len(grouping[-1])\\n\\n assert stem_count != 0\\n stem_filters = 128 // stem_count\\n\\n if grouping[-2]:\\n # Instead of loading optical flows as inputs from data pipeline, we are\\n # applying the \\\"Representation Flow\\\" to RGB frames so that we can compute\\n # the flow within TPU/GPU on fly. It's essentially optical flow since we\\n # do it with RGBs.\\n flow_inputs = rf.rep_flow(\\n original_inputs,\\n batch_size,\\n original_num_frames,\\n num_iter=40,\\n is_training=is_training,\\n bottleneck=1,\\n scope='rep_flow')\\n streams = []\\n\\n for i in range(len(structure)):\\n with tf.variable_scope('Node_' + str(i)):\\n if structure[i][0] == -1:\\n inputs = asn.rgb_conv_stem(original_inputs,\\n original_num_frames,\\n stem_filters,\\n structure[i][1],\\n is_training,\\n data_format)\\n streams.append(inputs)\\n elif structure[i][0] == -2:\\n inputs = asn.flow_conv_stem(flow_inputs,\\n stem_filters,\\n structure[i][1],\\n is_training,\\n data_format)\\n streams.append(inputs)\\n elif structure[i][0] == -3:\\n # In order to use the object inputs, you need to feed your object\\n # input tensor here.\\n inputs = object_conv_stem(object_inputs,\\n data_format)\\n streams.append(inputs)\\n else:\\n block_number = structure[i][0]\\n\\n combined_inputs = [streams[structure[i][1][j]]\\n for j in range(0, len(structure[i][1]))]\\n\\n tf.logging.info(grouping)\\n nodes_below = []\\n for k in range(-3, structure[i][0]):\\n nodes_below = nodes_below + grouping[k]\\n\\n peers = []\\n if FLAGS.attention_mode:\\n lg_channel = -1\\n tf.logging.info(nodes_below)\\n for k in nodes_below:\\n tf.logging.info(streams[k].shape)\\n lg_channel = max(streams[k].shape[3], lg_channel)\\n\\n for node_index in nodes_below:\\n attn = tf.reduce_mean(streams[node_index], [1, 2])\\n\\n attn = tf.layers.dense(\\n inputs=attn,\\n units=lg_channel,\\n kernel_initializer=tf.random_normal_initializer(stddev=.01))\\n peers.append(attn)\\n\\n combined_inputs = fusion_with_peer_attention(\\n combined_inputs,\\n index=i,\\n attention_mode=FLAGS.attention_mode,\\n attention_in=peers,\\n use_5d_mode=False,\\n data_format=data_format)\\n\\n graph = asn.block_group(\\n inputs=combined_inputs,\\n filters=structure[i][2],\\n block_fn=block_fn,\\n blocks=layers[block_number],\\n strides=structure[i][4],\\n is_training=is_training,\\n name='block_group' + str(i),\\n block_level=structure[i][0],\\n num_frames=num_frames,\\n temporal_dilation=structure[i][3],\\n data_format=data_format)\\n\\n streams.append(graph)\\n\\n outputs = asn.multi_stream_heads(streams,\\n grouping[3],\\n original_num_frames,\\n num_classes,\\n data_format)\\n\\n return outputs\",\n \"def process_videos(chapter_info):\\n\\n print(\\\"Processing chapter_info:\\\", chapter_info)\\n\\n # getting creation time of the first chapter\\n # TODO update when adding multiple directory proccessing\\n os.chdir(DIR_VIDEO_FILES)\\n print(\\\"1st chapter\\\", chapter_info[1][0])\\n chap1_time = time.strftime(\\n r\\\"%Y-%m-%d_%H-%M\\\", time.localtime(os.path.getctime(chapter_info[1][0])))\\n print(\\\"1st chapter creation\\\", chap1_time)\\n\\n # output_file = f\\\"M_GH00{chapter_info[0]}_{chap1_time}.MP4\\\"\\n output_file = f\\\"{chap1_time}_GH00{chapter_info[0]}_MRG.MP4\\\"\\n if os.path.isfile(output_file):\\n print(f\\\"Chapter already processed, found file: {output_file}\\\")\\n return\\n\\n # preparing text file containing file list for merging (for ffmpeg)\\n video_list_file = chapter_info[0] + \\\"_merge.txt\\\"\\n with open(video_list_file, \\\"w\\\") as f:\\n for video_chapter in chapter_info[1]:\\n f.write(f\\\"file {video_chapter}\\\\n\\\")\\n\\n command = f\\\"{FFMPEG_EXE} -f concat -i {video_list_file} -c copy {DIR_OUTPUT}{output_file}\\\"\\n print(\\\"command =\\\", command)\\n # p = subprocess.run(\\\"dir\\\", shell=True, capture_output=True)\\n # p = subprocess.run(\\\"dir\\\", shell=True, stdout=subprocess.PIPE, text=True)\\n p = subprocess.run(command, stdout=subprocess.PIPE, text=True)\\n print(\\\"returncode =\\\", p.returncode)\\n # print(\\\"stdout =\\\", p.stdout)\\n os.remove(video_list_file) # remove file list after merging\\n # rename original chapters after processing\\n for video_chapter in chapter_info[1]:\\n os.rename(video_chapter, f\\\"OK_{video_chapter}\\\")\",\n \"def read(self, ifDrawAxis=None, ifDrawSquare=None):\\n if(self.isLoaded() == False):\\n return\\n self.ret, frame = self.video.read()\\n if (self.ret == True):\\n \\n # Draw frame\\n self.currentFrame = frame\\n self.currentFrameNumber = int(self.video.get(cv2.CAP_PROP_POS_FRAMES))\\n \\n else: # If the video is end\\n self.isPlaying = False\\n \\n return self.frame(ifDrawAxis, ifDrawSquare)\",\n \"def main():\\n # Initialize so we can use it later\\n last_user = None\\n videos = []\\n\\n for line in _in:\\n if not line:\\n continue\\n\\n line = line.rstrip().split(\\\"\\\\t\\\")\\n if len(line) != 3:\\n sys.stderr.write(\\\"Malformed input: '%s'!\\\\n\\\" % \\\"\\\\t\\\".join(line))\\n return\\n\\n (user, video, timestamp) = line\\n\\n if last_user == user:\\n videos.append((video, timestamp))\\n else:\\n emit_reducer_output(videos) # If len(videos) <= 1, this is no-op\\n videos = [(video, timestamp)]\\n last_user = user\\n\\n emit_reducer_output(videos) # Make sure we emit for the last user\",\n \"def _decode_frames_by_av_module(\\n full_path,\\n video_start_pts=0,\\n video_end_pts=None,\\n audio_start_pts=0,\\n audio_end_pts=None,\\n):\\n if video_end_pts is None:\\n video_end_pts = float(\\\"inf\\\")\\n if audio_end_pts is None:\\n audio_end_pts = float(\\\"inf\\\")\\n container = av.open(full_path)\\n\\n video_frames = []\\n vtimebase = torch.zeros([0], dtype=torch.int32)\\n if container.streams.video:\\n video_frames = _read_from_stream(\\n container,\\n video_start_pts,\\n video_end_pts,\\n container.streams.video[0],\\n {\\\"video\\\": 0},\\n )\\n # container.streams.video[0].average_rate is not a reliable estimator of\\n # frame rate. It can be wrong for certain codec, such as VP80\\n # So we do not return video fps here\\n vtimebase = _fraction_to_tensor(container.streams.video[0].time_base)\\n\\n audio_frames = []\\n atimebase = torch.zeros([0], dtype=torch.int32)\\n if container.streams.audio:\\n audio_frames = _read_from_stream(\\n container,\\n audio_start_pts,\\n audio_end_pts,\\n container.streams.audio[0],\\n {\\\"audio\\\": 0},\\n )\\n atimebase = _fraction_to_tensor(container.streams.audio[0].time_base)\\n\\n container.close()\\n vframes = [frame.to_rgb().to_ndarray() for frame in video_frames]\\n vframes = torch.as_tensor(np.stack(vframes))\\n\\n vframe_pts = torch.tensor([frame.pts for frame in video_frames], dtype=torch.int64)\\n\\n aframes = [frame.to_ndarray() for frame in audio_frames]\\n if aframes:\\n aframes = np.transpose(np.concatenate(aframes, axis=1))\\n aframes = torch.as_tensor(aframes)\\n else:\\n aframes = torch.empty((1, 0), dtype=torch.float32)\\n\\n aframe_pts = torch.tensor([audio_frame.pts for audio_frame in audio_frames], dtype=torch.int64)\\n\\n return DecoderResult(\\n vframes=vframes,\\n vframe_pts=vframe_pts,\\n vtimebase=vtimebase,\\n aframes=aframes,\\n aframe_pts=aframe_pts,\\n atimebase=atimebase,\\n )\",\n \"def next_frame(self):\\n while True:\\n if self.grabbed:\\n buffer = self.__get_next_yuv_frame()\\n if len(buffer) != self.__frame_raw_data_size:\\n self.frame = False, False\\n self.stopped = True\\n break\\n\\n y, u, v = self.__extract_yuv_planes(buffer)\\n\\n # Save YUV planes now because they will be reshaped from (height, width) to (height, width, 1)\\n\\n converted_frame = self.__concatenate_planes_to_444yuv_frame(y, u, v)\\n\\n self.frame = True, converted_frame\\n self.grabbed = False\\n\\n if self.stopped:\\n break\\n\\n time.sleep(1/1000)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.660406","0.660406","0.6251925","0.62162185","0.61449426","0.6016263","0.59658784","0.59191173","0.5898252","0.58571494","0.58359957","0.58204484","0.5807554","0.57724744","0.5767315","0.57514405","0.5736507","0.57330585","0.5650401","0.5630842","0.5612644","0.56106573","0.5609324","0.5566299","0.55149204","0.55126166","0.5510266","0.5508319","0.5496684","0.548771","0.546425","0.54593915","0.5450174","0.5429082","0.54155433","0.5410944","0.5408088","0.5383312","0.53586644","0.53557754","0.5352625","0.53368324","0.5335559","0.53351885","0.5331957","0.53220165","0.53188974","0.53112555","0.5306653","0.53053004","0.5285857","0.5283461","0.5275938","0.5266976","0.5266671","0.52579427","0.52576417","0.5254926","0.52520543","0.52371097","0.5212802","0.5209495","0.52016264","0.51969486","0.51934546","0.51917636","0.5191663","0.5189578","0.51892906","0.5181349","0.517971","0.517787","0.51748204","0.5171627","0.5160728","0.5152416","0.5140705","0.5140318","0.5132824","0.51274776","0.5114465","0.51063764","0.5103796","0.50890744","0.5084585","0.50767577","0.50656456","0.5064792","0.5048147","0.504646","0.5046011","0.5045826","0.5043073","0.50395155","0.50381875","0.5029526","0.50291157","0.5027563","0.5019587","0.5007885"],"string":"[\n \"0.660406\",\n \"0.660406\",\n \"0.6251925\",\n \"0.62162185\",\n \"0.61449426\",\n \"0.6016263\",\n \"0.59658784\",\n \"0.59191173\",\n \"0.5898252\",\n \"0.58571494\",\n \"0.58359957\",\n \"0.58204484\",\n \"0.5807554\",\n \"0.57724744\",\n \"0.5767315\",\n \"0.57514405\",\n \"0.5736507\",\n \"0.57330585\",\n \"0.5650401\",\n \"0.5630842\",\n \"0.5612644\",\n \"0.56106573\",\n \"0.5609324\",\n \"0.5566299\",\n \"0.55149204\",\n \"0.55126166\",\n \"0.5510266\",\n \"0.5508319\",\n \"0.5496684\",\n \"0.548771\",\n \"0.546425\",\n \"0.54593915\",\n \"0.5450174\",\n \"0.5429082\",\n \"0.54155433\",\n \"0.5410944\",\n \"0.5408088\",\n \"0.5383312\",\n \"0.53586644\",\n \"0.53557754\",\n \"0.5352625\",\n \"0.53368324\",\n \"0.5335559\",\n \"0.53351885\",\n \"0.5331957\",\n \"0.53220165\",\n \"0.53188974\",\n \"0.53112555\",\n \"0.5306653\",\n \"0.53053004\",\n \"0.5285857\",\n \"0.5283461\",\n \"0.5275938\",\n \"0.5266976\",\n \"0.5266671\",\n \"0.52579427\",\n \"0.52576417\",\n \"0.5254926\",\n \"0.52520543\",\n \"0.52371097\",\n \"0.5212802\",\n \"0.5209495\",\n \"0.52016264\",\n \"0.51969486\",\n \"0.51934546\",\n \"0.51917636\",\n \"0.5191663\",\n \"0.5189578\",\n \"0.51892906\",\n \"0.5181349\",\n \"0.517971\",\n \"0.517787\",\n \"0.51748204\",\n \"0.5171627\",\n \"0.5160728\",\n \"0.5152416\",\n \"0.5140705\",\n \"0.5140318\",\n \"0.5132824\",\n \"0.51274776\",\n \"0.5114465\",\n \"0.51063764\",\n \"0.5103796\",\n \"0.50890744\",\n \"0.5084585\",\n \"0.50767577\",\n \"0.50656456\",\n \"0.5064792\",\n \"0.5048147\",\n \"0.504646\",\n \"0.5046011\",\n \"0.5045826\",\n \"0.5043073\",\n \"0.50395155\",\n \"0.50381875\",\n \"0.5029526\",\n \"0.50291157\",\n \"0.5027563\",\n \"0.5019587\",\n \"0.5007885\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5234842"},"document_rank":{"kind":"string","value":"60"}}},{"rowIdx":93078,"cells":{"query":{"kind":"string","value":"postprocess an inference result input in the format produced by the graph output in a human readable format"},"document":{"kind":"string","value":"def postprocess(output):\n text=''\n order = output.argsort()[::-1][:6]\n # print('\\n------- predictions --------')\n for i in range(1):\n # print ('prediction ' + str(i) + ' (probability ' + str(output[order[i]]*100) + '%) is ' + gNetworkCategories[order[i]] + ' label index is: ' + str(order[i]) )\n text=text+str(gNetworkCategories[order[i]])\n\n return text"},"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 postprocess(self, inference_output):\n logger.info(inference_output)\n return inference_output","def inference():\n if request.method == \"POST\":\n data = request.json #\n src_img = np.array(data[\"src\"]).astype(np.uint8) # Parsing data\n ref_img = np.array(data[\"ref\"]).astype(np.uint8) #\n ref_label = int(data[\"ref_label\"]) #\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\n return jsonify({\"result\": result.tolist()}) # Returning results into json","def inference_preprocess(self):\n return","def postprocess(self,graph_output):\n (w,h,f) = self.rawinputformat()\n #print(w,h)\n #print(graph_output.shape)\n results = self.interpret_output(graph_output.astype(numpy.float32), w, h)\n print(results)\n #order = graph_output.argsort()\n #last = len(self.categories)-1\n #res = NcsResult();\n #print(len(results))\n #for i in range(0,len(results)):\n # res = results[i]\n #res.add( self.categories[order[last-i]], ( graph_output[order[last-i]] ) )\n return res\n\n # YOLO stuff","def inference(self):\n raise NotImplementedError","def postprocess(self, inference_output):\n ret = []\n quantiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n # for each request\n for inference_output_request in inference_output:\n ret_request = []\n # for each time series\n for i in inference_output_request:\n l = {}\n l[\"item_id\"] = i.item_id\n l[\"quantiles\"] = {}\n for q in quantiles:\n l[\"quantiles\"][str(q)] = i.quantile(q).tolist()\n l[\"mean\"] = i.mean.tolist()\n ret_request.append(json.dumps(l))\n ret.append('\\n'.join(ret_request) + '\\n')\n return ret","def _post_process_output(self,predictions,convert_to_string):\n if convert_to_string:\n return ' '.join([\"%s-%s\" % (p[0],p[1]) for p in predictions])\n return predictions","def _postprocess(self, output: Dict[str, np.ndarray]):\n # Slice to remove padding, omitting initial [CLS] and final [SEP]\n slicer = slice(1, output.pop(\"ntok\") - 1)\n output[\"tokens\"] = self.tokenizer.convert_ids_to_tokens(\n output.pop(\"input_ids\")[slicer])\n probas = output.pop(\"probas\")\n\n # Predictions at every position, regardless of masking.\n output[\"pred_tokens\"] = self._get_topk_tokens(probas[slicer]) # pytype: disable=container-type-mismatch\n\n return output","def inference(self, inputs):\n # NOTE: This makes the assumption that your model expects text to be tokenized\n # with \"input_ids\" and \"token_type_ids\" - which is true for some popular transformer models, e.g. bert.\n # If your transformer model expects different tokenization, adapt this code to suit\n # its expected input format.\n input_ids = inputs[\"input_ids\"]\n input_ids = input_ids.to(self.device)\n\n coarse_result = self.model.generate(input_ids = input_ids, )\n coarse_result = coarse_result.to(\"cpu\")\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\"original_length\"]+1:],\n skip_special_tokens = True)\n #logger.info(\"Model predicted: '%s'\", fined_result)\n\n return [fined_result]","def postprocess(self, data):\n if self.error is not None:\n return [self.error]\n\n # Iterating over inference results to render the normalized probabilities\n response = []\n for inference_result in data:\n softmax_result = inference_result.softmax().asnumpy()\n for idx, label in enumerate(self.labels):\n response.append({label: float(softmax_result[0][idx])})\n return [response]","def print_inference_result(self):\n if (\n self.params.model_str == 'optfixedsig'\n or self.params.model_str == 'opt'\n or self.params.model_str == 'fixedparam'\n ):\n print('*ls pt est = ' + str(self.sample_list[0].ls) + '.')\n print('*alpha pt est = ' + str(self.sample_list[0].alpha) + '.')\n print('*sigma pt est = ' + str(self.sample_list[0].sigma) + '.')\n elif self.params.model_str == 'samp' or self.params.model_str == 'sampfixedsig':\n ls_arr = np.array([ns.ls for ns in self.sample_list])\n alpha_arr = np.array([ns.alpha for ns in self.sample_list])\n sigma_arr = np.array([ns.sigma for ns in self.sample_list])\n print('*ls mean = ' + str(ls_arr.mean()) + '.')\n print('*ls std = ' + str(ls_arr.std()) + '.')\n print('*alpha mean = ' + str(alpha_arr.mean()) + '.')\n print('*alpha std = ' + str(alpha_arr.std()) + '.')\n print('*sigma mean = ' + str(sigma_arr.mean()) + '.')\n print('*sigma std = ' + str(sigma_arr.std()) + '.')\n print('-----')","def do_inference(self, output_file = None):\n return","def handle_result(result):\n return str(len(result)) + \"\\n\" + \"\\n\".join([\"{0} {1} {2}\".format(*outfit) for outfit in result])","def _inference_step(self, state):\n\n decoder_inputs = state[\"inputs\"]\n encoder_outputs = state[\"encoder_outputs\"]\n attention_bias = state[\"encoder_decoder_attention_bias\"]\n alignment_positions = state[\"alignment_positions\"]\n\n outputs = self._decode_pass(\n decoder_inputs=decoder_inputs,\n encoder_outputs=encoder_outputs,\n enc_dec_attention_bias=attention_bias,\n alignment_positions=alignment_positions\n )\n\n with tf.variable_scope(\"inference_step\"):\n next_inputs_mel = outputs[\"post_net_spec\"][:, -1:, :]\n next_inputs_mel = self._expand(next_inputs_mel, self.reduction_factor)\n next_inputs_mag = outputs[\"mag_spec\"][:, -1:, :]\n next_inputs_mag = self._expand(next_inputs_mag, self.reduction_factor)\n next_inputs = tf.concat([next_inputs_mel, next_inputs_mag], axis=-1)\n\n n_features = self.num_mels + self.num_freq\n next_inputs = self._shrink(next_inputs, n_features, self.reduction_factor)\n\n # Set zero if sequence is finished\n next_inputs = tf.where(\n state[\"finished\"],\n tf.zeros_like(next_inputs),\n next_inputs\n )\n next_inputs = tf.concat([decoder_inputs, next_inputs], 1)\n\n # Update lengths\n lengths = state[\"outputs\"][\"lengths\"]\n lengths = tf.where(\n state[\"finished\"],\n lengths,\n lengths + 1 * self.reduction_factor\n )\n outputs[\"lengths\"] = lengths\n\n # Update spec, post_net_spec and mag_spec\n for key in [\"spec\", \"post_net_spec\", \"mag_spec\"]:\n output = outputs[key][:, -1:, :]\n output = tf.where(state[\"finished\"], tf.zeros_like(output), output)\n outputs[key] = tf.concat([state[\"outputs\"][key], output], 1)\n\n # Update stop token logits\n stop_token_logits = outputs[\"stop_token_logits\"][:, -1:, :]\n stop_token_logits = tf.where(\n state[\"finished\"],\n tf.zeros_like(stop_token_logits) + 1e9,\n stop_token_logits\n )\n stop_prediction = tf.sigmoid(stop_token_logits)\n stop_prediction = tf.reduce_max(stop_prediction, axis=-1)\n\n # Uncomment next line if you want to use stop token predictions\n finished = tf.reshape(tf.cast(tf.round(stop_prediction), tf.bool), [-1])\n finished = tf.reshape(finished, [-1])\n\n stop_token_logits = tf.concat(\n [state[\"outputs\"][\"stop_token_logits\"], stop_token_logits],\n axis=1\n )\n outputs[\"stop_token_logits\"] = stop_token_logits\n\n with tf.variable_scope(\"alignments\"):\n weights = []\n for index, attention in enumerate(self.attentions):\n if isinstance(attention, AttentionBlock):\n weights.append(attention.multiheaded_attention.attention_weights)\n\n weights = tf.stack(weights)\n outputs[\"alignments\"] = [weights]\n\n alignment_positions = tf.argmax(\n weights,\n axis=-1,\n output_type=tf.int32\n )[:, :, :, -1:]\n state[\"alignment_positions\"] = tf.concat(\n [state[\"alignment_positions\"], alignment_positions],\n axis=-1\n )\n\n state[\"iteration\"] = state[\"iteration\"] + 1\n state[\"inputs\"] = next_inputs\n state[\"finished\"] = finished\n state[\"outputs\"] = outputs\n\n return state","def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass","def postprocessor(answer, example=None, is_target=False):\n if example:\n return tf.compat.as_text(answer) + \"\\t\" + tf.compat.as_text(example[\"id\"])\n else:\n return answer","def infer(self, sequence: str) -> str: \n \n logging.info(\"Classifier.infer: infering for \\\"\" + sequence + \"\\\"...\") \n result = self.pipeline(sequence)\n logging.info(\"Classifier.infer: entities=\\\"\" + json.dumps(result, cls=NpEncoder) + \"\\\"\")\n\n return {'entities': json.dumps(result, cls=NpEncoder)}","def decode_results(self, outputs):\n ...","def inference(self):\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].send(\"inference\")\n \n ## wait for the finalization to be completed\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].recv()","def interpret_output(self, batch_output):\n raise NotImplementedError","def inference_end(self, inputs, results):\n return","def _do_infer(stream_manager_api, data_input):\n stream_name = b'segmentation'\n unique_id = stream_manager_api.SendData(\n stream_name, 0, data_input)\n if unique_id < 0:\n raise RuntimeError(\"Failed to send data to stream.\")\n\n keys = [b\"mxpi_tensorinfer0\"]\n keyVec = StringVector()\n for key in keys:\n keyVec.push_back(key)\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\n print(infer_result)\n if infer_result.size() == 0:\n print(\"infer_result is null\")\n exit()\n\n TensorList = MxpiDataType.MxpiTensorPackageList()\n TensorList.ParseFromString(infer_result[0].messageBuf)\n data = np.frombuffer(\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\n data = data.reshape(1, 19, 1024, 2048)\n return data","def _post_process_output(self,predictions,convert_to_string):\n normalized = [(p[0],REVERSE_ARROWS.get(p[1],p[1]),p[2]) for p in predictions]\n if convert_to_string:\n return ' '.join([\"%s%s\" % (p[0],p[1]) for p in normalized])\n return normalized","def inference(self, uInput):\n self.expose(uInput)\n for m in range(len(self.layers) - 1):\n self.layers[m].inference()\n self.propagate(m, m + 1)\n\n ## make inference on the output node\n self.layers[-1].pipes[0][0].send(\"inference\")\n self.layers[-1].pipes[0][0].recv()\n\n ## read its output\n self.layers[-1].pipes[0][0].send(\"get_output\")\n msg = self.layers[-1].pipes[0][0].recv()\n\n t = msg[1]['dtype']\n s = msg[1]['shape']\n output = recv_array(self.layers[-1].pipes[0][0], t, s)\n\n return output","def postprocess(self, inputs: Dict[str, Any],\n **postprocess_params) -> Dict[str, str]:\n text = inputs['text']\n logits = inputs[OutputKeys.LOGITS]\n predictions = torch.argmax(logits[0], dim=-1)\n logits = torch_nested_numpify(torch_nested_detach(logits))\n predictions = torch_nested_numpify(torch_nested_detach(predictions))\n offset_mapping = [x.cpu().tolist() for x in inputs['offset_mapping']]\n\n labels = [self.id2label[x] for x in predictions]\n if len(labels) > len(offset_mapping):\n labels = labels[1:-1]\n chunks = []\n chunk = {}\n for label, offsets in zip(labels, offset_mapping):\n if label[0] in 'BS':\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n chunk = {\n 'type': label[2:],\n 'start': offsets[0],\n 'end': offsets[1]\n }\n if label[0] in 'IES':\n if chunk:\n chunk['end'] = offsets[1]\n\n if label[0] in 'ES':\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n chunk = {}\n\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n\n # for cws outputs\n if len(chunks) > 0 and chunks[0]['type'] == 'cws':\n spans = [\n chunk['span'] for chunk in chunks if chunk['span'].strip()\n ]\n seg_result = ' '.join(spans)\n outputs = {OutputKeys.OUTPUT: seg_result}\n\n # for ner output\n else:\n outputs = {OutputKeys.OUTPUT: chunks}\n return outputs","def postprocess(m):\n logger.info(\"Postprocessing the model...\")\n while len(m.graph.value_info) > 0:\n m.graph.value_info.pop()\n m = other.polish_model(m)\n eliminating.eliminate_single_input_Concat(m.graph)\n eliminating.eliminate_nop_Maxpool_and_AveragePool(m.graph)\n eliminating.eliminate_trivial_elementwise_calculation(m.graph)\n m = other.polish_model(m)\n\n replacing.replace_depthwise_1x1_with_bn(m.graph)\n m = other.polish_model(m)\n\n # removing transpose\n m = removing_transpose.eliminate_transposes(m)\n m = other.polish_model(m)\n removing_transpose.remove_trivial_transpose(m.graph)\n removing_transpose.fuse_Transpose_into_Gemm_weight(m.graph)\n\n # fuse some nodes\n fusing.fuse_mul_and_add_into_bn(m.graph)\n m = other.polish_model(m)\n fusing.fuse_mul_and_add_into_gemm(m.graph)\n m = other.polish_model(m)\n fusing.fuse_conv_and_add_into_conv(m.graph)\n m = other.polish_model(m)\n replacing.replace_mul_to_bn(m.graph)\n replacing.replace_div_to_bn(m.graph)\n replacing.replace_add_to_bn(m.graph)\n replacing.replace_sub_to_bn(m.graph)\n replacing.replace_sub_with_bn_and_add(m.graph)\n m = other.polish_model(m)\n\n other.add_output_to_value_info(m.graph)\n m = optimizer.optimize(m, [\"eliminate_deadend\"])\n m.producer_name = \"kneron_formatter\"\n return m","def inference(self, inputs):\n\n input_ids = torch.tensor([inputs[\"head_ids\"]], dtype=torch.long).to(self.device)\n attention_masks = torch.tensor([inputs[\"attention_masks\"]], dtype=torch.bool).to(self.device)\n \n # Handling inference for sequence_classification.\n with torch.no_grad():\n output = self.model(input_ids, attention_masks)\n predict_label = output[0].argmax(dim=2)\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\n\n logger.info(\"Model predicted: '%s'\", predict_string)\n return [{'predict': predict_string}]","def inference():\n\n sents = request.get_json(force=True)['sents']\n\n vecs = tokenize_inputs(sents)\n results = model(vecs)\n\n result = dict()\n result['pred'] = [str(sample.numpy()[0]) for sample in results]\n \n response = flask.Response()\n response.headers.add(\"Access-Control-Allow-Origin\", \"*\")\n\n print(result)\n\n return result","def infer(self, input):\n input = self._get_encoding_form(input)\n input = self.inference_model(input)\n self.latent.infer(input)","def inference_on_data(image) -> str:\n result = inference_model(image)\n class_label = torch.argmax(result[0])\n # Print to log acts as a proxy of saving to an actual DB\n print(f'Image Class : {class_label}')\n return str(class_label)","def format_model_output(self, output, batch_size=1):\r\n return output","def inference(self, inputs):\n # test_2\n memory = self.get_go_frame(inputs)\n memory = self._update_memory(memory)\n\n self._init_states(inputs, mask=None)\n self.attention.init_states(inputs)\n\n outputs, stop_tokens, alignments, t = [], [], [], 0\n while True:\n memory = self.prenet(memory)\n decoder_output, alignment, stop_token = self.decode(memory)\n stop_token = torch.sigmoid(stop_token.data)\n outputs += [decoder_output.squeeze(1)]\n stop_tokens += [stop_token]\n alignments += [alignment]\n\n if stop_token > self.stop_threshold and t > inputs.shape[0] // 2:\n break\n if len(outputs) == self.max_decoder_steps:\n print(\" | > Decoder stopped with 'max_decoder_steps\")\n break\n\n memory = self._update_memory(decoder_output)\n t += 1\n\n outputs, stop_tokens, alignments = self._parse_outputs(\n outputs, stop_tokens, alignments)\n\n return outputs, alignments, stop_tokens","def inference_call(self, inputs):\n self.eval()\n\n with torch.no_grad():\n mid, downsampling_features = self.encoder(inputs)\n hd = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=0)\n pl = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=1)\n return hd, pl","def _post_process_result(result: Any) -> Any:\n return result","def compute_output(api, args):\n\n fusion = None\n\n # variables from command-line options\n resume = args.resume_\n fusion_ids = args.fusion_ids_\n output = args.predictions\n # there's only one fusion to be generated at present\n args.max_parallel_fusions = 1\n # fusion cannot be published yet.\n args.public_fusion = False\n\n # It is compulsory to have a description to publish either datasets or\n # fusions\n if (not args.description_ and args.public_fusion):\n sys.exit(\"You should provide a description to publish.\")\n\n path = u.check_dir(output)\n session_file = \"%s%s%s\" % (path, os.sep, SESSIONS_LOG)\n csv_properties = {}\n # If logging is required set the file for logging\n log = None\n if args.log_file:\n u.check_dir(args.log_file)\n log = args.log_file\n # If --clear_logs the log files are cleared\n clear_log_files([log])\n\n if args.fusion_file:\n # fusion regression is retrieved from the contents of the given local\n # JSON file\n fusion, csv_properties, fields = u.read_local_resource(\n args.fusion_file,\n csv_properties=csv_properties)\n fusion_ids = [fusion]\n else:\n # fusion is retrieved from the remote object or created\n fusion, resume = \\\n pf.fusion_processing( \\\n fusion, fusion_ids, \\\n api, args, resume, \\\n session_file=session_file, path=path, log=log)\n\n # We update the fusion public state if needed\n if fusion:\n if isinstance(fusion, str):\n if not a.has_test(args):\n query_string = MINIMUM_MODEL\n elif args.export_fields:\n query_string = r.ALL_FIELDS_QS\n else:\n query_string = ''\n fusion = u.check_resource(fusion,\n api.get_fusion,\n query_string=query_string)\n if (args.public_fusion or\n (args.shared_flag and r.shared_changed(args.shared,\n fusion))):\n fusion_args = {}\n if args.shared_flag and r.shared_changed(args.shared,\n fusion):\n fusion_args.update(shared=args.shared)\n if args.public_fusion:\n fusion_args.update( \\\n rfus.set_publish_fusion_args(args))\n if fusion_args:\n fusion = rfus.update_fusion( \\\n fusion, fusion_args, args,\n api=api, path=path, \\\n session_file=session_file)\n\n # We get the fields of the fusion if we haven't got\n # them yet and need them\n if fusion and (args.test_set or args.evaluate):\n fields = pf.get_fusion_fields( \\\n fusion, csv_properties, args)\n\n\n # If predicting\n if fusion and (a.has_test(args) or \\\n args.remote):\n test_dataset = get_test_dataset(args)\n\n # Remote predictions: predictions are computed as batch predictions\n # in bigml.com except when --no-batch flag is set on\n if args.remote and not args.no_batch:\n # create test source from file\n test_name = \"%s - test\" % args.name\n if args.test_source is None:\n test_properties = ps.test_source_processing(\n api, args, resume, name=test_name,\n session_file=session_file, path=path, log=log)\n (test_source, resume,\n csv_properties, test_fields) = test_properties\n else:\n test_source_id = bigml.api.get_source_id(args.test_source)\n test_source = api.check_resource(test_source_id)\n if test_dataset is None:\n # create test dataset from test source\n dataset_args = set_basic_dataset_args(args, name=test_name)\n test_dataset, resume = pd.alternative_dataset_processing(\n test_source, \"test\", dataset_args, api, args,\n resume, session_file=session_file, path=path, log=log)\n else:\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\n test_dataset = api.check_resource(test_dataset_id)\n\n csv_properties.update(objective_field=None,\n objective_field_present=False)\n test_fields = pd.get_fields_structure(test_dataset,\n csv_properties)\n if not args.evaluate:\n batch_prediction_args = set_batch_prediction_args(\n args, fields=fields,\n dataset_fields=test_fields)\n\n remote_prediction(fusion, test_dataset, \\\n batch_prediction_args, args, \\\n api, resume, prediction_file=output, \\\n session_file=session_file, path=path, log=log)\n\n else:\n prediction([fusion], fields, args,\n session_file=session_file)\n\n\n # If evaluate flag is on, create remote evaluation and save results in\n # json and human-readable format.\n if args.evaluate:\n # When we resume evaluation and models were already completed, we\n # should use the datasets array as test datasets\n args.max_parallel_evaluations = 1 # only one evaluation at present\n args.cross_validation_rate = 0 # no cross-validation\n args.number_of_evaluations = 1 # only one evaluation\n if args.has_test_datasets_:\n test_dataset = get_test_dataset(args)\n dataset = test_dataset\n dataset = u.check_resource(dataset, api=api,\n query_string=r.ALL_FIELDS_QS)\n dataset_fields = pd.get_fields_structure(dataset, None)\n resume = evaluate([fusion], [dataset], api,\n args, resume,\n fields=fields, dataset_fields=dataset_fields,\n session_file=session_file, path=path,\n log=log,\n objective_field=args.objective_field)\n\n\n u.print_generated_files(path, log_file=session_file,\n verbosity=args.verbosity)\n if args.reports:\n clear_reports(path)\n if args.upload:\n upload_reports(args.reports, path)","def handle(self, data, context):\n \n model_input = self.preprocess(data)\n model_out = self.inference(model_input)\n return self.postprocess(model_out)","def format_det_result():\n test_results = load(args.test_result)\n annos = load(args.anno_path)\n test_videos = annos['test_videos'][0]\n resolutions = annos['resolution']\n frm_dets = []\n for pred in track(test_results, description='formating...'):\n video_key = pred['video_id'].split('.mp4')[0]\n frm_num = pred['timestamp']\n bboxes = pred['pred_instances']['bboxes']\n cls_scores = pred['pred_instances']['scores']\n for bbox, cls_score in zip(bboxes, cls_scores):\n video_idx = test_videos.index(video_key)\n pred_label = np.argmax(cls_score)\n score = cls_score[pred_label]\n h, w = resolutions[video_key]\n bbox *= np.array([w, h, w, h])\n instance_result = np.array(\n [video_idx, frm_num, pred_label, score, *bbox])\n frm_dets.append(instance_result)\n frm_dets = np.array(frm_dets)\n video_tubes = link_tubes(annos, frm_dets, K=1)\n dump(frm_dets, args.frm_out_path)\n dump(video_tubes, args.tube_out_path)","def inference():\n data = request.get_json(force = True)\n\n with torch.no_grad():\n torch.cuda.empty_cache()\n image = ToTensor(Image.open(BytesIO(b64decode(data['image'])))).half().cuda().unsqueeze_(0)\n inputs = test_transform(image)\n model_id = model_usage.get(True)\n outputs = model[model_id](inputs)[0]\n model_usage.put(model_id, False)\n prediction = classes[outputs.argmax(0)]\n del inputs, outputs, image\n \n image_storage.put((data['esun_uuid'], data['image'], prediction), False)\n\n t = datetime.datetime.now()\n ts = str(int(t.utcnow().timestamp()))\n s = sha256()\n s.update((CAPTAIN_EMAIL + ts + SALT).encode(\"utf-8\"))\n server_uuid = s.hexdigest()\n\n return jsonify({'esun_uuid': data['esun_uuid'],\n 'server_uuid': server_uuid,\n 'answer': prediction,\n 'server_timestamp': time()})","def post_process(self, res):\n # some lists are better converted to numpy arrays\n convert_to_arr = (\n 'prediction_rank',\n 'cumulative_area',\n 'prediction_values',\n 'cumulative_crime',\n 'cumulative_crime_count',\n 'cumulative_crime_max',\n 'pai'\n )\n for k in convert_to_arr:\n if k in res:\n # this allows for optional components such as prediction values\n res[k] = np.array(res[k])","def infer_outputs(self):\n # TF lack a supported API for invoking shape inference directly,\n # so we instantiate a dummy graph and create a dummy Operation object\n temp_graph = tf.Graph()\n with temp_graph.as_default():\n input_placeholders = [tf.placeholder(shape=t.shape, dtype=t.dtype) for\n t in self._inputs]\n # See the docs for tf.Operation for important notes about the semantics\n # of each arg to the following constructor.\n dummy_op = tf.Operation(self.to_node_def(), temp_graph,\n inputs=input_placeholders)\n self.set_outputs_from_pairs([(o.dtype, o.shape)\n for o in dummy_op.outputs])\n # set_outputs_from_pairs() increments the version counter, so we don't\n # need to. Also, we haven't added edges to the graph until these\n # outputs are connected to another node's inputs.","def postprocess_for_inference(self,\n prediction: Dict[str, torch.Tensor],\n *args, **kwargs,\n ) -> Dict[str, torch.Tensor]:\n return {\"pred_seg\": self.logits_convert_fn(prediction[\"seg_logits\"])}","def run_inference_on_image(image):\n if not tf.gfile.Exists(image):\n tf.logging.fatal('File does not exist %s', image)\n image_data = tf.gfile.FastGFile(image, 'rb').read()\n\n\n\n with tf.Session() as sess:\n # Some useful tensors:\n # 'softmax:0': A tensor containing the normalized prediction across\n # 1000 labels.\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\n # float description of the image.\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\n # encoding of the image.\n # Runs the softmax tensor by feeding the image_data as input to the graph.\n\n # Creates node ID --> English string lookup.\n node_lookup = NodeLookup()\n\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n predictions = sess.run(softmax_tensor,\n {'DecodeJpeg/contents:0': image_data})\n predictions = np.squeeze(predictions)\n\n\n\n top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\n result =[]\n for node_id in top_k:\n human_string = node_lookup.id_to_string(node_id)\n score = predictions[node_id]\n\n point = collections.namedtuple('Point', ['humanString', 'score'])\n point.humanString = human_string\n point.score = score\n result.append(point)\n return result","def inference(self, input_batch):\r\n inferences = []\r\n # Handling inference for token_classification.\r\n batch_size = len(input_batch)\r\n\r\n num_rows = batch_size\r\n for i in range(num_rows):\r\n inferences.append({'entity':input_batch[i]})\r\n logger.info(\"Model predicted: '%s'\", input_batch)\r\n\r\n return inferences","def inference_as_raw_output(self, image_path, to_file = False):\n\n image_np = self.load_image_into_numpy_array(image_path)\n input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.uint8)\n\n detections_raw = self.detect_fn(input_tensor)\n # checking how many detections we got\n detections = self.process_detections(detections_raw)\n\n detections_api = {key: value.tolist() for key, value in detections.items()} # convert array to list for whole dict for API\n\n if to_file: # if saving to txt file was requested\n\n image_h, image_w, _ = image_np.shape\n\n dir_path=os.path.join(os.path.dirname(image_path),'prediction_txt_raw_output')\n\n if not os.path.isdir(dir_path):\n os.mkdir(dir_path)\n\n title , _ = os.path.splitext(os.path.basename(image_path))\n\n file_name = os.path.join(dir_path, f'{title}.txt')\n \n line2write = list()\n line2write.append(os.path.basename(image_path))\n \n with open(file_name, 'w') as text_file:\n # iterating over boxes\n for b, s, c in zip(\n detections['detection_boxes'], \n detections['detection_scores'], \n detections['detection_classes']\n ):\n \n y1abs, x1abs = b[0] * image_h, b[1] * image_w\n y2abs, x2abs = b[2] * image_h, b[3] * image_w\n \n list2append = [x1abs, y1abs, x2abs, y2abs, s, c]\n line2append = ','.join([str(item) for item in list2append])\n \n line2write.append(line2append)\n \n line2write = '\\n'.join(line2write)\n text_file.write(line2write + os.linesep)\n # print(f'save prediction result to {file_name} -> Done')\n \n return detections_api","def test_inference(VD, CD):\n \n if VD['inference_process'] == None:\n VD['terminal_output'] += \"There is no active inference process.\\n\"\n else:\n VD['terminal_output'] += \"\\nTesting the inference process.\\nOutput should be: \\\"let's test again then\\\".\\n\"\n ap.run_inference(CD['path_sample_audio'], VD, CD)\n VD['window']['inferred_text'].update(VD['temp_text'])","async def transformer_infer(query: dict, response: Response) -> dict:\n logger.debug(\"TRANSFORMER - predicting query: \" + str(query))\n results = {}\n try:\n results = MODELS.sparse_reader.predict(query)\n logger.info(results)\n except Exception:\n logger.error(f\"Unable to get results from transformer for {query}\")\n response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR\n raise\n return results","def _convert_outputs(outputs, reduction_factor, batch_size):\n\n with tf.variable_scope(\"output_converter\"):\n for key in [\"spec\", \"post_net_spec\", \"stop_token_logits\", \"mag_spec\"]:\n outputs[key] = CentaurDecoder._expand(outputs[key], reduction_factor)\n\n alignments = []\n for sample in range(batch_size):\n alignments.append([outputs[\"alignments\"][0][:, sample, :, :, :]])\n mel_spec = outputs[\"spec\"]\n post_net_spec = outputs[\"post_net_spec\"]\n alignments = alignments\n stop_token_logits = tf.sigmoid(outputs[\"stop_token_logits\"])\n sequence_lengths = outputs[\"lengths\"]\n mag_spec = outputs[\"mag_spec\"]\n stop_token_prediction = outputs[\"stop_token_logits\"]\n return mel_spec, post_net_spec, alignments, stop_token_logits, sequence_lengths, mag_spec, stop_token_prediction","def inference(self, input: Union[str, Any]):\n\n _input = transform(path=input, sr=16000)\n F, T = _input.shape\n\n x = torch.zeros(1, F, len(_input[0]))\n x[0, :, :] = _input\n x = x.unsqueeze(1)\n \n x = x.to(self.device)\n \n with torch.no_grad():\n output = self.model(x)\n \n if self.model_type == 'multi_class':\n pred = output.data.max(1, keepdim=True)[1]\n else:\n pred = torch.sigmoid(output)\n pred = pred[:, -1]\n pred = pred.view(-1).data.cpu().numpy()[0]\n\n return (pred, self.idx2label.get(int(pred >= 0.5)))","def postprocess(self, predicted_output, original_input=None, stats=None,\n **kwargs):\n pass","def postprocess(self, inference_output):\n\n predicted_idx = str(np.argmax(inference_output.cpu().detach().numpy()))\n\n if self.mapping:\n return [self.mapping[str(predicted_idx)]]\n return [predicted_idx]","def inference(self, x, data):\n\n ## Global features concatenated\n if self.u_dim > 0:\n u = data.u.view(-1, self.u_dim)\n x = torch.cat((x, u), 1)\n\n ## Final MLP map\n \n # Edge level inference\n if 'edge' in self.task:\n x = self.forward_2pt(x, data.edge_index)\n\n # Node or graph level inference\n else:\n x = self.mlp_final(x)\n\n return x","def postprocess_result(self):\n output_file = self.analyzer_result_file\n LOG.debug_analyzer(self.analyzer_stdout)\n tidy_stdout = self.analyzer_stdout.splitlines()\n generate_plist_from_tidy_result(output_file, tidy_stdout)\n\n if self.report_hash_type == 'context-free':\n report.use_context_free_hashes(output_file)","def infer():\n\n # Create StreamManagerApi object\n stream_manager_api = StreamManagerApi()\n # Use InitManager method init StreamManagerApi\n ret = stream_manager_api.InitManager()\n if ret != 0:\n print(\"Failed to init Stream manager, ret=%s\" % str(ret))\n exit()\n\n # create streams by pipeline config file\n with open(args.pipeline_path, \"rb\") as f:\n pipeline_str = f.read()\n\n # Configuring a stream\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\n if ret != 0:\n print(\"Failed to create Stream, ret=%s\" % str(ret))\n exit()\n\n # Construct the input of the stream\n data_input = MxDataInput()\n # Stream_name encoded in UTF-8\n stream_name = args.stream_name.encode()\n print(stream_name)\n predictions = []\n with open(args.label_path, 'rt') as f:\n val_cls = f.read().rstrip(\"\\n\").split(\"\\n\")\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(args.instances_path)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n for file_name in os.listdir(args.img_path):\n pred_data = []\n # Gets the Address of each image\n img_id = int(file_name.split('.')[0])\n file_path = args.img_path + file_name\n size = (cv2.imread(file_path)).shape\n\n # Read each photo in turn\n with open(file_path, \"rb\") as f:\n img_data = f.read()\n if not img_data:\n print(f\"read empty data from img:{file_name}\")\n continue\n # The element value img_data\n data_input.data = img_data\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\n pred_data.append({\"boxes\": boxes_output,\n \"box_scores\": scores_output,\n \"img_id\": img_id,\n \"image_shape\": size})\n\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\n print(f\"Inferred image:{file_name} success!\")\n\n # Save the result in JSON format\n if not os.path.exists(args.res_path):\n os.makedirs(args.res_path)\n with open(args.res_path + 'predictions_test.json', 'w') as f:\n json.dump(predictions, f)\n stream_manager_api.DestroyAllStreams()","def compute_output(api, args):\n source = None\n dataset = None\n model = None\n models = None\n fields = None\n other_label = OTHER\n ensemble_ids = []\n multi_label_data = None\n multi_label_fields = []\n local_ensemble = None\n test_dataset = None\n datasets = None\n\n # variables from command-line options\n resume = args.resume_\n model_ids = args.model_ids_\n output = args.predictions\n dataset_fields = args.dataset_fields_\n\n # It is compulsory to have a description to publish either datasets or\n # models\n if (not args.description_ and\n (args.black_box or args.white_box or args.public_dataset)):\n sys.exit(\"You should provide a description to publish.\")\n\n # When using --max-categories, it is compulsory to specify also the\n # objective_field\n if args.max_categories > 0 and args.objective_field is None:\n sys.exit(\"When --max-categories is used, you must also provide the\"\n \" --objective field name or column number\")\n\n # When using --new-fields, it is compulsory to specify also a dataset\n # id\n if args.new_fields and not args.dataset:\n sys.exit(\"To use --new-fields you must also provide a dataset id\"\n \" to generate the new dataset from it.\")\n\n path = u.check_dir(output)\n session_file = \"%s%s%s\" % (path, os.sep, SESSIONS_LOG)\n csv_properties = {}\n # If logging is required set the file for logging\n log = None\n if args.log_file:\n u.check_dir(args.log_file)\n log = args.log_file\n # If --clear_logs the log files are cleared\n clear_log_files([log])\n\n # labels to be used in multi-label expansion\n labels = (None if args.labels is None else\n [label.strip() for label in\n args.labels.split(args.args_separator)])\n if labels is not None:\n labels = sorted([label for label in labels])\n\n # multi_label file must be preprocessed to obtain a new extended file\n if args.multi_label and args.training_set is not None:\n (args.training_set, multi_label_data) = ps.multi_label_expansion(\n args.training_set, args.train_header, args, path,\n labels=labels, session_file=session_file)\n args.train_header = True\n args.objective_field = multi_label_data[\"objective_name\"]\n all_labels = l.get_all_labels(multi_label_data)\n if not labels:\n labels = all_labels\n else:\n all_labels = labels\n if args.source_file:\n # source is retrieved from the contents of the given local JSON file\n source, csv_properties, fields = u.read_local_resource(\n args.source_file,\n csv_properties=csv_properties)\n else:\n # source is retrieved from the remote object\n source, resume, csv_properties, fields = ps.source_processing(\n api, args, resume,\n csv_properties=csv_properties, multi_label_data=multi_label_data,\n session_file=session_file, path=path, log=log)\n if args.multi_label and source:\n multi_label_data = l.get_multi_label_data(source)\n (args.objective_field,\n labels,\n all_labels,\n multi_label_fields) = l.multi_label_sync(args.objective_field,\n labels,\n multi_label_data,\n fields,\n multi_label_fields)\n\n if args.dataset_file:\n # dataset is retrieved from the contents of the given local JSON file\n model_dataset, csv_properties, fields = u.read_local_resource(\n args.dataset_file,\n csv_properties=csv_properties)\n if not args.datasets:\n datasets = [model_dataset]\n dataset = model_dataset\n else:\n datasets = u.read_datasets(args.datasets)\n if not datasets:\n # dataset is retrieved from the remote object\n datasets, resume, csv_properties, fields = pd.dataset_processing(\n source, api, args, resume,\n fields=fields,\n csv_properties=csv_properties,\n multi_label_data=multi_label_data,\n session_file=session_file, path=path, log=log)\n if datasets:\n dataset = datasets[0]\n if args.to_csv is not None:\n resume = pd.export_dataset(dataset, api, args, resume,\n session_file=session_file, path=path)\n\n # Now we have a dataset, let's check if there's an objective_field\n # given by the user and update it in the fields structure\n args.objective_id_ = get_objective_id(args, fields)\n\n # If test_split is used, split the dataset in a training and a test dataset\n # according to the given split\n if args.test_split > 0:\n dataset, test_dataset, resume = pd.split_processing(\n dataset, api, args, resume,\n multi_label_data=multi_label_data,\n session_file=session_file, path=path, log=log)\n datasets[0] = dataset\n \n # Check if the dataset has a categorical objective field and it\n # has a max_categories limit for categories\n if args.max_categories > 0 and len(datasets) == 1:\n if pd.check_max_categories(fields.fields[args.objective_id_]):\n distribution = pd.get_categories_distribution(dataset,\n args.objective_id_)\n if distribution and len(distribution) > args.max_categories:\n categories = [element[0] for element in distribution]\n other_label = pd.create_other_label(categories, other_label)\n datasets, resume = pd.create_categories_datasets(\n dataset, distribution, fields, args,\n api, resume, session_file=session_file, path=path, log=log,\n other_label=other_label)\n else:\n sys.exit(\"The provided objective field is not categorical nor \"\n \"a full terms only text field. \"\n \"Only these fields can be used with\"\n \" --max-categories\")\n\n # If multi-dataset flag is on, generate a new dataset from the given\n # list of datasets\n if args.multi_dataset:\n dataset, resume = pd.create_new_dataset(\n datasets, api, args, resume, fields=fields,\n session_file=session_file, path=path, log=log)\n datasets = [dataset]\n\n # Check if the dataset has a generators file associated with it, and\n # generate a new dataset with the specified field structure\n if args.new_fields:\n dataset, resume = pd.create_new_dataset(\n dataset, api, args, resume, fields=fields,\n session_file=session_file, path=path, log=log)\n datasets[0] = dataset\n # rebuild fields structure for new ids and fields\n fields = pd.get_fields_structure(dataset, csv_properties)\n args.objective_id_ = get_objective_id(args, fields)\n if args.multi_label and dataset and multi_label_data is None:\n multi_label_data = l.get_multi_label_data(dataset)\n (args.objective_field,\n labels,\n all_labels,\n multi_label_fields) = l.multi_label_sync(args.objective_field,\n labels,\n multi_label_data,\n fields, multi_label_fields)\n\n if dataset:\n # retrieves max_categories data, if any\n args.max_categories = get_metadata(dataset, 'max_categories',\n args.max_categories)\n other_label = get_metadata(dataset, 'other_label',\n other_label)\n if args.model_file:\n # model is retrieved from the contents of the given local JSON file\n model, csv_properties, fields = u.read_local_resource(\n args.model_file,\n csv_properties=csv_properties)\n models = [model]\n model_ids = [model['resource']]\n ensemble_ids = []\n elif args.ensemble_file:\n # model is retrieved from the contents of the given local JSON file\n ensemble, csv_properties, fields = u.read_local_resource(\n args.ensemble_file,\n csv_properties=csv_properties)\n model_ids = ensemble['object']['models'][:]\n ensemble_ids = [ensemble['resource']]\n models = model_ids[:]\n model = retrieve_resource(bigml.api.BigML(storage='./storage'),\n models[0],\n query_string=r.ALL_FIELDS_QS)\n models[0] = model\n else:\n # model is retrieved from the remote object\n models, model_ids, ensemble_ids, resume = pm.models_processing(\n datasets, models, model_ids,\n api, args, resume, fields=fields,\n session_file=session_file, path=path, log=log, labels=labels,\n multi_label_data=multi_label_data, other_label=other_label)\n\n if models:\n model = models[0]\n single_model = len(models) == 1\n # If multi-label flag is set and no training_set was provided, label\n # info is extracted from the user_metadata. If models belong to an\n # ensemble, the ensemble must be retrieved to get the user_metadata.\n if model and args.multi_label and multi_label_data is None:\n if len(ensemble_ids) > 0 and isinstance(ensemble_ids[0], dict):\n resource = ensemble_ids[0]\n elif belongs_to_ensemble(model):\n ensemble_id = get_ensemble_id(model)\n resource = r.get_ensemble(ensemble_id, api=api,\n verbosity=args.verbosity,\n session_file=session_file)\n else:\n resource = model\n multi_label_data = l.get_multi_label_data(resource)\n\n # We update the model's public state if needed\n if model:\n if isinstance(model, basestring):\n if not args.evaluate and not has_test(args):\n query_string = MINIMUM_MODEL\n elif not args.test_header:\n query_string = r.ALL_FIELDS_QS\n else:\n query_string = \"%s;%s\" % (r.ALL_FIELDS_QS, r.FIELDS_QS)\n model = u.check_resource(model, api.get_model,\n query_string=query_string)\n if (args.black_box or args.white_box or\n (args.shared_flag and r.shared_changed(args.shared, model))):\n model_args = {}\n if args.shared_flag and r.shared_changed(args.shared, model):\n model_args.update(shared=args.shared)\n if args.black_box or args.white_box:\n model_args.update(r.set_publish_model_args(args))\n if model_args:\n model = r.update_model(model, model_args, args,\n api=api, path=path,\n session_file=session_file)\n models[0] = model\n\n # We get the fields of the model if we haven't got\n # them yet and need them\n if model and not args.evaluate and args.test_set:\n # If more than one model, use the full field structure\n if (not single_model and not args.multi_label and\n belongs_to_ensemble(model)):\n if len(ensemble_ids) > 0:\n ensemble_id = ensemble_ids[0]\n else:\n ensemble_id = get_ensemble_id(model)\n local_ensemble = Ensemble(ensemble_id, api=api,\n max_models=args.max_batch_models)\n fields = pm.get_model_fields(\n model, csv_properties, args, single_model=single_model,\n multi_label_data=multi_label_data)\n # Free memory after getting fields\n local_ensemble = None\n gc.collect()\n\n # Fills in all_labels from user_metadata\n if args.multi_label and not all_labels:\n (args.objective_field,\n labels,\n all_labels,\n multi_label_fields) = l.multi_label_sync(args.objective_field, labels,\n multi_label_data, fields,\n multi_label_fields)\n if model:\n # retrieves max_categories data, if any\n args.max_categories = get_metadata(model, 'max_categories',\n args.max_categories)\n other_label = get_metadata(model, 'other_label',\n other_label)\n # If predicting\n if (models and (has_test(args) or (test_dataset and args.remote))\n and not args.evaluate):\n models_per_label = 1\n if test_dataset is None:\n test_dataset = get_test_dataset(args)\n\n if args.multi_label:\n # When prediction starts from existing models, the\n # multi_label_fields can be retrieved from the user_metadata\n # in the models\n if args.multi_label_fields is None and multi_label_fields:\n multi_label_field_names = [field[1] for field\n in multi_label_fields]\n args.multi_label_fields = \",\".join(multi_label_field_names)\n test_set = ps.multi_label_expansion(\n args.test_set, args.test_header, args, path,\n labels=labels, session_file=session_file, input_flag=True)[0]\n test_set_header = True\n\n # Remote predictions: predictions are computed as batch predictions\n # in bigml.com except when --no-batch flag is set on or multi-label\n # or max-categories are used\n if (args.remote and not args.no_batch and not args.multi_label\n and not args.method in [THRESHOLD_CODE, COMBINATION]):\n # create test source from file\n test_name = \"%s - test\" % args.name\n if args.test_source is None:\n (test_source,\n resume,\n csv_properties,\n test_fields) = ps.test_source_processing(\n api, args, resume, session_file=session_file,\n path=path, log=log)\n else:\n test_source_id = bigml.api.get_source_id(args.test_source)\n test_source = api.check_resource(test_source_id)\n if test_dataset is None:\n # create test dataset from test source\n dataset_args = r.set_basic_dataset_args(args, name=test_name)\n test_dataset, resume = pd.alternative_dataset_processing(\n test_source, \"test\", dataset_args, api, args,\n resume, session_file=session_file, path=path, log=log)\n else:\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\n test_dataset = api.check_resource(test_dataset_id)\n\n csv_properties.update(objective_field=None,\n objective_field_present=False)\n test_fields = pd.get_fields_structure(test_dataset,\n csv_properties)\n\n batch_prediction_args = r.set_batch_prediction_args(\n args, fields=fields,\n dataset_fields=test_fields)\n\n remote_predict(model, test_dataset, batch_prediction_args, args,\n api, resume, prediction_file=output,\n session_file=session_file, path=path, log=log)\n else:\n models_per_label = args.number_of_models\n if (args.multi_label and len(ensemble_ids) > 0\n and args.number_of_models == 1):\n # use case where ensembles are read from a file\n models_per_label = len(models) / len(ensemble_ids)\n predict(models, fields, args, api=api, log=log,\n resume=resume, session_file=session_file, labels=labels,\n models_per_label=models_per_label, other_label=other_label,\n multi_label_data=multi_label_data)\n\n # When combine_votes flag is used, retrieve the predictions files saved\n # in the comma separated list of directories and combine them\n if args.votes_files_:\n model_id = re.sub(r'.*(model_[a-f0-9]{24})__predictions\\.csv$',\n r'\\1', args.votes_files_[0]).replace(\"_\", \"/\")\n try:\n model = u.check_resource(model_id, api.get_model)\n except ValueError, exception:\n sys.exit(\"Failed to get model %s: %s\" % (model_id, str(exception)))\n\n local_model = Model(model)\n message = u.dated(\"Combining votes.\\n\")\n u.log_message(message, log_file=session_file,\n console=args.verbosity)\n\n combine_votes(args.votes_files_, local_model.to_prediction,\n output, method=args.method)\n\n # If evaluate flag is on, create remote evaluation and save results in\n # json and human-readable format.\n if args.evaluate:\n # When we resume evaluation and models were already completed, we\n # should use the datasets array as test datasets\n if args.dataset_off and not args.test_dataset_ids:\n args.test_dataset_ids = datasets\n if args.test_dataset_ids:\n eval_ensembles = len(ensemble_ids) == len(args.test_dataset_ids)\n models_or_ensembles = (ensemble_ids if eval_ensembles else\n models)\n # Evaluate the models with the corresponding test datasets.\n resume = evaluate(models_or_ensembles, args.test_dataset_ids, api,\n args, resume,\n fields=fields, dataset_fields=dataset_fields,\n session_file=session_file, path=path,\n log=log, labels=labels, all_labels=all_labels,\n objective_field=args.objective_field)\n else:\n if args.multi_label and args.test_set is not None:\n # When evaluation starts from existing models, the\n # multi_label_fields can be retrieved from the user_metadata\n # in the models\n if args.multi_label_fields is None and multi_label_fields:\n args.multi_label_fields = multi_label_fields\n test_set = ps.multi_label_expansion(\n test_set, test_set_header, args, path,\n labels=labels, session_file=session_file)[0]\n test_set_header = True\n\n if args.test_split > 0:\n dataset = test_dataset\n dataset_fields = pd.get_fields_structure(dataset, None)\n models_or_ensembles = (ensemble_ids if ensemble_ids != []\n else models)\n resume = evaluate(models_or_ensembles, [dataset], api,\n args, resume,\n fields=fields, dataset_fields=dataset_fields,\n session_file=session_file, path=path,\n log=log, labels=labels, all_labels=all_labels,\n objective_field=args.objective_field)\n\n # If cross_validation_rate is > 0, create remote evaluations and save\n # results in json and human-readable format. Then average the results to\n # issue a cross_validation measure set.\n if args.cross_validation_rate > 0:\n args.sample_rate = 1 - args.cross_validation_rate\n cross_validate(models, dataset, fields, api, args, resume,\n session_file=session_file,\n path=path, log=log)\n\n u.print_generated_files(path, log_file=session_file,\n verbosity=args.verbosity)\n if args.reports:\n clear_reports(path)\n if args.upload:\n upload_reports(args.reports, path)","def output_predictions(predictions, output_file=None, output_format=\"plaintext\", info=None):\n\n content = \"\"\n\n if (output_format == \"plaintext\") or (output_format == \"txt\"):\n lines = []\n for k in predictions:\n lines.append(\"- %s: %s\" % (k, predictions[k]))\n content = \"\\n\".join(lines)\n\n elif output_format == \"csv\":\n output = io.StringIO()\n writer = csv.writer(output, quoting=csv.QUOTE_NONNUMERIC)\n writer.writerow([\"label\", \"probability\"])\n for k in predictions:\n writer.writerow([k, float(predictions[k])])\n content = output.getvalue()\n\n elif output_format == \"xml\":\n root = ET.Element(\"predictions\")\n if info is not None:\n for k in info:\n root.set(k, info[k])\n root.set(\"timestamp\", str(datetime.now()))\n for k in predictions:\n p = ET.SubElement(root, \"prediction\")\n p.set(\"label\", k)\n p.text = str(float(predictions[k]))\n content = minidom.parseString(ET.tostring(root)).toprettyxml(indent = \" \")\n\n elif output_format == \"json\":\n data = dict()\n if info is not None:\n info = copy.copy(info)\n else:\n info = dict()\n info[\"timestamp\"] = str(datetime.now())\n data[\"info\"] = info\n data[\"predictions\"] = dict()\n for k in predictions:\n data[\"predictions\"][k] = float(predictions[k])\n content = json.dumps(data)\n\n else:\n raise Exception(\"Unhandled format: %s\" % output_format)\n\n if output_file is None:\n print(content)\n else:\n with open(output_file, \"w\") as of:\n of.write(content)","def inference_line(config):\n def get_entity(doc, begin, end):\n for ent in doc.ents:\n # check included\n if ent.start_char <= begin and end <= ent.end_char:\n if ent.start_char == begin: return 'B-' + ent.label_\n else: return 'I-' + ent.label_\n return 'O'\n \n def build_bucket(nlp, line):\n bucket = []\n doc = nlp(line)\n for token in doc:\n begin = token.idx\n end = begin + len(token.text) - 1\n temp = []\n '''\n print(token.i, token.text, token.lemma_, token.pos_, token.tag_, token.dep_,\n token.shape_, token.is_alpha, token.is_stop, begin, end)\n '''\n temp.append(token.text)\n temp.append(token.tag_)\n temp.append('O') # no chunking info\n entity = get_entity(doc, begin, end)\n temp.append(entity) # entity by spacy\n temp = ' '.join(temp)\n bucket.append(temp)\n return bucket\n\n import spacy\n nlp = spacy.load('en')\n\n # create model and compile\n model = Model(config)\n model.compile()\n sess = model.sess\n\n # restore model\n saver = tf.train.Saver()\n saver.restore(sess, config.restore)\n tf.logging.info('model restored' +'\\n')\n\n while 1:\n try: line = sys.stdin.readline()\n except KeyboardInterrupt: break\n if not line: break\n line = line.strip()\n if not line: continue\n # create bucket\n try: bucket = build_bucket(nlp, line)\n except Exception as e:\n sys.stderr.write(str(e) +'\\n')\n continue\n inp, feed_dict = feed.build_input_feed_dict(model, bucket)\n if 'bert' in config.emb_class:\n # compute bert embedding at runtime\n bert_embeddings = sess.run([model.bert_embeddings_subgraph], feed_dict=feed_dict)\n # update feed_dict\n feed_dict[model.bert_embeddings] = feed.align_bert_embeddings(config, bert_embeddings, inp.example['bert_wordidx2tokenidx'], -1)\n logits_indices, sentence_lengths = sess.run([model.logits_indices, model.sentence_lengths], feed_dict=feed_dict)\n tags = config.logit_indices_to_tags(logits_indices[0], sentence_lengths[0])\n for i in range(len(bucket)):\n out = bucket[i] + ' ' + tags[i]\n sys.stdout.write(out + '\\n')\n sys.stdout.write('\\n')\n\n sess.close()","def postprocess(self, res, op_item, addon):\n result = res\n\n if \"postprocess\" in op_item:\n for post in [i.strip() for i in op_item[\"postprocess\"].split(\" --> \")]:\n func_name = sub(\"^([^\\(\\)]+)\\(.+$\", \"\\\\1\", post).strip()\n param_str = sub(\"^.+\\(([^\\(\\)]*)\\).*\", \"\\\\1\", post)\n if param_str == \"\":\n params_values = ()\n else:\n params_values = next(\n reader(param_str.splitlines(), skipinitialspace=True)\n )\n\n func = getattr(addon, func_name)\n func_params = (result,) + tuple(params_values)\n result, do_type_fields = func(*func_params)\n if do_type_fields:\n result = self.type_fields(result, op_item)\n\n return result","def postprocess_output(\n self,\n init_net: core.Net,\n predict_net: core.Net,\n workspace: core.workspace,\n output_names: List[str],\n py_model,\n ):\n model_out = py_model(*self.dummy_model_input)\n res = py_model.output_layer.export_to_caffe2(\n workspace, init_net, predict_net, model_out, *output_names\n )\n\n # optionally include the last decoder layer of pytorch model\n final_output_names = [str(output) for output in res] + (\n output_names if self.config.export_logits else []\n )\n\n return res, final_output_names","def _process_convert_output_(self, output_data, **kwargs):\n accept_input, current_state, output = output_data\n return (accept_input, current_state, output)","def make_output_human_readable(\n self, predictions: torch.Tensor\n ) -> Dict[str, torch.Tensor]:\n all_predictions = predictions.cpu().data.numpy()\n if all_predictions.ndim == 3:\n predictions_list = [all_predictions[i] for i in range(all_predictions.shape[0])]\n else:\n predictions_list = [all_predictions]\n all_tags = []\n for predictions in predictions_list:\n outside_index = self.vocab.get_token_index(\"O\", namespace=self.task)\n\n # @AR: Get the thresholded matrix and prepare the prediction sequence\n pred_over_thresh = (predictions >= self.threshold) * predictions\n #print(pred_over_thresh)\n sequence_token_labels = []\n maxxx = numpy.argmax(predictions, axis=-1).tolist()\n\n # @AR: For each label set, check if to apply argmax or sigmoid thresh\n j=0\n for pred in pred_over_thresh:\n num_pred_over_thresh = numpy.count_nonzero(pred)\n if (num_pred_over_thresh == 0) or (num_pred_over_thresh == 1):\n pred_idx_list = [maxxx[j]]\n\n else:\n try:\n outside_position = pred_idx_list.index(outside_index)\n except ValueError:\n outside_position = -1\n # get ranked list\n tuples = [[score, idx] for idx, score in enumerate(pred) if score > self.threshold and idx != outside_position]\n # check for max_heads\n if self.max_heads != 0 and len(tuples) > self.max_heads:\n tuples = tuples[:self.max_heads]\n if len(tuples) == 0:\n tuples = [1.0, outside_position]\n pred_idx_list = [x[1] for x in tuples]\n \n\n sequence_token_labels.append(pred_idx_list)\n j += 1\n\n # @AR: Create the list of tags to append for the output\n tags = []\n for token_labels in sequence_token_labels:\n curr_labels = []\n for token_label in token_labels:\n curr_labels.append(\n self.vocab.get_token_from_index(token_label, namespace=self.task))\n tags.append(curr_labels)\n\n all_tags.append(tags)\n return all_tags","def out(self, inputs):","def _create_output_alternatives(self, predictions):\n return {self.head_name: (self._problem_type, predictions)}","def convert_to_lf(input: str, output_1: str, output_2: str = None):\n\n commands = {'predicates': ['jump', 'run', 'look', 'turn', 'walk'],\n 'directions': ['right', 'left'],\n 'manners': ['around', 'opposite'],\n 'connectives': ['and', 'after'],\n 'repetitions': ['twice', 'thrice']}\n\n examples_parsed = []\n\n all_possible_tokens = []\n for tokens in commands.values():\n all_possible_tokens += tokens\n with open(input, 'r') as f:\n for row in f:\n connective = None\n question = row.split('OUT:')[0].replace('IN:', '').strip()\n denotation = row.split('OUT:')[1].strip()\n parts = [question]\n for token in parts[0].split(' '):\n assert token in all_possible_tokens\n for connective_candidate in commands['connectives']:\n parts = parts[0].split(connective_candidate)\n if len(parts) > 1:\n connective = connective_candidate\n break\n inner_programs = []\n for i, part in enumerate(parts):\n inner_programs.append(get_inner_program(part.split(' '), commands))\n if not connective:\n assert len(inner_programs) == 1\n program = inner_programs[0]\n else:\n assert len(inner_programs) == 2\n program = '{} ( {} , {} )'.format(PREFIX+connective+SUFFIX, inner_programs[0],\n inner_programs[1])\n program = program.replace(' ', ' ')\n examples_parsed.append({'question': question, 'program': program, 'answer': denotation})\n if output_2 is not None: # take 20% for dev\n random.shuffle(examples_parsed)\n train_size = math.ceil(0.8 * len(examples_parsed))\n with open(output_1, 'w') as f_1:\n with open(output_2, 'w') as f_2:\n for i, ex in enumerate(examples_parsed):\n if i < train_size:\n json.dump(ex, f_1)\n f_1.write('\\n')\n else:\n json.dump(ex, f_2)\n f_2.write('\\n')\n else:\n with open(output_1, 'w') as f_1:\n for i, ex in enumerate(examples_parsed):\n json.dump(ex, f_1)\n f_1.write('\\n')","def run_inference_on_image(image):\n if not tf.gfile.Exists(image):\n tf.logging.fatal('File does not exist %s', image)\n image_data = tf.gfile.FastGFile(image, 'rb').read()\n\n # Creates graph from saved GraphDef.\n #create_graph()\n\n with tf.Session() as sess:\n # Some useful tensors:\n # 'softmax:0': A tensor containing the normalized prediction across\n # 1000 labels.\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\n # float description of the image.\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\n # encoding of the image.\n # Runs the softmax tensor by feeding the image_data as input to the graph.\n global RESULTS_ANALYSIS\n softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')\n\t\n predictions = sess.run(softmax_tensor,\n {'DecodeJpeg/contents:0': image_data})\n predictions = np.squeeze(predictions)\n\n # Creates node ID --> English string lookup.\n node_lookup = NodeLookup()\n #top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\n top_k = predictions.argsort()[-3:][::-1]\n RESULTS_ANALYSIS=''\n for node_id in top_k:\n human_string = node_lookup.id_to_string(node_id)\n score = predictions[node_id]\n print('%s (score = %.5f)' % (human_string, score))\n RESULTS_ANALYSIS=RESULTS_ANALYSIS+'%s (score = %.5f)' % (human_string, score)+';'","def infer(self, example, model):\n asp_input = model + '\\n\\n' + example + '\\n\\n' + inference_program_ec\n ctl = clingo.Control()\n ctl.add(\"base\", [], asp_input)\n ctl.ground([(\"base\", [])], context=self)\n ctl.solve(on_model=self.show_model)","def transform():","def convert_mnist_experiment_result(experiment_result) -> str:\n import json\n r = json.loads(experiment_result)\n args = []\n for hp in r:\n print(hp)\n args.append(\"%s=%s\" % (hp[\"name\"], hp[\"value\"]))\n\n return \" \".join(args)","def predict(self, data):\n\t\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\n\t\tprint(res)","def get_pred_res_list_item_smith_de(result):\n pred_item_dict = {}\n pred_item_dict[\"predicted_score\"] = str(result[\"predicted_score\"])\n pred_item_dict[\"predicted_class\"] = str(result[\"predicted_class\"])\n pred_item_dict[\"documents_match_labels\"] = str(\n result[\"documents_match_labels\"][0])\n pred_item_dict[\"seq_embed_1\"] = \",\".join(\n [str(e) for e in result[\"seq_embed_1\"]])\n pred_item_dict[\"seq_embed_2\"] = \",\".join(\n [str(e) for e in result[\"seq_embed_2\"]])\n pred_item_dict[\"input_sent_embed_1\"] = transfer_2d_array_to_str(\n result[\"input_sent_embed_1\"])\n pred_item_dict[\"input_sent_embed_2\"] = transfer_2d_array_to_str(\n result[\"input_sent_embed_2\"])\n pred_item_dict[\"output_sent_embed_1\"] = transfer_2d_array_to_str(\n result[\"output_sent_embed_1\"])\n pred_item_dict[\"output_sent_embed_2\"] = transfer_2d_array_to_str(\n result[\"output_sent_embed_2\"])\n return pred_item_dict","def _format_output(predictions, descriptors):\n # type: (list,dict) -> list\n\n output = []\n for item in predictions:\n output.append(' - '.join([descriptors.get(item[1]), str(item[0]).format('0.00f')]))\n\n return output","def inference_graph(self, input_data):\n return self.inference_ops.tree_predictions(\n input_data, self.variables.tree, self.variables.tree_thresholds,\n self.variables.node_sums,\n valid_leaf_threshold=self.params.valid_leaf_threshold)","def query(self,text_input,prefix='answer:',convert_to_string=True):\n predictions, raw_outputs = self.model.predict([text_input])\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\n return self._post_process_output(preds,convert_to_string=convert_to_string)","def transform_fn(net, data, input_content_type, output_content_type):\n # we can use content types to vary input/output handling, but\n # here we just assume json for both\n ctx = mx.cpu() \n batch_size=64\n output=[]\n print (\"Start Parsing input\")\n parsed = json.loads(data)\n print (\"End Parsing input\")\n images=[]\n multisp=False\n \n #Check for Multispectral input type\n if 'type' in parsed.keys():\n if parsed['type'].lower() == 'rgb':\n multisp=False\n job_data=parsed['instances']\n else:\n multisp=True\n encodedBytes=parsed['instances'].encode(\"utf-8\")\n zip_value=base64.b64decode(encodedBytes)\n dump_value=gzip.decompress(zip_value)\n job_data=pickle.loads(dump_value)\n \n print (\"Multispacial\",multisp)\n \n for item in job_data:\n image_data=np.array(item['data'])\n print (\"Input Image Shape:\", image_data.shape)\n images.append ({'data':image_data})\n \n print (\"MultiSP:\", multisp)\n loader=BatchLoader(images,64,ctx,multisp)\n \n for idxb, batch in enumerate(loader.get_batches()):\n preds = nd.argmax(net(batch), axis=1)\n for pred in preds:\n output.append({'data':pred.asnumpy().astype('uint8').tolist() })\n\n response_body = json.dumps({'predictions':output})\n return response_body, output_content_type","def log_inference(tester, name, description):\r\n\tfor dataset, output in tester.preds.items():\r\n\t\tresults = pandas.DataFrame.from_dict(output)\r\n\t\tpath = os.path.join(\r\n\t\t\tEXPERIMENT_PATH, tester.config[\"name\"] + '-' + dataset)\r\n\t\twith open(path + \".csv\", \"w\") as f:\r\n\t\t\tresults.to_csv(f, sep=\"\\t\", encoding='utf-8', \r\n\t\t\t\tfloat_format='%.3f', index=False)\r\n\r\n\t\twith open(path + \"-predictions.csv\", \"w\") as f:\r\n\t\t\tresults[[\"tag\", \"y_hat\"]].to_csv(\r\n\t\t\t\tf, index=False, float_format='%.3f', header=False)","def format_predictions(outputs, annotations):\n data = []\n prediction = outputs[\"instances\"].to(\"cpu\")\n\n predicted_boxes = prediction.pred_boxes.tensor.numpy().tolist()\n predicted_scores = prediction.scores.numpy().tolist()\n predicted_classes = prediction.pred_classes.numpy().tolist()\n\n for annotation in annotations:\n bbox = annotation[\"bbox\"]\n\n # Convert from numpy.int64 to int\n x, y, x2, y2 = map(lambda x: x.item(), bbox)\n\n label = annotation[\"category_id\"]\n data.append(\n {\n \"label\": f\"ground_truth-{label}\",\n \"score\": 100,\n \"box\": {\"x\": x, \"y\": y, \"x2\": x2, \"y2\": y2},\n }\n )\n\n for predicted_box, predicted_score, predicted_class in zip(\n predicted_boxes, predicted_scores, predicted_classes\n ):\n x, y, x2, y2 = predicted_box\n data.append(\n {\n \"label\": predicted_class,\n \"box\": {\"x\": x, \"y\": y, \"x2\": x2, \"y2\": y2},\n \"score\": predicted_score * 100,\n }\n )\n\n return data","def infer(self, request, datastore=None):\n model = request.get(\"model\")\n if not model:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n \"Model is not provided for Inference Task\",\n )\n\n task = self._infers.get(model)\n if not task:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n f\"Inference Task is not Initialized. There is no model '{model}' available\",\n )\n\n request = copy.deepcopy(request)\n request[\"description\"] = task.description\n\n image_id = request[\"image\"]\n if isinstance(image_id, str):\n datastore = datastore if datastore else self.datastore()\n if os.path.exists(image_id):\n request[\"save_label\"] = False\n else:\n request[\"image\"] = datastore.get_image_uri(request[\"image\"])\n\n if os.path.isdir(request[\"image\"]):\n logger.info(\"Input is a Directory; Consider it as DICOM\")\n\n logger.debug(f\"Image => {request['image']}\")\n else:\n request[\"save_label\"] = False\n\n if self._infers_threadpool:\n\n def run_infer_in_thread(t, r):\n handle_torch_linalg_multithread(r)\n return t(r)\n\n f = self._infers_threadpool.submit(run_infer_in_thread, t=task, r=request)\n result_file_name, result_json = f.result(request.get(\"timeout\", settings.MONAI_LABEL_INFER_TIMEOUT))\n else:\n result_file_name, result_json = task(request)\n\n label_id = None\n if result_file_name and os.path.exists(result_file_name):\n tag = request.get(\"label_tag\", DefaultLabelTag.ORIGINAL)\n save_label = request.get(\"save_label\", False)\n if save_label:\n label_id = datastore.save_label(\n image_id, result_file_name, tag, {\"model\": model, \"params\": result_json}\n )\n else:\n label_id = result_file_name\n\n return {\"label\": label_id, \"tag\": DefaultLabelTag.ORIGINAL, \"file\": result_file_name, \"params\": result_json}","def post(self):\n result = {'status': 'error'}\n\n args = input_parser.parse_args()\n input_data = args['image'].read()\n image = self.model_wrapper._read_image(input_data)\n preds = self.model_wrapper._predict(image)\n\n # Modify this code if the schema is changed\n label_preds = [{'label_id': p[0], 'label': p[1], 'probability': p[2]} for p in [x for x in preds]]\n result['predictions'] = label_preds\n result['status'] = 'ok'\n\n return result","def make_pred_output(self, sample):\n output_sample = copy.deepcopy(sample)\n # output_sample.pop('profile', None)\n for msg in output_sample['messages-so-far']:\n # msg.pop('tokenized_utterance', None)\n if not isinstance(msg['tokenized_utterance'], basestring):\n msg['tokenized_utterance'] = ' '.join(msg['tokenized_utterance'])\n msg.pop('utterance_token_ids', None)\n\n for correct_answer in output_sample['options-for-correct-answers']:\n # correct_answer.pop('tokenized_utterance', None)\n if not isinstance(correct_answer['tokenized_utterance'], basestring):\n correct_answer['tokenized_utterance'] = ' '.join(correct_answer['tokenized_utterance'])\n correct_answer.pop('utterance_token_ids', None)\n\n if 'SEQTAG' in self.decode_goal:\n pass\n else:\n output_sample['pred_probs'] = sorted(output_sample['pred_probs'], key=lambda o: o['prob'], reverse=True)\n return output_sample","def postprocess_relation_predictions(predictions):\n \n output = {}\n word_pairs = [wp.split(\" -> \") for wp in predictions.keys()]\n for wp in word_pairs:\n fp = \" -> \".join([wp[0], wp[1]])\n bp = \" -> \".join([wp[1], wp[0]])\n \n if predictions[fp][\"relations\"][0] == predictions[bp][\"relations\"][0]:\n if predictions[fp][\"confidence\"][0] > predictions[bp][\"confidence\"][0]:\n output[fp] = predictions[fp]\n else:\n output[bp] = predictions[bp]\n else:\n output[fp] = predictions[fp]\n output[bp] = predictions[bp]\n return output","def preprocess_output(self, inference_results, image, show_bbox=False, **kwargs):\n flattened_predictions = np.vstack(inference_results).ravel()\n results = {}\n face_h, face_w = image.shape[:2]\n\n if len(flattened_predictions) == 70:\n landmarks = []\n for i in range(flattened_predictions.size // 2):\n x_coord = int(face_w * flattened_predictions[2 * i])\n y_coord = int(face_h * flattened_predictions[2 * i + 1])\n landmarks.append((x_coord, y_coord))\n\n face_landmarks = {\n \"type\": self._model_type,\n \"eyes_coords\": landmarks[:4],\n \"nose_coords\": landmarks[4:8],\n \"mouth_coords\": landmarks[8:12],\n \"face_contour\": landmarks[12:],\n }\n else:\n coord_mapping = dict(\n zip(\n (\n \"left_eye_x_coord\",\n \"left_eye_y_coord\",\n \"right_eye_x_coord\",\n \"right_eye_y_coord\",\n \"nose_coord\",\n \"left_mouth_coord\",\n \"right_mouth_coord\",\n ),\n flattened_predictions,\n )\n )\n\n def get_eye_points(eye_coords, eye_size=10):\n\n eye_min = eye_coords - eye_size\n eye_max = eye_coords + eye_size\n return map(int, [eye_coords, eye_min, eye_max])\n\n # left eye offset of face\n left_eye_x_coord, left_eye_xmin, left_eye_xmax = get_eye_points(\n coord_mapping[\"left_eye_x_coord\"] * face_w\n )\n\n # left eye offset of face\n left_eye_y_coord, left_eye_ymin, left_eye_ymax = get_eye_points(\n coord_mapping[\"left_eye_y_coord\"] * face_h\n )\n\n # right eye offset of face\n right_eye_x_coord, right_eye_xmin, right_eye_xmax = get_eye_points(\n coord_mapping[\"right_eye_x_coord\"] * face_w\n )\n\n # right eye offset of face\n right_eye_y_coord, right_eye_ymin, right_eye_ymax = get_eye_points(\n coord_mapping[\"right_eye_y_coord\"] * face_h\n )\n eye_size = 10\n\n left_eye_x_coord = int(flattened_predictions[0] * face_w)\n # left eye offset of face\n left_eye_xmin = left_eye_x_coord - eye_size\n left_eye_xmax = left_eye_x_coord + eye_size\n\n left_eye_y_coord = int(flattened_predictions[1] * face_h)\n # left eye offset of face\n left_eye_ymin = left_eye_y_coord - eye_size\n left_eye_ymax = left_eye_y_coord + eye_size\n\n right_eye_x_coord = int(flattened_predictions[2] * face_w)\n # right eye offset of face\n right_eye_xmin = right_eye_x_coord - eye_size\n right_eye_xmax = right_eye_x_coord + eye_size\n\n right_eye_y_coord = int(flattened_predictions[3] * face_h)\n # right eye offset of face\n right_eye_ymin = right_eye_y_coord - eye_size\n right_eye_ymax = right_eye_y_coord + eye_size\n # nose coordinates\n nose_coord = coord_mapping[\"nose_coord\"]\n\n # mouth coordinates\n left_part_mouth = coord_mapping[\"left_mouth_coord\"] * face_w\n right_part_mouth = coord_mapping[\"right_mouth_coord\"] * face_w\n\n face_landmarks = {\n \"type\": self._model_type,\n \"eyes_coords\": {\n \"left_eye_point\": (left_eye_x_coord, left_eye_y_coord),\n \"right_eye_point\": (right_eye_x_coord, right_eye_y_coord),\n \"left_eye_image\": image[\n left_eye_ymin:left_eye_ymax, left_eye_xmin:left_eye_xmax\n ],\n \"right_eye_image\": image[\n right_eye_ymin:right_eye_ymax, right_eye_xmin:right_eye_xmax,\n ],\n },\n \"nose_coords\": {\"nose_coords\": nose_coord},\n \"mouth_coords\": {\"mouth_coords\": [left_part_mouth, right_part_mouth]},\n }\n\n results[\"face_landmarks\"] = face_landmarks\n results[\"image\"] = image\n if show_bbox:\n self.draw_output(results, image, **kwargs)\n return results","def inference(self, img, img_meta, rescale):\n if not isinstance(img_meta, list):\n img_meta = img_meta.data[0]\n assert self.test_cfg.mode in ['slide', 'whole']\n # if isinstance(img_meta, list):\n # ori_shape = img_meta[0][0]['ori_shape']\n # else:\n # ori_shape = img_meta[0][0]['ori_shape']\n # assert all(_[0]['ori_shape'] == ori_shape for _ in img_meta.data)\n if self.test_cfg.mode == 'slide':\n seg_logit = self.slide_inference(img, img_meta, rescale)\n else:\n seg_logit, gen_out = self.whole_inference(img, img_meta, rescale)\n output = F.softmax(seg_logit, dim=1)\n flip = img_meta[0]['flip']\n if flip:\n flip_direction = img_meta[0]['flip_direction']\n assert flip_direction in ['horizontal', 'vertical']\n if flip_direction == 'horizontal':\n output = output.flip(dims=(3,))\n gen_out = gen_out.flip(dims=(3,))\n elif flip_direction == 'vertical':\n output = output.flip(dims=(2,))\n gen_out = gen_out.flip(dims=(2,))\n\n return output, gen_out","def run_inference_on_image(image):\n if not gfile.Exists(image):\n tf.logging.fatal('File does not exist %s', image)\n image_data = gfile.FastGFile(image, 'rb').read()\n\n # Creates graph from saved GraphDef.\n create_graph()\n\n with tf.Session() as sess:\n # Runs the softmax tensor by feeding the image_data as input to the graph.\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n \n print(\"Running inference on image: %s\" % os.path.basename(FLAGS.image_file))\n predictions = sess.run(softmax_tensor,\n {'DecodeJpeg/contents:0': image_data})\n predictions = np.squeeze(predictions)\n\n # Get indicies of top x predictions\n top_x = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\n # Get list of human readable class labels\n class_labels = get_label_list()\n \n #print results\n for top_i in top_x: \n print(class_labels[top_i] + ': %.2f%%' % (predictions[top_i] * 100))\n print('\\n')","def inference():\n inf_dataset = dataset\n net.eval()\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\n \n num_crop = args.test_crops\n length = 3\n if args.modality == 'Flow':\n length = 10\n elif args.modality == 'RGBDiff':\n length = 18\n \n # First get the base_out outputs\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\n volatile=True)\n cnt = 0\n for frames in frames_gen:\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\n # frame_batch_size is 4 by default\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\n volatile=True)\n base_out = net(input_var, None, None, None, None)\n bsc = base_out.view(num_crop, -1, base_out_dim)\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\n cnt += bsc.size(1)\n\n n_frames = base_output.size(1)\n assert frame_cnt == n_frames\n # GLCU\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\n gate, glcu_task_pred = net.glcu(step_features)\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\n if net.additive_glcu:\n base_output = base_output + gate\n else:\n base_output = base_output * gate\n\n # output.shape == [num_frames, 7791]\n output = torch.zeros((frame_cnt, output_dim)).cuda()\n cnt = 0\n for i in range(0, frame_cnt, 4):\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\n rst = net.test_fc(base_out)\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\n output[cnt: cnt + sc.size(0), :] = sc\n cnt += sc.size(0)\n base_output = base_output.mean(dim=0).data\n\n # act_scores.shape == [num_proposals, K+1]\n # comp_scores.shape == [num_proposals, K]\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\n\n # Task Head\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\n\n act_scores = act_scores.data\n comp_scores = comp_scores.data\n\n if reg_scores is not None:\n reg_scores = reg_scores.view(-1, num_class, 2)\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\n\n torch.cuda.empty_cache() # To empty the cache from previous iterations\n\n # perform stpp on scores\n return ((inf_dataset.video_list[index].id,\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \n glcu_task_pred, task_pred),\n output.cpu().numpy(),\n base_output.cpu().numpy()))","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected","def inference(self):\r\n\t\tfor partition, loader in self.loaders.items():\r\n\t\t\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\r\n\t\t\t\tloader)\r\n\t\t\tself.preds[partition] = {\r\n\t\t\t\t'tag': tags,\r\n\t\t\t\t'y': y,\r\n\t\t\t\t'y_hat': y_hat,\r\n\t\t\t\t# 'posteriors': post,\r\n\t\t\t\t# 'attentions': attentions\r\n\t\t\t}","def dump_data(opt):\n # create repeat label agent and assign it to the specified task\n agent = RepeatLabelAgent(opt)\n world = create_task(opt, agent)\n task = opt.get('task')\n speaker_0_id = opt.get('speaker_0_id') or f'{task}_as_human'\n speaker_1_id = opt.get('speaker_1_id') or f'{task}_as_model'\n if opt['outfile'] is None:\n outfile = tempfile.mkstemp(\n prefix='{}_{}_'.format(opt['task'], opt['datatype']), suffix='.txt'\n )[1]\n else:\n outfile = opt['outfile']\n\n num_episodes = (\n world.num_episodes()\n if opt['num_episodes'] == -1\n else min(opt['num_episodes'], world.num_episodes())\n )\n log_timer = TimeLogger()\n\n print(f'[ starting to convert, saving output to {outfile} ]')\n dialogues = []\n for _ in range(num_episodes):\n episode = []\n episode_done = False\n while not episode_done:\n world.parley()\n acts = world.get_acts()\n text = acts[0].get('text')\n split_text = text.split('\\n')\n label = random.choice(\n acts[0].get('labels', acts[0].pop('eval_labels', None))\n )\n if not episode and opt.get('prepended_context'):\n # first turn\n context = split_text[:-1]\n text = split_text[-1]\n context_turn = [\n {'text': context, 'episode_done': False, 'id': 'context'}\n for _ in range(2)\n ]\n episode.append(context_turn)\n turn = [\n {'text': text, 'episode_done': False, 'id': speaker_0_id},\n {'text': label, 'episode_done': False, 'id': speaker_1_id},\n ]\n episode.append(turn)\n if acts[0].get('episode_done', False):\n episode[-1][-1]['episode_done'] = True\n episode_done = True\n dialogues.append(episode)\n\n if log_timer.time() > opt['log_every_n_secs']:\n text, _log = log_timer.log(world.total_parleys, world.num_examples())\n print(text)\n\n if world.epoch_done():\n break\n\n Conversations.save_conversations(dialogues, outfile, opt)","def inference(config_file, image_file):\n # Get config\n FLAGS = Flags(config_file).get()\n out_charset = load_charset(FLAGS.charset)\n num_classes = len(out_charset)\n net = get_network(FLAGS, out_charset)\n\n if FLAGS.use_rgb:\n num_channel = 3\n mode = cv2.IMREAD_COLOR\n else:\n num_channel = 1\n mode = cv2.IMREAD_GRAYSCALE\n\n # Input node\n image = tf.placeholder(tf.uint8,\n shape=[None, None, num_channel],\n name='input_node')\n\n # Network\n proc_image = net.preprocess_image(image, is_train=False)\n proc_image = tf.expand_dims(proc_image, axis=0)\n proc_image.set_shape(\n [None, FLAGS.resize_hw.height, FLAGS.resize_hw.width, num_channel])\n logits, sequence_length = net.get_logits(proc_image,\n is_train=False,\n label=None)\n prediction, log_prob = net.get_prediction(logits, sequence_length)\n prediction = tf.sparse_to_dense(sparse_indices=prediction.indices,\n sparse_values=prediction.values,\n output_shape=prediction.dense_shape,\n default_value=num_classes,\n name='output_node')\n\n # Restore\n restore_model = get_init_trained()\n sess = tf.Session()\n restore_model(sess, FLAGS.eval.model_path)\n\n # Run\n img = cv2.imread(image_file, mode)\n img = np.reshape(img, [img.shape[0], img.shape[1], num_channel])\n predicted = sess.run(prediction, feed_dict={image: img})\n string = get_string(predicted[0], out_charset)\n string = adjust_string(string, FLAGS.eval.lowercase,\n FLAGS.eval.alphanumeric)\n print(string)\n\n return string","def postprocess(self, data):\n all_predictions, all_nbest_json, scores_diff_json = predictions(self._dev_dataset,\n data,\n self._tokenizer)\n\n if len(all_nbest_json) == 0 or len(all_nbest_json[0]) == 0:\n return [{'predicted': '',\n 'confidence': 0}]\n\n return [{'predicted': all_nbest_json[0][0]['text'],\n 'confidence': all_nbest_json[0][0]['probability']}]","def postprocess_wikidiff(\n output,\n vocabulary,\n normalize_fn,\n is_target=False,\n example=None,\n):\n del is_target\n inputs = tf_utils.maybe_decode(\n vocabulary.decode_tf(example[\"inputs\"]).numpy())\n targets = tf_utils.maybe_decode(output)\n normalized_inputs, normalized_targets = normalize_fn(inputs, targets)\n results = {\n \"inputs\":\n inputs,\n \"targets\":\n targets,\n \"normalized_inputs\":\n normalized_inputs,\n \"normalized_targets\":\n normalized_targets,\n \"generatable_surfaces\":\n json.loads(tf_utils.maybe_decode(example[\"generatable_surfaces\"])),\n }\n return results","def _get_inference_output_name(self):\n inference_output_name = 'output'\n if len(self['inference_output'].get_shape().as_list()) > 0:\n inference_output_name = 'inference_output'\n\n return inference_output_name","def downgrade_output(output):\n if output[\"output_type\"] in {\"execute_result\", \"display_data\"}:\n if output[\"output_type\"] == \"execute_result\":\n output[\"output_type\"] = \"pyout\"\n output[\"prompt_number\"] = output.pop(\"execution_count\", None)\n\n # promote data dict to top-level output namespace\n data = output.pop(\"data\", {})\n if \"application/json\" in data:\n data[\"application/json\"] = json.dumps(data[\"application/json\"])\n data = from_mime_key(data)\n output.update(data)\n from_mime_key(output.get(\"metadata\", {}))\n elif output[\"output_type\"] == \"error\":\n output[\"output_type\"] = \"pyerr\"\n elif output[\"output_type\"] == \"stream\":\n output[\"stream\"] = output.pop(\"name\")\n return output","def _massage_raw_pg_output_vals(self):\n pass","def inference(self, image_path_pattern: Text, output_dir: Text, **kwargs):\n params = copy.deepcopy(self.params)\n with tf.Session() as sess:\n # Buid inputs and preprocessing.\n raw_images, images, scales = build_inputs(image_path_pattern,\n params['image_size'],\n params['mean_rgb'],\n params['stddev_rgb'])\n if params['data_format'] == 'channels_first':\n images = tf.transpose(images, [0, 3, 1, 2])\n # Build model.\n class_outputs, box_outputs = build_model(self.model_name, images,\n **self.params)\n restore_ckpt(\n sess,\n self.ckpt_path,\n ema_decay=self.params['moving_average_decay'],\n export_ckpt=None)\n # Build postprocessing.\n detections_batch = det_post_process(params, class_outputs, box_outputs,\n scales)\n predictions = sess.run(detections_batch)\n # Visualize results.\n for i, prediction in enumerate(predictions):\n img = visualize_image_prediction(\n raw_images[i],\n prediction,\n label_map=self.label_map,\n **kwargs)\n output_image_path = os.path.join(output_dir, str(i) + '.jpg')\n Image.fromarray(img).save(output_image_path)\n print('writing file to %s' % output_image_path)\n\n return predictions","def getResult(f, opt, model_name):\n tacc = []\n vacc = []\n opt.write('======= ' + model_name + ' =======\\n')\n for l in f.readlines():\n if l.startswith('#'):\n opt.write(l[2:] + '\\n')\n elif l.startswith('Epoch'):\n continue\n else:\n data = l.split(' - ')\n tacc.append(float(data[2].split(': ')[1]))\n vacc.append(float(data[4].split(': ')[1]))\n return np.array(tacc), np.array(vacc)","def test_inference():\n\n input_path = os.path.join(MAIN_PATH, \"data/test_cases/\")\n output_path = os.path.join(MAIN_PATH, \"data/test_results/\")\n\n nifti_files = len(os.listdir(input_path))\n\n # remove existing files in the output path\n for file in os.listdir(output_path):\n filepath = output_path + file\n if \"test_results\" in filepath:\n os.remove(filepath)\n\n # run\n bpreg_inference(input_path, output_path, plot=True)\n\n # Test creation of json files\n json_output_files = [f for f in os.listdir(output_path) if f.endswith(\".json\")]\n assert len(json_output_files) == nifti_files\n\n # Test tags\n with open(output_path + json_output_files[0]) as f:\n x = json.load(f)\n\n assert \"settings\" in x.keys()\n assert \"cleaned slice scores\" in x.keys()\n assert \"unprocessed slice scores\" in x.keys()\n assert \"body part examined\" in x.keys()\n assert \"body part examined tag\" in x.keys()\n\n # Check if readme file is saved.\n assert \"README.md\" in os.listdir(output_path)","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def postprocess_model_outputs(self, predictions, expected):\n\n for key, val in predictions.items():\n predictions[key] = val.numpy()\n\n for key, val in expected.items():\n expected[key] = val.numpy()\n\n return predictions, expected","def convert_outputs(self):\n self.out('relaxed_structure', self.ctx.workchain.outputs.output_structure)\n self.out('total_energy', get_total_energy(self.ctx.workchain.outputs.output_parameters))\n self.out('forces', get_forces_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\n self.out('stress', get_stress_from_trajectory(self.ctx.workchain.outputs.output_trajectory))","def postprocessor_two_column(answer, example=None, is_target=False):\n return tf.compat.as_text(answer)","def inference_graph(self, input_data):\n probabilities = []\n for i in range(self.params.num_trees):\n with tf.device(self.device_assigner.get_device(i)):\n tree_data = input_data\n if self.params.bagged_features:\n tree_data = self._bag_features(i, input_data)\n probabilities.append(self.trees[i].inference_graph(tree_data))\n with tf.device(self.device_assigner.get_device(0)):\n all_predict = tf.pack(probabilities)\n return tf.reduce_sum(all_predict, 0) / self.params.num_trees"],"string":"[\n \"def postprocess(self, inference_output):\\n logger.info(inference_output)\\n return inference_output\",\n \"def inference():\\n if request.method == \\\"POST\\\":\\n data = request.json #\\n src_img = np.array(data[\\\"src\\\"]).astype(np.uint8) # Parsing data\\n ref_img = np.array(data[\\\"ref\\\"]).astype(np.uint8) #\\n ref_label = int(data[\\\"ref_label\\\"]) #\\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\\n return jsonify({\\\"result\\\": result.tolist()}) # Returning results into json\",\n \"def inference_preprocess(self):\\n return\",\n \"def postprocess(self,graph_output):\\n (w,h,f) = self.rawinputformat()\\n #print(w,h)\\n #print(graph_output.shape)\\n results = self.interpret_output(graph_output.astype(numpy.float32), w, h)\\n print(results)\\n #order = graph_output.argsort()\\n #last = len(self.categories)-1\\n #res = NcsResult();\\n #print(len(results))\\n #for i in range(0,len(results)):\\n # res = results[i]\\n #res.add( self.categories[order[last-i]], ( graph_output[order[last-i]] ) )\\n return res\\n\\n # YOLO stuff\",\n \"def inference(self):\\n raise NotImplementedError\",\n \"def postprocess(self, inference_output):\\n ret = []\\n quantiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\\n # for each request\\n for inference_output_request in inference_output:\\n ret_request = []\\n # for each time series\\n for i in inference_output_request:\\n l = {}\\n l[\\\"item_id\\\"] = i.item_id\\n l[\\\"quantiles\\\"] = {}\\n for q in quantiles:\\n l[\\\"quantiles\\\"][str(q)] = i.quantile(q).tolist()\\n l[\\\"mean\\\"] = i.mean.tolist()\\n ret_request.append(json.dumps(l))\\n ret.append('\\\\n'.join(ret_request) + '\\\\n')\\n return ret\",\n \"def _post_process_output(self,predictions,convert_to_string):\\n if convert_to_string:\\n return ' '.join([\\\"%s-%s\\\" % (p[0],p[1]) for p in predictions])\\n return predictions\",\n \"def _postprocess(self, output: Dict[str, np.ndarray]):\\n # Slice to remove padding, omitting initial [CLS] and final [SEP]\\n slicer = slice(1, output.pop(\\\"ntok\\\") - 1)\\n output[\\\"tokens\\\"] = self.tokenizer.convert_ids_to_tokens(\\n output.pop(\\\"input_ids\\\")[slicer])\\n probas = output.pop(\\\"probas\\\")\\n\\n # Predictions at every position, regardless of masking.\\n output[\\\"pred_tokens\\\"] = self._get_topk_tokens(probas[slicer]) # pytype: disable=container-type-mismatch\\n\\n return output\",\n \"def inference(self, inputs):\\n # NOTE: This makes the assumption that your model expects text to be tokenized\\n # with \\\"input_ids\\\" and \\\"token_type_ids\\\" - which is true for some popular transformer models, e.g. bert.\\n # If your transformer model expects different tokenization, adapt this code to suit\\n # its expected input format.\\n input_ids = inputs[\\\"input_ids\\\"]\\n input_ids = input_ids.to(self.device)\\n\\n coarse_result = self.model.generate(input_ids = input_ids, )\\n coarse_result = coarse_result.to(\\\"cpu\\\")\\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\\\"original_length\\\"]+1:],\\n skip_special_tokens = True)\\n #logger.info(\\\"Model predicted: '%s'\\\", fined_result)\\n\\n return [fined_result]\",\n \"def postprocess(self, data):\\n if self.error is not None:\\n return [self.error]\\n\\n # Iterating over inference results to render the normalized probabilities\\n response = []\\n for inference_result in data:\\n softmax_result = inference_result.softmax().asnumpy()\\n for idx, label in enumerate(self.labels):\\n response.append({label: float(softmax_result[0][idx])})\\n return [response]\",\n \"def print_inference_result(self):\\n if (\\n self.params.model_str == 'optfixedsig'\\n or self.params.model_str == 'opt'\\n or self.params.model_str == 'fixedparam'\\n ):\\n print('*ls pt est = ' + str(self.sample_list[0].ls) + '.')\\n print('*alpha pt est = ' + str(self.sample_list[0].alpha) + '.')\\n print('*sigma pt est = ' + str(self.sample_list[0].sigma) + '.')\\n elif self.params.model_str == 'samp' or self.params.model_str == 'sampfixedsig':\\n ls_arr = np.array([ns.ls for ns in self.sample_list])\\n alpha_arr = np.array([ns.alpha for ns in self.sample_list])\\n sigma_arr = np.array([ns.sigma for ns in self.sample_list])\\n print('*ls mean = ' + str(ls_arr.mean()) + '.')\\n print('*ls std = ' + str(ls_arr.std()) + '.')\\n print('*alpha mean = ' + str(alpha_arr.mean()) + '.')\\n print('*alpha std = ' + str(alpha_arr.std()) + '.')\\n print('*sigma mean = ' + str(sigma_arr.mean()) + '.')\\n print('*sigma std = ' + str(sigma_arr.std()) + '.')\\n print('-----')\",\n \"def do_inference(self, output_file = None):\\n return\",\n \"def handle_result(result):\\n return str(len(result)) + \\\"\\\\n\\\" + \\\"\\\\n\\\".join([\\\"{0} {1} {2}\\\".format(*outfit) for outfit in result])\",\n \"def _inference_step(self, state):\\n\\n decoder_inputs = state[\\\"inputs\\\"]\\n encoder_outputs = state[\\\"encoder_outputs\\\"]\\n attention_bias = state[\\\"encoder_decoder_attention_bias\\\"]\\n alignment_positions = state[\\\"alignment_positions\\\"]\\n\\n outputs = self._decode_pass(\\n decoder_inputs=decoder_inputs,\\n encoder_outputs=encoder_outputs,\\n enc_dec_attention_bias=attention_bias,\\n alignment_positions=alignment_positions\\n )\\n\\n with tf.variable_scope(\\\"inference_step\\\"):\\n next_inputs_mel = outputs[\\\"post_net_spec\\\"][:, -1:, :]\\n next_inputs_mel = self._expand(next_inputs_mel, self.reduction_factor)\\n next_inputs_mag = outputs[\\\"mag_spec\\\"][:, -1:, :]\\n next_inputs_mag = self._expand(next_inputs_mag, self.reduction_factor)\\n next_inputs = tf.concat([next_inputs_mel, next_inputs_mag], axis=-1)\\n\\n n_features = self.num_mels + self.num_freq\\n next_inputs = self._shrink(next_inputs, n_features, self.reduction_factor)\\n\\n # Set zero if sequence is finished\\n next_inputs = tf.where(\\n state[\\\"finished\\\"],\\n tf.zeros_like(next_inputs),\\n next_inputs\\n )\\n next_inputs = tf.concat([decoder_inputs, next_inputs], 1)\\n\\n # Update lengths\\n lengths = state[\\\"outputs\\\"][\\\"lengths\\\"]\\n lengths = tf.where(\\n state[\\\"finished\\\"],\\n lengths,\\n lengths + 1 * self.reduction_factor\\n )\\n outputs[\\\"lengths\\\"] = lengths\\n\\n # Update spec, post_net_spec and mag_spec\\n for key in [\\\"spec\\\", \\\"post_net_spec\\\", \\\"mag_spec\\\"]:\\n output = outputs[key][:, -1:, :]\\n output = tf.where(state[\\\"finished\\\"], tf.zeros_like(output), output)\\n outputs[key] = tf.concat([state[\\\"outputs\\\"][key], output], 1)\\n\\n # Update stop token logits\\n stop_token_logits = outputs[\\\"stop_token_logits\\\"][:, -1:, :]\\n stop_token_logits = tf.where(\\n state[\\\"finished\\\"],\\n tf.zeros_like(stop_token_logits) + 1e9,\\n stop_token_logits\\n )\\n stop_prediction = tf.sigmoid(stop_token_logits)\\n stop_prediction = tf.reduce_max(stop_prediction, axis=-1)\\n\\n # Uncomment next line if you want to use stop token predictions\\n finished = tf.reshape(tf.cast(tf.round(stop_prediction), tf.bool), [-1])\\n finished = tf.reshape(finished, [-1])\\n\\n stop_token_logits = tf.concat(\\n [state[\\\"outputs\\\"][\\\"stop_token_logits\\\"], stop_token_logits],\\n axis=1\\n )\\n outputs[\\\"stop_token_logits\\\"] = stop_token_logits\\n\\n with tf.variable_scope(\\\"alignments\\\"):\\n weights = []\\n for index, attention in enumerate(self.attentions):\\n if isinstance(attention, AttentionBlock):\\n weights.append(attention.multiheaded_attention.attention_weights)\\n\\n weights = tf.stack(weights)\\n outputs[\\\"alignments\\\"] = [weights]\\n\\n alignment_positions = tf.argmax(\\n weights,\\n axis=-1,\\n output_type=tf.int32\\n )[:, :, :, -1:]\\n state[\\\"alignment_positions\\\"] = tf.concat(\\n [state[\\\"alignment_positions\\\"], alignment_positions],\\n axis=-1\\n )\\n\\n state[\\\"iteration\\\"] = state[\\\"iteration\\\"] + 1\\n state[\\\"inputs\\\"] = next_inputs\\n state[\\\"finished\\\"] = finished\\n state[\\\"outputs\\\"] = outputs\\n\\n return state\",\n \"def inference(model, data, diagnostics, seed, extra_fitting_args):\\n pass\",\n \"def postprocessor(answer, example=None, is_target=False):\\n if example:\\n return tf.compat.as_text(answer) + \\\"\\\\t\\\" + tf.compat.as_text(example[\\\"id\\\"])\\n else:\\n return answer\",\n \"def infer(self, sequence: str) -> str: \\n \\n logging.info(\\\"Classifier.infer: infering for \\\\\\\"\\\" + sequence + \\\"\\\\\\\"...\\\") \\n result = self.pipeline(sequence)\\n logging.info(\\\"Classifier.infer: entities=\\\\\\\"\\\" + json.dumps(result, cls=NpEncoder) + \\\"\\\\\\\"\\\")\\n\\n return {'entities': json.dumps(result, cls=NpEncoder)}\",\n \"def decode_results(self, outputs):\\n ...\",\n \"def inference(self):\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].send(\\\"inference\\\")\\n \\n ## wait for the finalization to be completed\\n for i in range(len(self.nodes)):\\n for j in range(len(self.nodes[i])):\\n self.pipes[i][j].recv()\",\n \"def interpret_output(self, batch_output):\\n raise NotImplementedError\",\n \"def inference_end(self, inputs, results):\\n return\",\n \"def _do_infer(stream_manager_api, data_input):\\n stream_name = b'segmentation'\\n unique_id = stream_manager_api.SendData(\\n stream_name, 0, data_input)\\n if unique_id < 0:\\n raise RuntimeError(\\\"Failed to send data to stream.\\\")\\n\\n keys = [b\\\"mxpi_tensorinfer0\\\"]\\n keyVec = StringVector()\\n for key in keys:\\n keyVec.push_back(key)\\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\\n print(infer_result)\\n if infer_result.size() == 0:\\n print(\\\"infer_result is null\\\")\\n exit()\\n\\n TensorList = MxpiDataType.MxpiTensorPackageList()\\n TensorList.ParseFromString(infer_result[0].messageBuf)\\n data = np.frombuffer(\\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\\n data = data.reshape(1, 19, 1024, 2048)\\n return data\",\n \"def _post_process_output(self,predictions,convert_to_string):\\n normalized = [(p[0],REVERSE_ARROWS.get(p[1],p[1]),p[2]) for p in predictions]\\n if convert_to_string:\\n return ' '.join([\\\"%s%s\\\" % (p[0],p[1]) for p in normalized])\\n return normalized\",\n \"def inference(self, uInput):\\n self.expose(uInput)\\n for m in range(len(self.layers) - 1):\\n self.layers[m].inference()\\n self.propagate(m, m + 1)\\n\\n ## make inference on the output node\\n self.layers[-1].pipes[0][0].send(\\\"inference\\\")\\n self.layers[-1].pipes[0][0].recv()\\n\\n ## read its output\\n self.layers[-1].pipes[0][0].send(\\\"get_output\\\")\\n msg = self.layers[-1].pipes[0][0].recv()\\n\\n t = msg[1]['dtype']\\n s = msg[1]['shape']\\n output = recv_array(self.layers[-1].pipes[0][0], t, s)\\n\\n return output\",\n \"def postprocess(self, inputs: Dict[str, Any],\\n **postprocess_params) -> Dict[str, str]:\\n text = inputs['text']\\n logits = inputs[OutputKeys.LOGITS]\\n predictions = torch.argmax(logits[0], dim=-1)\\n logits = torch_nested_numpify(torch_nested_detach(logits))\\n predictions = torch_nested_numpify(torch_nested_detach(predictions))\\n offset_mapping = [x.cpu().tolist() for x in inputs['offset_mapping']]\\n\\n labels = [self.id2label[x] for x in predictions]\\n if len(labels) > len(offset_mapping):\\n labels = labels[1:-1]\\n chunks = []\\n chunk = {}\\n for label, offsets in zip(labels, offset_mapping):\\n if label[0] in 'BS':\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n chunk = {\\n 'type': label[2:],\\n 'start': offsets[0],\\n 'end': offsets[1]\\n }\\n if label[0] in 'IES':\\n if chunk:\\n chunk['end'] = offsets[1]\\n\\n if label[0] in 'ES':\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n chunk = {}\\n\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n\\n # for cws outputs\\n if len(chunks) > 0 and chunks[0]['type'] == 'cws':\\n spans = [\\n chunk['span'] for chunk in chunks if chunk['span'].strip()\\n ]\\n seg_result = ' '.join(spans)\\n outputs = {OutputKeys.OUTPUT: seg_result}\\n\\n # for ner output\\n else:\\n outputs = {OutputKeys.OUTPUT: chunks}\\n return outputs\",\n \"def postprocess(m):\\n logger.info(\\\"Postprocessing the model...\\\")\\n while len(m.graph.value_info) > 0:\\n m.graph.value_info.pop()\\n m = other.polish_model(m)\\n eliminating.eliminate_single_input_Concat(m.graph)\\n eliminating.eliminate_nop_Maxpool_and_AveragePool(m.graph)\\n eliminating.eliminate_trivial_elementwise_calculation(m.graph)\\n m = other.polish_model(m)\\n\\n replacing.replace_depthwise_1x1_with_bn(m.graph)\\n m = other.polish_model(m)\\n\\n # removing transpose\\n m = removing_transpose.eliminate_transposes(m)\\n m = other.polish_model(m)\\n removing_transpose.remove_trivial_transpose(m.graph)\\n removing_transpose.fuse_Transpose_into_Gemm_weight(m.graph)\\n\\n # fuse some nodes\\n fusing.fuse_mul_and_add_into_bn(m.graph)\\n m = other.polish_model(m)\\n fusing.fuse_mul_and_add_into_gemm(m.graph)\\n m = other.polish_model(m)\\n fusing.fuse_conv_and_add_into_conv(m.graph)\\n m = other.polish_model(m)\\n replacing.replace_mul_to_bn(m.graph)\\n replacing.replace_div_to_bn(m.graph)\\n replacing.replace_add_to_bn(m.graph)\\n replacing.replace_sub_to_bn(m.graph)\\n replacing.replace_sub_with_bn_and_add(m.graph)\\n m = other.polish_model(m)\\n\\n other.add_output_to_value_info(m.graph)\\n m = optimizer.optimize(m, [\\\"eliminate_deadend\\\"])\\n m.producer_name = \\\"kneron_formatter\\\"\\n return m\",\n \"def inference(self, inputs):\\n\\n input_ids = torch.tensor([inputs[\\\"head_ids\\\"]], dtype=torch.long).to(self.device)\\n attention_masks = torch.tensor([inputs[\\\"attention_masks\\\"]], dtype=torch.bool).to(self.device)\\n \\n # Handling inference for sequence_classification.\\n with torch.no_grad():\\n output = self.model(input_ids, attention_masks)\\n predict_label = output[0].argmax(dim=2)\\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\\n\\n logger.info(\\\"Model predicted: '%s'\\\", predict_string)\\n return [{'predict': predict_string}]\",\n \"def inference():\\n\\n sents = request.get_json(force=True)['sents']\\n\\n vecs = tokenize_inputs(sents)\\n results = model(vecs)\\n\\n result = dict()\\n result['pred'] = [str(sample.numpy()[0]) for sample in results]\\n \\n response = flask.Response()\\n response.headers.add(\\\"Access-Control-Allow-Origin\\\", \\\"*\\\")\\n\\n print(result)\\n\\n return result\",\n \"def infer(self, input):\\n input = self._get_encoding_form(input)\\n input = self.inference_model(input)\\n self.latent.infer(input)\",\n \"def inference_on_data(image) -> str:\\n result = inference_model(image)\\n class_label = torch.argmax(result[0])\\n # Print to log acts as a proxy of saving to an actual DB\\n print(f'Image Class : {class_label}')\\n return str(class_label)\",\n \"def format_model_output(self, output, batch_size=1):\\r\\n return output\",\n \"def inference(self, inputs):\\n # test_2\\n memory = self.get_go_frame(inputs)\\n memory = self._update_memory(memory)\\n\\n self._init_states(inputs, mask=None)\\n self.attention.init_states(inputs)\\n\\n outputs, stop_tokens, alignments, t = [], [], [], 0\\n while True:\\n memory = self.prenet(memory)\\n decoder_output, alignment, stop_token = self.decode(memory)\\n stop_token = torch.sigmoid(stop_token.data)\\n outputs += [decoder_output.squeeze(1)]\\n stop_tokens += [stop_token]\\n alignments += [alignment]\\n\\n if stop_token > self.stop_threshold and t > inputs.shape[0] // 2:\\n break\\n if len(outputs) == self.max_decoder_steps:\\n print(\\\" | > Decoder stopped with 'max_decoder_steps\\\")\\n break\\n\\n memory = self._update_memory(decoder_output)\\n t += 1\\n\\n outputs, stop_tokens, alignments = self._parse_outputs(\\n outputs, stop_tokens, alignments)\\n\\n return outputs, alignments, stop_tokens\",\n \"def inference_call(self, inputs):\\n self.eval()\\n\\n with torch.no_grad():\\n mid, downsampling_features = self.encoder(inputs)\\n hd = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=0)\\n pl = self.decode_branch(mid=mid, downsampling_features=downsampling_features, branch=1)\\n return hd, pl\",\n \"def _post_process_result(result: Any) -> Any:\\n return result\",\n \"def compute_output(api, args):\\n\\n fusion = None\\n\\n # variables from command-line options\\n resume = args.resume_\\n fusion_ids = args.fusion_ids_\\n output = args.predictions\\n # there's only one fusion to be generated at present\\n args.max_parallel_fusions = 1\\n # fusion cannot be published yet.\\n args.public_fusion = False\\n\\n # It is compulsory to have a description to publish either datasets or\\n # fusions\\n if (not args.description_ and args.public_fusion):\\n sys.exit(\\\"You should provide a description to publish.\\\")\\n\\n path = u.check_dir(output)\\n session_file = \\\"%s%s%s\\\" % (path, os.sep, SESSIONS_LOG)\\n csv_properties = {}\\n # If logging is required set the file for logging\\n log = None\\n if args.log_file:\\n u.check_dir(args.log_file)\\n log = args.log_file\\n # If --clear_logs the log files are cleared\\n clear_log_files([log])\\n\\n if args.fusion_file:\\n # fusion regression is retrieved from the contents of the given local\\n # JSON file\\n fusion, csv_properties, fields = u.read_local_resource(\\n args.fusion_file,\\n csv_properties=csv_properties)\\n fusion_ids = [fusion]\\n else:\\n # fusion is retrieved from the remote object or created\\n fusion, resume = \\\\\\n pf.fusion_processing( \\\\\\n fusion, fusion_ids, \\\\\\n api, args, resume, \\\\\\n session_file=session_file, path=path, log=log)\\n\\n # We update the fusion public state if needed\\n if fusion:\\n if isinstance(fusion, str):\\n if not a.has_test(args):\\n query_string = MINIMUM_MODEL\\n elif args.export_fields:\\n query_string = r.ALL_FIELDS_QS\\n else:\\n query_string = ''\\n fusion = u.check_resource(fusion,\\n api.get_fusion,\\n query_string=query_string)\\n if (args.public_fusion or\\n (args.shared_flag and r.shared_changed(args.shared,\\n fusion))):\\n fusion_args = {}\\n if args.shared_flag and r.shared_changed(args.shared,\\n fusion):\\n fusion_args.update(shared=args.shared)\\n if args.public_fusion:\\n fusion_args.update( \\\\\\n rfus.set_publish_fusion_args(args))\\n if fusion_args:\\n fusion = rfus.update_fusion( \\\\\\n fusion, fusion_args, args,\\n api=api, path=path, \\\\\\n session_file=session_file)\\n\\n # We get the fields of the fusion if we haven't got\\n # them yet and need them\\n if fusion and (args.test_set or args.evaluate):\\n fields = pf.get_fusion_fields( \\\\\\n fusion, csv_properties, args)\\n\\n\\n # If predicting\\n if fusion and (a.has_test(args) or \\\\\\n args.remote):\\n test_dataset = get_test_dataset(args)\\n\\n # Remote predictions: predictions are computed as batch predictions\\n # in bigml.com except when --no-batch flag is set on\\n if args.remote and not args.no_batch:\\n # create test source from file\\n test_name = \\\"%s - test\\\" % args.name\\n if args.test_source is None:\\n test_properties = ps.test_source_processing(\\n api, args, resume, name=test_name,\\n session_file=session_file, path=path, log=log)\\n (test_source, resume,\\n csv_properties, test_fields) = test_properties\\n else:\\n test_source_id = bigml.api.get_source_id(args.test_source)\\n test_source = api.check_resource(test_source_id)\\n if test_dataset is None:\\n # create test dataset from test source\\n dataset_args = set_basic_dataset_args(args, name=test_name)\\n test_dataset, resume = pd.alternative_dataset_processing(\\n test_source, \\\"test\\\", dataset_args, api, args,\\n resume, session_file=session_file, path=path, log=log)\\n else:\\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\\n test_dataset = api.check_resource(test_dataset_id)\\n\\n csv_properties.update(objective_field=None,\\n objective_field_present=False)\\n test_fields = pd.get_fields_structure(test_dataset,\\n csv_properties)\\n if not args.evaluate:\\n batch_prediction_args = set_batch_prediction_args(\\n args, fields=fields,\\n dataset_fields=test_fields)\\n\\n remote_prediction(fusion, test_dataset, \\\\\\n batch_prediction_args, args, \\\\\\n api, resume, prediction_file=output, \\\\\\n session_file=session_file, path=path, log=log)\\n\\n else:\\n prediction([fusion], fields, args,\\n session_file=session_file)\\n\\n\\n # If evaluate flag is on, create remote evaluation and save results in\\n # json and human-readable format.\\n if args.evaluate:\\n # When we resume evaluation and models were already completed, we\\n # should use the datasets array as test datasets\\n args.max_parallel_evaluations = 1 # only one evaluation at present\\n args.cross_validation_rate = 0 # no cross-validation\\n args.number_of_evaluations = 1 # only one evaluation\\n if args.has_test_datasets_:\\n test_dataset = get_test_dataset(args)\\n dataset = test_dataset\\n dataset = u.check_resource(dataset, api=api,\\n query_string=r.ALL_FIELDS_QS)\\n dataset_fields = pd.get_fields_structure(dataset, None)\\n resume = evaluate([fusion], [dataset], api,\\n args, resume,\\n fields=fields, dataset_fields=dataset_fields,\\n session_file=session_file, path=path,\\n log=log,\\n objective_field=args.objective_field)\\n\\n\\n u.print_generated_files(path, log_file=session_file,\\n verbosity=args.verbosity)\\n if args.reports:\\n clear_reports(path)\\n if args.upload:\\n upload_reports(args.reports, path)\",\n \"def handle(self, data, context):\\n \\n model_input = self.preprocess(data)\\n model_out = self.inference(model_input)\\n return self.postprocess(model_out)\",\n \"def format_det_result():\\n test_results = load(args.test_result)\\n annos = load(args.anno_path)\\n test_videos = annos['test_videos'][0]\\n resolutions = annos['resolution']\\n frm_dets = []\\n for pred in track(test_results, description='formating...'):\\n video_key = pred['video_id'].split('.mp4')[0]\\n frm_num = pred['timestamp']\\n bboxes = pred['pred_instances']['bboxes']\\n cls_scores = pred['pred_instances']['scores']\\n for bbox, cls_score in zip(bboxes, cls_scores):\\n video_idx = test_videos.index(video_key)\\n pred_label = np.argmax(cls_score)\\n score = cls_score[pred_label]\\n h, w = resolutions[video_key]\\n bbox *= np.array([w, h, w, h])\\n instance_result = np.array(\\n [video_idx, frm_num, pred_label, score, *bbox])\\n frm_dets.append(instance_result)\\n frm_dets = np.array(frm_dets)\\n video_tubes = link_tubes(annos, frm_dets, K=1)\\n dump(frm_dets, args.frm_out_path)\\n dump(video_tubes, args.tube_out_path)\",\n \"def inference():\\n data = request.get_json(force = True)\\n\\n with torch.no_grad():\\n torch.cuda.empty_cache()\\n image = ToTensor(Image.open(BytesIO(b64decode(data['image'])))).half().cuda().unsqueeze_(0)\\n inputs = test_transform(image)\\n model_id = model_usage.get(True)\\n outputs = model[model_id](inputs)[0]\\n model_usage.put(model_id, False)\\n prediction = classes[outputs.argmax(0)]\\n del inputs, outputs, image\\n \\n image_storage.put((data['esun_uuid'], data['image'], prediction), False)\\n\\n t = datetime.datetime.now()\\n ts = str(int(t.utcnow().timestamp()))\\n s = sha256()\\n s.update((CAPTAIN_EMAIL + ts + SALT).encode(\\\"utf-8\\\"))\\n server_uuid = s.hexdigest()\\n\\n return jsonify({'esun_uuid': data['esun_uuid'],\\n 'server_uuid': server_uuid,\\n 'answer': prediction,\\n 'server_timestamp': time()})\",\n \"def post_process(self, res):\\n # some lists are better converted to numpy arrays\\n convert_to_arr = (\\n 'prediction_rank',\\n 'cumulative_area',\\n 'prediction_values',\\n 'cumulative_crime',\\n 'cumulative_crime_count',\\n 'cumulative_crime_max',\\n 'pai'\\n )\\n for k in convert_to_arr:\\n if k in res:\\n # this allows for optional components such as prediction values\\n res[k] = np.array(res[k])\",\n \"def infer_outputs(self):\\n # TF lack a supported API for invoking shape inference directly,\\n # so we instantiate a dummy graph and create a dummy Operation object\\n temp_graph = tf.Graph()\\n with temp_graph.as_default():\\n input_placeholders = [tf.placeholder(shape=t.shape, dtype=t.dtype) for\\n t in self._inputs]\\n # See the docs for tf.Operation for important notes about the semantics\\n # of each arg to the following constructor.\\n dummy_op = tf.Operation(self.to_node_def(), temp_graph,\\n inputs=input_placeholders)\\n self.set_outputs_from_pairs([(o.dtype, o.shape)\\n for o in dummy_op.outputs])\\n # set_outputs_from_pairs() increments the version counter, so we don't\\n # need to. Also, we haven't added edges to the graph until these\\n # outputs are connected to another node's inputs.\",\n \"def postprocess_for_inference(self,\\n prediction: Dict[str, torch.Tensor],\\n *args, **kwargs,\\n ) -> Dict[str, torch.Tensor]:\\n return {\\\"pred_seg\\\": self.logits_convert_fn(prediction[\\\"seg_logits\\\"])}\",\n \"def run_inference_on_image(image):\\n if not tf.gfile.Exists(image):\\n tf.logging.fatal('File does not exist %s', image)\\n image_data = tf.gfile.FastGFile(image, 'rb').read()\\n\\n\\n\\n with tf.Session() as sess:\\n # Some useful tensors:\\n # 'softmax:0': A tensor containing the normalized prediction across\\n # 1000 labels.\\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\\n # float description of the image.\\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\\n # encoding of the image.\\n # Runs the softmax tensor by feeding the image_data as input to the graph.\\n\\n # Creates node ID --> English string lookup.\\n node_lookup = NodeLookup()\\n\\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\\n predictions = sess.run(softmax_tensor,\\n {'DecodeJpeg/contents:0': image_data})\\n predictions = np.squeeze(predictions)\\n\\n\\n\\n top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\\n result =[]\\n for node_id in top_k:\\n human_string = node_lookup.id_to_string(node_id)\\n score = predictions[node_id]\\n\\n point = collections.namedtuple('Point', ['humanString', 'score'])\\n point.humanString = human_string\\n point.score = score\\n result.append(point)\\n return result\",\n \"def inference(self, input_batch):\\r\\n inferences = []\\r\\n # Handling inference for token_classification.\\r\\n batch_size = len(input_batch)\\r\\n\\r\\n num_rows = batch_size\\r\\n for i in range(num_rows):\\r\\n inferences.append({'entity':input_batch[i]})\\r\\n logger.info(\\\"Model predicted: '%s'\\\", input_batch)\\r\\n\\r\\n return inferences\",\n \"def inference_as_raw_output(self, image_path, to_file = False):\\n\\n image_np = self.load_image_into_numpy_array(image_path)\\n input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.uint8)\\n\\n detections_raw = self.detect_fn(input_tensor)\\n # checking how many detections we got\\n detections = self.process_detections(detections_raw)\\n\\n detections_api = {key: value.tolist() for key, value in detections.items()} # convert array to list for whole dict for API\\n\\n if to_file: # if saving to txt file was requested\\n\\n image_h, image_w, _ = image_np.shape\\n\\n dir_path=os.path.join(os.path.dirname(image_path),'prediction_txt_raw_output')\\n\\n if not os.path.isdir(dir_path):\\n os.mkdir(dir_path)\\n\\n title , _ = os.path.splitext(os.path.basename(image_path))\\n\\n file_name = os.path.join(dir_path, f'{title}.txt')\\n \\n line2write = list()\\n line2write.append(os.path.basename(image_path))\\n \\n with open(file_name, 'w') as text_file:\\n # iterating over boxes\\n for b, s, c in zip(\\n detections['detection_boxes'], \\n detections['detection_scores'], \\n detections['detection_classes']\\n ):\\n \\n y1abs, x1abs = b[0] * image_h, b[1] * image_w\\n y2abs, x2abs = b[2] * image_h, b[3] * image_w\\n \\n list2append = [x1abs, y1abs, x2abs, y2abs, s, c]\\n line2append = ','.join([str(item) for item in list2append])\\n \\n line2write.append(line2append)\\n \\n line2write = '\\\\n'.join(line2write)\\n text_file.write(line2write + os.linesep)\\n # print(f'save prediction result to {file_name} -> Done')\\n \\n return detections_api\",\n \"def test_inference(VD, CD):\\n \\n if VD['inference_process'] == None:\\n VD['terminal_output'] += \\\"There is no active inference process.\\\\n\\\"\\n else:\\n VD['terminal_output'] += \\\"\\\\nTesting the inference process.\\\\nOutput should be: \\\\\\\"let's test again then\\\\\\\".\\\\n\\\"\\n ap.run_inference(CD['path_sample_audio'], VD, CD)\\n VD['window']['inferred_text'].update(VD['temp_text'])\",\n \"async def transformer_infer(query: dict, response: Response) -> dict:\\n logger.debug(\\\"TRANSFORMER - predicting query: \\\" + str(query))\\n results = {}\\n try:\\n results = MODELS.sparse_reader.predict(query)\\n logger.info(results)\\n except Exception:\\n logger.error(f\\\"Unable to get results from transformer for {query}\\\")\\n response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR\\n raise\\n return results\",\n \"def _convert_outputs(outputs, reduction_factor, batch_size):\\n\\n with tf.variable_scope(\\\"output_converter\\\"):\\n for key in [\\\"spec\\\", \\\"post_net_spec\\\", \\\"stop_token_logits\\\", \\\"mag_spec\\\"]:\\n outputs[key] = CentaurDecoder._expand(outputs[key], reduction_factor)\\n\\n alignments = []\\n for sample in range(batch_size):\\n alignments.append([outputs[\\\"alignments\\\"][0][:, sample, :, :, :]])\\n mel_spec = outputs[\\\"spec\\\"]\\n post_net_spec = outputs[\\\"post_net_spec\\\"]\\n alignments = alignments\\n stop_token_logits = tf.sigmoid(outputs[\\\"stop_token_logits\\\"])\\n sequence_lengths = outputs[\\\"lengths\\\"]\\n mag_spec = outputs[\\\"mag_spec\\\"]\\n stop_token_prediction = outputs[\\\"stop_token_logits\\\"]\\n return mel_spec, post_net_spec, alignments, stop_token_logits, sequence_lengths, mag_spec, stop_token_prediction\",\n \"def inference(self, input: Union[str, Any]):\\n\\n _input = transform(path=input, sr=16000)\\n F, T = _input.shape\\n\\n x = torch.zeros(1, F, len(_input[0]))\\n x[0, :, :] = _input\\n x = x.unsqueeze(1)\\n \\n x = x.to(self.device)\\n \\n with torch.no_grad():\\n output = self.model(x)\\n \\n if self.model_type == 'multi_class':\\n pred = output.data.max(1, keepdim=True)[1]\\n else:\\n pred = torch.sigmoid(output)\\n pred = pred[:, -1]\\n pred = pred.view(-1).data.cpu().numpy()[0]\\n\\n return (pred, self.idx2label.get(int(pred >= 0.5)))\",\n \"def postprocess(self, predicted_output, original_input=None, stats=None,\\n **kwargs):\\n pass\",\n \"def postprocess(self, inference_output):\\n\\n predicted_idx = str(np.argmax(inference_output.cpu().detach().numpy()))\\n\\n if self.mapping:\\n return [self.mapping[str(predicted_idx)]]\\n return [predicted_idx]\",\n \"def inference(self, x, data):\\n\\n ## Global features concatenated\\n if self.u_dim > 0:\\n u = data.u.view(-1, self.u_dim)\\n x = torch.cat((x, u), 1)\\n\\n ## Final MLP map\\n \\n # Edge level inference\\n if 'edge' in self.task:\\n x = self.forward_2pt(x, data.edge_index)\\n\\n # Node or graph level inference\\n else:\\n x = self.mlp_final(x)\\n\\n return x\",\n \"def postprocess_result(self):\\n output_file = self.analyzer_result_file\\n LOG.debug_analyzer(self.analyzer_stdout)\\n tidy_stdout = self.analyzer_stdout.splitlines()\\n generate_plist_from_tidy_result(output_file, tidy_stdout)\\n\\n if self.report_hash_type == 'context-free':\\n report.use_context_free_hashes(output_file)\",\n \"def infer():\\n\\n # Create StreamManagerApi object\\n stream_manager_api = StreamManagerApi()\\n # Use InitManager method init StreamManagerApi\\n ret = stream_manager_api.InitManager()\\n if ret != 0:\\n print(\\\"Failed to init Stream manager, ret=%s\\\" % str(ret))\\n exit()\\n\\n # create streams by pipeline config file\\n with open(args.pipeline_path, \\\"rb\\\") as f:\\n pipeline_str = f.read()\\n\\n # Configuring a stream\\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\\n if ret != 0:\\n print(\\\"Failed to create Stream, ret=%s\\\" % str(ret))\\n exit()\\n\\n # Construct the input of the stream\\n data_input = MxDataInput()\\n # Stream_name encoded in UTF-8\\n stream_name = args.stream_name.encode()\\n print(stream_name)\\n predictions = []\\n with open(args.label_path, 'rt') as f:\\n val_cls = f.read().rstrip(\\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(args.instances_path)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n for file_name in os.listdir(args.img_path):\\n pred_data = []\\n # Gets the Address of each image\\n img_id = int(file_name.split('.')[0])\\n file_path = args.img_path + file_name\\n size = (cv2.imread(file_path)).shape\\n\\n # Read each photo in turn\\n with open(file_path, \\\"rb\\\") as f:\\n img_data = f.read()\\n if not img_data:\\n print(f\\\"read empty data from img:{file_name}\\\")\\n continue\\n # The element value img_data\\n data_input.data = img_data\\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\\n pred_data.append({\\\"boxes\\\": boxes_output,\\n \\\"box_scores\\\": scores_output,\\n \\\"img_id\\\": img_id,\\n \\\"image_shape\\\": size})\\n\\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\\n print(f\\\"Inferred image:{file_name} success!\\\")\\n\\n # Save the result in JSON format\\n if not os.path.exists(args.res_path):\\n os.makedirs(args.res_path)\\n with open(args.res_path + 'predictions_test.json', 'w') as f:\\n json.dump(predictions, f)\\n stream_manager_api.DestroyAllStreams()\",\n \"def compute_output(api, args):\\n source = None\\n dataset = None\\n model = None\\n models = None\\n fields = None\\n other_label = OTHER\\n ensemble_ids = []\\n multi_label_data = None\\n multi_label_fields = []\\n local_ensemble = None\\n test_dataset = None\\n datasets = None\\n\\n # variables from command-line options\\n resume = args.resume_\\n model_ids = args.model_ids_\\n output = args.predictions\\n dataset_fields = args.dataset_fields_\\n\\n # It is compulsory to have a description to publish either datasets or\\n # models\\n if (not args.description_ and\\n (args.black_box or args.white_box or args.public_dataset)):\\n sys.exit(\\\"You should provide a description to publish.\\\")\\n\\n # When using --max-categories, it is compulsory to specify also the\\n # objective_field\\n if args.max_categories > 0 and args.objective_field is None:\\n sys.exit(\\\"When --max-categories is used, you must also provide the\\\"\\n \\\" --objective field name or column number\\\")\\n\\n # When using --new-fields, it is compulsory to specify also a dataset\\n # id\\n if args.new_fields and not args.dataset:\\n sys.exit(\\\"To use --new-fields you must also provide a dataset id\\\"\\n \\\" to generate the new dataset from it.\\\")\\n\\n path = u.check_dir(output)\\n session_file = \\\"%s%s%s\\\" % (path, os.sep, SESSIONS_LOG)\\n csv_properties = {}\\n # If logging is required set the file for logging\\n log = None\\n if args.log_file:\\n u.check_dir(args.log_file)\\n log = args.log_file\\n # If --clear_logs the log files are cleared\\n clear_log_files([log])\\n\\n # labels to be used in multi-label expansion\\n labels = (None if args.labels is None else\\n [label.strip() for label in\\n args.labels.split(args.args_separator)])\\n if labels is not None:\\n labels = sorted([label for label in labels])\\n\\n # multi_label file must be preprocessed to obtain a new extended file\\n if args.multi_label and args.training_set is not None:\\n (args.training_set, multi_label_data) = ps.multi_label_expansion(\\n args.training_set, args.train_header, args, path,\\n labels=labels, session_file=session_file)\\n args.train_header = True\\n args.objective_field = multi_label_data[\\\"objective_name\\\"]\\n all_labels = l.get_all_labels(multi_label_data)\\n if not labels:\\n labels = all_labels\\n else:\\n all_labels = labels\\n if args.source_file:\\n # source is retrieved from the contents of the given local JSON file\\n source, csv_properties, fields = u.read_local_resource(\\n args.source_file,\\n csv_properties=csv_properties)\\n else:\\n # source is retrieved from the remote object\\n source, resume, csv_properties, fields = ps.source_processing(\\n api, args, resume,\\n csv_properties=csv_properties, multi_label_data=multi_label_data,\\n session_file=session_file, path=path, log=log)\\n if args.multi_label and source:\\n multi_label_data = l.get_multi_label_data(source)\\n (args.objective_field,\\n labels,\\n all_labels,\\n multi_label_fields) = l.multi_label_sync(args.objective_field,\\n labels,\\n multi_label_data,\\n fields,\\n multi_label_fields)\\n\\n if args.dataset_file:\\n # dataset is retrieved from the contents of the given local JSON file\\n model_dataset, csv_properties, fields = u.read_local_resource(\\n args.dataset_file,\\n csv_properties=csv_properties)\\n if not args.datasets:\\n datasets = [model_dataset]\\n dataset = model_dataset\\n else:\\n datasets = u.read_datasets(args.datasets)\\n if not datasets:\\n # dataset is retrieved from the remote object\\n datasets, resume, csv_properties, fields = pd.dataset_processing(\\n source, api, args, resume,\\n fields=fields,\\n csv_properties=csv_properties,\\n multi_label_data=multi_label_data,\\n session_file=session_file, path=path, log=log)\\n if datasets:\\n dataset = datasets[0]\\n if args.to_csv is not None:\\n resume = pd.export_dataset(dataset, api, args, resume,\\n session_file=session_file, path=path)\\n\\n # Now we have a dataset, let's check if there's an objective_field\\n # given by the user and update it in the fields structure\\n args.objective_id_ = get_objective_id(args, fields)\\n\\n # If test_split is used, split the dataset in a training and a test dataset\\n # according to the given split\\n if args.test_split > 0:\\n dataset, test_dataset, resume = pd.split_processing(\\n dataset, api, args, resume,\\n multi_label_data=multi_label_data,\\n session_file=session_file, path=path, log=log)\\n datasets[0] = dataset\\n \\n # Check if the dataset has a categorical objective field and it\\n # has a max_categories limit for categories\\n if args.max_categories > 0 and len(datasets) == 1:\\n if pd.check_max_categories(fields.fields[args.objective_id_]):\\n distribution = pd.get_categories_distribution(dataset,\\n args.objective_id_)\\n if distribution and len(distribution) > args.max_categories:\\n categories = [element[0] for element in distribution]\\n other_label = pd.create_other_label(categories, other_label)\\n datasets, resume = pd.create_categories_datasets(\\n dataset, distribution, fields, args,\\n api, resume, session_file=session_file, path=path, log=log,\\n other_label=other_label)\\n else:\\n sys.exit(\\\"The provided objective field is not categorical nor \\\"\\n \\\"a full terms only text field. \\\"\\n \\\"Only these fields can be used with\\\"\\n \\\" --max-categories\\\")\\n\\n # If multi-dataset flag is on, generate a new dataset from the given\\n # list of datasets\\n if args.multi_dataset:\\n dataset, resume = pd.create_new_dataset(\\n datasets, api, args, resume, fields=fields,\\n session_file=session_file, path=path, log=log)\\n datasets = [dataset]\\n\\n # Check if the dataset has a generators file associated with it, and\\n # generate a new dataset with the specified field structure\\n if args.new_fields:\\n dataset, resume = pd.create_new_dataset(\\n dataset, api, args, resume, fields=fields,\\n session_file=session_file, path=path, log=log)\\n datasets[0] = dataset\\n # rebuild fields structure for new ids and fields\\n fields = pd.get_fields_structure(dataset, csv_properties)\\n args.objective_id_ = get_objective_id(args, fields)\\n if args.multi_label and dataset and multi_label_data is None:\\n multi_label_data = l.get_multi_label_data(dataset)\\n (args.objective_field,\\n labels,\\n all_labels,\\n multi_label_fields) = l.multi_label_sync(args.objective_field,\\n labels,\\n multi_label_data,\\n fields, multi_label_fields)\\n\\n if dataset:\\n # retrieves max_categories data, if any\\n args.max_categories = get_metadata(dataset, 'max_categories',\\n args.max_categories)\\n other_label = get_metadata(dataset, 'other_label',\\n other_label)\\n if args.model_file:\\n # model is retrieved from the contents of the given local JSON file\\n model, csv_properties, fields = u.read_local_resource(\\n args.model_file,\\n csv_properties=csv_properties)\\n models = [model]\\n model_ids = [model['resource']]\\n ensemble_ids = []\\n elif args.ensemble_file:\\n # model is retrieved from the contents of the given local JSON file\\n ensemble, csv_properties, fields = u.read_local_resource(\\n args.ensemble_file,\\n csv_properties=csv_properties)\\n model_ids = ensemble['object']['models'][:]\\n ensemble_ids = [ensemble['resource']]\\n models = model_ids[:]\\n model = retrieve_resource(bigml.api.BigML(storage='./storage'),\\n models[0],\\n query_string=r.ALL_FIELDS_QS)\\n models[0] = model\\n else:\\n # model is retrieved from the remote object\\n models, model_ids, ensemble_ids, resume = pm.models_processing(\\n datasets, models, model_ids,\\n api, args, resume, fields=fields,\\n session_file=session_file, path=path, log=log, labels=labels,\\n multi_label_data=multi_label_data, other_label=other_label)\\n\\n if models:\\n model = models[0]\\n single_model = len(models) == 1\\n # If multi-label flag is set and no training_set was provided, label\\n # info is extracted from the user_metadata. If models belong to an\\n # ensemble, the ensemble must be retrieved to get the user_metadata.\\n if model and args.multi_label and multi_label_data is None:\\n if len(ensemble_ids) > 0 and isinstance(ensemble_ids[0], dict):\\n resource = ensemble_ids[0]\\n elif belongs_to_ensemble(model):\\n ensemble_id = get_ensemble_id(model)\\n resource = r.get_ensemble(ensemble_id, api=api,\\n verbosity=args.verbosity,\\n session_file=session_file)\\n else:\\n resource = model\\n multi_label_data = l.get_multi_label_data(resource)\\n\\n # We update the model's public state if needed\\n if model:\\n if isinstance(model, basestring):\\n if not args.evaluate and not has_test(args):\\n query_string = MINIMUM_MODEL\\n elif not args.test_header:\\n query_string = r.ALL_FIELDS_QS\\n else:\\n query_string = \\\"%s;%s\\\" % (r.ALL_FIELDS_QS, r.FIELDS_QS)\\n model = u.check_resource(model, api.get_model,\\n query_string=query_string)\\n if (args.black_box or args.white_box or\\n (args.shared_flag and r.shared_changed(args.shared, model))):\\n model_args = {}\\n if args.shared_flag and r.shared_changed(args.shared, model):\\n model_args.update(shared=args.shared)\\n if args.black_box or args.white_box:\\n model_args.update(r.set_publish_model_args(args))\\n if model_args:\\n model = r.update_model(model, model_args, args,\\n api=api, path=path,\\n session_file=session_file)\\n models[0] = model\\n\\n # We get the fields of the model if we haven't got\\n # them yet and need them\\n if model and not args.evaluate and args.test_set:\\n # If more than one model, use the full field structure\\n if (not single_model and not args.multi_label and\\n belongs_to_ensemble(model)):\\n if len(ensemble_ids) > 0:\\n ensemble_id = ensemble_ids[0]\\n else:\\n ensemble_id = get_ensemble_id(model)\\n local_ensemble = Ensemble(ensemble_id, api=api,\\n max_models=args.max_batch_models)\\n fields = pm.get_model_fields(\\n model, csv_properties, args, single_model=single_model,\\n multi_label_data=multi_label_data)\\n # Free memory after getting fields\\n local_ensemble = None\\n gc.collect()\\n\\n # Fills in all_labels from user_metadata\\n if args.multi_label and not all_labels:\\n (args.objective_field,\\n labels,\\n all_labels,\\n multi_label_fields) = l.multi_label_sync(args.objective_field, labels,\\n multi_label_data, fields,\\n multi_label_fields)\\n if model:\\n # retrieves max_categories data, if any\\n args.max_categories = get_metadata(model, 'max_categories',\\n args.max_categories)\\n other_label = get_metadata(model, 'other_label',\\n other_label)\\n # If predicting\\n if (models and (has_test(args) or (test_dataset and args.remote))\\n and not args.evaluate):\\n models_per_label = 1\\n if test_dataset is None:\\n test_dataset = get_test_dataset(args)\\n\\n if args.multi_label:\\n # When prediction starts from existing models, the\\n # multi_label_fields can be retrieved from the user_metadata\\n # in the models\\n if args.multi_label_fields is None and multi_label_fields:\\n multi_label_field_names = [field[1] for field\\n in multi_label_fields]\\n args.multi_label_fields = \\\",\\\".join(multi_label_field_names)\\n test_set = ps.multi_label_expansion(\\n args.test_set, args.test_header, args, path,\\n labels=labels, session_file=session_file, input_flag=True)[0]\\n test_set_header = True\\n\\n # Remote predictions: predictions are computed as batch predictions\\n # in bigml.com except when --no-batch flag is set on or multi-label\\n # or max-categories are used\\n if (args.remote and not args.no_batch and not args.multi_label\\n and not args.method in [THRESHOLD_CODE, COMBINATION]):\\n # create test source from file\\n test_name = \\\"%s - test\\\" % args.name\\n if args.test_source is None:\\n (test_source,\\n resume,\\n csv_properties,\\n test_fields) = ps.test_source_processing(\\n api, args, resume, session_file=session_file,\\n path=path, log=log)\\n else:\\n test_source_id = bigml.api.get_source_id(args.test_source)\\n test_source = api.check_resource(test_source_id)\\n if test_dataset is None:\\n # create test dataset from test source\\n dataset_args = r.set_basic_dataset_args(args, name=test_name)\\n test_dataset, resume = pd.alternative_dataset_processing(\\n test_source, \\\"test\\\", dataset_args, api, args,\\n resume, session_file=session_file, path=path, log=log)\\n else:\\n test_dataset_id = bigml.api.get_dataset_id(test_dataset)\\n test_dataset = api.check_resource(test_dataset_id)\\n\\n csv_properties.update(objective_field=None,\\n objective_field_present=False)\\n test_fields = pd.get_fields_structure(test_dataset,\\n csv_properties)\\n\\n batch_prediction_args = r.set_batch_prediction_args(\\n args, fields=fields,\\n dataset_fields=test_fields)\\n\\n remote_predict(model, test_dataset, batch_prediction_args, args,\\n api, resume, prediction_file=output,\\n session_file=session_file, path=path, log=log)\\n else:\\n models_per_label = args.number_of_models\\n if (args.multi_label and len(ensemble_ids) > 0\\n and args.number_of_models == 1):\\n # use case where ensembles are read from a file\\n models_per_label = len(models) / len(ensemble_ids)\\n predict(models, fields, args, api=api, log=log,\\n resume=resume, session_file=session_file, labels=labels,\\n models_per_label=models_per_label, other_label=other_label,\\n multi_label_data=multi_label_data)\\n\\n # When combine_votes flag is used, retrieve the predictions files saved\\n # in the comma separated list of directories and combine them\\n if args.votes_files_:\\n model_id = re.sub(r'.*(model_[a-f0-9]{24})__predictions\\\\.csv$',\\n r'\\\\1', args.votes_files_[0]).replace(\\\"_\\\", \\\"/\\\")\\n try:\\n model = u.check_resource(model_id, api.get_model)\\n except ValueError, exception:\\n sys.exit(\\\"Failed to get model %s: %s\\\" % (model_id, str(exception)))\\n\\n local_model = Model(model)\\n message = u.dated(\\\"Combining votes.\\\\n\\\")\\n u.log_message(message, log_file=session_file,\\n console=args.verbosity)\\n\\n combine_votes(args.votes_files_, local_model.to_prediction,\\n output, method=args.method)\\n\\n # If evaluate flag is on, create remote evaluation and save results in\\n # json and human-readable format.\\n if args.evaluate:\\n # When we resume evaluation and models were already completed, we\\n # should use the datasets array as test datasets\\n if args.dataset_off and not args.test_dataset_ids:\\n args.test_dataset_ids = datasets\\n if args.test_dataset_ids:\\n eval_ensembles = len(ensemble_ids) == len(args.test_dataset_ids)\\n models_or_ensembles = (ensemble_ids if eval_ensembles else\\n models)\\n # Evaluate the models with the corresponding test datasets.\\n resume = evaluate(models_or_ensembles, args.test_dataset_ids, api,\\n args, resume,\\n fields=fields, dataset_fields=dataset_fields,\\n session_file=session_file, path=path,\\n log=log, labels=labels, all_labels=all_labels,\\n objective_field=args.objective_field)\\n else:\\n if args.multi_label and args.test_set is not None:\\n # When evaluation starts from existing models, the\\n # multi_label_fields can be retrieved from the user_metadata\\n # in the models\\n if args.multi_label_fields is None and multi_label_fields:\\n args.multi_label_fields = multi_label_fields\\n test_set = ps.multi_label_expansion(\\n test_set, test_set_header, args, path,\\n labels=labels, session_file=session_file)[0]\\n test_set_header = True\\n\\n if args.test_split > 0:\\n dataset = test_dataset\\n dataset_fields = pd.get_fields_structure(dataset, None)\\n models_or_ensembles = (ensemble_ids if ensemble_ids != []\\n else models)\\n resume = evaluate(models_or_ensembles, [dataset], api,\\n args, resume,\\n fields=fields, dataset_fields=dataset_fields,\\n session_file=session_file, path=path,\\n log=log, labels=labels, all_labels=all_labels,\\n objective_field=args.objective_field)\\n\\n # If cross_validation_rate is > 0, create remote evaluations and save\\n # results in json and human-readable format. Then average the results to\\n # issue a cross_validation measure set.\\n if args.cross_validation_rate > 0:\\n args.sample_rate = 1 - args.cross_validation_rate\\n cross_validate(models, dataset, fields, api, args, resume,\\n session_file=session_file,\\n path=path, log=log)\\n\\n u.print_generated_files(path, log_file=session_file,\\n verbosity=args.verbosity)\\n if args.reports:\\n clear_reports(path)\\n if args.upload:\\n upload_reports(args.reports, path)\",\n \"def output_predictions(predictions, output_file=None, output_format=\\\"plaintext\\\", info=None):\\n\\n content = \\\"\\\"\\n\\n if (output_format == \\\"plaintext\\\") or (output_format == \\\"txt\\\"):\\n lines = []\\n for k in predictions:\\n lines.append(\\\"- %s: %s\\\" % (k, predictions[k]))\\n content = \\\"\\\\n\\\".join(lines)\\n\\n elif output_format == \\\"csv\\\":\\n output = io.StringIO()\\n writer = csv.writer(output, quoting=csv.QUOTE_NONNUMERIC)\\n writer.writerow([\\\"label\\\", \\\"probability\\\"])\\n for k in predictions:\\n writer.writerow([k, float(predictions[k])])\\n content = output.getvalue()\\n\\n elif output_format == \\\"xml\\\":\\n root = ET.Element(\\\"predictions\\\")\\n if info is not None:\\n for k in info:\\n root.set(k, info[k])\\n root.set(\\\"timestamp\\\", str(datetime.now()))\\n for k in predictions:\\n p = ET.SubElement(root, \\\"prediction\\\")\\n p.set(\\\"label\\\", k)\\n p.text = str(float(predictions[k]))\\n content = minidom.parseString(ET.tostring(root)).toprettyxml(indent = \\\" \\\")\\n\\n elif output_format == \\\"json\\\":\\n data = dict()\\n if info is not None:\\n info = copy.copy(info)\\n else:\\n info = dict()\\n info[\\\"timestamp\\\"] = str(datetime.now())\\n data[\\\"info\\\"] = info\\n data[\\\"predictions\\\"] = dict()\\n for k in predictions:\\n data[\\\"predictions\\\"][k] = float(predictions[k])\\n content = json.dumps(data)\\n\\n else:\\n raise Exception(\\\"Unhandled format: %s\\\" % output_format)\\n\\n if output_file is None:\\n print(content)\\n else:\\n with open(output_file, \\\"w\\\") as of:\\n of.write(content)\",\n \"def inference_line(config):\\n def get_entity(doc, begin, end):\\n for ent in doc.ents:\\n # check included\\n if ent.start_char <= begin and end <= ent.end_char:\\n if ent.start_char == begin: return 'B-' + ent.label_\\n else: return 'I-' + ent.label_\\n return 'O'\\n \\n def build_bucket(nlp, line):\\n bucket = []\\n doc = nlp(line)\\n for token in doc:\\n begin = token.idx\\n end = begin + len(token.text) - 1\\n temp = []\\n '''\\n print(token.i, token.text, token.lemma_, token.pos_, token.tag_, token.dep_,\\n token.shape_, token.is_alpha, token.is_stop, begin, end)\\n '''\\n temp.append(token.text)\\n temp.append(token.tag_)\\n temp.append('O') # no chunking info\\n entity = get_entity(doc, begin, end)\\n temp.append(entity) # entity by spacy\\n temp = ' '.join(temp)\\n bucket.append(temp)\\n return bucket\\n\\n import spacy\\n nlp = spacy.load('en')\\n\\n # create model and compile\\n model = Model(config)\\n model.compile()\\n sess = model.sess\\n\\n # restore model\\n saver = tf.train.Saver()\\n saver.restore(sess, config.restore)\\n tf.logging.info('model restored' +'\\\\n')\\n\\n while 1:\\n try: line = sys.stdin.readline()\\n except KeyboardInterrupt: break\\n if not line: break\\n line = line.strip()\\n if not line: continue\\n # create bucket\\n try: bucket = build_bucket(nlp, line)\\n except Exception as e:\\n sys.stderr.write(str(e) +'\\\\n')\\n continue\\n inp, feed_dict = feed.build_input_feed_dict(model, bucket)\\n if 'bert' in config.emb_class:\\n # compute bert embedding at runtime\\n bert_embeddings = sess.run([model.bert_embeddings_subgraph], feed_dict=feed_dict)\\n # update feed_dict\\n feed_dict[model.bert_embeddings] = feed.align_bert_embeddings(config, bert_embeddings, inp.example['bert_wordidx2tokenidx'], -1)\\n logits_indices, sentence_lengths = sess.run([model.logits_indices, model.sentence_lengths], feed_dict=feed_dict)\\n tags = config.logit_indices_to_tags(logits_indices[0], sentence_lengths[0])\\n for i in range(len(bucket)):\\n out = bucket[i] + ' ' + tags[i]\\n sys.stdout.write(out + '\\\\n')\\n sys.stdout.write('\\\\n')\\n\\n sess.close()\",\n \"def postprocess(self, res, op_item, addon):\\n result = res\\n\\n if \\\"postprocess\\\" in op_item:\\n for post in [i.strip() for i in op_item[\\\"postprocess\\\"].split(\\\" --> \\\")]:\\n func_name = sub(\\\"^([^\\\\(\\\\)]+)\\\\(.+$\\\", \\\"\\\\\\\\1\\\", post).strip()\\n param_str = sub(\\\"^.+\\\\(([^\\\\(\\\\)]*)\\\\).*\\\", \\\"\\\\\\\\1\\\", post)\\n if param_str == \\\"\\\":\\n params_values = ()\\n else:\\n params_values = next(\\n reader(param_str.splitlines(), skipinitialspace=True)\\n )\\n\\n func = getattr(addon, func_name)\\n func_params = (result,) + tuple(params_values)\\n result, do_type_fields = func(*func_params)\\n if do_type_fields:\\n result = self.type_fields(result, op_item)\\n\\n return result\",\n \"def postprocess_output(\\n self,\\n init_net: core.Net,\\n predict_net: core.Net,\\n workspace: core.workspace,\\n output_names: List[str],\\n py_model,\\n ):\\n model_out = py_model(*self.dummy_model_input)\\n res = py_model.output_layer.export_to_caffe2(\\n workspace, init_net, predict_net, model_out, *output_names\\n )\\n\\n # optionally include the last decoder layer of pytorch model\\n final_output_names = [str(output) for output in res] + (\\n output_names if self.config.export_logits else []\\n )\\n\\n return res, final_output_names\",\n \"def _process_convert_output_(self, output_data, **kwargs):\\n accept_input, current_state, output = output_data\\n return (accept_input, current_state, output)\",\n \"def make_output_human_readable(\\n self, predictions: torch.Tensor\\n ) -> Dict[str, torch.Tensor]:\\n all_predictions = predictions.cpu().data.numpy()\\n if all_predictions.ndim == 3:\\n predictions_list = [all_predictions[i] for i in range(all_predictions.shape[0])]\\n else:\\n predictions_list = [all_predictions]\\n all_tags = []\\n for predictions in predictions_list:\\n outside_index = self.vocab.get_token_index(\\\"O\\\", namespace=self.task)\\n\\n # @AR: Get the thresholded matrix and prepare the prediction sequence\\n pred_over_thresh = (predictions >= self.threshold) * predictions\\n #print(pred_over_thresh)\\n sequence_token_labels = []\\n maxxx = numpy.argmax(predictions, axis=-1).tolist()\\n\\n # @AR: For each label set, check if to apply argmax or sigmoid thresh\\n j=0\\n for pred in pred_over_thresh:\\n num_pred_over_thresh = numpy.count_nonzero(pred)\\n if (num_pred_over_thresh == 0) or (num_pred_over_thresh == 1):\\n pred_idx_list = [maxxx[j]]\\n\\n else:\\n try:\\n outside_position = pred_idx_list.index(outside_index)\\n except ValueError:\\n outside_position = -1\\n # get ranked list\\n tuples = [[score, idx] for idx, score in enumerate(pred) if score > self.threshold and idx != outside_position]\\n # check for max_heads\\n if self.max_heads != 0 and len(tuples) > self.max_heads:\\n tuples = tuples[:self.max_heads]\\n if len(tuples) == 0:\\n tuples = [1.0, outside_position]\\n pred_idx_list = [x[1] for x in tuples]\\n \\n\\n sequence_token_labels.append(pred_idx_list)\\n j += 1\\n\\n # @AR: Create the list of tags to append for the output\\n tags = []\\n for token_labels in sequence_token_labels:\\n curr_labels = []\\n for token_label in token_labels:\\n curr_labels.append(\\n self.vocab.get_token_from_index(token_label, namespace=self.task))\\n tags.append(curr_labels)\\n\\n all_tags.append(tags)\\n return all_tags\",\n \"def out(self, inputs):\",\n \"def _create_output_alternatives(self, predictions):\\n return {self.head_name: (self._problem_type, predictions)}\",\n \"def convert_to_lf(input: str, output_1: str, output_2: str = None):\\n\\n commands = {'predicates': ['jump', 'run', 'look', 'turn', 'walk'],\\n 'directions': ['right', 'left'],\\n 'manners': ['around', 'opposite'],\\n 'connectives': ['and', 'after'],\\n 'repetitions': ['twice', 'thrice']}\\n\\n examples_parsed = []\\n\\n all_possible_tokens = []\\n for tokens in commands.values():\\n all_possible_tokens += tokens\\n with open(input, 'r') as f:\\n for row in f:\\n connective = None\\n question = row.split('OUT:')[0].replace('IN:', '').strip()\\n denotation = row.split('OUT:')[1].strip()\\n parts = [question]\\n for token in parts[0].split(' '):\\n assert token in all_possible_tokens\\n for connective_candidate in commands['connectives']:\\n parts = parts[0].split(connective_candidate)\\n if len(parts) > 1:\\n connective = connective_candidate\\n break\\n inner_programs = []\\n for i, part in enumerate(parts):\\n inner_programs.append(get_inner_program(part.split(' '), commands))\\n if not connective:\\n assert len(inner_programs) == 1\\n program = inner_programs[0]\\n else:\\n assert len(inner_programs) == 2\\n program = '{} ( {} , {} )'.format(PREFIX+connective+SUFFIX, inner_programs[0],\\n inner_programs[1])\\n program = program.replace(' ', ' ')\\n examples_parsed.append({'question': question, 'program': program, 'answer': denotation})\\n if output_2 is not None: # take 20% for dev\\n random.shuffle(examples_parsed)\\n train_size = math.ceil(0.8 * len(examples_parsed))\\n with open(output_1, 'w') as f_1:\\n with open(output_2, 'w') as f_2:\\n for i, ex in enumerate(examples_parsed):\\n if i < train_size:\\n json.dump(ex, f_1)\\n f_1.write('\\\\n')\\n else:\\n json.dump(ex, f_2)\\n f_2.write('\\\\n')\\n else:\\n with open(output_1, 'w') as f_1:\\n for i, ex in enumerate(examples_parsed):\\n json.dump(ex, f_1)\\n f_1.write('\\\\n')\",\n \"def run_inference_on_image(image):\\n if not tf.gfile.Exists(image):\\n tf.logging.fatal('File does not exist %s', image)\\n image_data = tf.gfile.FastGFile(image, 'rb').read()\\n\\n # Creates graph from saved GraphDef.\\n #create_graph()\\n\\n with tf.Session() as sess:\\n # Some useful tensors:\\n # 'softmax:0': A tensor containing the normalized prediction across\\n # 1000 labels.\\n # 'pool_3:0': A tensor containing the next-to-last layer containing 2048\\n # float description of the image.\\n # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG\\n # encoding of the image.\\n # Runs the softmax tensor by feeding the image_data as input to the graph.\\n global RESULTS_ANALYSIS\\n softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')\\n\\t\\n predictions = sess.run(softmax_tensor,\\n {'DecodeJpeg/contents:0': image_data})\\n predictions = np.squeeze(predictions)\\n\\n # Creates node ID --> English string lookup.\\n node_lookup = NodeLookup()\\n #top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\\n top_k = predictions.argsort()[-3:][::-1]\\n RESULTS_ANALYSIS=''\\n for node_id in top_k:\\n human_string = node_lookup.id_to_string(node_id)\\n score = predictions[node_id]\\n print('%s (score = %.5f)' % (human_string, score))\\n RESULTS_ANALYSIS=RESULTS_ANALYSIS+'%s (score = %.5f)' % (human_string, score)+';'\",\n \"def infer(self, example, model):\\n asp_input = model + '\\\\n\\\\n' + example + '\\\\n\\\\n' + inference_program_ec\\n ctl = clingo.Control()\\n ctl.add(\\\"base\\\", [], asp_input)\\n ctl.ground([(\\\"base\\\", [])], context=self)\\n ctl.solve(on_model=self.show_model)\",\n \"def transform():\",\n \"def convert_mnist_experiment_result(experiment_result) -> str:\\n import json\\n r = json.loads(experiment_result)\\n args = []\\n for hp in r:\\n print(hp)\\n args.append(\\\"%s=%s\\\" % (hp[\\\"name\\\"], hp[\\\"value\\\"]))\\n\\n return \\\" \\\".join(args)\",\n \"def predict(self, data):\\n\\t\\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\\n\\t\\tprint(res)\",\n \"def get_pred_res_list_item_smith_de(result):\\n pred_item_dict = {}\\n pred_item_dict[\\\"predicted_score\\\"] = str(result[\\\"predicted_score\\\"])\\n pred_item_dict[\\\"predicted_class\\\"] = str(result[\\\"predicted_class\\\"])\\n pred_item_dict[\\\"documents_match_labels\\\"] = str(\\n result[\\\"documents_match_labels\\\"][0])\\n pred_item_dict[\\\"seq_embed_1\\\"] = \\\",\\\".join(\\n [str(e) for e in result[\\\"seq_embed_1\\\"]])\\n pred_item_dict[\\\"seq_embed_2\\\"] = \\\",\\\".join(\\n [str(e) for e in result[\\\"seq_embed_2\\\"]])\\n pred_item_dict[\\\"input_sent_embed_1\\\"] = transfer_2d_array_to_str(\\n result[\\\"input_sent_embed_1\\\"])\\n pred_item_dict[\\\"input_sent_embed_2\\\"] = transfer_2d_array_to_str(\\n result[\\\"input_sent_embed_2\\\"])\\n pred_item_dict[\\\"output_sent_embed_1\\\"] = transfer_2d_array_to_str(\\n result[\\\"output_sent_embed_1\\\"])\\n pred_item_dict[\\\"output_sent_embed_2\\\"] = transfer_2d_array_to_str(\\n result[\\\"output_sent_embed_2\\\"])\\n return pred_item_dict\",\n \"def _format_output(predictions, descriptors):\\n # type: (list,dict) -> list\\n\\n output = []\\n for item in predictions:\\n output.append(' - '.join([descriptors.get(item[1]), str(item[0]).format('0.00f')]))\\n\\n return output\",\n \"def inference_graph(self, input_data):\\n return self.inference_ops.tree_predictions(\\n input_data, self.variables.tree, self.variables.tree_thresholds,\\n self.variables.node_sums,\\n valid_leaf_threshold=self.params.valid_leaf_threshold)\",\n \"def query(self,text_input,prefix='answer:',convert_to_string=True):\\n predictions, raw_outputs = self.model.predict([text_input])\\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\\n return self._post_process_output(preds,convert_to_string=convert_to_string)\",\n \"def transform_fn(net, data, input_content_type, output_content_type):\\n # we can use content types to vary input/output handling, but\\n # here we just assume json for both\\n ctx = mx.cpu() \\n batch_size=64\\n output=[]\\n print (\\\"Start Parsing input\\\")\\n parsed = json.loads(data)\\n print (\\\"End Parsing input\\\")\\n images=[]\\n multisp=False\\n \\n #Check for Multispectral input type\\n if 'type' in parsed.keys():\\n if parsed['type'].lower() == 'rgb':\\n multisp=False\\n job_data=parsed['instances']\\n else:\\n multisp=True\\n encodedBytes=parsed['instances'].encode(\\\"utf-8\\\")\\n zip_value=base64.b64decode(encodedBytes)\\n dump_value=gzip.decompress(zip_value)\\n job_data=pickle.loads(dump_value)\\n \\n print (\\\"Multispacial\\\",multisp)\\n \\n for item in job_data:\\n image_data=np.array(item['data'])\\n print (\\\"Input Image Shape:\\\", image_data.shape)\\n images.append ({'data':image_data})\\n \\n print (\\\"MultiSP:\\\", multisp)\\n loader=BatchLoader(images,64,ctx,multisp)\\n \\n for idxb, batch in enumerate(loader.get_batches()):\\n preds = nd.argmax(net(batch), axis=1)\\n for pred in preds:\\n output.append({'data':pred.asnumpy().astype('uint8').tolist() })\\n\\n response_body = json.dumps({'predictions':output})\\n return response_body, output_content_type\",\n \"def log_inference(tester, name, description):\\r\\n\\tfor dataset, output in tester.preds.items():\\r\\n\\t\\tresults = pandas.DataFrame.from_dict(output)\\r\\n\\t\\tpath = os.path.join(\\r\\n\\t\\t\\tEXPERIMENT_PATH, tester.config[\\\"name\\\"] + '-' + dataset)\\r\\n\\t\\twith open(path + \\\".csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults.to_csv(f, sep=\\\"\\\\t\\\", encoding='utf-8', \\r\\n\\t\\t\\t\\tfloat_format='%.3f', index=False)\\r\\n\\r\\n\\t\\twith open(path + \\\"-predictions.csv\\\", \\\"w\\\") as f:\\r\\n\\t\\t\\tresults[[\\\"tag\\\", \\\"y_hat\\\"]].to_csv(\\r\\n\\t\\t\\t\\tf, index=False, float_format='%.3f', header=False)\",\n \"def format_predictions(outputs, annotations):\\n data = []\\n prediction = outputs[\\\"instances\\\"].to(\\\"cpu\\\")\\n\\n predicted_boxes = prediction.pred_boxes.tensor.numpy().tolist()\\n predicted_scores = prediction.scores.numpy().tolist()\\n predicted_classes = prediction.pred_classes.numpy().tolist()\\n\\n for annotation in annotations:\\n bbox = annotation[\\\"bbox\\\"]\\n\\n # Convert from numpy.int64 to int\\n x, y, x2, y2 = map(lambda x: x.item(), bbox)\\n\\n label = annotation[\\\"category_id\\\"]\\n data.append(\\n {\\n \\\"label\\\": f\\\"ground_truth-{label}\\\",\\n \\\"score\\\": 100,\\n \\\"box\\\": {\\\"x\\\": x, \\\"y\\\": y, \\\"x2\\\": x2, \\\"y2\\\": y2},\\n }\\n )\\n\\n for predicted_box, predicted_score, predicted_class in zip(\\n predicted_boxes, predicted_scores, predicted_classes\\n ):\\n x, y, x2, y2 = predicted_box\\n data.append(\\n {\\n \\\"label\\\": predicted_class,\\n \\\"box\\\": {\\\"x\\\": x, \\\"y\\\": y, \\\"x2\\\": x2, \\\"y2\\\": y2},\\n \\\"score\\\": predicted_score * 100,\\n }\\n )\\n\\n return data\",\n \"def infer(self, request, datastore=None):\\n model = request.get(\\\"model\\\")\\n if not model:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n \\\"Model is not provided for Inference Task\\\",\\n )\\n\\n task = self._infers.get(model)\\n if not task:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n f\\\"Inference Task is not Initialized. There is no model '{model}' available\\\",\\n )\\n\\n request = copy.deepcopy(request)\\n request[\\\"description\\\"] = task.description\\n\\n image_id = request[\\\"image\\\"]\\n if isinstance(image_id, str):\\n datastore = datastore if datastore else self.datastore()\\n if os.path.exists(image_id):\\n request[\\\"save_label\\\"] = False\\n else:\\n request[\\\"image\\\"] = datastore.get_image_uri(request[\\\"image\\\"])\\n\\n if os.path.isdir(request[\\\"image\\\"]):\\n logger.info(\\\"Input is a Directory; Consider it as DICOM\\\")\\n\\n logger.debug(f\\\"Image => {request['image']}\\\")\\n else:\\n request[\\\"save_label\\\"] = False\\n\\n if self._infers_threadpool:\\n\\n def run_infer_in_thread(t, r):\\n handle_torch_linalg_multithread(r)\\n return t(r)\\n\\n f = self._infers_threadpool.submit(run_infer_in_thread, t=task, r=request)\\n result_file_name, result_json = f.result(request.get(\\\"timeout\\\", settings.MONAI_LABEL_INFER_TIMEOUT))\\n else:\\n result_file_name, result_json = task(request)\\n\\n label_id = None\\n if result_file_name and os.path.exists(result_file_name):\\n tag = request.get(\\\"label_tag\\\", DefaultLabelTag.ORIGINAL)\\n save_label = request.get(\\\"save_label\\\", False)\\n if save_label:\\n label_id = datastore.save_label(\\n image_id, result_file_name, tag, {\\\"model\\\": model, \\\"params\\\": result_json}\\n )\\n else:\\n label_id = result_file_name\\n\\n return {\\\"label\\\": label_id, \\\"tag\\\": DefaultLabelTag.ORIGINAL, \\\"file\\\": result_file_name, \\\"params\\\": result_json}\",\n \"def post(self):\\n result = {'status': 'error'}\\n\\n args = input_parser.parse_args()\\n input_data = args['image'].read()\\n image = self.model_wrapper._read_image(input_data)\\n preds = self.model_wrapper._predict(image)\\n\\n # Modify this code if the schema is changed\\n label_preds = [{'label_id': p[0], 'label': p[1], 'probability': p[2]} for p in [x for x in preds]]\\n result['predictions'] = label_preds\\n result['status'] = 'ok'\\n\\n return result\",\n \"def make_pred_output(self, sample):\\n output_sample = copy.deepcopy(sample)\\n # output_sample.pop('profile', None)\\n for msg in output_sample['messages-so-far']:\\n # msg.pop('tokenized_utterance', None)\\n if not isinstance(msg['tokenized_utterance'], basestring):\\n msg['tokenized_utterance'] = ' '.join(msg['tokenized_utterance'])\\n msg.pop('utterance_token_ids', None)\\n\\n for correct_answer in output_sample['options-for-correct-answers']:\\n # correct_answer.pop('tokenized_utterance', None)\\n if not isinstance(correct_answer['tokenized_utterance'], basestring):\\n correct_answer['tokenized_utterance'] = ' '.join(correct_answer['tokenized_utterance'])\\n correct_answer.pop('utterance_token_ids', None)\\n\\n if 'SEQTAG' in self.decode_goal:\\n pass\\n else:\\n output_sample['pred_probs'] = sorted(output_sample['pred_probs'], key=lambda o: o['prob'], reverse=True)\\n return output_sample\",\n \"def postprocess_relation_predictions(predictions):\\n \\n output = {}\\n word_pairs = [wp.split(\\\" -> \\\") for wp in predictions.keys()]\\n for wp in word_pairs:\\n fp = \\\" -> \\\".join([wp[0], wp[1]])\\n bp = \\\" -> \\\".join([wp[1], wp[0]])\\n \\n if predictions[fp][\\\"relations\\\"][0] == predictions[bp][\\\"relations\\\"][0]:\\n if predictions[fp][\\\"confidence\\\"][0] > predictions[bp][\\\"confidence\\\"][0]:\\n output[fp] = predictions[fp]\\n else:\\n output[bp] = predictions[bp]\\n else:\\n output[fp] = predictions[fp]\\n output[bp] = predictions[bp]\\n return output\",\n \"def preprocess_output(self, inference_results, image, show_bbox=False, **kwargs):\\n flattened_predictions = np.vstack(inference_results).ravel()\\n results = {}\\n face_h, face_w = image.shape[:2]\\n\\n if len(flattened_predictions) == 70:\\n landmarks = []\\n for i in range(flattened_predictions.size // 2):\\n x_coord = int(face_w * flattened_predictions[2 * i])\\n y_coord = int(face_h * flattened_predictions[2 * i + 1])\\n landmarks.append((x_coord, y_coord))\\n\\n face_landmarks = {\\n \\\"type\\\": self._model_type,\\n \\\"eyes_coords\\\": landmarks[:4],\\n \\\"nose_coords\\\": landmarks[4:8],\\n \\\"mouth_coords\\\": landmarks[8:12],\\n \\\"face_contour\\\": landmarks[12:],\\n }\\n else:\\n coord_mapping = dict(\\n zip(\\n (\\n \\\"left_eye_x_coord\\\",\\n \\\"left_eye_y_coord\\\",\\n \\\"right_eye_x_coord\\\",\\n \\\"right_eye_y_coord\\\",\\n \\\"nose_coord\\\",\\n \\\"left_mouth_coord\\\",\\n \\\"right_mouth_coord\\\",\\n ),\\n flattened_predictions,\\n )\\n )\\n\\n def get_eye_points(eye_coords, eye_size=10):\\n\\n eye_min = eye_coords - eye_size\\n eye_max = eye_coords + eye_size\\n return map(int, [eye_coords, eye_min, eye_max])\\n\\n # left eye offset of face\\n left_eye_x_coord, left_eye_xmin, left_eye_xmax = get_eye_points(\\n coord_mapping[\\\"left_eye_x_coord\\\"] * face_w\\n )\\n\\n # left eye offset of face\\n left_eye_y_coord, left_eye_ymin, left_eye_ymax = get_eye_points(\\n coord_mapping[\\\"left_eye_y_coord\\\"] * face_h\\n )\\n\\n # right eye offset of face\\n right_eye_x_coord, right_eye_xmin, right_eye_xmax = get_eye_points(\\n coord_mapping[\\\"right_eye_x_coord\\\"] * face_w\\n )\\n\\n # right eye offset of face\\n right_eye_y_coord, right_eye_ymin, right_eye_ymax = get_eye_points(\\n coord_mapping[\\\"right_eye_y_coord\\\"] * face_h\\n )\\n eye_size = 10\\n\\n left_eye_x_coord = int(flattened_predictions[0] * face_w)\\n # left eye offset of face\\n left_eye_xmin = left_eye_x_coord - eye_size\\n left_eye_xmax = left_eye_x_coord + eye_size\\n\\n left_eye_y_coord = int(flattened_predictions[1] * face_h)\\n # left eye offset of face\\n left_eye_ymin = left_eye_y_coord - eye_size\\n left_eye_ymax = left_eye_y_coord + eye_size\\n\\n right_eye_x_coord = int(flattened_predictions[2] * face_w)\\n # right eye offset of face\\n right_eye_xmin = right_eye_x_coord - eye_size\\n right_eye_xmax = right_eye_x_coord + eye_size\\n\\n right_eye_y_coord = int(flattened_predictions[3] * face_h)\\n # right eye offset of face\\n right_eye_ymin = right_eye_y_coord - eye_size\\n right_eye_ymax = right_eye_y_coord + eye_size\\n # nose coordinates\\n nose_coord = coord_mapping[\\\"nose_coord\\\"]\\n\\n # mouth coordinates\\n left_part_mouth = coord_mapping[\\\"left_mouth_coord\\\"] * face_w\\n right_part_mouth = coord_mapping[\\\"right_mouth_coord\\\"] * face_w\\n\\n face_landmarks = {\\n \\\"type\\\": self._model_type,\\n \\\"eyes_coords\\\": {\\n \\\"left_eye_point\\\": (left_eye_x_coord, left_eye_y_coord),\\n \\\"right_eye_point\\\": (right_eye_x_coord, right_eye_y_coord),\\n \\\"left_eye_image\\\": image[\\n left_eye_ymin:left_eye_ymax, left_eye_xmin:left_eye_xmax\\n ],\\n \\\"right_eye_image\\\": image[\\n right_eye_ymin:right_eye_ymax, right_eye_xmin:right_eye_xmax,\\n ],\\n },\\n \\\"nose_coords\\\": {\\\"nose_coords\\\": nose_coord},\\n \\\"mouth_coords\\\": {\\\"mouth_coords\\\": [left_part_mouth, right_part_mouth]},\\n }\\n\\n results[\\\"face_landmarks\\\"] = face_landmarks\\n results[\\\"image\\\"] = image\\n if show_bbox:\\n self.draw_output(results, image, **kwargs)\\n return results\",\n \"def inference(self, img, img_meta, rescale):\\n if not isinstance(img_meta, list):\\n img_meta = img_meta.data[0]\\n assert self.test_cfg.mode in ['slide', 'whole']\\n # if isinstance(img_meta, list):\\n # ori_shape = img_meta[0][0]['ori_shape']\\n # else:\\n # ori_shape = img_meta[0][0]['ori_shape']\\n # assert all(_[0]['ori_shape'] == ori_shape for _ in img_meta.data)\\n if self.test_cfg.mode == 'slide':\\n seg_logit = self.slide_inference(img, img_meta, rescale)\\n else:\\n seg_logit, gen_out = self.whole_inference(img, img_meta, rescale)\\n output = F.softmax(seg_logit, dim=1)\\n flip = img_meta[0]['flip']\\n if flip:\\n flip_direction = img_meta[0]['flip_direction']\\n assert flip_direction in ['horizontal', 'vertical']\\n if flip_direction == 'horizontal':\\n output = output.flip(dims=(3,))\\n gen_out = gen_out.flip(dims=(3,))\\n elif flip_direction == 'vertical':\\n output = output.flip(dims=(2,))\\n gen_out = gen_out.flip(dims=(2,))\\n\\n return output, gen_out\",\n \"def run_inference_on_image(image):\\n if not gfile.Exists(image):\\n tf.logging.fatal('File does not exist %s', image)\\n image_data = gfile.FastGFile(image, 'rb').read()\\n\\n # Creates graph from saved GraphDef.\\n create_graph()\\n\\n with tf.Session() as sess:\\n # Runs the softmax tensor by feeding the image_data as input to the graph.\\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\\n \\n print(\\\"Running inference on image: %s\\\" % os.path.basename(FLAGS.image_file))\\n predictions = sess.run(softmax_tensor,\\n {'DecodeJpeg/contents:0': image_data})\\n predictions = np.squeeze(predictions)\\n\\n # Get indicies of top x predictions\\n top_x = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]\\n # Get list of human readable class labels\\n class_labels = get_label_list()\\n \\n #print results\\n for top_i in top_x: \\n print(class_labels[top_i] + ': %.2f%%' % (predictions[top_i] * 100))\\n print('\\\\n')\",\n \"def inference():\\n inf_dataset = dataset\\n net.eval()\\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\\n \\n num_crop = args.test_crops\\n length = 3\\n if args.modality == 'Flow':\\n length = 10\\n elif args.modality == 'RGBDiff':\\n length = 18\\n \\n # First get the base_out outputs\\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\\n volatile=True)\\n cnt = 0\\n for frames in frames_gen:\\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\\n # frame_batch_size is 4 by default\\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\\n volatile=True)\\n base_out = net(input_var, None, None, None, None)\\n bsc = base_out.view(num_crop, -1, base_out_dim)\\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\\n cnt += bsc.size(1)\\n\\n n_frames = base_output.size(1)\\n assert frame_cnt == n_frames\\n # GLCU\\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\\n gate, glcu_task_pred = net.glcu(step_features)\\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\\n if net.additive_glcu:\\n base_output = base_output + gate\\n else:\\n base_output = base_output * gate\\n\\n # output.shape == [num_frames, 7791]\\n output = torch.zeros((frame_cnt, output_dim)).cuda()\\n cnt = 0\\n for i in range(0, frame_cnt, 4):\\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\\n rst = net.test_fc(base_out)\\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\\n output[cnt: cnt + sc.size(0), :] = sc\\n cnt += sc.size(0)\\n base_output = base_output.mean(dim=0).data\\n\\n # act_scores.shape == [num_proposals, K+1]\\n # comp_scores.shape == [num_proposals, K]\\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\\n\\n # Task Head\\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\\n\\n act_scores = act_scores.data\\n comp_scores = comp_scores.data\\n\\n if reg_scores is not None:\\n reg_scores = reg_scores.view(-1, num_class, 2)\\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\\n\\n torch.cuda.empty_cache() # To empty the cache from previous iterations\\n\\n # perform stpp on scores\\n return ((inf_dataset.video_list[index].id,\\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \\n glcu_task_pred, task_pred),\\n output.cpu().numpy(),\\n base_output.cpu().numpy()))\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\",\n \"def inference(self):\\r\\n\\t\\tfor partition, loader in self.loaders.items():\\r\\n\\t\\t\\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\\r\\n\\t\\t\\t\\tloader)\\r\\n\\t\\t\\tself.preds[partition] = {\\r\\n\\t\\t\\t\\t'tag': tags,\\r\\n\\t\\t\\t\\t'y': y,\\r\\n\\t\\t\\t\\t'y_hat': y_hat,\\r\\n\\t\\t\\t\\t# 'posteriors': post,\\r\\n\\t\\t\\t\\t# 'attentions': attentions\\r\\n\\t\\t\\t}\",\n \"def dump_data(opt):\\n # create repeat label agent and assign it to the specified task\\n agent = RepeatLabelAgent(opt)\\n world = create_task(opt, agent)\\n task = opt.get('task')\\n speaker_0_id = opt.get('speaker_0_id') or f'{task}_as_human'\\n speaker_1_id = opt.get('speaker_1_id') or f'{task}_as_model'\\n if opt['outfile'] is None:\\n outfile = tempfile.mkstemp(\\n prefix='{}_{}_'.format(opt['task'], opt['datatype']), suffix='.txt'\\n )[1]\\n else:\\n outfile = opt['outfile']\\n\\n num_episodes = (\\n world.num_episodes()\\n if opt['num_episodes'] == -1\\n else min(opt['num_episodes'], world.num_episodes())\\n )\\n log_timer = TimeLogger()\\n\\n print(f'[ starting to convert, saving output to {outfile} ]')\\n dialogues = []\\n for _ in range(num_episodes):\\n episode = []\\n episode_done = False\\n while not episode_done:\\n world.parley()\\n acts = world.get_acts()\\n text = acts[0].get('text')\\n split_text = text.split('\\\\n')\\n label = random.choice(\\n acts[0].get('labels', acts[0].pop('eval_labels', None))\\n )\\n if not episode and opt.get('prepended_context'):\\n # first turn\\n context = split_text[:-1]\\n text = split_text[-1]\\n context_turn = [\\n {'text': context, 'episode_done': False, 'id': 'context'}\\n for _ in range(2)\\n ]\\n episode.append(context_turn)\\n turn = [\\n {'text': text, 'episode_done': False, 'id': speaker_0_id},\\n {'text': label, 'episode_done': False, 'id': speaker_1_id},\\n ]\\n episode.append(turn)\\n if acts[0].get('episode_done', False):\\n episode[-1][-1]['episode_done'] = True\\n episode_done = True\\n dialogues.append(episode)\\n\\n if log_timer.time() > opt['log_every_n_secs']:\\n text, _log = log_timer.log(world.total_parleys, world.num_examples())\\n print(text)\\n\\n if world.epoch_done():\\n break\\n\\n Conversations.save_conversations(dialogues, outfile, opt)\",\n \"def inference(config_file, image_file):\\n # Get config\\n FLAGS = Flags(config_file).get()\\n out_charset = load_charset(FLAGS.charset)\\n num_classes = len(out_charset)\\n net = get_network(FLAGS, out_charset)\\n\\n if FLAGS.use_rgb:\\n num_channel = 3\\n mode = cv2.IMREAD_COLOR\\n else:\\n num_channel = 1\\n mode = cv2.IMREAD_GRAYSCALE\\n\\n # Input node\\n image = tf.placeholder(tf.uint8,\\n shape=[None, None, num_channel],\\n name='input_node')\\n\\n # Network\\n proc_image = net.preprocess_image(image, is_train=False)\\n proc_image = tf.expand_dims(proc_image, axis=0)\\n proc_image.set_shape(\\n [None, FLAGS.resize_hw.height, FLAGS.resize_hw.width, num_channel])\\n logits, sequence_length = net.get_logits(proc_image,\\n is_train=False,\\n label=None)\\n prediction, log_prob = net.get_prediction(logits, sequence_length)\\n prediction = tf.sparse_to_dense(sparse_indices=prediction.indices,\\n sparse_values=prediction.values,\\n output_shape=prediction.dense_shape,\\n default_value=num_classes,\\n name='output_node')\\n\\n # Restore\\n restore_model = get_init_trained()\\n sess = tf.Session()\\n restore_model(sess, FLAGS.eval.model_path)\\n\\n # Run\\n img = cv2.imread(image_file, mode)\\n img = np.reshape(img, [img.shape[0], img.shape[1], num_channel])\\n predicted = sess.run(prediction, feed_dict={image: img})\\n string = get_string(predicted[0], out_charset)\\n string = adjust_string(string, FLAGS.eval.lowercase,\\n FLAGS.eval.alphanumeric)\\n print(string)\\n\\n return string\",\n \"def postprocess(self, data):\\n all_predictions, all_nbest_json, scores_diff_json = predictions(self._dev_dataset,\\n data,\\n self._tokenizer)\\n\\n if len(all_nbest_json) == 0 or len(all_nbest_json[0]) == 0:\\n return [{'predicted': '',\\n 'confidence': 0}]\\n\\n return [{'predicted': all_nbest_json[0][0]['text'],\\n 'confidence': all_nbest_json[0][0]['probability']}]\",\n \"def postprocess_wikidiff(\\n output,\\n vocabulary,\\n normalize_fn,\\n is_target=False,\\n example=None,\\n):\\n del is_target\\n inputs = tf_utils.maybe_decode(\\n vocabulary.decode_tf(example[\\\"inputs\\\"]).numpy())\\n targets = tf_utils.maybe_decode(output)\\n normalized_inputs, normalized_targets = normalize_fn(inputs, targets)\\n results = {\\n \\\"inputs\\\":\\n inputs,\\n \\\"targets\\\":\\n targets,\\n \\\"normalized_inputs\\\":\\n normalized_inputs,\\n \\\"normalized_targets\\\":\\n normalized_targets,\\n \\\"generatable_surfaces\\\":\\n json.loads(tf_utils.maybe_decode(example[\\\"generatable_surfaces\\\"])),\\n }\\n return results\",\n \"def _get_inference_output_name(self):\\n inference_output_name = 'output'\\n if len(self['inference_output'].get_shape().as_list()) > 0:\\n inference_output_name = 'inference_output'\\n\\n return inference_output_name\",\n \"def downgrade_output(output):\\n if output[\\\"output_type\\\"] in {\\\"execute_result\\\", \\\"display_data\\\"}:\\n if output[\\\"output_type\\\"] == \\\"execute_result\\\":\\n output[\\\"output_type\\\"] = \\\"pyout\\\"\\n output[\\\"prompt_number\\\"] = output.pop(\\\"execution_count\\\", None)\\n\\n # promote data dict to top-level output namespace\\n data = output.pop(\\\"data\\\", {})\\n if \\\"application/json\\\" in data:\\n data[\\\"application/json\\\"] = json.dumps(data[\\\"application/json\\\"])\\n data = from_mime_key(data)\\n output.update(data)\\n from_mime_key(output.get(\\\"metadata\\\", {}))\\n elif output[\\\"output_type\\\"] == \\\"error\\\":\\n output[\\\"output_type\\\"] = \\\"pyerr\\\"\\n elif output[\\\"output_type\\\"] == \\\"stream\\\":\\n output[\\\"stream\\\"] = output.pop(\\\"name\\\")\\n return output\",\n \"def _massage_raw_pg_output_vals(self):\\n pass\",\n \"def inference(self, image_path_pattern: Text, output_dir: Text, **kwargs):\\n params = copy.deepcopy(self.params)\\n with tf.Session() as sess:\\n # Buid inputs and preprocessing.\\n raw_images, images, scales = build_inputs(image_path_pattern,\\n params['image_size'],\\n params['mean_rgb'],\\n params['stddev_rgb'])\\n if params['data_format'] == 'channels_first':\\n images = tf.transpose(images, [0, 3, 1, 2])\\n # Build model.\\n class_outputs, box_outputs = build_model(self.model_name, images,\\n **self.params)\\n restore_ckpt(\\n sess,\\n self.ckpt_path,\\n ema_decay=self.params['moving_average_decay'],\\n export_ckpt=None)\\n # Build postprocessing.\\n detections_batch = det_post_process(params, class_outputs, box_outputs,\\n scales)\\n predictions = sess.run(detections_batch)\\n # Visualize results.\\n for i, prediction in enumerate(predictions):\\n img = visualize_image_prediction(\\n raw_images[i],\\n prediction,\\n label_map=self.label_map,\\n **kwargs)\\n output_image_path = os.path.join(output_dir, str(i) + '.jpg')\\n Image.fromarray(img).save(output_image_path)\\n print('writing file to %s' % output_image_path)\\n\\n return predictions\",\n \"def getResult(f, opt, model_name):\\n tacc = []\\n vacc = []\\n opt.write('======= ' + model_name + ' =======\\\\n')\\n for l in f.readlines():\\n if l.startswith('#'):\\n opt.write(l[2:] + '\\\\n')\\n elif l.startswith('Epoch'):\\n continue\\n else:\\n data = l.split(' - ')\\n tacc.append(float(data[2].split(': ')[1]))\\n vacc.append(float(data[4].split(': ')[1]))\\n return np.array(tacc), np.array(vacc)\",\n \"def test_inference():\\n\\n input_path = os.path.join(MAIN_PATH, \\\"data/test_cases/\\\")\\n output_path = os.path.join(MAIN_PATH, \\\"data/test_results/\\\")\\n\\n nifti_files = len(os.listdir(input_path))\\n\\n # remove existing files in the output path\\n for file in os.listdir(output_path):\\n filepath = output_path + file\\n if \\\"test_results\\\" in filepath:\\n os.remove(filepath)\\n\\n # run\\n bpreg_inference(input_path, output_path, plot=True)\\n\\n # Test creation of json files\\n json_output_files = [f for f in os.listdir(output_path) if f.endswith(\\\".json\\\")]\\n assert len(json_output_files) == nifti_files\\n\\n # Test tags\\n with open(output_path + json_output_files[0]) as f:\\n x = json.load(f)\\n\\n assert \\\"settings\\\" in x.keys()\\n assert \\\"cleaned slice scores\\\" in x.keys()\\n assert \\\"unprocessed slice scores\\\" in x.keys()\\n assert \\\"body part examined\\\" in x.keys()\\n assert \\\"body part examined tag\\\" in x.keys()\\n\\n # Check if readme file is saved.\\n assert \\\"README.md\\\" in os.listdir(output_path)\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n for key, val in predictions.items():\\n predictions[key] = val.numpy()\\n\\n for key, val in expected.items():\\n expected[key] = val.numpy()\\n\\n return predictions, expected\",\n \"def convert_outputs(self):\\n self.out('relaxed_structure', self.ctx.workchain.outputs.output_structure)\\n self.out('total_energy', get_total_energy(self.ctx.workchain.outputs.output_parameters))\\n self.out('forces', get_forces_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\\n self.out('stress', get_stress_from_trajectory(self.ctx.workchain.outputs.output_trajectory))\",\n \"def postprocessor_two_column(answer, example=None, is_target=False):\\n return tf.compat.as_text(answer)\",\n \"def inference_graph(self, input_data):\\n probabilities = []\\n for i in range(self.params.num_trees):\\n with tf.device(self.device_assigner.get_device(i)):\\n tree_data = input_data\\n if self.params.bagged_features:\\n tree_data = self._bag_features(i, input_data)\\n probabilities.append(self.trees[i].inference_graph(tree_data))\\n with tf.device(self.device_assigner.get_device(0)):\\n all_predict = tf.pack(probabilities)\\n return tf.reduce_sum(all_predict, 0) / self.params.num_trees\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74513173","0.63642395","0.63103646","0.6209664","0.6149981","0.61384505","0.61171323","0.6045562","0.6036395","0.59836096","0.5979635","0.58721167","0.5831833","0.58255285","0.5821647","0.58004344","0.5789193","0.5777875","0.5736013","0.572711","0.5723454","0.57010293","0.5606525","0.5592771","0.5572294","0.5556432","0.5518881","0.5515136","0.5514629","0.5503438","0.54707754","0.5456623","0.5456606","0.54527557","0.5425077","0.53878117","0.5385389","0.5380521","0.5380296","0.5376907","0.536772","0.53415465","0.5340321","0.5337109","0.53365934","0.53318596","0.5319701","0.5313502","0.53121746","0.5284974","0.5283476","0.527694","0.52675045","0.52612764","0.52604115","0.52236485","0.5220649","0.521698","0.52015823","0.5201314","0.51918334","0.517904","0.51626384","0.51446044","0.5101186","0.50918096","0.50869834","0.50868","0.50725085","0.5072201","0.5071577","0.50715154","0.50693446","0.5068782","0.50682515","0.50655437","0.50639826","0.5059725","0.504811","0.5047083","0.5045698","0.50439936","0.50310606","0.50308037","0.50303507","0.5019875","0.50185335","0.5013983","0.50128186","0.5011266","0.50012344","0.49988493","0.49936533","0.49841067","0.49835986","0.49815512","0.49787006","0.49760023","0.49712557","0.49679387"],"string":"[\n \"0.74513173\",\n \"0.63642395\",\n \"0.63103646\",\n \"0.6209664\",\n \"0.6149981\",\n \"0.61384505\",\n \"0.61171323\",\n \"0.6045562\",\n \"0.6036395\",\n \"0.59836096\",\n \"0.5979635\",\n \"0.58721167\",\n \"0.5831833\",\n \"0.58255285\",\n \"0.5821647\",\n \"0.58004344\",\n \"0.5789193\",\n \"0.5777875\",\n \"0.5736013\",\n \"0.572711\",\n \"0.5723454\",\n \"0.57010293\",\n \"0.5606525\",\n \"0.5592771\",\n \"0.5572294\",\n \"0.5556432\",\n \"0.5518881\",\n \"0.5515136\",\n \"0.5514629\",\n \"0.5503438\",\n \"0.54707754\",\n \"0.5456623\",\n \"0.5456606\",\n \"0.54527557\",\n \"0.5425077\",\n \"0.53878117\",\n \"0.5385389\",\n \"0.5380521\",\n \"0.5380296\",\n \"0.5376907\",\n \"0.536772\",\n \"0.53415465\",\n \"0.5340321\",\n \"0.5337109\",\n \"0.53365934\",\n \"0.53318596\",\n \"0.5319701\",\n \"0.5313502\",\n \"0.53121746\",\n \"0.5284974\",\n \"0.5283476\",\n \"0.527694\",\n \"0.52675045\",\n \"0.52612764\",\n \"0.52604115\",\n \"0.52236485\",\n \"0.5220649\",\n \"0.521698\",\n \"0.52015823\",\n \"0.5201314\",\n \"0.51918334\",\n \"0.517904\",\n \"0.51626384\",\n \"0.51446044\",\n \"0.5101186\",\n \"0.50918096\",\n \"0.50869834\",\n \"0.50868\",\n \"0.50725085\",\n \"0.5072201\",\n \"0.5071577\",\n \"0.50715154\",\n \"0.50693446\",\n \"0.5068782\",\n \"0.50682515\",\n \"0.50655437\",\n \"0.50639826\",\n \"0.5059725\",\n \"0.504811\",\n \"0.5047083\",\n \"0.5045698\",\n \"0.50439936\",\n \"0.50310606\",\n \"0.50308037\",\n \"0.50303507\",\n \"0.5019875\",\n \"0.50185335\",\n \"0.5013983\",\n \"0.50128186\",\n \"0.5011266\",\n \"0.50012344\",\n \"0.49988493\",\n \"0.49936533\",\n \"0.49841067\",\n \"0.49835986\",\n \"0.49815512\",\n \"0.49787006\",\n \"0.49760023\",\n \"0.49712557\",\n \"0.49679387\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6112819"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":93079,"cells":{"query":{"kind":"string","value":"Newton's Method. f(y) = y2 x = 0 f(y1) = f(y0) + dy f'(y0) = y0 y0 x + (y1 y0) 2 y0 = 0 y1 = (y0 + x / y0) / 2"},"document":{"kind":"string","value":"def mySqrt(self, x: int) -> int:\n if x == 0:\n return 0\n d = 0.1\n y = x / 2\n z = (y + x/y) / 2\n e = abs(z-y)\n while e > d:\n y = z\n z = (y + x/y) / 2\n e = abs(z - y)\n return int(z)"},"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 newton(f, x0, Df, tol=1e-5, maxiter=15, alpha=1.):\n raise NotImplementedError(\"Problem 1 Incomplete\")","def test_newton():\n\n f = lambda x: x**2 + np.sin(5*x)\n df = lambda x: 2*x + 5*np.cos(5*x)\n ddf = lambda x: 2 + 0,-25*np.sin(5*x)\n\n\n print newtonsMethod(f,df,ddf, 0, niter = 100)","def newton_update(f, df):\n def update(x):\n return x - f(x) / df(x)\n return update","def newton(f, x0, dx, eps=1e-10):\n # Initialization\n globvar.ncalls = 0\n x = np.copy(x0)\n n = len(x)\n J = np.zeros((n, n), dtype='float64')\n fx = f(x)\n\n # Begin root search\n while True:\n globvar.ncalls += 1\n\n # Fill the Jacobian matrix\n for j in range(n):\n x[j] += dx[j]\n df = f(x) - fx\n\n for i in range(n):\n J[i, j] = df[i] / dx[j]\n\n x[j] -= dx[j]\n\n # Decompose and solve using Given's rotations\n decomp(J)\n Dx = -fx\n solve(J, Dx)\n\n # Begin backtracking linesearch\n lamb = 2.0\n while True: \n lamb /= 2\n y = x + Dx * lamb\n fy = f(y)\n\n fynorm = np.linalg.norm(fy)\n fxnorm = np.linalg.norm(fx)\n\n if (fynorm < (1 - lamb / 2) * fxnorm) or (lamb < (1 / 128.0)):\n break\n\n # Save latest approximation\n x = y\n fx = fy\n\n Dxnorm = np.linalg.norm(Dx)\n fxnorm = np.linalg.norm(fx)\n dxnorm = np.linalg.norm(dx)\n if Dxnorm < dxnorm or fxnorm < eps:\n break\n\n return x","def my_Newton( fct, df_dx, x0):\r\n xn = float(x0)\r\n eps = 1e-5\r\n N = 20\r\n i = 0\r\n while abs( fct( xn**(i + 1)) - fct( xn**i)) > eps and i < N:\r\n x_next = xn - fct(xn)/df_dx(xn)\r\n print( i, 'fct value', abs( fct(xn)), x_next)\r\n xn = x_next\r\n i += 1\r\n if abs( fct( xn)) < eps:\r\n return x_next\r\n else: #solution did not converge\r\n return np.nan","def halley_newton ( fun , ## the function \n x , ## x \n deriv1 , ## the first derivative \n deriv2 = None , ## the second derivative\n fx = None , ## value of fun(x)\n args = () ) : ## additional arguments for function calls\n \n ## newton corrections\n d1 = float ( deriv1 ( x , *args ) ) \n fx = float ( fun ( x , *args ) ) if fx is None else fx \n \n if d1 : rn = fx / d1\n else : return None ## error here! \n \n ## make corrections: Halley's steps\n if deriv2 : \n d2 = float ( deriv2 ( x , *args ) )\n if d2 : rn /= ( 1.0 - 0.5 * rn * d2 / d1 ) ## Halley's correction \n \n return x - rn ## Newton/Halley's iteration","def newtons_method_1d(f, df_dx, x0, tol):\n # begin solution\n x = x0\n while abs(f(x)) > tol:\n x -= f(x) / df_dx(x)\n return x\n # end solution","def newton_raphson(f,x0,iterations): \n current = x0\n fdash = differentiate_polynomial(f)\n print(fdash)\n for i in range(iterations): \n current = current - evaluate_polynomial(f,current)/evaluate_polynomial(fdash,current)\n return current","def my_Newton(fct, df_dx, x0):\r\n xn = float(x0)\r\n eps = 1e-5\r\n N = 20\r\n i = 0\r\n while abs(fct (xn)) > eps and i < N:\r\n x_next = xn - fct(xn)/df_dx(xn)\r\n print(i , 'fct_value', abs(fct(xn)), x_next)\r\n xn = x_next\r\n i += 1\r\n if abs(fct(xn)) < eps:\r\n return x_next\r\n else: #solution did not converge\r\n return np.nan","def newton_method(f, x_init = 0, epsilon = 1e-10):\n prev_value = x_init + 2 * epsilon\n value = x_init\n\n iterations = 0\n while abs(prev_value - value) > epsilon:\n prev_value = value\n\n f_dash = derivative(f, value)\n value = value - f(value) / f_dash\n\n iterations += 1\n\n print(f\"Newton Method converged in {iterations} iterations\")\n\n return value","def newtonsMethod(f, df, ddf, x, niter=10):\n\n points = []\n\n for i in xrange(niter):\n point = np.dot(-la.inv(ddf(x)), (df(x)))\n\n slope = np.dot(df(x), point)\n\n a = backtracking(f, slope, x, point)\n \n #update point\n x_k = x + a*point\n points.append(x_k)\n x = x_k\n\n return points","def newtonsMethod(self, x, a):\n return x - a * (self._f(x) / self._df(x))","def newton_method_vector(f, x_init, epsilon = 1e-10):\n prev_value = x_init + 2 * epsilon\n value = x_init\n\n iterations = 0\n while np.all(np.abs(prev_value - value)) > epsilon:\n prev_value = value\n\n j = jacobian(f, value)\n value = value - np.dot(np.linalg.pinv(j), f(value))\n\n iterations += 1\n\n print(f\"Newton Method converged in {iterations} iterations\")\n\n return value","def NewtonMethod(f, df, x=0.75, tol=1e-10):\n\tstart = time()\n\terror = tol + 1\n\t\n\ti = 0\n\terrs = []\n\n\twhile error > tol:\n\t\terrs.append(error)\n\n\t\tx_temp = x\n\t\tx = x - f(x) / df(x)\n\t\terror = np.abs(x-x_temp)\n\t\ti = i+1\n\tend = time()\n\treturn x, (end-start), i","def newton(n):\n x = n\n y = (x + 1) // 2\n while y < x:\n x = y\n y = (x + n // x) // 2\n return x","def newton_method(f, x, Ep, step):\n\n while True:\n step = step + 1\n # print(\"bnd1:=\",bnd1)\n h = f(x) / derivative(f, x)\n x = x - h\n if (decide(abs(h) <= Ep)):\n break\n # print(\"Root in Approximation: \",bnd1)\n return step","def newton(f, f_prime, x0, n):\n approximations = [x0]\n\n xnm1 = x0\n for i in range(1, n):\n xn = xnm1 - f(xnm1) / f_prime(xnm1)\n approximations.append(xn)\n xnm1 = xn\n\n for n in range(len(approximations)):\n print(f'Approximation {n + 1}: {approximations[n]:<17.13f} Exact: {pi:<17.13f} Difference: {abs(pi - approximations[n]):.13e}')","def quasi_newtons_method(f, initial_guess, max_iter = 10000, method = 'BFGS', tol = 1e-12):\n \n if method not in ['BFGS', 'DFP', 'Broyden']:\n raise Exception(\"Not a valid method.\")\n x = initial_guess\n H = np.identity(len(x))\n for i in range(max_iter):\n x_vector = ad.create_vector('x', x)\n fn_at_x = f(x_vector)\n gradient = fn_at_x.getGradient(['x{}'.format(i) for i in range(1, len(x) + 1)])\n\n p = -H @ gradient\n \n alpha = line_search(f, x, p)\n delta_x = alpha * p\n\n x = x + delta_x\n x_vector2 = ad.create_vector('x', x)\n fn_at_x2 = f(x_vector2)\n gradient2 = fn_at_x2.getGradient(['x{}'.format(i) for i in range(1, len(x) + 1)])\n if np.sqrt(np.abs(gradient2).sum()) < tol:\n break\n y = (gradient2 - gradient).reshape(-1, 1)\n delta_x = delta_x.reshape(-1, 1)\n if method == 'BFGS':\n H = (np.identity(len(H)) - (delta_x @ y.T) / (y.T @ delta_x)) @ H \\\n @ (np.identity(len(H)) - (y @ delta_x.T) / (y.T @ delta_x)) + (delta_x @ delta_x.T) / (y.T @ delta_x)\n elif method == 'DFP':\n H = H + (delta_x @ delta_x.T) / (delta_x.T @ y) - (H @ y @ y.T @ H) / (y.T @ H @ y)\n elif method == 'Broyden':\n H = H + ((delta_x - H @ y) @ delta_x.T @ H) / (delta_x.T @ H @ y)\n\n return (x, i + 1)","def newton_quad(f, x0, dx, eps=1e-10):\n # Initialization\n globvar.ncalls = 0\n x = np.copy(x0)\n n = len(x)\n J = np.zeros((n, n), dtype='float64')\n fx = f(x)\n\n # Begin root search\n while True:\n globvar.ncalls += 1\n\n # Fill the Jacobian matrix\n for j in range(n):\n x[j] += dx[j]\n df = f(x) - fx\n\n for i in range(n):\n J[i, j] = df[i] / dx[j]\n\n x[j] -= dx[j]\n\n # Decompose and solve using Given's rotations\n decomp(J)\n Dx = -fx\n solve(J, Dx)\n\n # Begin quadratic linesearch \n lamb = 1.0\n y = x + Dx * lamb\n fy = f(y)\n\n fxnorm = np.linalg.norm(fx)\n fynorm = np.linalg.norm(fy)\n\n # Define the known values of the minimization function (Eq. 9)\n g0 = 0.5 * fxnorm ** 2\n dg0 = - fxnorm ** 2\n\n while (fynorm > (1 - lamb / 2) * fxnorm) and (lamb > (1 / 128.0)):\n glamb = 0.5 * fynorm ** 2\n c = (glamb - g0 - dg0 * lamb) / (lamb ** 2)\n\n # Update step\n lamb = - dg0 / (2 * c)\n y = x + Dx * lamb\n fy = f(y)\n fynorm = np.linalg.norm(fy)\n\n # Save latest approximation\n x = y\n fx = fy\n\n Dxnorm = np.linalg.norm(Dx)\n dxnorm = np.linalg.norm(dx)\n if Dxnorm < dxnorm or fxnorm < eps:\n break\n\n return x","def newton_jacobian(f, x0, Jf, eps=1e-10):\n # Initialization\n globvar.ncalls = 0\n x = np.copy(x0)\n n = len(x)\n J = np.zeros((n, n), dtype='float64')\n fx = f(x)\n\n # Begin root search\n while True:\n globvar.ncalls += 1\n\n # Calculate Jacobian\n J = Jf(x)\n\n # Decompose and solve using Given's rotations\n decomp(J)\n Dx = -fx\n solve(J, Dx)\n\n # Begin backtracking linesearch\n lamb = 2.0\n while True: \n lamb /= 2\n y = x + Dx * lamb\n fy = f(y)\n\n fynorm = np.linalg.norm(fy)\n fxnorm = np.linalg.norm(fx)\n\n if (fynorm < (1 - lamb / 2) * fxnorm) or (lamb < (1 / 128.0)):\n break\n\n # Save latest approximation\n x = y\n fx = fy\n\n fxnorm = np.linalg.norm(fx)\n if fxnorm < eps:\n break\n\n return x","def newton_direction(\n x,\n problem: MinimizationProblem,\n prev_state: IterationState):\n\n hessian = problem.calc_hessian_at(x)\n grad = problem.calc_gradient_at(x)\n\n p = -solve(hessian, grad,\n problem.settings.cholesky_linear_systems_solver_enabled,\n problem.settings.gaussian_elimination_linear_systems_solver_enabled)\n\n return IterationState(x, p, grad)","def newton(f, x0, Df, tol=1e-5, maxiter=15, alpha=1.):\r\n #initialize variables\r\n iter = 0\r\n xk = x0\r\n change = tol+1\r\n #perform newton's method until maxiter hit or under tolerance\r\n #if x is in R\r\n if np.isscalar(x0):\r\n while iter < maxiter and change > tol:\r\n iter += 1\r\n xk1 = xk\r\n xk = xk - alpha*f(xk)/Df(xk)\r\n change = abs(xk-xk1)\r\n #if x is in Rn\r\n else:\r\n while iter < maxiter and change > tol:\r\n iter += 1\r\n xk1 = xk\r\n D = Df(xk)\r\n #make sure the matrix isn't singular\r\n if la.det(D)==0:\r\n break\r\n yk = la.solve(D,f(xk))\r\n xk = xk - alpha*yk\r\n change = la.norm(xk-xk1)\r\n #check if method converged\r\n if change > tol:\r\n conv = False\r\n else:\r\n conv = True\r\n return xk,conv,iter","def newton_iteration(f: Callable, df: Callable, eps: float, x0: float = None, a: float = None, b: float = None,\n weight: float = 0.9, display: bool = False, max_iterations: int = 100) -> float:\n x = np.inf\n if x0 is None:\n x0 = (a + b) / 2\n if a is not None and b is not None and a == b:\n return a\n x_next = x0\n iterations = 0\n while abs(x - x_next) > eps and iterations < max_iterations:\n iterations += 1\n x = x_next\n\n if display:\n import matplotlib.pyplot as plt\n xx0 = a or x-1\n xx1 = b or x+1\n xx = np.linspace(xx0, xx1, 100)\n yy = np.array(list(map(f, xx)))\n plt.plot(xx, yy)\n plt.axvline(x=x)\n plt.show()\n\n f_x = f(x)\n try:\n df_x = df(x)\n except ZeroDivisionError:\n df_x = (f_x - f(x-eps))/eps\n if df_x != 0:\n x_next = x - f_x / df_x\n\n if a is not None and x_next < a:\n x_next = weight * a + (1 - weight) * x\n elif b is not None and x_next > b:\n x_next = weight * b + (1 - weight) * x\n\n if a is not None and x_next < a:\n x_next = a\n if b is not None and x_next > b:\n x_next = b\n\n return x_next","def newton1d(f, df, ddf, x, niter=10):\n for i in xrange(niter):\n x_new = x - df(x)/ddf(x)\n x = x_new\n return x","def newtons_method(f, initial_guess, max_iter = 1000, method = 'exact', tol =1e-12):\n\n if method not in ['inverse', 'exact', 'gmres', 'gmres_action']:\n raise Exception(\"Not a valid method.\")\n if len(f(initial_guess)) != len(initial_guess):\n raise Exception('Output dimension of f should be the same as the input dimension of f.')\n if method == 'gmres_action':\n return _newtons_method_gmres_action(f, initial_guess, max_iter, tol)\n x0 = ad.create_vector('x0', initial_guess)\n for iter_num in range(max_iter):\n fn = np.array(f(x0)); #need convert the list/array that is passed back from function, so downstream autodiff functions for vectors work properly\n jacob = ad.get_jacobian(fn, ['x0{}'.format(i) for i in range(1, len(fn) + 1)])\n if method == 'inverse':\n step = np.linalg.inv(-jacob).dot(ad.get_value(fn))\n if method == 'exact':\n step = np.linalg.solve(-jacob, ad.get_value(fn))\n elif method == 'gmres':\n step, _ = gmres(jacob, -ad.get_value(fn), tol = tol, atol = 'legacy')\n xnext = x0 + step\n \n #check if we have converged\n if np.all(np.abs(ad.get_value(xnext) - ad.get_value(x0)) < tol):\n return (ad.get_value(xnext), iter_num + 1);\n \n #update x0 because we have not converged yet\n x0 = xnext\n \n raise RuntimeError(\"Failed to converge after {0} iterations, value is {1}\".format(max_iter, ad.get_value(x0)) );","def newton1d(f, df, ddf, x, niter=10):\n\n x_0 = x\n x_k = x\n\n for i in xrange(niter):\n x_k1 = x_k - df(x_k)/ddf(x_k)\n x_k = x_k1\n\n return x_k","def newton_1d(f, df, ddf, x, n=10):\n ret = [x]\n xk = x\n for i in range(n):\n if(ddf(xk) == 0):\n break\n xk1 = xk - df(xk) / ddf(xk)\n xk = xk1\n ret.append(xk)\n return ret","def NewtonRaphson(z_ini, f, fprime, tol):\r\n z_current = z_ini\r\n while np.linalg.norm(f(z_current)) > tol:\r\n hess = fprime(z_current)\r\n inv_hess = np.linalg.solve(hess, np.eye(hess.shape[0]))\r\n z_new = z_current - inv_hess.dot(f(z_current))\r\n z_current = z_new\r\n return z_current","def _newton_update(func):\n return lambda x: x - func[0](x) / func[1](x)","def newton_divided_difference(x, y):\n\n n = x.size\n q = np.zeros((n, n - 1))\n # Insert 'y' in the first column of the matrix 'q'\n q = np.concatenate((y[:, None], q), axis=1)\n\n for i in range(1, n):\n for j in range(1, i + 1):\n q[i, j] = (q[i, j - 1] - q[i - 1, j - 1]) / (x[i] - x[i - j])\n\n # Copy the diagonal values of the matrix q to the vector f\n f = np.zeros(n)\n for i in range(0, n):\n f[i] = q[i, i]\n\n # Prints the polynomial\n print(\"The polynomial is:\")\n print(\"p(x)={:+.4f}\".format(f[0]), end=\"\")\n for i in range(1, n):\n print(\"{:+.4f}\".format(f[i]), end=\"\")\n for j in range(1, i + 1):\n print(\"(x{:+.4f})\".format(x[j] * -1), end=\"\")\n print(\"\")\n\n return [f]","def newton_decent_directions(function, func_derivative, func_hessian, xk, A, P, b, q, t):\r\n # calculate steepest decent direction\r\n newton_dir = -np.dot(np.linalg.inv(func_hessian(x=xk, A=A, P=P, b=b, q=q, t=t)), func_derivative(x=xk, A=A, P=P, b=b, q=q, t=t))\r\n\r\n return newton_dir","def newtonraphson(self,g_temp,var_init):\n n_step=0\n error=np.linalg.norm(self.evaluate(var_init,g_temp))\n\n while (error > 1e-12 and n_step < 50):\n #Improve solution while error is too large and the number of steps does not exceed a limit\n J_inv=np.linalg.pinv(self.jacobian(var_init,g_temp))\n var_new=var_init-np.dot(J_inv,self.evaluate(var_init,g_temp))\n error=np.linalg.norm(self.evaluate(var_new,g_temp))\n var_init=var_new\n n_step+=1\n\n return var_init","def Newton(self, newton=True, eps=0.0000001):\n x_new=np.zeros(2)\n x_old=np.array([self.x_init,self.y_init])\n #eps=10.0**(-5)\n delta=10\n count=0\n if(newton):\n while(True):\n count+=1\n invJacobi=self.secJacobian(x_old)\n if(type(invJacobi)==type(0)):##check that the jacobian is not singular\n return x_new.tolist()\n part2=np.dot(invJacobi,np.array(self.derFunc(x_old)))\n\n x_new[0]=x_old[0]-part2[0]\n x_new[1]=x_old[1]-part2[1]\n if(abs(x_new[0]-x_old[0])>abs(x_new[1]-x_old[1])):\n delta=abs(x_new[0]-x_old[0])\n else:\n delta=abs(x_new[1]-x_old[1])\n\n x_old[0]=x_new[0]\n x_old[1]=x_new[1]\n print \"printing x\",x_new\n if(count>=self.step or eps>=delta):\n return x_new.tolist()\n \n \n else:\n while(True):\n count+=1\n invJacobi=self.secJacobian(x_old)\n if(type(invJacobi)==type(0)):##check that the jacobian is not singular\n return x_new.tolist()\n part2=np.dot(invJacobi,np.array(self.derFunc(x_old)))\n \n x_new[0]=x_old[0]-part2[0]\n x_new[1]=x_old[1]-part2[1]\n \n if(abs(x_new[0]-x_old[0])>abs(x_new[1]-x_old[1])):\n delta=abs(x_new[0]-x_old[0])\n else:\n delta=abs(x_new[1]-x_old[1])\n \n x_old[0]=x_new[0]\n x_old[1]=x_new[1]\n print \"printing x\", x_new\n if(count>=self.step or eps>=delta):\n return x_new.tolist()","def newton(flogl, start, fgrad, fhess, maxiter):\r\n warn = 0\r\n iteration = 0\r\n par_hat0 = start\r\n m = 1\r\n while (iteration < maxiter and m >= 1e-04):\r\n H = -la.inv(fhess(par_hat0))\r\n g = fgrad(par_hat0).reshape(start.shape)\r\n Hg = np.dot(H, g)\r\n par_hat0 = par_hat0 + Hg\r\n iteration += 1\r\n m = np.dot(g.T, Hg)\r\n if iteration == maxiter:\r\n warn = 1\r\n logl = flogl(par_hat0)\r\n return (par_hat0, logl, warn)","def newtonJacobian(self,r):\n #x_vec=np.array(r)\n x=r[0]\n y=r[1]\n jacobi=np.zeros([2,2], float)\n \n \n jacobi[0][0]=(4.0*(self.x_0-x)**2.0-2.0)*self.sfunc(x,y)\n jacobi[1][1]=(4.0*(self.y_0-y)**2.0-2.0)*self.sfunc(x,y)\n jacobi[1][0]=4.0*(self.x_0-x)*(self.y_0-y)*self.sfunc(x,y)\n jacobi[0][1]=jacobi[1][0]\n #print \"newton jacobian is \",jacobi\n try:\n return mat.inv(jacobi)\n except:\n print \"singular jacobi not invertable\"\n return 0","def test_newton_rhapson(testFunctions, tol, printFlag): \n pass","def _compute_newton_step(lambdas, p_norm, w_norm):\n return lambdas.candidate + (p_norm / w_norm) ** 2 * (p_norm - 1)","def newton(backward_differences, max_num_iters, newton_coefficient, ode_fn_vec,\n order, step_size, time, tol, unitary, upper):\n initial_guess = tf.reduce_sum(\n tf1.where(\n tf.range(MAX_ORDER + 1) <= order,\n backward_differences[:MAX_ORDER + 1],\n tf.zeros_like(backward_differences)[:MAX_ORDER + 1]),\n axis=0)\n\n np_dtype = np_dtype = dtype_util.as_numpy_dtype(backward_differences.dtype)\n\n rhs_constant_term = newton_coefficient * tf.reduce_sum(\n tf1.where(\n tf.range(1, MAX_ORDER + 1) <= order,\n RECIPROCAL_SUMS[1:, np.newaxis].astype(np_dtype) *\n backward_differences[1:MAX_ORDER + 1],\n tf.zeros_like(backward_differences)[1:MAX_ORDER + 1]),\n axis=0)\n\n next_time = time + step_size\n step_size_cast = tf.cast(step_size, backward_differences.dtype)\n real_dtype = tf.abs(backward_differences).dtype\n\n def newton_body(iterand):\n \"\"\"Performs one iteration of Newton's method.\"\"\"\n next_backward_difference = iterand.next_backward_difference\n next_state_vec = iterand.next_state_vec\n\n rhs = newton_coefficient * step_size_cast * ode_fn_vec(\n next_time,\n next_state_vec) - rhs_constant_term - next_backward_difference\n delta = tf.squeeze(\n tf.linalg.triangular_solve(\n upper,\n tf.matmul(tf.transpose(unitary), rhs[:, tf.newaxis]),\n lower=False))\n num_iters = iterand.num_iters + 1\n\n next_backward_difference += delta\n next_state_vec += delta\n\n delta_norm = tf.cast(tf.norm(delta), real_dtype)\n lipschitz_const = delta_norm / iterand.prev_delta_norm\n\n # Stop if method has converged.\n approx_dist_to_sol = lipschitz_const / (1. - lipschitz_const) * delta_norm\n close_to_sol = approx_dist_to_sol < tol\n delta_norm_is_zero = tf.equal(delta_norm, tf.constant(0., dtype=real_dtype))\n converged = close_to_sol | delta_norm_is_zero\n finished = converged\n\n # Stop if any of the following conditions are met:\n # (A) We have hit the maximum number of iterations.\n # (B) The method is converging too slowly.\n # (C) The method is not expected to converge.\n too_slow = lipschitz_const > 1.\n finished = finished | too_slow\n if max_num_iters is not None:\n too_many_iters = tf.equal(num_iters, max_num_iters)\n num_iters_left = max_num_iters - num_iters\n num_iters_left_cast = tf.cast(num_iters_left, real_dtype)\n wont_converge = (\n approx_dist_to_sol * lipschitz_const**num_iters_left_cast > tol)\n finished = finished | too_many_iters | wont_converge\n\n return [\n _NewtonIterand(\n converged=converged,\n finished=finished,\n next_backward_difference=next_backward_difference,\n next_state_vec=next_state_vec,\n num_iters=num_iters,\n prev_delta_norm=delta_norm)\n ]\n\n iterand = _NewtonIterand(\n converged=False,\n finished=False,\n next_backward_difference=tf.zeros_like(initial_guess),\n next_state_vec=tf.identity(initial_guess),\n num_iters=0,\n prev_delta_norm=tf.constant(np.array(-0.), dtype=real_dtype))\n [iterand] = tf.while_loop(lambda iterand: tf.logical_not(iterand.finished),\n newton_body, [iterand])\n return (iterand.converged, iterand.next_backward_difference,\n iterand.next_state_vec, iterand.num_iters)","def newton_restart(fn, grad_fn, x_0, max_iters=20):\n y_i = fn(x_0)\n x_i = x_0\n i = 0\n while torch.abs(y_i) > 1e-6:\n i = i + 1\n grad_i = grad_fn(x_i)\n x_i = x_i - y_i / grad_i\n y_i = fn(x_i)\n\n if i == max_iters:\n return None\n\n return x_i","def Pol_Newton_un_punto(x,datos_x,datos_y):\n n = datos_x.shape[0]\n matriz=np.ones([n,n])\n for j in range(n):\n for i in range(n):\n if j>i:\n matriz[i][j]=0\n else:\n producto=1\n for k in range(j):\n producto=producto*(datos_x[i]-datos_x[k])\n matriz[i][j]=producto\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\n x1 = descompo_LU(matriz,datos_y1)\n prod=np.zeros(x1.shape[0])\n for i in range(n):\n if i==0:\n prod[i]=1\n else: \n prod[i]=prod[i-1]*(x-datos_x[i-1])\n solucion=x1@prod\n return solucion","def newtona(f, Df, x_0, M, epsilon):\n xn = []\n v = f(x_0)\n k = 1\n\n while k<M:\n xn.append(x_0)\n if abs(v) < epsilon: #warunek pierwszy\n break\n\n x_1 = x_0 - v/Df(x_0) #wzor metody iteracyjnej newtona\n v = f(x_1)\n\n if abs(x_1 - x_0) < epsilon: #warunek drugi\n break\n x_0 = x_1\n k=k+1\n\n return(x_0, xn)","def Newton_system(F, J, cst, x, max_iter=100, eps=1e-4):\n F_value = F(cst, x)\n F_norm = np.linalg.norm(F_value, ord=2) # l2 norm of vector\n iteration_counter = 0\n while abs(F_norm) > eps and iteration_counter < max_iter:\n try:\n delta = np.linalg.solve(J(cst, x), -F_value)\n except LinAlgError:\n print(\"Singular matrix in np.linalg.solve, after \", iteration_counter, \" iterations.\")\n return x, -1\n else:\n x = x + delta\n F_value = F(cst, x)\n F_norm = np.linalg.norm(F_value, ord=2)\n iteration_counter += 1\n\n # Here, either a solution is found, or too many iterations\n if abs(F_norm) > eps:\n iteration_counter = -1\n return x, iteration_counter","def test_newton_rhapson_system(testFunctions, tol, printFlag): \n pass","def root_finding_newton_previously(fun, J, x, eps, max_iter, args):\n F_value = fun(x, args)\n F_value_ = F_value.reshape((-1,1))\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\n iteration_counter = 0\n while abs(F_norm) > eps and iteration_counter < max_iter:\n delta = np.linalg.solve(J(x, args), -F_value)\n x = x + delta\n F_value = fun(x, args)\n F_value_ = F_value.reshape((-1,1))\n F_norm = np.linalg.norm(F_value, 2)\n iteration_counter += 1\n\n # Here, either a solution is found, or too many iterations\n if abs(F_norm) > eps:\n iteration_counter = -1\n raise ValueError('Maximum iteration reached in newton root finding!')\n return x, iteration_counter","def root_finding_newton_previously(fun, J, x, eps, max_iter, args):\n F_value = fun(x, args)\n # F_value_ = F_value.reshape((-1, 1))\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\n iteration_counter = 0\n while abs(F_norm) > eps and iteration_counter < max_iter:\n delta = np.linalg.solve(J(x, args), -F_value)\n x = x + delta\n F_value = fun(x, args)\n # F_value_ = F_value.reshape((-1, 1))\n F_norm = np.linalg.norm(F_value, 2)\n iteration_counter += 1\n\n # Here, either a solution is found, or too many iterations\n if abs(F_norm) > eps:\n iteration_counter = -1\n raise ValueError(\"Maximum iteration reached in newton root finding!\")\n return x, iteration_counter","def Pol_Newton(x,datos_x,datos_y):\n puntos=[]\n for p in x:\n n = datos_x.shape[0]\n matriz=np.ones([n,n])\n for j in range(n):\n for i in range(n):\n if j>i:\n matriz[i][j]=0\n else:\n producto=1\n for k in range(j):\n producto=producto*(datos_x[i]-datos_x[k])\n matriz[i][j]=producto\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\n x1 = descompo_LU(matriz,datos_y1)\n prod=np.zeros(x1.shape[0])\n for i in range(n):\n if i==0:\n prod[i]=1\n else: \n prod[i]=prod[i-1]*(p-datos_x[i-1])\n solucion=x1@prod\n puntos.append(solucion)\n puntos=np.array(puntos)\n return puntos","def ret_f(t,y):\n\n f = np.zeros(3)\n f[0] = 77.27*(y(1) - y(0)*y(1)+ y(0)-8.375e-6*y(0)*y(0))\n f[1] = (1.0/77.27)*(-y(1)-y(0)*y(1)+y(2))\n f[2] = 0.161*(y(0)-y(2))\n\n return f","def newtons_method(expr, wrt, atol=1e-12, delta=None, debug=False,\n itermax=None, counter=None):\n\n if delta is None:\n delta = Dummy()\n Wrapper = Scope\n name_d = 'delta'\n else:\n Wrapper = lambda x: x\n name_d = delta.name\n\n delta_expr = -expr/expr.diff(wrt)\n whl_bdy = [Assignment(delta, delta_expr), AddAugmentedAssignment(wrt, delta)]\n if debug:\n prnt = Print([wrt, delta], r\"{0}=%12.5g {1}=%12.5g\\n\".format(wrt.name, name_d))\n whl_bdy = [whl_bdy[0], prnt] + whl_bdy[1:]\n req = Gt(Abs(delta), atol)\n declars = [Declaration(Variable(delta, type=real, value=oo))]\n if itermax is not None:\n counter = counter or Dummy(integer=True)\n v_counter = Variable.deduced(counter, 0)\n declars.append(Declaration(v_counter))\n whl_bdy.append(AddAugmentedAssignment(counter, 1))\n req = And(req, Lt(counter, itermax))\n whl = While(req, CodeBlock(*whl_bdy))\n blck = declars + [whl]\n return Wrapper(CodeBlock(*blck))","def f_inv(self, y, psi, iterations = 10):\r\n\r\n y = y.copy()\r\n z = np.ones_like(y)\r\n\r\n for i in range(iterations):\r\n z -= (self.f(z, psi) - y)/self.fgrad_y(z,psi)\r\n\r\n return z","def newtons_method(fn, grad_fn, max_iters=20):\n\n x_0 = torch.normal(mean=torch.tensor(0.), std=10)\n x = newton_restart(fn, grad_fn, x_0, max_iters=20)\n\n while x is None:\n x_0 = torch.normal(mean=torch.tensor(0.), std=10)\n x = newton_restart(fn, grad_fn, x_0, max_iters=20)\n\n return x","def newton(f, xinit, tol, N):\n if f(xinit) < tol:\n return xinit\n else:\n n = 1\n while n < N:\n xnew = xinit - (f(xinit) / derivative(f, xinit))\n if abs(f(xnew)) < tol:\n print('Root found. Number of iterations: ', n)\n return xnew\n break\n else:\n xinit = xnew\n n = n + 1\n else:\n return 'Max iterations reached. No root found within chosen tolerance.'","def _newtons_method_gmres_action(f, initial_guess, max_iter=50, tol=1e-12):\n\n output_dim = len(f(initial_guess))\n \n @np.vectorize\n def sum_values(dictionary):\n return sum(dictionary.values())\n \n def create_action(x0):\n \n def L_fun(x):\n \"\"\"\n Action\n Returns J_f(x0)*x by setting the values of 'x' as the initial derivatives for the variables in x0.\n \"\"\"\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action\n \n L = LinearOperator(shape=(output_dim, len(x0)), matvec=L_fun)\n \n return L\n \n x0 = initial_guess\n for iter_num in range(max_iter):\n L = create_action(x0)\n b = -1 * np.array(f(x0))\n if len(x0) == 1:\n b = np.array([b])\n step, _ = gmres(L, b, tol = tol, atol = 'legacy')\n xnext = x0 + step \n if np.all(np.abs(xnext - x0) < tol):\n return (xnext, iter_num + 1);\n x0 = xnext\n \n raise RuntimeError(\"Failed to converge after {0} iterations, value is {1}\".format(max_iter, x0) );","def f(y):\n \n\n k = 1.0\n return y*(1-y)","def f(self,y,psi):\r\n raise NotImplementedError","def newton_body(iterand):\n next_backward_difference = iterand.next_backward_difference\n next_state_vec = iterand.next_state_vec\n\n rhs = newton_coefficient * step_size_cast * ode_fn_vec(\n next_time,\n next_state_vec) - rhs_constant_term - next_backward_difference\n delta = tf.squeeze(\n tf.linalg.triangular_solve(\n upper,\n tf.matmul(tf.transpose(unitary), rhs[:, tf.newaxis]),\n lower=False))\n num_iters = iterand.num_iters + 1\n\n next_backward_difference += delta\n next_state_vec += delta\n\n delta_norm = tf.cast(tf.norm(delta), real_dtype)\n lipschitz_const = delta_norm / iterand.prev_delta_norm\n\n # Stop if method has converged.\n approx_dist_to_sol = lipschitz_const / (1. - lipschitz_const) * delta_norm\n close_to_sol = approx_dist_to_sol < tol\n delta_norm_is_zero = tf.equal(delta_norm, tf.constant(0., dtype=real_dtype))\n converged = close_to_sol | delta_norm_is_zero\n finished = converged\n\n # Stop if any of the following conditions are met:\n # (A) We have hit the maximum number of iterations.\n # (B) The method is converging too slowly.\n # (C) The method is not expected to converge.\n too_slow = lipschitz_const > 1.\n finished = finished | too_slow\n if max_num_iters is not None:\n too_many_iters = tf.equal(num_iters, max_num_iters)\n num_iters_left = max_num_iters - num_iters\n num_iters_left_cast = tf.cast(num_iters_left, real_dtype)\n wont_converge = (\n approx_dist_to_sol * lipschitz_const**num_iters_left_cast > tol)\n finished = finished | too_many_iters | wont_converge\n\n return [\n _NewtonIterand(\n converged=converged,\n finished=finished,\n next_backward_difference=next_backward_difference,\n next_state_vec=next_state_vec,\n num_iters=num_iters,\n prev_delta_norm=delta_norm)\n ]","def newtons_method(expr, wrt, atol=1e-12, delta=None, *, rtol=4e-16, debug=False,\n itermax=None, counter=None, delta_fn=lambda e, x: -e/e.diff(x),\n cse=False, handle_nan=None,\n bounds=None):\n\n if delta is None:\n delta = Dummy()\n Wrapper = Scope\n name_d = 'delta'\n else:\n Wrapper = lambda x: x\n name_d = delta.name\n\n delta_expr = delta_fn(expr, wrt)\n if cse:\n from sympy.simplify.cse_main import cse\n cses, (red,) = cse([delta_expr.factor()])\n whl_bdy = [Assignment(dum, sub_e) for dum, sub_e in cses]\n whl_bdy += [Assignment(delta, red)]\n else:\n whl_bdy = [Assignment(delta, delta_expr)]\n if handle_nan is not None:\n whl_bdy += [While(isnan(delta), CodeBlock(handle_nan, break_))]\n whl_bdy += [AddAugmentedAssignment(wrt, delta)]\n if bounds is not None:\n whl_bdy += [Assignment(wrt, Min(Max(wrt, bounds[0]), bounds[1]))]\n if debug:\n prnt = Print([wrt, delta], r\"{}=%12.5g {}=%12.5g\\n\".format(wrt.name, name_d))\n whl_bdy += [prnt]\n req = Gt(Abs(delta), atol + rtol*Abs(wrt))\n declars = [Declaration(Variable(delta, type=real, value=oo))]\n if itermax is not None:\n counter = counter or Dummy(integer=True)\n v_counter = Variable.deduced(counter, 0)\n declars.append(Declaration(v_counter))\n whl_bdy.append(AddAugmentedAssignment(counter, 1))\n req = And(req, Lt(counter, itermax))\n whl = While(req, CodeBlock(*whl_bdy))\n blck = declars\n if debug:\n blck.append(Print([wrt], r\"{}=%12.5g\\n\".format(wrt.name)))\n blck += [whl]\n return Wrapper(CodeBlock(*blck))","def root_finding_newton(fun, J, x, eps, max_iter, args):\n F_value = fun(x, *args)\n F_value_ = F_value.reshape((-1,1))\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\n iteration_counter = 0\n while abs(F_norm) > eps and iteration_counter < max_iter:\n delta = np.linalg.solve(J(x, args), -F_value_)\n\n for i in range(x.size): #wtf numba!?!?!\n x[i] += delta[i,0]\n\n F_value = fun(x, *args)\n F_value_ = F_value.reshape((-1,1))\n F_norm = np.linalg.norm(F_value, 2)\n iteration_counter += 1\n\n # Here, either a solution is found, or too many iterations\n if abs(F_norm) > eps:\n iteration_counter = -1\n raise ValueError('Maximum iteration reached in newton root finding!')\n return x, iteration_counter","def fgrad_y(self,y,psi):\r\n raise NotImplementedError","def gaussNewton(f, df, jac, r, x, niter=10):\n\n for i in xrange(niter):\n #check if it's close enough\n if np.allclose(np.dot(jac(x).T, r(x)), 0):\n return x\n\n else:\n p = la.solve(np.dot(jac(x).T, jac(x)), -np.dot(jac(x).T, r(x)))\n\n a = line_search(f, df, x, p)[0]\n if a is None:\n return x\n else:\n x_k = x + a*p\n\n return x_k","def newton_method_bidirectional(f, bnd1, bnd2, Ep, step):\n\n while True:\n step = step + 1\n\n # print(\"bnd1=\",bnd1,\" and bnd2=\",bnd2)\n\n h_bnd1 = f(bnd1) / derivative(f, bnd1)\n bnd1 = bnd1 - h_bnd1\n if (decide(abs(h_bnd1) <= Ep)):\n # print(\"Root in Approximation: \",bnd1)\n return step\n\n h_bnd2 = f(bnd2) / derivative(f, bnd2)\n bnd2 = bnd2 - h_bnd2\n if (decide(abs(h_bnd2) <= Ep)):\n # print(\"Root in Approximation: \",bnd2)\n return step","def find_zero(f, df):\n def near_zero(x):\n return approx_eq(f(x), 0)\n return improve(newton_update(f, df), near_zero)","def f(self,y,psi):\r\n\r\n #1. check that number of params is consistent\r\n # assert psi.shape[0] == self.n_terms, 'inconsistent parameter dimensions'\r\n # assert psi.shape[1] == 4, 'inconsistent parameter dimensions'\r\n mpsi = psi.copy()\r\n d = psi[-1]\r\n mpsi = mpsi[:self.num_parameters-1].reshape(self.n_terms, 3)\r\n\r\n #3. transform data\r\n z = d*y.copy()\r\n for i in range(len(mpsi)):\r\n a,b,c = mpsi[i]\r\n z += a*np.tanh(b*(y+c))\r\n return z","def derivative_given_y(self, y):\n return 1","def jacobian(self,x,p,fun):\n n = self.n\n y = fun(x,p)\n h = 1e-4\n nout = np.size(y)\n dfdx = np.zeros((nout,n))\n for j in range(n):\n dx1 = np.zeros(n)\n dx2 = np.zeros(n)\n dx1[j] = -h\n dx2[j] = h\n dfdx[:,j] = (fun(x+dx2,p)-fun(x+dx1,p))/(2*h)\n return dfdx","def derivatives(x_p, y_p):\r\n # set up the matrix equation\r\n n = x_p.shape[0]\r\n M = np.zeros( [n,n] )\r\n d = np.zeros( [n,1] )\r\n \r\n # fill in the constants where they can be\r\n for i in np.arange(1,n-1 ): # for all but the first and last row\r\n M[i,i-1 ] = ( x_p[i] - x_p[i-1] ) / 6.\r\n M[i,i] = ( x_p[i+1] - x_p[i-1] ) / 3.\r\n M[i,i+1] = ( x_p[i+1] - x_p[i] ) /6.\r\n d[i,0 ] = ( y_p[i+1] - y_p[i] ) / ( x_p[i+1] - x_p[i] ) - ( y_p[i] - y_p[i-1] ) / ( x_p[i] - x_p[i-1] )\r\n \r\n M[0,0],M[-1,-1] = 1.,1. # compactly sets the BCs\r\n \r\n LU = lu.LU_decomp(M) # solves the matrix equations\r\n return lu.FB_sub(LU.Low, LU.Upp, d) # find and return 2nd derivatives\r","def newtons_method_function(expr, wrt, params=None, func_name=\"newton\", attrs=Tuple(), **kwargs):\n if params is None:\n params = (wrt,)\n pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)\n for p in params if isinstance(p, Pointer)}\n delta = kwargs.pop('delta', None)\n if delta is None:\n delta = Symbol('d_' + wrt.name)\n if expr.has(delta):\n delta = None # will use Dummy\n algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)\n if isinstance(algo, Scope):\n algo = algo.body\n not_in_params = expr.free_symbols.difference(set(_symbol_of(p) for p in params))\n if not_in_params:\n raise ValueError(\"Missing symbols in params: %s\" % ', '.join(map(str, not_in_params)))\n declars = tuple(Variable(p, real) for p in params)\n body = CodeBlock(algo, Return(wrt))\n return FunctionDefinition(real, func_name, declars, body, attrs=attrs)","def f_inv(self, z, psi, max_iterations=1000, y=None):\r\n\r\n z = z.copy()\r\n if y is None:\r\n y = np.ones_like(z)\r\n \r\n it = 0\r\n update = np.inf\r\n\r\n while it == 0 or (np.abs(update).sum() > 1e-10 and it < max_iterations):\r\n update = (self.f(y, psi) - z)/self.fgrad_y(y, psi)\r\n y -= update\r\n it += 1\r\n if it == max_iterations:\r\n print \"WARNING!!! Maximum number of iterations reached in f_inv \"\r\n\r\n return y","def f(self, t, y, n):\n y1, y2 = y\n return y2, -np.absolute(y1)**n - 2 * y2 / t","def func_ludwigson(eps,k1,n1,k2,n2,):\n return k1*eps**n1+np.exp(k2+n2*eps)","def f(self,y,psi):\r\n\r\n #1. check that number of params is consistent\r\n assert psi.shape[0] == self.n_terms, 'inconsistent parameter dimensions'\r\n assert psi.shape[1] == 3, 'inconsistent parameter dimensions'\r\n\r\n #2. exponentiate the a and b (positive!)\r\n mpsi = psi.copy()\r\n\r\n #3. transform data\r\n z = y.copy()\r\n for i in range(len(mpsi)):\r\n a,b,c = mpsi[i]\r\n z += a*np.tanh(b*(y+c))\r\n return z","def newtons_method_function(expr, wrt, params=None, func_name=\"newton\", attrs=Tuple(), *, delta=None, **kwargs):\n if params is None:\n params = (wrt,)\n pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)\n for p in params if isinstance(p, Pointer)}\n if delta is None:\n delta = Symbol('d_' + wrt.name)\n if expr.has(delta):\n delta = None # will use Dummy\n algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)\n if isinstance(algo, Scope):\n algo = algo.body\n not_in_params = expr.free_symbols.difference({_symbol_of(p) for p in params})\n if not_in_params:\n raise ValueError(\"Missing symbols in params: %s\" % ', '.join(map(str, not_in_params)))\n declars = tuple(Variable(p, real) for p in params)\n body = CodeBlock(algo, Return(wrt))\n return FunctionDefinition(real, func_name, declars, body, attrs=attrs)","def F(x):\n soln = x - (1.0/5.0)*math.cos(10.0*x+1.0) \n return soln","def smale_newton(f, x0, df=(), args=(), tol=1.48e-8, maxiter=50):\n # skip using smale alpha if not enough derivatives are provided\n if len(df) < 2:\n warnings.warn('not enough derivatives provided for smale',\n RuntimeWarning)\n else:\n # raise a warning if x0 is not an approximate solution\n alpha = smale_alpha(f, x0, df, args=args)\n if alpha > 0.15767078078675478:\n warnings.warn('the estimate may not be an approximate solution to the '\n 'function', RuntimeWarning)\n\n # newton iterate (omit use of fprime2 due to unknown issues)\n fprime = df[0] if len(df) > 0 else None\n zero = newton(f, x0, fprime=fprime, args=args, tol=tol, maxiter=maxiter)\n return zero","def fgrad_y_psi(self,y,psi):\r\n raise NotImplementedError","def newtons_method(function, start, epsilon_rounding=6):\n point = start\n\n f = get_gradient(function)\n jacobian_matrix = get_jacobian(f)\n inverse_jacobian = jacobian_matrix.inv()\n\n f_subs = gradient_subs(f, point)\n\n temp = [0, 0]\n\n points = [point]\n while temp != point:\n jacobian_subs_matrix = matrix_subs(jacobian_matrix, point)\n inverse_subs_jacobian = matrix_subs(inverse_jacobian, point)\n negative_gradient = Matrix([-x for x in f_subs])\n solution = Ax_b(jacobian_subs_matrix, negative_gradient)\n temp = [round(float(x), epsilon_rounding) for x in point]\n point = [a + b for a, b in zip(solution, point)]\n point = [round(float(x), epsilon_rounding) for x in point]\n points.append(point)\n f_subs = gradient_subs(f, point)\n new_minimum = [float(x) for x in point]\n\n return new_minimum, points, f\"The minimum is {new_minimum}, with a starting point of {start}\"","def f(z):\n omega_m = 0.308\n omega_de = 0.692\n #omega = omega_m*(1+z)**3\n #return omega**0.6 + omega_de/70*(1+omega/2) # Dodelson approx\n\n omega = omega_m*(1+z)**3*H(0)**2/H(z)**2\n omega_de = omega_de*H(0)**2/H(z)**2\n return omega**(4/7) + omega_de/70*(1+omega/2) # Dodelson approx\n #return 5*omega/(2*(omega**(4/7) - omega_de + (1 + omega/2)*(1 + omega_de/70)))\n #return omega**0.55","def root_finding_newton(fun, J, x, eps, max_iter, args):\n F_value = fun(x, args)\n F_value_ = F_value.reshape((-1, 1))\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\n iteration_counter = 0\n while abs(F_norm) > eps and iteration_counter < max_iter:\n delta = np.linalg.solve(J(x, args), -F_value_)\n\n for i in range(x.size): # wtf numba!?!?!\n x[i] += delta[i, 0]\n\n F_value = fun(x, args)\n F_value_ = F_value.reshape((-1, 1))\n F_norm = np.linalg.norm(F_value, 2)\n iteration_counter += 1\n\n # Here, either a solution is found, or too many iterations\n if abs(F_norm) > eps:\n iteration_counter = -1\n raise ValueError(\"Maximum iteration reached in newton root finding!\")\n return x, iteration_counter","def flow_inference_newton_raphson(self,newton_raphson_max_iters:int = 100,dsf_max_iters:int = 1000,show_params:bool=False,**params):\n\n # Define empty array of flows\n flows = np.ones((self.N,self.M)).astype('float64')\n\n # Define initial \\beta if beta is not zero (default value)\n if params['beta'] == 0.0:\n # See suggestion in page 386 of \"Gravity Models of Spatial Interaction Behavior\" book\n beta = np.ones((newton_raphson_max_iters)) * 1.5 * (1./self.total_cost)\n else:\n beta = np.ones((newton_raphson_max_iters)) * params['beta']\n\n # Define initial cost of beta\n c_beta = np.zeros(newton_raphson_max_iters)\n\n # Infer flows\n value = self.infer_flows_newton_raphson(flows,beta,c_beta,self.origin_supply,self.destination_demand,self.cost_matrix,self.total_cost,self.N,self.M,dsf_max_iters,newton_raphson_max_iters)\n\n # Trim beta and c_beta arrays if they were not used in full\n beta = beta[~np.isnan(beta)]\n c_beta = c_beta[c_beta>=0]\n\n # Print parameters if requested\n if show_params:\n print('\\n')\n print('Beta',beta)\n print('Cost(beta)',c_beta)\n\n return flows,beta,c_beta","def f(t,y):\n return np.array([lam*y[0] + (1.0-lam)*np.cos(t) - (1.0+lam)*np.sin(t)])","def Newton(f, x0, tol, kmax, c=0.5, tao=1e-6, reg_const=1e-7):\r\n\r\n k = 1\r\n\r\n xk = x0.copy() # We don't want to change x0 from the outside scope\r\n\r\n # Cache for f(xk) in case the calculation is expensive\r\n # - Should save 2-3 function evaluations per outside loop iteration\r\n f_xk = f(xk)\r\n\r\n s = LA.norm(f_xk)**2\r\n\r\n while np.sqrt(s) > tol and k < kmax:\r\n # Build the Jacobian matrix approximation using Central Differences\r\n H = _CentralDifferencesJacobian(f, xk, tao)\r\n\r\n try:\r\n # Uses LAPACK _gesv to solve H*dk = -f(xk)\r\n dk = LA.solve(H, -f_xk)\r\n except LA.LinAlgError:\r\n # Most likely here because the above H is singular\r\n # Therefore we regularize by adding a small (1e-7) multiple of I:\r\n dk = LA.solve(H + reg_const*np.eye(xk.shape[0]), -f_xk)\r\n\r\n z = c*LA.norm(np.matmul(f_xk.T, H))*LA.norm(dk)\r\n\r\n # Solve the step size using the method by Stoer and Bulirsch\r\n j = 0\r\n L = LA.norm(f(xk + dk))**2\r\n R = s-z\r\n Lmin = L\r\n index = 0\r\n while L > R:\r\n j += 1\r\n L = LA.norm(f(xk + 2**(-j)*dk))**2\r\n R = s - 2**(-j)*z\r\n if L < Lmin:\r\n Lmin = L\r\n index = j\r\n\r\n # Update xk\r\n xk = xk + 2**(-index)*dk\r\n\r\n k += 1\r\n\r\n # Cache the new f(xk)\r\n f_xk = f(xk)\r\n\r\n s = LA.norm(f_xk)**2\r\n\r\n # If kmax gets exceeded, we can't trust the answer so issue a warning\r\n if k >= kmax:\r\n # For debugging purposes\r\n # print(\"k exceeded kmax, can't trust answer\")\r\n # return xk\r\n warnings.warn(\"kmax exceeded, consider raising it\", NonConvergenceWarning)\r\n\r\n # Otherwise, we stopped the above loop because we're within tolerance so the answer is good\r\n return xk, k","def _get_F(self, omega, y): \n x = y[:-1]\n newt_lambda = y[-1]\n F = np.zeros([len(x)+1, 1])\n F[:-1] = omega @ x - newt_lambda/x\n F[-1] = x.sum()-1\n return F","def f(t,y):\n return (lam*y)","def _derY(self, x, y):\n if _isscalar(x):\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n else:\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n alpha = (x - self.x_list[x_pos - 1]) / (\n self.x_list[x_pos] - self.x_list[x_pos - 1]\n )\n dfdy = (\n (\n (1 - alpha) * self.f_values[x_pos - 1, y_pos]\n + alpha * self.f_values[x_pos, y_pos]\n )\n - (\n (1 - alpha) * self.f_values[x_pos - 1, y_pos - 1]\n + alpha * self.f_values[x_pos, y_pos - 1]\n )\n ) / (self.y_list[y_pos] - self.y_list[y_pos - 1])\n return dfdy","def f(x):\n return np.tan(x) - np.sin(x) - (m*g)/(2*k*L)","def hessian(f, delta=DELTA):\n def hessian_f(*args, **kwargs):\n if len(args) == 1:\n x, = args\n hessianf_x = (\n f(x+delta) + f(x-delta) - 2*f(x)\n )/delta**2\n return hessianf_x\n elif len(args) == 2:\n x, y = args\n if type(x) in [float, int] and type(y) in [float, int]:\n hess_xx = (\n f(x + delta, y) + f(x - delta, y) - 2*f(x, y)\n )/delta**2\n hess_yy = (\n f(x, y + delta) + f(x, y - delta) - 2*f(x, y)\n )/delta**2\n hess_xy = (\n + f(x+delta/2, y+delta/2)\n + f(x-delta/2, y-delta/2)\n - f(x+delta/2, y-delta/2)\n - f(x-delta/2, y+delta/2)\n )/delta**2\n return hess_xx, hess_xy, hess_yy\n return hessian_f","def f(t,y):\n return np.array([lam*y[0] + (1.0-lam)*np.cos(t) - (1.0+lam)*np.sin(t)])","def fit(self, start_params=None, method='newton', maxiter=100,\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\n skip_hessian=False, **kwargs):\n Hinv = None # JP error if full_output=0, Hinv not defined\n\n start_params = self._get_start_params(start_params)\n\n # TODO: separate args from nonarg taking score and hessian, ie.,\n # user-supplied and numerically evaluated estimate frprime doesn't take\n # args in most (any?) of the optimize function\n\n nobs = self.endog.shape[0]\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\n\n def f(params, *args):\n return -self.loglike(params, *args) / nobs\n\n if method == 'newton':\n # TODO: why are score and hess positive?\n def score(params, *args):\n return self.score(params, *args) / nobs\n\n def hess(params, *args):\n return self.hessian(params, *args) / nobs\n else:\n def score(params, *args):\n return -self.score(params, *args) / nobs\n\n def hess(params, *args):\n return -self.hessian(params, *args) / nobs\n\n warn_convergence = kwargs.pop('warn_convergence', True)\n optimizer = Optimizer()\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\n fargs, kwargs,\n hessian=hess,\n method=method,\n disp=disp,\n maxiter=maxiter,\n callback=callback,\n retall=retall,\n full_output=full_output)\n\n # NOTE: this is for fit_regularized and should be generalized\n cov_params_func = kwargs.setdefault('cov_params_func', None)\n if cov_params_func:\n Hinv = cov_params_func(self, xopt, retvals)\n elif method == 'newton' and full_output:\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\n # TODO: try/except for non-invertible hessian?\n elif not skip_hessian:\n H = -1 * self.hessian(xopt)\n invertible = False\n if np.all(np.isfinite(H)):\n eigvals, eigvecs = np.linalg.eigh(H)\n if np.min(eigvals) > 0:\n invertible = True\n\n if invertible:\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\n else:\n warnings.warn('Inverting hessian failed, no bse or cov_params '\n 'available', HessianInversionWarning)\n Hinv = None\n\n if 'cov_type' in kwargs:\n cov_kwds = kwargs.get('cov_kwds', {})\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\n else:\n kwds = {}\n if 'use_t' in kwargs:\n kwds['use_t'] = kwargs['use_t']\n # TODO: add Hessian approximation and change the above if needed\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\n\n # TODO: hardcode scale?\n if isinstance(retvals, dict):\n mlefit.mle_retvals = retvals\n if warn_convergence and not retvals['converged']:\n warnings.warn(\"Maximum Likelihood optimization failed to \"\n \"converge. Check mle_retvals\",\n ConvergenceWarning)\n\n mlefit.mle_settings = optim_settings\n return mlefit","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def prob2(N1, N2, P1, P2):\r\n #initialize function and its derivative\r\n f = lambda x: P1*((1+x)**N1-1)-P2*(1-(1+x)**-N2)\r\n Df = grad(f)\r\n #use Newton's method\r\n r,conv,iter = newton(f,.1,Df)\r\n return r","def f_y(Y, betas, sigma, nodes):\n\n # set-up\n if len(betas.shape) == 1:\n betas = np.array([betas]).T\n X = 1 - Y # X: NxI matrix\n N, I = np.shape(Y)\n M = len(nodes)\n\n # sufficient statistics\n r = Y.sum(axis=1) # Nx1 vector\n q = Y.sum(axis=0) # Ix1 vector\n\n ### equation (13) in paper\n # numerator: NxM matrix\n to_exp = (np.outer(I - r, -sigma * nodes) + X.dot(betas))\n numerator = np.exp(to_exp)\n\n # denomenator: Mx1 vector\n denomenator = (np.outer(np.exp(-sigma * nodes), np.exp(betas)) + 1).prod(axis=1)\n\n # conditional likelihood: NxM matrix\n CLF = numerator / denomenator\n return CLF","def _f(X, g, n):\n if n == 3:\n n = 3.001 # for numerical stability\n hyp2f1_term = hyp2f1((n-1)/2, g/2, n/2, 1/(1+X**2))\n beta_term = beta((n-1)/2, 0.5)\n return 0.5 * beta_term * hyp2f1_term * (1+X**2) ** ((1-n)/2)","def log_likelihood_gradients_(self, y, f):\n log_lik = self.evaluate_log_likelihood(y, f)\n f = np.squeeze(f)\n J = jacrev(self.evaluate_log_likelihood, argnums=1)\n H = jacrev(J, argnums=1)\n return log_lik, J(y, f), H(y, f)","def fgrad_y(self, y, psi, return_precalc = False):\r\n\r\n\r\n mpsi = psi.copy()\r\n d = psi[-1]\r\n mpsi = mpsi[:self.num_parameters-1].reshape(self.n_terms, 3)\r\n\r\n # vectorized version\r\n\r\n S = (mpsi[:,1]*(y[:,:,None] + mpsi[:,2])).T\r\n R = np.tanh(S)\r\n D = 1-R**2\r\n\r\n GRAD = (d + (mpsi[:,0:1][:,:,None]*mpsi[:,1:2][:,:,None]*D).sum(axis=0)).T\r\n\r\n if return_precalc:\r\n return GRAD, S, R, D\r\n\r\n\r\n return GRAD","def newton(n, k):\n if k == 0 or k == n:\n return 1\n else:\n return newton(n - 1, k - 1) + newton(n - 1, k)","def func(x, f, fp):\n\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def lnlike(params, cos2, y, yerr):\n a, b, f = params\n model = f * (b * cos2**2 + a * cos2 + 1)\n\n return -0.5 * np.sum((y - model)**2 / yerr**2 + np.log(yerr**2))","def f1d(t,y,float_params,sigmaI): #sigmastep is an array\n \n ## y is Ntot0 ##\n\n # unpack parameters\n Nbar, Nstar, sigma0, nu_kin_mlyperus, DoverdeltaX2 = float_params \n\n # Ntot is passed in, Fqll calculated from Ntot\n Ntot0 = np.ascontiguousarray(y)\n Nqll0 = Nbar - Nstar * np.sin(2*np.pi*(Ntot0))\n\n # Calc surface deposition, dNtot_dt before diffusion\n m = (Nqll0 - (Nbar - Nstar))/(2*Nstar)\n sigmaM = (sigmaI - m * sigma0)/(1+m*sigma0)\n depsurf = nu_kin_mlyperus * sigmaM\n dNtot_dt = depsurf\n\n # Diffusion\n dy = diffuse_1d(Nqll0,DoverdeltaX2)\n dNtot_dt += dy \n\n # Package for output, only values of dNtot\n derivs = dNtot_dt\n return derivs","def fn(a, y):\n return 0.5*np.linalg.norm(a-y)**2","def ThetaMethod(f, iv : Array[float], t0 : float, tn : float, h : float, theta : float, df = None, TOL : float = 1.0e-5, NEWTITER : int = 10) -> Array[float]:\n\n\tif h <= 0.0:\n\t\traise ValueError('The stepsize h must be positive')\n\n\tif (tn - t0) <= 0.0:\n\t\traise ValueError('The final time must be greater than the initial time')\n\n\tif not 0 <= theta <= 1:\n\t\traise ValueError('Theta has to be between 0 and 1')\n\n\tif TOL <= 0.0:\n\t\traise ValueError('The numerical tolerance must be positive')\n\n\tif (theta != 1) and (NEWTITER < 0.0):\n\t\traise ValueError('The maximum number of Newton Iteration steps must be positive')\n\n\tif (theta != 1) and df is None:\n\t\traise NotImplementedError('Automatic differentiation not implemented yet. Please provide the Jacobian of f')\n\n\tN : np.int = np.int(np.ceil((tn - t0)/h));\t# number of steps\n\n\tx = np.empty((np.int(N+1),iv.size), float);\t# preallocating the array (+1 for including initial condition)\n\tx[0,:] = iv;\n\n\tif (theta == 1):\n\t\tfor i in range(N):\n\t\t\tx[i+1,:] = _ExplicitEuler_step(f,x[i,:],(t0+h*i),h);\n\telse:\n\t\tfor i in range(N):\n\t\t\tx[i+1,:] = _Theta_step(f,df,x[i,:],(t0+h*i),h,theta,TOL,NEWTITER);\n\n\treturn x;","def reg_logistic_regression_newton(y, tx, lambda_, initial_w, max_iters, gamma, debug = False):\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_logistic.reg_loss, grad_f = model_logistic.newton_reg_grad, kwargs = {'lambda_': lambda_}, debug = debug)\n return get_last_ans(ws, losses)"],"string":"[\n \"def newton(f, x0, Df, tol=1e-5, maxiter=15, alpha=1.):\\n raise NotImplementedError(\\\"Problem 1 Incomplete\\\")\",\n \"def test_newton():\\n\\n f = lambda x: x**2 + np.sin(5*x)\\n df = lambda x: 2*x + 5*np.cos(5*x)\\n ddf = lambda x: 2 + 0,-25*np.sin(5*x)\\n\\n\\n print newtonsMethod(f,df,ddf, 0, niter = 100)\",\n \"def newton_update(f, df):\\n def update(x):\\n return x - f(x) / df(x)\\n return update\",\n \"def newton(f, x0, dx, eps=1e-10):\\n # Initialization\\n globvar.ncalls = 0\\n x = np.copy(x0)\\n n = len(x)\\n J = np.zeros((n, n), dtype='float64')\\n fx = f(x)\\n\\n # Begin root search\\n while True:\\n globvar.ncalls += 1\\n\\n # Fill the Jacobian matrix\\n for j in range(n):\\n x[j] += dx[j]\\n df = f(x) - fx\\n\\n for i in range(n):\\n J[i, j] = df[i] / dx[j]\\n\\n x[j] -= dx[j]\\n\\n # Decompose and solve using Given's rotations\\n decomp(J)\\n Dx = -fx\\n solve(J, Dx)\\n\\n # Begin backtracking linesearch\\n lamb = 2.0\\n while True: \\n lamb /= 2\\n y = x + Dx * lamb\\n fy = f(y)\\n\\n fynorm = np.linalg.norm(fy)\\n fxnorm = np.linalg.norm(fx)\\n\\n if (fynorm < (1 - lamb / 2) * fxnorm) or (lamb < (1 / 128.0)):\\n break\\n\\n # Save latest approximation\\n x = y\\n fx = fy\\n\\n Dxnorm = np.linalg.norm(Dx)\\n fxnorm = np.linalg.norm(fx)\\n dxnorm = np.linalg.norm(dx)\\n if Dxnorm < dxnorm or fxnorm < eps:\\n break\\n\\n return x\",\n \"def my_Newton( fct, df_dx, x0):\\r\\n xn = float(x0)\\r\\n eps = 1e-5\\r\\n N = 20\\r\\n i = 0\\r\\n while abs( fct( xn**(i + 1)) - fct( xn**i)) > eps and i < N:\\r\\n x_next = xn - fct(xn)/df_dx(xn)\\r\\n print( i, 'fct value', abs( fct(xn)), x_next)\\r\\n xn = x_next\\r\\n i += 1\\r\\n if abs( fct( xn)) < eps:\\r\\n return x_next\\r\\n else: #solution did not converge\\r\\n return np.nan\",\n \"def halley_newton ( fun , ## the function \\n x , ## x \\n deriv1 , ## the first derivative \\n deriv2 = None , ## the second derivative\\n fx = None , ## value of fun(x)\\n args = () ) : ## additional arguments for function calls\\n \\n ## newton corrections\\n d1 = float ( deriv1 ( x , *args ) ) \\n fx = float ( fun ( x , *args ) ) if fx is None else fx \\n \\n if d1 : rn = fx / d1\\n else : return None ## error here! \\n \\n ## make corrections: Halley's steps\\n if deriv2 : \\n d2 = float ( deriv2 ( x , *args ) )\\n if d2 : rn /= ( 1.0 - 0.5 * rn * d2 / d1 ) ## Halley's correction \\n \\n return x - rn ## Newton/Halley's iteration\",\n \"def newtons_method_1d(f, df_dx, x0, tol):\\n # begin solution\\n x = x0\\n while abs(f(x)) > tol:\\n x -= f(x) / df_dx(x)\\n return x\\n # end solution\",\n \"def newton_raphson(f,x0,iterations): \\n current = x0\\n fdash = differentiate_polynomial(f)\\n print(fdash)\\n for i in range(iterations): \\n current = current - evaluate_polynomial(f,current)/evaluate_polynomial(fdash,current)\\n return current\",\n \"def my_Newton(fct, df_dx, x0):\\r\\n xn = float(x0)\\r\\n eps = 1e-5\\r\\n N = 20\\r\\n i = 0\\r\\n while abs(fct (xn)) > eps and i < N:\\r\\n x_next = xn - fct(xn)/df_dx(xn)\\r\\n print(i , 'fct_value', abs(fct(xn)), x_next)\\r\\n xn = x_next\\r\\n i += 1\\r\\n if abs(fct(xn)) < eps:\\r\\n return x_next\\r\\n else: #solution did not converge\\r\\n return np.nan\",\n \"def newton_method(f, x_init = 0, epsilon = 1e-10):\\n prev_value = x_init + 2 * epsilon\\n value = x_init\\n\\n iterations = 0\\n while abs(prev_value - value) > epsilon:\\n prev_value = value\\n\\n f_dash = derivative(f, value)\\n value = value - f(value) / f_dash\\n\\n iterations += 1\\n\\n print(f\\\"Newton Method converged in {iterations} iterations\\\")\\n\\n return value\",\n \"def newtonsMethod(f, df, ddf, x, niter=10):\\n\\n points = []\\n\\n for i in xrange(niter):\\n point = np.dot(-la.inv(ddf(x)), (df(x)))\\n\\n slope = np.dot(df(x), point)\\n\\n a = backtracking(f, slope, x, point)\\n \\n #update point\\n x_k = x + a*point\\n points.append(x_k)\\n x = x_k\\n\\n return points\",\n \"def newtonsMethod(self, x, a):\\n return x - a * (self._f(x) / self._df(x))\",\n \"def newton_method_vector(f, x_init, epsilon = 1e-10):\\n prev_value = x_init + 2 * epsilon\\n value = x_init\\n\\n iterations = 0\\n while np.all(np.abs(prev_value - value)) > epsilon:\\n prev_value = value\\n\\n j = jacobian(f, value)\\n value = value - np.dot(np.linalg.pinv(j), f(value))\\n\\n iterations += 1\\n\\n print(f\\\"Newton Method converged in {iterations} iterations\\\")\\n\\n return value\",\n \"def NewtonMethod(f, df, x=0.75, tol=1e-10):\\n\\tstart = time()\\n\\terror = tol + 1\\n\\t\\n\\ti = 0\\n\\terrs = []\\n\\n\\twhile error > tol:\\n\\t\\terrs.append(error)\\n\\n\\t\\tx_temp = x\\n\\t\\tx = x - f(x) / df(x)\\n\\t\\terror = np.abs(x-x_temp)\\n\\t\\ti = i+1\\n\\tend = time()\\n\\treturn x, (end-start), i\",\n \"def newton(n):\\n x = n\\n y = (x + 1) // 2\\n while y < x:\\n x = y\\n y = (x + n // x) // 2\\n return x\",\n \"def newton_method(f, x, Ep, step):\\n\\n while True:\\n step = step + 1\\n # print(\\\"bnd1:=\\\",bnd1)\\n h = f(x) / derivative(f, x)\\n x = x - h\\n if (decide(abs(h) <= Ep)):\\n break\\n # print(\\\"Root in Approximation: \\\",bnd1)\\n return step\",\n \"def newton(f, f_prime, x0, n):\\n approximations = [x0]\\n\\n xnm1 = x0\\n for i in range(1, n):\\n xn = xnm1 - f(xnm1) / f_prime(xnm1)\\n approximations.append(xn)\\n xnm1 = xn\\n\\n for n in range(len(approximations)):\\n print(f'Approximation {n + 1}: {approximations[n]:<17.13f} Exact: {pi:<17.13f} Difference: {abs(pi - approximations[n]):.13e}')\",\n \"def quasi_newtons_method(f, initial_guess, max_iter = 10000, method = 'BFGS', tol = 1e-12):\\n \\n if method not in ['BFGS', 'DFP', 'Broyden']:\\n raise Exception(\\\"Not a valid method.\\\")\\n x = initial_guess\\n H = np.identity(len(x))\\n for i in range(max_iter):\\n x_vector = ad.create_vector('x', x)\\n fn_at_x = f(x_vector)\\n gradient = fn_at_x.getGradient(['x{}'.format(i) for i in range(1, len(x) + 1)])\\n\\n p = -H @ gradient\\n \\n alpha = line_search(f, x, p)\\n delta_x = alpha * p\\n\\n x = x + delta_x\\n x_vector2 = ad.create_vector('x', x)\\n fn_at_x2 = f(x_vector2)\\n gradient2 = fn_at_x2.getGradient(['x{}'.format(i) for i in range(1, len(x) + 1)])\\n if np.sqrt(np.abs(gradient2).sum()) < tol:\\n break\\n y = (gradient2 - gradient).reshape(-1, 1)\\n delta_x = delta_x.reshape(-1, 1)\\n if method == 'BFGS':\\n H = (np.identity(len(H)) - (delta_x @ y.T) / (y.T @ delta_x)) @ H \\\\\\n @ (np.identity(len(H)) - (y @ delta_x.T) / (y.T @ delta_x)) + (delta_x @ delta_x.T) / (y.T @ delta_x)\\n elif method == 'DFP':\\n H = H + (delta_x @ delta_x.T) / (delta_x.T @ y) - (H @ y @ y.T @ H) / (y.T @ H @ y)\\n elif method == 'Broyden':\\n H = H + ((delta_x - H @ y) @ delta_x.T @ H) / (delta_x.T @ H @ y)\\n\\n return (x, i + 1)\",\n \"def newton_quad(f, x0, dx, eps=1e-10):\\n # Initialization\\n globvar.ncalls = 0\\n x = np.copy(x0)\\n n = len(x)\\n J = np.zeros((n, n), dtype='float64')\\n fx = f(x)\\n\\n # Begin root search\\n while True:\\n globvar.ncalls += 1\\n\\n # Fill the Jacobian matrix\\n for j in range(n):\\n x[j] += dx[j]\\n df = f(x) - fx\\n\\n for i in range(n):\\n J[i, j] = df[i] / dx[j]\\n\\n x[j] -= dx[j]\\n\\n # Decompose and solve using Given's rotations\\n decomp(J)\\n Dx = -fx\\n solve(J, Dx)\\n\\n # Begin quadratic linesearch \\n lamb = 1.0\\n y = x + Dx * lamb\\n fy = f(y)\\n\\n fxnorm = np.linalg.norm(fx)\\n fynorm = np.linalg.norm(fy)\\n\\n # Define the known values of the minimization function (Eq. 9)\\n g0 = 0.5 * fxnorm ** 2\\n dg0 = - fxnorm ** 2\\n\\n while (fynorm > (1 - lamb / 2) * fxnorm) and (lamb > (1 / 128.0)):\\n glamb = 0.5 * fynorm ** 2\\n c = (glamb - g0 - dg0 * lamb) / (lamb ** 2)\\n\\n # Update step\\n lamb = - dg0 / (2 * c)\\n y = x + Dx * lamb\\n fy = f(y)\\n fynorm = np.linalg.norm(fy)\\n\\n # Save latest approximation\\n x = y\\n fx = fy\\n\\n Dxnorm = np.linalg.norm(Dx)\\n dxnorm = np.linalg.norm(dx)\\n if Dxnorm < dxnorm or fxnorm < eps:\\n break\\n\\n return x\",\n \"def newton_jacobian(f, x0, Jf, eps=1e-10):\\n # Initialization\\n globvar.ncalls = 0\\n x = np.copy(x0)\\n n = len(x)\\n J = np.zeros((n, n), dtype='float64')\\n fx = f(x)\\n\\n # Begin root search\\n while True:\\n globvar.ncalls += 1\\n\\n # Calculate Jacobian\\n J = Jf(x)\\n\\n # Decompose and solve using Given's rotations\\n decomp(J)\\n Dx = -fx\\n solve(J, Dx)\\n\\n # Begin backtracking linesearch\\n lamb = 2.0\\n while True: \\n lamb /= 2\\n y = x + Dx * lamb\\n fy = f(y)\\n\\n fynorm = np.linalg.norm(fy)\\n fxnorm = np.linalg.norm(fx)\\n\\n if (fynorm < (1 - lamb / 2) * fxnorm) or (lamb < (1 / 128.0)):\\n break\\n\\n # Save latest approximation\\n x = y\\n fx = fy\\n\\n fxnorm = np.linalg.norm(fx)\\n if fxnorm < eps:\\n break\\n\\n return x\",\n \"def newton_direction(\\n x,\\n problem: MinimizationProblem,\\n prev_state: IterationState):\\n\\n hessian = problem.calc_hessian_at(x)\\n grad = problem.calc_gradient_at(x)\\n\\n p = -solve(hessian, grad,\\n problem.settings.cholesky_linear_systems_solver_enabled,\\n problem.settings.gaussian_elimination_linear_systems_solver_enabled)\\n\\n return IterationState(x, p, grad)\",\n \"def newton(f, x0, Df, tol=1e-5, maxiter=15, alpha=1.):\\r\\n #initialize variables\\r\\n iter = 0\\r\\n xk = x0\\r\\n change = tol+1\\r\\n #perform newton's method until maxiter hit or under tolerance\\r\\n #if x is in R\\r\\n if np.isscalar(x0):\\r\\n while iter < maxiter and change > tol:\\r\\n iter += 1\\r\\n xk1 = xk\\r\\n xk = xk - alpha*f(xk)/Df(xk)\\r\\n change = abs(xk-xk1)\\r\\n #if x is in Rn\\r\\n else:\\r\\n while iter < maxiter and change > tol:\\r\\n iter += 1\\r\\n xk1 = xk\\r\\n D = Df(xk)\\r\\n #make sure the matrix isn't singular\\r\\n if la.det(D)==0:\\r\\n break\\r\\n yk = la.solve(D,f(xk))\\r\\n xk = xk - alpha*yk\\r\\n change = la.norm(xk-xk1)\\r\\n #check if method converged\\r\\n if change > tol:\\r\\n conv = False\\r\\n else:\\r\\n conv = True\\r\\n return xk,conv,iter\",\n \"def newton_iteration(f: Callable, df: Callable, eps: float, x0: float = None, a: float = None, b: float = None,\\n weight: float = 0.9, display: bool = False, max_iterations: int = 100) -> float:\\n x = np.inf\\n if x0 is None:\\n x0 = (a + b) / 2\\n if a is not None and b is not None and a == b:\\n return a\\n x_next = x0\\n iterations = 0\\n while abs(x - x_next) > eps and iterations < max_iterations:\\n iterations += 1\\n x = x_next\\n\\n if display:\\n import matplotlib.pyplot as plt\\n xx0 = a or x-1\\n xx1 = b or x+1\\n xx = np.linspace(xx0, xx1, 100)\\n yy = np.array(list(map(f, xx)))\\n plt.plot(xx, yy)\\n plt.axvline(x=x)\\n plt.show()\\n\\n f_x = f(x)\\n try:\\n df_x = df(x)\\n except ZeroDivisionError:\\n df_x = (f_x - f(x-eps))/eps\\n if df_x != 0:\\n x_next = x - f_x / df_x\\n\\n if a is not None and x_next < a:\\n x_next = weight * a + (1 - weight) * x\\n elif b is not None and x_next > b:\\n x_next = weight * b + (1 - weight) * x\\n\\n if a is not None and x_next < a:\\n x_next = a\\n if b is not None and x_next > b:\\n x_next = b\\n\\n return x_next\",\n \"def newton1d(f, df, ddf, x, niter=10):\\n for i in xrange(niter):\\n x_new = x - df(x)/ddf(x)\\n x = x_new\\n return x\",\n \"def newtons_method(f, initial_guess, max_iter = 1000, method = 'exact', tol =1e-12):\\n\\n if method not in ['inverse', 'exact', 'gmres', 'gmres_action']:\\n raise Exception(\\\"Not a valid method.\\\")\\n if len(f(initial_guess)) != len(initial_guess):\\n raise Exception('Output dimension of f should be the same as the input dimension of f.')\\n if method == 'gmres_action':\\n return _newtons_method_gmres_action(f, initial_guess, max_iter, tol)\\n x0 = ad.create_vector('x0', initial_guess)\\n for iter_num in range(max_iter):\\n fn = np.array(f(x0)); #need convert the list/array that is passed back from function, so downstream autodiff functions for vectors work properly\\n jacob = ad.get_jacobian(fn, ['x0{}'.format(i) for i in range(1, len(fn) + 1)])\\n if method == 'inverse':\\n step = np.linalg.inv(-jacob).dot(ad.get_value(fn))\\n if method == 'exact':\\n step = np.linalg.solve(-jacob, ad.get_value(fn))\\n elif method == 'gmres':\\n step, _ = gmres(jacob, -ad.get_value(fn), tol = tol, atol = 'legacy')\\n xnext = x0 + step\\n \\n #check if we have converged\\n if np.all(np.abs(ad.get_value(xnext) - ad.get_value(x0)) < tol):\\n return (ad.get_value(xnext), iter_num + 1);\\n \\n #update x0 because we have not converged yet\\n x0 = xnext\\n \\n raise RuntimeError(\\\"Failed to converge after {0} iterations, value is {1}\\\".format(max_iter, ad.get_value(x0)) );\",\n \"def newton1d(f, df, ddf, x, niter=10):\\n\\n x_0 = x\\n x_k = x\\n\\n for i in xrange(niter):\\n x_k1 = x_k - df(x_k)/ddf(x_k)\\n x_k = x_k1\\n\\n return x_k\",\n \"def newton_1d(f, df, ddf, x, n=10):\\n ret = [x]\\n xk = x\\n for i in range(n):\\n if(ddf(xk) == 0):\\n break\\n xk1 = xk - df(xk) / ddf(xk)\\n xk = xk1\\n ret.append(xk)\\n return ret\",\n \"def NewtonRaphson(z_ini, f, fprime, tol):\\r\\n z_current = z_ini\\r\\n while np.linalg.norm(f(z_current)) > tol:\\r\\n hess = fprime(z_current)\\r\\n inv_hess = np.linalg.solve(hess, np.eye(hess.shape[0]))\\r\\n z_new = z_current - inv_hess.dot(f(z_current))\\r\\n z_current = z_new\\r\\n return z_current\",\n \"def _newton_update(func):\\n return lambda x: x - func[0](x) / func[1](x)\",\n \"def newton_divided_difference(x, y):\\n\\n n = x.size\\n q = np.zeros((n, n - 1))\\n # Insert 'y' in the first column of the matrix 'q'\\n q = np.concatenate((y[:, None], q), axis=1)\\n\\n for i in range(1, n):\\n for j in range(1, i + 1):\\n q[i, j] = (q[i, j - 1] - q[i - 1, j - 1]) / (x[i] - x[i - j])\\n\\n # Copy the diagonal values of the matrix q to the vector f\\n f = np.zeros(n)\\n for i in range(0, n):\\n f[i] = q[i, i]\\n\\n # Prints the polynomial\\n print(\\\"The polynomial is:\\\")\\n print(\\\"p(x)={:+.4f}\\\".format(f[0]), end=\\\"\\\")\\n for i in range(1, n):\\n print(\\\"{:+.4f}\\\".format(f[i]), end=\\\"\\\")\\n for j in range(1, i + 1):\\n print(\\\"(x{:+.4f})\\\".format(x[j] * -1), end=\\\"\\\")\\n print(\\\"\\\")\\n\\n return [f]\",\n \"def newton_decent_directions(function, func_derivative, func_hessian, xk, A, P, b, q, t):\\r\\n # calculate steepest decent direction\\r\\n newton_dir = -np.dot(np.linalg.inv(func_hessian(x=xk, A=A, P=P, b=b, q=q, t=t)), func_derivative(x=xk, A=A, P=P, b=b, q=q, t=t))\\r\\n\\r\\n return newton_dir\",\n \"def newtonraphson(self,g_temp,var_init):\\n n_step=0\\n error=np.linalg.norm(self.evaluate(var_init,g_temp))\\n\\n while (error > 1e-12 and n_step < 50):\\n #Improve solution while error is too large and the number of steps does not exceed a limit\\n J_inv=np.linalg.pinv(self.jacobian(var_init,g_temp))\\n var_new=var_init-np.dot(J_inv,self.evaluate(var_init,g_temp))\\n error=np.linalg.norm(self.evaluate(var_new,g_temp))\\n var_init=var_new\\n n_step+=1\\n\\n return var_init\",\n \"def Newton(self, newton=True, eps=0.0000001):\\n x_new=np.zeros(2)\\n x_old=np.array([self.x_init,self.y_init])\\n #eps=10.0**(-5)\\n delta=10\\n count=0\\n if(newton):\\n while(True):\\n count+=1\\n invJacobi=self.secJacobian(x_old)\\n if(type(invJacobi)==type(0)):##check that the jacobian is not singular\\n return x_new.tolist()\\n part2=np.dot(invJacobi,np.array(self.derFunc(x_old)))\\n\\n x_new[0]=x_old[0]-part2[0]\\n x_new[1]=x_old[1]-part2[1]\\n if(abs(x_new[0]-x_old[0])>abs(x_new[1]-x_old[1])):\\n delta=abs(x_new[0]-x_old[0])\\n else:\\n delta=abs(x_new[1]-x_old[1])\\n\\n x_old[0]=x_new[0]\\n x_old[1]=x_new[1]\\n print \\\"printing x\\\",x_new\\n if(count>=self.step or eps>=delta):\\n return x_new.tolist()\\n \\n \\n else:\\n while(True):\\n count+=1\\n invJacobi=self.secJacobian(x_old)\\n if(type(invJacobi)==type(0)):##check that the jacobian is not singular\\n return x_new.tolist()\\n part2=np.dot(invJacobi,np.array(self.derFunc(x_old)))\\n \\n x_new[0]=x_old[0]-part2[0]\\n x_new[1]=x_old[1]-part2[1]\\n \\n if(abs(x_new[0]-x_old[0])>abs(x_new[1]-x_old[1])):\\n delta=abs(x_new[0]-x_old[0])\\n else:\\n delta=abs(x_new[1]-x_old[1])\\n \\n x_old[0]=x_new[0]\\n x_old[1]=x_new[1]\\n print \\\"printing x\\\", x_new\\n if(count>=self.step or eps>=delta):\\n return x_new.tolist()\",\n \"def newton(flogl, start, fgrad, fhess, maxiter):\\r\\n warn = 0\\r\\n iteration = 0\\r\\n par_hat0 = start\\r\\n m = 1\\r\\n while (iteration < maxiter and m >= 1e-04):\\r\\n H = -la.inv(fhess(par_hat0))\\r\\n g = fgrad(par_hat0).reshape(start.shape)\\r\\n Hg = np.dot(H, g)\\r\\n par_hat0 = par_hat0 + Hg\\r\\n iteration += 1\\r\\n m = np.dot(g.T, Hg)\\r\\n if iteration == maxiter:\\r\\n warn = 1\\r\\n logl = flogl(par_hat0)\\r\\n return (par_hat0, logl, warn)\",\n \"def newtonJacobian(self,r):\\n #x_vec=np.array(r)\\n x=r[0]\\n y=r[1]\\n jacobi=np.zeros([2,2], float)\\n \\n \\n jacobi[0][0]=(4.0*(self.x_0-x)**2.0-2.0)*self.sfunc(x,y)\\n jacobi[1][1]=(4.0*(self.y_0-y)**2.0-2.0)*self.sfunc(x,y)\\n jacobi[1][0]=4.0*(self.x_0-x)*(self.y_0-y)*self.sfunc(x,y)\\n jacobi[0][1]=jacobi[1][0]\\n #print \\\"newton jacobian is \\\",jacobi\\n try:\\n return mat.inv(jacobi)\\n except:\\n print \\\"singular jacobi not invertable\\\"\\n return 0\",\n \"def test_newton_rhapson(testFunctions, tol, printFlag): \\n pass\",\n \"def _compute_newton_step(lambdas, p_norm, w_norm):\\n return lambdas.candidate + (p_norm / w_norm) ** 2 * (p_norm - 1)\",\n \"def newton(backward_differences, max_num_iters, newton_coefficient, ode_fn_vec,\\n order, step_size, time, tol, unitary, upper):\\n initial_guess = tf.reduce_sum(\\n tf1.where(\\n tf.range(MAX_ORDER + 1) <= order,\\n backward_differences[:MAX_ORDER + 1],\\n tf.zeros_like(backward_differences)[:MAX_ORDER + 1]),\\n axis=0)\\n\\n np_dtype = np_dtype = dtype_util.as_numpy_dtype(backward_differences.dtype)\\n\\n rhs_constant_term = newton_coefficient * tf.reduce_sum(\\n tf1.where(\\n tf.range(1, MAX_ORDER + 1) <= order,\\n RECIPROCAL_SUMS[1:, np.newaxis].astype(np_dtype) *\\n backward_differences[1:MAX_ORDER + 1],\\n tf.zeros_like(backward_differences)[1:MAX_ORDER + 1]),\\n axis=0)\\n\\n next_time = time + step_size\\n step_size_cast = tf.cast(step_size, backward_differences.dtype)\\n real_dtype = tf.abs(backward_differences).dtype\\n\\n def newton_body(iterand):\\n \\\"\\\"\\\"Performs one iteration of Newton's method.\\\"\\\"\\\"\\n next_backward_difference = iterand.next_backward_difference\\n next_state_vec = iterand.next_state_vec\\n\\n rhs = newton_coefficient * step_size_cast * ode_fn_vec(\\n next_time,\\n next_state_vec) - rhs_constant_term - next_backward_difference\\n delta = tf.squeeze(\\n tf.linalg.triangular_solve(\\n upper,\\n tf.matmul(tf.transpose(unitary), rhs[:, tf.newaxis]),\\n lower=False))\\n num_iters = iterand.num_iters + 1\\n\\n next_backward_difference += delta\\n next_state_vec += delta\\n\\n delta_norm = tf.cast(tf.norm(delta), real_dtype)\\n lipschitz_const = delta_norm / iterand.prev_delta_norm\\n\\n # Stop if method has converged.\\n approx_dist_to_sol = lipschitz_const / (1. - lipschitz_const) * delta_norm\\n close_to_sol = approx_dist_to_sol < tol\\n delta_norm_is_zero = tf.equal(delta_norm, tf.constant(0., dtype=real_dtype))\\n converged = close_to_sol | delta_norm_is_zero\\n finished = converged\\n\\n # Stop if any of the following conditions are met:\\n # (A) We have hit the maximum number of iterations.\\n # (B) The method is converging too slowly.\\n # (C) The method is not expected to converge.\\n too_slow = lipschitz_const > 1.\\n finished = finished | too_slow\\n if max_num_iters is not None:\\n too_many_iters = tf.equal(num_iters, max_num_iters)\\n num_iters_left = max_num_iters - num_iters\\n num_iters_left_cast = tf.cast(num_iters_left, real_dtype)\\n wont_converge = (\\n approx_dist_to_sol * lipschitz_const**num_iters_left_cast > tol)\\n finished = finished | too_many_iters | wont_converge\\n\\n return [\\n _NewtonIterand(\\n converged=converged,\\n finished=finished,\\n next_backward_difference=next_backward_difference,\\n next_state_vec=next_state_vec,\\n num_iters=num_iters,\\n prev_delta_norm=delta_norm)\\n ]\\n\\n iterand = _NewtonIterand(\\n converged=False,\\n finished=False,\\n next_backward_difference=tf.zeros_like(initial_guess),\\n next_state_vec=tf.identity(initial_guess),\\n num_iters=0,\\n prev_delta_norm=tf.constant(np.array(-0.), dtype=real_dtype))\\n [iterand] = tf.while_loop(lambda iterand: tf.logical_not(iterand.finished),\\n newton_body, [iterand])\\n return (iterand.converged, iterand.next_backward_difference,\\n iterand.next_state_vec, iterand.num_iters)\",\n \"def newton_restart(fn, grad_fn, x_0, max_iters=20):\\n y_i = fn(x_0)\\n x_i = x_0\\n i = 0\\n while torch.abs(y_i) > 1e-6:\\n i = i + 1\\n grad_i = grad_fn(x_i)\\n x_i = x_i - y_i / grad_i\\n y_i = fn(x_i)\\n\\n if i == max_iters:\\n return None\\n\\n return x_i\",\n \"def Pol_Newton_un_punto(x,datos_x,datos_y):\\n n = datos_x.shape[0]\\n matriz=np.ones([n,n])\\n for j in range(n):\\n for i in range(n):\\n if j>i:\\n matriz[i][j]=0\\n else:\\n producto=1\\n for k in range(j):\\n producto=producto*(datos_x[i]-datos_x[k])\\n matriz[i][j]=producto\\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\\n x1 = descompo_LU(matriz,datos_y1)\\n prod=np.zeros(x1.shape[0])\\n for i in range(n):\\n if i==0:\\n prod[i]=1\\n else: \\n prod[i]=prod[i-1]*(x-datos_x[i-1])\\n solucion=x1@prod\\n return solucion\",\n \"def newtona(f, Df, x_0, M, epsilon):\\n xn = []\\n v = f(x_0)\\n k = 1\\n\\n while k<M:\\n xn.append(x_0)\\n if abs(v) < epsilon: #warunek pierwszy\\n break\\n\\n x_1 = x_0 - v/Df(x_0) #wzor metody iteracyjnej newtona\\n v = f(x_1)\\n\\n if abs(x_1 - x_0) < epsilon: #warunek drugi\\n break\\n x_0 = x_1\\n k=k+1\\n\\n return(x_0, xn)\",\n \"def Newton_system(F, J, cst, x, max_iter=100, eps=1e-4):\\n F_value = F(cst, x)\\n F_norm = np.linalg.norm(F_value, ord=2) # l2 norm of vector\\n iteration_counter = 0\\n while abs(F_norm) > eps and iteration_counter < max_iter:\\n try:\\n delta = np.linalg.solve(J(cst, x), -F_value)\\n except LinAlgError:\\n print(\\\"Singular matrix in np.linalg.solve, after \\\", iteration_counter, \\\" iterations.\\\")\\n return x, -1\\n else:\\n x = x + delta\\n F_value = F(cst, x)\\n F_norm = np.linalg.norm(F_value, ord=2)\\n iteration_counter += 1\\n\\n # Here, either a solution is found, or too many iterations\\n if abs(F_norm) > eps:\\n iteration_counter = -1\\n return x, iteration_counter\",\n \"def test_newton_rhapson_system(testFunctions, tol, printFlag): \\n pass\",\n \"def root_finding_newton_previously(fun, J, x, eps, max_iter, args):\\n F_value = fun(x, args)\\n F_value_ = F_value.reshape((-1,1))\\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\\n iteration_counter = 0\\n while abs(F_norm) > eps and iteration_counter < max_iter:\\n delta = np.linalg.solve(J(x, args), -F_value)\\n x = x + delta\\n F_value = fun(x, args)\\n F_value_ = F_value.reshape((-1,1))\\n F_norm = np.linalg.norm(F_value, 2)\\n iteration_counter += 1\\n\\n # Here, either a solution is found, or too many iterations\\n if abs(F_norm) > eps:\\n iteration_counter = -1\\n raise ValueError('Maximum iteration reached in newton root finding!')\\n return x, iteration_counter\",\n \"def root_finding_newton_previously(fun, J, x, eps, max_iter, args):\\n F_value = fun(x, args)\\n # F_value_ = F_value.reshape((-1, 1))\\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\\n iteration_counter = 0\\n while abs(F_norm) > eps and iteration_counter < max_iter:\\n delta = np.linalg.solve(J(x, args), -F_value)\\n x = x + delta\\n F_value = fun(x, args)\\n # F_value_ = F_value.reshape((-1, 1))\\n F_norm = np.linalg.norm(F_value, 2)\\n iteration_counter += 1\\n\\n # Here, either a solution is found, or too many iterations\\n if abs(F_norm) > eps:\\n iteration_counter = -1\\n raise ValueError(\\\"Maximum iteration reached in newton root finding!\\\")\\n return x, iteration_counter\",\n \"def Pol_Newton(x,datos_x,datos_y):\\n puntos=[]\\n for p in x:\\n n = datos_x.shape[0]\\n matriz=np.ones([n,n])\\n for j in range(n):\\n for i in range(n):\\n if j>i:\\n matriz[i][j]=0\\n else:\\n producto=1\\n for k in range(j):\\n producto=producto*(datos_x[i]-datos_x[k])\\n matriz[i][j]=producto\\n matriz,datos_y1= pivoteo_parcial(matriz,datos_y)\\n x1 = descompo_LU(matriz,datos_y1)\\n prod=np.zeros(x1.shape[0])\\n for i in range(n):\\n if i==0:\\n prod[i]=1\\n else: \\n prod[i]=prod[i-1]*(p-datos_x[i-1])\\n solucion=x1@prod\\n puntos.append(solucion)\\n puntos=np.array(puntos)\\n return puntos\",\n \"def ret_f(t,y):\\n\\n f = np.zeros(3)\\n f[0] = 77.27*(y(1) - y(0)*y(1)+ y(0)-8.375e-6*y(0)*y(0))\\n f[1] = (1.0/77.27)*(-y(1)-y(0)*y(1)+y(2))\\n f[2] = 0.161*(y(0)-y(2))\\n\\n return f\",\n \"def newtons_method(expr, wrt, atol=1e-12, delta=None, debug=False,\\n itermax=None, counter=None):\\n\\n if delta is None:\\n delta = Dummy()\\n Wrapper = Scope\\n name_d = 'delta'\\n else:\\n Wrapper = lambda x: x\\n name_d = delta.name\\n\\n delta_expr = -expr/expr.diff(wrt)\\n whl_bdy = [Assignment(delta, delta_expr), AddAugmentedAssignment(wrt, delta)]\\n if debug:\\n prnt = Print([wrt, delta], r\\\"{0}=%12.5g {1}=%12.5g\\\\n\\\".format(wrt.name, name_d))\\n whl_bdy = [whl_bdy[0], prnt] + whl_bdy[1:]\\n req = Gt(Abs(delta), atol)\\n declars = [Declaration(Variable(delta, type=real, value=oo))]\\n if itermax is not None:\\n counter = counter or Dummy(integer=True)\\n v_counter = Variable.deduced(counter, 0)\\n declars.append(Declaration(v_counter))\\n whl_bdy.append(AddAugmentedAssignment(counter, 1))\\n req = And(req, Lt(counter, itermax))\\n whl = While(req, CodeBlock(*whl_bdy))\\n blck = declars + [whl]\\n return Wrapper(CodeBlock(*blck))\",\n \"def f_inv(self, y, psi, iterations = 10):\\r\\n\\r\\n y = y.copy()\\r\\n z = np.ones_like(y)\\r\\n\\r\\n for i in range(iterations):\\r\\n z -= (self.f(z, psi) - y)/self.fgrad_y(z,psi)\\r\\n\\r\\n return z\",\n \"def newtons_method(fn, grad_fn, max_iters=20):\\n\\n x_0 = torch.normal(mean=torch.tensor(0.), std=10)\\n x = newton_restart(fn, grad_fn, x_0, max_iters=20)\\n\\n while x is None:\\n x_0 = torch.normal(mean=torch.tensor(0.), std=10)\\n x = newton_restart(fn, grad_fn, x_0, max_iters=20)\\n\\n return x\",\n \"def newton(f, xinit, tol, N):\\n if f(xinit) < tol:\\n return xinit\\n else:\\n n = 1\\n while n < N:\\n xnew = xinit - (f(xinit) / derivative(f, xinit))\\n if abs(f(xnew)) < tol:\\n print('Root found. Number of iterations: ', n)\\n return xnew\\n break\\n else:\\n xinit = xnew\\n n = n + 1\\n else:\\n return 'Max iterations reached. No root found within chosen tolerance.'\",\n \"def _newtons_method_gmres_action(f, initial_guess, max_iter=50, tol=1e-12):\\n\\n output_dim = len(f(initial_guess))\\n \\n @np.vectorize\\n def sum_values(dictionary):\\n return sum(dictionary.values())\\n \\n def create_action(x0):\\n \\n def L_fun(x):\\n \\\"\\\"\\\"\\n Action\\n Returns J_f(x0)*x by setting the values of 'x' as the initial derivatives for the variables in x0.\\n \\\"\\\"\\\"\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\\n \\n L = LinearOperator(shape=(output_dim, len(x0)), matvec=L_fun)\\n \\n return L\\n \\n x0 = initial_guess\\n for iter_num in range(max_iter):\\n L = create_action(x0)\\n b = -1 * np.array(f(x0))\\n if len(x0) == 1:\\n b = np.array([b])\\n step, _ = gmres(L, b, tol = tol, atol = 'legacy')\\n xnext = x0 + step \\n if np.all(np.abs(xnext - x0) < tol):\\n return (xnext, iter_num + 1);\\n x0 = xnext\\n \\n raise RuntimeError(\\\"Failed to converge after {0} iterations, value is {1}\\\".format(max_iter, x0) );\",\n \"def f(y):\\n \\n\\n k = 1.0\\n return y*(1-y)\",\n \"def f(self,y,psi):\\r\\n raise NotImplementedError\",\n \"def newton_body(iterand):\\n next_backward_difference = iterand.next_backward_difference\\n next_state_vec = iterand.next_state_vec\\n\\n rhs = newton_coefficient * step_size_cast * ode_fn_vec(\\n next_time,\\n next_state_vec) - rhs_constant_term - next_backward_difference\\n delta = tf.squeeze(\\n tf.linalg.triangular_solve(\\n upper,\\n tf.matmul(tf.transpose(unitary), rhs[:, tf.newaxis]),\\n lower=False))\\n num_iters = iterand.num_iters + 1\\n\\n next_backward_difference += delta\\n next_state_vec += delta\\n\\n delta_norm = tf.cast(tf.norm(delta), real_dtype)\\n lipschitz_const = delta_norm / iterand.prev_delta_norm\\n\\n # Stop if method has converged.\\n approx_dist_to_sol = lipschitz_const / (1. - lipschitz_const) * delta_norm\\n close_to_sol = approx_dist_to_sol < tol\\n delta_norm_is_zero = tf.equal(delta_norm, tf.constant(0., dtype=real_dtype))\\n converged = close_to_sol | delta_norm_is_zero\\n finished = converged\\n\\n # Stop if any of the following conditions are met:\\n # (A) We have hit the maximum number of iterations.\\n # (B) The method is converging too slowly.\\n # (C) The method is not expected to converge.\\n too_slow = lipschitz_const > 1.\\n finished = finished | too_slow\\n if max_num_iters is not None:\\n too_many_iters = tf.equal(num_iters, max_num_iters)\\n num_iters_left = max_num_iters - num_iters\\n num_iters_left_cast = tf.cast(num_iters_left, real_dtype)\\n wont_converge = (\\n approx_dist_to_sol * lipschitz_const**num_iters_left_cast > tol)\\n finished = finished | too_many_iters | wont_converge\\n\\n return [\\n _NewtonIterand(\\n converged=converged,\\n finished=finished,\\n next_backward_difference=next_backward_difference,\\n next_state_vec=next_state_vec,\\n num_iters=num_iters,\\n prev_delta_norm=delta_norm)\\n ]\",\n \"def newtons_method(expr, wrt, atol=1e-12, delta=None, *, rtol=4e-16, debug=False,\\n itermax=None, counter=None, delta_fn=lambda e, x: -e/e.diff(x),\\n cse=False, handle_nan=None,\\n bounds=None):\\n\\n if delta is None:\\n delta = Dummy()\\n Wrapper = Scope\\n name_d = 'delta'\\n else:\\n Wrapper = lambda x: x\\n name_d = delta.name\\n\\n delta_expr = delta_fn(expr, wrt)\\n if cse:\\n from sympy.simplify.cse_main import cse\\n cses, (red,) = cse([delta_expr.factor()])\\n whl_bdy = [Assignment(dum, sub_e) for dum, sub_e in cses]\\n whl_bdy += [Assignment(delta, red)]\\n else:\\n whl_bdy = [Assignment(delta, delta_expr)]\\n if handle_nan is not None:\\n whl_bdy += [While(isnan(delta), CodeBlock(handle_nan, break_))]\\n whl_bdy += [AddAugmentedAssignment(wrt, delta)]\\n if bounds is not None:\\n whl_bdy += [Assignment(wrt, Min(Max(wrt, bounds[0]), bounds[1]))]\\n if debug:\\n prnt = Print([wrt, delta], r\\\"{}=%12.5g {}=%12.5g\\\\n\\\".format(wrt.name, name_d))\\n whl_bdy += [prnt]\\n req = Gt(Abs(delta), atol + rtol*Abs(wrt))\\n declars = [Declaration(Variable(delta, type=real, value=oo))]\\n if itermax is not None:\\n counter = counter or Dummy(integer=True)\\n v_counter = Variable.deduced(counter, 0)\\n declars.append(Declaration(v_counter))\\n whl_bdy.append(AddAugmentedAssignment(counter, 1))\\n req = And(req, Lt(counter, itermax))\\n whl = While(req, CodeBlock(*whl_bdy))\\n blck = declars\\n if debug:\\n blck.append(Print([wrt], r\\\"{}=%12.5g\\\\n\\\".format(wrt.name)))\\n blck += [whl]\\n return Wrapper(CodeBlock(*blck))\",\n \"def root_finding_newton(fun, J, x, eps, max_iter, args):\\n F_value = fun(x, *args)\\n F_value_ = F_value.reshape((-1,1))\\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\\n iteration_counter = 0\\n while abs(F_norm) > eps and iteration_counter < max_iter:\\n delta = np.linalg.solve(J(x, args), -F_value_)\\n\\n for i in range(x.size): #wtf numba!?!?!\\n x[i] += delta[i,0]\\n\\n F_value = fun(x, *args)\\n F_value_ = F_value.reshape((-1,1))\\n F_norm = np.linalg.norm(F_value, 2)\\n iteration_counter += 1\\n\\n # Here, either a solution is found, or too many iterations\\n if abs(F_norm) > eps:\\n iteration_counter = -1\\n raise ValueError('Maximum iteration reached in newton root finding!')\\n return x, iteration_counter\",\n \"def fgrad_y(self,y,psi):\\r\\n raise NotImplementedError\",\n \"def gaussNewton(f, df, jac, r, x, niter=10):\\n\\n for i in xrange(niter):\\n #check if it's close enough\\n if np.allclose(np.dot(jac(x).T, r(x)), 0):\\n return x\\n\\n else:\\n p = la.solve(np.dot(jac(x).T, jac(x)), -np.dot(jac(x).T, r(x)))\\n\\n a = line_search(f, df, x, p)[0]\\n if a is None:\\n return x\\n else:\\n x_k = x + a*p\\n\\n return x_k\",\n \"def newton_method_bidirectional(f, bnd1, bnd2, Ep, step):\\n\\n while True:\\n step = step + 1\\n\\n # print(\\\"bnd1=\\\",bnd1,\\\" and bnd2=\\\",bnd2)\\n\\n h_bnd1 = f(bnd1) / derivative(f, bnd1)\\n bnd1 = bnd1 - h_bnd1\\n if (decide(abs(h_bnd1) <= Ep)):\\n # print(\\\"Root in Approximation: \\\",bnd1)\\n return step\\n\\n h_bnd2 = f(bnd2) / derivative(f, bnd2)\\n bnd2 = bnd2 - h_bnd2\\n if (decide(abs(h_bnd2) <= Ep)):\\n # print(\\\"Root in Approximation: \\\",bnd2)\\n return step\",\n \"def find_zero(f, df):\\n def near_zero(x):\\n return approx_eq(f(x), 0)\\n return improve(newton_update(f, df), near_zero)\",\n \"def f(self,y,psi):\\r\\n\\r\\n #1. check that number of params is consistent\\r\\n # assert psi.shape[0] == self.n_terms, 'inconsistent parameter dimensions'\\r\\n # assert psi.shape[1] == 4, 'inconsistent parameter dimensions'\\r\\n mpsi = psi.copy()\\r\\n d = psi[-1]\\r\\n mpsi = mpsi[:self.num_parameters-1].reshape(self.n_terms, 3)\\r\\n\\r\\n #3. transform data\\r\\n z = d*y.copy()\\r\\n for i in range(len(mpsi)):\\r\\n a,b,c = mpsi[i]\\r\\n z += a*np.tanh(b*(y+c))\\r\\n return z\",\n \"def derivative_given_y(self, y):\\n return 1\",\n \"def jacobian(self,x,p,fun):\\n n = self.n\\n y = fun(x,p)\\n h = 1e-4\\n nout = np.size(y)\\n dfdx = np.zeros((nout,n))\\n for j in range(n):\\n dx1 = np.zeros(n)\\n dx2 = np.zeros(n)\\n dx1[j] = -h\\n dx2[j] = h\\n dfdx[:,j] = (fun(x+dx2,p)-fun(x+dx1,p))/(2*h)\\n return dfdx\",\n \"def derivatives(x_p, y_p):\\r\\n # set up the matrix equation\\r\\n n = x_p.shape[0]\\r\\n M = np.zeros( [n,n] )\\r\\n d = np.zeros( [n,1] )\\r\\n \\r\\n # fill in the constants where they can be\\r\\n for i in np.arange(1,n-1 ): # for all but the first and last row\\r\\n M[i,i-1 ] = ( x_p[i] - x_p[i-1] ) / 6.\\r\\n M[i,i] = ( x_p[i+1] - x_p[i-1] ) / 3.\\r\\n M[i,i+1] = ( x_p[i+1] - x_p[i] ) /6.\\r\\n d[i,0 ] = ( y_p[i+1] - y_p[i] ) / ( x_p[i+1] - x_p[i] ) - ( y_p[i] - y_p[i-1] ) / ( x_p[i] - x_p[i-1] )\\r\\n \\r\\n M[0,0],M[-1,-1] = 1.,1. # compactly sets the BCs\\r\\n \\r\\n LU = lu.LU_decomp(M) # solves the matrix equations\\r\\n return lu.FB_sub(LU.Low, LU.Upp, d) # find and return 2nd derivatives\\r\",\n \"def newtons_method_function(expr, wrt, params=None, func_name=\\\"newton\\\", attrs=Tuple(), **kwargs):\\n if params is None:\\n params = (wrt,)\\n pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)\\n for p in params if isinstance(p, Pointer)}\\n delta = kwargs.pop('delta', None)\\n if delta is None:\\n delta = Symbol('d_' + wrt.name)\\n if expr.has(delta):\\n delta = None # will use Dummy\\n algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)\\n if isinstance(algo, Scope):\\n algo = algo.body\\n not_in_params = expr.free_symbols.difference(set(_symbol_of(p) for p in params))\\n if not_in_params:\\n raise ValueError(\\\"Missing symbols in params: %s\\\" % ', '.join(map(str, not_in_params)))\\n declars = tuple(Variable(p, real) for p in params)\\n body = CodeBlock(algo, Return(wrt))\\n return FunctionDefinition(real, func_name, declars, body, attrs=attrs)\",\n \"def f_inv(self, z, psi, max_iterations=1000, y=None):\\r\\n\\r\\n z = z.copy()\\r\\n if y is None:\\r\\n y = np.ones_like(z)\\r\\n \\r\\n it = 0\\r\\n update = np.inf\\r\\n\\r\\n while it == 0 or (np.abs(update).sum() > 1e-10 and it < max_iterations):\\r\\n update = (self.f(y, psi) - z)/self.fgrad_y(y, psi)\\r\\n y -= update\\r\\n it += 1\\r\\n if it == max_iterations:\\r\\n print \\\"WARNING!!! Maximum number of iterations reached in f_inv \\\"\\r\\n\\r\\n return y\",\n \"def f(self, t, y, n):\\n y1, y2 = y\\n return y2, -np.absolute(y1)**n - 2 * y2 / t\",\n \"def func_ludwigson(eps,k1,n1,k2,n2,):\\n return k1*eps**n1+np.exp(k2+n2*eps)\",\n \"def f(self,y,psi):\\r\\n\\r\\n #1. check that number of params is consistent\\r\\n assert psi.shape[0] == self.n_terms, 'inconsistent parameter dimensions'\\r\\n assert psi.shape[1] == 3, 'inconsistent parameter dimensions'\\r\\n\\r\\n #2. exponentiate the a and b (positive!)\\r\\n mpsi = psi.copy()\\r\\n\\r\\n #3. transform data\\r\\n z = y.copy()\\r\\n for i in range(len(mpsi)):\\r\\n a,b,c = mpsi[i]\\r\\n z += a*np.tanh(b*(y+c))\\r\\n return z\",\n \"def newtons_method_function(expr, wrt, params=None, func_name=\\\"newton\\\", attrs=Tuple(), *, delta=None, **kwargs):\\n if params is None:\\n params = (wrt,)\\n pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)\\n for p in params if isinstance(p, Pointer)}\\n if delta is None:\\n delta = Symbol('d_' + wrt.name)\\n if expr.has(delta):\\n delta = None # will use Dummy\\n algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)\\n if isinstance(algo, Scope):\\n algo = algo.body\\n not_in_params = expr.free_symbols.difference({_symbol_of(p) for p in params})\\n if not_in_params:\\n raise ValueError(\\\"Missing symbols in params: %s\\\" % ', '.join(map(str, not_in_params)))\\n declars = tuple(Variable(p, real) for p in params)\\n body = CodeBlock(algo, Return(wrt))\\n return FunctionDefinition(real, func_name, declars, body, attrs=attrs)\",\n \"def F(x):\\n soln = x - (1.0/5.0)*math.cos(10.0*x+1.0) \\n return soln\",\n \"def smale_newton(f, x0, df=(), args=(), tol=1.48e-8, maxiter=50):\\n # skip using smale alpha if not enough derivatives are provided\\n if len(df) < 2:\\n warnings.warn('not enough derivatives provided for smale',\\n RuntimeWarning)\\n else:\\n # raise a warning if x0 is not an approximate solution\\n alpha = smale_alpha(f, x0, df, args=args)\\n if alpha > 0.15767078078675478:\\n warnings.warn('the estimate may not be an approximate solution to the '\\n 'function', RuntimeWarning)\\n\\n # newton iterate (omit use of fprime2 due to unknown issues)\\n fprime = df[0] if len(df) > 0 else None\\n zero = newton(f, x0, fprime=fprime, args=args, tol=tol, maxiter=maxiter)\\n return zero\",\n \"def fgrad_y_psi(self,y,psi):\\r\\n raise NotImplementedError\",\n \"def newtons_method(function, start, epsilon_rounding=6):\\n point = start\\n\\n f = get_gradient(function)\\n jacobian_matrix = get_jacobian(f)\\n inverse_jacobian = jacobian_matrix.inv()\\n\\n f_subs = gradient_subs(f, point)\\n\\n temp = [0, 0]\\n\\n points = [point]\\n while temp != point:\\n jacobian_subs_matrix = matrix_subs(jacobian_matrix, point)\\n inverse_subs_jacobian = matrix_subs(inverse_jacobian, point)\\n negative_gradient = Matrix([-x for x in f_subs])\\n solution = Ax_b(jacobian_subs_matrix, negative_gradient)\\n temp = [round(float(x), epsilon_rounding) for x in point]\\n point = [a + b for a, b in zip(solution, point)]\\n point = [round(float(x), epsilon_rounding) for x in point]\\n points.append(point)\\n f_subs = gradient_subs(f, point)\\n new_minimum = [float(x) for x in point]\\n\\n return new_minimum, points, f\\\"The minimum is {new_minimum}, with a starting point of {start}\\\"\",\n \"def f(z):\\n omega_m = 0.308\\n omega_de = 0.692\\n #omega = omega_m*(1+z)**3\\n #return omega**0.6 + omega_de/70*(1+omega/2) # Dodelson approx\\n\\n omega = omega_m*(1+z)**3*H(0)**2/H(z)**2\\n omega_de = omega_de*H(0)**2/H(z)**2\\n return omega**(4/7) + omega_de/70*(1+omega/2) # Dodelson approx\\n #return 5*omega/(2*(omega**(4/7) - omega_de + (1 + omega/2)*(1 + omega_de/70)))\\n #return omega**0.55\",\n \"def root_finding_newton(fun, J, x, eps, max_iter, args):\\n F_value = fun(x, args)\\n F_value_ = F_value.reshape((-1, 1))\\n F_norm = np.linalg.norm(F_value, 2) # l2 norm of vector\\n iteration_counter = 0\\n while abs(F_norm) > eps and iteration_counter < max_iter:\\n delta = np.linalg.solve(J(x, args), -F_value_)\\n\\n for i in range(x.size): # wtf numba!?!?!\\n x[i] += delta[i, 0]\\n\\n F_value = fun(x, args)\\n F_value_ = F_value.reshape((-1, 1))\\n F_norm = np.linalg.norm(F_value, 2)\\n iteration_counter += 1\\n\\n # Here, either a solution is found, or too many iterations\\n if abs(F_norm) > eps:\\n iteration_counter = -1\\n raise ValueError(\\\"Maximum iteration reached in newton root finding!\\\")\\n return x, iteration_counter\",\n \"def flow_inference_newton_raphson(self,newton_raphson_max_iters:int = 100,dsf_max_iters:int = 1000,show_params:bool=False,**params):\\n\\n # Define empty array of flows\\n flows = np.ones((self.N,self.M)).astype('float64')\\n\\n # Define initial \\\\beta if beta is not zero (default value)\\n if params['beta'] == 0.0:\\n # See suggestion in page 386 of \\\"Gravity Models of Spatial Interaction Behavior\\\" book\\n beta = np.ones((newton_raphson_max_iters)) * 1.5 * (1./self.total_cost)\\n else:\\n beta = np.ones((newton_raphson_max_iters)) * params['beta']\\n\\n # Define initial cost of beta\\n c_beta = np.zeros(newton_raphson_max_iters)\\n\\n # Infer flows\\n value = self.infer_flows_newton_raphson(flows,beta,c_beta,self.origin_supply,self.destination_demand,self.cost_matrix,self.total_cost,self.N,self.M,dsf_max_iters,newton_raphson_max_iters)\\n\\n # Trim beta and c_beta arrays if they were not used in full\\n beta = beta[~np.isnan(beta)]\\n c_beta = c_beta[c_beta>=0]\\n\\n # Print parameters if requested\\n if show_params:\\n print('\\\\n')\\n print('Beta',beta)\\n print('Cost(beta)',c_beta)\\n\\n return flows,beta,c_beta\",\n \"def f(t,y):\\n return np.array([lam*y[0] + (1.0-lam)*np.cos(t) - (1.0+lam)*np.sin(t)])\",\n \"def Newton(f, x0, tol, kmax, c=0.5, tao=1e-6, reg_const=1e-7):\\r\\n\\r\\n k = 1\\r\\n\\r\\n xk = x0.copy() # We don't want to change x0 from the outside scope\\r\\n\\r\\n # Cache for f(xk) in case the calculation is expensive\\r\\n # - Should save 2-3 function evaluations per outside loop iteration\\r\\n f_xk = f(xk)\\r\\n\\r\\n s = LA.norm(f_xk)**2\\r\\n\\r\\n while np.sqrt(s) > tol and k < kmax:\\r\\n # Build the Jacobian matrix approximation using Central Differences\\r\\n H = _CentralDifferencesJacobian(f, xk, tao)\\r\\n\\r\\n try:\\r\\n # Uses LAPACK _gesv to solve H*dk = -f(xk)\\r\\n dk = LA.solve(H, -f_xk)\\r\\n except LA.LinAlgError:\\r\\n # Most likely here because the above H is singular\\r\\n # Therefore we regularize by adding a small (1e-7) multiple of I:\\r\\n dk = LA.solve(H + reg_const*np.eye(xk.shape[0]), -f_xk)\\r\\n\\r\\n z = c*LA.norm(np.matmul(f_xk.T, H))*LA.norm(dk)\\r\\n\\r\\n # Solve the step size using the method by Stoer and Bulirsch\\r\\n j = 0\\r\\n L = LA.norm(f(xk + dk))**2\\r\\n R = s-z\\r\\n Lmin = L\\r\\n index = 0\\r\\n while L > R:\\r\\n j += 1\\r\\n L = LA.norm(f(xk + 2**(-j)*dk))**2\\r\\n R = s - 2**(-j)*z\\r\\n if L < Lmin:\\r\\n Lmin = L\\r\\n index = j\\r\\n\\r\\n # Update xk\\r\\n xk = xk + 2**(-index)*dk\\r\\n\\r\\n k += 1\\r\\n\\r\\n # Cache the new f(xk)\\r\\n f_xk = f(xk)\\r\\n\\r\\n s = LA.norm(f_xk)**2\\r\\n\\r\\n # If kmax gets exceeded, we can't trust the answer so issue a warning\\r\\n if k >= kmax:\\r\\n # For debugging purposes\\r\\n # print(\\\"k exceeded kmax, can't trust answer\\\")\\r\\n # return xk\\r\\n warnings.warn(\\\"kmax exceeded, consider raising it\\\", NonConvergenceWarning)\\r\\n\\r\\n # Otherwise, we stopped the above loop because we're within tolerance so the answer is good\\r\\n return xk, k\",\n \"def _get_F(self, omega, y): \\n x = y[:-1]\\n newt_lambda = y[-1]\\n F = np.zeros([len(x)+1, 1])\\n F[:-1] = omega @ x - newt_lambda/x\\n F[-1] = x.sum()-1\\n return F\",\n \"def f(t,y):\\n return (lam*y)\",\n \"def _derY(self, x, y):\\n if _isscalar(x):\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n else:\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n alpha = (x - self.x_list[x_pos - 1]) / (\\n self.x_list[x_pos] - self.x_list[x_pos - 1]\\n )\\n dfdy = (\\n (\\n (1 - alpha) * self.f_values[x_pos - 1, y_pos]\\n + alpha * self.f_values[x_pos, y_pos]\\n )\\n - (\\n (1 - alpha) * self.f_values[x_pos - 1, y_pos - 1]\\n + alpha * self.f_values[x_pos, y_pos - 1]\\n )\\n ) / (self.y_list[y_pos] - self.y_list[y_pos - 1])\\n return dfdy\",\n \"def f(x):\\n return np.tan(x) - np.sin(x) - (m*g)/(2*k*L)\",\n \"def hessian(f, delta=DELTA):\\n def hessian_f(*args, **kwargs):\\n if len(args) == 1:\\n x, = args\\n hessianf_x = (\\n f(x+delta) + f(x-delta) - 2*f(x)\\n )/delta**2\\n return hessianf_x\\n elif len(args) == 2:\\n x, y = args\\n if type(x) in [float, int] and type(y) in [float, int]:\\n hess_xx = (\\n f(x + delta, y) + f(x - delta, y) - 2*f(x, y)\\n )/delta**2\\n hess_yy = (\\n f(x, y + delta) + f(x, y - delta) - 2*f(x, y)\\n )/delta**2\\n hess_xy = (\\n + f(x+delta/2, y+delta/2)\\n + f(x-delta/2, y-delta/2)\\n - f(x+delta/2, y-delta/2)\\n - f(x-delta/2, y+delta/2)\\n )/delta**2\\n return hess_xx, hess_xy, hess_yy\\n return hessian_f\",\n \"def f(t,y):\\n return np.array([lam*y[0] + (1.0-lam)*np.cos(t) - (1.0+lam)*np.sin(t)])\",\n \"def fit(self, start_params=None, method='newton', maxiter=100,\\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\\n skip_hessian=False, **kwargs):\\n Hinv = None # JP error if full_output=0, Hinv not defined\\n\\n start_params = self._get_start_params(start_params)\\n\\n # TODO: separate args from nonarg taking score and hessian, ie.,\\n # user-supplied and numerically evaluated estimate frprime doesn't take\\n # args in most (any?) of the optimize function\\n\\n nobs = self.endog.shape[0]\\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\\n\\n def f(params, *args):\\n return -self.loglike(params, *args) / nobs\\n\\n if method == 'newton':\\n # TODO: why are score and hess positive?\\n def score(params, *args):\\n return self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return self.hessian(params, *args) / nobs\\n else:\\n def score(params, *args):\\n return -self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return -self.hessian(params, *args) / nobs\\n\\n warn_convergence = kwargs.pop('warn_convergence', True)\\n optimizer = Optimizer()\\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\\n fargs, kwargs,\\n hessian=hess,\\n method=method,\\n disp=disp,\\n maxiter=maxiter,\\n callback=callback,\\n retall=retall,\\n full_output=full_output)\\n\\n # NOTE: this is for fit_regularized and should be generalized\\n cov_params_func = kwargs.setdefault('cov_params_func', None)\\n if cov_params_func:\\n Hinv = cov_params_func(self, xopt, retvals)\\n elif method == 'newton' and full_output:\\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\\n # TODO: try/except for non-invertible hessian?\\n elif not skip_hessian:\\n H = -1 * self.hessian(xopt)\\n invertible = False\\n if np.all(np.isfinite(H)):\\n eigvals, eigvecs = np.linalg.eigh(H)\\n if np.min(eigvals) > 0:\\n invertible = True\\n\\n if invertible:\\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\\n else:\\n warnings.warn('Inverting hessian failed, no bse or cov_params '\\n 'available', HessianInversionWarning)\\n Hinv = None\\n\\n if 'cov_type' in kwargs:\\n cov_kwds = kwargs.get('cov_kwds', {})\\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\\n else:\\n kwds = {}\\n if 'use_t' in kwargs:\\n kwds['use_t'] = kwargs['use_t']\\n # TODO: add Hessian approximation and change the above if needed\\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\\n\\n # TODO: hardcode scale?\\n if isinstance(retvals, dict):\\n mlefit.mle_retvals = retvals\\n if warn_convergence and not retvals['converged']:\\n warnings.warn(\\\"Maximum Likelihood optimization failed to \\\"\\n \\\"converge. Check mle_retvals\\\",\\n ConvergenceWarning)\\n\\n mlefit.mle_settings = optim_settings\\n return mlefit\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def prob2(N1, N2, P1, P2):\\r\\n #initialize function and its derivative\\r\\n f = lambda x: P1*((1+x)**N1-1)-P2*(1-(1+x)**-N2)\\r\\n Df = grad(f)\\r\\n #use Newton's method\\r\\n r,conv,iter = newton(f,.1,Df)\\r\\n return r\",\n \"def f_y(Y, betas, sigma, nodes):\\n\\n # set-up\\n if len(betas.shape) == 1:\\n betas = np.array([betas]).T\\n X = 1 - Y # X: NxI matrix\\n N, I = np.shape(Y)\\n M = len(nodes)\\n\\n # sufficient statistics\\n r = Y.sum(axis=1) # Nx1 vector\\n q = Y.sum(axis=0) # Ix1 vector\\n\\n ### equation (13) in paper\\n # numerator: NxM matrix\\n to_exp = (np.outer(I - r, -sigma * nodes) + X.dot(betas))\\n numerator = np.exp(to_exp)\\n\\n # denomenator: Mx1 vector\\n denomenator = (np.outer(np.exp(-sigma * nodes), np.exp(betas)) + 1).prod(axis=1)\\n\\n # conditional likelihood: NxM matrix\\n CLF = numerator / denomenator\\n return CLF\",\n \"def _f(X, g, n):\\n if n == 3:\\n n = 3.001 # for numerical stability\\n hyp2f1_term = hyp2f1((n-1)/2, g/2, n/2, 1/(1+X**2))\\n beta_term = beta((n-1)/2, 0.5)\\n return 0.5 * beta_term * hyp2f1_term * (1+X**2) ** ((1-n)/2)\",\n \"def log_likelihood_gradients_(self, y, f):\\n log_lik = self.evaluate_log_likelihood(y, f)\\n f = np.squeeze(f)\\n J = jacrev(self.evaluate_log_likelihood, argnums=1)\\n H = jacrev(J, argnums=1)\\n return log_lik, J(y, f), H(y, f)\",\n \"def fgrad_y(self, y, psi, return_precalc = False):\\r\\n\\r\\n\\r\\n mpsi = psi.copy()\\r\\n d = psi[-1]\\r\\n mpsi = mpsi[:self.num_parameters-1].reshape(self.n_terms, 3)\\r\\n\\r\\n # vectorized version\\r\\n\\r\\n S = (mpsi[:,1]*(y[:,:,None] + mpsi[:,2])).T\\r\\n R = np.tanh(S)\\r\\n D = 1-R**2\\r\\n\\r\\n GRAD = (d + (mpsi[:,0:1][:,:,None]*mpsi[:,1:2][:,:,None]*D).sum(axis=0)).T\\r\\n\\r\\n if return_precalc:\\r\\n return GRAD, S, R, D\\r\\n\\r\\n\\r\\n return GRAD\",\n \"def newton(n, k):\\n if k == 0 or k == n:\\n return 1\\n else:\\n return newton(n - 1, k - 1) + newton(n - 1, k)\",\n \"def func(x, f, fp):\\n\\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def lnlike(params, cos2, y, yerr):\\n a, b, f = params\\n model = f * (b * cos2**2 + a * cos2 + 1)\\n\\n return -0.5 * np.sum((y - model)**2 / yerr**2 + np.log(yerr**2))\",\n \"def f1d(t,y,float_params,sigmaI): #sigmastep is an array\\n \\n ## y is Ntot0 ##\\n\\n # unpack parameters\\n Nbar, Nstar, sigma0, nu_kin_mlyperus, DoverdeltaX2 = float_params \\n\\n # Ntot is passed in, Fqll calculated from Ntot\\n Ntot0 = np.ascontiguousarray(y)\\n Nqll0 = Nbar - Nstar * np.sin(2*np.pi*(Ntot0))\\n\\n # Calc surface deposition, dNtot_dt before diffusion\\n m = (Nqll0 - (Nbar - Nstar))/(2*Nstar)\\n sigmaM = (sigmaI - m * sigma0)/(1+m*sigma0)\\n depsurf = nu_kin_mlyperus * sigmaM\\n dNtot_dt = depsurf\\n\\n # Diffusion\\n dy = diffuse_1d(Nqll0,DoverdeltaX2)\\n dNtot_dt += dy \\n\\n # Package for output, only values of dNtot\\n derivs = dNtot_dt\\n return derivs\",\n \"def fn(a, y):\\n return 0.5*np.linalg.norm(a-y)**2\",\n \"def ThetaMethod(f, iv : Array[float], t0 : float, tn : float, h : float, theta : float, df = None, TOL : float = 1.0e-5, NEWTITER : int = 10) -> Array[float]:\\n\\n\\tif h <= 0.0:\\n\\t\\traise ValueError('The stepsize h must be positive')\\n\\n\\tif (tn - t0) <= 0.0:\\n\\t\\traise ValueError('The final time must be greater than the initial time')\\n\\n\\tif not 0 <= theta <= 1:\\n\\t\\traise ValueError('Theta has to be between 0 and 1')\\n\\n\\tif TOL <= 0.0:\\n\\t\\traise ValueError('The numerical tolerance must be positive')\\n\\n\\tif (theta != 1) and (NEWTITER < 0.0):\\n\\t\\traise ValueError('The maximum number of Newton Iteration steps must be positive')\\n\\n\\tif (theta != 1) and df is None:\\n\\t\\traise NotImplementedError('Automatic differentiation not implemented yet. Please provide the Jacobian of f')\\n\\n\\tN : np.int = np.int(np.ceil((tn - t0)/h));\\t# number of steps\\n\\n\\tx = np.empty((np.int(N+1),iv.size), float);\\t# preallocating the array (+1 for including initial condition)\\n\\tx[0,:] = iv;\\n\\n\\tif (theta == 1):\\n\\t\\tfor i in range(N):\\n\\t\\t\\tx[i+1,:] = _ExplicitEuler_step(f,x[i,:],(t0+h*i),h);\\n\\telse:\\n\\t\\tfor i in range(N):\\n\\t\\t\\tx[i+1,:] = _Theta_step(f,df,x[i,:],(t0+h*i),h,theta,TOL,NEWTITER);\\n\\n\\treturn x;\",\n \"def reg_logistic_regression_newton(y, tx, lambda_, initial_w, max_iters, gamma, debug = False):\\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_logistic.reg_loss, grad_f = model_logistic.newton_reg_grad, kwargs = {'lambda_': lambda_}, debug = debug)\\n return get_last_ans(ws, losses)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7441877","0.7211542","0.71977335","0.719035","0.7187115","0.71342146","0.71297497","0.7069365","0.7065893","0.70429343","0.69355184","0.68557405","0.6837517","0.68288064","0.68169826","0.6779649","0.6760478","0.6721544","0.6686242","0.6662009","0.6661222","0.66215533","0.66171205","0.65835214","0.65044904","0.6497888","0.6450938","0.6439893","0.63913757","0.6383677","0.6371147","0.6355948","0.63460636","0.63227224","0.6292592","0.62257385","0.620394","0.61831033","0.6182399","0.6119931","0.6099727","0.60970664","0.60916865","0.60895616","0.60852426","0.60695046","0.60336614","0.60174143","0.59957886","0.5992391","0.59710884","0.5946169","0.5942058","0.5928079","0.5926085","0.5877408","0.5876071","0.58746046","0.5865212","0.58636266","0.58390784","0.5811232","0.5785818","0.57800895","0.5775083","0.57700026","0.57610226","0.57599556","0.57430863","0.5729516","0.5708589","0.57033396","0.5702656","0.57025284","0.56977683","0.5688399","0.5685833","0.56834894","0.5667546","0.5666139","0.564057","0.56230265","0.56145865","0.5605889","0.56022024","0.55912524","0.5590234","0.55899805","0.557027","0.5558623","0.55509096","0.5534548","0.5528143","0.55266577","0.5526478","0.5518146","0.5515462","0.54974025","0.5483056","0.5470649","0.54520005"],"string":"[\n \"0.7441877\",\n \"0.7211542\",\n \"0.71977335\",\n \"0.719035\",\n \"0.7187115\",\n \"0.71342146\",\n \"0.71297497\",\n \"0.7069365\",\n \"0.7065893\",\n \"0.70429343\",\n \"0.69355184\",\n \"0.68557405\",\n \"0.6837517\",\n \"0.68288064\",\n \"0.68169826\",\n \"0.6779649\",\n \"0.6760478\",\n \"0.6721544\",\n \"0.6686242\",\n \"0.6662009\",\n \"0.6661222\",\n \"0.66215533\",\n \"0.66171205\",\n \"0.65835214\",\n \"0.65044904\",\n \"0.6497888\",\n \"0.6450938\",\n \"0.6439893\",\n \"0.63913757\",\n \"0.6383677\",\n \"0.6371147\",\n \"0.6355948\",\n \"0.63460636\",\n \"0.63227224\",\n \"0.6292592\",\n \"0.62257385\",\n \"0.620394\",\n \"0.61831033\",\n \"0.6182399\",\n \"0.6119931\",\n \"0.6099727\",\n \"0.60970664\",\n \"0.60916865\",\n \"0.60895616\",\n \"0.60852426\",\n \"0.60695046\",\n \"0.60336614\",\n \"0.60174143\",\n \"0.59957886\",\n \"0.5992391\",\n \"0.59710884\",\n \"0.5946169\",\n \"0.5942058\",\n \"0.5928079\",\n \"0.5926085\",\n \"0.5877408\",\n \"0.5876071\",\n \"0.58746046\",\n \"0.5865212\",\n \"0.58636266\",\n \"0.58390784\",\n \"0.5811232\",\n \"0.5785818\",\n \"0.57800895\",\n \"0.5775083\",\n \"0.57700026\",\n \"0.57610226\",\n \"0.57599556\",\n \"0.57430863\",\n \"0.5729516\",\n \"0.5708589\",\n \"0.57033396\",\n \"0.5702656\",\n \"0.57025284\",\n \"0.56977683\",\n \"0.5688399\",\n \"0.5685833\",\n \"0.56834894\",\n \"0.5667546\",\n \"0.5666139\",\n \"0.564057\",\n \"0.56230265\",\n \"0.56145865\",\n \"0.5605889\",\n \"0.56022024\",\n \"0.55912524\",\n \"0.5590234\",\n \"0.55899805\",\n \"0.557027\",\n \"0.5558623\",\n \"0.55509096\",\n \"0.5534548\",\n \"0.5528143\",\n \"0.55266577\",\n \"0.5526478\",\n \"0.5518146\",\n \"0.5515462\",\n \"0.54974025\",\n \"0.5483056\",\n \"0.5470649\",\n \"0.54520005\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93080,"cells":{"query":{"kind":"string","value":"Return the pending number of messages in the queue by doing a passive Queue declare."},"document":{"kind":"string","value":"def __len__(self):\n response = self._rpc(self._declare(True))\n return response.message_count"},"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 num_pending(status=\"pending\", username=\"garrett.wilson\"):\n cmd = [\n \"squeue\",\n \"-u\", username,\n \"-t\", status,\n \"-h\"\n ]\n\n output = subprocess.check_output(cmd)\n output = output.decode(\"utf-8\").strip()\n\n if output == \"\":\n return 0\n\n return len(output.split(\"\\n\"))","def getQueueCount(self, force=False):\n if self.queuecount == -1 or force:\n self.queuecount = self.db.queuecount()\n\n return self.queuecount","def test_get_queue_msg_count1(self):\n self.queue.direct_declare(TEST_QUEUE)\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\n\n msg_count = self.queue.get_queue_msg_count(TEST_QUEUE)\n assert isinstance(msg_count, int)","def declare(self, passive=False):\n response = self._rpc(self._declare(passive))\n return response.message_count, response.consumer_count","def get_pending_messages():\n global logger\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n msg = \"exception 1 in connecting\"\n logger.debug(msg)\n # print(msg)\n time.sleep(3)\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n logger.debug(msg+\" for the second time\")\n return -1\n channel = connection.channel()\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\n num = queue.method.message_count\n connection.close()\n return num","def get_queue_number(self):\n outstring = self.dut.send_expect(\"stop\", \"testpmd> \")\n time.sleep(2)\n result_scanner = r\"Forward Stats for RX Port= %s/Queue=\\s?([0-9]+)\" % self.dut_ports[0]\n scanner = re.compile(result_scanner, re.DOTALL)\n m = scanner.search(outstring)\n queue_id = m.group(1)\n print \"queue is %s\" % queue_id\n self.dut.send_expect(\"start\", \"testpmd> \")\n return queue_id","def get_queue_size(queue):\n with current_celery_app.pool.acquire(block=True) as connection:\n bound_queue = queue.bind(connection)\n _, size, _ = bound_queue.queue_declare(passive=True)\n return size","def queue_count(self):\n with self.mutex:\n return len(self.queues)","def ctrlqueue_num_actions(self) -> int:\n try:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(2), ctypes.c_int32(0))\n except Exception as e:\n Base.warn_msg(\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\", e)","def queue_size(self):\n # pylint: disable=protected-access\n if self._handler._received_messages:\n return self._handler._received_messages.qsize()\n return 0","def count_remaining(self):\n\t\treturn self._queue.qsize()","def count_remaining(self):\n\t\treturn self._queue.qsize()","def queue_message_count(self, queue_name):\n queue_list = self.__session.getObjects(_class=\"queue\", _name=queue_name)\n if len(queue_list):\n return queue_list[0].msgDepth","def pending(self):\n return 0","def _numQueuedTotal(self):\n queueSize = len(self.__queue) + len(self.__clientQueue)\n return queueSize","def get_amount_queued(self):\n return self._num_queued","def _queue_len(queue_path: str) -> int:\n if not os.path.exists(queue_path):\n return 0\n return len([path for path in os.listdir(queue_path)])","def ctrlqueue_queue_size(self) -> int:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(10), ctypes.c_int32(0))","def queue_size(self) -> int:\n return self._queue.qsize()","def _getqueuesize(self):\n return self._queuesize","def new_messages_number(self, tag):\n return len(self._message_queue.setdefault(tag,[]))","def num_pending_messages(self):\n if self.connected:\n return len(self.messenger.num_pending_messages())\n return 0","def get_message_queue_size(self):\n with self.lock:\n return len(self.message_queue)","def size():\r\n qry = ImportQueue.query.filter(or_(\r\n ImportQueue.status != COMPLETE,\r\n ImportQueue.status != ERROR))\r\n return qry.count()","def number_of_jobs_in_queue():\n\n # Initialize #\n user_name = get_username()\n\n process = subprocess.check_output([\"squeue\", \"-u\", user_name])\n\n return len([line for line in process.split(\"\\n\") if user_name in line])","def api_get_queue_len():\n try:\n ret = AppStatus.check_manager_status(brief=False)\n if ret is not None:\n return jsonify({\"total_queue_len\": ret.get(\"total_queue_len\", 0)})\n except Exception as e:\n logger.error(\"Traceback:\\n%s\", traceback.format_exc())\n abort(500, \"failed to send message or invalid manager response\")","def get_number_message_on_queue(client, queue):\n messages = list()\n channel = client.channel()\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\n\n try:\n for method_frame, properties, body in channel.consume(\n queue=queue,\n exclusive=True,\n inactivity_timeout=30):\n messages.append({'method_frame': method_frame, 'properties': properties, 'body': body})\n # Acknowledge the message\n channel.basic_ack(method_frame.delivery_tag)\n except TypeError:\n print(\"Fin de la lecture des messages.\")\n\n # Cancel the consumer and return any pending messages\n requeued_messages = channel.cancel()\n logger.info('Requeued %i messages' % requeued_messages)\n\n # Close the channel and the connection\n channel.close()\n return len(messages)","def qsize(self):\r\n return len(self._queue)","def queue_size(self):\n return self.sql_queue.qsize()","def get_number_of_messages(queue_name):\n queue = sqs.get_queue_by_name(QueueName=queue_name)\n return queue.attributes.get('ApproximateNumberOfMessages')","def size(self):\r\n return len(self.queue)","def size(self):\r\n return len(self.queue)","def queue_size(self):\n return self._queue_size","def size(self):\n return len(self.__queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")","def queue_size(self):\n return len(self.groups)","def in_waiting(self):\n [ack, txcount, rxcount] = self._GetResponseFrame()\n return rxcount","def GetTotalQueueCount(handler, query):\n # pylint: disable=unused-argument\n\n json_config = {}\n json_config['count'] = 0\n\n with active_tivos_lock:\n for tivoIP in active_tivos:\n with active_tivos[tivoIP]['lock']:\n json_config['count'] += len(active_tivos[tivoIP]['queue'])\n\n handler.send_json(json.dumps(json_config))","def qsize(self) -> int:\n return len(self._queue)","def qsize(self) -> int:\n return self._queue.qsize()","def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )","def max_pending(self):\n return self._max_pending","def record_queue_size():\n statsd.gauge('rabbitmq.size', rabbitmq_queue_size())","def __len__(self):\n\n return len(self._queue)","def ReceiveIncomingDelivery(self):\r\n quantityReceived = self.incomingDeliveriesQueue.PopEnvelope()\r\n \r\n if quantityReceived > 0:\r\n self.currentStock += quantityReceived\r\n \r\n return quantityReceived","def queue_lengths(self):\r\n out = []\r\n for probe in self.__probes.values():\r\n if probe.complete():\r\n out.append(probe.queue_length)\r\n return out","def test_the_queue_size(the_queue):\n the_queue.enqueue(1)\n the_queue.enqueue(2)\n the_queue.enqueue(3)\n assert the_queue.size() == 3","def ctrlqueue_show(self) -> int:\n try:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(7), ctypes.c_int32(0))\n except Exception as e:\n Base.warn_msg(\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\", e)","def size(self):\n return len(self._queue_items)","def clear_queue(self):\n enqueued_pkt_count = len(self.packets)\n with self.packets_cv:\n self.packets = []\n return enqueued_pkt_count","def pending_nb_bytes(self):\n if self.df_length is not None:\n if self.df_length > 0:\n return self.df_length - len(self.buf)\n\n if self.cf_length is not None:\n if self.cf_length > 0:\n return self.cf_length - len(self.buf)\n \n return 4","def celery_queue_lengths(request):\n queue_len = collect_queue_metrics()\n LOG.info(f\"Celery queue backlog info: {queue_len}\")\n return Response(queue_len)","def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)","def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')","def declare(self):\n self.channel.queue_declare(queue='files_to_database')","def test_size_of_new_queue():\n queue = Queue()\n assert queue.size() == 0","def queued_tasks(self, name=None) -> int:\n pass","def num_pending_connections(self, host=\"localhost\", port=9090):\n\t\tmgr = NetworkConnectionsManager(self.db_uri_)\n\t\treturn mgr.num_pending_connections(host, port)","def queue_tabnav(context):\n counts = queue_counts()\n return [('apps', 'queue_pending',\n ngettext('Apps ({0})', 'Apps ({0})', counts['pending'])\n .format(counts['pending']))]","def test_size_increments_with_enqueue():\n queue = Queue()\n queue.enqueue('val')\n assert queue.size() == 1","def count(self):\t\n\t\ttry:\n\t\t\treturn True, self.queue.qsize()\n\t\texcept Exception, e:\n\t\t\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\n\t\t\treturn False, None","def QueueStatPortNumber(self):\n\t\treturn self._get_attribute('queueStatPortNumber')","def __len__(self):\n\n return len(self._block_queue)","def get_text_queue_count(self):\n return self.db.llen(\"soq_texts\")","def send_and_check(self, pkt, rss_queue):\n self.tester.scapy_append('sendp(%s, iface=\"%s\")' % (pkt, self.tester_itf))\n self.tester.scapy_execute()\n time.sleep(2)\n queue = self.get_queue_number()\n self.verify(queue in rss_queue, \"the packet doesn't enter the expected RSS queue.\")\n return queue","def report_queue_status(self):\n raise NotImplementedError","def get_message_count(self):\n return self.buffer.count()","def ctrlqueue_push(self) -> int:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(6), ctypes.c_int32(0))","def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()","def get_interface_queue_counters_queued_packets(device, interface, expected_queue_number, extensive=False):\r\n try:\r\n if extensive:\r\n out = device.parse('show interfaces extensive {interface}'.format(\r\n interface=interface.split('.')[0]\r\n ))\r\n else:\r\n out = device.parse('show interfaces {interface}'.format(\r\n interface=interface.split('.')[0]\r\n ))\r\n except SchemaEmptyParserError as e:\r\n return None\r\n # Dcitonary:\r\n # 'queue': [{'queue-counters-queued-packets': '0',\r\n # 'queue-counters-total-drop-packets': '0',\r\n # 'queue-counters-trans-packets': '0',\r\n # 'queue-number': '0'}]\r\n queue_counters_queued_packets = out.q.get_values('queue-counters-queued-packets', \r\n int(expected_queue_number))\r\n if not queue_counters_queued_packets:\r\n return None\r\n return queue_counters_queued_packets","def out_waiting(self):\n [ack, txcount, rxcount] = self._GetResponseFrame()\n return txcount","def queue_size(self) -> ConfigNodePropertyInteger:\n return self._queue_size","def test_get_messages1(self):\n self.queue.direct_declare(TEST_QUEUE)\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\n\n messages = self.queue.get_messages(TEST_QUEUE, prefetch_count=1)\n assert len(messages) >= 1","def size(self):\n return self.url_queue.qsize()","def waitQueue(threshold=0, wait=3):\n\t\n\tif settings._tn == None:\n\t\treturn\n\t\n\tflushBuffer()\n\t\n\tb = False\n\twTrigger = False\n\t\n\twhile b == False:\n\t\tres = sendData('\"API\" GET API.Manager queueCount', read=True)\n\t\tfor r in res:\n\t\t\ts = str(r).lower()\n\t\t\t\n\t\t\tif s == 'ok' or 'error' in s:\n\t\t\t\tcontinue\n\t\t\t\n\t\t\tq = int(s)\n\t\t\t\n\t\t\tif q <= threshold:\n\t\t\t\tb = True\n\t\t\t\tbreak\n\t\t\t\n\t\t\toutput('Waiting for queue to flush, {} pending...'.format(q))\n\t\t\twTrigger = True\n\t\t\n\t\tif b == False:\n\t\t\ttime.sleep(wait)\n\t\n\t# NOTE: When a wait has been triggered, we will assure that there's nothing\n\t# else pending, so we run the wait again until there's no more fluctuations\n\t# on the queue. This is a issue that will only be resolved when the API \n\t# async problem is solved.\n\tif wTrigger == True:\n\t\twaitQueue(threshold=threshold, wait=wait)","def admin_message_queue(self, user, nick, channel, rest):\n message = \"Error loading messages\"\n with self.getDbSession() as db_session:\n count = db_session.query(func.count(Message.id)).scalar()\n message = \"%d messages pending delivery\" % count\n self.reply(channel, nick, message)","def getNumOfMessagesToSend(self):\n return len(self.SendMessageBuffer)","def sock_avail(self):\n return self.channel.recv_ready()","def qsize(self):\n if not self.connected:\n raise QueueNotConnectedError(\"Queue is not Connected\")\n\n try:\n size = self.__db.llen(self._key)\n except redis.ConnectionError as e:\n raise redis.ConnectionError(repr(e))\n return size","def __len__(self) -> int:\n return len(self._data_queue)","def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)","def get_queue(self):\r\n return _channeldata[self.chan].queue","def HasPendingCommands(self):\n\t\n return self.queue.qsize() > 0","def message_count(self):\n pass","def test_size(self):\n queue = Queue()\n self.assertEqual(queue.size(), 0)\n queue.enqueue(1)\n self.assertEqual(queue.size(), 1)","def result_available(self):\n return self.result_queue.qsize() + len(self.result_data)","def get_queue_items(self, queue_name):\n proc = start_proc([\"/usr/bin/sudo\", \"rabbitmqctl\", \"list_queues\"],\n shell=False)\n for line in iter(proc.stdout.readline, \"\"):\n print(\"LIST QUEUES:\" + line)\n m = re.search(r\"%s\\s+([0-9]+)\" % queue_name, line)\n if m:\n return int(m.group(1))\n return None","def PopEnvelope(self):\r\n if len(self.data) >= 1:\r\n quantityDelivered = self.data[0]\r\n self.AdvanceQueue()\r\n else:\r\n quantityDelivered = 0\r\n \r\n return quantityDelivered","def message_count(self) -> int:\n return len(self._leased_messages)","def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)","def get_awaiting_request(self):\n return self.client.in_flight_request_count()","def ctrlqueue_do_all_queue(self) -> int:\n try:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(11), ctypes.c_int32(0))\n except Exception as e:\n Base.warn_msg(\"An error occur when tried to *Do All Control Actions of CrlQueue* check if *Queue* is NOT \"\n \"empty\", e)","def n_in_progress(self) -> int:\n return self.n_tasks() - self.qsize()","def get_njobs_in_queue(self, username=None):\n if username is None: username = getpass.getuser()\n njobs, process = self._get_njobs_in_queue(username=username)\n\n if process is not None and process.returncode != 0:\n # there's a problem talking to squeue server?\n err_msg = ('Error trying to get the number of jobs in the queue' +\n 'The error response reads:\\n {}'.format(process.stderr.read()))\n logger.critical(err_msg)\n\n if not isinstance(self, ShellAdapter):\n logger.info('The number of jobs currently in the queue is: {}'.format(njobs))\n\n return njobs","def get_queue(self):\n if self.queue is not None:\n return self.queue\n state = self.get_state()\n self.queue = state.get_queue()\n # print(\"IQ\", self.queue)\n return self.queue","def _get_queue(self):\n return self.__queue"],"string":"[\n \"def num_pending(status=\\\"pending\\\", username=\\\"garrett.wilson\\\"):\\n cmd = [\\n \\\"squeue\\\",\\n \\\"-u\\\", username,\\n \\\"-t\\\", status,\\n \\\"-h\\\"\\n ]\\n\\n output = subprocess.check_output(cmd)\\n output = output.decode(\\\"utf-8\\\").strip()\\n\\n if output == \\\"\\\":\\n return 0\\n\\n return len(output.split(\\\"\\\\n\\\"))\",\n \"def getQueueCount(self, force=False):\\n if self.queuecount == -1 or force:\\n self.queuecount = self.db.queuecount()\\n\\n return self.queuecount\",\n \"def test_get_queue_msg_count1(self):\\n self.queue.direct_declare(TEST_QUEUE)\\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\\n\\n msg_count = self.queue.get_queue_msg_count(TEST_QUEUE)\\n assert isinstance(msg_count, int)\",\n \"def declare(self, passive=False):\\n response = self._rpc(self._declare(passive))\\n return response.message_count, response.consumer_count\",\n \"def get_pending_messages():\\n global logger\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n msg = \\\"exception 1 in connecting\\\"\\n logger.debug(msg)\\n # print(msg)\\n time.sleep(3)\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n logger.debug(msg+\\\" for the second time\\\")\\n return -1\\n channel = connection.channel()\\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\\n num = queue.method.message_count\\n connection.close()\\n return num\",\n \"def get_queue_number(self):\\n outstring = self.dut.send_expect(\\\"stop\\\", \\\"testpmd> \\\")\\n time.sleep(2)\\n result_scanner = r\\\"Forward Stats for RX Port= %s/Queue=\\\\s?([0-9]+)\\\" % self.dut_ports[0]\\n scanner = re.compile(result_scanner, re.DOTALL)\\n m = scanner.search(outstring)\\n queue_id = m.group(1)\\n print \\\"queue is %s\\\" % queue_id\\n self.dut.send_expect(\\\"start\\\", \\\"testpmd> \\\")\\n return queue_id\",\n \"def get_queue_size(queue):\\n with current_celery_app.pool.acquire(block=True) as connection:\\n bound_queue = queue.bind(connection)\\n _, size, _ = bound_queue.queue_declare(passive=True)\\n return size\",\n \"def queue_count(self):\\n with self.mutex:\\n return len(self.queues)\",\n \"def ctrlqueue_num_actions(self) -> int:\\n try:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(2), ctypes.c_int32(0))\\n except Exception as e:\\n Base.warn_msg(\\\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\\\", e)\",\n \"def queue_size(self):\\n # pylint: disable=protected-access\\n if self._handler._received_messages:\\n return self._handler._received_messages.qsize()\\n return 0\",\n \"def count_remaining(self):\\n\\t\\treturn self._queue.qsize()\",\n \"def count_remaining(self):\\n\\t\\treturn self._queue.qsize()\",\n \"def queue_message_count(self, queue_name):\\n queue_list = self.__session.getObjects(_class=\\\"queue\\\", _name=queue_name)\\n if len(queue_list):\\n return queue_list[0].msgDepth\",\n \"def pending(self):\\n return 0\",\n \"def _numQueuedTotal(self):\\n queueSize = len(self.__queue) + len(self.__clientQueue)\\n return queueSize\",\n \"def get_amount_queued(self):\\n return self._num_queued\",\n \"def _queue_len(queue_path: str) -> int:\\n if not os.path.exists(queue_path):\\n return 0\\n return len([path for path in os.listdir(queue_path)])\",\n \"def ctrlqueue_queue_size(self) -> int:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(10), ctypes.c_int32(0))\",\n \"def queue_size(self) -> int:\\n return self._queue.qsize()\",\n \"def _getqueuesize(self):\\n return self._queuesize\",\n \"def new_messages_number(self, tag):\\n return len(self._message_queue.setdefault(tag,[]))\",\n \"def num_pending_messages(self):\\n if self.connected:\\n return len(self.messenger.num_pending_messages())\\n return 0\",\n \"def get_message_queue_size(self):\\n with self.lock:\\n return len(self.message_queue)\",\n \"def size():\\r\\n qry = ImportQueue.query.filter(or_(\\r\\n ImportQueue.status != COMPLETE,\\r\\n ImportQueue.status != ERROR))\\r\\n return qry.count()\",\n \"def number_of_jobs_in_queue():\\n\\n # Initialize #\\n user_name = get_username()\\n\\n process = subprocess.check_output([\\\"squeue\\\", \\\"-u\\\", user_name])\\n\\n return len([line for line in process.split(\\\"\\\\n\\\") if user_name in line])\",\n \"def api_get_queue_len():\\n try:\\n ret = AppStatus.check_manager_status(brief=False)\\n if ret is not None:\\n return jsonify({\\\"total_queue_len\\\": ret.get(\\\"total_queue_len\\\", 0)})\\n except Exception as e:\\n logger.error(\\\"Traceback:\\\\n%s\\\", traceback.format_exc())\\n abort(500, \\\"failed to send message or invalid manager response\\\")\",\n \"def get_number_message_on_queue(client, queue):\\n messages = list()\\n channel = client.channel()\\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\\n\\n try:\\n for method_frame, properties, body in channel.consume(\\n queue=queue,\\n exclusive=True,\\n inactivity_timeout=30):\\n messages.append({'method_frame': method_frame, 'properties': properties, 'body': body})\\n # Acknowledge the message\\n channel.basic_ack(method_frame.delivery_tag)\\n except TypeError:\\n print(\\\"Fin de la lecture des messages.\\\")\\n\\n # Cancel the consumer and return any pending messages\\n requeued_messages = channel.cancel()\\n logger.info('Requeued %i messages' % requeued_messages)\\n\\n # Close the channel and the connection\\n channel.close()\\n return len(messages)\",\n \"def qsize(self):\\r\\n return len(self._queue)\",\n \"def queue_size(self):\\n return self.sql_queue.qsize()\",\n \"def get_number_of_messages(queue_name):\\n queue = sqs.get_queue_by_name(QueueName=queue_name)\\n return queue.attributes.get('ApproximateNumberOfMessages')\",\n \"def size(self):\\r\\n return len(self.queue)\",\n \"def size(self):\\r\\n return len(self.queue)\",\n \"def queue_size(self):\\n return self._queue_size\",\n \"def size(self):\\n return len(self.__queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def declare_queue(self):\\n\\n self._channel.queue_declare(queue=self._queue_name, durable=True)\\n print(\\\"Queue declared....\\\")\",\n \"def queue_size(self):\\n return len(self.groups)\",\n \"def in_waiting(self):\\n [ack, txcount, rxcount] = self._GetResponseFrame()\\n return rxcount\",\n \"def GetTotalQueueCount(handler, query):\\n # pylint: disable=unused-argument\\n\\n json_config = {}\\n json_config['count'] = 0\\n\\n with active_tivos_lock:\\n for tivoIP in active_tivos:\\n with active_tivos[tivoIP]['lock']:\\n json_config['count'] += len(active_tivos[tivoIP]['queue'])\\n\\n handler.send_json(json.dumps(json_config))\",\n \"def qsize(self) -> int:\\n return len(self._queue)\",\n \"def qsize(self) -> int:\\n return self._queue.qsize()\",\n \"def on_exchange_declareok(self, _unused_frame):\\n self._channel_ctrl.queue_declare(\\n '',\\n exclusive=True,\\n auto_delete=True,\\n callback=self.on_queue_declareok\\n )\",\n \"def max_pending(self):\\n return self._max_pending\",\n \"def record_queue_size():\\n statsd.gauge('rabbitmq.size', rabbitmq_queue_size())\",\n \"def __len__(self):\\n\\n return len(self._queue)\",\n \"def ReceiveIncomingDelivery(self):\\r\\n quantityReceived = self.incomingDeliveriesQueue.PopEnvelope()\\r\\n \\r\\n if quantityReceived > 0:\\r\\n self.currentStock += quantityReceived\\r\\n \\r\\n return quantityReceived\",\n \"def queue_lengths(self):\\r\\n out = []\\r\\n for probe in self.__probes.values():\\r\\n if probe.complete():\\r\\n out.append(probe.queue_length)\\r\\n return out\",\n \"def test_the_queue_size(the_queue):\\n the_queue.enqueue(1)\\n the_queue.enqueue(2)\\n the_queue.enqueue(3)\\n assert the_queue.size() == 3\",\n \"def ctrlqueue_show(self) -> int:\\n try:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(7), ctypes.c_int32(0))\\n except Exception as e:\\n Base.warn_msg(\\\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\\\", e)\",\n \"def size(self):\\n return len(self._queue_items)\",\n \"def clear_queue(self):\\n enqueued_pkt_count = len(self.packets)\\n with self.packets_cv:\\n self.packets = []\\n return enqueued_pkt_count\",\n \"def pending_nb_bytes(self):\\n if self.df_length is not None:\\n if self.df_length > 0:\\n return self.df_length - len(self.buf)\\n\\n if self.cf_length is not None:\\n if self.cf_length > 0:\\n return self.cf_length - len(self.buf)\\n \\n return 4\",\n \"def celery_queue_lengths(request):\\n queue_len = collect_queue_metrics()\\n LOG.info(f\\\"Celery queue backlog info: {queue_len}\\\")\\n return Response(queue_len)\",\n \"def _declare(self, passive=False):\\n arguments = dict(self._arguments)\\n if self._expires:\\n arguments['x-expires'] = self._expires\\n if self._message_ttl:\\n arguments['x-message-ttl'] = self._message_ttl\\n if self._max_length:\\n arguments['x-max-length'] = self._max_length\\n if self._dlx:\\n arguments['x-dead-letter-exchange'] = self._dlx\\n if self._dlr:\\n arguments['x-dead-letter-routing-key'] = self._dlr\\n return specification.Queue.Declare(queue=self.name,\\n durable=self._durable,\\n passive=passive,\\n exclusive=self._exclusive,\\n auto_delete=self._auto_delete,\\n arguments=arguments)\",\n \"def on_queue_declared(frame):\\n channel.basic_consume(handle_delivery, queue='test')\",\n \"def declare(self):\\n self.channel.queue_declare(queue='files_to_database')\",\n \"def test_size_of_new_queue():\\n queue = Queue()\\n assert queue.size() == 0\",\n \"def queued_tasks(self, name=None) -> int:\\n pass\",\n \"def num_pending_connections(self, host=\\\"localhost\\\", port=9090):\\n\\t\\tmgr = NetworkConnectionsManager(self.db_uri_)\\n\\t\\treturn mgr.num_pending_connections(host, port)\",\n \"def queue_tabnav(context):\\n counts = queue_counts()\\n return [('apps', 'queue_pending',\\n ngettext('Apps ({0})', 'Apps ({0})', counts['pending'])\\n .format(counts['pending']))]\",\n \"def test_size_increments_with_enqueue():\\n queue = Queue()\\n queue.enqueue('val')\\n assert queue.size() == 1\",\n \"def count(self):\\t\\n\\t\\ttry:\\n\\t\\t\\treturn True, self.queue.qsize()\\n\\t\\texcept Exception, e:\\n\\t\\t\\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\\n\\t\\t\\treturn False, None\",\n \"def QueueStatPortNumber(self):\\n\\t\\treturn self._get_attribute('queueStatPortNumber')\",\n \"def __len__(self):\\n\\n return len(self._block_queue)\",\n \"def get_text_queue_count(self):\\n return self.db.llen(\\\"soq_texts\\\")\",\n \"def send_and_check(self, pkt, rss_queue):\\n self.tester.scapy_append('sendp(%s, iface=\\\"%s\\\")' % (pkt, self.tester_itf))\\n self.tester.scapy_execute()\\n time.sleep(2)\\n queue = self.get_queue_number()\\n self.verify(queue in rss_queue, \\\"the packet doesn't enter the expected RSS queue.\\\")\\n return queue\",\n \"def report_queue_status(self):\\n raise NotImplementedError\",\n \"def get_message_count(self):\\n return self.buffer.count()\",\n \"def ctrlqueue_push(self) -> int:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(6), ctypes.c_int32(0))\",\n \"def on_exchange_declareok(self, unused_frame):\\n self.logger.info('exchange declared')\\n self.setup_queue()\",\n \"def get_interface_queue_counters_queued_packets(device, interface, expected_queue_number, extensive=False):\\r\\n try:\\r\\n if extensive:\\r\\n out = device.parse('show interfaces extensive {interface}'.format(\\r\\n interface=interface.split('.')[0]\\r\\n ))\\r\\n else:\\r\\n out = device.parse('show interfaces {interface}'.format(\\r\\n interface=interface.split('.')[0]\\r\\n ))\\r\\n except SchemaEmptyParserError as e:\\r\\n return None\\r\\n # Dcitonary:\\r\\n # 'queue': [{'queue-counters-queued-packets': '0',\\r\\n # 'queue-counters-total-drop-packets': '0',\\r\\n # 'queue-counters-trans-packets': '0',\\r\\n # 'queue-number': '0'}]\\r\\n queue_counters_queued_packets = out.q.get_values('queue-counters-queued-packets', \\r\\n int(expected_queue_number))\\r\\n if not queue_counters_queued_packets:\\r\\n return None\\r\\n return queue_counters_queued_packets\",\n \"def out_waiting(self):\\n [ack, txcount, rxcount] = self._GetResponseFrame()\\n return txcount\",\n \"def queue_size(self) -> ConfigNodePropertyInteger:\\n return self._queue_size\",\n \"def test_get_messages1(self):\\n self.queue.direct_declare(TEST_QUEUE)\\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\\n\\n messages = self.queue.get_messages(TEST_QUEUE, prefetch_count=1)\\n assert len(messages) >= 1\",\n \"def size(self):\\n return self.url_queue.qsize()\",\n \"def waitQueue(threshold=0, wait=3):\\n\\t\\n\\tif settings._tn == None:\\n\\t\\treturn\\n\\t\\n\\tflushBuffer()\\n\\t\\n\\tb = False\\n\\twTrigger = False\\n\\t\\n\\twhile b == False:\\n\\t\\tres = sendData('\\\"API\\\" GET API.Manager queueCount', read=True)\\n\\t\\tfor r in res:\\n\\t\\t\\ts = str(r).lower()\\n\\t\\t\\t\\n\\t\\t\\tif s == 'ok' or 'error' in s:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\n\\t\\t\\tq = int(s)\\n\\t\\t\\t\\n\\t\\t\\tif q <= threshold:\\n\\t\\t\\t\\tb = True\\n\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\toutput('Waiting for queue to flush, {} pending...'.format(q))\\n\\t\\t\\twTrigger = True\\n\\t\\t\\n\\t\\tif b == False:\\n\\t\\t\\ttime.sleep(wait)\\n\\t\\n\\t# NOTE: When a wait has been triggered, we will assure that there's nothing\\n\\t# else pending, so we run the wait again until there's no more fluctuations\\n\\t# on the queue. This is a issue that will only be resolved when the API \\n\\t# async problem is solved.\\n\\tif wTrigger == True:\\n\\t\\twaitQueue(threshold=threshold, wait=wait)\",\n \"def admin_message_queue(self, user, nick, channel, rest):\\n message = \\\"Error loading messages\\\"\\n with self.getDbSession() as db_session:\\n count = db_session.query(func.count(Message.id)).scalar()\\n message = \\\"%d messages pending delivery\\\" % count\\n self.reply(channel, nick, message)\",\n \"def getNumOfMessagesToSend(self):\\n return len(self.SendMessageBuffer)\",\n \"def sock_avail(self):\\n return self.channel.recv_ready()\",\n \"def qsize(self):\\n if not self.connected:\\n raise QueueNotConnectedError(\\\"Queue is not Connected\\\")\\n\\n try:\\n size = self.__db.llen(self._key)\\n except redis.ConnectionError as e:\\n raise redis.ConnectionError(repr(e))\\n return size\",\n \"def __len__(self) -> int:\\n return len(self._data_queue)\",\n \"def on_queue_declared(self, frame):\\n\\t\\tself.channel.basic_qos(prefetch_count=1)\\n\\t\\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\\n\\t\\tself.consumer_tag = self.channel.basic_consume(\\n\\t\\t\\tself.handle_delivery, \\n\\t\\t\\tframe.method.queue\\n\\t\\t)\",\n \"def get_queue(self):\\r\\n return _channeldata[self.chan].queue\",\n \"def HasPendingCommands(self):\\n\\t\\n return self.queue.qsize() > 0\",\n \"def message_count(self):\\n pass\",\n \"def test_size(self):\\n queue = Queue()\\n self.assertEqual(queue.size(), 0)\\n queue.enqueue(1)\\n self.assertEqual(queue.size(), 1)\",\n \"def result_available(self):\\n return self.result_queue.qsize() + len(self.result_data)\",\n \"def get_queue_items(self, queue_name):\\n proc = start_proc([\\\"/usr/bin/sudo\\\", \\\"rabbitmqctl\\\", \\\"list_queues\\\"],\\n shell=False)\\n for line in iter(proc.stdout.readline, \\\"\\\"):\\n print(\\\"LIST QUEUES:\\\" + line)\\n m = re.search(r\\\"%s\\\\s+([0-9]+)\\\" % queue_name, line)\\n if m:\\n return int(m.group(1))\\n return None\",\n \"def PopEnvelope(self):\\r\\n if len(self.data) >= 1:\\r\\n quantityDelivered = self.data[0]\\r\\n self.AdvanceQueue()\\r\\n else:\\r\\n quantityDelivered = 0\\r\\n \\r\\n return quantityDelivered\",\n \"def message_count(self) -> int:\\n return len(self._leased_messages)\",\n \"def on_exchange_declareok(self, unused_frame):\\n LOGGER.debug('Exchange declared')\\n\\n for queue in self._handlers.keys():\\n self._channel.queue_declare(self.on_queue_declareok, queue)\\n\\n RabbitMQ.on_exchange_declareok(self, unused_frame)\",\n \"def get_awaiting_request(self):\\n return self.client.in_flight_request_count()\",\n \"def ctrlqueue_do_all_queue(self) -> int:\\n try:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(11), ctypes.c_int32(0))\\n except Exception as e:\\n Base.warn_msg(\\\"An error occur when tried to *Do All Control Actions of CrlQueue* check if *Queue* is NOT \\\"\\n \\\"empty\\\", e)\",\n \"def n_in_progress(self) -> int:\\n return self.n_tasks() - self.qsize()\",\n \"def get_njobs_in_queue(self, username=None):\\n if username is None: username = getpass.getuser()\\n njobs, process = self._get_njobs_in_queue(username=username)\\n\\n if process is not None and process.returncode != 0:\\n # there's a problem talking to squeue server?\\n err_msg = ('Error trying to get the number of jobs in the queue' +\\n 'The error response reads:\\\\n {}'.format(process.stderr.read()))\\n logger.critical(err_msg)\\n\\n if not isinstance(self, ShellAdapter):\\n logger.info('The number of jobs currently in the queue is: {}'.format(njobs))\\n\\n return njobs\",\n \"def get_queue(self):\\n if self.queue is not None:\\n return self.queue\\n state = self.get_state()\\n self.queue = state.get_queue()\\n # print(\\\"IQ\\\", self.queue)\\n return self.queue\",\n \"def _get_queue(self):\\n return self.__queue\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6994661","0.69166964","0.6806728","0.6793772","0.674106","0.653735","0.65129846","0.64847827","0.64818645","0.6461492","0.63980144","0.63980144","0.6334779","0.6294051","0.62864494","0.6266857","0.6237147","0.620611","0.6205403","0.6193056","0.6183044","0.6174565","0.61535805","0.61117375","0.610529","0.61046684","0.6089492","0.60226256","0.60027003","0.6002081","0.600139","0.600139","0.60002786","0.59841204","0.5977822","0.5977822","0.5977822","0.5977822","0.5927025","0.5917075","0.5892268","0.5858878","0.5854907","0.58467746","0.58298886","0.5825905","0.58018947","0.57969135","0.5753457","0.57023275","0.5699531","0.56807244","0.5653515","0.5628484","0.5627942","0.5625998","0.56155545","0.5613908","0.56048876","0.559318","0.5575662","0.55492413","0.55435175","0.5535504","0.55311733","0.5519677","0.55182457","0.5506068","0.5500612","0.54986453","0.5486164","0.5481974","0.54818416","0.54797685","0.54789907","0.5473381","0.5449809","0.5449786","0.5439109","0.5432071","0.5422161","0.5420404","0.5414709","0.54126054","0.54106265","0.5398725","0.53878313","0.5386175","0.53677005","0.5365579","0.5359839","0.5359829","0.53501844","0.5344912","0.5339738","0.53264","0.53257614","0.53236926","0.5300721","0.53005815"],"string":"[\n \"0.6994661\",\n \"0.69166964\",\n \"0.6806728\",\n \"0.6793772\",\n \"0.674106\",\n \"0.653735\",\n \"0.65129846\",\n \"0.64847827\",\n \"0.64818645\",\n \"0.6461492\",\n \"0.63980144\",\n \"0.63980144\",\n \"0.6334779\",\n \"0.6294051\",\n \"0.62864494\",\n \"0.6266857\",\n \"0.6237147\",\n \"0.620611\",\n \"0.6205403\",\n \"0.6193056\",\n \"0.6183044\",\n \"0.6174565\",\n \"0.61535805\",\n \"0.61117375\",\n \"0.610529\",\n \"0.61046684\",\n \"0.6089492\",\n \"0.60226256\",\n \"0.60027003\",\n \"0.6002081\",\n \"0.600139\",\n \"0.600139\",\n \"0.60002786\",\n \"0.59841204\",\n \"0.5977822\",\n \"0.5977822\",\n \"0.5977822\",\n \"0.5977822\",\n \"0.5927025\",\n \"0.5917075\",\n \"0.5892268\",\n \"0.5858878\",\n \"0.5854907\",\n \"0.58467746\",\n \"0.58298886\",\n \"0.5825905\",\n \"0.58018947\",\n \"0.57969135\",\n \"0.5753457\",\n \"0.57023275\",\n \"0.5699531\",\n \"0.56807244\",\n \"0.5653515\",\n \"0.5628484\",\n \"0.5627942\",\n \"0.5625998\",\n \"0.56155545\",\n \"0.5613908\",\n \"0.56048876\",\n \"0.559318\",\n \"0.5575662\",\n \"0.55492413\",\n \"0.55435175\",\n \"0.5535504\",\n \"0.55311733\",\n \"0.5519677\",\n \"0.55182457\",\n \"0.5506068\",\n \"0.5500612\",\n \"0.54986453\",\n \"0.5486164\",\n \"0.5481974\",\n \"0.54818416\",\n \"0.54797685\",\n \"0.54789907\",\n \"0.5473381\",\n \"0.5449809\",\n \"0.5449786\",\n \"0.5439109\",\n \"0.5432071\",\n \"0.5422161\",\n \"0.5420404\",\n \"0.5414709\",\n \"0.54126054\",\n \"0.54106265\",\n \"0.5398725\",\n \"0.53878313\",\n \"0.5386175\",\n \"0.53677005\",\n \"0.5365579\",\n \"0.5359839\",\n \"0.5359829\",\n \"0.53501844\",\n \"0.5344912\",\n \"0.5339738\",\n \"0.53264\",\n \"0.53257614\",\n \"0.53236926\",\n \"0.5300721\",\n \"0.53005815\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56386495"},"document_rank":{"kind":"string","value":"53"}}},{"rowIdx":93081,"cells":{"query":{"kind":"string","value":"Bind the queue to the specified exchange or routing key."},"document":{"kind":"string","value":"def bind(self, source, routing_key=None, arguments=None):\n if hasattr(source, 'name'):\n source = source.name\n frame = specification.Queue.Bind(queue=self.name,\n exchange=source,\n routing_key=routing_key or '',\n arguments=arguments)\n response = self._rpc(frame)\n return isinstance(response, specification.Queue.BindOk)"},"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 bind_queue_to_exchange(self, channel, exchange, queue_name, routing_key):\n logger.info('Binding %s to %s with %s',\n exchange, queue_name, routing_key)\n channel.queue_bind(queue=queue_name,\n exchange=exchange,\n routing_key=routing_key)","async def bind(\n self,\n exchange: ExchangeParamType,\n routing_key: Optional[str] = None,\n *,\n arguments: Arguments = None,\n timeout: TimeoutType = None,\n ) -> aiormq.spec.Queue.BindOk:\n\n if routing_key is None:\n routing_key = self.name\n\n log.debug(\n \"Binding queue %r: exchange=%r, routing_key=%r, arguments=%r\",\n self,\n exchange,\n routing_key,\n arguments,\n )\n\n channel = await self.channel.get_underlay_channel()\n return await channel.queue_bind(\n self.name,\n exchange=get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n timeout=timeout,\n )","def bind_queue(self, exchange_name, queue_name, bind_key):\n self.logger.info('Subscribed to topic: {}'.format(bind_key))\n try:\n self._channel.queue_bind(\n exchange=exchange_name, queue=queue_name, routing_key=bind_key)\n except Exception as exc:\n raise exc","def bind(self, exchange, routing_key='', arguments=None, timeout=None):\n\n log.debug(\"Binding exchange %r to exchange %r, routing_key=%r, arguments=%r\", self, exchange, routing_key,\n arguments)\n\n f = self._create_future(timeout)\n\n self._channel.exchange_bind(\n destination=self.name,\n source=self._get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n callback=f.set_result,\n )\n\n return f","def bind_queue(self):\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_bindok(unused_frame):\n future.set_result(True)\n\n self.log.debug('Bind queue exchange=%s, routing_key=%s',\n self.exchange, self.routing_key)\n self._channel.queue_bind(on_bindok, self.name,\n self.exchange, self.routing_key)\n\n return future","def setup_queues_and_bindings(self):\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)","def on_queue_declareok(self, method_frame):\n # LOGGER.info('Binding %s to %s with %s',\n # self.EXCHANGE, self.QUEUE, self.ROUTING_KEY)\n # self._channel.queue_bind(self.on_bindok, self.QUEUE,\n # self.EXCHANGE, self.ROUTING_KEY)\n logger.info(\n \"[{}] Binding to {} with queue {} and routing key \\\"\\\"\".format(self.bot_id, self.exchange,\n self.queue_name))\n\n self._channel.queue_bind(self.on_bindok,\n queue=self.queue_name,\n exchange=self.exchange,\n routing_key=\"\")","def on_queue_declareok(self, method_frame):\n self.logger.info('binding %s and %s together with %s', self.exchange, self.queue, self.routing_key)\n self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)","def unbind(self, source, routing_key=None):\n if hasattr(source, 'name'):\n source = source.name\n self._rpc(specification.Queue.Bind(queue=self.name,\n exchange=source,\n routing_key=routing_key or\n self.name))","def bind_key(self, key):\n self.key_bindings.append(key)","def on_queue_declareok(self, method_frame):\n\n for queue in self._handlers.keys():\n LOGGER.debug('Binding %s to %s with %s',\n self.EXCHANGE, queue, self.ROUTING_KEY)\n self._channel.queue_bind(self.on_bindok, queue,\n self.EXCHANGE, self.ROUTING_KEY)","def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\n durable=durable, arguments=arguments)\n else:\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)","def on_bindok(self, unused_frame):\n\n self.logger.info('queue bound')\n if self.acked:\n # if we wish to care about the servers replies, this is were we set up things\n self.logger.info('issuing confirm.select RPC')\n self._channel.confirm_delivery(self.on_delivery_confirmation)\n\n if self.sender:\n pass\n self.send()\n else:\n self.start_consuming()","def __init__(self, routing_key):\n self.routing_key = routing_key\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\n self.channel = self.connection.channel()\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\n self.callback_queue = result.method.queue\n\n self.channel.basic_consume(\n queue=self.callback_queue,\n on_message_callback=self.on_response,\n auto_ack=True\n )","def receive_key(self, key):\n self.queue.put(key)","def _amqp_bind(self):\n if self.amqp_connection is not None:\n try:\n self.amqp_connection.close()\n except:\n pass\n\n self.amqp_connection = pika.BlockingConnection(\n pika.ConnectionParameters(\n host=self.amqp_server\n )\n )\n\n # listening channel for ermrest change notifications\n self.notice_channel = self.amqp_connection.channel()\n try:\n # newer pika API\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\n except TypeError as te:\n # try older API as fallback\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\n sys.stderr.write('ERMrest change-notice channel open.\\n')","def declare_queue(self, c, queue_name):\n return self._management_req(\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\n {\"auto_delete\": False, \"durable\": False, \"arguments\": {}})","def register_queue(self, queue) -> None:\r\n if queue is None:\r\n raise ValueError('queue is None')\r\n if not hasattr(queue, 'empty'):\r\n raise ValueError(f'queue {queue} is missing empty member')\r\n if not hasattr(queue, 'get_nowait'):\r\n raise ValueError(f'queue {queue} is missing get_nowait member')\r\n self.receive_queues.append(queue)","def on_bindok(self, unused_frame):\n logger.info('Queue bound')\n self.setup_error_queue()","def bind_key(self, key, command):\n self.key_bindings[key] = command","def _listen_queue(self, queue, callback):\n # Listen buy/sell orders from external system\n self._logger.info(f\"Declaring rabbit queue {queue}\")\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\n self._logger.info(f\"Declaring callback to rabbit queue: {queue}, callback: {callback}\")\n self._consumer_rabbit_channel.basic_consume(queue, callback,\n consumer_tag=queue)","def setup_queue(self, channel, queue_name):\n logger.info('Declaring queue %s', queue_name)\n channel.queue_declare(queue = queue_name, \n durable = True,\n auto_delete = False)","def add_queue(self, queue):\n\n queue_id = queue[\"ovsdb:queues\"][0][\"queue-id\"]\n self.queue_dict[queue_id] = queue","def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)","def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')","def receive_key(self, key):\n try:\n self.queue.put(key)\n except:\n raise #Just collecting possible exceptions for now","def bind(self, scope: aws_cdk.core.Construct, bucket: \"IBucket\") -> \"BucketNotificationDestinationConfig\":\n ...","def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")","def declare_queue(self, queue_name):\n if queue_name not in self.queues:\n self.emit_before(\"declare_queue\", queue_name)\n self.queues.add(queue_name)\n self.emit_after(\"declare_queue\", queue_name)\n\n delayed_name = dq_name(queue_name)\n self.delay_queues.add(delayed_name)\n self.emit_after(\"declare_delay_queue\", delayed_name)","def bind(self, scope: aws_cdk.core.Construct, bucket: \"IBucket\") -> \"BucketNotificationDestinationConfig\":\n return jsii.invoke(self, \"bind\", [scope, bucket])","def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\n\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()","async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self","async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})","def publish(self, queue, message):\n\n # Instead of passing a queue to the constructor, the publish checks if\n # the target queue exists. If not, it declares the target queue\n if not self.queue:\n self.channel.queue_declare(queue=queue)\n self.queue = queue\n\n self.channel.basic_publish(\n exchange='', routing_key=queue, body=message)","def from_queue_key(cls, queue_key, connection=None):\n prefix = cls.redis_queue_namespace_prefix\n if not queue_key.startswith(prefix):\n raise ValueError('Not a valid RQ queue key: %s' % (queue_key,))\n name = queue_key[len(prefix):]\n return cls(name)","def exchange(self, exchange):\n\n self._exchange = exchange","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def _set_queue(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"queue must be of a type compatible with leafref\"\"\",\n 'defined-type': \"leafref\",\n 'generated-type': \"\"\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\"queue\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\"\"\",\n })\n\n self.__queue = t\n if hasattr(self, '_set'):\n self._set()","def setExchange(self, exchange):\r\n\t\tself.pair.exchange = exchange","def __init__(self, queue_name, **kwargs):\n super(Queue, self).__init__(**kwargs)\n self.value = queue_name","def _bind(self):\n\n pass","def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()","def bind(self, address: Tuple[str, int]) -> None:\n ...","def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))","def send_message_to_server(self, key, value):\n if self.from_kivy_queue is None:\n return\n self.from_kivy_queue.put((key, value))","def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)","def rx_queue_settings(self, rx_queue_settings):\n\n self._rx_queue_settings = rx_queue_settings","def sendCommand(self, command:str=\"?\"):\n self.commandQueue.put(command)\n #self.queueLock.release()\n pass","def set_turn_queue(queue: Dict[EntityID, int]):\n store.turn_queue = queue","def subscribe(self):\n with self._rabbit_connection.connection.channel() as channel:\n self._queue = rabbitpy.Queue(\n channel=channel,\n name=self._subscriber_name + \"_queue\",\n durable=True,\n message_ttl=5 * 24 * 60 * 60 * 1000 # 5 days\n )\n self._queue.declare()\n self._queue.bind(self._exchange, self._routing_key)\n\n self._consume()","def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )","def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel","def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)","def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(\n host=self.rabbit_host,\n port=int(self.rabbit_port),\n credentials=pika.PlainCredentials(\n self.rabbit_user,\n self.rabbit_pass))\n )\n channel = connection.channel()\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_declare(queue=\"zcp-keystone\", exclusive=True)\n channel.queue_bind(exchange='keystone',\n queue=\"zcp-keystone\",\n routing_key='notifications.#')\n channel.basic_consume(self.keystone_callback,\n queue=\"zcp-keystone\",\n no_ack=True)\n channel.start_consuming()","def queue(self, name):\n # First create a queue\n queue = self.inbound_channel.declare_queue(name)\n\n # Create the registry for the queue\n registry = Registry(self, queue)\n\n # Prepare consuming queue with registry\n self.inbound_channel.consume(queue=queue, callback=registry)\n\n # Then, return the Registry object.\n return registry","def _put(self, item, queue):","def queue(self, queue_, value):\n while not self.closed:\n try:\n queue_.put(value, block=True, timeout=1)\n return\n except queue.Full:\n continue","def bind(self, *args):\r\n return self._fd.bind(*args)","def add_to_queue(self, word):\n self.q.put(word)\n print(\"word \\'{}\\' added in clients queue\".format(word))","def _ns_queue(self, queue, consumer_id):\n return self._ns(queue, consumer_id, \"messages\")","def set_queue_name(self, queue_name):\n self._graph_executor.set_queue_name(queue_name)","def bind_router(self, context, router_id, chosen_agent):\n try:\n with context.session.begin(subtransactions=True):\n binding = l3_agentschedulers_db.RouterL3AgentBinding()\n binding.l3_agent = chosen_agent\n binding.router_id = router_id\n context.session.add(binding)\n except db_exc.DBDuplicateEntry:\n LOG.debug('Router %(router_id)s has already been scheduled '\n 'to L3 agent %(agent_id)s.',\n {'agent_id': chosen_agent.id,\n 'router_id': router_id})\n return\n\n LOG.debug('Router %(router_id)s is scheduled to L3 agent '\n '%(agent_id)s', {'router_id': router_id,\n 'agent_id': chosen_agent.id})","def bind(self, _target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [_target])","def __init__(self, queue_id):\n self.queue_id = queue_id\n self.action_type = 'set_queue'","def resolve(self, binding_key: Hashable) -> Any:\n binding = self._bindings[binding_key](self)\n return binding","def listen(self):\n result = self.channel.queue_declare(queue=self.config['queue'], \n exclusive=True)\n if self.endpoints is not None:\n for key in self.endpoints:\n self.channel.queue_bind(exchange=self.config['exchange'], \n queue=self.config['queue'],\n routing_key=f\"sensor_value.{key}\")\n else:\n self.channel.queue_bind(exchange=self.config['exchange'],\n queue=self.config['queue'],\n routing_key=\"sensor_value.#\")\n \n self.channel.basic_consume(queue=self.config['queue'], \n on_message_callback=self.decode_values, \n auto_ack=True)\n\n # starts a while-type loop\n print(\"wabbit eatin hay\")\n self.channel.start_consuming()","def register(self, queue, project=None):\n\n # TODO(kgriffs): SHARDING - Implement this!\n pass","def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)","def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\n return jsii.invoke(self, \"bind\", [target])","def bind(self, server_name: str, port: int) -> None:\n self.socket.bind((server_name, port))","def enqueue(self, key, value):\n el = SinglyNode(key, value)\n self.inbound_stack.append(el)","def query_queue(self, queue_name, alt_exchange_name=None):\n return self._query(queue_name, \"queue\", \"org.apache.qpid.broker\", alt_exchange_name)","def add_bindings(self, configuration, bind_to, typ, bindings):\n wanted = list(bindings.wanted(configuration[typ].values()))\n if not self.get_current(bind_to)[0]:\n log.info(\"Would bind <%s>(%s) to %s\", typ, ', '.join(wanted), bind_to.long_name)\n return\n\n for thing in wanted:\n bound = self.is_bound(typ, thing, bind_to.typ, bind_to.name)\n\n if not bound:\n log.info(\"Binding <%s>(%s) to %s\", typ, thing, bind_to.long_name)\n combined_typ, binding_name_str, name_str = self.combined_typ(bind_to.typ, typ)\n payload = {binding_name_str: bind_to.name, name_str: thing}\n payload.update(configuration[typ][thing].binding_options)\n self.post(combined_typ, {combined_typ: payload, \"params\": {\"action\": \"bind\"}}, content_type=self.content_type(combined_typ))\n else:\n log.debug(\"<%s(%s) already bound to %s\", typ, thing, bind_to.long_name)","def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)","def amqp(self, **options):\n pass","def bind(self, binding_id, event_props, handler, arg_list=None, once=False):\n\n args = (arg_list,) if arg_list else ()\n self._bindings[binding_id] = (once, event_props, handler) + args","def setExchange(self, exchange):\r\n\t\tself.exchange = exchange","def bind(self, _target: aws_cdk.aws_lambda.IFunction) -> None:\n ...","def bind(\n self,\n scope: aws_cdk.core.Construct,\n stage: aws_cdk.aws_codepipeline.IStage,\n *,\n bucket: aws_cdk.aws_s3.IBucket,\n role: aws_cdk.aws_iam.IRole,\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\n\n return jsii.invoke(self, \"bind\", [scope, stage, options])","def bind(\n self,\n scope: aws_cdk.core.Construct,\n stage: aws_cdk.aws_codepipeline.IStage,\n *,\n bucket: aws_cdk.aws_s3.IBucket,\n role: aws_cdk.aws_iam.IRole,\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\n\n return jsii.invoke(self, \"bind\", [scope, stage, options])","def bind(\n self,\n scope: aws_cdk.core.Construct,\n stage: aws_cdk.aws_codepipeline.IStage,\n *,\n bucket: aws_cdk.aws_s3.IBucket,\n role: aws_cdk.aws_iam.IRole,\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\n\n return jsii.invoke(self, \"bind\", [scope, stage, options])","def bind(\n self,\n scope: aws_cdk.core.Construct,\n stage: aws_cdk.aws_codepipeline.IStage,\n *,\n bucket: aws_cdk.aws_s3.IBucket,\n role: aws_cdk.aws_iam.IRole,\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\n\n return jsii.invoke(self, \"bind\", [scope, stage, options])","def bind(\n self,\n scope: aws_cdk.core.Construct,\n stage: aws_cdk.aws_codepipeline.IStage,\n *,\n bucket: aws_cdk.aws_s3.IBucket,\n role: aws_cdk.aws_iam.IRole,\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\n\n return jsii.invoke(self, \"bind\", [scope, stage, options])","def add_queue(self, queue):\n with self.mutex:\n self.queues.append(queue)","def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\n\n if queue is None:\n queue = routing_key\n self.exchange = exchange\n self.exchange_type = exchange_type\n self.queue = queue\n self.routing_key = routing_key\n self._url = url\n self.acked = acked\n self.otq = otq\n\n self.cb = None\n\n self._connection = None\n self._channel = None\n self._closing = False\n\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\n handler = logging.FileHandler(log_file)\n logging.basicConfig(level=log_level, format=log_format)\n self.logger = logging.getLogger(__name__)\n self.logger.addHandler(handler)\n\n # used only for sending\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n self._stopping = False\n self._done_sending = False\n self.message = \"\"\n self.sender = sender\n\n # self.run()\n # self._connection = self.connect()","def zmq_bind_host(self):\n return _host_tuple(self._get('zmq_bind_host'))","def put_message(cls, message):\n rp = cls.get()\n rp.queue_receive.put(message)","def keyExchangeServer():\n with socket.socket() as sock:\n try:\n # if the port number already taken, the following line will not work\n sock.bind((GW_ADRRESS, KEY_EXCHANGE_PORT))\n print(\"success in binding\")\n except:\n print(\"error in binding\")\n sys.exit()\n sock.listen(0)\n while True:\n client_socket, client_address = sock.accept()\n valid, data = get_msg(client_socket)\n if valid:\n data = data.split(\" \")\n if data[0] == HELLO_MASSEGE:\n if (client_address[0], int(data[1])) not in key_dic:\n key = int.from_bytes(Fernet.generate_key(), \"big\")\n else:\n key = key_dic[(client_address[0], int(data[1]))]\n client_socket.send(create_msg(get_key(key)).encode())\n key_dic[(client_address[0], int(data[1]))] = key\n print(key_dic)","def reroute_queue(queue_name: str, exchange_name: str,\n limit: int = 0,\n message_filter: Optional[Tuple[str, str]] = None,\n server_url: Optional[str] = None):\n # Gather queue & exchange info + existance check\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\n server_url)\n get_object('org.apache.qpid.broker', 'exchange',\n exchange_name, server_url)\n\n method_arguments = {'request': limit} # type: dict\n\n if exchange_name:\n method_arguments['useAltExchange'] = False\n method_arguments['exchange'] = exchange_name\n else:\n method_arguments['useAltExchange'] = True\n method_arguments['exchange'] = ''\n\n if message_filter:\n method_arguments['filter'] = _build_message_filter(*message_filter)\n\n rpc = RemoteProcedure(handle_QMF2_exception,\n 'qmf.default.direct', server_url)\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\n 'reroute', method_arguments),\n timedelta(seconds=5))","def bind(self):\n if self.allow_reuse_address:\n self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)\n self.socket.bind(self.server_address)\n self.server_address = self.socket.getsockname()"],"string":"[\n \"def bind_queue_to_exchange(self, channel, exchange, queue_name, routing_key):\\n logger.info('Binding %s to %s with %s',\\n exchange, queue_name, routing_key)\\n channel.queue_bind(queue=queue_name,\\n exchange=exchange,\\n routing_key=routing_key)\",\n \"async def bind(\\n self,\\n exchange: ExchangeParamType,\\n routing_key: Optional[str] = None,\\n *,\\n arguments: Arguments = None,\\n timeout: TimeoutType = None,\\n ) -> aiormq.spec.Queue.BindOk:\\n\\n if routing_key is None:\\n routing_key = self.name\\n\\n log.debug(\\n \\\"Binding queue %r: exchange=%r, routing_key=%r, arguments=%r\\\",\\n self,\\n exchange,\\n routing_key,\\n arguments,\\n )\\n\\n channel = await self.channel.get_underlay_channel()\\n return await channel.queue_bind(\\n self.name,\\n exchange=get_exchange_name(exchange),\\n routing_key=routing_key,\\n arguments=arguments,\\n timeout=timeout,\\n )\",\n \"def bind_queue(self, exchange_name, queue_name, bind_key):\\n self.logger.info('Subscribed to topic: {}'.format(bind_key))\\n try:\\n self._channel.queue_bind(\\n exchange=exchange_name, queue=queue_name, routing_key=bind_key)\\n except Exception as exc:\\n raise exc\",\n \"def bind(self, exchange, routing_key='', arguments=None, timeout=None):\\n\\n log.debug(\\\"Binding exchange %r to exchange %r, routing_key=%r, arguments=%r\\\", self, exchange, routing_key,\\n arguments)\\n\\n f = self._create_future(timeout)\\n\\n self._channel.exchange_bind(\\n destination=self.name,\\n source=self._get_exchange_name(exchange),\\n routing_key=routing_key,\\n arguments=arguments,\\n callback=f.set_result,\\n )\\n\\n return f\",\n \"def bind_queue(self):\\n # pylint: disable=protected-access\\n future = self._backend._create_future()\\n\\n def on_bindok(unused_frame):\\n future.set_result(True)\\n\\n self.log.debug('Bind queue exchange=%s, routing_key=%s',\\n self.exchange, self.routing_key)\\n self._channel.queue_bind(on_bindok, self.name,\\n self.exchange, self.routing_key)\\n\\n return future\",\n \"def setup_queues_and_bindings(self):\\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)\",\n \"def on_queue_declareok(self, method_frame):\\n # LOGGER.info('Binding %s to %s with %s',\\n # self.EXCHANGE, self.QUEUE, self.ROUTING_KEY)\\n # self._channel.queue_bind(self.on_bindok, self.QUEUE,\\n # self.EXCHANGE, self.ROUTING_KEY)\\n logger.info(\\n \\\"[{}] Binding to {} with queue {} and routing key \\\\\\\"\\\\\\\"\\\".format(self.bot_id, self.exchange,\\n self.queue_name))\\n\\n self._channel.queue_bind(self.on_bindok,\\n queue=self.queue_name,\\n exchange=self.exchange,\\n routing_key=\\\"\\\")\",\n \"def on_queue_declareok(self, method_frame):\\n self.logger.info('binding %s and %s together with %s', self.exchange, self.queue, self.routing_key)\\n self._channel.queue_bind(self.on_bindok, self.queue, self.exchange, self.routing_key)\",\n \"def unbind(self, source, routing_key=None):\\n if hasattr(source, 'name'):\\n source = source.name\\n self._rpc(specification.Queue.Bind(queue=self.name,\\n exchange=source,\\n routing_key=routing_key or\\n self.name))\",\n \"def bind_key(self, key):\\n self.key_bindings.append(key)\",\n \"def on_queue_declareok(self, method_frame):\\n\\n for queue in self._handlers.keys():\\n LOGGER.debug('Binding %s to %s with %s',\\n self.EXCHANGE, queue, self.ROUTING_KEY)\\n self._channel.queue_bind(self.on_bindok, queue,\\n self.EXCHANGE, self.ROUTING_KEY)\",\n \"def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\\n amqp_session = self.__broker.getAmqpSession()\\n if arguments == None:\\n arguments = {}\\n if alt_exchange_name:\\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\\n durable=durable, arguments=arguments)\\n else:\\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)\",\n \"def on_bindok(self, unused_frame):\\n\\n self.logger.info('queue bound')\\n if self.acked:\\n # if we wish to care about the servers replies, this is were we set up things\\n self.logger.info('issuing confirm.select RPC')\\n self._channel.confirm_delivery(self.on_delivery_confirmation)\\n\\n if self.sender:\\n pass\\n self.send()\\n else:\\n self.start_consuming()\",\n \"def __init__(self, routing_key):\\n self.routing_key = routing_key\\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(host=rabbitmq_hostname))\\n self.channel = self.connection.channel()\\n result = self.channel.queue_declare(queue='', exclusive=True, durable=True)\\n self.callback_queue = result.method.queue\\n\\n self.channel.basic_consume(\\n queue=self.callback_queue,\\n on_message_callback=self.on_response,\\n auto_ack=True\\n )\",\n \"def receive_key(self, key):\\n self.queue.put(key)\",\n \"def _amqp_bind(self):\\n if self.amqp_connection is not None:\\n try:\\n self.amqp_connection.close()\\n except:\\n pass\\n\\n self.amqp_connection = pika.BlockingConnection(\\n pika.ConnectionParameters(\\n host=self.amqp_server\\n )\\n )\\n\\n # listening channel for ermrest change notifications\\n self.notice_channel = self.amqp_connection.channel()\\n try:\\n # newer pika API\\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\\n except TypeError as te:\\n # try older API as fallback\\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\\n sys.stderr.write('ERMrest change-notice channel open.\\\\n')\",\n \"def declare_queue(self, c, queue_name):\\n return self._management_req(\\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\\n {\\\"auto_delete\\\": False, \\\"durable\\\": False, \\\"arguments\\\": {}})\",\n \"def register_queue(self, queue) -> None:\\r\\n if queue is None:\\r\\n raise ValueError('queue is None')\\r\\n if not hasattr(queue, 'empty'):\\r\\n raise ValueError(f'queue {queue} is missing empty member')\\r\\n if not hasattr(queue, 'get_nowait'):\\r\\n raise ValueError(f'queue {queue} is missing get_nowait member')\\r\\n self.receive_queues.append(queue)\",\n \"def on_bindok(self, unused_frame):\\n logger.info('Queue bound')\\n self.setup_error_queue()\",\n \"def bind_key(self, key, command):\\n self.key_bindings[key] = command\",\n \"def _listen_queue(self, queue, callback):\\n # Listen buy/sell orders from external system\\n self._logger.info(f\\\"Declaring rabbit queue {queue}\\\")\\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\\n self._logger.info(f\\\"Declaring callback to rabbit queue: {queue}, callback: {callback}\\\")\\n self._consumer_rabbit_channel.basic_consume(queue, callback,\\n consumer_tag=queue)\",\n \"def setup_queue(self, channel, queue_name):\\n logger.info('Declaring queue %s', queue_name)\\n channel.queue_declare(queue = queue_name, \\n durable = True,\\n auto_delete = False)\",\n \"def add_queue(self, queue):\\n\\n queue_id = queue[\\\"ovsdb:queues\\\"][0][\\\"queue-id\\\"]\\n self.queue_dict[queue_id] = queue\",\n \"def setup_queue(self, method_frame):\\n logger.info('Declaring queue %s', self.queue_name)\\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\\n\\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)\",\n \"def on_queue_declared(frame):\\n channel.basic_consume(handle_delivery, queue='test')\",\n \"def receive_key(self, key):\\n try:\\n self.queue.put(key)\\n except:\\n raise #Just collecting possible exceptions for now\",\n \"def bind(self, scope: aws_cdk.core.Construct, bucket: \\\"IBucket\\\") -> \\\"BucketNotificationDestinationConfig\\\":\\n ...\",\n \"def declare_queue(self):\\n\\n self._channel.queue_declare(queue=self._queue_name, durable=True)\\n print(\\\"Queue declared....\\\")\",\n \"def declare_queue(self, queue_name):\\n if queue_name not in self.queues:\\n self.emit_before(\\\"declare_queue\\\", queue_name)\\n self.queues.add(queue_name)\\n self.emit_after(\\\"declare_queue\\\", queue_name)\\n\\n delayed_name = dq_name(queue_name)\\n self.delay_queues.add(delayed_name)\\n self.emit_after(\\\"declare_delay_queue\\\", delayed_name)\",\n \"def bind(self, scope: aws_cdk.core.Construct, bucket: \\\"IBucket\\\") -> \\\"BucketNotificationDestinationConfig\\\":\\n return jsii.invoke(self, \\\"bind\\\", [scope, bucket])\",\n \"def keystone_amq(self):\\n\\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\\n credentials=pika.PlainCredentials(\\n username=self.rabbit_user,\\n password=self.rabbit_pass)))\\n channel = connection.channel()\\n result = channel.queue_declare(exclusive=True)\\n queue_name = result.method.queue\\n channel.exchange_declare(exchange='keystone', type='topic')\\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\\n\\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\\n channel.start_consuming()\",\n \"async def declare(self) -> 'Queue':\\n # we are relying to this in other functions\\n self._channel = await self._backend.channel()\\n self.log.debug(\\\"Channel acquired CHANNEL%i\\\",\\n self._channel.channel_number)\\n\\n if self.exchange:\\n await self.declare_exchange()\\n\\n if self.name is not None:\\n await self.declare_queue()\\n\\n if self.exchange:\\n await self.bind_queue()\\n\\n return self\",\n \"async def _connect(self):\\n self._connection = await connect_robust(self._connection_string)\\n self._channel = await self._connection.channel()\\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})\",\n \"def publish(self, queue, message):\\n\\n # Instead of passing a queue to the constructor, the publish checks if\\n # the target queue exists. If not, it declares the target queue\\n if not self.queue:\\n self.channel.queue_declare(queue=queue)\\n self.queue = queue\\n\\n self.channel.basic_publish(\\n exchange='', routing_key=queue, body=message)\",\n \"def from_queue_key(cls, queue_key, connection=None):\\n prefix = cls.redis_queue_namespace_prefix\\n if not queue_key.startswith(prefix):\\n raise ValueError('Not a valid RQ queue key: %s' % (queue_key,))\\n name = queue_key[len(prefix):]\\n return cls(name)\",\n \"def exchange(self, exchange):\\n\\n self._exchange = exchange\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_queue(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"queue must be of a type compatible with leafref\\\"\\\"\\\",\\n 'defined-type': \\\"leafref\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=ReferenceType(referenced_path='../../../../../../../../queues/queue/name', caller=self._path() + ['queue'], path_helper=self._path_helper, require_instance=True), is_leaf=True, yang_name=\\\"queue\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='leafref', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__queue = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def setExchange(self, exchange):\\r\\n\\t\\tself.pair.exchange = exchange\",\n \"def __init__(self, queue_name, **kwargs):\\n super(Queue, self).__init__(**kwargs)\\n self.value = queue_name\",\n \"def _bind(self):\\n\\n pass\",\n \"def linkRabbit(self):\\n\\n print(\\\"Listening for RabbitMQ messages\\\")\\n\\n # RabbitMQ setup\\n connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host='localhost'))\\n channel = connection.channel()\\n\\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\\n\\n result = channel.queue_declare(queue='', exclusive=True)\\n queue_name = result.method.queue\\n\\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\\n channel.start_consuming()\",\n \"def bind(self, address: Tuple[str, int]) -> None:\\n ...\",\n \"def __init__(self, address, queue_name):\\n self.connection = pika.BlockingConnection(\\n pika.ConnectionParameters(address))\\n self.queue_name = queue_name\\n\\n # create the channel\\n self.channel = self.connection.channel()\\n\\n # declare the queue\\n self.channel.queue_declare(queue=queue_name, durable=True)\\n\\n logging.info(\\\"Message Broker connected to {0}\\\".format(address))\",\n \"def send_message_to_server(self, key, value):\\n if self.from_kivy_queue is None:\\n return\\n self.from_kivy_queue.put((key, value))\",\n \"def setup_queue(self):\\n self.logger.info('declaring queue %s', self.queue)\\n if self.otq:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\\n else:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue)\",\n \"def rx_queue_settings(self, rx_queue_settings):\\n\\n self._rx_queue_settings = rx_queue_settings\",\n \"def sendCommand(self, command:str=\\\"?\\\"):\\n self.commandQueue.put(command)\\n #self.queueLock.release()\\n pass\",\n \"def set_turn_queue(queue: Dict[EntityID, int]):\\n store.turn_queue = queue\",\n \"def subscribe(self):\\n with self._rabbit_connection.connection.channel() as channel:\\n self._queue = rabbitpy.Queue(\\n channel=channel,\\n name=self._subscriber_name + \\\"_queue\\\",\\n durable=True,\\n message_ttl=5 * 24 * 60 * 60 * 1000 # 5 days\\n )\\n self._queue.declare()\\n self._queue.bind(self._exchange, self._routing_key)\\n\\n self._consume()\",\n \"def on_exchange_declareok(self, _unused_frame):\\n self._channel_ctrl.queue_declare(\\n '',\\n exclusive=True,\\n auto_delete=True,\\n callback=self.on_queue_declareok\\n )\",\n \"def connect(self):\\n # @TODO: implement SSL\\n connection = pika.BlockingConnection(self.params)\\n channel = connection.channel()\\n channel.queue_declare(queue=self.queue_name, durable=True)\\n\\n self.connection = connection\\n self.channel = channel\",\n \"def setup_exchange(self):\\n self.logger.info('declaring exchange %s', self.exchange)\\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)\",\n \"def keystone_amq(self):\\n\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\n host=self.rabbit_host,\\n port=int(self.rabbit_port),\\n credentials=pika.PlainCredentials(\\n self.rabbit_user,\\n self.rabbit_pass))\\n )\\n channel = connection.channel()\\n channel.exchange_declare(exchange='keystone', type='topic')\\n channel.queue_declare(queue=\\\"zcp-keystone\\\", exclusive=True)\\n channel.queue_bind(exchange='keystone',\\n queue=\\\"zcp-keystone\\\",\\n routing_key='notifications.#')\\n channel.basic_consume(self.keystone_callback,\\n queue=\\\"zcp-keystone\\\",\\n no_ack=True)\\n channel.start_consuming()\",\n \"def queue(self, name):\\n # First create a queue\\n queue = self.inbound_channel.declare_queue(name)\\n\\n # Create the registry for the queue\\n registry = Registry(self, queue)\\n\\n # Prepare consuming queue with registry\\n self.inbound_channel.consume(queue=queue, callback=registry)\\n\\n # Then, return the Registry object.\\n return registry\",\n \"def _put(self, item, queue):\",\n \"def queue(self, queue_, value):\\n while not self.closed:\\n try:\\n queue_.put(value, block=True, timeout=1)\\n return\\n except queue.Full:\\n continue\",\n \"def bind(self, *args):\\r\\n return self._fd.bind(*args)\",\n \"def add_to_queue(self, word):\\n self.q.put(word)\\n print(\\\"word \\\\'{}\\\\' added in clients queue\\\".format(word))\",\n \"def _ns_queue(self, queue, consumer_id):\\n return self._ns(queue, consumer_id, \\\"messages\\\")\",\n \"def set_queue_name(self, queue_name):\\n self._graph_executor.set_queue_name(queue_name)\",\n \"def bind_router(self, context, router_id, chosen_agent):\\n try:\\n with context.session.begin(subtransactions=True):\\n binding = l3_agentschedulers_db.RouterL3AgentBinding()\\n binding.l3_agent = chosen_agent\\n binding.router_id = router_id\\n context.session.add(binding)\\n except db_exc.DBDuplicateEntry:\\n LOG.debug('Router %(router_id)s has already been scheduled '\\n 'to L3 agent %(agent_id)s.',\\n {'agent_id': chosen_agent.id,\\n 'router_id': router_id})\\n return\\n\\n LOG.debug('Router %(router_id)s is scheduled to L3 agent '\\n '%(agent_id)s', {'router_id': router_id,\\n 'agent_id': chosen_agent.id})\",\n \"def bind(self, _target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [_target])\",\n \"def __init__(self, queue_id):\\n self.queue_id = queue_id\\n self.action_type = 'set_queue'\",\n \"def resolve(self, binding_key: Hashable) -> Any:\\n binding = self._bindings[binding_key](self)\\n return binding\",\n \"def listen(self):\\n result = self.channel.queue_declare(queue=self.config['queue'], \\n exclusive=True)\\n if self.endpoints is not None:\\n for key in self.endpoints:\\n self.channel.queue_bind(exchange=self.config['exchange'], \\n queue=self.config['queue'],\\n routing_key=f\\\"sensor_value.{key}\\\")\\n else:\\n self.channel.queue_bind(exchange=self.config['exchange'],\\n queue=self.config['queue'],\\n routing_key=\\\"sensor_value.#\\\")\\n \\n self.channel.basic_consume(queue=self.config['queue'], \\n on_message_callback=self.decode_values, \\n auto_ack=True)\\n\\n # starts a while-type loop\\n print(\\\"wabbit eatin hay\\\")\\n self.channel.start_consuming()\",\n \"def register(self, queue, project=None):\\n\\n # TODO(kgriffs): SHARDING - Implement this!\\n pass\",\n \"def on_channel_open(new_channel):\\n global channel\\n channel = new_channel\\n channel.queue_declare(queue=\\\"test\\\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)\",\n \"def on_exchange_declareok(self, unused_frame):\\n LOGGER.debug('Exchange declared')\\n\\n for queue in self._handlers.keys():\\n self._channel.queue_declare(self.on_queue_declareok, queue)\\n\\n RabbitMQ.on_exchange_declareok(self, unused_frame)\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, target: aws_cdk.aws_lambda.IFunction) -> None:\\n return jsii.invoke(self, \\\"bind\\\", [target])\",\n \"def bind(self, server_name: str, port: int) -> None:\\n self.socket.bind((server_name, port))\",\n \"def enqueue(self, key, value):\\n el = SinglyNode(key, value)\\n self.inbound_stack.append(el)\",\n \"def query_queue(self, queue_name, alt_exchange_name=None):\\n return self._query(queue_name, \\\"queue\\\", \\\"org.apache.qpid.broker\\\", alt_exchange_name)\",\n \"def add_bindings(self, configuration, bind_to, typ, bindings):\\n wanted = list(bindings.wanted(configuration[typ].values()))\\n if not self.get_current(bind_to)[0]:\\n log.info(\\\"Would bind <%s>(%s) to %s\\\", typ, ', '.join(wanted), bind_to.long_name)\\n return\\n\\n for thing in wanted:\\n bound = self.is_bound(typ, thing, bind_to.typ, bind_to.name)\\n\\n if not bound:\\n log.info(\\\"Binding <%s>(%s) to %s\\\", typ, thing, bind_to.long_name)\\n combined_typ, binding_name_str, name_str = self.combined_typ(bind_to.typ, typ)\\n payload = {binding_name_str: bind_to.name, name_str: thing}\\n payload.update(configuration[typ][thing].binding_options)\\n self.post(combined_typ, {combined_typ: payload, \\\"params\\\": {\\\"action\\\": \\\"bind\\\"}}, content_type=self.content_type(combined_typ))\\n else:\\n log.debug(\\\"<%s(%s) already bound to %s\\\", typ, thing, bind_to.long_name)\",\n \"def declare_queue(self, topic):\\n #from trove.rpc.impl_kombu import Connection\\n from trove.openstack.common.rpc import create_connection\\n with create_connection() as conn:\\n consumer = conn.declare_topic_consumer(topic=topic)\",\n \"def amqp(self, **options):\\n pass\",\n \"def bind(self, binding_id, event_props, handler, arg_list=None, once=False):\\n\\n args = (arg_list,) if arg_list else ()\\n self._bindings[binding_id] = (once, event_props, handler) + args\",\n \"def setExchange(self, exchange):\\r\\n\\t\\tself.exchange = exchange\",\n \"def bind(self, _target: aws_cdk.aws_lambda.IFunction) -> None:\\n ...\",\n \"def bind(\\n self,\\n scope: aws_cdk.core.Construct,\\n stage: aws_cdk.aws_codepipeline.IStage,\\n *,\\n bucket: aws_cdk.aws_s3.IBucket,\\n role: aws_cdk.aws_iam.IRole,\\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\\n\\n return jsii.invoke(self, \\\"bind\\\", [scope, stage, options])\",\n \"def bind(\\n self,\\n scope: aws_cdk.core.Construct,\\n stage: aws_cdk.aws_codepipeline.IStage,\\n *,\\n bucket: aws_cdk.aws_s3.IBucket,\\n role: aws_cdk.aws_iam.IRole,\\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\\n\\n return jsii.invoke(self, \\\"bind\\\", [scope, stage, options])\",\n \"def bind(\\n self,\\n scope: aws_cdk.core.Construct,\\n stage: aws_cdk.aws_codepipeline.IStage,\\n *,\\n bucket: aws_cdk.aws_s3.IBucket,\\n role: aws_cdk.aws_iam.IRole,\\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\\n\\n return jsii.invoke(self, \\\"bind\\\", [scope, stage, options])\",\n \"def bind(\\n self,\\n scope: aws_cdk.core.Construct,\\n stage: aws_cdk.aws_codepipeline.IStage,\\n *,\\n bucket: aws_cdk.aws_s3.IBucket,\\n role: aws_cdk.aws_iam.IRole,\\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\\n\\n return jsii.invoke(self, \\\"bind\\\", [scope, stage, options])\",\n \"def bind(\\n self,\\n scope: aws_cdk.core.Construct,\\n stage: aws_cdk.aws_codepipeline.IStage,\\n *,\\n bucket: aws_cdk.aws_s3.IBucket,\\n role: aws_cdk.aws_iam.IRole,\\n ) -> aws_cdk.aws_codepipeline.ActionConfig:\\n options = aws_cdk.aws_codepipeline.ActionBindOptions(bucket=bucket, role=role)\\n\\n return jsii.invoke(self, \\\"bind\\\", [scope, stage, options])\",\n \"def add_queue(self, queue):\\n with self.mutex:\\n self.queues.append(queue)\",\n \"def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\\n\\n if queue is None:\\n queue = routing_key\\n self.exchange = exchange\\n self.exchange_type = exchange_type\\n self.queue = queue\\n self.routing_key = routing_key\\n self._url = url\\n self.acked = acked\\n self.otq = otq\\n\\n self.cb = None\\n\\n self._connection = None\\n self._channel = None\\n self._closing = False\\n\\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\\n handler = logging.FileHandler(log_file)\\n logging.basicConfig(level=log_level, format=log_format)\\n self.logger = logging.getLogger(__name__)\\n self.logger.addHandler(handler)\\n\\n # used only for sending\\n self._deliveries = []\\n self._acked = 0\\n self._nacked = 0\\n self._message_number = 0\\n self._stopping = False\\n self._done_sending = False\\n self.message = \\\"\\\"\\n self.sender = sender\\n\\n # self.run()\\n # self._connection = self.connect()\",\n \"def zmq_bind_host(self):\\n return _host_tuple(self._get('zmq_bind_host'))\",\n \"def put_message(cls, message):\\n rp = cls.get()\\n rp.queue_receive.put(message)\",\n \"def keyExchangeServer():\\n with socket.socket() as sock:\\n try:\\n # if the port number already taken, the following line will not work\\n sock.bind((GW_ADRRESS, KEY_EXCHANGE_PORT))\\n print(\\\"success in binding\\\")\\n except:\\n print(\\\"error in binding\\\")\\n sys.exit()\\n sock.listen(0)\\n while True:\\n client_socket, client_address = sock.accept()\\n valid, data = get_msg(client_socket)\\n if valid:\\n data = data.split(\\\" \\\")\\n if data[0] == HELLO_MASSEGE:\\n if (client_address[0], int(data[1])) not in key_dic:\\n key = int.from_bytes(Fernet.generate_key(), \\\"big\\\")\\n else:\\n key = key_dic[(client_address[0], int(data[1]))]\\n client_socket.send(create_msg(get_key(key)).encode())\\n key_dic[(client_address[0], int(data[1]))] = key\\n print(key_dic)\",\n \"def reroute_queue(queue_name: str, exchange_name: str,\\n limit: int = 0,\\n message_filter: Optional[Tuple[str, str]] = None,\\n server_url: Optional[str] = None):\\n # Gather queue & exchange info + existance check\\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\\n server_url)\\n get_object('org.apache.qpid.broker', 'exchange',\\n exchange_name, server_url)\\n\\n method_arguments = {'request': limit} # type: dict\\n\\n if exchange_name:\\n method_arguments['useAltExchange'] = False\\n method_arguments['exchange'] = exchange_name\\n else:\\n method_arguments['useAltExchange'] = True\\n method_arguments['exchange'] = ''\\n\\n if message_filter:\\n method_arguments['filter'] = _build_message_filter(*message_filter)\\n\\n rpc = RemoteProcedure(handle_QMF2_exception,\\n 'qmf.default.direct', server_url)\\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\\n 'reroute', method_arguments),\\n timedelta(seconds=5))\",\n \"def bind(self):\\n if self.allow_reuse_address:\\n self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)\\n self.socket.bind(self.server_address)\\n self.server_address = self.socket.getsockname()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8586502","0.84070414","0.8285592","0.6888623","0.6881881","0.65968955","0.63757175","0.63733155","0.6050453","0.59048396","0.5763697","0.57079154","0.57029057","0.56764746","0.5662288","0.5568562","0.5544528","0.5477283","0.54671043","0.5458153","0.5446383","0.5401654","0.54010415","0.5394541","0.53860784","0.53612477","0.53573966","0.5355057","0.52654594","0.5262958","0.52583677","0.52424854","0.51964134","0.51948947","0.517227","0.513196","0.50957614","0.50957614","0.50957614","0.5092851","0.5092851","0.5092851","0.5076644","0.5073443","0.505574","0.502319","0.5009979","0.5009908","0.5009373","0.49814075","0.49722934","0.4953645","0.49314174","0.49157813","0.4888588","0.48859796","0.48830706","0.48679373","0.4858608","0.485373","0.48371345","0.48306653","0.48230702","0.48208654","0.4812414","0.48117638","0.4806975","0.48046923","0.48028633","0.4792015","0.47813177","0.47786477","0.47646162","0.4763074","0.4763074","0.4763074","0.4763074","0.4763074","0.4763074","0.4759183","0.47575653","0.4754083","0.4748781","0.47469252","0.47323856","0.47300202","0.47284487","0.47253114","0.47236526","0.47236526","0.47236526","0.47236526","0.47236526","0.47226125","0.47142902","0.47140592","0.47095832","0.47072387","0.46766633","0.4673223"],"string":"[\n \"0.8586502\",\n \"0.84070414\",\n \"0.8285592\",\n \"0.6888623\",\n \"0.6881881\",\n \"0.65968955\",\n \"0.63757175\",\n \"0.63733155\",\n \"0.6050453\",\n \"0.59048396\",\n \"0.5763697\",\n \"0.57079154\",\n \"0.57029057\",\n \"0.56764746\",\n \"0.5662288\",\n \"0.5568562\",\n \"0.5544528\",\n \"0.5477283\",\n \"0.54671043\",\n \"0.5458153\",\n \"0.5446383\",\n \"0.5401654\",\n \"0.54010415\",\n \"0.5394541\",\n \"0.53860784\",\n \"0.53612477\",\n \"0.53573966\",\n \"0.5355057\",\n \"0.52654594\",\n \"0.5262958\",\n \"0.52583677\",\n \"0.52424854\",\n \"0.51964134\",\n \"0.51948947\",\n \"0.517227\",\n \"0.513196\",\n \"0.50957614\",\n \"0.50957614\",\n \"0.50957614\",\n \"0.5092851\",\n \"0.5092851\",\n \"0.5092851\",\n \"0.5076644\",\n \"0.5073443\",\n \"0.505574\",\n \"0.502319\",\n \"0.5009979\",\n \"0.5009908\",\n \"0.5009373\",\n \"0.49814075\",\n \"0.49722934\",\n \"0.4953645\",\n \"0.49314174\",\n \"0.49157813\",\n \"0.4888588\",\n \"0.48859796\",\n \"0.48830706\",\n \"0.48679373\",\n \"0.4858608\",\n \"0.485373\",\n \"0.48371345\",\n \"0.48306653\",\n \"0.48230702\",\n \"0.48208654\",\n \"0.4812414\",\n \"0.48117638\",\n \"0.4806975\",\n \"0.48046923\",\n \"0.48028633\",\n \"0.4792015\",\n \"0.47813177\",\n \"0.47786477\",\n \"0.47646162\",\n \"0.4763074\",\n \"0.4763074\",\n \"0.4763074\",\n \"0.4763074\",\n \"0.4763074\",\n \"0.4763074\",\n \"0.4759183\",\n \"0.47575653\",\n \"0.4754083\",\n \"0.4748781\",\n \"0.47469252\",\n \"0.47323856\",\n \"0.47300202\",\n \"0.47284487\",\n \"0.47253114\",\n \"0.47236526\",\n \"0.47236526\",\n \"0.47236526\",\n \"0.47236526\",\n \"0.47236526\",\n \"0.47226125\",\n \"0.47142902\",\n \"0.47140592\",\n \"0.47095832\",\n \"0.47072387\",\n \"0.46766633\",\n \"0.4673223\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73164797"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":93082,"cells":{"query":{"kind":"string","value":"Consumer message context manager, returns a consumer message generator."},"document":{"kind":"string","value":"def consumer(self, no_ack=False, prefetch=100, priority=None):\n if prefetch is not None:\n self.channel.prefetch_count(prefetch)\n self.channel._consume(self, no_ack, priority)\n self.consuming = True\n yield Consumer(self)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.pause.set()\n\n while True:\n self.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n meta, message = self.queue.get(block=True, timeout=1)\n except Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[meta.partition] = message.offset + 1\n self.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.start.clear()","def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.events.pause.set()\n\n while True:\n self.events.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n partition, message = self.queue.get(block=True, timeout=1)\n except queue.Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[partition] = message.offset + 1\n self.events.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.events.start.clear()","def next_message(self):\n while self.queue.consuming:\n yield self.queue.channel._consume_message()","def _consume(self):\n # HACK: run_in_executor is used as a workaround to use boto\n # inside a coroutine. This is a stopgap solution that should be\n # replaced once boto has support for asyncio or aiobotocore has\n # a stable release.\n loop = asyncio.get_event_loop()\n receive_message = partial(\n self.client.receive_message,\n QueueUrl=self.app.settings['SQS_INBOUND_QUEUE_URL'],\n AttributeNames=self.app.settings['SQS_ATTRIBUTE_NAMES'],\n MessageAttributeNames=self.app.settings['SQS_MESSAGE_ATTRIBUTES'],\n MaxNumberOfMessages=self.app.settings['SQS_MESSAGE_BATCH_SIZE'],\n VisibilityTimeout=self.app.settings['SQS_VISIBILITY_TIMEOUT'],\n WaitTimeSeconds=self.app.settings['SQS_WAIT_TIME'],\n )\n while True:\n future = loop.run_in_executor(None, receive_message)\n messages = yield from future\n for message in messages.get('Messages', []):\n message['Body'] = json.loads(message['Body'])\n yield from self._message_queue.put(message)","def consumer(self):\n return Consumer(app=self.app, client=self.client)","def consumer(self):\n return self._consumer","def read(self):\n if not self._consuming:\n yield from self._begin_consuming()\n return (yield from self._message_queue.get())","async def consumer(message):\n # TODO\n print(message)","def kafka_consumer_factory(kafka_broker, topic, request):\n _consumer = [None]\n\n def factory(**kafka_consumer_params):\n params = {} if kafka_consumer_params is None else kafka_consumer_params.copy()\n params.setdefault('client_id', 'consumer_%s' % (request.node.name,))\n params.setdefault('auto_offset_reset', 'earliest')\n _consumer[0] = next(kafka_broker.get_consumers(cnt=1, topics=[topic], **params))\n return _consumer[0]\n\n yield factory\n\n if _consumer[0]:\n _consumer[0].close()","def consume(self, **kwargs):\n kwargs.setdefault('block', True)\n try:\n while True:\n msg = self.get(**kwargs)\n if msg is None:\n break\n yield msg\n except KeyboardInterrupt: # pragma: no cover\n print()\n return","def receive(self):\n while True:\n if self.pending_request:\n request = self.unpack(self.pending_request)\n self.pending_request = None\n else: \n request = self.unpack(self.mh.receive_message())\n if request:\n yield request\n else: break","def consumer (self):\n try:\n while True:\n try:\n data = os.read (self.read_fd, 65536)\n if not data:\n break\n except OSError as error:\n if error.errno not in BlockingErrorSet:\n break\n yield self.core.Poll (self.read_fd, POLL_READ)\n finally:\n self.Dispose ()","def get_generator(self):\n while self._is_running():\n yield self._queue.get()","def get_generator(self):\n while self._is_running():\n yield self._queue.get()","def _generator(self):\n\t\twhile(1):\n\t\t\ttry:\n\t\t\t\tm = self.messages.pop(0) # pop the first Flash2Message in the list\n\t\t\t\tyield m\n\t\t\texcept IndexError:\n\t\t\t\traise StopIteration","def start_consuming(self):\n logger.info('Issuing consumer related RPC commands')\n self.add_on_cancel_callback()\n logger.info(\"[{}] Waiting for messages on exchange {}\".format(self.bot_id, self.exchange))\n self._consumer_tag = self._channel.basic_consume(self.on_message,\n self.queue_name)","async def get_context(self, message, *, cls=NewCtx):\n return await super().get_context(message, cls=cls)","def _mp_consume(client, group, topic, chunk, queue, start, exit, pause, size):\n\n # Make the child processes open separate socket connections\n client.reinit()\n\n # We will start consumers without auto-commit. Auto-commit will be\n # done by the master controller process.\n consumer = SimpleConsumer(client, group, topic,\n partitions=chunk,\n auto_commit=False,\n auto_commit_every_n=None,\n auto_commit_every_t=None)\n\n # Ensure that the consumer provides the partition information\n consumer.provide_partition_info()\n\n while True:\n # Wait till the controller indicates us to start consumption\n start.wait()\n\n # If we are asked to quit, do so\n if exit.is_set():\n break\n\n # Consume messages and add them to the queue. If the controller\n # indicates a specific number of messages, follow that advice\n count = 0\n\n message = consumer.get_message()\n if message:\n queue.put(message)\n count += 1\n\n # We have reached the required size. The controller might have\n # more than what he needs. Wait for a while.\n # Without this logic, it is possible that we run into a big\n # loop consuming all available messages before the controller\n # can reset the 'start' event\n if count == size.value:\n pause.wait()\n\n else:\n # In case we did not receive any message, give up the CPU for\n # a while before we try again\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\n\n consumer.stop()","def create_receiver(self):\n receiver = kafka.KafkaConsumer(bootstrap_servers=['%s:%s' % (self._host, self._port)])\n return receiver","def _mp_consume(client, group, topic, queue, size, events, **consumer_options):\n\n # Initial interval for retries in seconds.\n interval = 1\n while not events.exit.is_set():\n try:\n # Make the child processes open separate socket connections\n client.reinit()\n\n # We will start consumers without auto-commit. Auto-commit will be\n # done by the master controller process.\n consumer = SimpleConsumer(client, group, topic,\n auto_commit=False,\n auto_commit_every_n=None,\n auto_commit_every_t=None,\n **consumer_options)\n\n # Ensure that the consumer provides the partition information\n consumer.provide_partition_info()\n\n while True:\n # Wait till the controller indicates us to start consumption\n events.start.wait()\n\n # If we are asked to quit, do so\n if events.exit.is_set():\n break\n\n # Consume messages and add them to the queue. If the controller\n # indicates a specific number of messages, follow that advice\n count = 0\n\n message = consumer.get_message()\n if message:\n while True:\n try:\n queue.put(message, timeout=FULL_QUEUE_WAIT_TIME_SECONDS)\n break\n except queue.Full:\n if events.exit.is_set():\n break\n\n count += 1\n\n # We have reached the required size. The controller might have\n # more than what he needs. Wait for a while.\n # Without this logic, it is possible that we run into a big\n # loop consuming all available messages before the controller\n # can reset the 'start' event\n if count == size.value:\n events.pause.wait()\n\n else:\n # In case we did not receive any message, give up the CPU for\n # a while before we try again\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\n\n consumer.stop()\n\n except KafkaError as e:\n # Retry with exponential backoff\n log.error(\n \"Problem communicating with Kafka (%s), retrying in %d seconds...\" % (e, interval))\n time.sleep(interval)\n interval = interval * 2 if interval * 2 < MAX_BACKOFF_SECONDS else MAX_BACKOFF_SECONDS","def start_consuming(self):\n self.logger.debug(\"Issuing consumer related RPC commands\")\n\n self._channel.basic_qos(prefetch_count=self._max_concurrent)\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\n consume_kwargs = {\"queue\": self._queue_name}\n if PIKA_ONE:\n consume_kwargs[\"on_message_callback\"] = self.on_message\n else:\n consume_kwargs[\"consumer_callback\"] = self.on_message\n\n self._consumer_tag = self._channel.basic_consume(**consume_kwargs)","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","def __init__(self, consumer):\n self._consumer = consumer","def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)\n \n \n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\n chan.exchange_declare(exchange = EXCHANGE,\n type = EXCHANGE_TYPE)\n queue = chan.queue_declare(QUEUE)\n chan.queue_bind(exchange = EXCHANGE, \n queue = QUEUE, \n routing_key = ROUTING_KEY)\n \n # Declare that we are going to listen to given queue\n chan.basic_consume(queue = QUEUE, \n callback = on_msg_recv)\n \n # Main loop. Waiting for messages from RabbitMQ.\n while True:\n chan.wait()","def produce(self, ctx):\n pass","def get_consumer(conf_settings, address=Config.INSIGHTS_KAFKA_ADDRESS): # pragma: no cover\n conf = _get_consumer_config(address, conf_settings)\n LOG.info(f\"Consumer config {conf}\")\n return Consumer(conf, logger=LOG)","def consume_messages(process_func: Callable[[str], None]):\n consumer = get_consumer()\n\n for message in consumer:\n log.debug(f'Received a message: {message}')\n try:\n process_func(message.value)\n except Exception as e:\n log.error(f'Failed to process a message: {message.value}')\n log.exception(e)","def getConsumer(self, topic):\n\n consumer = topic.get_balanced_consumer(zookeeper_connect=self.zookeeper_server, \n consumer_group=self.consumer_group,\n use_rdkafka=self.use_rdkafka,\n auto_offset_reset=self.initial_offset)\n self.consumer_started = True\n\n return consumer","def consume(self):\n LOGGER.debug('Consumer Initialized')\n # self.connect()\n channel = self.get_channel()\n self._bind_things(channel)\n\n try:\n LOGGER.info('Start consuming')\n channel.start_consuming()\n except ConnectionClosed:\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\n self.consume()\n except KeyboardInterrupt as e:\n LOGGER.info('Keyboard interrupt, stop consuming')\n self.shutdown()\n raise e\n except Exception as e:\n LOGGER.exception(\"'%s\" % str(e))\n self.shutdown()\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\n LOGGER.info(\"CONSUMER RAISED EXCEPTION\")\n raise e","def get_consumers(self, Consumer, channel):\n logger.debug(\"Get worker consumers\")\n return [Consumer(\n queues=self.queues,\n callbacks=[self.process_task]\n )]","def bind_message_ctx(message: Message, **additional_ctx) -> Iterator[None]:\n ctx = dict(\n kafka_topic=message.topic(),\n kafka_partition=message.partition(),\n kafka_offset=message.offset(),\n )\n ctx.update(additional_ctx)\n muselog.context.bind(**ctx)\n try:\n yield\n finally:\n # Clear only our context.\n # This will clear the `ctx` keys even if their values have been overwritten\n # by our yieldee.\n muselog.context.unbind(*list(ctx.keys()))","def __iter__(self):\n while True:\n m = self.recv(timeout=1.0)\n if m is not None:\n yield m\n logger.debug(\"done iterating over bus messages\")","def kafka_consumer(kafka_consumer_factory):\n return kafka_consumer_factory()","def create_consumers() -> List[Consumer]:\n consumers = []\n for consumer in range(CONSUMER_COUNT):\n consumers.append(\n Consumer(\n {\n AGE: FAKE.random_int(min=0, max=120),\n STATE: FAKE.state(),\n KIDS_COUNT: FAKE.random_int(min=0, max=12),\n CARS_COUNT: FAKE.random_int(min=0, max=10),\n INSURANCE_OPERATION: random.choice((RENT, BUY)),\n INCOME: FAKE.random_int(min=0, max=99999999999),\n PHONE_NUMBER: FAKE.phone_number(),\n AVAILABLE: True,\n }\n )\n )\n return consumers","def consume(self, handler):\n bounded_handler = partial(handler, self)\n self._consume_handler = handler\n self.log.debug(\"Start consuming\")\n self._channel.add_on_close_callback(\n self.on_channel_closed\n )\n self._consumer_tag = self._channel.basic_consume(bounded_handler,\n self.name)\n self.log.debug(\"Consumer tag %s on CHANNEL%i\",\n self._consumer_tag, self._channel.channel_number)","def start_consuming(self):\n\n for queue in self._handlers.keys():\n self._consumer_tags += self._channel.basic_consume(self.on_message,\n queue=queue)","def __next__(self):\n return self.read_message()","def server_message_iterator(self) -> Iterator[ServerMessage]:\n while not self._is_closed():\n with self._cv:\n self._cv.wait_for(\n lambda: self._status\n in [Status.CLOSED, Status.SERVER_MESSAGE_AVAILABLE]\n )\n\n self._raise_if_closed()\n\n server_message = self._server_message # Read\n self._server_message = None # Reset\n\n # Transition before yielding as after the yield the execution of this\n # function is paused and will resume when next is called again.\n # Also release condition variable by exiting the context\n self._transition(Status.AWAITING_CLIENT_MESSAGE)\n\n if server_message is None:\n raise Exception(\"Server message can not be None\")\n\n yield server_message","def message_listener(self, topic, timeout):\n \"\"\"\n demo_message = [\n {'user_id': 'Lazy Man', 'timestamp': '2019-10-06T22:59:59.989Z', 'risk_level': 3}\n ]\n\n for message in demo_message:\n yield ERROR_CODE_ZERO, \"\", message\n \"\"\"\n\n while True:\n for error_code, error_message, message in self._consumer.subscribe(topic, timeout):\n yield error_code, error_message, message\n if error_code == 1:\n break","def kafka_producer(kafka_producer_factory):\n yield kafka_producer_factory()","def consume(self, timeout=None):\n\n def _raise_timeout(exc):\n raise driver_common.Timeout(str(exc))\n\n timer = driver_common.DecayingTimer(duration=timeout)\n timer.start()\n\n poll_timeout = (self.consumer_timeout if timeout is None\n else min(timeout, self.consumer_timeout))\n\n while True:\n if self._consume_loop_stopped:\n return\n try:\n return self._poll_messages(poll_timeout)\n except kafka.errors.ConsumerTimeout as exc:\n poll_timeout = timer.check_return(\n _raise_timeout, exc, maximum=self.consumer_timeout)\n except Exception:\n LOG.exception(_LE(\"Failed to consume messages\"))\n return","def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak","def consume(self, block=True, timeout=0):\n\n # We need to repeat this step, because there may be messages\n # that expired, and we expect this method to always return message.\n while True:\n # Retrieve last message ID\n if block:\n # Blocking query, wait until message is available.\n message_id = self.pyrps.redis.blpop(self.pyrps._ns_queue(self.queue, self.consumer_id), timeout)\n\n # blpop returns tuple(key, value), we need only value.\n message_id = message_id[1]\n else:\n # Non blocking query. Return if there is no message in queue.\n message_id = self.pyrps.redis.lpop(self.pyrps._ns_queue(self.queue, self.consumer_id))\n\n # If there is no message in the queue, return None.\n if message_id is None:\n return None\n\n # Retrieve the message\n message = self.pyrps.redis.get(self.pyrps._ns_message(self.queue, message_id))\n \n # If message still exists (no TTL has been reached), return it.\n if message is not None:\n return message","def messageCollector():\n\ttempui = CatchallUI()\n\trealui = base.ui\n\ttry:\n\t\tbase.ui = tempui\n\t\tyield tempui\n\tfinally:\n\t\tbase.ui = realui","def get():\n _processEvents()\n return _event_generator()","def _next_message(self):\n msg = yield self._read_message()\n message = self._slack_to_chat(msg)\n\n raise gen.Return(message)","def consumer(func):\n\n from functools import wraps\n\n @wraps(func)\n def wrapper(*args,**kw):\n gen = func(*args, **kw)\n gen.next()\n return gen\n return wrapper","def __iter__(self):\n self.enable_receiving()\n with closing(select.epoll()) as notifier:\n notifier.register(self, select.EPOLLIN)\n while True:\n events = eintr_retry_call(notifier.poll)\n for event in events:\n yield self.receive_device()","def test_consumer_read_messages(self):\n try:\n test_consumer = TestConsumer(self.msg_queue, self.queue_lock, self.topic, self.properties_file)\n test_consumer.start()\n except Exception as e:\n self.fail(f\"test_consumer_read_messages() failed with exception: {e}\")\n\n producer_msg_queue = queue.Queue()\n producer_queue_lock = threading.Lock()\n try:\n test_producer = Producer(producer_msg_queue, producer_queue_lock, self.topic, self.producer_properties_file)\n test_producer.start()\n except Exception as e:\n self.fail(f\"test_consumer_read_messages() failed with exception: {e}\")\n\n msgs = []\n\n for i in range(1, 4):\n msg = f\"Message number {i}\"\n\n producer_queue_lock.acquire()\n producer_msg_queue.put_nowait(msg)\n producer_queue_lock.release()\n\n msgs.append(msg)\n\n # Sleep for few seconds seconds to allow the consumer thread to process all the messages.\n time.sleep(20)\n\n self.assertEqual(test_consumer.dequeue_msgs(), msgs)\n\n test_producer.stop()\n test_consumer.stop()\n test_producer.join()\n test_consumer.join()","def kafka_payment_consumer_worker(mq: queue.Queue):\n global app_config\n\n # Client\n consumer = KafkaConsumer('payment',\n bootstrap_servers=bootstrap_servers,\n value_deserializer=lambda item: json.loads(item.decode('utf-8')))\n\n\n\n while not t_stop_event.is_set():\n try:\n # Message loop\n for message in consumer:\n logging.info(\"READING MESSAGE %s:%d:%d: key=%s value=%s\" % (\n message.topic,\n message.partition,\n message.offset,\n message.key,\n message.value)\n )\n\n # simple sanitizer\n if (\"action\" not in message.value) \\\n or (\"message\" not in message.value) \\\n or (\"request\" not in message.value[\"message\"]):\n logging.info(\"MALFORMED MESSAGE value=%s SKIPPING\" % (message.value,))\n continue\n\n # Action switch\n if str(message.value[\"action\"]).upper() == \"NOTIFY_DELIVERY_RESPONSE\":\n logging.info(\"MESSAGE <NOTIFY_DELIVERY_RESPONSE> RECEIVE\") # Mocked\n \"\"\"logging.info(\"PUT credit_deliverer MESSAGE in QUEUE\")\n mq.put(\n credit_deliverer()\n )\"\"\"\n except Exception as e:\n logging.fatal(e, exc_info=True)\n # Post routine\n\n consumer.close()\n return","def receive_message(self, context, message):\r\n pass","def retrieve(self) -> Iterator[SQSMessage]:\n while True:\n try:\n sqs = SQSClientFactory(boto3).from_env()\n\n res = sqs.receive_message(\n QueueUrl=self.queue_url,\n WaitTimeSeconds=3,\n MaxNumberOfMessages=10,\n )\n\n messages = res.get(\"Messages\", [])\n if not messages:\n LOGGER.info(\"queue was empty\")\n\n s3_events = [SQSMessage(msg) for msg in messages]\n for sqs_message in s3_events:\n yield sqs_message\n\n sqs.delete_message(\n QueueUrl=self.queue_url,\n ReceiptHandle=sqs_message.receipt_handle,\n )\n\n except Exception as e:\n LOGGER.error(traceback.format_exc())\n time.sleep(2)","def _dispatch_messages(self):\n while True:\n select_obj = (yield)\n if select_obj == self._message_queue.selobj:\n msg = self._message_queue.get_nowait()\n if msg is not None:\n msg_type = msg.get('type', None)\n if msg_type is not None:\n msg_handler = self._message_handlers.get(msg_type, None)\n if msg_handler is not None:\n msg_handler(msg['data'])","def generator(self):\n return self._generator","async def get_context(self, message: discord.Message, *, cls: commands.Context = None) -> commands.Context:\n return await super().get_context(message, cls=cls or WMBotContext)","def _wrap_generator(ctx_factory, func):\n @functools.wraps(func)\n def generator_context(*args, **kwargs):\n gen = func(*args, **kwargs)\n\n # Generators are suspended and unsuspended at `yield`, hence we\n # make sure the grad mode is properly set every time the execution\n # flow returns into the wrapped generator and restored when it\n # returns through our `yield` to our caller (see PR #49017).\n try:\n # Issuing `None` to a generator fires it up\n with ctx_factory():\n response = gen.send(None)\n\n while True:\n try:\n # Forward the response to our caller and get its next request\n request = yield response\n\n except GeneratorExit:\n # Inform the still active generator about its imminent closure\n with ctx_factory():\n gen.close()\n raise\n\n except BaseException:\n # Propagate the exception thrown at us by the caller\n with ctx_factory():\n response = gen.throw(*sys.exc_info())\n\n else:\n # Pass the last request to the generator and get its response\n with ctx_factory():\n response = gen.send(request)\n\n # We let the exceptions raised above by the generator's `.throw` or\n # `.send` methods bubble up to our caller, except for StopIteration\n except StopIteration as e:\n # The generator informed us that it is done: take whatever its\n # returned value (if any) was and indicate that we're done too\n # by returning it (see docs for python's return-statement).\n return e.value\n\n return generator_context","def receive():\n now = time.time()\n end = now + MAX_DURATION\n tmp = None\n # Heroku doesn't notify when clients disconnect so we have to impose a\n # maximum connection duration.\n while now < end:\n if not tmp:\n tmp = AsyncResult()\n BROADCAST_QUEUE.put(tmp)\n try:\n yield tmp.get(timeout=KEEP_ALIVE_DELAY)\n tmp = None\n except Timeout:\n yield ''\n now = time.time()","def get_generator(self):\n if(not self._constructed): raise EGCSUnconstructedStateError()\n return self._generator","async def consumer_loop(\n uri: str,\n topic: str,\n ssl_context: SSLContext,\n writers: List[Callable[[ConsumerPayload], Awaitable[int]]],\n) -> int:\n log.info(\"consumer: starting\")\n if len(writers) < 1:\n raise ValueError(\"there must be at least one writer passed to consumer_loop.\")\n queue: asyncio.Queue[ConsumerPayload] = asyncio.Queue()\n async with AIOKafkaConsumer(\n topic,\n bootstrap_servers=uri,\n security_protocol=\"SSL\",\n ssl_context=ssl_context,\n group_id=DEFAULT_GROUP_ID,\n ) as consumer:\n await asyncio.gather(\n decoder(queue, consumer), writer_wrapper(queue=queue, writers=writers)\n )\n log.info(\"consumer: exiting\")\n return 0","def start_consuming(self):\n # LOGGER.info('Issuing consumer related RPC commands')\n if self._init_ok_ctrl and self._init_ok_task:\n self._channel_ctrl.add_on_cancel_callback(self.on_consumer_ctrl_cancelled)\n self._channel_task.add_on_cancel_callback(self.on_consumer_task_cancelled)\n self._consumer_tag_task = self._channel_task.basic_consume(\n self.queue_task,\n auto_ack=False,\n on_message_callback=self.on_message\n )\n self._consumer_tag_ctrl = self._channel_ctrl.basic_consume(\n self._topic_queue_name,\n auto_ack=False,\n on_message_callback=self.on_topic\n )\n self.was_consuming = True\n self._consuming = True","def start_consuming(self, channel, rx_queue_name):\n if self.should_stop():\n logger.info(\"ready to stop, pause to consume\")\n return\n logger.info('Issuing consumer related RPC commands')\n self._consumer_tag = channel.basic_consume(\n self.on_message, rx_queue_name, auto_ack = False)\n channel.start_consuming()","def subscribeConsumer(consumer):","def _create_channel(self):\n self.connection = pika.BlockingConnection(self.pikaparams)\n self.channel = self.connection.channel()\n try:\n yield self.channel\n finally:\n self.channel.close()\n self.connection.close()","def consume(self):\n if not self.__events:\n raise StopIteration\n\n if self.__instance.id is None:\n raise ImplementationError(\n \"Can not consume event stream before aggregate has\"\n \"been assigned an identifier.\")\n\n cid = str(uuid.UUID(bytes=os.urandom(16)))\n while self.__events:\n event = self.__events.pop(0)\n event.aggregate_id = self.__instance.id\n event.correlation_id = cid\n event.timestamp = sq.timezone.now()\n yield ImmutableDTO(event).as_dto()","def consume_message(\n engine, cert_folder=CERT_FOLDER, service_uri=SERVICE_URI, topic_name=TOPIC_NAME\n):\n\n consumer = get_consumer(\n cert_folder=cert_folder, service_uri=service_uri, topic_name=topic_name\n )\n\n if consumer is None:\n sys.exit(1)\n\n tries = 0\n\n for message in consumer:\n data = None\n\n try:\n # Read message and get the data (dict).\n data = read_message(message=message)\n\n except Exception as error: # pylint: disable=broad-except\n tries += 1\n logger.error(\"Consumer could not read message due to %s.\", error)\n\n # Exit if number of tries exceeds the number of max read tries.\n if tries > MAX_READ_TRIES:\n sys.exit(1)\n\n finally:\n if data is not None:\n # Send the data to PostgreSQL server.\n insert_data(engine=engine, data=data)","def consume(self):\n\n self.consumer = self.getConsumer(self.client.topics[self.topic])\n\n # create splunk hec instance\n splunk_hec = hec(self.splunk_server,\n self.splunk_hec_port,\n self.splunk_hec_channel,\n self.splunk_hec_token,\n self.splunk_sourcetype,\n self.splunk_source,\n self.use_https,\n self.verify_ssl,\n self.use_compression,\n self.compresslevel)\n while(True):\n m = self.consumer.consume()\n \n # Append messages to list until we've hit self.batch_size\n if(len(self.messages) <= self.batch_size):\n self.messages.append(m.value)\n\n # Send messages to Splunk HEC\n if(len(self.messages) == self.batch_size):\n retry(self.sendToSplunk,\n attempts=self.retry_attempts,\n sleeptime=self.sleeptime,\n max_sleeptime=self.max_sleeptime,\n sleepscale=self.sleepscale,\n jitter=self.jitter,\n retry_exceptions=(Exception,),\n args=(splunk_hec,))","def allocation(self):\n return self.mapping[self.consumer_name]","def new_generator(self):\n return self.generator_function(*self.args, **self.kwargs)","def __next__(self):\n waitable = queue.Queue(maxsize=1)\n getter = functools.partial(waitable.get, timeout=self._timeout)\n self._latest_item = self._async_wrapper_class(\n func=getter,\n concurrency_provider=self._provider\n )\n with self._lock:\n try:\n # get latest notification\n data = self._notifications.get_nowait()\n except queue.Empty:\n # store the consumer\n self._waitables.put(waitable)\n LOG.debug('no data for new consumer')\n else:\n # if we have a notification, pass it to the consumer immediately\n waitable.put_nowait(data)\n LOG.debug('new consumer taking next data immediately')\n return self._latest_item","def consume(self, consume_mode):\n resp = yield from self.command('consume {}'.format(consume_mode))\n return True","def get_generator(generator: Generator, **kwargs) -> Generator:\n return generator(**kwargs)","def gen_ciphertext(message: str) -> str:\r\n key = 1\r\n for i in range(26):\r\n ciphertext = cipher(key, message)\r\n yield f\"Key #{key}: {ciphertext}\"\r\n key += 1","def get_context(self):\n return self.context.generate()","def yield_messages(self, *, mailbox=DEFAULT_MAILBOX):\n with imaplib.IMAP4_SSL(\n host=self.host, port=self.port,\n ssl_context=ssl.create_default_context()) as ic:\n logger.debug(f'Logging in as {self.user}')\n restype, _ = ic.login(user=self.user, password=self.password)\n check_restype(restype, f'failed to LOGIN as {self.user}')\n\n logger.debug(f'Selecting mailbox {mailbox}')\n restype, _ = ic.select(mailbox=mailbox)\n check_restype(restype, f'failed to SELECT mailbox {mailbox}')\n\n # First, query for *all* message UIDs in the selected mailbox.\n # Interpret the response as a list of integers.\n logger.debug('Getting UID list')\n restype, [uids] = ic.uid('SEARCH', 'ALL')\n check_restype(restype, 'failed to execute SEARCH')\n uids = [*map(int, filter(None, uids.split(b' ')))]\n\n # In the event that the mailbox is empty, there will be no UIDs and\n # nothing more to do.\n if not uids:\n logger.debug('No messages in this mailbox')\n raise NoMessages\n\n # Fetch a range of message headers, from the smallest UID to the\n # largest UID. Build a structure that links each UID to the `Date`\n # header on the message it refers to.\n message_set = f'{min(uids)}:{max(uids)}'\n logger.debug(f'Fetching headers in UID range {message_set}')\n restype, resdata = ic.uid('FETCH', message_set, '(BODY.PEEK[HEADER])')\n check_restype(restype, f'failed to execute FETCH UIDs {message_set} (peek)')\n uids_dated = self.date_uid_map(data=resdata)\n\n # Iterate over all UIDs in date order, oldest to newest.\n for _, uid in sorted(uids_dated, key=itemgetter(0)):\n # Fetch the full message content, wrap it in an IMAPMessage and\n # yield it to the caller.\n logger.debug(f'Fetching message UID {int(uid)}')\n restype, resdata = ic.uid('FETCH', uid, '(RFC822)')\n check_restype(restype, f'failed to execute FETCH UID {int(uid)} (full)')\n\n yield IMAPMessage(data=resdata, imap_connection=ic, uid=uid)","def kafka_consumer(request: 'SubRequest') -> KafkaConsumer:\n _, kafka_port = request.getfixturevalue(kafka_fixture_name)\n\n used_consumer_kwargs = consumer_kwargs.copy()\n used_consumer_kwargs.setdefault('consumer_timeout_ms', DEFAULT_CONSUMER_TIMEOUT_MS)\n used_consumer_kwargs.setdefault('bootstrap_servers', 'localhost:{}'.format(kafka_port))\n\n consumer = KafkaConsumer(\n *kafka_topics,\n **used_consumer_kwargs,\n )\n\n if seek_to_beginning:\n assert kafka_topics, (\n 'In order to be able to seek to beginning, we must have some partitions assigned '\n 'for which we need to subscribe to topics.')\n\n def partitions_assigned():\n consumer.poll(timeout_ms=20)\n return len(consumer.assignment()) > 0\n\n _wait_until(partitions_assigned)\n\n consumer.seek_to_beginning()\n return consumer","def stream(\n consumer: Consumer,\n count: Optional[int] = None,\n poll_timeout: Optional[float] = DEFAULT_POLL_TIMEOUT,\n timeout: Optional[float] = None,\n) -> Iterator[Message]:\n if count is not None and count <= 0:\n raise ValueError(\"count must be a positive integer.\")\n if poll_timeout is not None and poll_timeout <= 0:\n raise ValueError(\"poll_timeout must be a positive float.\")\n if timeout is not None and timeout <= 0:\n raise ValueError(\"timeout must be a positive float.\")\n\n if count is None:\n LOGGER.debug(\"Streaming messages....\")\n else:\n LOGGER.debug(\"Streaming up to %d messages....\", count)\n\n if timeout is not None:\n timeout_delta = timedelta(milliseconds=int(timeout * MILLIS_IN_SECOND))\n\n stream_duration = timedelta()\n num_messages = 0\n while count is None or num_messages < count:\n if musekafka.shutdown.is_shutting_down():\n break\n\n if timeout is not None:\n if stream_duration >= timeout_delta:\n LOGGER.debug(\"Hit stream timeout (%.3f seconds).\", timeout)\n break\n poll_timeout = min(\n poll_timeout or timeout, (timeout_delta - stream_duration).total_seconds()\n )\n\n stream_start = datetime.utcnow()\n try:\n message = poll(consumer, timeout=poll_timeout)\n except TimeoutError as e:\n LOGGER.debug(str(e))\n continue\n finally:\n stream_duration += datetime.utcnow() - stream_start\n with bind_message_ctx(message):\n yield message\n num_messages += 1\n LOGGER.debug(\"Completed streaming %d messages.\", num_messages)","def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions] = None,\n consumer_group_id: Optional[pulumi.Input[str]] = None,\n consumer_group_name: Optional[pulumi.Input[str]] = None,\n consumer_group_password: Optional[pulumi.Input[str]] = None,\n consumer_group_user_name: Optional[pulumi.Input[str]] = None,\n dts_instance_id: Optional[pulumi.Input[str]] = None) -> 'ConsumerChannel':\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\n\n __props__ = _ConsumerChannelState.__new__(_ConsumerChannelState)\n\n __props__.__dict__[\"consumer_group_id\"] = consumer_group_id\n __props__.__dict__[\"consumer_group_name\"] = consumer_group_name\n __props__.__dict__[\"consumer_group_password\"] = consumer_group_password\n __props__.__dict__[\"consumer_group_user_name\"] = consumer_group_user_name\n __props__.__dict__[\"dts_instance_id\"] = dts_instance_id\n return ConsumerChannel(resource_name, opts=opts, __props__=__props__)","def consumer(self, consumer):\n self._consumer = consumer","def message_thread(self):\r\n return resource.MessageThread(self)","def consumer_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"consumer_id\")","def get_generator(self, file_generator, batch_size=None, **kwargs):\n raise NotImplementedError('')","def keypress_get_generator(self):\n raise NotImplementedError(\"ERROR: Unimplemented function.\")","def consume_user_message(self, message):\n pass","def consumer_group(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"consumer_group\")","def rosbag_msg_generator(bag_file, topics=None):\n\n import rosbag\n from datetime import datetime\n if not rospy.core.is_initialized():\n rospy.init_node('rosbag_msg_generator', anonymous=True)\n bag = rosbag.Bag(bag_file)\n types_topics_tuple = bag.get_type_and_topic_info()\n if topics is None:\n topics = types_topics_tuple.topics.keys()\n\n pubs = {}\n for topic, message, timestamp in bag.read_messages(topics=topics, raw=True):\n msg_type = message[4]\n data = message[1]\n if topic in pubs:\n pub = pubs[topic]\n else:\n pub = rospy.Publisher(topic, msg_type, latch=True, queue_size=30)\n pubs[topic] = pub\n msg = msg_type()\n msg.deserialize(data)\n pub.publish(msg)\n timestamp = datetime.fromtimestamp(timestamp.to_sec())\n yield topic, msg, timestamp\n bag.close()","def poll(consumer: Consumer, timeout: Optional[float] = DEFAULT_POLL_TIMEOUT) -> Message:\n if timeout is not None and timeout <= 0:\n raise ValueError(\"timeout must be a positive integer.\")\n\n if timeout is not None:\n timeout_delta = timedelta(milliseconds=int(timeout * MILLIS_IN_SECOND))\n\n poll_duration = timedelta()\n while True:\n if timeout is not None:\n if poll_duration >= timeout_delta:\n raise TimeoutError(f\"Hit poll timeout of {timeout} seconds.\")\n poll_timeout = (timeout_delta - poll_duration).total_seconds()\n\n poll_start = datetime.utcnow()\n message = consumer.poll() if timeout is None else consumer.poll(timeout=poll_timeout)\n poll_duration += datetime.utcnow() - poll_start\n if message is None:\n continue\n\n with bind_message_ctx(message):\n LOGGER.debug(\n \"Received message -- topic=%s partition=%s offset=%s\",\n message.topic(),\n message.partition(),\n message.offset(),\n )\n\n if message.error():\n # If we cannot read the raw message correctly, we give up and\n # raise the error to the caller.\n raise ConsumerException(f\"Got bad message from Kafka: {message.error()}\")\n\n return message","def consumer_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"consumer_id\")","def consume_messages(self):\n\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\n\n while method_frame:\n\n LOGGER.info(\"Message received\")\n\n self.channel.basic_ack(method_frame.delivery_tag)\n payload = json.loads(body)\n if not isinstance(payload, dict):\n return\n\n # Process the message\n if 'control' in payload:\n LOGGER.info(\"A control signal received!\")\n # self.set_control(payload['control'])\n print(payload['control'])\n\n # Continue getting messages\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\n\n # TODO\n # return control_signal","def generate_message(self, mtu):\r\n raise GeneratorExit(\"No more message to send\")","def consumer(state: SharedState):","async def produce_consume(topic_name):\n await asyncio.create_task(produce(topic_name))","def generate(self, *args: t.Any, **kwargs: t.Any) -> t.Iterator[str]:\n if self.environment.is_async:\n import asyncio\n\n async def to_list() -> t.List[str]:\n return [x async for x in self.generate_async(*args, **kwargs)]\n\n yield from asyncio.run(to_list())\n return\n\n ctx = self.new_context(dict(*args, **kwargs))\n\n try:\n yield from self.root_render_func(ctx) # type: ignore\n except Exception:\n yield self.environment.handle_exception()","def kafka_producer_factory(kafka_broker, request):\n _producer = [None]\n\n def factory(**kafka_producer_params):\n params = {} if kafka_producer_params is None else kafka_producer_params.copy()\n params.setdefault('client_id', 'producer_%s' % (request.node.name,))\n _producer[0] = next(kafka_broker.get_producers(cnt=1, **params))\n return _producer[0]\n\n yield factory\n\n if _producer[0]:\n _producer[0].close()","def __iter__(self):\n return self.new_generator()","def stream(self):\n\n iterator = iter(self._stream)\n while self._state < Computation.STATE_COMPLETED:\n try:\n message = next(iterator)\n except StopIteration:\n if self._state < Computation.STATE_COMPLETED:\n self._stream = self._execute()\n iterator = iter(self._stream)\n continue\n break\n\n if isinstance(message, messages.StreamStartMessage):\n self._state = Computation.STATE_STREAM_STARTED\n continue\n\n if isinstance(message, messages.JobStartMessage):\n self._state = Computation.STATE_COMPUTATION_STARTED\n self._id = message.handle\n yield message\n continue\n\n if isinstance(message, messages.JobProgressMessage):\n yield message\n continue\n\n if isinstance(message, messages.ChannelAbortMessage):\n self._state = Computation.STATE_ABORTED\n raise errors.ComputationAborted(message.abort_info)\n\n if isinstance(message, messages.EndOfChannelMessage):\n self._state = Computation.STATE_COMPLETED\n continue\n\n # Intercept metadata messages to accumulate received metadata...\n if isinstance(message, messages.MetadataMessage):\n self._metadata[message.tsid] = message.properties\n yield message\n continue\n\n # ...as well as expired-tsid messages to clean it up.\n if isinstance(message, messages.ExpiredTsIdMessage):\n if message.tsid in self._metadata:\n del self._metadata[message.tsid]\n yield message\n continue\n\n if isinstance(message, messages.InfoMessage):\n self._process_info_message(message.message)\n self._batch_count_detected = True\n yield message\n if self._current_batch_message:\n yield self._get_batch_to_yield()\n continue\n\n # Accumulate data messages and release them when we have received\n # all batches for the same logical timestamp.\n if isinstance(message, messages.DataMessage):\n self._state = Computation.STATE_DATA_RECEIVED\n\n if not self._batch_count_detected:\n self._expected_batches += 1\n\n if not self._current_batch_message:\n self._current_batch_message = message\n self._current_batch_count = 1\n elif (message.logical_timestamp_ms ==\n self._current_batch_message.logical_timestamp_ms):\n self._current_batch_message.add_data(message.data)\n self._current_batch_count += 1\n else:\n self._batch_count_detected = True\n\n if (self._batch_count_detected and\n self._current_batch_count == self._expected_batches):\n yield self._get_batch_to_yield()\n continue\n\n if isinstance(message, messages.EventMessage):\n yield message\n continue\n\n if isinstance(message, messages.ErrorMessage):\n raise errors.ComputationFailed(message.errors)\n\n # Yield last batch, even if potentially incomplete.\n if self._current_batch_message:\n yield self._get_batch_to_yield()","def blocking_context():\n block()\n try:\n yield\n finally:\n # an error could happen somewhere else when this ctx manager is on `yield`\n unblock()","def loan_message_creator_factory():\n return partial(\n message_factory, current_app.config[\"ILS_CIRCULATION_MAIL_MSG_CREATOR\"]\n )","def kafka_client(kafka_broker, request):\n (client,) = kafka_broker.get_clients(cnt=1, client_id='%s_client' % (request.node.name,))\n yield client\n client.close()","def get_manager_with_least_processed_events_generator(self):\n try:\n managers = self.db_handler.get_manager_with_least_processed_events()\n\n for manager in managers:\n self.logger.write_to_log(f'returned manager for notification', 'model')\n yield (len(managers) - managers.index(manager)) - 1, manager[0]\n except Exception as err:\n method_name = sys._getframe().f_code.co_name\n\n self.logger.write_to_log('exception', 'model')\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')","def __call__(self, gen) -> Generator:\n self.stream = gen\n self.prepare()\n return self.stream"],"string":"[\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.pause.set()\\n\\n while True:\\n self.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n meta, message = self.queue.get(block=True, timeout=1)\\n except Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[meta.partition] = message.offset + 1\\n self.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.start.clear()\",\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.events.pause.set()\\n\\n while True:\\n self.events.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n partition, message = self.queue.get(block=True, timeout=1)\\n except queue.Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[partition] = message.offset + 1\\n self.events.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.events.start.clear()\",\n \"def next_message(self):\\n while self.queue.consuming:\\n yield self.queue.channel._consume_message()\",\n \"def _consume(self):\\n # HACK: run_in_executor is used as a workaround to use boto\\n # inside a coroutine. This is a stopgap solution that should be\\n # replaced once boto has support for asyncio or aiobotocore has\\n # a stable release.\\n loop = asyncio.get_event_loop()\\n receive_message = partial(\\n self.client.receive_message,\\n QueueUrl=self.app.settings['SQS_INBOUND_QUEUE_URL'],\\n AttributeNames=self.app.settings['SQS_ATTRIBUTE_NAMES'],\\n MessageAttributeNames=self.app.settings['SQS_MESSAGE_ATTRIBUTES'],\\n MaxNumberOfMessages=self.app.settings['SQS_MESSAGE_BATCH_SIZE'],\\n VisibilityTimeout=self.app.settings['SQS_VISIBILITY_TIMEOUT'],\\n WaitTimeSeconds=self.app.settings['SQS_WAIT_TIME'],\\n )\\n while True:\\n future = loop.run_in_executor(None, receive_message)\\n messages = yield from future\\n for message in messages.get('Messages', []):\\n message['Body'] = json.loads(message['Body'])\\n yield from self._message_queue.put(message)\",\n \"def consumer(self):\\n return Consumer(app=self.app, client=self.client)\",\n \"def consumer(self):\\n return self._consumer\",\n \"def read(self):\\n if not self._consuming:\\n yield from self._begin_consuming()\\n return (yield from self._message_queue.get())\",\n \"async def consumer(message):\\n # TODO\\n print(message)\",\n \"def kafka_consumer_factory(kafka_broker, topic, request):\\n _consumer = [None]\\n\\n def factory(**kafka_consumer_params):\\n params = {} if kafka_consumer_params is None else kafka_consumer_params.copy()\\n params.setdefault('client_id', 'consumer_%s' % (request.node.name,))\\n params.setdefault('auto_offset_reset', 'earliest')\\n _consumer[0] = next(kafka_broker.get_consumers(cnt=1, topics=[topic], **params))\\n return _consumer[0]\\n\\n yield factory\\n\\n if _consumer[0]:\\n _consumer[0].close()\",\n \"def consume(self, **kwargs):\\n kwargs.setdefault('block', True)\\n try:\\n while True:\\n msg = self.get(**kwargs)\\n if msg is None:\\n break\\n yield msg\\n except KeyboardInterrupt: # pragma: no cover\\n print()\\n return\",\n \"def receive(self):\\n while True:\\n if self.pending_request:\\n request = self.unpack(self.pending_request)\\n self.pending_request = None\\n else: \\n request = self.unpack(self.mh.receive_message())\\n if request:\\n yield request\\n else: break\",\n \"def consumer (self):\\n try:\\n while True:\\n try:\\n data = os.read (self.read_fd, 65536)\\n if not data:\\n break\\n except OSError as error:\\n if error.errno not in BlockingErrorSet:\\n break\\n yield self.core.Poll (self.read_fd, POLL_READ)\\n finally:\\n self.Dispose ()\",\n \"def get_generator(self):\\n while self._is_running():\\n yield self._queue.get()\",\n \"def get_generator(self):\\n while self._is_running():\\n yield self._queue.get()\",\n \"def _generator(self):\\n\\t\\twhile(1):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tm = self.messages.pop(0) # pop the first Flash2Message in the list\\n\\t\\t\\t\\tyield m\\n\\t\\t\\texcept IndexError:\\n\\t\\t\\t\\traise StopIteration\",\n \"def start_consuming(self):\\n logger.info('Issuing consumer related RPC commands')\\n self.add_on_cancel_callback()\\n logger.info(\\\"[{}] Waiting for messages on exchange {}\\\".format(self.bot_id, self.exchange))\\n self._consumer_tag = self._channel.basic_consume(self.on_message,\\n self.queue_name)\",\n \"async def get_context(self, message, *, cls=NewCtx):\\n return await super().get_context(message, cls=cls)\",\n \"def _mp_consume(client, group, topic, chunk, queue, start, exit, pause, size):\\n\\n # Make the child processes open separate socket connections\\n client.reinit()\\n\\n # We will start consumers without auto-commit. Auto-commit will be\\n # done by the master controller process.\\n consumer = SimpleConsumer(client, group, topic,\\n partitions=chunk,\\n auto_commit=False,\\n auto_commit_every_n=None,\\n auto_commit_every_t=None)\\n\\n # Ensure that the consumer provides the partition information\\n consumer.provide_partition_info()\\n\\n while True:\\n # Wait till the controller indicates us to start consumption\\n start.wait()\\n\\n # If we are asked to quit, do so\\n if exit.is_set():\\n break\\n\\n # Consume messages and add them to the queue. If the controller\\n # indicates a specific number of messages, follow that advice\\n count = 0\\n\\n message = consumer.get_message()\\n if message:\\n queue.put(message)\\n count += 1\\n\\n # We have reached the required size. The controller might have\\n # more than what he needs. Wait for a while.\\n # Without this logic, it is possible that we run into a big\\n # loop consuming all available messages before the controller\\n # can reset the 'start' event\\n if count == size.value:\\n pause.wait()\\n\\n else:\\n # In case we did not receive any message, give up the CPU for\\n # a while before we try again\\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\\n\\n consumer.stop()\",\n \"def create_receiver(self):\\n receiver = kafka.KafkaConsumer(bootstrap_servers=['%s:%s' % (self._host, self._port)])\\n return receiver\",\n \"def _mp_consume(client, group, topic, queue, size, events, **consumer_options):\\n\\n # Initial interval for retries in seconds.\\n interval = 1\\n while not events.exit.is_set():\\n try:\\n # Make the child processes open separate socket connections\\n client.reinit()\\n\\n # We will start consumers without auto-commit. Auto-commit will be\\n # done by the master controller process.\\n consumer = SimpleConsumer(client, group, topic,\\n auto_commit=False,\\n auto_commit_every_n=None,\\n auto_commit_every_t=None,\\n **consumer_options)\\n\\n # Ensure that the consumer provides the partition information\\n consumer.provide_partition_info()\\n\\n while True:\\n # Wait till the controller indicates us to start consumption\\n events.start.wait()\\n\\n # If we are asked to quit, do so\\n if events.exit.is_set():\\n break\\n\\n # Consume messages and add them to the queue. If the controller\\n # indicates a specific number of messages, follow that advice\\n count = 0\\n\\n message = consumer.get_message()\\n if message:\\n while True:\\n try:\\n queue.put(message, timeout=FULL_QUEUE_WAIT_TIME_SECONDS)\\n break\\n except queue.Full:\\n if events.exit.is_set():\\n break\\n\\n count += 1\\n\\n # We have reached the required size. The controller might have\\n # more than what he needs. Wait for a while.\\n # Without this logic, it is possible that we run into a big\\n # loop consuming all available messages before the controller\\n # can reset the 'start' event\\n if count == size.value:\\n events.pause.wait()\\n\\n else:\\n # In case we did not receive any message, give up the CPU for\\n # a while before we try again\\n time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)\\n\\n consumer.stop()\\n\\n except KafkaError as e:\\n # Retry with exponential backoff\\n log.error(\\n \\\"Problem communicating with Kafka (%s), retrying in %d seconds...\\\" % (e, interval))\\n time.sleep(interval)\\n interval = interval * 2 if interval * 2 < MAX_BACKOFF_SECONDS else MAX_BACKOFF_SECONDS\",\n \"def start_consuming(self):\\n self.logger.debug(\\\"Issuing consumer related RPC commands\\\")\\n\\n self._channel.basic_qos(prefetch_count=self._max_concurrent)\\n self._channel.add_on_cancel_callback(self.on_consumer_cancelled)\\n\\n consume_kwargs = {\\\"queue\\\": self._queue_name}\\n if PIKA_ONE:\\n consume_kwargs[\\\"on_message_callback\\\"] = self.on_message\\n else:\\n consume_kwargs[\\\"consumer_callback\\\"] = self.on_message\\n\\n self._consumer_tag = self._channel.basic_consume(**consume_kwargs)\",\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 __init__(self, consumer):\\n self._consumer = consumer\",\n \"def consume():\\n with conn.channel() as chan:\\n \\n def on_msg_recv(msg):\\n \\\"\\\"\\\" Called when message arrives from RabbitMQ\\n \\\"\\\"\\\"\\n print \\\"processor|%s::Received message: %s\\\" % (UID, msg.body)\\n chan.basic_ack(msg.delivery_tag)\\n log(msg.body)\\n process_msg(msg)\\n \\n \\n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\\n chan.exchange_declare(exchange = EXCHANGE,\\n type = EXCHANGE_TYPE)\\n queue = chan.queue_declare(QUEUE)\\n chan.queue_bind(exchange = EXCHANGE, \\n queue = QUEUE, \\n routing_key = ROUTING_KEY)\\n \\n # Declare that we are going to listen to given queue\\n chan.basic_consume(queue = QUEUE, \\n callback = on_msg_recv)\\n \\n # Main loop. Waiting for messages from RabbitMQ.\\n while True:\\n chan.wait()\",\n \"def produce(self, ctx):\\n pass\",\n \"def get_consumer(conf_settings, address=Config.INSIGHTS_KAFKA_ADDRESS): # pragma: no cover\\n conf = _get_consumer_config(address, conf_settings)\\n LOG.info(f\\\"Consumer config {conf}\\\")\\n return Consumer(conf, logger=LOG)\",\n \"def consume_messages(process_func: Callable[[str], None]):\\n consumer = get_consumer()\\n\\n for message in consumer:\\n log.debug(f'Received a message: {message}')\\n try:\\n process_func(message.value)\\n except Exception as e:\\n log.error(f'Failed to process a message: {message.value}')\\n log.exception(e)\",\n \"def getConsumer(self, topic):\\n\\n consumer = topic.get_balanced_consumer(zookeeper_connect=self.zookeeper_server, \\n consumer_group=self.consumer_group,\\n use_rdkafka=self.use_rdkafka,\\n auto_offset_reset=self.initial_offset)\\n self.consumer_started = True\\n\\n return consumer\",\n \"def consume(self):\\n LOGGER.debug('Consumer Initialized')\\n # self.connect()\\n channel = self.get_channel()\\n self._bind_things(channel)\\n\\n try:\\n LOGGER.info('Start consuming')\\n channel.start_consuming()\\n except ConnectionClosed:\\n LOGGER.exception('Pika connection closed detected. Will attempt to start consuming again')\\n self.consume()\\n except KeyboardInterrupt as e:\\n LOGGER.info('Keyboard interrupt, stop consuming')\\n self.shutdown()\\n raise e\\n except Exception as e:\\n LOGGER.exception(\\\"'%s\\\" % str(e))\\n self.shutdown()\\n if self.settings.CONSUMER['RAISE_EXCEPTION']:\\n LOGGER.info(\\\"CONSUMER RAISED EXCEPTION\\\")\\n raise e\",\n \"def get_consumers(self, Consumer, channel):\\n logger.debug(\\\"Get worker consumers\\\")\\n return [Consumer(\\n queues=self.queues,\\n callbacks=[self.process_task]\\n )]\",\n \"def bind_message_ctx(message: Message, **additional_ctx) -> Iterator[None]:\\n ctx = dict(\\n kafka_topic=message.topic(),\\n kafka_partition=message.partition(),\\n kafka_offset=message.offset(),\\n )\\n ctx.update(additional_ctx)\\n muselog.context.bind(**ctx)\\n try:\\n yield\\n finally:\\n # Clear only our context.\\n # This will clear the `ctx` keys even if their values have been overwritten\\n # by our yieldee.\\n muselog.context.unbind(*list(ctx.keys()))\",\n \"def __iter__(self):\\n while True:\\n m = self.recv(timeout=1.0)\\n if m is not None:\\n yield m\\n logger.debug(\\\"done iterating over bus messages\\\")\",\n \"def kafka_consumer(kafka_consumer_factory):\\n return kafka_consumer_factory()\",\n \"def create_consumers() -> List[Consumer]:\\n consumers = []\\n for consumer in range(CONSUMER_COUNT):\\n consumers.append(\\n Consumer(\\n {\\n AGE: FAKE.random_int(min=0, max=120),\\n STATE: FAKE.state(),\\n KIDS_COUNT: FAKE.random_int(min=0, max=12),\\n CARS_COUNT: FAKE.random_int(min=0, max=10),\\n INSURANCE_OPERATION: random.choice((RENT, BUY)),\\n INCOME: FAKE.random_int(min=0, max=99999999999),\\n PHONE_NUMBER: FAKE.phone_number(),\\n AVAILABLE: True,\\n }\\n )\\n )\\n return consumers\",\n \"def consume(self, handler):\\n bounded_handler = partial(handler, self)\\n self._consume_handler = handler\\n self.log.debug(\\\"Start consuming\\\")\\n self._channel.add_on_close_callback(\\n self.on_channel_closed\\n )\\n self._consumer_tag = self._channel.basic_consume(bounded_handler,\\n self.name)\\n self.log.debug(\\\"Consumer tag %s on CHANNEL%i\\\",\\n self._consumer_tag, self._channel.channel_number)\",\n \"def start_consuming(self):\\n\\n for queue in self._handlers.keys():\\n self._consumer_tags += self._channel.basic_consume(self.on_message,\\n queue=queue)\",\n \"def __next__(self):\\n return self.read_message()\",\n \"def server_message_iterator(self) -> Iterator[ServerMessage]:\\n while not self._is_closed():\\n with self._cv:\\n self._cv.wait_for(\\n lambda: self._status\\n in [Status.CLOSED, Status.SERVER_MESSAGE_AVAILABLE]\\n )\\n\\n self._raise_if_closed()\\n\\n server_message = self._server_message # Read\\n self._server_message = None # Reset\\n\\n # Transition before yielding as after the yield the execution of this\\n # function is paused and will resume when next is called again.\\n # Also release condition variable by exiting the context\\n self._transition(Status.AWAITING_CLIENT_MESSAGE)\\n\\n if server_message is None:\\n raise Exception(\\\"Server message can not be None\\\")\\n\\n yield server_message\",\n \"def message_listener(self, topic, timeout):\\n \\\"\\\"\\\"\\n demo_message = [\\n {'user_id': 'Lazy Man', 'timestamp': '2019-10-06T22:59:59.989Z', 'risk_level': 3}\\n ]\\n\\n for message in demo_message:\\n yield ERROR_CODE_ZERO, \\\"\\\", message\\n \\\"\\\"\\\"\\n\\n while True:\\n for error_code, error_message, message in self._consumer.subscribe(topic, timeout):\\n yield error_code, error_message, message\\n if error_code == 1:\\n break\",\n \"def kafka_producer(kafka_producer_factory):\\n yield kafka_producer_factory()\",\n \"def consume(self, timeout=None):\\n\\n def _raise_timeout(exc):\\n raise driver_common.Timeout(str(exc))\\n\\n timer = driver_common.DecayingTimer(duration=timeout)\\n timer.start()\\n\\n poll_timeout = (self.consumer_timeout if timeout is None\\n else min(timeout, self.consumer_timeout))\\n\\n while True:\\n if self._consume_loop_stopped:\\n return\\n try:\\n return self._poll_messages(poll_timeout)\\n except kafka.errors.ConsumerTimeout as exc:\\n poll_timeout = timer.check_return(\\n _raise_timeout, exc, maximum=self.consumer_timeout)\\n except Exception:\\n LOG.exception(_LE(\\\"Failed to consume messages\\\"))\\n return\",\n \"def consumeMsg():\\n\\tosuser = 'osdev'\\n\\tospass = 'osdev'\\n\\toshost = '10.32.29.94'\\n\\tosport = '5672'\\n\\tosvhost = '/openstack'\\n\\tneutronExchange = Exchange('quantum', type='topic', durable=False)\\n\\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\\n\\t\\t\\trouting_key='notifications.info')\\n\\twith Connection(\\\"\\\".join(['amqp://', osuser, ':', ospass, '@', \\n\\t\\toshost, ':',osport, '/', osvhost])) as conn:\\n\\t\\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\ttry: \\n\\t\\t\\t\\t\\tconn.drain_events()\\n\\t\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\t\\tlogging.exception('Draining events from AMQP stop')\\n\\t\\t\\t\\t\\tbreak\",\n \"def consume(self, block=True, timeout=0):\\n\\n # We need to repeat this step, because there may be messages\\n # that expired, and we expect this method to always return message.\\n while True:\\n # Retrieve last message ID\\n if block:\\n # Blocking query, wait until message is available.\\n message_id = self.pyrps.redis.blpop(self.pyrps._ns_queue(self.queue, self.consumer_id), timeout)\\n\\n # blpop returns tuple(key, value), we need only value.\\n message_id = message_id[1]\\n else:\\n # Non blocking query. Return if there is no message in queue.\\n message_id = self.pyrps.redis.lpop(self.pyrps._ns_queue(self.queue, self.consumer_id))\\n\\n # If there is no message in the queue, return None.\\n if message_id is None:\\n return None\\n\\n # Retrieve the message\\n message = self.pyrps.redis.get(self.pyrps._ns_message(self.queue, message_id))\\n \\n # If message still exists (no TTL has been reached), return it.\\n if message is not None:\\n return message\",\n \"def messageCollector():\\n\\ttempui = CatchallUI()\\n\\trealui = base.ui\\n\\ttry:\\n\\t\\tbase.ui = tempui\\n\\t\\tyield tempui\\n\\tfinally:\\n\\t\\tbase.ui = realui\",\n \"def get():\\n _processEvents()\\n return _event_generator()\",\n \"def _next_message(self):\\n msg = yield self._read_message()\\n message = self._slack_to_chat(msg)\\n\\n raise gen.Return(message)\",\n \"def consumer(func):\\n\\n from functools import wraps\\n\\n @wraps(func)\\n def wrapper(*args,**kw):\\n gen = func(*args, **kw)\\n gen.next()\\n return gen\\n return wrapper\",\n \"def __iter__(self):\\n self.enable_receiving()\\n with closing(select.epoll()) as notifier:\\n notifier.register(self, select.EPOLLIN)\\n while True:\\n events = eintr_retry_call(notifier.poll)\\n for event in events:\\n yield self.receive_device()\",\n \"def test_consumer_read_messages(self):\\n try:\\n test_consumer = TestConsumer(self.msg_queue, self.queue_lock, self.topic, self.properties_file)\\n test_consumer.start()\\n except Exception as e:\\n self.fail(f\\\"test_consumer_read_messages() failed with exception: {e}\\\")\\n\\n producer_msg_queue = queue.Queue()\\n producer_queue_lock = threading.Lock()\\n try:\\n test_producer = Producer(producer_msg_queue, producer_queue_lock, self.topic, self.producer_properties_file)\\n test_producer.start()\\n except Exception as e:\\n self.fail(f\\\"test_consumer_read_messages() failed with exception: {e}\\\")\\n\\n msgs = []\\n\\n for i in range(1, 4):\\n msg = f\\\"Message number {i}\\\"\\n\\n producer_queue_lock.acquire()\\n producer_msg_queue.put_nowait(msg)\\n producer_queue_lock.release()\\n\\n msgs.append(msg)\\n\\n # Sleep for few seconds seconds to allow the consumer thread to process all the messages.\\n time.sleep(20)\\n\\n self.assertEqual(test_consumer.dequeue_msgs(), msgs)\\n\\n test_producer.stop()\\n test_consumer.stop()\\n test_producer.join()\\n test_consumer.join()\",\n \"def kafka_payment_consumer_worker(mq: queue.Queue):\\n global app_config\\n\\n # Client\\n consumer = KafkaConsumer('payment',\\n bootstrap_servers=bootstrap_servers,\\n value_deserializer=lambda item: json.loads(item.decode('utf-8')))\\n\\n\\n\\n while not t_stop_event.is_set():\\n try:\\n # Message loop\\n for message in consumer:\\n logging.info(\\\"READING MESSAGE %s:%d:%d: key=%s value=%s\\\" % (\\n message.topic,\\n message.partition,\\n message.offset,\\n message.key,\\n message.value)\\n )\\n\\n # simple sanitizer\\n if (\\\"action\\\" not in message.value) \\\\\\n or (\\\"message\\\" not in message.value) \\\\\\n or (\\\"request\\\" not in message.value[\\\"message\\\"]):\\n logging.info(\\\"MALFORMED MESSAGE value=%s SKIPPING\\\" % (message.value,))\\n continue\\n\\n # Action switch\\n if str(message.value[\\\"action\\\"]).upper() == \\\"NOTIFY_DELIVERY_RESPONSE\\\":\\n logging.info(\\\"MESSAGE <NOTIFY_DELIVERY_RESPONSE> RECEIVE\\\") # Mocked\\n \\\"\\\"\\\"logging.info(\\\"PUT credit_deliverer MESSAGE in QUEUE\\\")\\n mq.put(\\n credit_deliverer()\\n )\\\"\\\"\\\"\\n except Exception as e:\\n logging.fatal(e, exc_info=True)\\n # Post routine\\n\\n consumer.close()\\n return\",\n \"def receive_message(self, context, message):\\r\\n pass\",\n \"def retrieve(self) -> Iterator[SQSMessage]:\\n while True:\\n try:\\n sqs = SQSClientFactory(boto3).from_env()\\n\\n res = sqs.receive_message(\\n QueueUrl=self.queue_url,\\n WaitTimeSeconds=3,\\n MaxNumberOfMessages=10,\\n )\\n\\n messages = res.get(\\\"Messages\\\", [])\\n if not messages:\\n LOGGER.info(\\\"queue was empty\\\")\\n\\n s3_events = [SQSMessage(msg) for msg in messages]\\n for sqs_message in s3_events:\\n yield sqs_message\\n\\n sqs.delete_message(\\n QueueUrl=self.queue_url,\\n ReceiptHandle=sqs_message.receipt_handle,\\n )\\n\\n except Exception as e:\\n LOGGER.error(traceback.format_exc())\\n time.sleep(2)\",\n \"def _dispatch_messages(self):\\n while True:\\n select_obj = (yield)\\n if select_obj == self._message_queue.selobj:\\n msg = self._message_queue.get_nowait()\\n if msg is not None:\\n msg_type = msg.get('type', None)\\n if msg_type is not None:\\n msg_handler = self._message_handlers.get(msg_type, None)\\n if msg_handler is not None:\\n msg_handler(msg['data'])\",\n \"def generator(self):\\n return self._generator\",\n \"async def get_context(self, message: discord.Message, *, cls: commands.Context = None) -> commands.Context:\\n return await super().get_context(message, cls=cls or WMBotContext)\",\n \"def _wrap_generator(ctx_factory, func):\\n @functools.wraps(func)\\n def generator_context(*args, **kwargs):\\n gen = func(*args, **kwargs)\\n\\n # Generators are suspended and unsuspended at `yield`, hence we\\n # make sure the grad mode is properly set every time the execution\\n # flow returns into the wrapped generator and restored when it\\n # returns through our `yield` to our caller (see PR #49017).\\n try:\\n # Issuing `None` to a generator fires it up\\n with ctx_factory():\\n response = gen.send(None)\\n\\n while True:\\n try:\\n # Forward the response to our caller and get its next request\\n request = yield response\\n\\n except GeneratorExit:\\n # Inform the still active generator about its imminent closure\\n with ctx_factory():\\n gen.close()\\n raise\\n\\n except BaseException:\\n # Propagate the exception thrown at us by the caller\\n with ctx_factory():\\n response = gen.throw(*sys.exc_info())\\n\\n else:\\n # Pass the last request to the generator and get its response\\n with ctx_factory():\\n response = gen.send(request)\\n\\n # We let the exceptions raised above by the generator's `.throw` or\\n # `.send` methods bubble up to our caller, except for StopIteration\\n except StopIteration as e:\\n # The generator informed us that it is done: take whatever its\\n # returned value (if any) was and indicate that we're done too\\n # by returning it (see docs for python's return-statement).\\n return e.value\\n\\n return generator_context\",\n \"def receive():\\n now = time.time()\\n end = now + MAX_DURATION\\n tmp = None\\n # Heroku doesn't notify when clients disconnect so we have to impose a\\n # maximum connection duration.\\n while now < end:\\n if not tmp:\\n tmp = AsyncResult()\\n BROADCAST_QUEUE.put(tmp)\\n try:\\n yield tmp.get(timeout=KEEP_ALIVE_DELAY)\\n tmp = None\\n except Timeout:\\n yield ''\\n now = time.time()\",\n \"def get_generator(self):\\n if(not self._constructed): raise EGCSUnconstructedStateError()\\n return self._generator\",\n \"async def consumer_loop(\\n uri: str,\\n topic: str,\\n ssl_context: SSLContext,\\n writers: List[Callable[[ConsumerPayload], Awaitable[int]]],\\n) -> int:\\n log.info(\\\"consumer: starting\\\")\\n if len(writers) < 1:\\n raise ValueError(\\\"there must be at least one writer passed to consumer_loop.\\\")\\n queue: asyncio.Queue[ConsumerPayload] = asyncio.Queue()\\n async with AIOKafkaConsumer(\\n topic,\\n bootstrap_servers=uri,\\n security_protocol=\\\"SSL\\\",\\n ssl_context=ssl_context,\\n group_id=DEFAULT_GROUP_ID,\\n ) as consumer:\\n await asyncio.gather(\\n decoder(queue, consumer), writer_wrapper(queue=queue, writers=writers)\\n )\\n log.info(\\\"consumer: exiting\\\")\\n return 0\",\n \"def start_consuming(self):\\n # LOGGER.info('Issuing consumer related RPC commands')\\n if self._init_ok_ctrl and self._init_ok_task:\\n self._channel_ctrl.add_on_cancel_callback(self.on_consumer_ctrl_cancelled)\\n self._channel_task.add_on_cancel_callback(self.on_consumer_task_cancelled)\\n self._consumer_tag_task = self._channel_task.basic_consume(\\n self.queue_task,\\n auto_ack=False,\\n on_message_callback=self.on_message\\n )\\n self._consumer_tag_ctrl = self._channel_ctrl.basic_consume(\\n self._topic_queue_name,\\n auto_ack=False,\\n on_message_callback=self.on_topic\\n )\\n self.was_consuming = True\\n self._consuming = True\",\n \"def start_consuming(self, channel, rx_queue_name):\\n if self.should_stop():\\n logger.info(\\\"ready to stop, pause to consume\\\")\\n return\\n logger.info('Issuing consumer related RPC commands')\\n self._consumer_tag = channel.basic_consume(\\n self.on_message, rx_queue_name, auto_ack = False)\\n channel.start_consuming()\",\n \"def subscribeConsumer(consumer):\",\n \"def _create_channel(self):\\n self.connection = pika.BlockingConnection(self.pikaparams)\\n self.channel = self.connection.channel()\\n try:\\n yield self.channel\\n finally:\\n self.channel.close()\\n self.connection.close()\",\n \"def consume(self):\\n if not self.__events:\\n raise StopIteration\\n\\n if self.__instance.id is None:\\n raise ImplementationError(\\n \\\"Can not consume event stream before aggregate has\\\"\\n \\\"been assigned an identifier.\\\")\\n\\n cid = str(uuid.UUID(bytes=os.urandom(16)))\\n while self.__events:\\n event = self.__events.pop(0)\\n event.aggregate_id = self.__instance.id\\n event.correlation_id = cid\\n event.timestamp = sq.timezone.now()\\n yield ImmutableDTO(event).as_dto()\",\n \"def consume_message(\\n engine, cert_folder=CERT_FOLDER, service_uri=SERVICE_URI, topic_name=TOPIC_NAME\\n):\\n\\n consumer = get_consumer(\\n cert_folder=cert_folder, service_uri=service_uri, topic_name=topic_name\\n )\\n\\n if consumer is None:\\n sys.exit(1)\\n\\n tries = 0\\n\\n for message in consumer:\\n data = None\\n\\n try:\\n # Read message and get the data (dict).\\n data = read_message(message=message)\\n\\n except Exception as error: # pylint: disable=broad-except\\n tries += 1\\n logger.error(\\\"Consumer could not read message due to %s.\\\", error)\\n\\n # Exit if number of tries exceeds the number of max read tries.\\n if tries > MAX_READ_TRIES:\\n sys.exit(1)\\n\\n finally:\\n if data is not None:\\n # Send the data to PostgreSQL server.\\n insert_data(engine=engine, data=data)\",\n \"def consume(self):\\n\\n self.consumer = self.getConsumer(self.client.topics[self.topic])\\n\\n # create splunk hec instance\\n splunk_hec = hec(self.splunk_server,\\n self.splunk_hec_port,\\n self.splunk_hec_channel,\\n self.splunk_hec_token,\\n self.splunk_sourcetype,\\n self.splunk_source,\\n self.use_https,\\n self.verify_ssl,\\n self.use_compression,\\n self.compresslevel)\\n while(True):\\n m = self.consumer.consume()\\n \\n # Append messages to list until we've hit self.batch_size\\n if(len(self.messages) <= self.batch_size):\\n self.messages.append(m.value)\\n\\n # Send messages to Splunk HEC\\n if(len(self.messages) == self.batch_size):\\n retry(self.sendToSplunk,\\n attempts=self.retry_attempts,\\n sleeptime=self.sleeptime,\\n max_sleeptime=self.max_sleeptime,\\n sleepscale=self.sleepscale,\\n jitter=self.jitter,\\n retry_exceptions=(Exception,),\\n args=(splunk_hec,))\",\n \"def allocation(self):\\n return self.mapping[self.consumer_name]\",\n \"def new_generator(self):\\n return self.generator_function(*self.args, **self.kwargs)\",\n \"def __next__(self):\\n waitable = queue.Queue(maxsize=1)\\n getter = functools.partial(waitable.get, timeout=self._timeout)\\n self._latest_item = self._async_wrapper_class(\\n func=getter,\\n concurrency_provider=self._provider\\n )\\n with self._lock:\\n try:\\n # get latest notification\\n data = self._notifications.get_nowait()\\n except queue.Empty:\\n # store the consumer\\n self._waitables.put(waitable)\\n LOG.debug('no data for new consumer')\\n else:\\n # if we have a notification, pass it to the consumer immediately\\n waitable.put_nowait(data)\\n LOG.debug('new consumer taking next data immediately')\\n return self._latest_item\",\n \"def consume(self, consume_mode):\\n resp = yield from self.command('consume {}'.format(consume_mode))\\n return True\",\n \"def get_generator(generator: Generator, **kwargs) -> Generator:\\n return generator(**kwargs)\",\n \"def gen_ciphertext(message: str) -> str:\\r\\n key = 1\\r\\n for i in range(26):\\r\\n ciphertext = cipher(key, message)\\r\\n yield f\\\"Key #{key}: {ciphertext}\\\"\\r\\n key += 1\",\n \"def get_context(self):\\n return self.context.generate()\",\n \"def yield_messages(self, *, mailbox=DEFAULT_MAILBOX):\\n with imaplib.IMAP4_SSL(\\n host=self.host, port=self.port,\\n ssl_context=ssl.create_default_context()) as ic:\\n logger.debug(f'Logging in as {self.user}')\\n restype, _ = ic.login(user=self.user, password=self.password)\\n check_restype(restype, f'failed to LOGIN as {self.user}')\\n\\n logger.debug(f'Selecting mailbox {mailbox}')\\n restype, _ = ic.select(mailbox=mailbox)\\n check_restype(restype, f'failed to SELECT mailbox {mailbox}')\\n\\n # First, query for *all* message UIDs in the selected mailbox.\\n # Interpret the response as a list of integers.\\n logger.debug('Getting UID list')\\n restype, [uids] = ic.uid('SEARCH', 'ALL')\\n check_restype(restype, 'failed to execute SEARCH')\\n uids = [*map(int, filter(None, uids.split(b' ')))]\\n\\n # In the event that the mailbox is empty, there will be no UIDs and\\n # nothing more to do.\\n if not uids:\\n logger.debug('No messages in this mailbox')\\n raise NoMessages\\n\\n # Fetch a range of message headers, from the smallest UID to the\\n # largest UID. Build a structure that links each UID to the `Date`\\n # header on the message it refers to.\\n message_set = f'{min(uids)}:{max(uids)}'\\n logger.debug(f'Fetching headers in UID range {message_set}')\\n restype, resdata = ic.uid('FETCH', message_set, '(BODY.PEEK[HEADER])')\\n check_restype(restype, f'failed to execute FETCH UIDs {message_set} (peek)')\\n uids_dated = self.date_uid_map(data=resdata)\\n\\n # Iterate over all UIDs in date order, oldest to newest.\\n for _, uid in sorted(uids_dated, key=itemgetter(0)):\\n # Fetch the full message content, wrap it in an IMAPMessage and\\n # yield it to the caller.\\n logger.debug(f'Fetching message UID {int(uid)}')\\n restype, resdata = ic.uid('FETCH', uid, '(RFC822)')\\n check_restype(restype, f'failed to execute FETCH UID {int(uid)} (full)')\\n\\n yield IMAPMessage(data=resdata, imap_connection=ic, uid=uid)\",\n \"def kafka_consumer(request: 'SubRequest') -> KafkaConsumer:\\n _, kafka_port = request.getfixturevalue(kafka_fixture_name)\\n\\n used_consumer_kwargs = consumer_kwargs.copy()\\n used_consumer_kwargs.setdefault('consumer_timeout_ms', DEFAULT_CONSUMER_TIMEOUT_MS)\\n used_consumer_kwargs.setdefault('bootstrap_servers', 'localhost:{}'.format(kafka_port))\\n\\n consumer = KafkaConsumer(\\n *kafka_topics,\\n **used_consumer_kwargs,\\n )\\n\\n if seek_to_beginning:\\n assert kafka_topics, (\\n 'In order to be able to seek to beginning, we must have some partitions assigned '\\n 'for which we need to subscribe to topics.')\\n\\n def partitions_assigned():\\n consumer.poll(timeout_ms=20)\\n return len(consumer.assignment()) > 0\\n\\n _wait_until(partitions_assigned)\\n\\n consumer.seek_to_beginning()\\n return consumer\",\n \"def stream(\\n consumer: Consumer,\\n count: Optional[int] = None,\\n poll_timeout: Optional[float] = DEFAULT_POLL_TIMEOUT,\\n timeout: Optional[float] = None,\\n) -> Iterator[Message]:\\n if count is not None and count <= 0:\\n raise ValueError(\\\"count must be a positive integer.\\\")\\n if poll_timeout is not None and poll_timeout <= 0:\\n raise ValueError(\\\"poll_timeout must be a positive float.\\\")\\n if timeout is not None and timeout <= 0:\\n raise ValueError(\\\"timeout must be a positive float.\\\")\\n\\n if count is None:\\n LOGGER.debug(\\\"Streaming messages....\\\")\\n else:\\n LOGGER.debug(\\\"Streaming up to %d messages....\\\", count)\\n\\n if timeout is not None:\\n timeout_delta = timedelta(milliseconds=int(timeout * MILLIS_IN_SECOND))\\n\\n stream_duration = timedelta()\\n num_messages = 0\\n while count is None or num_messages < count:\\n if musekafka.shutdown.is_shutting_down():\\n break\\n\\n if timeout is not None:\\n if stream_duration >= timeout_delta:\\n LOGGER.debug(\\\"Hit stream timeout (%.3f seconds).\\\", timeout)\\n break\\n poll_timeout = min(\\n poll_timeout or timeout, (timeout_delta - stream_duration).total_seconds()\\n )\\n\\n stream_start = datetime.utcnow()\\n try:\\n message = poll(consumer, timeout=poll_timeout)\\n except TimeoutError as e:\\n LOGGER.debug(str(e))\\n continue\\n finally:\\n stream_duration += datetime.utcnow() - stream_start\\n with bind_message_ctx(message):\\n yield message\\n num_messages += 1\\n LOGGER.debug(\\\"Completed streaming %d messages.\\\", num_messages)\",\n \"def get(resource_name: str,\\n id: pulumi.Input[str],\\n opts: Optional[pulumi.ResourceOptions] = None,\\n consumer_group_id: Optional[pulumi.Input[str]] = None,\\n consumer_group_name: Optional[pulumi.Input[str]] = None,\\n consumer_group_password: Optional[pulumi.Input[str]] = None,\\n consumer_group_user_name: Optional[pulumi.Input[str]] = None,\\n dts_instance_id: Optional[pulumi.Input[str]] = None) -> 'ConsumerChannel':\\n opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))\\n\\n __props__ = _ConsumerChannelState.__new__(_ConsumerChannelState)\\n\\n __props__.__dict__[\\\"consumer_group_id\\\"] = consumer_group_id\\n __props__.__dict__[\\\"consumer_group_name\\\"] = consumer_group_name\\n __props__.__dict__[\\\"consumer_group_password\\\"] = consumer_group_password\\n __props__.__dict__[\\\"consumer_group_user_name\\\"] = consumer_group_user_name\\n __props__.__dict__[\\\"dts_instance_id\\\"] = dts_instance_id\\n return ConsumerChannel(resource_name, opts=opts, __props__=__props__)\",\n \"def consumer(self, consumer):\\n self._consumer = consumer\",\n \"def message_thread(self):\\r\\n return resource.MessageThread(self)\",\n \"def consumer_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"consumer_id\\\")\",\n \"def get_generator(self, file_generator, batch_size=None, **kwargs):\\n raise NotImplementedError('')\",\n \"def keypress_get_generator(self):\\n raise NotImplementedError(\\\"ERROR: Unimplemented function.\\\")\",\n \"def consume_user_message(self, message):\\n pass\",\n \"def consumer_group(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"consumer_group\\\")\",\n \"def rosbag_msg_generator(bag_file, topics=None):\\n\\n import rosbag\\n from datetime import datetime\\n if not rospy.core.is_initialized():\\n rospy.init_node('rosbag_msg_generator', anonymous=True)\\n bag = rosbag.Bag(bag_file)\\n types_topics_tuple = bag.get_type_and_topic_info()\\n if topics is None:\\n topics = types_topics_tuple.topics.keys()\\n\\n pubs = {}\\n for topic, message, timestamp in bag.read_messages(topics=topics, raw=True):\\n msg_type = message[4]\\n data = message[1]\\n if topic in pubs:\\n pub = pubs[topic]\\n else:\\n pub = rospy.Publisher(topic, msg_type, latch=True, queue_size=30)\\n pubs[topic] = pub\\n msg = msg_type()\\n msg.deserialize(data)\\n pub.publish(msg)\\n timestamp = datetime.fromtimestamp(timestamp.to_sec())\\n yield topic, msg, timestamp\\n bag.close()\",\n \"def poll(consumer: Consumer, timeout: Optional[float] = DEFAULT_POLL_TIMEOUT) -> Message:\\n if timeout is not None and timeout <= 0:\\n raise ValueError(\\\"timeout must be a positive integer.\\\")\\n\\n if timeout is not None:\\n timeout_delta = timedelta(milliseconds=int(timeout * MILLIS_IN_SECOND))\\n\\n poll_duration = timedelta()\\n while True:\\n if timeout is not None:\\n if poll_duration >= timeout_delta:\\n raise TimeoutError(f\\\"Hit poll timeout of {timeout} seconds.\\\")\\n poll_timeout = (timeout_delta - poll_duration).total_seconds()\\n\\n poll_start = datetime.utcnow()\\n message = consumer.poll() if timeout is None else consumer.poll(timeout=poll_timeout)\\n poll_duration += datetime.utcnow() - poll_start\\n if message is None:\\n continue\\n\\n with bind_message_ctx(message):\\n LOGGER.debug(\\n \\\"Received message -- topic=%s partition=%s offset=%s\\\",\\n message.topic(),\\n message.partition(),\\n message.offset(),\\n )\\n\\n if message.error():\\n # If we cannot read the raw message correctly, we give up and\\n # raise the error to the caller.\\n raise ConsumerException(f\\\"Got bad message from Kafka: {message.error()}\\\")\\n\\n return message\",\n \"def consumer_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"consumer_id\\\")\",\n \"def consume_messages(self):\\n\\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\\n\\n while method_frame:\\n\\n LOGGER.info(\\\"Message received\\\")\\n\\n self.channel.basic_ack(method_frame.delivery_tag)\\n payload = json.loads(body)\\n if not isinstance(payload, dict):\\n return\\n\\n # Process the message\\n if 'control' in payload:\\n LOGGER.info(\\\"A control signal received!\\\")\\n # self.set_control(payload['control'])\\n print(payload['control'])\\n\\n # Continue getting messages\\n method_frame, properties, body = self.channel.basic_get(self.queue_name, no_ack=False)\\n\\n # TODO\\n # return control_signal\",\n \"def generate_message(self, mtu):\\r\\n raise GeneratorExit(\\\"No more message to send\\\")\",\n \"def consumer(state: SharedState):\",\n \"async def produce_consume(topic_name):\\n await asyncio.create_task(produce(topic_name))\",\n \"def generate(self, *args: t.Any, **kwargs: t.Any) -> t.Iterator[str]:\\n if self.environment.is_async:\\n import asyncio\\n\\n async def to_list() -> t.List[str]:\\n return [x async for x in self.generate_async(*args, **kwargs)]\\n\\n yield from asyncio.run(to_list())\\n return\\n\\n ctx = self.new_context(dict(*args, **kwargs))\\n\\n try:\\n yield from self.root_render_func(ctx) # type: ignore\\n except Exception:\\n yield self.environment.handle_exception()\",\n \"def kafka_producer_factory(kafka_broker, request):\\n _producer = [None]\\n\\n def factory(**kafka_producer_params):\\n params = {} if kafka_producer_params is None else kafka_producer_params.copy()\\n params.setdefault('client_id', 'producer_%s' % (request.node.name,))\\n _producer[0] = next(kafka_broker.get_producers(cnt=1, **params))\\n return _producer[0]\\n\\n yield factory\\n\\n if _producer[0]:\\n _producer[0].close()\",\n \"def __iter__(self):\\n return self.new_generator()\",\n \"def stream(self):\\n\\n iterator = iter(self._stream)\\n while self._state < Computation.STATE_COMPLETED:\\n try:\\n message = next(iterator)\\n except StopIteration:\\n if self._state < Computation.STATE_COMPLETED:\\n self._stream = self._execute()\\n iterator = iter(self._stream)\\n continue\\n break\\n\\n if isinstance(message, messages.StreamStartMessage):\\n self._state = Computation.STATE_STREAM_STARTED\\n continue\\n\\n if isinstance(message, messages.JobStartMessage):\\n self._state = Computation.STATE_COMPUTATION_STARTED\\n self._id = message.handle\\n yield message\\n continue\\n\\n if isinstance(message, messages.JobProgressMessage):\\n yield message\\n continue\\n\\n if isinstance(message, messages.ChannelAbortMessage):\\n self._state = Computation.STATE_ABORTED\\n raise errors.ComputationAborted(message.abort_info)\\n\\n if isinstance(message, messages.EndOfChannelMessage):\\n self._state = Computation.STATE_COMPLETED\\n continue\\n\\n # Intercept metadata messages to accumulate received metadata...\\n if isinstance(message, messages.MetadataMessage):\\n self._metadata[message.tsid] = message.properties\\n yield message\\n continue\\n\\n # ...as well as expired-tsid messages to clean it up.\\n if isinstance(message, messages.ExpiredTsIdMessage):\\n if message.tsid in self._metadata:\\n del self._metadata[message.tsid]\\n yield message\\n continue\\n\\n if isinstance(message, messages.InfoMessage):\\n self._process_info_message(message.message)\\n self._batch_count_detected = True\\n yield message\\n if self._current_batch_message:\\n yield self._get_batch_to_yield()\\n continue\\n\\n # Accumulate data messages and release them when we have received\\n # all batches for the same logical timestamp.\\n if isinstance(message, messages.DataMessage):\\n self._state = Computation.STATE_DATA_RECEIVED\\n\\n if not self._batch_count_detected:\\n self._expected_batches += 1\\n\\n if not self._current_batch_message:\\n self._current_batch_message = message\\n self._current_batch_count = 1\\n elif (message.logical_timestamp_ms ==\\n self._current_batch_message.logical_timestamp_ms):\\n self._current_batch_message.add_data(message.data)\\n self._current_batch_count += 1\\n else:\\n self._batch_count_detected = True\\n\\n if (self._batch_count_detected and\\n self._current_batch_count == self._expected_batches):\\n yield self._get_batch_to_yield()\\n continue\\n\\n if isinstance(message, messages.EventMessage):\\n yield message\\n continue\\n\\n if isinstance(message, messages.ErrorMessage):\\n raise errors.ComputationFailed(message.errors)\\n\\n # Yield last batch, even if potentially incomplete.\\n if self._current_batch_message:\\n yield self._get_batch_to_yield()\",\n \"def blocking_context():\\n block()\\n try:\\n yield\\n finally:\\n # an error could happen somewhere else when this ctx manager is on `yield`\\n unblock()\",\n \"def loan_message_creator_factory():\\n return partial(\\n message_factory, current_app.config[\\\"ILS_CIRCULATION_MAIL_MSG_CREATOR\\\"]\\n )\",\n \"def kafka_client(kafka_broker, request):\\n (client,) = kafka_broker.get_clients(cnt=1, client_id='%s_client' % (request.node.name,))\\n yield client\\n client.close()\",\n \"def get_manager_with_least_processed_events_generator(self):\\n try:\\n managers = self.db_handler.get_manager_with_least_processed_events()\\n\\n for manager in managers:\\n self.logger.write_to_log(f'returned manager for notification', 'model')\\n yield (len(managers) - managers.index(manager)) - 1, manager[0]\\n except Exception as err:\\n method_name = sys._getframe().f_code.co_name\\n\\n self.logger.write_to_log('exception', 'model')\\n self.logger.write_to_err_log(f'exception in method {method_name} - {err}', 'model')\",\n \"def __call__(self, gen) -> Generator:\\n self.stream = gen\\n self.prepare()\\n return self.stream\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6520486","0.64304805","0.6348474","0.6260189","0.6066062","0.59972835","0.5906607","0.5790026","0.57867485","0.57645184","0.5661963","0.5636426","0.5610837","0.5610837","0.56106585","0.55232435","0.5515625","0.54985094","0.5481432","0.5471095","0.5469184","0.54481894","0.53808063","0.5365092","0.5357328","0.532284","0.5301427","0.5300059","0.5272083","0.5263752","0.52421683","0.52376616","0.522911","0.5209037","0.5207072","0.519513","0.51862144","0.5182557","0.5181767","0.5178642","0.5174494","0.5172042","0.5165281","0.5158801","0.5158498","0.51476777","0.51286745","0.512146","0.5118437","0.5106403","0.51040375","0.51034534","0.5092477","0.5068645","0.5026228","0.50066394","0.49642098","0.49609956","0.49561268","0.4935512","0.49207395","0.48927292","0.48902494","0.4889367","0.48826864","0.48630026","0.48597717","0.48593137","0.4858915","0.48457113","0.4831765","0.48195317","0.48145998","0.4803994","0.47991255","0.4795187","0.4785381","0.47754174","0.47711474","0.47646055","0.47583285","0.47447944","0.4738016","0.47353426","0.47293693","0.47175953","0.47128946","0.47032326","0.4700144","0.46986586","0.46908247","0.46801788","0.46795118","0.46748012","0.46652865","0.46518517","0.4650994","0.46461898","0.46444127","0.46372974"],"string":"[\n \"0.6520486\",\n \"0.64304805\",\n \"0.6348474\",\n \"0.6260189\",\n \"0.6066062\",\n \"0.59972835\",\n \"0.5906607\",\n \"0.5790026\",\n \"0.57867485\",\n \"0.57645184\",\n \"0.5661963\",\n \"0.5636426\",\n \"0.5610837\",\n \"0.5610837\",\n \"0.56106585\",\n \"0.55232435\",\n \"0.5515625\",\n \"0.54985094\",\n \"0.5481432\",\n \"0.5471095\",\n \"0.5469184\",\n \"0.54481894\",\n \"0.53808063\",\n \"0.5365092\",\n \"0.5357328\",\n \"0.532284\",\n \"0.5301427\",\n \"0.5300059\",\n \"0.5272083\",\n \"0.5263752\",\n \"0.52421683\",\n \"0.52376616\",\n \"0.522911\",\n \"0.5209037\",\n \"0.5207072\",\n \"0.519513\",\n \"0.51862144\",\n \"0.5182557\",\n \"0.5181767\",\n \"0.5178642\",\n \"0.5174494\",\n \"0.5172042\",\n \"0.5165281\",\n \"0.5158801\",\n \"0.5158498\",\n \"0.51476777\",\n \"0.51286745\",\n \"0.512146\",\n \"0.5118437\",\n \"0.5106403\",\n \"0.51040375\",\n \"0.51034534\",\n \"0.5092477\",\n \"0.5068645\",\n \"0.5026228\",\n \"0.50066394\",\n \"0.49642098\",\n \"0.49609956\",\n \"0.49561268\",\n \"0.4935512\",\n \"0.49207395\",\n \"0.48927292\",\n \"0.48902494\",\n \"0.4889367\",\n \"0.48826864\",\n \"0.48630026\",\n \"0.48597717\",\n \"0.48593137\",\n \"0.4858915\",\n \"0.48457113\",\n \"0.4831765\",\n \"0.48195317\",\n \"0.48145998\",\n \"0.4803994\",\n \"0.47991255\",\n \"0.4795187\",\n \"0.4785381\",\n \"0.47754174\",\n \"0.47711474\",\n \"0.47646055\",\n \"0.47583285\",\n \"0.47447944\",\n \"0.4738016\",\n \"0.47353426\",\n \"0.47293693\",\n \"0.47175953\",\n \"0.47128946\",\n \"0.47032326\",\n \"0.4700144\",\n \"0.46986586\",\n \"0.46908247\",\n \"0.46801788\",\n \"0.46795118\",\n \"0.46748012\",\n \"0.46652865\",\n \"0.46518517\",\n \"0.4650994\",\n \"0.46461898\",\n \"0.46444127\",\n \"0.46372974\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60765916"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":93083,"cells":{"query":{"kind":"string","value":"Declare the queue on the RabbitMQ channel passed into the constructor, returning the current message count for the queue and its consumer count as a tuple."},"document":{"kind":"string","value":"def declare(self, passive=False):\n response = self._rpc(self._declare(passive))\n return response.message_count, response.consumer_count"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_get_queue_msg_count1(self):\n self.queue.direct_declare(TEST_QUEUE)\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\n\n msg_count = self.queue.get_queue_msg_count(TEST_QUEUE)\n assert isinstance(msg_count, int)","def get_pending_messages():\n global logger\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n msg = \"exception 1 in connecting\"\n logger.debug(msg)\n # print(msg)\n time.sleep(3)\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n logger.debug(msg+\" for the second time\")\n return -1\n channel = connection.channel()\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\n num = queue.method.message_count\n connection.close()\n return num","def get_number_message_on_queue(client, queue):\n messages = list()\n channel = client.channel()\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\n\n try:\n for method_frame, properties, body in channel.consume(\n queue=queue,\n exclusive=True,\n inactivity_timeout=30):\n messages.append({'method_frame': method_frame, 'properties': properties, 'body': body})\n # Acknowledge the message\n channel.basic_ack(method_frame.delivery_tag)\n except TypeError:\n print(\"Fin de la lecture des messages.\")\n\n # Cancel the consumer and return any pending messages\n requeued_messages = channel.cancel()\n logger.info('Requeued %i messages' % requeued_messages)\n\n # Close the channel and the connection\n channel.close()\n return len(messages)","def getQueueCount(self, force=False):\n if self.queuecount == -1 or force:\n self.queuecount = self.db.queuecount()\n\n return self.queuecount","def queue_message_count(self, queue_name):\n queue_list = self.__session.getObjects(_class=\"queue\", _name=queue_name)\n if len(queue_list):\n return queue_list[0].msgDepth","def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")","def setup_queue(self, channel, queue_name):\n logger.info('Declaring queue %s', queue_name)\n channel.queue_declare(queue = queue_name, \n durable = True,\n auto_delete = False)","def queue_count(self):\n with self.mutex:\n return len(self.queues)","def record_queue_size():\n statsd.gauge('rabbitmq.size', rabbitmq_queue_size())","def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)","def new_messages_number(self, tag):\n return len(self._message_queue.setdefault(tag,[]))","def get_rabbit_queue():\n\n return \"metrics_queue\"","def queue_size(self):\n # pylint: disable=protected-access\n if self._handler._received_messages:\n return self._handler._received_messages.qsize()\n return 0","def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)","def get_queue_size(queue):\n with current_celery_app.pool.acquire(block=True) as connection:\n bound_queue = queue.bind(connection)\n _, size, _ = bound_queue.queue_declare(passive=True)\n return size","async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self","async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})","def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)","def get_message_queue_size(self):\n with self.lock:\n return len(self.message_queue)","def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')","def _ns_queue(self, queue, consumer_id):\n return self._ns(queue, consumer_id, \"messages\")","def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )","def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)","def ceilometer_amq(self):\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='ceilometer', type='topic')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='metering')\n\n #channel.queue_bind(exchange='ceilometer.agent.notification_fanout', queue=queue_name)\n #channel.queue_bind(exchange='ceilometer.collector_fanout', queue=queue_name)\n channel.basic_consume(self.ceilometer_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()","def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)","def get_number_of_messages(queue_name):\n queue = sqs.get_queue_by_name(QueueName=queue_name)\n return queue.attributes.get('ApproximateNumberOfMessages')","def queue_size(self) -> int:\n return self._queue.qsize()","def _numQueuedTotal(self):\n queueSize = len(self.__queue) + len(self.__clientQueue)\n return queueSize","def declare(self):\n self.channel.queue_declare(queue='files_to_database')","def celery_queue_lengths(request):\n queue_len = collect_queue_metrics()\n LOG.info(f\"Celery queue backlog info: {queue_len}\")\n return Response(queue_len)","def on_open_channel(new_channel):\n # assign new channel to the global channel variable\n global channel\n channel = new_channel\n\n # channel is assigned and declare a queue named scripbox.\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\n # Pass a callback on_queue_declared which fires when a queue declaration\n # is successful\n channel.queue_declare(queue='scripbox', durable=True,\n auto_delete=False, callback=on_queue_declared)","def ctrlqueue_num_actions(self) -> int:\n try:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(2), ctypes.c_int32(0))\n except Exception as e:\n Base.warn_msg(\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\", e)","def _queue_len(queue_path: str) -> int:\n if not os.path.exists(queue_path):\n return 0\n return len([path for path in os.listdir(queue_path)])","def _getqueuesize(self):\n return self._queuesize","def connect(self):\n # @TODO: implement SSL\n connection = pika.BlockingConnection(self.params)\n channel = connection.channel()\n channel.queue_declare(queue=self.queue_name, durable=True)\n\n self.connection = connection\n self.channel = channel","def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)","def GetTotalQueueCount(handler, query):\n # pylint: disable=unused-argument\n\n json_config = {}\n json_config['count'] = 0\n\n with active_tivos_lock:\n for tivoIP in active_tivos:\n with active_tivos[tivoIP]['lock']:\n json_config['count'] += len(active_tivos[tivoIP]['queue'])\n\n handler.send_json(json.dumps(json_config))","def ctrlqueue_queue_size(self) -> int:\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(10), ctypes.c_int32(0))","def test_the_queue_size(the_queue):\n the_queue.enqueue(1)\n the_queue.enqueue(2)\n the_queue.enqueue(3)\n assert the_queue.size() == 3","def api_get_queue_len():\n try:\n ret = AppStatus.check_manager_status(brief=False)\n if ret is not None:\n return jsonify({\"total_queue_len\": ret.get(\"total_queue_len\", 0)})\n except Exception as e:\n logger.error(\"Traceback:\\n%s\", traceback.format_exc())\n abort(500, \"failed to send message or invalid manager response\")","def test_size_increments_with_enqueue():\n queue = Queue()\n queue.enqueue('val')\n assert queue.size() == 1","def test_list_queues(self, rabbitmq):\n assert rabbitmq.list_queues() == []\n self.declare_queue(rabbitmq, \"q1\")\n self.declare_queue(rabbitmq, \"q2\")\n assert sorted(rabbitmq.list_queues()) == [('q1', '0'), ('q2', '0')]","def queue_size(self):\n return self._queue_size","def count_remaining(self):\n\t\treturn self._queue.qsize()","def count_remaining(self):\n\t\treturn self._queue.qsize()","def queue_size(self) -> ConfigNodePropertyInteger:\n return self._queue_size","def linkRabbit(self):\n\n print(\"Listening for RabbitMQ messages\")\n\n # RabbitMQ setup\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host='localhost'))\n channel = connection.channel()\n\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\n\n result = channel.queue_declare(queue='', exclusive=True)\n queue_name = result.method.queue\n\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\n channel.start_consuming()","def _listen_queue(self, queue, callback):\n # Listen buy/sell orders from external system\n self._logger.info(f\"Declaring rabbit queue {queue}\")\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\n self._logger.info(f\"Declaring callback to rabbit queue: {queue}, callback: {callback}\")\n self._consumer_rabbit_channel.basic_consume(queue, callback,\n consumer_tag=queue)","def qsize(self):\n if not self.connected:\n raise QueueNotConnectedError(\"Queue is not Connected\")\n\n try:\n size = self.__db.llen(self._key)\n except redis.ConnectionError as e:\n raise redis.ConnectionError(repr(e))\n return size","def test_size_of_new_queue():\n queue = Queue()\n assert queue.size() == 0","def num_pending(status=\"pending\", username=\"garrett.wilson\"):\n cmd = [\n \"squeue\",\n \"-u\", username,\n \"-t\", status,\n \"-h\"\n ]\n\n output = subprocess.check_output(cmd)\n output = output.decode(\"utf-8\").strip()\n\n if output == \"\":\n return 0\n\n return len(output.split(\"\\n\"))","async def consume_items_from_rabbitmq(queue):\n ctr = 0\n start = time.time()\n while True:\n await asyncio.sleep(0.001)\n for method_frame, properties, body in channel.consume(queue_name, inactivity_timeout=1):\n if method_frame:\n # print(body)\n while queue.full():\n await asyncio.sleep(0.001)\n # await queue.put(body)\n queue.put_nowait(body)\n # Acknowledge the message\n channel.basic_ack(method_frame.delivery_tag)\n ctr += 1\n if not ctr % 1000:\n end = time.time() - start\n print(f'elapsed time: {end:.3f}\\tmessages received: {ctr}')\n else:\n # empty remaining items from queue\n while queue.qsize():\n await asyncio.sleep(0.001)\n end = time.time() - start\n print(f'elapsed time: {end:.3f}\\tmessages received: {ctr}')\n break\n await asyncio.sleep(0.001)\n\n requeued_messages = channel.cancel()","def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)","def create(self, queue, metadata, tenant=None, limit=10):\n msg_ctrl = self.driver.message_controller\n\n # We don't need the qid here but\n # we need to verify it exists.\n qid = self._get_queue_id(queue, tenant)\n\n ttl = int(metadata.get(\"ttl\", 60))\n oid = objectid.ObjectId()\n\n # Lets remove the timezone,\n # we want it to be plain utc\n expires = utils.oid_ts(oid) + ttl\n\n meta = {\n \"id\": oid,\n \"t\": ttl,\n \"e\": expires,\n }\n\n # Get a list of active, not claimed nor expired\n # messages that could be claimed.\n msgs = msg_ctrl.active(qid, fields={\"_id\": 1})\n msgs = msgs.limit(limit).sort(\"_id\")\n\n messages = iter([])\n\n # Lets respect the limit\n # during the count\n if msgs.count(True) == 0:\n return (str(oid), messages)\n\n ids = [msg[\"_id\"] for msg in msgs]\n now = timeutils.utcnow_ts()\n\n # Set claim field for messages in ids\n updated = msg_ctrl._col.update({\"_id\": {\"$in\": ids},\n \"$or\": [\n {\"c.id\": None},\n {\n \"c.id\": {\"$ne\": None},\n \"c.e\": {\"$lte\": now}\n }\n ]},\n {\"$set\": {\"c\": meta}}, upsert=False,\n multi=True)[\"n\"]\n\n # NOTE(flaper87): Dirty hack!\n # This sets the expiration time to\n # `expires` on messages that would\n # expire before claim.\n msg_ctrl._col.update({\"q\": queue,\n \"e\": {\"$lte\": expires},\n \"c.id\": oid},\n {\"$set\": {\"e\": expires}},\n upsert=False, multi=True)\n\n if updated != 0:\n claim, messages = self.get(queue, oid, tenant=tenant)\n return (str(oid), messages)","def qsize(self) -> int:\n return len(self._queue)","def get_queue_number(self):\n outstring = self.dut.send_expect(\"stop\", \"testpmd> \")\n time.sleep(2)\n result_scanner = r\"Forward Stats for RX Port= %s/Queue=\\s?([0-9]+)\" % self.dut_ports[0]\n scanner = re.compile(result_scanner, re.DOTALL)\n m = scanner.search(outstring)\n queue_id = m.group(1)\n print \"queue is %s\" % queue_id\n self.dut.send_expect(\"start\", \"testpmd> \")\n return queue_id","def get_amount_queued(self):\n return self._num_queued","def get_queue(self):\r\n return _channeldata[self.chan].queue","def keystone_amq(self):\n\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\n credentials=pika.PlainCredentials(\n username=self.rabbit_user,\n password=self.rabbit_pass)))\n channel = connection.channel()\n result = channel.queue_declare(exclusive=True)\n queue_name = result.method.queue\n channel.exchange_declare(exchange='keystone', type='topic')\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\n\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\n channel.start_consuming()","def get_message_count(self):\n return self.buffer.count()","def queue_size(self):\n return self.sql_queue.qsize()","def message_count(self):\n pass","def queue_size(self):\n return len(self.groups)","def qsize(self):\r\n return len(self._queue)","def qsize(self) -> int:\n return self._queue.qsize()","def queue(self, name):\n # First create a queue\n queue = self.inbound_channel.declare_queue(name)\n\n # Create the registry for the queue\n registry = Registry(self, queue)\n\n # Prepare consuming queue with registry\n self.inbound_channel.consume(queue=queue, callback=registry)\n\n # Then, return the Registry object.\n return registry","def subscribe(self):\n with self._rabbit_connection.connection.channel() as channel:\n self._queue = rabbitpy.Queue(\n channel=channel,\n name=self._subscriber_name + \"_queue\",\n durable=True,\n message_ttl=5 * 24 * 60 * 60 * 1000 # 5 days\n )\n self._queue.declare()\n self._queue.bind(self._exchange, self._routing_key)\n\n self._consume()","def _queue_create(self, **kwargs):\n name = self.generate_random_name()\n return self.clients(\"zaqar\").queue(name, **kwargs)","def declare_queue(self, c, queue_name):\n return self._management_req(\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\n {\"auto_delete\": False, \"durable\": False, \"arguments\": {}})","def message_count(self):\n return self._message_count","def size(self):\n return len(self.__queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def size(self):\n return len(self.queue)","def ReceiveIncomingDelivery(self):\r\n quantityReceived = self.incomingDeliveriesQueue.PopEnvelope()\r\n \r\n if quantityReceived > 0:\r\n self.currentStock += quantityReceived\r\n \r\n return quantityReceived","def test_create_qos_queue(self):\r\n resource = 'qos_queue'\r\n cmd = qos.CreateQoSQueue(\r\n test_cli20.MyApp(sys.stdout), None)\r\n myid = 'myid'\r\n name = 'my_queue'\r\n default = False\r\n args = ['--default', default, name]\r\n position_names = ['name', 'default']\r\n position_values = [name, default]\r\n self._test_create_resource(resource, cmd, name, myid, args,\r\n position_names, position_values)","def connect(self):\n self._connect()\n if self.conn is not None:\n try:\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\n except:\n self.closeConn()","def create_queue(self, queue_name='', exclusive=True, queue_size=10,\n message_ttl=60000, overflow_behaviour='drop-head',\n expires=600000):\n args = {\n 'x-max-length': queue_size,\n 'x-overflow': overflow_behaviour,\n 'x-message-ttl': message_ttl,\n 'x-expires': expires\n }\n\n result = self._channel.queue_declare(\n exclusive=exclusive,\n queue=queue_name,\n durable=False,\n auto_delete=True,\n arguments=args)\n queue_name = result.method.queue\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\n queue_name, queue_size, message_ttl))\n return queue_name","def test_size(self):\n queue = Queue()\n self.assertEqual(queue.size(), 0)\n queue.enqueue(1)\n self.assertEqual(queue.size(), 1)","def __init__(self, address, queue_name):\n self.connection = pika.BlockingConnection(\n pika.ConnectionParameters(address))\n self.queue_name = queue_name\n\n # create the channel\n self.channel = self.connection.channel()\n\n # declare the queue\n self.channel.queue_declare(queue=queue_name, durable=True)\n\n logging.info(\"Message Broker connected to {0}\".format(address))","def consumer_count(self, obj):\n return obj.get_or_set_consumer_count()","def process_queue_message(message):\n resource_storage = ResourceStorageFactory.create()\n resources = _parse_resources(message)\n\n resource_storage.write_entries(resources)\n return len(resources)","def on_secondary_channel_open(self, ch):\n # Our usable channel has been passed to us, assign it for future use\n self.amqp_secondary_channel = ch\n \n # Declare 'IN' queue - for receiving confirmations\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\n exclusive=False, auto_delete=False,\n callback=self.on_confirm_queue_declared)","def create_qos_queue(self, body=None):\r\n return self.post(self.qos_queues_path, body=body)","def create_message_queue_table(self):\n app_process = sqlite3.connect('app_process::memory:', check_same_thread=False)\n app_process_cursor = app_process.cursor()\n app_process_cursor.execute(\"SELECT count(name) FROM sqlite_master WHERE type='table' AND name='message_queue'\")\n if app_process_cursor.fetchone()[0]==1:\n return\n app_process_cursor.execute(\"\"\"\n CREATE TABLE message_queue (\n tstamp real,\n request text,\n dest_ip text,\n dest_port integer,\n next_tstamp real\n )\n \"\"\")\n app_process.commit()\n app_process.close()","def size(self):\r\n return len(self.queue)","def size(self):\r\n return len(self.queue)","def read_queue():\n with open(\"config.json\") as f:\n config = json.load(f)\n \n cpars = pika.ConnectionParameters(host=config[\"cage_daq\"])\n connection = pika.BlockingConnection(cpars)\n channel = connection.channel()\n\n channel.exchange_declare(exchange=config[\"exchange\"], exchange_type='topic')\n \n channel.queue_declare(queue=config[\"queue\"], exclusive=True)\n \n channel.queue_bind(queue=config[\"queue\"], exchange=config[\"exchange\"], \n routing_key='sensor_value.#')\n \n channel.basic_consume(queue=config[\"queue\"], on_message_callback=callback, \n auto_ack=True)\n\n print(' [*] Waiting for messages. To exit press CTRL+C')\n channel.start_consuming()","def connect(self):\n try:\n self.conn = amqp.Connection(insist=True, **self.config)\n self.chan = self.conn.channel()\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\n self.chan.exchange_declare(exchange=self.EXCH, type=\"topic\", durable=True, auto_delete=False,)\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\"ctag\")\n except:\n self.closeConn()","def size(self):\n return len(self._queue_items)","def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)","def subscribe(self, queue, action):\n self.channel.queue_declare(queue=queue)\n self.channel.basic_consume(queue=queue,\n on_message_callback=action,\n auto_ack=True)\n self.channel.start_consuming()","def get_queue_items(self, queue_name):\n proc = start_proc([\"/usr/bin/sudo\", \"rabbitmqctl\", \"list_queues\"],\n shell=False)\n for line in iter(proc.stdout.readline, \"\"):\n print(\"LIST QUEUES:\" + line)\n m = re.search(r\"%s\\s+([0-9]+)\" % queue_name, line)\n if m:\n return int(m.group(1))\n return None","def size():\r\n qry = ImportQueue.query.filter(or_(\r\n ImportQueue.status != COMPLETE,\r\n ImportQueue.status != ERROR))\r\n return qry.count()","def number_of_jobs_in_queue():\n\n # Initialize #\n user_name = get_username()\n\n process = subprocess.check_output([\"squeue\", \"-u\", user_name])\n\n return len([line for line in process.split(\"\\n\") if user_name in line])","def count(self):\t\n\t\ttry:\n\t\t\treturn True, self.queue.qsize()\n\t\texcept Exception, e:\n\t\t\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\n\t\t\treturn False, None","def create_queue(self):\n queue_name = self.generate_name()\n try:\n queue = self.sqs.create_queue(QueueName=queue_name)\n except Exception as e:\n raise RuntimeError('SQS could create queue: %s' % e)\n self.queue_name, self.queue = queue_name, queue","def consumer_details_for_queue(self):\n response_json = self.rabbit_request(\"queues/%2F/\" + self._queue)\n return response_json[\"consumer_details\"]","def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)\n \n \n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\n chan.exchange_declare(exchange = EXCHANGE,\n type = EXCHANGE_TYPE)\n queue = chan.queue_declare(QUEUE)\n chan.queue_bind(exchange = EXCHANGE, \n queue = QUEUE, \n routing_key = ROUTING_KEY)\n \n # Declare that we are going to listen to given queue\n chan.basic_consume(queue = QUEUE, \n callback = on_msg_recv)\n \n # Main loop. Waiting for messages from RabbitMQ.\n while True:\n chan.wait()"],"string":"[\n \"def test_get_queue_msg_count1(self):\\n self.queue.direct_declare(TEST_QUEUE)\\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\\n\\n msg_count = self.queue.get_queue_msg_count(TEST_QUEUE)\\n assert isinstance(msg_count, int)\",\n \"def get_pending_messages():\\n global logger\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n msg = \\\"exception 1 in connecting\\\"\\n logger.debug(msg)\\n # print(msg)\\n time.sleep(3)\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n logger.debug(msg+\\\" for the second time\\\")\\n return -1\\n channel = connection.channel()\\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\\n num = queue.method.message_count\\n connection.close()\\n return num\",\n \"def get_number_message_on_queue(client, queue):\\n messages = list()\\n channel = client.channel()\\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\\n\\n try:\\n for method_frame, properties, body in channel.consume(\\n queue=queue,\\n exclusive=True,\\n inactivity_timeout=30):\\n messages.append({'method_frame': method_frame, 'properties': properties, 'body': body})\\n # Acknowledge the message\\n channel.basic_ack(method_frame.delivery_tag)\\n except TypeError:\\n print(\\\"Fin de la lecture des messages.\\\")\\n\\n # Cancel the consumer and return any pending messages\\n requeued_messages = channel.cancel()\\n logger.info('Requeued %i messages' % requeued_messages)\\n\\n # Close the channel and the connection\\n channel.close()\\n return len(messages)\",\n \"def getQueueCount(self, force=False):\\n if self.queuecount == -1 or force:\\n self.queuecount = self.db.queuecount()\\n\\n return self.queuecount\",\n \"def queue_message_count(self, queue_name):\\n queue_list = self.__session.getObjects(_class=\\\"queue\\\", _name=queue_name)\\n if len(queue_list):\\n return queue_list[0].msgDepth\",\n \"def declare_queue(self):\\n\\n self._channel.queue_declare(queue=self._queue_name, durable=True)\\n print(\\\"Queue declared....\\\")\",\n \"def setup_queue(self, channel, queue_name):\\n logger.info('Declaring queue %s', queue_name)\\n channel.queue_declare(queue = queue_name, \\n durable = True,\\n auto_delete = False)\",\n \"def queue_count(self):\\n with self.mutex:\\n return len(self.queues)\",\n \"def record_queue_size():\\n statsd.gauge('rabbitmq.size', rabbitmq_queue_size())\",\n \"def on_channel_open(new_channel):\\n global channel\\n channel = new_channel\\n channel.queue_declare(queue=\\\"test\\\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)\",\n \"def new_messages_number(self, tag):\\n return len(self._message_queue.setdefault(tag,[]))\",\n \"def get_rabbit_queue():\\n\\n return \\\"metrics_queue\\\"\",\n \"def queue_size(self):\\n # pylint: disable=protected-access\\n if self._handler._received_messages:\\n return self._handler._received_messages.qsize()\\n return 0\",\n \"def declare_queue(self, topic):\\n #from trove.rpc.impl_kombu import Connection\\n from trove.openstack.common.rpc import create_connection\\n with create_connection() as conn:\\n consumer = conn.declare_topic_consumer(topic=topic)\",\n \"def get_queue_size(queue):\\n with current_celery_app.pool.acquire(block=True) as connection:\\n bound_queue = queue.bind(connection)\\n _, size, _ = bound_queue.queue_declare(passive=True)\\n return size\",\n \"async def declare(self) -> 'Queue':\\n # we are relying to this in other functions\\n self._channel = await self._backend.channel()\\n self.log.debug(\\\"Channel acquired CHANNEL%i\\\",\\n self._channel.channel_number)\\n\\n if self.exchange:\\n await self.declare_exchange()\\n\\n if self.name is not None:\\n await self.declare_queue()\\n\\n if self.exchange:\\n await self.bind_queue()\\n\\n return self\",\n \"async def _connect(self):\\n self._connection = await connect_robust(self._connection_string)\\n self._channel = await self._connection.channel()\\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})\",\n \"def perform_setup():\\n global credentials, connection, channel\\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\\"127.0.0.1\\\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\\n channel = connection.channel()\\n channel.queue_declare(queue='poll', durable=True)\",\n \"def get_message_queue_size(self):\\n with self.lock:\\n return len(self.message_queue)\",\n \"def on_queue_declared(frame):\\n channel.basic_consume(handle_delivery, queue='test')\",\n \"def _ns_queue(self, queue, consumer_id):\\n return self._ns(queue, consumer_id, \\\"messages\\\")\",\n \"def on_exchange_declareok(self, _unused_frame):\\n self._channel_ctrl.queue_declare(\\n '',\\n exclusive=True,\\n auto_delete=True,\\n callback=self.on_queue_declareok\\n )\",\n \"def setup_queue(self, method_frame):\\n logger.info('Declaring queue %s', self.queue_name)\\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\\n\\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)\",\n \"def ceilometer_amq(self):\\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\\n credentials=pika.PlainCredentials(\\n username=self.rabbit_user,\\n password=self.rabbit_pass)))\\n channel = connection.channel()\\n result = channel.queue_declare(exclusive=True)\\n queue_name = result.method.queue\\n channel.exchange_declare(exchange='ceilometer', type='topic')\\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='notifications.#')\\n channel.queue_bind(exchange='ceilometer', queue=queue_name, routing_key='metering')\\n\\n #channel.queue_bind(exchange='ceilometer.agent.notification_fanout', queue=queue_name)\\n #channel.queue_bind(exchange='ceilometer.collector_fanout', queue=queue_name)\\n channel.basic_consume(self.ceilometer_callback, queue=queue_name, no_ack=True)\\n channel.start_consuming()\",\n \"def setup_queue(self):\\n self.logger.info('declaring queue %s', self.queue)\\n if self.otq:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\\n else:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue)\",\n \"def get_number_of_messages(queue_name):\\n queue = sqs.get_queue_by_name(QueueName=queue_name)\\n return queue.attributes.get('ApproximateNumberOfMessages')\",\n \"def queue_size(self) -> int:\\n return self._queue.qsize()\",\n \"def _numQueuedTotal(self):\\n queueSize = len(self.__queue) + len(self.__clientQueue)\\n return queueSize\",\n \"def declare(self):\\n self.channel.queue_declare(queue='files_to_database')\",\n \"def celery_queue_lengths(request):\\n queue_len = collect_queue_metrics()\\n LOG.info(f\\\"Celery queue backlog info: {queue_len}\\\")\\n return Response(queue_len)\",\n \"def on_open_channel(new_channel):\\n # assign new channel to the global channel variable\\n global channel\\n channel = new_channel\\n\\n # channel is assigned and declare a queue named scripbox.\\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\\n # Pass a callback on_queue_declared which fires when a queue declaration\\n # is successful\\n channel.queue_declare(queue='scripbox', durable=True,\\n auto_delete=False, callback=on_queue_declared)\",\n \"def ctrlqueue_num_actions(self) -> int:\\n try:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(2), ctypes.c_int32(0))\\n except Exception as e:\\n Base.warn_msg(\\\"An error occur when tried to get *Num Actions of CrlQueue* check if *Queue* is NOT empty\\\", e)\",\n \"def _queue_len(queue_path: str) -> int:\\n if not os.path.exists(queue_path):\\n return 0\\n return len([path for path in os.listdir(queue_path)])\",\n \"def _getqueuesize(self):\\n return self._queuesize\",\n \"def connect(self):\\n # @TODO: implement SSL\\n connection = pika.BlockingConnection(self.params)\\n channel = connection.channel()\\n channel.queue_declare(queue=self.queue_name, durable=True)\\n\\n self.connection = connection\\n self.channel = channel\",\n \"def on_queue_declared(self, frame):\\n\\t\\tself.channel.basic_qos(prefetch_count=1)\\n\\t\\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\\n\\t\\tself.consumer_tag = self.channel.basic_consume(\\n\\t\\t\\tself.handle_delivery, \\n\\t\\t\\tframe.method.queue\\n\\t\\t)\",\n \"def GetTotalQueueCount(handler, query):\\n # pylint: disable=unused-argument\\n\\n json_config = {}\\n json_config['count'] = 0\\n\\n with active_tivos_lock:\\n for tivoIP in active_tivos:\\n with active_tivos[tivoIP]['lock']:\\n json_config['count'] += len(active_tivos[tivoIP]['queue'])\\n\\n handler.send_json(json.dumps(json_config))\",\n \"def ctrlqueue_queue_size(self) -> int:\\n return self.dss_obj.CtrlQueueI(ctypes.c_int32(10), ctypes.c_int32(0))\",\n \"def test_the_queue_size(the_queue):\\n the_queue.enqueue(1)\\n the_queue.enqueue(2)\\n the_queue.enqueue(3)\\n assert the_queue.size() == 3\",\n \"def api_get_queue_len():\\n try:\\n ret = AppStatus.check_manager_status(brief=False)\\n if ret is not None:\\n return jsonify({\\\"total_queue_len\\\": ret.get(\\\"total_queue_len\\\", 0)})\\n except Exception as e:\\n logger.error(\\\"Traceback:\\\\n%s\\\", traceback.format_exc())\\n abort(500, \\\"failed to send message or invalid manager response\\\")\",\n \"def test_size_increments_with_enqueue():\\n queue = Queue()\\n queue.enqueue('val')\\n assert queue.size() == 1\",\n \"def test_list_queues(self, rabbitmq):\\n assert rabbitmq.list_queues() == []\\n self.declare_queue(rabbitmq, \\\"q1\\\")\\n self.declare_queue(rabbitmq, \\\"q2\\\")\\n assert sorted(rabbitmq.list_queues()) == [('q1', '0'), ('q2', '0')]\",\n \"def queue_size(self):\\n return self._queue_size\",\n \"def count_remaining(self):\\n\\t\\treturn self._queue.qsize()\",\n \"def count_remaining(self):\\n\\t\\treturn self._queue.qsize()\",\n \"def queue_size(self) -> ConfigNodePropertyInteger:\\n return self._queue_size\",\n \"def linkRabbit(self):\\n\\n print(\\\"Listening for RabbitMQ messages\\\")\\n\\n # RabbitMQ setup\\n connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host='localhost'))\\n channel = connection.channel()\\n\\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\\n\\n result = channel.queue_declare(queue='', exclusive=True)\\n queue_name = result.method.queue\\n\\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\\n channel.start_consuming()\",\n \"def _listen_queue(self, queue, callback):\\n # Listen buy/sell orders from external system\\n self._logger.info(f\\\"Declaring rabbit queue {queue}\\\")\\n self._consumer_rabbit_channel.queue_declare(queue=queue, durable=True, auto_delete=True)\\n self._logger.info(f\\\"Declaring callback to rabbit queue: {queue}, callback: {callback}\\\")\\n self._consumer_rabbit_channel.basic_consume(queue, callback,\\n consumer_tag=queue)\",\n \"def qsize(self):\\n if not self.connected:\\n raise QueueNotConnectedError(\\\"Queue is not Connected\\\")\\n\\n try:\\n size = self.__db.llen(self._key)\\n except redis.ConnectionError as e:\\n raise redis.ConnectionError(repr(e))\\n return size\",\n \"def test_size_of_new_queue():\\n queue = Queue()\\n assert queue.size() == 0\",\n \"def num_pending(status=\\\"pending\\\", username=\\\"garrett.wilson\\\"):\\n cmd = [\\n \\\"squeue\\\",\\n \\\"-u\\\", username,\\n \\\"-t\\\", status,\\n \\\"-h\\\"\\n ]\\n\\n output = subprocess.check_output(cmd)\\n output = output.decode(\\\"utf-8\\\").strip()\\n\\n if output == \\\"\\\":\\n return 0\\n\\n return len(output.split(\\\"\\\\n\\\"))\",\n \"async def consume_items_from_rabbitmq(queue):\\n ctr = 0\\n start = time.time()\\n while True:\\n await asyncio.sleep(0.001)\\n for method_frame, properties, body in channel.consume(queue_name, inactivity_timeout=1):\\n if method_frame:\\n # print(body)\\n while queue.full():\\n await asyncio.sleep(0.001)\\n # await queue.put(body)\\n queue.put_nowait(body)\\n # Acknowledge the message\\n channel.basic_ack(method_frame.delivery_tag)\\n ctr += 1\\n if not ctr % 1000:\\n end = time.time() - start\\n print(f'elapsed time: {end:.3f}\\\\tmessages received: {ctr}')\\n else:\\n # empty remaining items from queue\\n while queue.qsize():\\n await asyncio.sleep(0.001)\\n end = time.time() - start\\n print(f'elapsed time: {end:.3f}\\\\tmessages received: {ctr}')\\n break\\n await asyncio.sleep(0.001)\\n\\n requeued_messages = channel.cancel()\",\n \"def on_exchange_declareok(self, unused_frame):\\n LOGGER.debug('Exchange declared')\\n\\n for queue in self._handlers.keys():\\n self._channel.queue_declare(self.on_queue_declareok, queue)\\n\\n RabbitMQ.on_exchange_declareok(self, unused_frame)\",\n \"def create(self, queue, metadata, tenant=None, limit=10):\\n msg_ctrl = self.driver.message_controller\\n\\n # We don't need the qid here but\\n # we need to verify it exists.\\n qid = self._get_queue_id(queue, tenant)\\n\\n ttl = int(metadata.get(\\\"ttl\\\", 60))\\n oid = objectid.ObjectId()\\n\\n # Lets remove the timezone,\\n # we want it to be plain utc\\n expires = utils.oid_ts(oid) + ttl\\n\\n meta = {\\n \\\"id\\\": oid,\\n \\\"t\\\": ttl,\\n \\\"e\\\": expires,\\n }\\n\\n # Get a list of active, not claimed nor expired\\n # messages that could be claimed.\\n msgs = msg_ctrl.active(qid, fields={\\\"_id\\\": 1})\\n msgs = msgs.limit(limit).sort(\\\"_id\\\")\\n\\n messages = iter([])\\n\\n # Lets respect the limit\\n # during the count\\n if msgs.count(True) == 0:\\n return (str(oid), messages)\\n\\n ids = [msg[\\\"_id\\\"] for msg in msgs]\\n now = timeutils.utcnow_ts()\\n\\n # Set claim field for messages in ids\\n updated = msg_ctrl._col.update({\\\"_id\\\": {\\\"$in\\\": ids},\\n \\\"$or\\\": [\\n {\\\"c.id\\\": None},\\n {\\n \\\"c.id\\\": {\\\"$ne\\\": None},\\n \\\"c.e\\\": {\\\"$lte\\\": now}\\n }\\n ]},\\n {\\\"$set\\\": {\\\"c\\\": meta}}, upsert=False,\\n multi=True)[\\\"n\\\"]\\n\\n # NOTE(flaper87): Dirty hack!\\n # This sets the expiration time to\\n # `expires` on messages that would\\n # expire before claim.\\n msg_ctrl._col.update({\\\"q\\\": queue,\\n \\\"e\\\": {\\\"$lte\\\": expires},\\n \\\"c.id\\\": oid},\\n {\\\"$set\\\": {\\\"e\\\": expires}},\\n upsert=False, multi=True)\\n\\n if updated != 0:\\n claim, messages = self.get(queue, oid, tenant=tenant)\\n return (str(oid), messages)\",\n \"def qsize(self) -> int:\\n return len(self._queue)\",\n \"def get_queue_number(self):\\n outstring = self.dut.send_expect(\\\"stop\\\", \\\"testpmd> \\\")\\n time.sleep(2)\\n result_scanner = r\\\"Forward Stats for RX Port= %s/Queue=\\\\s?([0-9]+)\\\" % self.dut_ports[0]\\n scanner = re.compile(result_scanner, re.DOTALL)\\n m = scanner.search(outstring)\\n queue_id = m.group(1)\\n print \\\"queue is %s\\\" % queue_id\\n self.dut.send_expect(\\\"start\\\", \\\"testpmd> \\\")\\n return queue_id\",\n \"def get_amount_queued(self):\\n return self._num_queued\",\n \"def get_queue(self):\\r\\n return _channeldata[self.chan].queue\",\n \"def keystone_amq(self):\\n\\n connection = pika.BlockingConnection(pika.ConnectionParameters(host=self.rabbit_host,\\n credentials=pika.PlainCredentials(\\n username=self.rabbit_user,\\n password=self.rabbit_pass)))\\n channel = connection.channel()\\n result = channel.queue_declare(exclusive=True)\\n queue_name = result.method.queue\\n channel.exchange_declare(exchange='keystone', type='topic')\\n channel.queue_bind(exchange='openstack', queue=queue_name, routing_key='notifications.#')\\n channel.queue_bind(exchange='keystone', queue=queue_name, routing_key='keystone.#')\\n\\n channel.basic_consume(self.keystone_callback, queue=queue_name, no_ack=True)\\n channel.start_consuming()\",\n \"def get_message_count(self):\\n return self.buffer.count()\",\n \"def queue_size(self):\\n return self.sql_queue.qsize()\",\n \"def message_count(self):\\n pass\",\n \"def queue_size(self):\\n return len(self.groups)\",\n \"def qsize(self):\\r\\n return len(self._queue)\",\n \"def qsize(self) -> int:\\n return self._queue.qsize()\",\n \"def queue(self, name):\\n # First create a queue\\n queue = self.inbound_channel.declare_queue(name)\\n\\n # Create the registry for the queue\\n registry = Registry(self, queue)\\n\\n # Prepare consuming queue with registry\\n self.inbound_channel.consume(queue=queue, callback=registry)\\n\\n # Then, return the Registry object.\\n return registry\",\n \"def subscribe(self):\\n with self._rabbit_connection.connection.channel() as channel:\\n self._queue = rabbitpy.Queue(\\n channel=channel,\\n name=self._subscriber_name + \\\"_queue\\\",\\n durable=True,\\n message_ttl=5 * 24 * 60 * 60 * 1000 # 5 days\\n )\\n self._queue.declare()\\n self._queue.bind(self._exchange, self._routing_key)\\n\\n self._consume()\",\n \"def _queue_create(self, **kwargs):\\n name = self.generate_random_name()\\n return self.clients(\\\"zaqar\\\").queue(name, **kwargs)\",\n \"def declare_queue(self, c, queue_name):\\n return self._management_req(\\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\\n {\\\"auto_delete\\\": False, \\\"durable\\\": False, \\\"arguments\\\": {}})\",\n \"def message_count(self):\\n return self._message_count\",\n \"def size(self):\\n return len(self.__queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def size(self):\\n return len(self.queue)\",\n \"def ReceiveIncomingDelivery(self):\\r\\n quantityReceived = self.incomingDeliveriesQueue.PopEnvelope()\\r\\n \\r\\n if quantityReceived > 0:\\r\\n self.currentStock += quantityReceived\\r\\n \\r\\n return quantityReceived\",\n \"def test_create_qos_queue(self):\\r\\n resource = 'qos_queue'\\r\\n cmd = qos.CreateQoSQueue(\\r\\n test_cli20.MyApp(sys.stdout), None)\\r\\n myid = 'myid'\\r\\n name = 'my_queue'\\r\\n default = False\\r\\n args = ['--default', default, name]\\r\\n position_names = ['name', 'default']\\r\\n position_values = [name, default]\\r\\n self._test_create_resource(resource, cmd, name, myid, args,\\r\\n position_names, position_values)\",\n \"def connect(self):\\n self._connect()\\n if self.conn is not None:\\n try:\\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\\n except:\\n self.closeConn()\",\n \"def create_queue(self, queue_name='', exclusive=True, queue_size=10,\\n message_ttl=60000, overflow_behaviour='drop-head',\\n expires=600000):\\n args = {\\n 'x-max-length': queue_size,\\n 'x-overflow': overflow_behaviour,\\n 'x-message-ttl': message_ttl,\\n 'x-expires': expires\\n }\\n\\n result = self._channel.queue_declare(\\n exclusive=exclusive,\\n queue=queue_name,\\n durable=False,\\n auto_delete=True,\\n arguments=args)\\n queue_name = result.method.queue\\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\\n queue_name, queue_size, message_ttl))\\n return queue_name\",\n \"def test_size(self):\\n queue = Queue()\\n self.assertEqual(queue.size(), 0)\\n queue.enqueue(1)\\n self.assertEqual(queue.size(), 1)\",\n \"def __init__(self, address, queue_name):\\n self.connection = pika.BlockingConnection(\\n pika.ConnectionParameters(address))\\n self.queue_name = queue_name\\n\\n # create the channel\\n self.channel = self.connection.channel()\\n\\n # declare the queue\\n self.channel.queue_declare(queue=queue_name, durable=True)\\n\\n logging.info(\\\"Message Broker connected to {0}\\\".format(address))\",\n \"def consumer_count(self, obj):\\n return obj.get_or_set_consumer_count()\",\n \"def process_queue_message(message):\\n resource_storage = ResourceStorageFactory.create()\\n resources = _parse_resources(message)\\n\\n resource_storage.write_entries(resources)\\n return len(resources)\",\n \"def on_secondary_channel_open(self, ch):\\n # Our usable channel has been passed to us, assign it for future use\\n self.amqp_secondary_channel = ch\\n \\n # Declare 'IN' queue - for receiving confirmations\\n self.amqp_secondary_channel.queue_declare(queue=self.amqp_confirm_queue, durable=True,\\n exclusive=False, auto_delete=False,\\n callback=self.on_confirm_queue_declared)\",\n \"def create_qos_queue(self, body=None):\\r\\n return self.post(self.qos_queues_path, body=body)\",\n \"def create_message_queue_table(self):\\n app_process = sqlite3.connect('app_process::memory:', check_same_thread=False)\\n app_process_cursor = app_process.cursor()\\n app_process_cursor.execute(\\\"SELECT count(name) FROM sqlite_master WHERE type='table' AND name='message_queue'\\\")\\n if app_process_cursor.fetchone()[0]==1:\\n return\\n app_process_cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE message_queue (\\n tstamp real,\\n request text,\\n dest_ip text,\\n dest_port integer,\\n next_tstamp real\\n )\\n \\\"\\\"\\\")\\n app_process.commit()\\n app_process.close()\",\n \"def size(self):\\r\\n return len(self.queue)\",\n \"def size(self):\\r\\n return len(self.queue)\",\n \"def read_queue():\\n with open(\\\"config.json\\\") as f:\\n config = json.load(f)\\n \\n cpars = pika.ConnectionParameters(host=config[\\\"cage_daq\\\"])\\n connection = pika.BlockingConnection(cpars)\\n channel = connection.channel()\\n\\n channel.exchange_declare(exchange=config[\\\"exchange\\\"], exchange_type='topic')\\n \\n channel.queue_declare(queue=config[\\\"queue\\\"], exclusive=True)\\n \\n channel.queue_bind(queue=config[\\\"queue\\\"], exchange=config[\\\"exchange\\\"], \\n routing_key='sensor_value.#')\\n \\n channel.basic_consume(queue=config[\\\"queue\\\"], on_message_callback=callback, \\n auto_ack=True)\\n\\n print(' [*] Waiting for messages. To exit press CTRL+C')\\n channel.start_consuming()\",\n \"def connect(self):\\n try:\\n self.conn = amqp.Connection(insist=True, **self.config)\\n self.chan = self.conn.channel()\\n self.chan.queue_declare(queue=self.RQU, durable=False, exclusive=False, auto_delete=True)\\n self.chan.exchange_declare(exchange=self.EXCH, type=\\\"topic\\\", durable=True, auto_delete=False,)\\n self.chan.queue_bind(queue=self.RQU, exchange=self.EXCH, routing_key=self.RKEY)\\n self.chan.basic_consume(queue=self.RQU, no_ack=True, callback=self.amqpCallback, consumer_tag=\\\"ctag\\\")\\n except:\\n self.closeConn()\",\n \"def size(self):\\n return len(self._queue_items)\",\n \"def _declare(self, passive=False):\\n arguments = dict(self._arguments)\\n if self._expires:\\n arguments['x-expires'] = self._expires\\n if self._message_ttl:\\n arguments['x-message-ttl'] = self._message_ttl\\n if self._max_length:\\n arguments['x-max-length'] = self._max_length\\n if self._dlx:\\n arguments['x-dead-letter-exchange'] = self._dlx\\n if self._dlr:\\n arguments['x-dead-letter-routing-key'] = self._dlr\\n return specification.Queue.Declare(queue=self.name,\\n durable=self._durable,\\n passive=passive,\\n exclusive=self._exclusive,\\n auto_delete=self._auto_delete,\\n arguments=arguments)\",\n \"def subscribe(self, queue, action):\\n self.channel.queue_declare(queue=queue)\\n self.channel.basic_consume(queue=queue,\\n on_message_callback=action,\\n auto_ack=True)\\n self.channel.start_consuming()\",\n \"def get_queue_items(self, queue_name):\\n proc = start_proc([\\\"/usr/bin/sudo\\\", \\\"rabbitmqctl\\\", \\\"list_queues\\\"],\\n shell=False)\\n for line in iter(proc.stdout.readline, \\\"\\\"):\\n print(\\\"LIST QUEUES:\\\" + line)\\n m = re.search(r\\\"%s\\\\s+([0-9]+)\\\" % queue_name, line)\\n if m:\\n return int(m.group(1))\\n return None\",\n \"def size():\\r\\n qry = ImportQueue.query.filter(or_(\\r\\n ImportQueue.status != COMPLETE,\\r\\n ImportQueue.status != ERROR))\\r\\n return qry.count()\",\n \"def number_of_jobs_in_queue():\\n\\n # Initialize #\\n user_name = get_username()\\n\\n process = subprocess.check_output([\\\"squeue\\\", \\\"-u\\\", user_name])\\n\\n return len([line for line in process.split(\\\"\\\\n\\\") if user_name in line])\",\n \"def count(self):\\t\\n\\t\\ttry:\\n\\t\\t\\treturn True, self.queue.qsize()\\n\\t\\texcept Exception, e:\\n\\t\\t\\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\\n\\t\\t\\treturn False, None\",\n \"def create_queue(self):\\n queue_name = self.generate_name()\\n try:\\n queue = self.sqs.create_queue(QueueName=queue_name)\\n except Exception as e:\\n raise RuntimeError('SQS could create queue: %s' % e)\\n self.queue_name, self.queue = queue_name, queue\",\n \"def consumer_details_for_queue(self):\\n response_json = self.rabbit_request(\\\"queues/%2F/\\\" + self._queue)\\n return response_json[\\\"consumer_details\\\"]\",\n \"def consume():\\n with conn.channel() as chan:\\n \\n def on_msg_recv(msg):\\n \\\"\\\"\\\" Called when message arrives from RabbitMQ\\n \\\"\\\"\\\"\\n print \\\"processor|%s::Received message: %s\\\" % (UID, msg.body)\\n chan.basic_ack(msg.delivery_tag)\\n log(msg.body)\\n process_msg(msg)\\n \\n \\n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\\n chan.exchange_declare(exchange = EXCHANGE,\\n type = EXCHANGE_TYPE)\\n queue = chan.queue_declare(QUEUE)\\n chan.queue_bind(exchange = EXCHANGE, \\n queue = QUEUE, \\n routing_key = ROUTING_KEY)\\n \\n # Declare that we are going to listen to given queue\\n chan.basic_consume(queue = QUEUE, \\n callback = on_msg_recv)\\n \\n # Main loop. Waiting for messages from RabbitMQ.\\n while True:\\n chan.wait()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6695004","0.65361464","0.6433904","0.6380009","0.63566524","0.6303155","0.6188639","0.6182734","0.61554193","0.6077462","0.6067161","0.60579026","0.60351235","0.6034361","0.60192823","0.5917088","0.58340645","0.58212996","0.5819722","0.58159286","0.5790397","0.57903755","0.57754976","0.5732488","0.5723154","0.57152146","0.5696736","0.5684892","0.56677055","0.5617301","0.55758965","0.55731535","0.55705374","0.5568581","0.5559799","0.5546474","0.5499495","0.5492067","0.54888445","0.54448617","0.542941","0.5425602","0.5423436","0.54098415","0.54098415","0.54082304","0.5397879","0.53872263","0.5382316","0.53741395","0.5372021","0.5343314","0.53322476","0.5319757","0.53080225","0.53078645","0.5277497","0.52723646","0.527025","0.5259019","0.52547467","0.5251796","0.5246667","0.5240734","0.52346003","0.5233966","0.523211","0.5231567","0.5226674","0.5212543","0.5178325","0.517771","0.517771","0.517771","0.517771","0.5163121","0.515666","0.51487595","0.51347417","0.5128032","0.512729","0.5118121","0.51093143","0.51057553","0.51014847","0.5087561","0.5069325","0.5069325","0.50650054","0.50495774","0.5048401","0.5047555","0.5047159","0.5030234","0.5023592","0.5018226","0.5011775","0.5009102","0.5003241","0.49824345"],"string":"[\n \"0.6695004\",\n \"0.65361464\",\n \"0.6433904\",\n \"0.6380009\",\n \"0.63566524\",\n \"0.6303155\",\n \"0.6188639\",\n \"0.6182734\",\n \"0.61554193\",\n \"0.6077462\",\n \"0.6067161\",\n \"0.60579026\",\n \"0.60351235\",\n \"0.6034361\",\n \"0.60192823\",\n \"0.5917088\",\n \"0.58340645\",\n \"0.58212996\",\n \"0.5819722\",\n \"0.58159286\",\n \"0.5790397\",\n \"0.57903755\",\n \"0.57754976\",\n \"0.5732488\",\n \"0.5723154\",\n \"0.57152146\",\n \"0.5696736\",\n \"0.5684892\",\n \"0.56677055\",\n \"0.5617301\",\n \"0.55758965\",\n \"0.55731535\",\n \"0.55705374\",\n \"0.5568581\",\n \"0.5559799\",\n \"0.5546474\",\n \"0.5499495\",\n \"0.5492067\",\n \"0.54888445\",\n \"0.54448617\",\n \"0.542941\",\n \"0.5425602\",\n \"0.5423436\",\n \"0.54098415\",\n \"0.54098415\",\n \"0.54082304\",\n \"0.5397879\",\n \"0.53872263\",\n \"0.5382316\",\n \"0.53741395\",\n \"0.5372021\",\n \"0.5343314\",\n \"0.53322476\",\n \"0.5319757\",\n \"0.53080225\",\n \"0.53078645\",\n \"0.5277497\",\n \"0.52723646\",\n \"0.527025\",\n \"0.5259019\",\n \"0.52547467\",\n \"0.5251796\",\n \"0.5246667\",\n \"0.5240734\",\n \"0.52346003\",\n \"0.5233966\",\n \"0.523211\",\n \"0.5231567\",\n \"0.5226674\",\n \"0.5212543\",\n \"0.5178325\",\n \"0.517771\",\n \"0.517771\",\n \"0.517771\",\n \"0.517771\",\n \"0.5163121\",\n \"0.515666\",\n \"0.51487595\",\n \"0.51347417\",\n \"0.5128032\",\n \"0.512729\",\n \"0.5118121\",\n \"0.51093143\",\n \"0.51057553\",\n \"0.51014847\",\n \"0.5087561\",\n \"0.5069325\",\n \"0.5069325\",\n \"0.50650054\",\n \"0.50495774\",\n \"0.5048401\",\n \"0.5047555\",\n \"0.5047159\",\n \"0.5030234\",\n \"0.5023592\",\n \"0.5018226\",\n \"0.5011775\",\n \"0.5009102\",\n \"0.5003241\",\n \"0.49824345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6078519"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":93084,"cells":{"query":{"kind":"string","value":"Request a single message from RabbitMQ using the Basic.Get AMQP command."},"document":{"kind":"string","value":"def get(self, acknowledge=True):\n self._write_frame(specification.Basic.Get(queue=self.name,\n no_ack=not acknowledge))\n return self.channel._get_message()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get(self, msg):\n\n # print(\"get\")\n self.q.put(msg)","def rabbit_request(self, path):\n uri = self._base_uri + path\n response = requests.get(uri, auth=self._auth)\n\n if response.status_code != 200:\n raise Exception(self.error_message(response))\n return json.loads(response.content)","def get_msg(self, my_queue):\n self.channel.basic_qos(prefetch_count=COUNT)\n try:\n for method_frame, properties, body in self.channel.consume(my_queue):\n self.channel.basic_ack(method_frame.delivery_tag)\n return body\n except pika.exceptions, err_msg:\n log.error(err_msg)\n return False","def read(self):\n method_frame, header_frame, body = self._channel.basic_get(self.name)\n if method_frame:\n pika_message = PikaMessage(body,\n delivery_info=method_frame,\n properties=header_frame,\n )\n return pika_message.to_message()\n else:\n return None","def get_message_from_queue(self):\n message = None, None\n\n try:\n message = self.queue.get(block=True, timeout=3)\n except Empty:\n self.fail(msg='Queue get() failed empty')\n\n return message","async def get(\n self, *, no_ack: bool = False,\n fail: bool = True, timeout: TimeoutType = 5,\n ) -> Optional[IncomingMessage]:\n\n channel = await self.channel.get_underlay_channel()\n msg: DeliveredMessage = await channel.basic_get(\n self.name, no_ack=no_ack, timeout=timeout,\n )\n\n if isinstance(msg.delivery, aiormq.spec.Basic.GetEmpty):\n if fail:\n raise QueueEmpty\n return None\n\n return IncomingMessage(msg, no_ack=no_ack)","def getMsg(self, time=None, msg=\"\"):\n\t\ttry:\n\t\t\tr = self._queue.get(True, time)\n\t\texcept Empty:\n\t\t\traise TimeoutException(\"%s.getMsg(timeout=%s,msg=%s)\"%(self,time,msg))\n\t\telse:\n\t\t\tself._queue.task_done()\n\t\t\treturn r","def consume_message(message):\n # Assign the message to the global drone_message\n global drone_message\n drone_message = message\n # The Rabbit mq runs in the localhost and the username , password is\n # athavan\n credentials = pika.PlainCredentials('guest', 'guest')\n # Pass the mqhost , port , virtualhost and credentials\n parameters = pika.ConnectionParameters('localhost', 5672, '/', credentials)\n connection = pika.SelectConnection(parameters, on_connected)\n try:\n connection.ioloop.start()\n except KeyboardInterrupt:\n # close the connnection\n connection.close()\n # loop until we are fully closed. It will stop on its own\n connection.ioloop.start()","def fetch_job_from_queue(self):\n while 1:\n time.sleep(2)\n try:\n credentials = pika.PlainCredentials('USER', 'PASSWORD')\n connection = pika.BlockingConnection(pika.ConnectionParameters('rabbitmq', 5672, '/', credentials))\n channel = connection.channel()\n channel.queue_declare(queue='purserq')\n method_frame, header_frame, body = channel.basic_get(queue='purserq')\n if method_frame.NAME == 'Basic.GetEmpty':\n connection.close()\n else:\n channel.basic_ack(delivery_tag=method_frame.delivery_tag)\n print \"Received job:\", body, \"starting job to reply\"\n connection.close()\n self.reply_to_master(body)\n except AttributeError:\n print \"No content\"\n connection.close()\n except pika.exceptions.ConnectionClosed:\n print \"You get Connection Closed\"\n continue","def get_message(agentIdPath, messageIdPath): # noqa: E501\n keys = [\"id:\"+messageIdPath]\n result = multichain_client.liststreamqueryitems (agentIdPath, keys, verbose)\n print(result)\n print(type(result))\n j_result = json.loads(result);\n print(j_result)\n print(type(j_result))\n if j_result[\"error\"] is None:\n if len(j_result[\"result\"])>0:\n return j_result[\"result\"][0][\"data\"][\"json\"]\n else:\n return Response(status=404, mimetype='application/json')\n else:\n return Response(status=500, mimetype='application/json')","def test_get_message(self):\n response = self.client.open(\n '/api/rtx/v1/message/{message_id}'.format(message_id=56),\n method='GET')\n self.assert200(response,\n 'Response body is : ' + response.data.decode('utf-8'))","async def Read(self) -> Optional[Message]:\n return await self._read_queue.Get()","def get_message(cls):\n rp = cls.get()\n try:\n message = rp.queue_send.get_nowait()\n except Exception:\n return None\n\n return message","def get_msg(self, block=True, timeout=None):\n return self.in_queue.get(block, timeout)","def get_msg(self, block=True, timeout=None):\n return self.in_queue.get(block, timeout)","def GetApiMessage(message_name):\n messages = apis.GetMessagesModule(_BQ_API, _BQ_API_VERSION)\n return getattr(messages, message_name)","def test_basic():\n client = CloudAMQPClient(CLOUDAMQP_URL, TEST_QUEUE_NAME)\n send_msg = {'test': 'ans'}\n client.send_message(send_msg)\n received_msg = client.get_message()\n assert send_msg == received_msg\n print 'test_basic() passed'","def get_message(self, message_id: int) -> discord.Message:\n return self._connection._get_message(message_id)","def get(self, id):\n return read_msg(id)","def query(self):\n self.bus.write('@\\x51\\r\\n')\n response = self.bus.read(23)\n return response","def GetMessage(service, user_id, msg_id):\n try:\n message = service.users().messages().get(userId=user_id, id=msg_id).execute()\n\n return message\n except errors.HttpError:\n print('An error occurred: ')","def receive_message(request):\n message_id = request.GET.get('message_id')\n message = Message.objects.get(pk=message_id)\n return Response({'message': message})","async def fetch_message(ctx: commands.Context, message_id: int) -> discord.Message:\r\n try:\r\n msg = await ctx.fetch_message(message_id)\r\n except discord.NotFound:\r\n raise CommandError(f\"Cannot find message with ID `{message_id}`!\")\r\n except discord.Forbidden:\r\n raise CommandError(\"Lacking permissions to fetch message!\")\r\n except discord.HTTPException:\r\n raise CommandError(\"Failed to retrieve message. Try again later!\")\r\n else:\r\n return msg","def pull(self):\n \n data = self.s.recv(1024)\n if data:\n info = json.loads(data.decode()) \n print(\"DATA FROM BROKER : \", info)\n \n return info.get(\"topic\"), info.get(\"value\")\n pass","def query(self, message):\n return self.device.query(message)","def get(self):\r\n try:\r\n # get with block=False returns an item if one\r\n # is immediately available, else raises the Empty exception\r\n return self._queue.get(block=False)\r\n except queue.Empty:\r\n return self._create_connection()","def message(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'message')\r\n return http.Request('GET', url), parsers.parse_json","def get(self):\n return dumps(AQ.queue()), 200","def get_message():\n\tincoming_message = conn.recv(1024)\n\tincoming_message = incoming_message.decode()\n\treturn incoming_message","def GetMessage(service, user_id, msg_id):\n try:\n #take out format='raw' if don't want base64\n message = service.users().messages().get(userId=user_id, id=msg_id, format='raw').execute()\n\n print('Message snippet: %s' % message['snippet'])\n\n return message\n except errors.HttpError, error:\n print('An error occurred: %s' % error)","def getMessage(self, queue_name, max=None, project_id=None):\n if project_id is None:\n project_id = self.project_id\n n = \"\"\n if max is not None:\n n = \"&n=%s\" % max\n url = \"%sprojects/%s/queues/%s/messages?oauth=%s%s\" % (self.url,\n project_id, queue_name, self.token, n)\n body = self.__get(url)\n\n return json.loads(body)","def read(self) -> requests.request:\n # Check if id is set,\n if self.args.id is not None:\n self.REQUEST_URL += str(self.args.id)\n\n # Send GET request\n return requests.get(self.REQUEST_URL)","def api_getmessage():\n message = receive_lyrics()\n if message != \"\":\n return jsonify(ready=True, msg=message)\n else:\n return jsonify(ready=False)","def _get(self, path=None, version=None, params=None,\n header=None):\n return self.client.get(module='mam', path=path,\n version=version, params=params, header=header)","def get(self, message = None, wait = 2):\n # Verify if sonar is initialized\n if not self.initialized:\n raise SonarNotConfigured\n\n expected_name = Message.to_string(message)\n if message:\n rospy.logdebug(\"Waiting for %s message\", expected_name)\n else:\n rospy.logdebug(\"Waiting for unlabeled message\")\n\n # Determine end time\n end = datetime.datetime.now() + datetime.timedelta(seconds=wait)\n\n # Wait until received if a specific message ID is requested, otherwise wait forever\n while message is None or datetime.datetime.now() < end:\n if message is None:\n try:\n reply = self.conn.get_reply()\n return reply\n except:\n break\n else:\n try:\n reply = self.conn.get_reply(message)\n except:\n break\n # Verify reply ID if requested\n if reply.id == message:\n #rospy.logdebug(\"Found %s message\", expected_name)\n return reply\n else:\n rospy.logwarn(\"Received unexpected %s message\", reply.name)\n # Timeout\n rospy.logerr(\"Timed out before receiving message: %s\", expected_name)\n raise TimeoutError()","def get_message(self, message_id):\n req_data = [ str(message_id) ]\n return self.request(\"find:Message.stats, Message.content\", req_data)","def get_msg(self, timeout_in_seconds=-1):\n return self._client.get_msg(timeout_in_seconds)","def get_message(self, message_id):\n res = requests.get(url=\"https://api.ciscospark.com/v1/messages/{}\".format(message_id),\n headers=self.headers)\n\n try:\n text = res.json()['text']\n except AttributeError as e:\n print(res.text)\n return None\n\n return text","def pop_message(self, queue_name):\r\n messages = self.pop_messages(queue_name, count=1)\r\n if messages['item_count'] > 0:\r\n return messages['items'][0]\r\n else:\r\n return None","def get(self,cmd,ch,async_mode):\n comString = cmd + str(ch) + \"?\\n\"\n if async_mode == 'QUERY':\n self.query_async(comString)\n return\n if async_mode == 'REPLY':\n try:\n return self.truncate_float_reply(self.get_async_response(comString))\n except ValueError:\n #print('a')\n return 'EMPTY'","async def method_get(\n self,\n request: Request,\n body: dict,\n session: DBSession,\n message_id: int,\n token: dict,\n *args,\n **kwargs,\n ) -> BaseHTTPResponse:\n try:\n db_message = get_message_by_id(session, message_id=message_id)\n except DBMessageNotExists as e:\n raise NotFound(f\"Message {message_id} not found\") from e\n\n if token[\"sub\"] not in (db_message.sender_id, db_message.recipient_id):\n raise Forbidden(\"user is not recipient or sender\")\n\n response_model = ResponseMessageDto(db_message)\n\n return await self.make_response_json(status=200, body=response_model.dump())","def get_message_by_id(message_id):\n return Message.query.get(message_id)","async def fetch_message(self, channel_id: int, message_id: int) -> discord.Message:\n channel: discord.TextChannel = self.get_channel(channel_id)\n return await channel.fetch_message(message_id)","def get(self, block=True, timeout=None):\n if block:\n message = self.redis.blpop(self.queue, timeout=timeout)\n else:\n message = self.redis.lpop(self.queue)\n\n parsed_message = self.parse(message[1])\n return parsed_message","def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak","def GetMessage(service, user_id, msg_id, snippetMessage=True):\n try:\n message = service.users().messages().get(userId=user_id, id=msg_id).execute()\n #print('Message snippet: %s' % message['snippet'])\n #print('Message snippet: %s' % message['payload']['headers'])\n #print(unicode('Message snippet: %s' % message['snippet'],'utf-8'))\n\n if snippetMessage:\n return message['snippet']\n else:\n return message\n except errors.HttpError, error:\n print('An error occurred: %s' % error)","async def get_msg(self):\n try:\n # 2^8 bytes at a time. I just like it, no special reason\n data = await self.reader.read(256)\n msg = data.decode()\n addr = writer.get_extra_info(\"peername\")\n logging.info(\"Received %s from %s\", (msg, addr))\n\n except Exception as e:\n logging.error(\"Command could not be decoded; %s\", e)\n\n return msg","def get_message(request):\r\n message_key = request.GET.get('message', None)\r\n message = None\r\n message_type = None\r\n\r\n if ((not message_key or message_key == 'upload_success') and\r\n QIFParser.get_status() == 'in_progress'):\r\n message_key = 'in_progress_quicken_file'\r\n\r\n try:\r\n message = Message.MESSAGES[message_key]\r\n message_type = message['type']\r\n message = message['message']\r\n except KeyError:\r\n pass\r\n\r\n return {'message': message,\r\n 'message_key': message_key,\r\n 'message_type': message_type}","def consume():\n with conn.channel() as chan:\n \n def on_msg_recv(msg):\n \"\"\" Called when message arrives from RabbitMQ\n \"\"\"\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)\n \n \n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\n chan.exchange_declare(exchange = EXCHANGE,\n type = EXCHANGE_TYPE)\n queue = chan.queue_declare(QUEUE)\n chan.queue_bind(exchange = EXCHANGE, \n queue = QUEUE, \n routing_key = ROUTING_KEY)\n \n # Declare that we are going to listen to given queue\n chan.basic_consume(queue = QUEUE, \n callback = on_msg_recv)\n \n # Main loop. Waiting for messages from RabbitMQ.\n while True:\n chan.wait()","def handle_get(self, api, command):\n return self._make_request_from_command('GET', command)","async def retrieve(self, msg_id: int):\n if not self._session:\n await self._create_session()\n \n raise NotImplementedError","def get(self, block=True, timeout=None):\n return self.queue.get(block, timeout)","def get(self, name):\n self.connect()\n self._write('GET %s\\r\\n' % name)\n return self._get_value()","def get(self) -> Optional[Message]:\n self._recv()\n if not self.inq:\n return None\n return self.inq.popleft()","def get(self, block=True, timeout=None):\n if block and timeout is None:\n self.message = self.handle.read(wait_time_seconds=20)\n while self.message is None:\n self.message = self.handle.read(wait_time_seconds=20)\n elif block and 1 <= timeout <= 20:\n self.message = self.handle.read(wait_time_seconds=timeout)\n elif not block and timeout is None:\n self.message = self.handle.read(wait_time_seconds=0)\n else:\n raise Exception('invalid arguments')\n if self.message is None:\n raise Empty\n return self.message.get_body()","def _get_message(self, block=True, timeout=0.1, get_partition_info=None,\n update_offset=True):\n if self.got_error:\n raise self.error\n try:\n meta, message = self.queue.get(timeout=timeout)\n\n if update_offset:\n # Update partition offset\n self.offsets[meta.partition] = message.offset + 1\n\n # Count, check and commit messages if necessary\n self.count_since_commit += 1\n self._auto_commit()\n\n if get_partition_info is None:\n get_partition_info = self.partition_info\n if get_partition_info:\n return meta, message\n else:\n return message\n except Empty:\n return None","def get(self):\n try:\n return self.url_queue.get(timeout=self.timeout)\n except Exception as e:\n print(e)\n return None","def _get_message(self):\n if not self.opened: return None\n \n # Remove from link buffer\n msg = None\n logger.debug(\"%s: Loop-back port read started...\" % \\\n self.__class__.__name__)\n try:\n msg = messages.HorizonMessage(raw = self._link.get(block=False),\n payload_type = payloads.HorizonPayload,\n store_error = True)\n except queue.Empty:\n msg = None\n logger.debug(\"%s: ...loop-back port read complete.\" % \\\n self.__class__.__name__)\n \n if msg != None:\n logger.info(\"%s: Message of %d bytes found:\\n%s\" % (\n self.__class__.__name__, len(msg.data), \n ' '.join(map(utils.hex,msg.data))))\n return msg","def get_req(self, path):\n \n res = self.client.get(path)\n return res","def request(self, method, command, payload):\n if method not in [METHOD_GET]:\n raise ValueError('Invalid method {0}, must be one of METHOD_* constants'.format(method))\n\n if command not in [COMMAND_UIC, COMMAND_CPM]:\n raise ValueError('Invalid command {0}, must be one of COMMAND_* constants'.format(method))\n\n url = '{0}/{1}?cmd={2}'.format(self._endpoint, command, urllib.parse.quote(payload))\n headers = {\n 'mobileUUID': self._user,\n 'mobileName': 'Wireless Audio',\n 'mobileVersion': '1.0',\n }\n\n try:\n _LOGGER.debug('Request %s. Raw payload %s', url, payload)\n response = requests.get(url, headers=headers, timeout=self._timeout)\n\n return self._parse_response_text(response.text)\n except requests.exceptions.RequestException as request_exception:\n _LOGGER.error('Request %s failed', url, exc_info=1)\n raise SamsungMultiroomApiException('Request {0} failed'.format(url)) from request_exception","def read_raw(self):\n resp = self._client.get(self._topic, timeout=self._timeout)\n\n # XXX: when client closes the last response is a NoneType\n if resp is None:\n raise IOError(\"client shutting down...\")\n elif coap_response_success(resp):\n return resp.payload\n else:\n raise IOError(\"CoAP response bad: %s\" % resp)","async def get(self):\n destination = (self.replica.ip,self.replica.port)\n await self.sock.sendto(self._req(), destination)\n while True:\n reply, _ = await self.sock.recvfrom(MAX_MSG_SIZE)\n assert 1 == reply[0]\n _, seq_num = struct.unpack(HEADER_FMT, reply[0:HEADER_SIZE])\n if seq_num == self.seq_num:\n return json.loads(reply[HEADER_SIZE:])","def read(self):\n if not self._consuming:\n yield from self._begin_consuming()\n return (yield from self._message_queue.get())","def make_iq_get(self, queryxmlns=None):\n return self.Iq()._set_stanza_values({'type': 'get',\n 'query': queryxmlns})","def get(queue_name: str, **kwargs) -> Queue:\n return Queue(queue_name, **kwargs)","def get( self ):\n return self.__to_message_function( self.__raw_payload )","def get_request(self, target_uri, resource_type, params=None):\n message, sc = self.request(target_uri, GET, params=params)\n operation = 'GET {resource_type}'.format(resource_type=resource_type)\n self.check_status_code_success(operation, sc, message)\n return message","def render_get(self, request):\n try:\n remote = request.remote[0]\n except TypeError:\n remote = request.remote.sockaddr[0]\n\n logger.debug(\"CoAP GET received from {}\".format(remote))\n\n return Message(code=CONTENT,\n payload=self._controller\n .get_latest_firmware_version(\n self._appid, self._slot).encode('ascii'))","def get_pending_messages():\n global logger\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n msg = \"exception 1 in connecting\"\n logger.debug(msg)\n # print(msg)\n time.sleep(3)\n try:\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\n except:\n logger.debug(msg+\" for the second time\")\n return -1\n channel = connection.channel()\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\n num = queue.method.message_count\n connection.close()\n return num","def send_rabbit_message (params ):\n print \"sending message to rabbitmq exchange\"\n logging.basicConfig()\n rabbitmq_host = params.get( 'host' )\n rabbitmq_port = params.get( 'port' )\n rabbitmq_username = params.get( 'user-name' )\n rabbitmq_password = params.get( 'password' )\n exchange_name = params.get( 'exchange' )\n routing_key = params.get( 'routing' )\n message = params.get( 'message' )\n \n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\n amqp_url = str(amqp_url)\n parameters = pika.URLParameters(amqp_url)\n connection = pika.BlockingConnection(parameters)\n channel = connection.channel()\n \n channel.basic_publish(exchange=exchange_name,routing_key=routing_key,body=message)\n ## close connection at the end \n connection.close()","def get_client() -> RabbitmqClient:\n # Replace the parameters with proper values for host, port, login and password\n # Change the value of exchange if needed.\n #\n # For any parameter that is not given here, the client tries to use a value from an environment variable\n # and most of the parameters also have a default value that is used if neither the constructor parameter\n # nor the environmental variable exist.\n # See tools/clients.py for details about the environmental variables and the default values.\n return RabbitmqClient(\n host=\"\",\n port=0,\n login=\"\",\n password=\"\",\n exchange=\"procem.examples_testing\",\n ssl=True,\n ssl_version=\"PROTOCOL_TLS\",\n exchange_autodelete=True,\n exchange_durable=False\n )","def _get_rabbit_connection_info(queue_key):\n\n\tif consul_server == \"127.0.0.1\":\n\t\treturn \"Consul server is set to 127.0.0.1\", None\n\tlook_for_service_name = \"docker-rabbitmq-5672\"\n\tfound_service = config_manager.discover_service(consul_server, look_for_service_name)\n\tif found_service.__class__.__name__ not in (\"list\", \"tuple\"):\n\t\treturn \"Service class not in expected format\", None\n\tif len(found_service) == 0:\n\t\treturn \"No services found for `%s`\" % look_for_service_name, None\n\n\trabbitmq_host = found_service[0][\"Address\"]\n\trabbitmq_port = int(found_service[0][\"ServicePort\"])\n\n\tconfig_arr = config_manager.get_config(consul_server, [queue_key, \"rabbitmq_user\", \"rabbitmq_pass\"])\n\trabbit_username = config_arr[0][\"rabbitmq_user\"]\n\trabbit_password = config_arr[0][\"rabbitmq_pass\"]\n\n\ttry:\n\t\tcredentials = pika.PlainCredentials(rabbit_username, rabbit_password)\n\t\tparameters = pika.ConnectionParameters(rabbitmq_host, rabbitmq_port, \"/\", credentials,\n\t\t heartbeat=0, blocked_connection_timeout=None)\n\t\tconnection = pika.BlockingConnection(parameters)\n\t\treturn None, connection\n\texcept Exception, ex:\n\t\treturn traceback.print_exc(), None","def get(ctx, key):\n config = buildConfig(ctx.obj[\"HOST\"], ctx.obj[\"PORT\"])\n client = getClient(config)\n click.echo(client.get(key))","def fusion_api_get_rabbitmq_client_certificate(self, param='', api=None, headers=None):\n return self.rabmq.get(param=param, api=api, headers=headers)","def request_msg(self, method, path, data=None, headers=None, **kwargs):\n return self._request(method, path, data=data, headers=headers,\n **kwargs)","def query(self):\n return self.msg","def GetMessage(service, user_id, msg_id):\n try:\n message = service.users().messages().get(userId=user_id, id=msg_id,format='raw').execute()\n msg_str = base64.urlsafe_b64decode(message['raw'].encode('ASCII'))\n mime_msg = email.message_from_string(msg_str)\n data = {}\n data['to'] = mime_msg['To']\n data['from'] = mime_msg['From']\n data['date'] = mime_msg['Date']\n data['subject'] = mime_msg['Subject']\n data['message'] = \"\"\n return data\n except errors.HttpError as error:\n print('An error occurred: %s' % error)","def request_and_show(self, verb, path, body=None):\n path = '%s%s' % (self.prefix, path.lstrip('/'))\n try:\n if body is None: self.conn.request(verb, path)\n else: self.conn.request(verb, path, body)\n except socket.error, e:\n print 'Cannot request %r %r: %s' % (verb, path, e)\n sys.exit(1)\n rl = self.conn.getresponse()\n if self.verbose or rl.status//100 != 2:\n print '%s %s gave: %s %r' % (verb, path, rl.status, rl.reason)\n if rl.status//100 == 2:\n if self.verbose:\n print 'HEADERS:'\n for h, v in rl.getheaders(): print ' ', h, v\n print 'CONTENTS:'\n body = rl.read()\n if self.verbose:\n for line in body.splitlines():\n print ' ', line\n print\n return simplejson.loads(body)\n else:\n return None","def show(self, req, id):\n context = req.environ['manila.context']\n\n try:\n message = self.message_api.get(context, id)\n except exception.MessageNotFound as error:\n raise exc.HTTPNotFound(explanation=error.msg)\n\n return self._view_builder.detail(req, message)","def get(self, block=True, timeout=None):\n return self.q.get(block, timeout)","def get_queue(queue_name=\"\"):\n print(get_qstat_arg(queue_name))\n q = subprocess.Popen(\n _get_qstat_arg(queue_name), stdout=subprocess.PIPE,\n stderr=subprocess.PIPE, stdin=subprocess.PIPE\n )\n o, e = q.communicate()\n\n return o","def get(self):\n\t\ttry:\n\t\t\tself.logger.debug('Im trying to get item from queue')\n\t\t\titem = self.queue.get()\n\t\t\tself.logger.debug('Recevie item from queue %s'%(item))\n\t\t\treturn True, item\n\t\texcept Exception, e:\n\t\t\tself.logger.error('Error method get, error: %s'%(e),exc_info=True)\n\t\t\treturn False, None","def get(self) -> Any:\n return self._queue.get()","def read_queue():\n with open(\"config.json\") as f:\n config = json.load(f)\n \n cpars = pika.ConnectionParameters(host=config[\"cage_daq\"])\n connection = pika.BlockingConnection(cpars)\n channel = connection.channel()\n\n channel.exchange_declare(exchange=config[\"exchange\"], exchange_type='topic')\n \n channel.queue_declare(queue=config[\"queue\"], exclusive=True)\n \n channel.queue_bind(queue=config[\"queue\"], exchange=config[\"exchange\"], \n routing_key='sensor_value.#')\n \n channel.basic_consume(queue=config[\"queue\"], on_message_callback=callback, \n auto_ack=True)\n\n print(' [*] Waiting for messages. To exit press CTRL+C')\n channel.start_consuming()","def receive_message(self):\n return self.receive_message_queue.get()","def test_get_messages1(self):\n self.queue.direct_declare(TEST_QUEUE)\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\n\n messages = self.queue.get_messages(TEST_QUEUE, prefetch_count=1)\n assert len(messages) >= 1","def read_item(id: str, request: Request):\n obj = db.get(id, kind=endpoint_model)\n return obj","def render_get(self, request):\n try:\n remote = request.remote[0]\n except TypeError:\n remote = request.remote.sockaddr[0]\n\n logger.debug(\"CoAP GET received from {}\".format(remote))\n\n firmware_binary = self._controller.\\\n get_latest_firmware_binary(self._appid, self._slot)\n\n return Message(code=CONTENT, payload=firmware_binary)","def message():\n # Retrieve JSON parameters data.\n data = request.get_json() or {}\n data.update(dict(request.values))\n msg = data.get(\"msg\")\n if not msg:\n raise abort(400, \"missing 'msg' data\")\n\n # Deffer the message as a task.\n result = tasks.process_message.delay(msg, delta=10)\n task_id = result.task_id\n if not task_id or result.failed():\n raise abort(400, \"task failed\")\n # Then check and return ID.\n return {\n \"task_id\": result.id\n }","def ztest_get_item(self):\n \n queue = NMSQueue()\n \n result_set = queue.get_items_with_priority(1,1,0,1)\n \n for item in result_set:\n print(\"\\nItem = %s\\n\" % (item) )\n newitem = queue.get_item(item.uuid)\n print(\"\\nRetrieve the same from queue Item = %s\\n\" % (newitem) )","def handle_request_get(self, msg):\n\n\t\tfor arg in msg.arguments:\n\t\t\tmethod = {\n\t\t\t\t'ucr': self.handle_request_get_ucr,\n\t\t\t\t'meta': self.handle_request_get_meta,\n\t\t\t\t'info': self.handle_request_get_info,\n\t\t\t\t'modules/list': self.handle_request_get_modules,\n\t\t\t\t'modules': self.handle_request_get_modules,\n\t\t\t\t'categories/list': self.handle_request_get_categories,\n\t\t\t\t'categories': self.handle_request_get_categories,\n\t\t\t\t'user/preferences': self.handle_request_get_user_preferences,\n\t\t\t\t'hosts/list': self.handle_request_get_hosts,\n\t\t\t\t'hosts': self.handle_request_get_hosts,\n\t\t\t}.get(arg)\n\t\t\tif method:\n\t\t\t\tself.finished(msg.id, method(msg))\n\t\t\t\treturn\n\t\traise NotFound()","def pub(payload):\n print(payload)\n sys.stdout.flush()\n\n corr_id = pub.send_request(payload)\n r.lpushx(\"payload\", payload)\n\n\n while pub.queue[corr_id] is None:\n time.sleep(0.1)\n\n return pub.queue[corr_id]","def wait_for_messages(self):\n msg = self.inbox.get()\n return msg","def ask(self, message):\n\n self.write(message)\n\n if self.multi_command is None:\n return self.read()\n else:\n self.responses_expected += 1","def query(self, message: str) -> str:\n raise NotImplementedError()","def do_get(args):\n session = BMC(server=args.server, username=args.username, password=args.password)\n print(json.dumps(session.get(args.path), indent=4))","def _get(self, *args, **kwargs):\n return self._request('get', *args, **kwargs)","def get_object(self):\n # read the URL data values into variables\n astronaut_pk = self.kwargs['astronaut_pk']\n message_pk = self.kwargs['message_pk']\n\n # find the SendMessage object, and return it\n st_cfh = SendMessage.objects.get(pk=message_pk)\n return st_cfh","def get():","def get():"],"string":"[\n \"def get(self, msg):\\n\\n # print(\\\"get\\\")\\n self.q.put(msg)\",\n \"def rabbit_request(self, path):\\n uri = self._base_uri + path\\n response = requests.get(uri, auth=self._auth)\\n\\n if response.status_code != 200:\\n raise Exception(self.error_message(response))\\n return json.loads(response.content)\",\n \"def get_msg(self, my_queue):\\n self.channel.basic_qos(prefetch_count=COUNT)\\n try:\\n for method_frame, properties, body in self.channel.consume(my_queue):\\n self.channel.basic_ack(method_frame.delivery_tag)\\n return body\\n except pika.exceptions, err_msg:\\n log.error(err_msg)\\n return False\",\n \"def read(self):\\n method_frame, header_frame, body = self._channel.basic_get(self.name)\\n if method_frame:\\n pika_message = PikaMessage(body,\\n delivery_info=method_frame,\\n properties=header_frame,\\n )\\n return pika_message.to_message()\\n else:\\n return None\",\n \"def get_message_from_queue(self):\\n message = None, None\\n\\n try:\\n message = self.queue.get(block=True, timeout=3)\\n except Empty:\\n self.fail(msg='Queue get() failed empty')\\n\\n return message\",\n \"async def get(\\n self, *, no_ack: bool = False,\\n fail: bool = True, timeout: TimeoutType = 5,\\n ) -> Optional[IncomingMessage]:\\n\\n channel = await self.channel.get_underlay_channel()\\n msg: DeliveredMessage = await channel.basic_get(\\n self.name, no_ack=no_ack, timeout=timeout,\\n )\\n\\n if isinstance(msg.delivery, aiormq.spec.Basic.GetEmpty):\\n if fail:\\n raise QueueEmpty\\n return None\\n\\n return IncomingMessage(msg, no_ack=no_ack)\",\n \"def getMsg(self, time=None, msg=\\\"\\\"):\\n\\t\\ttry:\\n\\t\\t\\tr = self._queue.get(True, time)\\n\\t\\texcept Empty:\\n\\t\\t\\traise TimeoutException(\\\"%s.getMsg(timeout=%s,msg=%s)\\\"%(self,time,msg))\\n\\t\\telse:\\n\\t\\t\\tself._queue.task_done()\\n\\t\\t\\treturn r\",\n \"def consume_message(message):\\n # Assign the message to the global drone_message\\n global drone_message\\n drone_message = message\\n # The Rabbit mq runs in the localhost and the username , password is\\n # athavan\\n credentials = pika.PlainCredentials('guest', 'guest')\\n # Pass the mqhost , port , virtualhost and credentials\\n parameters = pika.ConnectionParameters('localhost', 5672, '/', credentials)\\n connection = pika.SelectConnection(parameters, on_connected)\\n try:\\n connection.ioloop.start()\\n except KeyboardInterrupt:\\n # close the connnection\\n connection.close()\\n # loop until we are fully closed. It will stop on its own\\n connection.ioloop.start()\",\n \"def fetch_job_from_queue(self):\\n while 1:\\n time.sleep(2)\\n try:\\n credentials = pika.PlainCredentials('USER', 'PASSWORD')\\n connection = pika.BlockingConnection(pika.ConnectionParameters('rabbitmq', 5672, '/', credentials))\\n channel = connection.channel()\\n channel.queue_declare(queue='purserq')\\n method_frame, header_frame, body = channel.basic_get(queue='purserq')\\n if method_frame.NAME == 'Basic.GetEmpty':\\n connection.close()\\n else:\\n channel.basic_ack(delivery_tag=method_frame.delivery_tag)\\n print \\\"Received job:\\\", body, \\\"starting job to reply\\\"\\n connection.close()\\n self.reply_to_master(body)\\n except AttributeError:\\n print \\\"No content\\\"\\n connection.close()\\n except pika.exceptions.ConnectionClosed:\\n print \\\"You get Connection Closed\\\"\\n continue\",\n \"def get_message(agentIdPath, messageIdPath): # noqa: E501\\n keys = [\\\"id:\\\"+messageIdPath]\\n result = multichain_client.liststreamqueryitems (agentIdPath, keys, verbose)\\n print(result)\\n print(type(result))\\n j_result = json.loads(result);\\n print(j_result)\\n print(type(j_result))\\n if j_result[\\\"error\\\"] is None:\\n if len(j_result[\\\"result\\\"])>0:\\n return j_result[\\\"result\\\"][0][\\\"data\\\"][\\\"json\\\"]\\n else:\\n return Response(status=404, mimetype='application/json')\\n else:\\n return Response(status=500, mimetype='application/json')\",\n \"def test_get_message(self):\\n response = self.client.open(\\n '/api/rtx/v1/message/{message_id}'.format(message_id=56),\\n method='GET')\\n self.assert200(response,\\n 'Response body is : ' + response.data.decode('utf-8'))\",\n \"async def Read(self) -> Optional[Message]:\\n return await self._read_queue.Get()\",\n \"def get_message(cls):\\n rp = cls.get()\\n try:\\n message = rp.queue_send.get_nowait()\\n except Exception:\\n return None\\n\\n return message\",\n \"def get_msg(self, block=True, timeout=None):\\n return self.in_queue.get(block, timeout)\",\n \"def get_msg(self, block=True, timeout=None):\\n return self.in_queue.get(block, timeout)\",\n \"def GetApiMessage(message_name):\\n messages = apis.GetMessagesModule(_BQ_API, _BQ_API_VERSION)\\n return getattr(messages, message_name)\",\n \"def test_basic():\\n client = CloudAMQPClient(CLOUDAMQP_URL, TEST_QUEUE_NAME)\\n send_msg = {'test': 'ans'}\\n client.send_message(send_msg)\\n received_msg = client.get_message()\\n assert send_msg == received_msg\\n print 'test_basic() passed'\",\n \"def get_message(self, message_id: int) -> discord.Message:\\n return self._connection._get_message(message_id)\",\n \"def get(self, id):\\n return read_msg(id)\",\n \"def query(self):\\n self.bus.write('@\\\\x51\\\\r\\\\n')\\n response = self.bus.read(23)\\n return response\",\n \"def GetMessage(service, user_id, msg_id):\\n try:\\n message = service.users().messages().get(userId=user_id, id=msg_id).execute()\\n\\n return message\\n except errors.HttpError:\\n print('An error occurred: ')\",\n \"def receive_message(request):\\n message_id = request.GET.get('message_id')\\n message = Message.objects.get(pk=message_id)\\n return Response({'message': message})\",\n \"async def fetch_message(ctx: commands.Context, message_id: int) -> discord.Message:\\r\\n try:\\r\\n msg = await ctx.fetch_message(message_id)\\r\\n except discord.NotFound:\\r\\n raise CommandError(f\\\"Cannot find message with ID `{message_id}`!\\\")\\r\\n except discord.Forbidden:\\r\\n raise CommandError(\\\"Lacking permissions to fetch message!\\\")\\r\\n except discord.HTTPException:\\r\\n raise CommandError(\\\"Failed to retrieve message. Try again later!\\\")\\r\\n else:\\r\\n return msg\",\n \"def pull(self):\\n \\n data = self.s.recv(1024)\\n if data:\\n info = json.loads(data.decode()) \\n print(\\\"DATA FROM BROKER : \\\", info)\\n \\n return info.get(\\\"topic\\\"), info.get(\\\"value\\\")\\n pass\",\n \"def query(self, message):\\n return self.device.query(message)\",\n \"def get(self):\\r\\n try:\\r\\n # get with block=False returns an item if one\\r\\n # is immediately available, else raises the Empty exception\\r\\n return self._queue.get(block=False)\\r\\n except queue.Empty:\\r\\n return self._create_connection()\",\n \"def message(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'message')\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def get(self):\\n return dumps(AQ.queue()), 200\",\n \"def get_message():\\n\\tincoming_message = conn.recv(1024)\\n\\tincoming_message = incoming_message.decode()\\n\\treturn incoming_message\",\n \"def GetMessage(service, user_id, msg_id):\\n try:\\n #take out format='raw' if don't want base64\\n message = service.users().messages().get(userId=user_id, id=msg_id, format='raw').execute()\\n\\n print('Message snippet: %s' % message['snippet'])\\n\\n return message\\n except errors.HttpError, error:\\n print('An error occurred: %s' % error)\",\n \"def getMessage(self, queue_name, max=None, project_id=None):\\n if project_id is None:\\n project_id = self.project_id\\n n = \\\"\\\"\\n if max is not None:\\n n = \\\"&n=%s\\\" % max\\n url = \\\"%sprojects/%s/queues/%s/messages?oauth=%s%s\\\" % (self.url,\\n project_id, queue_name, self.token, n)\\n body = self.__get(url)\\n\\n return json.loads(body)\",\n \"def read(self) -> requests.request:\\n # Check if id is set,\\n if self.args.id is not None:\\n self.REQUEST_URL += str(self.args.id)\\n\\n # Send GET request\\n return requests.get(self.REQUEST_URL)\",\n \"def api_getmessage():\\n message = receive_lyrics()\\n if message != \\\"\\\":\\n return jsonify(ready=True, msg=message)\\n else:\\n return jsonify(ready=False)\",\n \"def _get(self, path=None, version=None, params=None,\\n header=None):\\n return self.client.get(module='mam', path=path,\\n version=version, params=params, header=header)\",\n \"def get(self, message = None, wait = 2):\\n # Verify if sonar is initialized\\n if not self.initialized:\\n raise SonarNotConfigured\\n\\n expected_name = Message.to_string(message)\\n if message:\\n rospy.logdebug(\\\"Waiting for %s message\\\", expected_name)\\n else:\\n rospy.logdebug(\\\"Waiting for unlabeled message\\\")\\n\\n # Determine end time\\n end = datetime.datetime.now() + datetime.timedelta(seconds=wait)\\n\\n # Wait until received if a specific message ID is requested, otherwise wait forever\\n while message is None or datetime.datetime.now() < end:\\n if message is None:\\n try:\\n reply = self.conn.get_reply()\\n return reply\\n except:\\n break\\n else:\\n try:\\n reply = self.conn.get_reply(message)\\n except:\\n break\\n # Verify reply ID if requested\\n if reply.id == message:\\n #rospy.logdebug(\\\"Found %s message\\\", expected_name)\\n return reply\\n else:\\n rospy.logwarn(\\\"Received unexpected %s message\\\", reply.name)\\n # Timeout\\n rospy.logerr(\\\"Timed out before receiving message: %s\\\", expected_name)\\n raise TimeoutError()\",\n \"def get_message(self, message_id):\\n req_data = [ str(message_id) ]\\n return self.request(\\\"find:Message.stats, Message.content\\\", req_data)\",\n \"def get_msg(self, timeout_in_seconds=-1):\\n return self._client.get_msg(timeout_in_seconds)\",\n \"def get_message(self, message_id):\\n res = requests.get(url=\\\"https://api.ciscospark.com/v1/messages/{}\\\".format(message_id),\\n headers=self.headers)\\n\\n try:\\n text = res.json()['text']\\n except AttributeError as e:\\n print(res.text)\\n return None\\n\\n return text\",\n \"def pop_message(self, queue_name):\\r\\n messages = self.pop_messages(queue_name, count=1)\\r\\n if messages['item_count'] > 0:\\r\\n return messages['items'][0]\\r\\n else:\\r\\n return None\",\n \"def get(self,cmd,ch,async_mode):\\n comString = cmd + str(ch) + \\\"?\\\\n\\\"\\n if async_mode == 'QUERY':\\n self.query_async(comString)\\n return\\n if async_mode == 'REPLY':\\n try:\\n return self.truncate_float_reply(self.get_async_response(comString))\\n except ValueError:\\n #print('a')\\n return 'EMPTY'\",\n \"async def method_get(\\n self,\\n request: Request,\\n body: dict,\\n session: DBSession,\\n message_id: int,\\n token: dict,\\n *args,\\n **kwargs,\\n ) -> BaseHTTPResponse:\\n try:\\n db_message = get_message_by_id(session, message_id=message_id)\\n except DBMessageNotExists as e:\\n raise NotFound(f\\\"Message {message_id} not found\\\") from e\\n\\n if token[\\\"sub\\\"] not in (db_message.sender_id, db_message.recipient_id):\\n raise Forbidden(\\\"user is not recipient or sender\\\")\\n\\n response_model = ResponseMessageDto(db_message)\\n\\n return await self.make_response_json(status=200, body=response_model.dump())\",\n \"def get_message_by_id(message_id):\\n return Message.query.get(message_id)\",\n \"async def fetch_message(self, channel_id: int, message_id: int) -> discord.Message:\\n channel: discord.TextChannel = self.get_channel(channel_id)\\n return await channel.fetch_message(message_id)\",\n \"def get(self, block=True, timeout=None):\\n if block:\\n message = self.redis.blpop(self.queue, timeout=timeout)\\n else:\\n message = self.redis.lpop(self.queue)\\n\\n parsed_message = self.parse(message[1])\\n return parsed_message\",\n \"def consumeMsg():\\n\\tosuser = 'osdev'\\n\\tospass = 'osdev'\\n\\toshost = '10.32.29.94'\\n\\tosport = '5672'\\n\\tosvhost = '/openstack'\\n\\tneutronExchange = Exchange('quantum', type='topic', durable=False)\\n\\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\\n\\t\\t\\trouting_key='notifications.info')\\n\\twith Connection(\\\"\\\".join(['amqp://', osuser, ':', ospass, '@', \\n\\t\\toshost, ':',osport, '/', osvhost])) as conn:\\n\\t\\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\ttry: \\n\\t\\t\\t\\t\\tconn.drain_events()\\n\\t\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\t\\tlogging.exception('Draining events from AMQP stop')\\n\\t\\t\\t\\t\\tbreak\",\n \"def GetMessage(service, user_id, msg_id, snippetMessage=True):\\n try:\\n message = service.users().messages().get(userId=user_id, id=msg_id).execute()\\n #print('Message snippet: %s' % message['snippet'])\\n #print('Message snippet: %s' % message['payload']['headers'])\\n #print(unicode('Message snippet: %s' % message['snippet'],'utf-8'))\\n\\n if snippetMessage:\\n return message['snippet']\\n else:\\n return message\\n except errors.HttpError, error:\\n print('An error occurred: %s' % error)\",\n \"async def get_msg(self):\\n try:\\n # 2^8 bytes at a time. I just like it, no special reason\\n data = await self.reader.read(256)\\n msg = data.decode()\\n addr = writer.get_extra_info(\\\"peername\\\")\\n logging.info(\\\"Received %s from %s\\\", (msg, addr))\\n\\n except Exception as e:\\n logging.error(\\\"Command could not be decoded; %s\\\", e)\\n\\n return msg\",\n \"def get_message(request):\\r\\n message_key = request.GET.get('message', None)\\r\\n message = None\\r\\n message_type = None\\r\\n\\r\\n if ((not message_key or message_key == 'upload_success') and\\r\\n QIFParser.get_status() == 'in_progress'):\\r\\n message_key = 'in_progress_quicken_file'\\r\\n\\r\\n try:\\r\\n message = Message.MESSAGES[message_key]\\r\\n message_type = message['type']\\r\\n message = message['message']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n return {'message': message,\\r\\n 'message_key': message_key,\\r\\n 'message_type': message_type}\",\n \"def consume():\\n with conn.channel() as chan:\\n \\n def on_msg_recv(msg):\\n \\\"\\\"\\\" Called when message arrives from RabbitMQ\\n \\\"\\\"\\\"\\n print \\\"processor|%s::Received message: %s\\\" % (UID, msg.body)\\n chan.basic_ack(msg.delivery_tag)\\n log(msg.body)\\n process_msg(msg)\\n \\n \\n # Declare and bind queue. RabbitMQ does nothing if queue already exists.\\n chan.exchange_declare(exchange = EXCHANGE,\\n type = EXCHANGE_TYPE)\\n queue = chan.queue_declare(QUEUE)\\n chan.queue_bind(exchange = EXCHANGE, \\n queue = QUEUE, \\n routing_key = ROUTING_KEY)\\n \\n # Declare that we are going to listen to given queue\\n chan.basic_consume(queue = QUEUE, \\n callback = on_msg_recv)\\n \\n # Main loop. Waiting for messages from RabbitMQ.\\n while True:\\n chan.wait()\",\n \"def handle_get(self, api, command):\\n return self._make_request_from_command('GET', command)\",\n \"async def retrieve(self, msg_id: int):\\n if not self._session:\\n await self._create_session()\\n \\n raise NotImplementedError\",\n \"def get(self, block=True, timeout=None):\\n return self.queue.get(block, timeout)\",\n \"def get(self, name):\\n self.connect()\\n self._write('GET %s\\\\r\\\\n' % name)\\n return self._get_value()\",\n \"def get(self) -> Optional[Message]:\\n self._recv()\\n if not self.inq:\\n return None\\n return self.inq.popleft()\",\n \"def get(self, block=True, timeout=None):\\n if block and timeout is None:\\n self.message = self.handle.read(wait_time_seconds=20)\\n while self.message is None:\\n self.message = self.handle.read(wait_time_seconds=20)\\n elif block and 1 <= timeout <= 20:\\n self.message = self.handle.read(wait_time_seconds=timeout)\\n elif not block and timeout is None:\\n self.message = self.handle.read(wait_time_seconds=0)\\n else:\\n raise Exception('invalid arguments')\\n if self.message is None:\\n raise Empty\\n return self.message.get_body()\",\n \"def _get_message(self, block=True, timeout=0.1, get_partition_info=None,\\n update_offset=True):\\n if self.got_error:\\n raise self.error\\n try:\\n meta, message = self.queue.get(timeout=timeout)\\n\\n if update_offset:\\n # Update partition offset\\n self.offsets[meta.partition] = message.offset + 1\\n\\n # Count, check and commit messages if necessary\\n self.count_since_commit += 1\\n self._auto_commit()\\n\\n if get_partition_info is None:\\n get_partition_info = self.partition_info\\n if get_partition_info:\\n return meta, message\\n else:\\n return message\\n except Empty:\\n return None\",\n \"def get(self):\\n try:\\n return self.url_queue.get(timeout=self.timeout)\\n except Exception as e:\\n print(e)\\n return None\",\n \"def _get_message(self):\\n if not self.opened: return None\\n \\n # Remove from link buffer\\n msg = None\\n logger.debug(\\\"%s: Loop-back port read started...\\\" % \\\\\\n self.__class__.__name__)\\n try:\\n msg = messages.HorizonMessage(raw = self._link.get(block=False),\\n payload_type = payloads.HorizonPayload,\\n store_error = True)\\n except queue.Empty:\\n msg = None\\n logger.debug(\\\"%s: ...loop-back port read complete.\\\" % \\\\\\n self.__class__.__name__)\\n \\n if msg != None:\\n logger.info(\\\"%s: Message of %d bytes found:\\\\n%s\\\" % (\\n self.__class__.__name__, len(msg.data), \\n ' '.join(map(utils.hex,msg.data))))\\n return msg\",\n \"def get_req(self, path):\\n \\n res = self.client.get(path)\\n return res\",\n \"def request(self, method, command, payload):\\n if method not in [METHOD_GET]:\\n raise ValueError('Invalid method {0}, must be one of METHOD_* constants'.format(method))\\n\\n if command not in [COMMAND_UIC, COMMAND_CPM]:\\n raise ValueError('Invalid command {0}, must be one of COMMAND_* constants'.format(method))\\n\\n url = '{0}/{1}?cmd={2}'.format(self._endpoint, command, urllib.parse.quote(payload))\\n headers = {\\n 'mobileUUID': self._user,\\n 'mobileName': 'Wireless Audio',\\n 'mobileVersion': '1.0',\\n }\\n\\n try:\\n _LOGGER.debug('Request %s. Raw payload %s', url, payload)\\n response = requests.get(url, headers=headers, timeout=self._timeout)\\n\\n return self._parse_response_text(response.text)\\n except requests.exceptions.RequestException as request_exception:\\n _LOGGER.error('Request %s failed', url, exc_info=1)\\n raise SamsungMultiroomApiException('Request {0} failed'.format(url)) from request_exception\",\n \"def read_raw(self):\\n resp = self._client.get(self._topic, timeout=self._timeout)\\n\\n # XXX: when client closes the last response is a NoneType\\n if resp is None:\\n raise IOError(\\\"client shutting down...\\\")\\n elif coap_response_success(resp):\\n return resp.payload\\n else:\\n raise IOError(\\\"CoAP response bad: %s\\\" % resp)\",\n \"async def get(self):\\n destination = (self.replica.ip,self.replica.port)\\n await self.sock.sendto(self._req(), destination)\\n while True:\\n reply, _ = await self.sock.recvfrom(MAX_MSG_SIZE)\\n assert 1 == reply[0]\\n _, seq_num = struct.unpack(HEADER_FMT, reply[0:HEADER_SIZE])\\n if seq_num == self.seq_num:\\n return json.loads(reply[HEADER_SIZE:])\",\n \"def read(self):\\n if not self._consuming:\\n yield from self._begin_consuming()\\n return (yield from self._message_queue.get())\",\n \"def make_iq_get(self, queryxmlns=None):\\n return self.Iq()._set_stanza_values({'type': 'get',\\n 'query': queryxmlns})\",\n \"def get(queue_name: str, **kwargs) -> Queue:\\n return Queue(queue_name, **kwargs)\",\n \"def get( self ):\\n return self.__to_message_function( self.__raw_payload )\",\n \"def get_request(self, target_uri, resource_type, params=None):\\n message, sc = self.request(target_uri, GET, params=params)\\n operation = 'GET {resource_type}'.format(resource_type=resource_type)\\n self.check_status_code_success(operation, sc, message)\\n return message\",\n \"def render_get(self, request):\\n try:\\n remote = request.remote[0]\\n except TypeError:\\n remote = request.remote.sockaddr[0]\\n\\n logger.debug(\\\"CoAP GET received from {}\\\".format(remote))\\n\\n return Message(code=CONTENT,\\n payload=self._controller\\n .get_latest_firmware_version(\\n self._appid, self._slot).encode('ascii'))\",\n \"def get_pending_messages():\\n global logger\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n msg = \\\"exception 1 in connecting\\\"\\n logger.debug(msg)\\n # print(msg)\\n time.sleep(3)\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(rabbit_host))\\n except:\\n logger.debug(msg+\\\" for the second time\\\")\\n return -1\\n channel = connection.channel()\\n queue = channel.queue_declare(queue=queue_name, durable=True, auto_delete=False)\\n num = queue.method.message_count\\n connection.close()\\n return num\",\n \"def send_rabbit_message (params ):\\n print \\\"sending message to rabbitmq exchange\\\"\\n logging.basicConfig()\\n rabbitmq_host = params.get( 'host' )\\n rabbitmq_port = params.get( 'port' )\\n rabbitmq_username = params.get( 'user-name' )\\n rabbitmq_password = params.get( 'password' )\\n exchange_name = params.get( 'exchange' )\\n routing_key = params.get( 'routing' )\\n message = params.get( 'message' )\\n \\n amqp_url='amqp://'+rabbitmq_username+':'+rabbitmq_password+'@'+rabbitmq_host+':'+rabbitmq_port+'/%2f'\\n amqp_url = str(amqp_url)\\n parameters = pika.URLParameters(amqp_url)\\n connection = pika.BlockingConnection(parameters)\\n channel = connection.channel()\\n \\n channel.basic_publish(exchange=exchange_name,routing_key=routing_key,body=message)\\n ## close connection at the end \\n connection.close()\",\n \"def get_client() -> RabbitmqClient:\\n # Replace the parameters with proper values for host, port, login and password\\n # Change the value of exchange if needed.\\n #\\n # For any parameter that is not given here, the client tries to use a value from an environment variable\\n # and most of the parameters also have a default value that is used if neither the constructor parameter\\n # nor the environmental variable exist.\\n # See tools/clients.py for details about the environmental variables and the default values.\\n return RabbitmqClient(\\n host=\\\"\\\",\\n port=0,\\n login=\\\"\\\",\\n password=\\\"\\\",\\n exchange=\\\"procem.examples_testing\\\",\\n ssl=True,\\n ssl_version=\\\"PROTOCOL_TLS\\\",\\n exchange_autodelete=True,\\n exchange_durable=False\\n )\",\n \"def _get_rabbit_connection_info(queue_key):\\n\\n\\tif consul_server == \\\"127.0.0.1\\\":\\n\\t\\treturn \\\"Consul server is set to 127.0.0.1\\\", None\\n\\tlook_for_service_name = \\\"docker-rabbitmq-5672\\\"\\n\\tfound_service = config_manager.discover_service(consul_server, look_for_service_name)\\n\\tif found_service.__class__.__name__ not in (\\\"list\\\", \\\"tuple\\\"):\\n\\t\\treturn \\\"Service class not in expected format\\\", None\\n\\tif len(found_service) == 0:\\n\\t\\treturn \\\"No services found for `%s`\\\" % look_for_service_name, None\\n\\n\\trabbitmq_host = found_service[0][\\\"Address\\\"]\\n\\trabbitmq_port = int(found_service[0][\\\"ServicePort\\\"])\\n\\n\\tconfig_arr = config_manager.get_config(consul_server, [queue_key, \\\"rabbitmq_user\\\", \\\"rabbitmq_pass\\\"])\\n\\trabbit_username = config_arr[0][\\\"rabbitmq_user\\\"]\\n\\trabbit_password = config_arr[0][\\\"rabbitmq_pass\\\"]\\n\\n\\ttry:\\n\\t\\tcredentials = pika.PlainCredentials(rabbit_username, rabbit_password)\\n\\t\\tparameters = pika.ConnectionParameters(rabbitmq_host, rabbitmq_port, \\\"/\\\", credentials,\\n\\t\\t heartbeat=0, blocked_connection_timeout=None)\\n\\t\\tconnection = pika.BlockingConnection(parameters)\\n\\t\\treturn None, connection\\n\\texcept Exception, ex:\\n\\t\\treturn traceback.print_exc(), None\",\n \"def get(ctx, key):\\n config = buildConfig(ctx.obj[\\\"HOST\\\"], ctx.obj[\\\"PORT\\\"])\\n client = getClient(config)\\n click.echo(client.get(key))\",\n \"def fusion_api_get_rabbitmq_client_certificate(self, param='', api=None, headers=None):\\n return self.rabmq.get(param=param, api=api, headers=headers)\",\n \"def request_msg(self, method, path, data=None, headers=None, **kwargs):\\n return self._request(method, path, data=data, headers=headers,\\n **kwargs)\",\n \"def query(self):\\n return self.msg\",\n \"def GetMessage(service, user_id, msg_id):\\n try:\\n message = service.users().messages().get(userId=user_id, id=msg_id,format='raw').execute()\\n msg_str = base64.urlsafe_b64decode(message['raw'].encode('ASCII'))\\n mime_msg = email.message_from_string(msg_str)\\n data = {}\\n data['to'] = mime_msg['To']\\n data['from'] = mime_msg['From']\\n data['date'] = mime_msg['Date']\\n data['subject'] = mime_msg['Subject']\\n data['message'] = \\\"\\\"\\n return data\\n except errors.HttpError as error:\\n print('An error occurred: %s' % error)\",\n \"def request_and_show(self, verb, path, body=None):\\n path = '%s%s' % (self.prefix, path.lstrip('/'))\\n try:\\n if body is None: self.conn.request(verb, path)\\n else: self.conn.request(verb, path, body)\\n except socket.error, e:\\n print 'Cannot request %r %r: %s' % (verb, path, e)\\n sys.exit(1)\\n rl = self.conn.getresponse()\\n if self.verbose or rl.status//100 != 2:\\n print '%s %s gave: %s %r' % (verb, path, rl.status, rl.reason)\\n if rl.status//100 == 2:\\n if self.verbose:\\n print 'HEADERS:'\\n for h, v in rl.getheaders(): print ' ', h, v\\n print 'CONTENTS:'\\n body = rl.read()\\n if self.verbose:\\n for line in body.splitlines():\\n print ' ', line\\n print\\n return simplejson.loads(body)\\n else:\\n return None\",\n \"def show(self, req, id):\\n context = req.environ['manila.context']\\n\\n try:\\n message = self.message_api.get(context, id)\\n except exception.MessageNotFound as error:\\n raise exc.HTTPNotFound(explanation=error.msg)\\n\\n return self._view_builder.detail(req, message)\",\n \"def get(self, block=True, timeout=None):\\n return self.q.get(block, timeout)\",\n \"def get_queue(queue_name=\\\"\\\"):\\n print(get_qstat_arg(queue_name))\\n q = subprocess.Popen(\\n _get_qstat_arg(queue_name), stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE, stdin=subprocess.PIPE\\n )\\n o, e = q.communicate()\\n\\n return o\",\n \"def get(self):\\n\\t\\ttry:\\n\\t\\t\\tself.logger.debug('Im trying to get item from queue')\\n\\t\\t\\titem = self.queue.get()\\n\\t\\t\\tself.logger.debug('Recevie item from queue %s'%(item))\\n\\t\\t\\treturn True, item\\n\\t\\texcept Exception, e:\\n\\t\\t\\tself.logger.error('Error method get, error: %s'%(e),exc_info=True)\\n\\t\\t\\treturn False, None\",\n \"def get(self) -> Any:\\n return self._queue.get()\",\n \"def read_queue():\\n with open(\\\"config.json\\\") as f:\\n config = json.load(f)\\n \\n cpars = pika.ConnectionParameters(host=config[\\\"cage_daq\\\"])\\n connection = pika.BlockingConnection(cpars)\\n channel = connection.channel()\\n\\n channel.exchange_declare(exchange=config[\\\"exchange\\\"], exchange_type='topic')\\n \\n channel.queue_declare(queue=config[\\\"queue\\\"], exclusive=True)\\n \\n channel.queue_bind(queue=config[\\\"queue\\\"], exchange=config[\\\"exchange\\\"], \\n routing_key='sensor_value.#')\\n \\n channel.basic_consume(queue=config[\\\"queue\\\"], on_message_callback=callback, \\n auto_ack=True)\\n\\n print(' [*] Waiting for messages. To exit press CTRL+C')\\n channel.start_consuming()\",\n \"def receive_message(self):\\n return self.receive_message_queue.get()\",\n \"def test_get_messages1(self):\\n self.queue.direct_declare(TEST_QUEUE)\\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\\n\\n messages = self.queue.get_messages(TEST_QUEUE, prefetch_count=1)\\n assert len(messages) >= 1\",\n \"def read_item(id: str, request: Request):\\n obj = db.get(id, kind=endpoint_model)\\n return obj\",\n \"def render_get(self, request):\\n try:\\n remote = request.remote[0]\\n except TypeError:\\n remote = request.remote.sockaddr[0]\\n\\n logger.debug(\\\"CoAP GET received from {}\\\".format(remote))\\n\\n firmware_binary = self._controller.\\\\\\n get_latest_firmware_binary(self._appid, self._slot)\\n\\n return Message(code=CONTENT, payload=firmware_binary)\",\n \"def message():\\n # Retrieve JSON parameters data.\\n data = request.get_json() or {}\\n data.update(dict(request.values))\\n msg = data.get(\\\"msg\\\")\\n if not msg:\\n raise abort(400, \\\"missing 'msg' data\\\")\\n\\n # Deffer the message as a task.\\n result = tasks.process_message.delay(msg, delta=10)\\n task_id = result.task_id\\n if not task_id or result.failed():\\n raise abort(400, \\\"task failed\\\")\\n # Then check and return ID.\\n return {\\n \\\"task_id\\\": result.id\\n }\",\n \"def ztest_get_item(self):\\n \\n queue = NMSQueue()\\n \\n result_set = queue.get_items_with_priority(1,1,0,1)\\n \\n for item in result_set:\\n print(\\\"\\\\nItem = %s\\\\n\\\" % (item) )\\n newitem = queue.get_item(item.uuid)\\n print(\\\"\\\\nRetrieve the same from queue Item = %s\\\\n\\\" % (newitem) )\",\n \"def handle_request_get(self, msg):\\n\\n\\t\\tfor arg in msg.arguments:\\n\\t\\t\\tmethod = {\\n\\t\\t\\t\\t'ucr': self.handle_request_get_ucr,\\n\\t\\t\\t\\t'meta': self.handle_request_get_meta,\\n\\t\\t\\t\\t'info': self.handle_request_get_info,\\n\\t\\t\\t\\t'modules/list': self.handle_request_get_modules,\\n\\t\\t\\t\\t'modules': self.handle_request_get_modules,\\n\\t\\t\\t\\t'categories/list': self.handle_request_get_categories,\\n\\t\\t\\t\\t'categories': self.handle_request_get_categories,\\n\\t\\t\\t\\t'user/preferences': self.handle_request_get_user_preferences,\\n\\t\\t\\t\\t'hosts/list': self.handle_request_get_hosts,\\n\\t\\t\\t\\t'hosts': self.handle_request_get_hosts,\\n\\t\\t\\t}.get(arg)\\n\\t\\t\\tif method:\\n\\t\\t\\t\\tself.finished(msg.id, method(msg))\\n\\t\\t\\t\\treturn\\n\\t\\traise NotFound()\",\n \"def pub(payload):\\n print(payload)\\n sys.stdout.flush()\\n\\n corr_id = pub.send_request(payload)\\n r.lpushx(\\\"payload\\\", payload)\\n\\n\\n while pub.queue[corr_id] is None:\\n time.sleep(0.1)\\n\\n return pub.queue[corr_id]\",\n \"def wait_for_messages(self):\\n msg = self.inbox.get()\\n return msg\",\n \"def ask(self, message):\\n\\n self.write(message)\\n\\n if self.multi_command is None:\\n return self.read()\\n else:\\n self.responses_expected += 1\",\n \"def query(self, message: str) -> str:\\n raise NotImplementedError()\",\n \"def do_get(args):\\n session = BMC(server=args.server, username=args.username, password=args.password)\\n print(json.dumps(session.get(args.path), indent=4))\",\n \"def _get(self, *args, **kwargs):\\n return self._request('get', *args, **kwargs)\",\n \"def get_object(self):\\n # read the URL data values into variables\\n astronaut_pk = self.kwargs['astronaut_pk']\\n message_pk = self.kwargs['message_pk']\\n\\n # find the SendMessage object, and return it\\n st_cfh = SendMessage.objects.get(pk=message_pk)\\n return st_cfh\",\n \"def get():\",\n \"def get():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6866893","0.68570006","0.63802916","0.6348834","0.6341484","0.61993957","0.61341304","0.6129399","0.61021316","0.5994536","0.5983703","0.59462357","0.5938115","0.59198","0.59198","0.59195334","0.59125274","0.5909593","0.5882313","0.58796036","0.5872847","0.58448005","0.58437586","0.5829821","0.58174026","0.58042693","0.5778121","0.5763018","0.5738492","0.5732126","0.5715068","0.5705086","0.5703576","0.5700736","0.5667122","0.566351","0.56408703","0.557003","0.55512506","0.55484647","0.554797","0.55462915","0.5498748","0.54869723","0.5480097","0.54703945","0.5438539","0.543825","0.5427459","0.5426328","0.5425421","0.5417579","0.54172003","0.54157877","0.5407007","0.5394108","0.5381136","0.5374543","0.5349618","0.533365","0.5327955","0.5306014","0.5297476","0.5296961","0.5296754","0.5294805","0.5293162","0.52898425","0.5281851","0.5275924","0.52725154","0.527222","0.5270246","0.52675694","0.5264282","0.5260943","0.52589315","0.52577084","0.52573776","0.52570224","0.5251076","0.5243951","0.52419287","0.5237892","0.523674","0.52366686","0.5232802","0.52309436","0.5230474","0.52273285","0.52224505","0.52175194","0.52148837","0.52004856","0.52001107","0.5195816","0.51914483","0.5185819","0.518475","0.518475"],"string":"[\n \"0.6866893\",\n \"0.68570006\",\n \"0.63802916\",\n \"0.6348834\",\n \"0.6341484\",\n \"0.61993957\",\n \"0.61341304\",\n \"0.6129399\",\n \"0.61021316\",\n \"0.5994536\",\n \"0.5983703\",\n \"0.59462357\",\n \"0.5938115\",\n \"0.59198\",\n \"0.59198\",\n \"0.59195334\",\n \"0.59125274\",\n \"0.5909593\",\n \"0.5882313\",\n \"0.58796036\",\n \"0.5872847\",\n \"0.58448005\",\n \"0.58437586\",\n \"0.5829821\",\n \"0.58174026\",\n \"0.58042693\",\n \"0.5778121\",\n \"0.5763018\",\n \"0.5738492\",\n \"0.5732126\",\n \"0.5715068\",\n \"0.5705086\",\n \"0.5703576\",\n \"0.5700736\",\n \"0.5667122\",\n \"0.566351\",\n \"0.56408703\",\n \"0.557003\",\n \"0.55512506\",\n \"0.55484647\",\n \"0.554797\",\n \"0.55462915\",\n \"0.5498748\",\n \"0.54869723\",\n \"0.5480097\",\n \"0.54703945\",\n \"0.5438539\",\n \"0.543825\",\n \"0.5427459\",\n \"0.5426328\",\n \"0.5425421\",\n \"0.5417579\",\n \"0.54172003\",\n \"0.54157877\",\n \"0.5407007\",\n \"0.5394108\",\n \"0.5381136\",\n \"0.5374543\",\n \"0.5349618\",\n \"0.533365\",\n \"0.5327955\",\n \"0.5306014\",\n \"0.5297476\",\n \"0.5296961\",\n \"0.5296754\",\n \"0.5294805\",\n \"0.5293162\",\n \"0.52898425\",\n \"0.5281851\",\n \"0.5275924\",\n \"0.52725154\",\n \"0.527222\",\n \"0.5270246\",\n \"0.52675694\",\n \"0.5264282\",\n \"0.5260943\",\n \"0.52589315\",\n \"0.52577084\",\n \"0.52573776\",\n \"0.52570224\",\n \"0.5251076\",\n \"0.5243951\",\n \"0.52419287\",\n \"0.5237892\",\n \"0.523674\",\n \"0.52366686\",\n \"0.5232802\",\n \"0.52309436\",\n \"0.5230474\",\n \"0.52273285\",\n \"0.52224505\",\n \"0.52175194\",\n \"0.52148837\",\n \"0.52004856\",\n \"0.52001107\",\n \"0.5195816\",\n \"0.51914483\",\n \"0.5185819\",\n \"0.518475\",\n \"0.518475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6481924"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":93085,"cells":{"query":{"kind":"string","value":"Declare a the queue as highly available, passing in a list of nodes the queue should live on. If no nodes are passed, the queue will be declared across all nodes in the cluster."},"document":{"kind":"string","value":"def ha_declare(self, nodes=None):\n if nodes:\n self._arguments['x-ha-policy'] = 'nodes'\n self._arguments['x-ha-nodes'] = nodes\n else:\n self._arguments['x-ha-policy'] = 'all'\n if 'x-ha-nodes' in self._arguments:\n del self._arguments['x-ha-nodes']\n return self.declare()"},"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 declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")","def _create_queue(self):\n # Instantiate\n queue = pbs.queue(verbose=not self.quiet)\n\n if self.q == 'ember':\n # Submitting to Utah ember cluster\n ppn = 12\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n walltime = self.walltime if int(self.walltime.split(':')[0]) < 72 else '72:00:00'\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\n walltime=walltime, ppn=ppn, cpus=cpus, partition='ember', alloc='sdss')\n elif self.q is not None:\n # All other self.q values expected for Portsmouth cluster,\n # sciama. In this case, the number of nodes is queue\n # dependent, and qos is not set\n if self.q == 'sciama1.q':\n ppn = 12\n elif self.q == 'sciama3.q':\n ppn = 20\n else:\n ppn = 16\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n queue.create(label=self.label, nodes=self.nodes, umask=self.umask,\n walltime=self.walltime, queue=self.q, ppn=ppn, cpus=cpus)\n else:\n # self.q can be None when submitting to both the Portsmouth\n # and Utah clusters. In this case, the default queue\n # destination and ppn is correct. qos is also set, but this\n # should only be used when submitting to Utah.\n ppn = 16\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\n walltime=self.walltime, ppn=ppn, cpus=cpus)\n\n return queue","def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)","def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)","def init_ready_queue(inbound_counts, nodes):\n ready = [n for n in nodes if inbound_counts[n] == 0]\n return deque(ready) # to get popleft()","def declare_queue(self, queue_name):\n if queue_name not in self.queues:\n self.emit_before(\"declare_queue\", queue_name)\n self.queues.add(queue_name)\n self.emit_after(\"declare_queue\", queue_name)\n\n delayed_name = dq_name(queue_name)\n self.delay_queues.add(delayed_name)\n self.emit_after(\"declare_delay_queue\", delayed_name)","def setup_queue(self, channel, queue_name):\n logger.info('Declaring queue %s', queue_name)\n channel.queue_declare(queue = queue_name, \n durable = True,\n auto_delete = False)","def small_queue():\n queue = Queue()\n queue.enqueue(1)\n queue.enqueue(2)\n queue.enqueue(3)\n queue.enqueue(4)\n return queue","def large_queue():\n que = Queue()\n for num in range(1, 11):\n que.enqueue(num)\n return que","async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self","def declare(self):\n self.channel.queue_declare(queue='files_to_database')","def new_queue() -> Queue:\n return multiprocessing.Queue()","def producer(networks, q):\n host_count = 0\n for network in networks:\n LOG.debug(f\"Producer: working on network {network} queue[current size = {q.qsize()}] {time.strftime('%H:%M:%S')}\")\n num_hosts = len(list(network.hosts()))\n # Select first 5 hosts add to queue if num_hosts > 10 else add them all\n if num_hosts > 10:\n hosts = list(network.hosts())[:5]\n for host in hosts:\n q.put(host)\n host_count += 1\n else:\n hosts = list(network.hosts())\n for host in hosts:\n q.put(host)\n host_count += 1\n # Select last 5 hosts add to queue\n if num_hosts > 10:\n hosts = list(network.hosts())[-5:]\n for host in hosts:\n q.put(host)\n host_count += 1\n # Select 10% of the rest of the hosts add to queue\n if num_hosts > 10:\n sample_hosts_len = network.size() // 10\n hosts = random.sample(list(network.hosts())[5:-5], sample_hosts_len)\n for host in hosts:\n q.put(host)\n host_count += 1\n return host_count","def __init__(self, initial_node):\n self.__nodes = MinPriorityQueue({initial_node : initial_node.estimate})","def small_queue():\n que = Queue()\n que.enqueue(1)\n que.enqueue(2)\n que.enqueue(3)\n que.enqueue(4)\n que.enqueue(5)\n return que","def draw_queue(total_nodes, total_cores, used_cores, empty_nodes, desired_host, \n disabled_cores, disabled_nodes, node_list, free_cores):\n \n if total_cores > 400:\n screen_size = 119\n cores_per_row = 39\n else:\n screen_size = 100\n cores_per_row = 30\n \n o_core = '[O]'\n u_core = '[~]'\n dis_core = '[#]'\n print('{0} Queue'.format(str(desired_host)).center(screen_size))\n print('-'.center(screen_size,'-'))\n print('Total Cores:'.ljust(int(screen_size/2)), end=\"\")\n print('{0}'.format(str(total_cores)).ljust(int(screen_size/2)))\n print('Used Cores:'.ljust(int(screen_size/2)), end=\"\")\n print('{0}'.format(str(used_cores)).ljust(int(screen_size/2)))\n print('Free Cores:'.ljust(int(screen_size/2)), end=\"\")\n print('{0}'.format(str(free_cores)).ljust(int(screen_size/2)))\n print('Disabled/Error Cores:'.ljust(int(screen_size/2)), end=\"\")\n print('{0}'.format(str(disabled_cores)).ljust(int(screen_size/2)))\n print('Total Nodes:'.ljust(int(screen_size/2)),end =\"\")\n print('{0}'.format(str(total_nodes)).ljust(int(screen_size/2)))\n print('-'.center(screen_size, '-'))\n print(('[0] = Open Core' + PRINT_INDENT + '[~] = Used Core' + PRINT_INDENT + \\\n '[#] = Disabled/Err Core').center(screen_size) + '\\n')\n \n #Drawing representation of the Queue\n drawn_cores = 0\n for node in node_list:\n if node.get_disabled_switch():\n for i in range(1, node.total_cores +1):\n print(dis_core, end=\"\")\n drawn_cores += 1\n if drawn_cores == cores_per_row:\n drawn_cores = 0\n print('')\n continue\n if node.get_free():\n for i in range(1, (node.free_cores) +1):\n print(o_core, end=\"\")\n drawn_cores += 1\n if drawn_cores == cores_per_row:\n drawn_cores = 0\n print('')\n if node.get_used():\n for i in range(1, (node.used_cores) +1):\n print(u_core, end=\"\")\n drawn_cores += 1\n if drawn_cores == cores_per_row:\n drawn_cores = 0\n print('')\n print('\\n' + '-'.center(screen_size,'-'))\n return","def enqueue(queue, item):\n new_node = Node(item, None)\n if empty_queue(queue):\n queue.front = new_node\n queue.back = new_node\n else:\n queue.back.next = new_node\n queue.back = new_node\n queue.size = queue.size + 1","def __init__(self, maxsize=0, workers=10):\n self.queue = JoinableQueue(maxsize=maxsize)\n [spawn(self.worker) for x in range(workers)]","def dynamic_alloc(self, minExecutors=None, maxExecutors=None, initialExecutors=None, fairScheduling=False,\n maxCores=None):\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_ENABLED] = 'true'\n self.sparkProperties[SparkProperties.SPARK_SHUFFLE_SERVICE_ENABLED] = 'true'\n if maxCores:\n self.sparkProperties[SparkProperties.SPARK_CORES_MAX] = maxCores\n if initialExecutors:\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_INITIALEXECUTORS] = initialExecutors\n if minExecutors:\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_MINEXECUTORS] = minExecutors\n if maxExecutors:\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_MAXEXECUTORS] = maxExecutors\n if fairScheduling:\n self.sparkProperties[SparkProperties.SPARK_SCHEDULER_MODE] = \"FAIR\"\n return self","def new_queue(self, params, maxUsers=1):\n self.spotify.reset_queue()\n\n #Extract parameters\n mood = params[0]\n users = []\n for i in range(maxUsers):\n if len(params[i + 1]) > 0:\n users.append(params[i + 1])\n\n #Add default host if only one guest is present\n # if len(users) == 1:\n # users.append('Paolo')\n\n #Lists to load\n names = []\n for n in self.listIDs.keys():\n for u in users:\n if len(mood) > 0:\n if u + ':' + mood in n:\n names.append(n)\n else:\n if 'top:' + u in n:\n names.append(n)\n\n\n self.add_playlist(names)","def process_queue(host_user_list, user_name, user_list):\n\n total_nodes = 0\n total_cores = 0\n disabled_cores = 0\n used_cores = 0\n free_cores = 0\n empty_nodes = 0\n disabled_nodes = 0\n \n node_strings= []\n\n for hostgroup in host_user_list:\n # Obtain totals for one hostgroup, and contine a summation\n tc, uc, tn, en, dc,dn, nl = process_host(hostgroup.replace('@',''))\n\n # Do not want to recount same nodes. This needs to be looked at for efficiency.\n nl_strings = [n.name for n in nl]\n\n if nl_strings[0] in node_strings:\n continue\n\n # Sum to get totals for whole queue which user has access to\n total_cores += tc \n used_cores += uc \n total_nodes += tn\n empty_nodes += en\n disabled_cores += dc\n disabled_nodes += dn\n node_strings= node_strings + nl\n\n # Send totals to be printed to screen\n print_host_info(total_cores, used_cores, total_nodes, empty_nodes, \"Long Queue\", disabled_cores, \n disabled_nodes)\n sys.exit(0)","def _get_node_list(self, machine_name, max_nodes):\n\n q = Queue()\n # if machine_name.lower() == 'summit':\n # add relative node names starting with 1 for creating ERF files\n for i in range(max_nodes):\n q.put('{}'.format(i+1))\n return q","def start_nodes(self, *node_list, wait_for_everything=None, quiet=False):\n\n if not wait_for_everything:\n wait_for_everything = self.wait_all\n\n if not node_list:\n node_list = self.nodes_waiting_to_start\n\n if not wait_for_everything:\n wait_for_everything = not quiet\n\n # node_list can be either names or node dictionaries\n node_names_to_start = [node['name'] if type(node) == dict else node for node in node_list]\n\n threading.Thread(target=self.httpd.serve_forever).start()\n\n existing_nodes = self.nodes()\n\n names_by_node_id = {node['node_id']:node['name'] for node in existing_nodes}\n node_ids_by_name = {node['name']:node['node_id'] for node in existing_nodes}\n\n all_dependent_nodes = set()\n for value in self.node_dependencies.values():\n for node in value:\n all_dependent_nodes.update((node['node_id'], ))\n\n # We assume that if GNS3 reported the node as 'started', that it's ready for service.\n # This isn't entirely valid, as it might still be booting, but it's OK for now (I hope).\n\n running_nodeids = set(node['node_id'] for node in existing_nodes if node['status'] == 'started')\n\n waiting_for_nodeids_to_start = set()\n\n # If we declare a node that already ran once but isn't running now, we'll treat it\n # here as a brand new node, start it (at some point in this function) and wait for\n # it to phone home. The problem is that phone home only happens once-per-instance,\n # so it will never phone home and we'll wait forever for it.\n\n for node_name in node_names_to_start:\n # If we create a node, start it, then delete it, it will still be listed in\n # node_names_to_start, but it no longer exists. It won't appear in\n # node_ids_by_name, so just skip it.\n if node_name in node_ids_by_name:\n node_id = node_ids_by_name[node_name]\n dependencies = self.node_dependencies.get(node_id, [])\n # we'll need to start all nodes dependent on the nodes to start\n for v in dependencies:\n if v['name'] not in node_names_to_start:\n node_names_to_start.append(v['name'])\n # if the node isn't running but all of its dependencies are, start it\n if node_id not in running_nodeids and node_id not in waiting_for_nodeids_to_start:\n if running_nodeids.issuperset([v['node_id'] for v in dependencies]):\n self.start_nodeid(node_id, print_console=not quiet)\n waiting_for_nodeids_to_start.add(node_id)\n\n with self.httpd.instance_report_cv:\n if wait_for_everything:\n waitlist = waiting_for_nodeids_to_start\n else:\n waitlist = waiting_for_nodeids_to_start.intersection(all_dependent_nodes)\n while waitlist:\n print('Waiting for', [names_by_node_id[nodeid] for nodeid in waitlist])\n self.httpd.instance_report_cv.wait()\n for inst in self.httpd.instances_reported:\n # Same consideration as before if a node was started and then deleted\n if inst in node_ids_by_name:\n running_nodeids.add(node_ids_by_name[inst])\n if inst in self.telnet_procs:\n self.telnet_procs[inst].terminate()\n del self.telnet_procs[inst]\n\n waiting_for_nodeids_to_start.difference_update(running_nodeids)\n\n candidate_nodes = set()\n\n for key, value in self.node_dependencies.items():\n if key not in waiting_for_nodeids_to_start and key not in running_nodeids:\n if running_nodeids.issuperset([v['node_id'] for v in value]):\n candidate_nodes.add(key)\n\n for start_node in candidate_nodes:\n self.start_nodeid(start_node, print_console=not quiet)\n waiting_for_nodeids_to_start.add(start_node)\n\n if wait_for_everything:\n waitlist = waiting_for_nodeids_to_start\n else:\n waitlist = waiting_for_nodeids_to_start.intersection(all_dependent_nodes)\n\n self.httpd.shutdown()","def enqueue(self, node):\n self.items.append(node)","def __init__(self, name, jobs=[],cores_used=0):\n \n self.name = str(name)\n self.job_list = jobs\n self.cores_used = cores_used\n self.node_list = []","def make_empty_queue():\n return Queue(0, None, None)","def queue_maker(queue, bucket_name):\n scraper = key_scraper.KaleidoscopeKeyScraper(\n bucket_name=bucket_name,\n queue=queue,\n )\n scraper.add_keys_to_queue()\n\n return None","def __init__(self):\n self.queues=[]","def main(args):\n\n\n _NUM_GROUPS=args.numgroups\n state = json.load(open(args.jsonfile))\n\n nq = gpfs.nodequeue.NodeQueue(state)\n\n nq.create_queue(_NUM_GROUPS)\n nq.print_queue()","def requires_matching_queues(self, requires_matching_queues):\n \n self._requires_matching_queues = requires_matching_queues","def _queue_create(self, **kwargs):\n name = self.generate_random_name()\n return self.clients(\"zaqar\").queue(name, **kwargs)","def declare_queue(self, c, queue_name):\n return self._management_req(\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\n {\"auto_delete\": False, \"durable\": False, \"arguments\": {}})","def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)","def __init__(self):\r\n self.point_to_head = MyQueueNode('head')\r\n self.point_to_tail = MyQueueNode('tail')","def process_host(desired_host):\n \n node_list = []\n host_info_list = [] \n if desired_host == \"all\":\n desired_host_list = getAllMachines()\n else:\n desired_host_list = (subprocess.getoutput(\"qconf -shgrp_resolved \" + '@' + str(desired_host))).split()\n qstat = subprocess.getoutput('qstat -f')\n for host in desired_host_list:\n if qstat.find(host) != (-1):\n #Searches the long string for the index of the occurance of the specified host, then\n #parses it the string for just that one line with the host that we want.\n host_info_list.append((qstat[qstat.find(host):].split('\\n'))[0])\n #Start at with everything at 0, and will count up as encountered.\n total_nodes = 0\n total_cores = 0\n disabled_cores = 0\n used_cores = 0\n free_cores = 0\n empty_nodes = 0\n disabled_nodes = 0\n for host in host_info_list:\n #simply gathering info qstat spat out for us\n temp_node = Node((host.split()[0]))\n cores = host.split()[2].replace('/', ' ').split()\n host_used_cores = cores[1]\n host_total_cores = cores[2]\n if len(host.split()) == 6 and (host.split()[5] == 'd' or host.split()[5] == 'E' or \\\n host.split()[5] == 'au' or host.split()[5] == 'Eau' or host.split()[5] == 'Eqw' \\\n or host.split()[5] == 'adu'):\n temp_node.set_disabled_switch(True)\n disabled_cores += int(host_total_cores)\n total_cores += int(host_total_cores)\n disabled_nodes += 1\n else: \n temp_node.set_disabled_switch(False)\n used_cores += int(host_used_cores)\n total_cores += int(host_total_cores)\n free_cores += int(host_total_cores) - int(host_used_cores)\n if int(host_used_cores) == 0:\n empty_nodes += 1\n temp_node.set_cores(host_total_cores, host_used_cores)\n total_nodes += 1\n node_list.append(temp_node) \n \n if len(sys.argv) == 3:\n if sys.argv[2] == '--details':\n print_detailed_host(total_cores, used_cores, total_nodes, empty_nodes, desired_host, \n disabled_cores, disabled_nodes, node_list)\n elif sys.argv[2] == '-v' or sys.argv[2] == '--visual':\n draw_queue(total_nodes, total_cores, used_cores, empty_nodes, desired_host, disabled_cores, \n disabled_nodes, node_list, free_cores)\n else:\n print('Error: Arg syntax error with: ' + sys.argv[2])\n show_usage(23)\n elif sys.argv[1] == \"-qlong\":\n # Returning values from this host group to the qlong function\n return(total_cores, used_cores, total_nodes, empty_nodes, disabled_cores,disabled_nodes, node_list)\n elif len(sys.argv) < 3:\n print_host_info(total_cores, used_cores, total_nodes, empty_nodes, desired_host, disabled_cores, \n disabled_nodes)\n else:\n print('Error: Too many args')\n show_usage(23)\n return","def on_channel_open(new_channel):\n global channel\n channel = new_channel\n channel.queue_declare(queue=\"test\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)","def __init__(self, k: int):\n self.queue = [0]*k\n self.headIndex = 0\n self.count = 0\n self.capacity = k","def __init__(self, k):\n self.queue = [0]*k\n self.headIndex = 0\n self.count = 0\n self.capacity = k","def setup_queues():\n sqs = boto.connect_sqs()\n sqs.create_queue('mls_parse_requests')\n sqs.create_queue('mls_fetcher')","def __init__(self):\r\n self.bucket = []\r\n for i in range(4096):\r\n self.bucket.append(Node(0,0))","def enqueue(self, item, priority):\n # TODO: Insert given item into heap\n ...","def __init__(self, partition_requests=[], timeout=1000, min_bytes=1024):\n self.timeout = timeout\n self.min_bytes = min_bytes\n self._reqs = defaultdict(dict)\n for req in partition_requests:\n self.add_request(req)","def add_queue(queues, host=\"localhost\", port=6379, http_host=\"localhost\",\n http_port=DEFAULT_HTTP_PORT, workers=1,\n unix_domain_socket=None):\n if http_host.startswith('/'):\n # This is an unix socket\n new_http_host = UnixResolver.register_unixsocket(http_host)\n else:\n new_http_host = http_host\n if isinstance(queues, six.string_types):\n Queues.add(Queue([queues], host=host, port=port,\n http_host=new_http_host,\n http_port=http_port, workers=workers,\n unix_domain_socket=unix_domain_socket))\n else:\n Queues.add(Queue(queues, host=host, port=port, http_host=new_http_host,\n http_port=http_port, workers=workers,\n unix_domain_socket=unix_domain_socket))","def __init__(self, k: int):\n self.queue = [0]*k\n self.headIndex = 0\n self.count = 0\n self.capacity = k\n # the additional attribute to protect the access of our queue\n self.queueLock = Lock()","def enqueue(elem: Any, priority: int = 0) -> None:\n\tglobal queue\n\tqueue.append((priority, elem))\n\treturn None","def enqueue(self):\n # TensorFlow Input Pipelines for Large Data Sets\n # ischlag.github.io\n # http://ischlag.github.io/2016/11/07/tensorflow-input-pipeline-for-large-datasets/\n # http://web.stanford.edu/class/cs20si/lectures/slides_09.pdf\n under = 0\n max = len(self.train_x)\n try:\n while not self.coord.should_stop():\n # print(\"starting to write into queue\")\n upper = under + self.capacity\n # print(\"try to enqueue \", under, \" to \", upper)\n if upper <= max:\n curr_x = self.train_x[under:upper]\n curr_t = self.train_t[under:upper]\n curr_e = self.train_e[under:upper]\n under = upper\n else:\n rest = upper - max\n curr_x = np.concatenate((self.train_x[under:max], self.train_x[0:rest]))\n curr_t = np.concatenate((self.train_t[under:max], self.train_t[0:rest]))\n curr_e = np.concatenate((self.train_e[under:max], self.train_e[0:rest]))\n under = rest\n\n self.session.run(self.enqueue_op,\n feed_dict={self.x: curr_x, self.t: curr_t, self.e: curr_e})\n except tf.errors.CancelledError:\n print(\"finished enqueueing\")","def queue_enqueue(queue, targets):\n\n enqueued = []\n for target in map(lambda x: x.strip(), targets):\n if target != '':\n enqueued.append({'target': target, 'queue_id': queue.id})\n if enqueued:\n db.session.execute(Target.__table__.insert().values(enqueued))\n db.session.commit()","def create_queue(data_size,\n num_steps,\n capacity=128,\n dtype=tf.int32):\n\n # Feeds for inputs.\n input_data = tf.placeholder(\n dtype, shape=[data_size, num_steps], name=\"input_data\")\n\n targets = tf.placeholder(\n dtype, shape=[data_size, num_steps], name=\"targets\")\n\n queue = tf.FIFOQueue(\n capacity=capacity,\n # min_after_dequeue=min_after_dequeue,\n dtypes=[dtype, dtype],\n shapes=[[num_steps]] * 2)\n\n enqueue_op = queue.enqueue_many(\n [input_data, targets])\n\n placeholders = {\n \"input_data\": input_data,\n \"targets\": targets\n }\n\n return queue, enqueue_op, placeholders","def spam( self, node ):\n map( lambda queue: queue.put( node ), self.state[ 'qout' ] )","async def _connect(self):\n self._connection = await connect_robust(self._connection_string)\n self._channel = await self._connection.channel()\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})","def populateQueue(self, graph, queue, parent):\n\t\t# get possible moves\n\t\tmoves = graph.getMoves()\n\n\t\t# put into queue all the moves possible\n\t\tfor move in moves:\n\t\t\t# make move and get copy\n\t\t\tnewBoard = graph.copyConfidentMove(move)\n\n\t\t\t# calculate heuristic for this move that was made\n\t\t\th = self.heuristic(newBoard)\n\n\t\t\t# create node\n\t\t\tnode = AStarNode(newBoard, move, parent, parent.g + 1, h)\n\n\t\t\t# put the node in priority queue\n\t\t\tqueue.put((node.cost(), node))","def initialize_executor(self, queue_to_lower: multiprocessing.Queue, queue_from_lower: multiprocessing.Queue, cs: BaseContentStore, classic: bool = False):\n self.queue_to_lower = queue_to_lower\n self.queue_from_lower = queue_from_lower\n self.cs = cs\n self.classic = classic","def __init__(self, nodes, cost=float('inf')):\n self.nodes = nodes\n self.cost = cost\n self.backset = set()\n self.backptr = None\n self.collision_set = set()","def __init__(self, n=1, cpu=.1, bw=10, delay=100,\n max_queue_size=None, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n assert(n > 0)\n self.n = n\n\n # Host and link configuration\n hconfig = {'cpu': cpu}\n lconfig = {'bw': bw, 'delay': ('%sms' % delay),\n 'max_queue_size': max_queue_size, 'loss': args.loss}\n \n serverSwitch = self.add_switch('s1')\n clientSwitch = self.add_switch('s2')\n \n self.add_link(serverSwitch, clientSwitch, 0, 0, **lconfig)\n \n for i in range(1, args.hosts + 1):\n server = self.add_host('server' + str(i), **hconfig)\n client = self.add_host('client' + str(i), **hconfig)\n \n self.add_link(server, serverSwitch, 0, i)\n self.add_link(client, clientSwitch, 0, i)","def constraint(self):\n with self.mutating:\n self.queue = heapq.nsmallest(self.max_size, self.queue)\n heapq.heapify(self.queue)","def __init__(self, n=1, delay='1ms', z=1, bw=1, cpu=.1, max_queue_size=None, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n\n #TODO: Create your Dynamic Mininet Topology here!\n #NOTE: You MUST label switches as s1, s2, ... sz\n #NOTE: You MUST label hosts as h1-1, h1-2, ... hz-n \n #HINT: Use a loop to construct the topology in pieces.","def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\n durable=durable, arguments=arguments)\n else:\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)","def test_initialization_with_empty_list_first_node_check():\n queue = Queue([])\n assert queue._queue.first_node is None","def m_cliques(adj_list,labels,matrix,topology=\"clique\",cut=0):\n num_clusters = list(np.unique(labels))\n clusters = {i:[] for i in num_clusters}\n print(\"m_cliques CUT:\", cut)\n #Add nodes to clusters\n for idx,n in enumerate(adj_list):\n clusters[labels[idx]].append(n)\n \n if topology == \"sample_rand\":\n G_cliques = sampled_clique(clusters,\"rand\")\n print(\"Rand sampled clique size:\", G_cliques.number_of_nodes())\n elif topology == \"sample_optim\":\n G_cliques = sampled_clique(clusters,\"optim\")\n print(\"Optim sampled clique size:\", G_cliques.number_of_nodes())\n elif topology == \"pcc_rand\":\n G_cliques = pcc_clique(clusters,\"rand\",labels,cut)\n print(\"Rand sampled clique size:\", G_cliques.number_of_nodes())\n elif topology == \"pcc_optim\":\n G_cliques = pcc_clique(clusters,\"optim\",labels,cut)\n print(\"Optim sampled clique size:\", G_cliques.number_of_nodes())\n elif topology == \"pcc_greedy\":\n G_cliques = pcc_clique(clusters,\"greedy\",labels,cut,matrix)\n print(\"Greedy sampled clique size:\", G_cliques.number_of_nodes())\n else:\n G_cliques = nx.Graph()\n cliques = []\n while not is_empty(clusters):\n clique = []\n \n #Add clique nodes\n for _,cluster in clusters.items():\n if len(cluster) > 0:\n n = random.choice(cluster)\n clique.append(n)\n cluster.remove(n)\n \n #Cliqify\n for n1 in clique:\n for n2 in clique:\n if n1 != n2:\n G_cliques.add_edge(n1,n2)\n \n #Aggregate clique\n cliques.append(clique)\n\n if topology == \"clique\":\n clique_the_cliques(cliques,labels,G_cliques)\n elif topology == \"ring\":\n cliques_on_ring(cliques,labels,G_cliques)\n \n return G_cliques","def __init__(self):\n self.queue = []\n self.queue.append(Queue())\n self.queue.append(Queue())\n self.tag = 0 # using to record which queue contain the data","def setup_node(\n *,\n # Change this to take host, user, and identity_file?\n # Add some kind of caching for SSH connections so that they\n # can be looked up by host and reused?\n ssh_client: paramiko.client.SSHClient,\n services: list,\n cluster: FlintrockCluster):\n host = ssh_client.get_transport().getpeername()[0]\n ssh_check_output(\n client=ssh_client,\n command=\"\"\"\n set -e\n\n echo {private_key} > \"$HOME/.ssh/id_rsa\"\n echo {public_key} >> \"$HOME/.ssh/authorized_keys\"\n\n chmod 400 \"$HOME/.ssh/id_rsa\"\n \"\"\".format(\n private_key=shlex.quote(cluster.ssh_key_pair.private),\n public_key=shlex.quote(cluster.ssh_key_pair.public)))\n\n with ssh_client.open_sftp() as sftp:\n sftp.put(\n localpath=os.path.join(SCRIPTS_DIR, 'setup-ephemeral-storage.py'),\n remotepath='/tmp/setup-ephemeral-storage.py')\n\n logger.info(\"[{h}] Configuring ephemeral storage...\".format(h=host))\n # TODO: Print some kind of warning if storage is large, since formatting\n # will take several minutes (~4 minutes for 2TB).\n storage_dirs_raw = ssh_check_output(\n client=ssh_client,\n command=\"\"\"\n set -e\n python /tmp/setup-ephemeral-storage.py\n rm -f /tmp/setup-ephemeral-storage.py\n \"\"\")\n storage_dirs = json.loads(storage_dirs_raw)\n\n cluster.storage_dirs.root = storage_dirs['root']\n cluster.storage_dirs.ephemeral = storage_dirs['ephemeral']\n\n ensure_java8(ssh_client)\n\n for service in services:\n service.install(\n ssh_client=ssh_client,\n cluster=cluster)","def on_queue_declared(frame):\n start_consuming(frame)","def __init__(self, threads_count):\n\n self.queue = Queue(threads_count)\n\n self.threads = []\n self.device = None\n\n self.create_workers(threads_count)\n self.start_workers()","def pushPriorityQueue(self, node):\r\n if self.priority == \"bin\":\r\n heappush(self.unvisited, node)\r\n elif self.priority == \"fib\":\r\n fheappush(self.unvisited, node)\r\n else: # list\r\n self.unvisited.append(node)","def create_initial_priority_queue(self, t_max=None):\n for particle_number in range(self.N): # iterate through each particle\n self.add_collision_horizontal_wall_to_queue(particle_number, 0) # add collision with horizontal wall\n self.add_collision_vertical_wall_to_queue(particle_number, 0) # add collision with vertical wall\n self.add_collision_tb_wall_to_queue(particle_number, 0) # add collision with tb wall\n self.add_collisions_particle_to_queue(particle_number, 0, t_max) # add collisions with other particles","def add_a_queue(self, size):\n \tself.queues.append(ContextModalityQueue(size))","def priority_queue():\n from src.priorityq import PriorityQueue\n priority_queue = PriorityQueue()\n return priority_queue","def main(nodelist):\n log.debug(f\"SuspendProgram {nodelist}\")\n nodes = util.to_hostnames(nodelist)\n\n # Filter out nodes not in config.yaml\n cloud_nodes, local_nodes = lkp.filter_nodes(nodes)\n if len(local_nodes) > 0:\n log.debug(\n f\"Ignoring slurm-gcp external nodes '{util.to_hostlist(local_nodes)}' from '{nodelist}'\"\n )\n if len(cloud_nodes) > 0:\n log.debug(\n f\"Using cloud nodes '{util.to_hostlist(cloud_nodes)}' from '{nodelist}'\"\n )\n else:\n log.debug(\"No cloud nodes to suspend\")\n return\n\n # suspend is allowed to delete exclusive nodes\n log.info(f\"suspend {nodelist}\")\n suspend_nodes(nodes)","def sync_idle_nodes(client_queue, free_nodes):\n\n idle_nodes = []\n if len(client_queue) == 0:\n print_rank(f\"Free idle nodes {len(free_nodes)}\", loglevel=logging.DEBUG)\n while len(free_nodes) > 0:\n node = free_nodes.pop()\n idle_nodes.append(node)\n _send(COMMAND_SYNC_NODES, node)\n return idle_nodes","def setup_queues_and_bindings(self):\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)","def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)","def creator(data, q):\n print('Creating data and putting it on the queue')\n for item in data:\n q.put(item)","def resize_for_new_nodes(new_total_nodes, k8s, cluster, test=False):\n if confirm((\"Resizing up to: %d nodes\" % new_total_nodes)):\n scale_logger.info(\"Resizing up to: %d nodes\", new_total_nodes)\n if not test:\n cluster.add_new_node(new_total_nodes)\n wait_time = 130\n scale_logger.debug(\n \"Sleeping for %i seconds for the node to be ready for populating\", wait_time)\n time.sleep(wait_time)\n populate(k8s)","def enqueue(self, name):\n pass","def metis_partition(G):\n partition_list = partition(G, 2)[1]\n for i in range(2):\n for username in partition_list[i]:\n G.add_node(username, cluster=i)\n \n return G","def enqueue(self, new_data):\n new_node = Node(new_data)\n current = self.front\n\n if current is None:\n self.front = new_node\n else:\n while current.getPtr() is not None:\n current = current.getPtr()\n\n current.setPtr(new_node)","def __init__(self, name=None, nodes=None):\n super(Graph, self).__init__(name=name)\n self._nodes = nodes or []","def create_nodes_heap(self, graph):\n min_heap = []\n for label, node in self.graph.nodes.items():\n node_container = NodeContainer(node)\n heappush(min_heap, node_container)\n\n return min_heap","def __init__(self, nodes=None, edges=None):\n self._nodes = []\n self.nodes = nodes\n self._edges = []\n self.edges = edges\n self._create_connections()\n self._sorted_nodes = None\n self._node_wip = []","def simulateArrivalOfJobs(env, processes, batchQ):\n for p in processes:\n batchQ.addToBq(p)","def simulateArrivalOfJobs(env, processes, batchQ):\n for p in processes:\n batchQ.addToBq(p)","def __init__(self, num_nodes):\n self.graph = sps.lil_matrix((num_nodes, num_nodes))\n self.size = num_nodes","def make_heap(self, frequency):\n\n\n\t\t\tfor key in frequency:\n\t\t\t\tnode = self.HeapNode(key, frequency[key])#instaciamos un nodo con el valor y frecuencia\n\t\t\t\theapq.heappush(self.heap, node)#agregamos el nodo al priority queue","def __init__(self, parallel_server):\n self.queue = deque()\n self.parallel_server = parallel_server","def __init__(self, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n\n # Host and link configuration\n hostConfiguration = {'cpu': cpuShare()}\n linkConfiguration = {'bw': args.bandwidth, 'delay': delay(), 'max_queue_len': args.input_queue_size }\n \n # Create the actual topology\n client = self.add_host( 'client0', **hostConfiguration )\n \n switch = self.add_switch('switch0' )\n \n self.add_link( switch, client, port1=0, port2=0, **linkConfiguration )\n \n for i in range(1,args.servers+1):\n server = self.add_host( 'server%d' % i, **hostConfiguration )\n self.add_link( switch, server, port1=i, port2=0, **linkConfiguration )","def enqueue(self, data):\n\n node = Node(data)\n\n if self.front == None and self.rear == None:\n\n self.front = node\n self.rear = node\n\n else:\n\n self.rear.next = node\n self.rear = self.rear.next","def perform_setup():\n global credentials, connection, channel\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\n connection = pika.BlockingConnection(pika.ConnectionParameters(\"127.0.0.1\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\n channel = connection.channel()\n channel.queue_declare(queue='poll', durable=True)","def enqueue(Q, x):\n # Q.append(x)\n Q.put_nowait(x)\n if debug: \n print(\"enqueue\", x, \":\", end=\" \")\n show_queue(Q)\n return Q","def test_create_qos_queue(self):\r\n resource = 'qos_queue'\r\n cmd = qos.CreateQoSQueue(\r\n test_cli20.MyApp(sys.stdout), None)\r\n myid = 'myid'\r\n name = 'my_queue'\r\n default = False\r\n args = ['--default', default, name]\r\n position_names = ['name', 'default']\r\n position_values = [name, default]\r\n self._test_create_resource(resource, cmd, name, myid, args,\r\n position_names, position_values)","def enqueue(self, item):\n if self.rear == None:\n self.front = Node(item)\n self.rear = self.front\n else:\n self.rear.next = Node(item)\n self.rear = self.rear.next","def enqueue(self, otp_params, local_params, server, server_nonce):\n info = 'yk_publicname=%(yk_publicname)s&yk_counter=%(yk_counter)s' % otp_params\n info += '&yk_use=%(yk_use)s&yk_high=%(yk_high)s&yk_low=%(yk_low)s' % otp_params\n info += '&nonce=%(nonce)s' % otp_params\n info += ',&local_counter=%(yk_counter)s&local_use=%(yk_use)s' % local_params\n query = \"\"\"INSERT INTO queue (\n queued,\n modified,\n otp,\n server,\n server_nonce,\n info\n ) VALUES (%s, %s, %s, %s, %s, %s)\"\"\"\n self._execute(query, (int(time.time()), otp_params['modified'],\n otp_params['otp'], server, server_nonce, info))","def get_jobqueue_cluster(walltime='12:00', ncpus=1, cores=1, local_directory=None, memory='15GB', env_extra=None, **kwargs):\n import dask\n # this is necessary to ensure that workers get the job script from stdin\n dask.config.set({\"jobqueue.lsf.use-stdin\": True})\n from dask_jobqueue import LSFCluster\n import os\n\n if env_extra is None:\n env_extra = [\n \"export NUM_MKL_THREADS=1\",\n \"export OPENBLAS_NUM_THREADS=1\",\n \"export OPENMP_NUM_THREADS=1\",\n \"export OMP_NUM_THREADS=1\",\n ]\n\n if local_directory is None:\n local_directory = '/scratch/' + os.environ['USER'] + '/'\n\n cluster = LSFCluster(queue='normal',\n walltime=walltime,\n ncpus=ncpus,\n cores=cores,\n local_directory=local_directory,\n memory=memory,\n env_extra=env_extra,\n job_extra=[\"-o /dev/null\"],\n **kwargs)\n return cluster","def runQueueEnqueue(self):\n raise NotImplementedError","def init(number_of_workers=0):\n global _wq, _use_workers\n\n if number_of_workers:\n _use_workers = number_of_workers\n else:\n _use_workers = benchmark_workers()\n\n # if it is best to use zero workers, then use that.\n _wq = WorkerQueue(_use_workers)","def __init__(self, globalQueue, primaryNetwork, actionSpace):\n\n self.globalQueue = globalQueue\n self.killed = False\n self.net = primaryNetwork\n self.numUpdated = 0\n self.actionSpace = actionSpace","def enqueue(self, value): ################# <-\n self.top = Node(value, next=self.top)","def enqueue(self, value): ################# <-\n self.top = Node(value, next=self.top)","def global_queue(n=None,\n delay=3.0,\n verbose=True,\n enable=True,\n namespace: str = None):\n if n is None:\n n = ENV.global_lock or 1\n if namespace is None:\n namespace = ENV.namespace\n\n if enable:\n return FileQueue(n=n,\n delay=delay,\n verbose=verbose,\n file_prefix=f'mlkit{namespace}.queue')\n else:\n return nullcontext()","def __init__(self): # 1+1+1+1+1 => O(1)\n self._capacity = 7 #O(1)\n self._queue = [None] * self._capacity #O(1)\n self._size = 0 #O(1)\n self._start = 0 #O(1)\n self._end = 0 #O(1)","def test_ipc_queues():\n IPCComm.ipc_queues()"],"string":"[\n \"def declare_queue(self):\\n\\n self._channel.queue_declare(queue=self._queue_name, durable=True)\\n print(\\\"Queue declared....\\\")\",\n \"def _create_queue(self):\\n # Instantiate\\n queue = pbs.queue(verbose=not self.quiet)\\n\\n if self.q == 'ember':\\n # Submitting to Utah ember cluster\\n ppn = 12\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n walltime = self.walltime if int(self.walltime.split(':')[0]) < 72 else '72:00:00'\\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\\n walltime=walltime, ppn=ppn, cpus=cpus, partition='ember', alloc='sdss')\\n elif self.q is not None:\\n # All other self.q values expected for Portsmouth cluster,\\n # sciama. In this case, the number of nodes is queue\\n # dependent, and qos is not set\\n if self.q == 'sciama1.q':\\n ppn = 12\\n elif self.q == 'sciama3.q':\\n ppn = 20\\n else:\\n ppn = 16\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n queue.create(label=self.label, nodes=self.nodes, umask=self.umask,\\n walltime=self.walltime, queue=self.q, ppn=ppn, cpus=cpus)\\n else:\\n # self.q can be None when submitting to both the Portsmouth\\n # and Utah clusters. In this case, the default queue\\n # destination and ppn is correct. qos is also set, but this\\n # should only be used when submitting to Utah.\\n ppn = 16\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\\n walltime=self.walltime, ppn=ppn, cpus=cpus)\\n\\n return queue\",\n \"def setup_queue(self):\\n self.logger.info('declaring queue %s', self.queue)\\n if self.otq:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\\n else:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue)\",\n \"def declare_queue(self, topic):\\n #from trove.rpc.impl_kombu import Connection\\n from trove.openstack.common.rpc import create_connection\\n with create_connection() as conn:\\n consumer = conn.declare_topic_consumer(topic=topic)\",\n \"def init_ready_queue(inbound_counts, nodes):\\n ready = [n for n in nodes if inbound_counts[n] == 0]\\n return deque(ready) # to get popleft()\",\n \"def declare_queue(self, queue_name):\\n if queue_name not in self.queues:\\n self.emit_before(\\\"declare_queue\\\", queue_name)\\n self.queues.add(queue_name)\\n self.emit_after(\\\"declare_queue\\\", queue_name)\\n\\n delayed_name = dq_name(queue_name)\\n self.delay_queues.add(delayed_name)\\n self.emit_after(\\\"declare_delay_queue\\\", delayed_name)\",\n \"def setup_queue(self, channel, queue_name):\\n logger.info('Declaring queue %s', queue_name)\\n channel.queue_declare(queue = queue_name, \\n durable = True,\\n auto_delete = False)\",\n \"def small_queue():\\n queue = Queue()\\n queue.enqueue(1)\\n queue.enqueue(2)\\n queue.enqueue(3)\\n queue.enqueue(4)\\n return queue\",\n \"def large_queue():\\n que = Queue()\\n for num in range(1, 11):\\n que.enqueue(num)\\n return que\",\n \"async def declare(self) -> 'Queue':\\n # we are relying to this in other functions\\n self._channel = await self._backend.channel()\\n self.log.debug(\\\"Channel acquired CHANNEL%i\\\",\\n self._channel.channel_number)\\n\\n if self.exchange:\\n await self.declare_exchange()\\n\\n if self.name is not None:\\n await self.declare_queue()\\n\\n if self.exchange:\\n await self.bind_queue()\\n\\n return self\",\n \"def declare(self):\\n self.channel.queue_declare(queue='files_to_database')\",\n \"def new_queue() -> Queue:\\n return multiprocessing.Queue()\",\n \"def producer(networks, q):\\n host_count = 0\\n for network in networks:\\n LOG.debug(f\\\"Producer: working on network {network} queue[current size = {q.qsize()}] {time.strftime('%H:%M:%S')}\\\")\\n num_hosts = len(list(network.hosts()))\\n # Select first 5 hosts add to queue if num_hosts > 10 else add them all\\n if num_hosts > 10:\\n hosts = list(network.hosts())[:5]\\n for host in hosts:\\n q.put(host)\\n host_count += 1\\n else:\\n hosts = list(network.hosts())\\n for host in hosts:\\n q.put(host)\\n host_count += 1\\n # Select last 5 hosts add to queue\\n if num_hosts > 10:\\n hosts = list(network.hosts())[-5:]\\n for host in hosts:\\n q.put(host)\\n host_count += 1\\n # Select 10% of the rest of the hosts add to queue\\n if num_hosts > 10:\\n sample_hosts_len = network.size() // 10\\n hosts = random.sample(list(network.hosts())[5:-5], sample_hosts_len)\\n for host in hosts:\\n q.put(host)\\n host_count += 1\\n return host_count\",\n \"def __init__(self, initial_node):\\n self.__nodes = MinPriorityQueue({initial_node : initial_node.estimate})\",\n \"def small_queue():\\n que = Queue()\\n que.enqueue(1)\\n que.enqueue(2)\\n que.enqueue(3)\\n que.enqueue(4)\\n que.enqueue(5)\\n return que\",\n \"def draw_queue(total_nodes, total_cores, used_cores, empty_nodes, desired_host, \\n disabled_cores, disabled_nodes, node_list, free_cores):\\n \\n if total_cores > 400:\\n screen_size = 119\\n cores_per_row = 39\\n else:\\n screen_size = 100\\n cores_per_row = 30\\n \\n o_core = '[O]'\\n u_core = '[~]'\\n dis_core = '[#]'\\n print('{0} Queue'.format(str(desired_host)).center(screen_size))\\n print('-'.center(screen_size,'-'))\\n print('Total Cores:'.ljust(int(screen_size/2)), end=\\\"\\\")\\n print('{0}'.format(str(total_cores)).ljust(int(screen_size/2)))\\n print('Used Cores:'.ljust(int(screen_size/2)), end=\\\"\\\")\\n print('{0}'.format(str(used_cores)).ljust(int(screen_size/2)))\\n print('Free Cores:'.ljust(int(screen_size/2)), end=\\\"\\\")\\n print('{0}'.format(str(free_cores)).ljust(int(screen_size/2)))\\n print('Disabled/Error Cores:'.ljust(int(screen_size/2)), end=\\\"\\\")\\n print('{0}'.format(str(disabled_cores)).ljust(int(screen_size/2)))\\n print('Total Nodes:'.ljust(int(screen_size/2)),end =\\\"\\\")\\n print('{0}'.format(str(total_nodes)).ljust(int(screen_size/2)))\\n print('-'.center(screen_size, '-'))\\n print(('[0] = Open Core' + PRINT_INDENT + '[~] = Used Core' + PRINT_INDENT + \\\\\\n '[#] = Disabled/Err Core').center(screen_size) + '\\\\n')\\n \\n #Drawing representation of the Queue\\n drawn_cores = 0\\n for node in node_list:\\n if node.get_disabled_switch():\\n for i in range(1, node.total_cores +1):\\n print(dis_core, end=\\\"\\\")\\n drawn_cores += 1\\n if drawn_cores == cores_per_row:\\n drawn_cores = 0\\n print('')\\n continue\\n if node.get_free():\\n for i in range(1, (node.free_cores) +1):\\n print(o_core, end=\\\"\\\")\\n drawn_cores += 1\\n if drawn_cores == cores_per_row:\\n drawn_cores = 0\\n print('')\\n if node.get_used():\\n for i in range(1, (node.used_cores) +1):\\n print(u_core, end=\\\"\\\")\\n drawn_cores += 1\\n if drawn_cores == cores_per_row:\\n drawn_cores = 0\\n print('')\\n print('\\\\n' + '-'.center(screen_size,'-'))\\n return\",\n \"def enqueue(queue, item):\\n new_node = Node(item, None)\\n if empty_queue(queue):\\n queue.front = new_node\\n queue.back = new_node\\n else:\\n queue.back.next = new_node\\n queue.back = new_node\\n queue.size = queue.size + 1\",\n \"def __init__(self, maxsize=0, workers=10):\\n self.queue = JoinableQueue(maxsize=maxsize)\\n [spawn(self.worker) for x in range(workers)]\",\n \"def dynamic_alloc(self, minExecutors=None, maxExecutors=None, initialExecutors=None, fairScheduling=False,\\n maxCores=None):\\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_ENABLED] = 'true'\\n self.sparkProperties[SparkProperties.SPARK_SHUFFLE_SERVICE_ENABLED] = 'true'\\n if maxCores:\\n self.sparkProperties[SparkProperties.SPARK_CORES_MAX] = maxCores\\n if initialExecutors:\\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_INITIALEXECUTORS] = initialExecutors\\n if minExecutors:\\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_MINEXECUTORS] = minExecutors\\n if maxExecutors:\\n self.sparkProperties[SparkProperties.SPARK_DYNAMICALLOCATION_MAXEXECUTORS] = maxExecutors\\n if fairScheduling:\\n self.sparkProperties[SparkProperties.SPARK_SCHEDULER_MODE] = \\\"FAIR\\\"\\n return self\",\n \"def new_queue(self, params, maxUsers=1):\\n self.spotify.reset_queue()\\n\\n #Extract parameters\\n mood = params[0]\\n users = []\\n for i in range(maxUsers):\\n if len(params[i + 1]) > 0:\\n users.append(params[i + 1])\\n\\n #Add default host if only one guest is present\\n # if len(users) == 1:\\n # users.append('Paolo')\\n\\n #Lists to load\\n names = []\\n for n in self.listIDs.keys():\\n for u in users:\\n if len(mood) > 0:\\n if u + ':' + mood in n:\\n names.append(n)\\n else:\\n if 'top:' + u in n:\\n names.append(n)\\n\\n\\n self.add_playlist(names)\",\n \"def process_queue(host_user_list, user_name, user_list):\\n\\n total_nodes = 0\\n total_cores = 0\\n disabled_cores = 0\\n used_cores = 0\\n free_cores = 0\\n empty_nodes = 0\\n disabled_nodes = 0\\n \\n node_strings= []\\n\\n for hostgroup in host_user_list:\\n # Obtain totals for one hostgroup, and contine a summation\\n tc, uc, tn, en, dc,dn, nl = process_host(hostgroup.replace('@',''))\\n\\n # Do not want to recount same nodes. This needs to be looked at for efficiency.\\n nl_strings = [n.name for n in nl]\\n\\n if nl_strings[0] in node_strings:\\n continue\\n\\n # Sum to get totals for whole queue which user has access to\\n total_cores += tc \\n used_cores += uc \\n total_nodes += tn\\n empty_nodes += en\\n disabled_cores += dc\\n disabled_nodes += dn\\n node_strings= node_strings + nl\\n\\n # Send totals to be printed to screen\\n print_host_info(total_cores, used_cores, total_nodes, empty_nodes, \\\"Long Queue\\\", disabled_cores, \\n disabled_nodes)\\n sys.exit(0)\",\n \"def _get_node_list(self, machine_name, max_nodes):\\n\\n q = Queue()\\n # if machine_name.lower() == 'summit':\\n # add relative node names starting with 1 for creating ERF files\\n for i in range(max_nodes):\\n q.put('{}'.format(i+1))\\n return q\",\n \"def start_nodes(self, *node_list, wait_for_everything=None, quiet=False):\\n\\n if not wait_for_everything:\\n wait_for_everything = self.wait_all\\n\\n if not node_list:\\n node_list = self.nodes_waiting_to_start\\n\\n if not wait_for_everything:\\n wait_for_everything = not quiet\\n\\n # node_list can be either names or node dictionaries\\n node_names_to_start = [node['name'] if type(node) == dict else node for node in node_list]\\n\\n threading.Thread(target=self.httpd.serve_forever).start()\\n\\n existing_nodes = self.nodes()\\n\\n names_by_node_id = {node['node_id']:node['name'] for node in existing_nodes}\\n node_ids_by_name = {node['name']:node['node_id'] for node in existing_nodes}\\n\\n all_dependent_nodes = set()\\n for value in self.node_dependencies.values():\\n for node in value:\\n all_dependent_nodes.update((node['node_id'], ))\\n\\n # We assume that if GNS3 reported the node as 'started', that it's ready for service.\\n # This isn't entirely valid, as it might still be booting, but it's OK for now (I hope).\\n\\n running_nodeids = set(node['node_id'] for node in existing_nodes if node['status'] == 'started')\\n\\n waiting_for_nodeids_to_start = set()\\n\\n # If we declare a node that already ran once but isn't running now, we'll treat it\\n # here as a brand new node, start it (at some point in this function) and wait for\\n # it to phone home. The problem is that phone home only happens once-per-instance,\\n # so it will never phone home and we'll wait forever for it.\\n\\n for node_name in node_names_to_start:\\n # If we create a node, start it, then delete it, it will still be listed in\\n # node_names_to_start, but it no longer exists. It won't appear in\\n # node_ids_by_name, so just skip it.\\n if node_name in node_ids_by_name:\\n node_id = node_ids_by_name[node_name]\\n dependencies = self.node_dependencies.get(node_id, [])\\n # we'll need to start all nodes dependent on the nodes to start\\n for v in dependencies:\\n if v['name'] not in node_names_to_start:\\n node_names_to_start.append(v['name'])\\n # if the node isn't running but all of its dependencies are, start it\\n if node_id not in running_nodeids and node_id not in waiting_for_nodeids_to_start:\\n if running_nodeids.issuperset([v['node_id'] for v in dependencies]):\\n self.start_nodeid(node_id, print_console=not quiet)\\n waiting_for_nodeids_to_start.add(node_id)\\n\\n with self.httpd.instance_report_cv:\\n if wait_for_everything:\\n waitlist = waiting_for_nodeids_to_start\\n else:\\n waitlist = waiting_for_nodeids_to_start.intersection(all_dependent_nodes)\\n while waitlist:\\n print('Waiting for', [names_by_node_id[nodeid] for nodeid in waitlist])\\n self.httpd.instance_report_cv.wait()\\n for inst in self.httpd.instances_reported:\\n # Same consideration as before if a node was started and then deleted\\n if inst in node_ids_by_name:\\n running_nodeids.add(node_ids_by_name[inst])\\n if inst in self.telnet_procs:\\n self.telnet_procs[inst].terminate()\\n del self.telnet_procs[inst]\\n\\n waiting_for_nodeids_to_start.difference_update(running_nodeids)\\n\\n candidate_nodes = set()\\n\\n for key, value in self.node_dependencies.items():\\n if key not in waiting_for_nodeids_to_start and key not in running_nodeids:\\n if running_nodeids.issuperset([v['node_id'] for v in value]):\\n candidate_nodes.add(key)\\n\\n for start_node in candidate_nodes:\\n self.start_nodeid(start_node, print_console=not quiet)\\n waiting_for_nodeids_to_start.add(start_node)\\n\\n if wait_for_everything:\\n waitlist = waiting_for_nodeids_to_start\\n else:\\n waitlist = waiting_for_nodeids_to_start.intersection(all_dependent_nodes)\\n\\n self.httpd.shutdown()\",\n \"def enqueue(self, node):\\n self.items.append(node)\",\n \"def __init__(self, name, jobs=[],cores_used=0):\\n \\n self.name = str(name)\\n self.job_list = jobs\\n self.cores_used = cores_used\\n self.node_list = []\",\n \"def make_empty_queue():\\n return Queue(0, None, None)\",\n \"def queue_maker(queue, bucket_name):\\n scraper = key_scraper.KaleidoscopeKeyScraper(\\n bucket_name=bucket_name,\\n queue=queue,\\n )\\n scraper.add_keys_to_queue()\\n\\n return None\",\n \"def __init__(self):\\n self.queues=[]\",\n \"def main(args):\\n\\n\\n _NUM_GROUPS=args.numgroups\\n state = json.load(open(args.jsonfile))\\n\\n nq = gpfs.nodequeue.NodeQueue(state)\\n\\n nq.create_queue(_NUM_GROUPS)\\n nq.print_queue()\",\n \"def requires_matching_queues(self, requires_matching_queues):\\n \\n self._requires_matching_queues = requires_matching_queues\",\n \"def _queue_create(self, **kwargs):\\n name = self.generate_random_name()\\n return self.clients(\\\"zaqar\\\").queue(name, **kwargs)\",\n \"def declare_queue(self, c, queue_name):\\n return self._management_req(\\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\\n {\\\"auto_delete\\\": False, \\\"durable\\\": False, \\\"arguments\\\": {}})\",\n \"def setup_queue(self, method_frame):\\n logger.info('Declaring queue %s', self.queue_name)\\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\\n\\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)\",\n \"def __init__(self):\\r\\n self.point_to_head = MyQueueNode('head')\\r\\n self.point_to_tail = MyQueueNode('tail')\",\n \"def process_host(desired_host):\\n \\n node_list = []\\n host_info_list = [] \\n if desired_host == \\\"all\\\":\\n desired_host_list = getAllMachines()\\n else:\\n desired_host_list = (subprocess.getoutput(\\\"qconf -shgrp_resolved \\\" + '@' + str(desired_host))).split()\\n qstat = subprocess.getoutput('qstat -f')\\n for host in desired_host_list:\\n if qstat.find(host) != (-1):\\n #Searches the long string for the index of the occurance of the specified host, then\\n #parses it the string for just that one line with the host that we want.\\n host_info_list.append((qstat[qstat.find(host):].split('\\\\n'))[0])\\n #Start at with everything at 0, and will count up as encountered.\\n total_nodes = 0\\n total_cores = 0\\n disabled_cores = 0\\n used_cores = 0\\n free_cores = 0\\n empty_nodes = 0\\n disabled_nodes = 0\\n for host in host_info_list:\\n #simply gathering info qstat spat out for us\\n temp_node = Node((host.split()[0]))\\n cores = host.split()[2].replace('/', ' ').split()\\n host_used_cores = cores[1]\\n host_total_cores = cores[2]\\n if len(host.split()) == 6 and (host.split()[5] == 'd' or host.split()[5] == 'E' or \\\\\\n host.split()[5] == 'au' or host.split()[5] == 'Eau' or host.split()[5] == 'Eqw' \\\\\\n or host.split()[5] == 'adu'):\\n temp_node.set_disabled_switch(True)\\n disabled_cores += int(host_total_cores)\\n total_cores += int(host_total_cores)\\n disabled_nodes += 1\\n else: \\n temp_node.set_disabled_switch(False)\\n used_cores += int(host_used_cores)\\n total_cores += int(host_total_cores)\\n free_cores += int(host_total_cores) - int(host_used_cores)\\n if int(host_used_cores) == 0:\\n empty_nodes += 1\\n temp_node.set_cores(host_total_cores, host_used_cores)\\n total_nodes += 1\\n node_list.append(temp_node) \\n \\n if len(sys.argv) == 3:\\n if sys.argv[2] == '--details':\\n print_detailed_host(total_cores, used_cores, total_nodes, empty_nodes, desired_host, \\n disabled_cores, disabled_nodes, node_list)\\n elif sys.argv[2] == '-v' or sys.argv[2] == '--visual':\\n draw_queue(total_nodes, total_cores, used_cores, empty_nodes, desired_host, disabled_cores, \\n disabled_nodes, node_list, free_cores)\\n else:\\n print('Error: Arg syntax error with: ' + sys.argv[2])\\n show_usage(23)\\n elif sys.argv[1] == \\\"-qlong\\\":\\n # Returning values from this host group to the qlong function\\n return(total_cores, used_cores, total_nodes, empty_nodes, disabled_cores,disabled_nodes, node_list)\\n elif len(sys.argv) < 3:\\n print_host_info(total_cores, used_cores, total_nodes, empty_nodes, desired_host, disabled_cores, \\n disabled_nodes)\\n else:\\n print('Error: Too many args')\\n show_usage(23)\\n return\",\n \"def on_channel_open(new_channel):\\n global channel\\n channel = new_channel\\n channel.queue_declare(queue=\\\"test\\\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)\",\n \"def __init__(self, k: int):\\n self.queue = [0]*k\\n self.headIndex = 0\\n self.count = 0\\n self.capacity = k\",\n \"def __init__(self, k):\\n self.queue = [0]*k\\n self.headIndex = 0\\n self.count = 0\\n self.capacity = k\",\n \"def setup_queues():\\n sqs = boto.connect_sqs()\\n sqs.create_queue('mls_parse_requests')\\n sqs.create_queue('mls_fetcher')\",\n \"def __init__(self):\\r\\n self.bucket = []\\r\\n for i in range(4096):\\r\\n self.bucket.append(Node(0,0))\",\n \"def enqueue(self, item, priority):\\n # TODO: Insert given item into heap\\n ...\",\n \"def __init__(self, partition_requests=[], timeout=1000, min_bytes=1024):\\n self.timeout = timeout\\n self.min_bytes = min_bytes\\n self._reqs = defaultdict(dict)\\n for req in partition_requests:\\n self.add_request(req)\",\n \"def add_queue(queues, host=\\\"localhost\\\", port=6379, http_host=\\\"localhost\\\",\\n http_port=DEFAULT_HTTP_PORT, workers=1,\\n unix_domain_socket=None):\\n if http_host.startswith('/'):\\n # This is an unix socket\\n new_http_host = UnixResolver.register_unixsocket(http_host)\\n else:\\n new_http_host = http_host\\n if isinstance(queues, six.string_types):\\n Queues.add(Queue([queues], host=host, port=port,\\n http_host=new_http_host,\\n http_port=http_port, workers=workers,\\n unix_domain_socket=unix_domain_socket))\\n else:\\n Queues.add(Queue(queues, host=host, port=port, http_host=new_http_host,\\n http_port=http_port, workers=workers,\\n unix_domain_socket=unix_domain_socket))\",\n \"def __init__(self, k: int):\\n self.queue = [0]*k\\n self.headIndex = 0\\n self.count = 0\\n self.capacity = k\\n # the additional attribute to protect the access of our queue\\n self.queueLock = Lock()\",\n \"def enqueue(elem: Any, priority: int = 0) -> None:\\n\\tglobal queue\\n\\tqueue.append((priority, elem))\\n\\treturn None\",\n \"def enqueue(self):\\n # TensorFlow Input Pipelines for Large Data Sets\\n # ischlag.github.io\\n # http://ischlag.github.io/2016/11/07/tensorflow-input-pipeline-for-large-datasets/\\n # http://web.stanford.edu/class/cs20si/lectures/slides_09.pdf\\n under = 0\\n max = len(self.train_x)\\n try:\\n while not self.coord.should_stop():\\n # print(\\\"starting to write into queue\\\")\\n upper = under + self.capacity\\n # print(\\\"try to enqueue \\\", under, \\\" to \\\", upper)\\n if upper <= max:\\n curr_x = self.train_x[under:upper]\\n curr_t = self.train_t[under:upper]\\n curr_e = self.train_e[under:upper]\\n under = upper\\n else:\\n rest = upper - max\\n curr_x = np.concatenate((self.train_x[under:max], self.train_x[0:rest]))\\n curr_t = np.concatenate((self.train_t[under:max], self.train_t[0:rest]))\\n curr_e = np.concatenate((self.train_e[under:max], self.train_e[0:rest]))\\n under = rest\\n\\n self.session.run(self.enqueue_op,\\n feed_dict={self.x: curr_x, self.t: curr_t, self.e: curr_e})\\n except tf.errors.CancelledError:\\n print(\\\"finished enqueueing\\\")\",\n \"def queue_enqueue(queue, targets):\\n\\n enqueued = []\\n for target in map(lambda x: x.strip(), targets):\\n if target != '':\\n enqueued.append({'target': target, 'queue_id': queue.id})\\n if enqueued:\\n db.session.execute(Target.__table__.insert().values(enqueued))\\n db.session.commit()\",\n \"def create_queue(data_size,\\n num_steps,\\n capacity=128,\\n dtype=tf.int32):\\n\\n # Feeds for inputs.\\n input_data = tf.placeholder(\\n dtype, shape=[data_size, num_steps], name=\\\"input_data\\\")\\n\\n targets = tf.placeholder(\\n dtype, shape=[data_size, num_steps], name=\\\"targets\\\")\\n\\n queue = tf.FIFOQueue(\\n capacity=capacity,\\n # min_after_dequeue=min_after_dequeue,\\n dtypes=[dtype, dtype],\\n shapes=[[num_steps]] * 2)\\n\\n enqueue_op = queue.enqueue_many(\\n [input_data, targets])\\n\\n placeholders = {\\n \\\"input_data\\\": input_data,\\n \\\"targets\\\": targets\\n }\\n\\n return queue, enqueue_op, placeholders\",\n \"def spam( self, node ):\\n map( lambda queue: queue.put( node ), self.state[ 'qout' ] )\",\n \"async def _connect(self):\\n self._connection = await connect_robust(self._connection_string)\\n self._channel = await self._connection.channel()\\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})\",\n \"def populateQueue(self, graph, queue, parent):\\n\\t\\t# get possible moves\\n\\t\\tmoves = graph.getMoves()\\n\\n\\t\\t# put into queue all the moves possible\\n\\t\\tfor move in moves:\\n\\t\\t\\t# make move and get copy\\n\\t\\t\\tnewBoard = graph.copyConfidentMove(move)\\n\\n\\t\\t\\t# calculate heuristic for this move that was made\\n\\t\\t\\th = self.heuristic(newBoard)\\n\\n\\t\\t\\t# create node\\n\\t\\t\\tnode = AStarNode(newBoard, move, parent, parent.g + 1, h)\\n\\n\\t\\t\\t# put the node in priority queue\\n\\t\\t\\tqueue.put((node.cost(), node))\",\n \"def initialize_executor(self, queue_to_lower: multiprocessing.Queue, queue_from_lower: multiprocessing.Queue, cs: BaseContentStore, classic: bool = False):\\n self.queue_to_lower = queue_to_lower\\n self.queue_from_lower = queue_from_lower\\n self.cs = cs\\n self.classic = classic\",\n \"def __init__(self, nodes, cost=float('inf')):\\n self.nodes = nodes\\n self.cost = cost\\n self.backset = set()\\n self.backptr = None\\n self.collision_set = set()\",\n \"def __init__(self, n=1, cpu=.1, bw=10, delay=100,\\n max_queue_size=None, **params):\\n\\n # Initialize topo\\n Topo.__init__(self, **params)\\n assert(n > 0)\\n self.n = n\\n\\n # Host and link configuration\\n hconfig = {'cpu': cpu}\\n lconfig = {'bw': bw, 'delay': ('%sms' % delay),\\n 'max_queue_size': max_queue_size, 'loss': args.loss}\\n \\n serverSwitch = self.add_switch('s1')\\n clientSwitch = self.add_switch('s2')\\n \\n self.add_link(serverSwitch, clientSwitch, 0, 0, **lconfig)\\n \\n for i in range(1, args.hosts + 1):\\n server = self.add_host('server' + str(i), **hconfig)\\n client = self.add_host('client' + str(i), **hconfig)\\n \\n self.add_link(server, serverSwitch, 0, i)\\n self.add_link(client, clientSwitch, 0, i)\",\n \"def constraint(self):\\n with self.mutating:\\n self.queue = heapq.nsmallest(self.max_size, self.queue)\\n heapq.heapify(self.queue)\",\n \"def __init__(self, n=1, delay='1ms', z=1, bw=1, cpu=.1, max_queue_size=None, **params):\\n\\n # Initialize topo\\n Topo.__init__(self, **params)\\n\\n #TODO: Create your Dynamic Mininet Topology here!\\n #NOTE: You MUST label switches as s1, s2, ... sz\\n #NOTE: You MUST label hosts as h1-1, h1-2, ... hz-n \\n #HINT: Use a loop to construct the topology in pieces.\",\n \"def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\\n amqp_session = self.__broker.getAmqpSession()\\n if arguments == None:\\n arguments = {}\\n if alt_exchange_name:\\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\\n durable=durable, arguments=arguments)\\n else:\\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)\",\n \"def test_initialization_with_empty_list_first_node_check():\\n queue = Queue([])\\n assert queue._queue.first_node is None\",\n \"def m_cliques(adj_list,labels,matrix,topology=\\\"clique\\\",cut=0):\\n num_clusters = list(np.unique(labels))\\n clusters = {i:[] for i in num_clusters}\\n print(\\\"m_cliques CUT:\\\", cut)\\n #Add nodes to clusters\\n for idx,n in enumerate(adj_list):\\n clusters[labels[idx]].append(n)\\n \\n if topology == \\\"sample_rand\\\":\\n G_cliques = sampled_clique(clusters,\\\"rand\\\")\\n print(\\\"Rand sampled clique size:\\\", G_cliques.number_of_nodes())\\n elif topology == \\\"sample_optim\\\":\\n G_cliques = sampled_clique(clusters,\\\"optim\\\")\\n print(\\\"Optim sampled clique size:\\\", G_cliques.number_of_nodes())\\n elif topology == \\\"pcc_rand\\\":\\n G_cliques = pcc_clique(clusters,\\\"rand\\\",labels,cut)\\n print(\\\"Rand sampled clique size:\\\", G_cliques.number_of_nodes())\\n elif topology == \\\"pcc_optim\\\":\\n G_cliques = pcc_clique(clusters,\\\"optim\\\",labels,cut)\\n print(\\\"Optim sampled clique size:\\\", G_cliques.number_of_nodes())\\n elif topology == \\\"pcc_greedy\\\":\\n G_cliques = pcc_clique(clusters,\\\"greedy\\\",labels,cut,matrix)\\n print(\\\"Greedy sampled clique size:\\\", G_cliques.number_of_nodes())\\n else:\\n G_cliques = nx.Graph()\\n cliques = []\\n while not is_empty(clusters):\\n clique = []\\n \\n #Add clique nodes\\n for _,cluster in clusters.items():\\n if len(cluster) > 0:\\n n = random.choice(cluster)\\n clique.append(n)\\n cluster.remove(n)\\n \\n #Cliqify\\n for n1 in clique:\\n for n2 in clique:\\n if n1 != n2:\\n G_cliques.add_edge(n1,n2)\\n \\n #Aggregate clique\\n cliques.append(clique)\\n\\n if topology == \\\"clique\\\":\\n clique_the_cliques(cliques,labels,G_cliques)\\n elif topology == \\\"ring\\\":\\n cliques_on_ring(cliques,labels,G_cliques)\\n \\n return G_cliques\",\n \"def __init__(self):\\n self.queue = []\\n self.queue.append(Queue())\\n self.queue.append(Queue())\\n self.tag = 0 # using to record which queue contain the data\",\n \"def setup_node(\\n *,\\n # Change this to take host, user, and identity_file?\\n # Add some kind of caching for SSH connections so that they\\n # can be looked up by host and reused?\\n ssh_client: paramiko.client.SSHClient,\\n services: list,\\n cluster: FlintrockCluster):\\n host = ssh_client.get_transport().getpeername()[0]\\n ssh_check_output(\\n client=ssh_client,\\n command=\\\"\\\"\\\"\\n set -e\\n\\n echo {private_key} > \\\"$HOME/.ssh/id_rsa\\\"\\n echo {public_key} >> \\\"$HOME/.ssh/authorized_keys\\\"\\n\\n chmod 400 \\\"$HOME/.ssh/id_rsa\\\"\\n \\\"\\\"\\\".format(\\n private_key=shlex.quote(cluster.ssh_key_pair.private),\\n public_key=shlex.quote(cluster.ssh_key_pair.public)))\\n\\n with ssh_client.open_sftp() as sftp:\\n sftp.put(\\n localpath=os.path.join(SCRIPTS_DIR, 'setup-ephemeral-storage.py'),\\n remotepath='/tmp/setup-ephemeral-storage.py')\\n\\n logger.info(\\\"[{h}] Configuring ephemeral storage...\\\".format(h=host))\\n # TODO: Print some kind of warning if storage is large, since formatting\\n # will take several minutes (~4 minutes for 2TB).\\n storage_dirs_raw = ssh_check_output(\\n client=ssh_client,\\n command=\\\"\\\"\\\"\\n set -e\\n python /tmp/setup-ephemeral-storage.py\\n rm -f /tmp/setup-ephemeral-storage.py\\n \\\"\\\"\\\")\\n storage_dirs = json.loads(storage_dirs_raw)\\n\\n cluster.storage_dirs.root = storage_dirs['root']\\n cluster.storage_dirs.ephemeral = storage_dirs['ephemeral']\\n\\n ensure_java8(ssh_client)\\n\\n for service in services:\\n service.install(\\n ssh_client=ssh_client,\\n cluster=cluster)\",\n \"def on_queue_declared(frame):\\n start_consuming(frame)\",\n \"def __init__(self, threads_count):\\n\\n self.queue = Queue(threads_count)\\n\\n self.threads = []\\n self.device = None\\n\\n self.create_workers(threads_count)\\n self.start_workers()\",\n \"def pushPriorityQueue(self, node):\\r\\n if self.priority == \\\"bin\\\":\\r\\n heappush(self.unvisited, node)\\r\\n elif self.priority == \\\"fib\\\":\\r\\n fheappush(self.unvisited, node)\\r\\n else: # list\\r\\n self.unvisited.append(node)\",\n \"def create_initial_priority_queue(self, t_max=None):\\n for particle_number in range(self.N): # iterate through each particle\\n self.add_collision_horizontal_wall_to_queue(particle_number, 0) # add collision with horizontal wall\\n self.add_collision_vertical_wall_to_queue(particle_number, 0) # add collision with vertical wall\\n self.add_collision_tb_wall_to_queue(particle_number, 0) # add collision with tb wall\\n self.add_collisions_particle_to_queue(particle_number, 0, t_max) # add collisions with other particles\",\n \"def add_a_queue(self, size):\\n \\tself.queues.append(ContextModalityQueue(size))\",\n \"def priority_queue():\\n from src.priorityq import PriorityQueue\\n priority_queue = PriorityQueue()\\n return priority_queue\",\n \"def main(nodelist):\\n log.debug(f\\\"SuspendProgram {nodelist}\\\")\\n nodes = util.to_hostnames(nodelist)\\n\\n # Filter out nodes not in config.yaml\\n cloud_nodes, local_nodes = lkp.filter_nodes(nodes)\\n if len(local_nodes) > 0:\\n log.debug(\\n f\\\"Ignoring slurm-gcp external nodes '{util.to_hostlist(local_nodes)}' from '{nodelist}'\\\"\\n )\\n if len(cloud_nodes) > 0:\\n log.debug(\\n f\\\"Using cloud nodes '{util.to_hostlist(cloud_nodes)}' from '{nodelist}'\\\"\\n )\\n else:\\n log.debug(\\\"No cloud nodes to suspend\\\")\\n return\\n\\n # suspend is allowed to delete exclusive nodes\\n log.info(f\\\"suspend {nodelist}\\\")\\n suspend_nodes(nodes)\",\n \"def sync_idle_nodes(client_queue, free_nodes):\\n\\n idle_nodes = []\\n if len(client_queue) == 0:\\n print_rank(f\\\"Free idle nodes {len(free_nodes)}\\\", loglevel=logging.DEBUG)\\n while len(free_nodes) > 0:\\n node = free_nodes.pop()\\n idle_nodes.append(node)\\n _send(COMMAND_SYNC_NODES, node)\\n return idle_nodes\",\n \"def setup_queues_and_bindings(self):\\n self._channel.exchange_declare(self.setup_queue, exchange=self.exchange, passive=True)\",\n \"def _declare(self, passive=False):\\n arguments = dict(self._arguments)\\n if self._expires:\\n arguments['x-expires'] = self._expires\\n if self._message_ttl:\\n arguments['x-message-ttl'] = self._message_ttl\\n if self._max_length:\\n arguments['x-max-length'] = self._max_length\\n if self._dlx:\\n arguments['x-dead-letter-exchange'] = self._dlx\\n if self._dlr:\\n arguments['x-dead-letter-routing-key'] = self._dlr\\n return specification.Queue.Declare(queue=self.name,\\n durable=self._durable,\\n passive=passive,\\n exclusive=self._exclusive,\\n auto_delete=self._auto_delete,\\n arguments=arguments)\",\n \"def creator(data, q):\\n print('Creating data and putting it on the queue')\\n for item in data:\\n q.put(item)\",\n \"def resize_for_new_nodes(new_total_nodes, k8s, cluster, test=False):\\n if confirm((\\\"Resizing up to: %d nodes\\\" % new_total_nodes)):\\n scale_logger.info(\\\"Resizing up to: %d nodes\\\", new_total_nodes)\\n if not test:\\n cluster.add_new_node(new_total_nodes)\\n wait_time = 130\\n scale_logger.debug(\\n \\\"Sleeping for %i seconds for the node to be ready for populating\\\", wait_time)\\n time.sleep(wait_time)\\n populate(k8s)\",\n \"def enqueue(self, name):\\n pass\",\n \"def metis_partition(G):\\n partition_list = partition(G, 2)[1]\\n for i in range(2):\\n for username in partition_list[i]:\\n G.add_node(username, cluster=i)\\n \\n return G\",\n \"def enqueue(self, new_data):\\n new_node = Node(new_data)\\n current = self.front\\n\\n if current is None:\\n self.front = new_node\\n else:\\n while current.getPtr() is not None:\\n current = current.getPtr()\\n\\n current.setPtr(new_node)\",\n \"def __init__(self, name=None, nodes=None):\\n super(Graph, self).__init__(name=name)\\n self._nodes = nodes or []\",\n \"def create_nodes_heap(self, graph):\\n min_heap = []\\n for label, node in self.graph.nodes.items():\\n node_container = NodeContainer(node)\\n heappush(min_heap, node_container)\\n\\n return min_heap\",\n \"def __init__(self, nodes=None, edges=None):\\n self._nodes = []\\n self.nodes = nodes\\n self._edges = []\\n self.edges = edges\\n self._create_connections()\\n self._sorted_nodes = None\\n self._node_wip = []\",\n \"def simulateArrivalOfJobs(env, processes, batchQ):\\n for p in processes:\\n batchQ.addToBq(p)\",\n \"def simulateArrivalOfJobs(env, processes, batchQ):\\n for p in processes:\\n batchQ.addToBq(p)\",\n \"def __init__(self, num_nodes):\\n self.graph = sps.lil_matrix((num_nodes, num_nodes))\\n self.size = num_nodes\",\n \"def make_heap(self, frequency):\\n\\n\\n\\t\\t\\tfor key in frequency:\\n\\t\\t\\t\\tnode = self.HeapNode(key, frequency[key])#instaciamos un nodo con el valor y frecuencia\\n\\t\\t\\t\\theapq.heappush(self.heap, node)#agregamos el nodo al priority queue\",\n \"def __init__(self, parallel_server):\\n self.queue = deque()\\n self.parallel_server = parallel_server\",\n \"def __init__(self, **params):\\n\\n # Initialize topo\\n Topo.__init__(self, **params)\\n\\n # Host and link configuration\\n hostConfiguration = {'cpu': cpuShare()}\\n linkConfiguration = {'bw': args.bandwidth, 'delay': delay(), 'max_queue_len': args.input_queue_size }\\n \\n # Create the actual topology\\n client = self.add_host( 'client0', **hostConfiguration )\\n \\n switch = self.add_switch('switch0' )\\n \\n self.add_link( switch, client, port1=0, port2=0, **linkConfiguration )\\n \\n for i in range(1,args.servers+1):\\n server = self.add_host( 'server%d' % i, **hostConfiguration )\\n self.add_link( switch, server, port1=i, port2=0, **linkConfiguration )\",\n \"def enqueue(self, data):\\n\\n node = Node(data)\\n\\n if self.front == None and self.rear == None:\\n\\n self.front = node\\n self.rear = node\\n\\n else:\\n\\n self.rear.next = node\\n self.rear = self.rear.next\",\n \"def perform_setup():\\n global credentials, connection, channel\\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\\"127.0.0.1\\\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\\n channel = connection.channel()\\n channel.queue_declare(queue='poll', durable=True)\",\n \"def enqueue(Q, x):\\n # Q.append(x)\\n Q.put_nowait(x)\\n if debug: \\n print(\\\"enqueue\\\", x, \\\":\\\", end=\\\" \\\")\\n show_queue(Q)\\n return Q\",\n \"def test_create_qos_queue(self):\\r\\n resource = 'qos_queue'\\r\\n cmd = qos.CreateQoSQueue(\\r\\n test_cli20.MyApp(sys.stdout), None)\\r\\n myid = 'myid'\\r\\n name = 'my_queue'\\r\\n default = False\\r\\n args = ['--default', default, name]\\r\\n position_names = ['name', 'default']\\r\\n position_values = [name, default]\\r\\n self._test_create_resource(resource, cmd, name, myid, args,\\r\\n position_names, position_values)\",\n \"def enqueue(self, item):\\n if self.rear == None:\\n self.front = Node(item)\\n self.rear = self.front\\n else:\\n self.rear.next = Node(item)\\n self.rear = self.rear.next\",\n \"def enqueue(self, otp_params, local_params, server, server_nonce):\\n info = 'yk_publicname=%(yk_publicname)s&yk_counter=%(yk_counter)s' % otp_params\\n info += '&yk_use=%(yk_use)s&yk_high=%(yk_high)s&yk_low=%(yk_low)s' % otp_params\\n info += '&nonce=%(nonce)s' % otp_params\\n info += ',&local_counter=%(yk_counter)s&local_use=%(yk_use)s' % local_params\\n query = \\\"\\\"\\\"INSERT INTO queue (\\n queued,\\n modified,\\n otp,\\n server,\\n server_nonce,\\n info\\n ) VALUES (%s, %s, %s, %s, %s, %s)\\\"\\\"\\\"\\n self._execute(query, (int(time.time()), otp_params['modified'],\\n otp_params['otp'], server, server_nonce, info))\",\n \"def get_jobqueue_cluster(walltime='12:00', ncpus=1, cores=1, local_directory=None, memory='15GB', env_extra=None, **kwargs):\\n import dask\\n # this is necessary to ensure that workers get the job script from stdin\\n dask.config.set({\\\"jobqueue.lsf.use-stdin\\\": True})\\n from dask_jobqueue import LSFCluster\\n import os\\n\\n if env_extra is None:\\n env_extra = [\\n \\\"export NUM_MKL_THREADS=1\\\",\\n \\\"export OPENBLAS_NUM_THREADS=1\\\",\\n \\\"export OPENMP_NUM_THREADS=1\\\",\\n \\\"export OMP_NUM_THREADS=1\\\",\\n ]\\n\\n if local_directory is None:\\n local_directory = '/scratch/' + os.environ['USER'] + '/'\\n\\n cluster = LSFCluster(queue='normal',\\n walltime=walltime,\\n ncpus=ncpus,\\n cores=cores,\\n local_directory=local_directory,\\n memory=memory,\\n env_extra=env_extra,\\n job_extra=[\\\"-o /dev/null\\\"],\\n **kwargs)\\n return cluster\",\n \"def runQueueEnqueue(self):\\n raise NotImplementedError\",\n \"def init(number_of_workers=0):\\n global _wq, _use_workers\\n\\n if number_of_workers:\\n _use_workers = number_of_workers\\n else:\\n _use_workers = benchmark_workers()\\n\\n # if it is best to use zero workers, then use that.\\n _wq = WorkerQueue(_use_workers)\",\n \"def __init__(self, globalQueue, primaryNetwork, actionSpace):\\n\\n self.globalQueue = globalQueue\\n self.killed = False\\n self.net = primaryNetwork\\n self.numUpdated = 0\\n self.actionSpace = actionSpace\",\n \"def enqueue(self, value): ################# <-\\n self.top = Node(value, next=self.top)\",\n \"def enqueue(self, value): ################# <-\\n self.top = Node(value, next=self.top)\",\n \"def global_queue(n=None,\\n delay=3.0,\\n verbose=True,\\n enable=True,\\n namespace: str = None):\\n if n is None:\\n n = ENV.global_lock or 1\\n if namespace is None:\\n namespace = ENV.namespace\\n\\n if enable:\\n return FileQueue(n=n,\\n delay=delay,\\n verbose=verbose,\\n file_prefix=f'mlkit{namespace}.queue')\\n else:\\n return nullcontext()\",\n \"def __init__(self): # 1+1+1+1+1 => O(1)\\n self._capacity = 7 #O(1)\\n self._queue = [None] * self._capacity #O(1)\\n self._size = 0 #O(1)\\n self._start = 0 #O(1)\\n self._end = 0 #O(1)\",\n \"def test_ipc_queues():\\n IPCComm.ipc_queues()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62286747","0.60477805","0.58977777","0.5751411","0.5699497","0.5601299","0.5536529","0.5517704","0.55171967","0.54711384","0.54707986","0.5445398","0.5411856","0.54114914","0.5409894","0.53511775","0.5346529","0.5311034","0.52988267","0.5228136","0.5223217","0.5207306","0.5180689","0.51797485","0.51612234","0.5155036","0.51525354","0.5150576","0.51254225","0.5097606","0.50918764","0.5082153","0.50768626","0.5076428","0.5072314","0.50642633","0.50600475","0.5059135","0.505619","0.50389737","0.49946412","0.4992902","0.4960645","0.494404","0.49416354","0.49233922","0.49233875","0.4922271","0.4911294","0.49109286","0.49098462","0.4908914","0.49036714","0.4903542","0.49034008","0.49020624","0.49007064","0.4871336","0.4864072","0.48559672","0.48541233","0.4842601","0.48273373","0.48262098","0.4823711","0.48229808","0.48120683","0.4809148","0.48022172","0.48003015","0.47972274","0.47956982","0.47916958","0.47854114","0.47821686","0.47805545","0.47805437","0.4768199","0.4767916","0.4766166","0.4766166","0.47660968","0.47660875","0.47657344","0.4760026","0.4750592","0.47465777","0.474515","0.4745133","0.4744986","0.47423705","0.47357142","0.47335732","0.47325313","0.47289613","0.4727966","0.4727966","0.47278842","0.47219646","0.47218257"],"string":"[\n \"0.62286747\",\n \"0.60477805\",\n \"0.58977777\",\n \"0.5751411\",\n \"0.5699497\",\n \"0.5601299\",\n \"0.5536529\",\n \"0.5517704\",\n \"0.55171967\",\n \"0.54711384\",\n \"0.54707986\",\n \"0.5445398\",\n \"0.5411856\",\n \"0.54114914\",\n \"0.5409894\",\n \"0.53511775\",\n \"0.5346529\",\n \"0.5311034\",\n \"0.52988267\",\n \"0.5228136\",\n \"0.5223217\",\n \"0.5207306\",\n \"0.5180689\",\n \"0.51797485\",\n \"0.51612234\",\n \"0.5155036\",\n \"0.51525354\",\n \"0.5150576\",\n \"0.51254225\",\n \"0.5097606\",\n \"0.50918764\",\n \"0.5082153\",\n \"0.50768626\",\n \"0.5076428\",\n \"0.5072314\",\n \"0.50642633\",\n \"0.50600475\",\n \"0.5059135\",\n \"0.505619\",\n \"0.50389737\",\n \"0.49946412\",\n \"0.4992902\",\n \"0.4960645\",\n \"0.494404\",\n \"0.49416354\",\n \"0.49233922\",\n \"0.49233875\",\n \"0.4922271\",\n \"0.4911294\",\n \"0.49109286\",\n \"0.49098462\",\n \"0.4908914\",\n \"0.49036714\",\n \"0.4903542\",\n \"0.49034008\",\n \"0.49020624\",\n \"0.49007064\",\n \"0.4871336\",\n \"0.4864072\",\n \"0.48559672\",\n \"0.48541233\",\n \"0.4842601\",\n \"0.48273373\",\n \"0.48262098\",\n \"0.4823711\",\n \"0.48229808\",\n \"0.48120683\",\n \"0.4809148\",\n \"0.48022172\",\n \"0.48003015\",\n \"0.47972274\",\n \"0.47956982\",\n \"0.47916958\",\n \"0.47854114\",\n \"0.47821686\",\n \"0.47805545\",\n \"0.47805437\",\n \"0.4768199\",\n \"0.4767916\",\n \"0.4766166\",\n \"0.4766166\",\n \"0.47660968\",\n \"0.47660875\",\n \"0.47657344\",\n \"0.4760026\",\n \"0.4750592\",\n \"0.47465777\",\n \"0.474515\",\n \"0.4745133\",\n \"0.4744986\",\n \"0.47423705\",\n \"0.47357142\",\n \"0.47335732\",\n \"0.47325313\",\n \"0.47289613\",\n \"0.4727966\",\n \"0.4727966\",\n \"0.47278842\",\n \"0.47219646\",\n \"0.47218257\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57938516"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":93086,"cells":{"query":{"kind":"string","value":"Purge the queue of all of its messages."},"document":{"kind":"string","value":"def purge(self):\n self._rpc(specification.Queue.Purge())"},"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 clearQueueAll():","def clear_queue(self):\n while not self.queue.empty():\n self.queue.get()","def clear_queue(self):\n\t\t\tself.message_queue.clear()\n\t\t\treturn self.message_queue","def clear_messages(self):\n self.redis_client.delete(self.message_list)","def flush_msg_queue(self):\n if self.msg_queue is None:\n return\n while not self.msg_queue.empty():\n self.msg_queue.get()","def clear(self):\r\n try:\r\n while not self._queue.empty():\r\n self._queue.get().close()\r\n except:\r\n pass","def __clear_message_queue(self):\r\n self.__lib.CC_ClearMessageQueue(self.__serno)","def clear(self):\n self.queue.clear()","def drop_message(self):\n heapq.heappop(self._message_queue)","def clear_messages(self):\n with self.message_lock:\n self.messages = self.messages[self._processed_messages:]\n self._processed_messages = 0","def purge_queue(client, queue):\n channel = client.channel()\n\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\n channel.queue_purge(queue)\n channel.close()","def purge_mailbox(self):\n self._mailbox.clear()","def PurgeAll(self):\n\t\tself.acad.ActiveDocument.PurgeAll()","def purge(self):\n while self.bus.inWaiting() > 0:\n self.bus.read(self.bus.inWaiting())","def clear_queue(self):\n self.queue = deque()","def remove_all(self):\n if self._processed:\n res, messages = self._mailconn.search(None, 'ALL')\n if res == 'OK':\n for msg in messages[0].split():\n res, data = self._mailconn.store(msg.decode('utf-8'), '+FLAGS', '\\\\Deleted')\n print(res)","def _purge(self):\n for _ in self.all():\n self.delete(_)","async def clear(ctx, messages=5):\n await ctx.channel.purge(\n limit=messages + 1\n ) # the clear command counts as a message, so be sure to remove it too","def _queue_delete(self, queue):\n\n queue.delete()","def flushMsgs(self):\n\n self.queue = self.pre_queue[:]\n self.pre_queue = []","def purge_manager(self) -> None:\n\n self.logger.debug(f\"Beginning purging of {self.name}\")\n # Don't need to join an empty queue, likely will result in more issues if you do.\n if self.input_queue.empty():\n self.logger.debug(f\"Input Queue of {self.name} is empty.\")\n else:\n # Try to process all the remaining values put in (no need to change behavior around poison pills)\n while not self.input_queue.empty():\n try:\n task = self.input_queue.get_nowait()\n self.logger.debug(f\"Receiving Task to purge: {task.get_job_id()}\")\n self.error_queue.put(task)\n # NOTE: This sleep call may be unnecessary but I placed it here to err on the side of caution.\n sleep(1)\n self.input_queue.task_done()\n except:\n break\n # NOTE: This loop is a bit hacky probably, but it does ensure that the correct number of task_done calls are made.\n # NOTE: This is meant to handle any \"unfinished tasks\" (meaning ones that haven't had their task_done calls).\n while not self.input_queue._unfinished_tasks._semlock._is_zero():\n self.input_queue.task_done()\n self.restart_required = True","def purge(self):\n pass","def delete_all_messages(self):\n\t\tassert len(self.data) > 0, \"Data file is already empty!\"\n\n\t\tfor element in self:\n\t\t\tself.data.remove(element)\n\n\t\tself.update_data()","def clear(self):\n self.queue = Queue()","def clean(self):\r\n # Note that we do not close the connection here -- somebody\r\n # may still be reading from it.\r\n while len(self.queue) > 0 and self._pair_stale(self.queue[0]):\r\n self.queue.pop(0)","def delete_messages(self):\n msgs_body = []\n if not self.messages:\n u_print(\" Queue.delete_messages() ERR - There is no messages or malformed messages on queue. \")\n u_print(json.dumps(self.messages, indent=4))\n sys.exit(1)\n\n try:\n for m in self.messages:\n u_print_d(\" Queue.delete_messages() Deleting the message: {}\".format(m.message_id))\n r = self.queue.delete_messages(Entries=[\n {\n 'Id': m.message_id,\n 'ReceiptHandle': m.receipt_handle\n },\n ])\n u_print_d(\" Queue.delete_messages() Deletied: {}\".format(r))\n self.stats_update('msgs_deleted', m.message_id)\n except:\n raise\n\n return msgs_body","def delete_messages(self):\n if not self.processed_messages:\n LOGGER.error('No processed messages to delete')\n return\n\n while self.processed_messages:\n len_processed_messages = len(self.processed_messages)\n batch = len_processed_messages if len_processed_messages < 10 else 10\n\n # Delete_batch can only process up to 10 messages\n message_batch = [self.processed_messages.pop() for _ in range(batch)]\n\n resp = self.sqs_client.delete_message_batch(\n QueueUrl=self.athena_sqs_url,\n Entries=[{'Id': message['MessageId'],\n 'ReceiptHandle': message['ReceiptHandle']}\n for message in message_batch]\n )\n LOGGER.info('Successfully deleted %s messages from the queue',\n len(resp['Successful']))","def clear(self):\n with self._not_full:\n with self._not_empty:\n with self._mutex:\n self.close()\n self._queue.clear()\n self._cur_size = 0","def delete_queue(self):\n self.work_queue_client.delete_queue()","def prune_dropped_messages(self) -> None:\n # Remember that the message map and queue of dropped messages are\n # concurrently modified so sizes are estimates.\n sizeest = len(self.droppedmsgs) # warning: O(n) operation\n if sizeest > self.DROP_TRIGGER:\n dropcount = sizeest // 2\n _TRACE(\"PURGE Purging about %s force-dropped messages\",\n dropcount)\n for mrec in _utils.getsome(self.droppedmsgs.pop, dropcount):\n self.msgmap.remove_instance(mrec.id, mrec) # O(log(n))","def clear(self):\n\n if not self.connected:\n raise QueueNotConnectedError(\"Queue is not Connected\")\n\n self.__db.delete(self._key)\n self.__db.delete(self._lock_key)","def pop_all(self):\n with self.lock:\n output = list(self.queue)\n self.queue.clear()\n\n return output","async def delAllMsg(self, waitingTime=0):\n for msg in self.msgToDelete:\n await msg.delete(delay=waitingTime)","def purce_all_dropped_messages(self) -> None:\n for mrec in _utils.getsome(self.droppedmsgs.pop):\n self.msgmap.remove_instance(mrec.id, mrec) # O(log(n))","def clearQueue(targets):","def drain(queue):\n while not queue.is_empty():\n queue.remove()","async def clear(ctx, amount=10):\n\tawait ctx.channel.purge(limit=amount + 1)","async def purge(self, ctx, count: int):\n await ctx.channel.purge(limit=count+1)","def unsubscribe(self):\n\n # Unsubscribe\n self.pyrps.redis.srem(self.pyrps._ns_subscriptions(self.queue), self.consumer_id) \n\n # Remove message queue\n self.pyrps.redis.delete(self.pyrps._ns_queue(self.queue, self.consumer_id))","def clearDownloadQueue(self):\n #print(\"CLEAR DOWNLOAD QUEUE\")\n self.downloadQueue = []\n self.clearEvents()","async def purge(self, ctx, limit: int, flags=\"\"):\n\n await ctx.message.delete()\n if \"all\" in flags:\n await ctx.message.channel.purge(limit=limit)\n else:\n await ctx.message.channel.purge(limit=limit,\n check=lambda msg: not msg.pinned\n and not msg.attachments)","def _cleanUp(self):\r\n limit = datetime.now() - timedelta(seconds=self._timeout)\r\n\r\n toClean = [msg for msg in self._incompleteMsgs if msg.older(limit)]\r\n\r\n if toClean:\r\n for msg in toClean:\r\n self._incompleteMsgs.remove(msg)\r\n\r\n log.msg('{0} incomplete messages have been dropped '\r\n 'from assembler.'.format(len(toClean)))\r\n\r\n toClean = [uri for uri, (_, timestamp) in self._binaries.iteritems()\r\n if timestamp < limit]\r\n\r\n if toClean:\r\n for uri in toClean:\r\n del self._binaries[uri]\r\n\r\n log.msg('{0} unused binaries have been dropped '\r\n 'from assembler.'.format(len(toClean)))","async def purge(\n self, no_wait: bool = False, timeout: TimeoutType = None,\n ) -> aiormq.spec.Queue.PurgeOk:\n\n log.info(\"Purging queue: %r\", self)\n\n channel = await self.channel.get_underlay_channel()\n return await channel.queue_purge(\n self.name, nowait=no_wait, timeout=timeout,\n )","def clean_queue(queue):\n yield queue\n\n # Clean the dirty queue\n queue.join()\n\n # Check for clean shutdown\n assert queue.qsize == 0\n assert queue.inprogress_size == 0","def clear(self):\n self.background_scheduler.remove_all_jobs()","def surge_purge(self):\n\n # Sends all packets!\n for x in self.packet_pool:\n self.accept(x)\n\n pool_len = len(self.packet_pool)\n\n self.print_clear()\n self.print(\"[!] Packets sent: {} - Surge Interval: {:.2f}s\".format(pool_len, self.collection_period), end='\\r')\n\n self.packet_pool = []\n self.start_purge_monitor()","def _purge():\r\n _cache.clear()","async def clear(self, ctx, amount: int = 2):\n loading_msg = await ctx.send(content=f\"Deleting {amount} messages.\")\n\n def check(m):\n return m.id != loading_msg.id\n\n await ctx.channel.purge(limit=amount, check=check)\n await loading_msg.edit(content=f\"{amount} messages have been deleted.\")","def reset_queue(self, db_session):\n for player in self.player_queue.queue:\n self.command_queue.appendleft(('_delete_last_row', {}))\n self.player_queue = PlayerQueue.PlayerQueue()\n db_session.execute(sqlalchemy.update(db.User.__table__, values={db.User.__table__.c.times_played: 0}))\n self._add_to_chat_queue('The queue has been emptied and all players start fresh.')","def on_queue_clear_command(self, event):\n self.pre_check(event)\n self.same_channel_check(event)\n if self.get_player(event.guild.id).queue:\n self.get_player(event.guild.id).queue.clear()\n api_loop(event.channel.send_message, \"The queue has been cleared.\")\n else:\n api_loop(event.channel.send_message, \"The queue is already empty.\")","def shutdown(self):\n self.log.info(\"Purging event queue...\")\n self.kill_all()\n self.log.info(\"done\")\n self.log.info(\"Exiting...\")\n sys.exit()","async def purge(self, context: Context, amount: int) -> None:\n await context.send(\n \"Deleting messages...\"\n ) # Bit of a hacky way to make sure the bot responds to the interaction and doens't get a \"Unknown Interaction\" response\n purged_messages = await context.channel.purge(limit=amount + 1)\n embed = discord.Embed(\n description=f\"**{context.author}** cleared **{len(purged_messages)-1}** messages!\",\n color=0x9C84EF,\n )\n await context.channel.send(embed=embed)","def sqs_delete_all(session, domain):\n client = session.client('sqs')\n resp = client.list_queues(QueueNamePrefix=domain.replace('.','-'))\n\n for url in resp.get('QueueUrls', []):\n client.delete_queue(QueueUrl=url)","def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()","def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()","def cleanup():\n redis_client.flushall()","def tearDownClass(cls):\n cls.producer.channel.queue_purge(queue='files_to_database')\n cls.producer.channel.close()","def clear_all(self):\n self.clear_redis()\n self.clear_cache()","async def purge(self, ctx, num_msg: int = 100):\n if num_msg > 100:\n return await ctx.error('Number of messages to be deleted must not exceed 100.')\n\n try:\n await ctx.channel.purge(limit=num_msg)\n except Exception as e:\n await ctx.error(f'Failed to delete messages.\\n ```py\\n{e}```')","def push_cleaning_signal_to_slack_bot(self) -> None:\n\n item = [self.name, None, None, \"Purge\", -1]\n if self.slack_queue:\n self.push_information_to_slack_bot(self.slack_queue, item)\n else:\n self.logger.debug(f\"No Slack Queue detected in {self.name}\")","def _drain_queue(self):\n while self.queue:\n self._export_batch()","def purge(self, **options):\n pass","def clear_jobs(self):\n with self._mutex:\n self._jobs = []","async def purge(self, ctx, msg_number: int = 10):\n\n if ctx.guild.id == 202724765218242560:\n return\n\n if msg_number > 100:\n await ctx.error(\"No more than 100 messages can be purged at a time.\")\n return\n\n deleted = await ctx.channel.purge(limit=msg_number)\n s = \"s\" if len(deleted) > 1 else \"\"\n result_msg = await ctx.info(f'Deleted {len(deleted)} message{s}.')\n await asyncio.sleep(3)\n await result_msg.delete()","def RemoveAll(self):\n\t\tcontacts = self.GetContactList()\n\t\t\n\t\tfor contact in contacts:\n\t\t\tself.BatchEnqueue('delete', contact)\n\t\tself.ExecuteBatchQueue()","def remove_all():\n \"\"\" Removes all from the database \"\"\"\n redis_store.flushall()","def ClearBatchQueue(self):\n\t\tself.batch_queue = gdata.contacts.data.ContactsFeed()","def clean_queue(self):\n self._stdin_queue.put_nowait(None) # Release thread","def clear_redis(self):\n self.redis_conn.flushall()","def delete_all(self):\n with self.__lock:\n self.__data = dict()\n self.flush()","def purge_queue(queue_name: str,\n limit: int = 0,\n message_filter: Optional[Tuple[str, str]] = None,\n server_url: Optional[str] = None):\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\n server_url)\n method_arguments = {'request': limit} # type: dict\n if message_filter:\n method_arguments['filter'] = _build_message_filter(*message_filter)\n\n rpc = RemoteProcedure(handle_QMF2_exception,\n 'qmf.default.direct', server_url)\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\n 'purge', method_arguments),\n timedelta(seconds=5))","def flush(self):\n size = self.queue.qsize()\n self.queue.join()\n logger.debug(f'[Analytics Client] Forcefully flushed {size} events')","def flush(self):\n if not self.isqueue:\n self.connection.flush()","def purge_all(self, ctx, limit: int = 100):\r\n if ctx.invoked_subcommand is None:\r\n date_limit = datetime.today() - timedelta(days=12)\r\n yield from ctx.message.channel.purge(after=date_limit, bulk=True)\r\n yield from ctx.author.send('Purge Complete')","def queue_delete(queue):\n\n for job in queue.jobs:\n job_delete(job)\n if os.path.exists(queue.data_abspath):\n os.rmdir(queue.data_abspath)\n db.session.delete(queue)\n db.session.commit()","def cleanup(self):\n self.msgmap.clear()\n self.droppedmsgs.clear()\n self.chan.stop_receiving_messages()\n\n # TODO: enable\n #self.cmdMap.clear()\n #self.cmdCliSubmitQueue.clear()\n #self.cmdSvrComputeQueue.clear()\n #self.droppedCommands.clear()\n #self.ch.stop_receiving_commands()","async def purge(self, ctx, amount: int = 1):\r\n if amount > 500:\r\n return await ctx.reply(\"Too many messages, limit is 500\", delete_after=3)\r\n await ctx.message.delete()\r\n await ctx.channel.purge(limit=amount)\r\n if amount >= 2:\r\n await ctx.send(f\"Purged {amount} mesages\", delete_after=3)\r\n else:\r\n await ctx.send(f\"Purged {amount} message\", delete_after=3)","async def clear_all(self) -> None:","def purge_cache(self):\n\n self.local_store.purge_cache()","def destroy_queue(self):\n response = self.queue.delete()\n if self._is_error_call(response):\n raise RuntimeError('SQS could not delete queue: %s' % response)\n self.queue, self.queue_name = None, None","def terminateAll(self):\n with self.__queueLock:\n for queue in [self.__queue, self.__clientQueue]:\n queue.clear()\n\n for runList in [self.__running, self.__clientRunning]:\n unfinishedRuns = [run for run in runList if run is not None]\n for run in unfinishedRuns:\n run.kill()","def deQueue(self):\n\t\tif self.isEmpty():\n\t\t\tprint(\"Queue already empty: Queue Empty\")\n\t\t\texit(1)\n\t\tprint(\"Dequeueing: \", self.queue[self.front])\n\t\tself.queue[self.front] = None\n\t\tself.front = self.front + 1\n\t\tself.size = self.size - 1","def purge(self):\n self.remaining = 0","async def cleanup(self, ctx):\r\n msgs = await ctx.message.channel.history(limit=100).flatten()\r\n msgs = [msg for msg in msgs if msg.author.id == self.amethyst.user.id]\r\n\r\n if (len(msgs) > 0 and\r\n ctx.me.permissions_in(ctx.channel).manage_messages):\r\n await ctx.channel.delete_messages(msgs)\r\n elif len(msgs) > 0:\r\n for msg in msgs:\r\n await msg.delete()\r\n else:\r\n return\r\n\r\n msg = await ctx.send(\"Cleaned `{}`\".format(len(msgs)))\r\n await asyncio.sleep(2.5)\r\n await msg.delete()","def _flush_enqueued(self):\n\n msgs = self.RPC.query.all()\n for msg in msgs:\n if msg.enqueued:\n if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object\n LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))\n elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object\n LOG.info('Plan name: {}'.format(msg.args['plan_name']))\n msg.delete()","def reset_queueing(self):\n self._num_queued = 0","def purge() -> None:\r\n _purge_func(False)","def flushall(self) -> Response:\n\n self.queue.r.flushall()\n return self.return_ok(\"Sucesfully flushed all data in redis pipeline\")","def purge_pending_jobs(event=None, site=None, queue=None):\n\tpurged_task_count = 0\n\tfor _queue in get_queue_list(queue):\n\t\tq = get_queue(_queue)\n\t\tfor job in q.jobs:\n\t\t\tif site and event:\n\t\t\t\tif job.kwargs[\"site\"] == site and job.kwargs[\"event\"] == event:\n\t\t\t\t\tjob.delete()\n\t\t\t\t\tpurged_task_count += 1\n\t\t\telif site:\n\t\t\t\tif job.kwargs[\"site\"] == site:\n\t\t\t\t\tjob.delete()\n\t\t\t\t\tpurged_task_count += 1\n\t\t\telif event:\n\t\t\t\tif job.kwargs[\"event\"] == event:\n\t\t\t\t\tjob.delete()\n\t\t\t\t\tpurged_task_count += 1\n\t\t\telse:\n\t\t\t\tpurged_task_count += q.count\n\t\t\t\tq.empty()\n\n\treturn purged_task_count","def _gc(self):\n remove_before = time.time() - self._keep_for\n for item in self._queue:\n # Time for the sequence to be removed?\n if item[1] < remove_before:\n # Sequence data is old, so remove it\n self._queue.remove(item)\n else:\n # Sequence number was added recently, so don't remove it. Also\n # stop processing the queue because all later items will be\n # newer\n break","def purge(self):\n sql = \"DELETE FROM {t_id}\".format(t_id=self.table_id)\n self.fusiontables.query().sql(sql=sql).execute()","def sipserver_purge(self) -> None:","def clear(self, key):\n cache_key = make_key('queue-' + self.name, key)\n memcache.delete(cache_key)","def flush_email_queue():\n from indico.core.emails import store_failed_email, update_email_log_state\n queue = g.get('email_queue', [])\n if not queue:\n return\n logger.debug('Sending %d queued emails', len(queue))\n for fn, email, log_entry in queue:\n try:\n fn(email, log_entry)\n except Exception:\n # Flushing the email queue happens after a commit.\n # If anything goes wrong here we keep going and just log\n # it to avoid losing (more) emails in case celery is not\n # used for email sending or there is a temporary issue\n # with celery.\n if log_entry:\n update_email_log_state(log_entry, failed=True)\n path = store_failed_email(email, log_entry)\n logger.exception('Flushing queued email \"%s\" failed; stored data in %s',\n truncate(email['subject'], 100), path)\n # Wait for a short moment in case it's a very temporary issue\n time.sleep(0.25)\n del queue[:]\n db.session.commit()","def remove_to_deletes(self):\n go = True\n while go:\n go = False\n for op in self.queue:\n if op.delete:\n self.queue.remove(op)\n go = True\n break","async def delete_bot_msg(self, channel):\n await channel.purge(limit=100, check=self.is_me)","def clearQueue(self, queue_name, project_id=None):\n if project_id is None:\n project_id = self.project_id\n\n url = \"%sprojects/%s/queues/%s/clear?oauth=%s\" % (self.url, project_id, queue_name, self.token)\n body = self.__post(url)\n return json.loads(body)","def delete_all_exchanges(self) -> None:\n self.connected_exchanges.clear()","def clear(self):\n with self._lock:\n for key in self._get_keys():\n self.cache.delete(self.make_key(key))\n self._set_keys([])","def clean_test_queues(prefix=TEST_NAME_PREFIX, region_name=None):\n sqs = boto3.resource('sqs', region_name=region_name)\n num_queues = 0\n try:\n for queue in sqs.queues.all():\n if re.match(r'.+%s\\d+' % TEST_NAME_PREFIX, queue.url):\n queue.delete()\n num_queues += 1\n finally:\n log.info('deleted %s test queues' % num_queues)"],"string":"[\n \"def clearQueueAll():\",\n \"def clear_queue(self):\\n while not self.queue.empty():\\n self.queue.get()\",\n \"def clear_queue(self):\\n\\t\\t\\tself.message_queue.clear()\\n\\t\\t\\treturn self.message_queue\",\n \"def clear_messages(self):\\n self.redis_client.delete(self.message_list)\",\n \"def flush_msg_queue(self):\\n if self.msg_queue is None:\\n return\\n while not self.msg_queue.empty():\\n self.msg_queue.get()\",\n \"def clear(self):\\r\\n try:\\r\\n while not self._queue.empty():\\r\\n self._queue.get().close()\\r\\n except:\\r\\n pass\",\n \"def __clear_message_queue(self):\\r\\n self.__lib.CC_ClearMessageQueue(self.__serno)\",\n \"def clear(self):\\n self.queue.clear()\",\n \"def drop_message(self):\\n heapq.heappop(self._message_queue)\",\n \"def clear_messages(self):\\n with self.message_lock:\\n self.messages = self.messages[self._processed_messages:]\\n self._processed_messages = 0\",\n \"def purge_queue(client, queue):\\n channel = client.channel()\\n\\n channel.queue_declare(queue=queue, durable=True, auto_delete=False)\\n channel.queue_purge(queue)\\n channel.close()\",\n \"def purge_mailbox(self):\\n self._mailbox.clear()\",\n \"def PurgeAll(self):\\n\\t\\tself.acad.ActiveDocument.PurgeAll()\",\n \"def purge(self):\\n while self.bus.inWaiting() > 0:\\n self.bus.read(self.bus.inWaiting())\",\n \"def clear_queue(self):\\n self.queue = deque()\",\n \"def remove_all(self):\\n if self._processed:\\n res, messages = self._mailconn.search(None, 'ALL')\\n if res == 'OK':\\n for msg in messages[0].split():\\n res, data = self._mailconn.store(msg.decode('utf-8'), '+FLAGS', '\\\\\\\\Deleted')\\n print(res)\",\n \"def _purge(self):\\n for _ in self.all():\\n self.delete(_)\",\n \"async def clear(ctx, messages=5):\\n await ctx.channel.purge(\\n limit=messages + 1\\n ) # the clear command counts as a message, so be sure to remove it too\",\n \"def _queue_delete(self, queue):\\n\\n queue.delete()\",\n \"def flushMsgs(self):\\n\\n self.queue = self.pre_queue[:]\\n self.pre_queue = []\",\n \"def purge_manager(self) -> None:\\n\\n self.logger.debug(f\\\"Beginning purging of {self.name}\\\")\\n # Don't need to join an empty queue, likely will result in more issues if you do.\\n if self.input_queue.empty():\\n self.logger.debug(f\\\"Input Queue of {self.name} is empty.\\\")\\n else:\\n # Try to process all the remaining values put in (no need to change behavior around poison pills)\\n while not self.input_queue.empty():\\n try:\\n task = self.input_queue.get_nowait()\\n self.logger.debug(f\\\"Receiving Task to purge: {task.get_job_id()}\\\")\\n self.error_queue.put(task)\\n # NOTE: This sleep call may be unnecessary but I placed it here to err on the side of caution.\\n sleep(1)\\n self.input_queue.task_done()\\n except:\\n break\\n # NOTE: This loop is a bit hacky probably, but it does ensure that the correct number of task_done calls are made.\\n # NOTE: This is meant to handle any \\\"unfinished tasks\\\" (meaning ones that haven't had their task_done calls).\\n while not self.input_queue._unfinished_tasks._semlock._is_zero():\\n self.input_queue.task_done()\\n self.restart_required = True\",\n \"def purge(self):\\n pass\",\n \"def delete_all_messages(self):\\n\\t\\tassert len(self.data) > 0, \\\"Data file is already empty!\\\"\\n\\n\\t\\tfor element in self:\\n\\t\\t\\tself.data.remove(element)\\n\\n\\t\\tself.update_data()\",\n \"def clear(self):\\n self.queue = Queue()\",\n \"def clean(self):\\r\\n # Note that we do not close the connection here -- somebody\\r\\n # may still be reading from it.\\r\\n while len(self.queue) > 0 and self._pair_stale(self.queue[0]):\\r\\n self.queue.pop(0)\",\n \"def delete_messages(self):\\n msgs_body = []\\n if not self.messages:\\n u_print(\\\" Queue.delete_messages() ERR - There is no messages or malformed messages on queue. \\\")\\n u_print(json.dumps(self.messages, indent=4))\\n sys.exit(1)\\n\\n try:\\n for m in self.messages:\\n u_print_d(\\\" Queue.delete_messages() Deleting the message: {}\\\".format(m.message_id))\\n r = self.queue.delete_messages(Entries=[\\n {\\n 'Id': m.message_id,\\n 'ReceiptHandle': m.receipt_handle\\n },\\n ])\\n u_print_d(\\\" Queue.delete_messages() Deletied: {}\\\".format(r))\\n self.stats_update('msgs_deleted', m.message_id)\\n except:\\n raise\\n\\n return msgs_body\",\n \"def delete_messages(self):\\n if not self.processed_messages:\\n LOGGER.error('No processed messages to delete')\\n return\\n\\n while self.processed_messages:\\n len_processed_messages = len(self.processed_messages)\\n batch = len_processed_messages if len_processed_messages < 10 else 10\\n\\n # Delete_batch can only process up to 10 messages\\n message_batch = [self.processed_messages.pop() for _ in range(batch)]\\n\\n resp = self.sqs_client.delete_message_batch(\\n QueueUrl=self.athena_sqs_url,\\n Entries=[{'Id': message['MessageId'],\\n 'ReceiptHandle': message['ReceiptHandle']}\\n for message in message_batch]\\n )\\n LOGGER.info('Successfully deleted %s messages from the queue',\\n len(resp['Successful']))\",\n \"def clear(self):\\n with self._not_full:\\n with self._not_empty:\\n with self._mutex:\\n self.close()\\n self._queue.clear()\\n self._cur_size = 0\",\n \"def delete_queue(self):\\n self.work_queue_client.delete_queue()\",\n \"def prune_dropped_messages(self) -> None:\\n # Remember that the message map and queue of dropped messages are\\n # concurrently modified so sizes are estimates.\\n sizeest = len(self.droppedmsgs) # warning: O(n) operation\\n if sizeest > self.DROP_TRIGGER:\\n dropcount = sizeest // 2\\n _TRACE(\\\"PURGE Purging about %s force-dropped messages\\\",\\n dropcount)\\n for mrec in _utils.getsome(self.droppedmsgs.pop, dropcount):\\n self.msgmap.remove_instance(mrec.id, mrec) # O(log(n))\",\n \"def clear(self):\\n\\n if not self.connected:\\n raise QueueNotConnectedError(\\\"Queue is not Connected\\\")\\n\\n self.__db.delete(self._key)\\n self.__db.delete(self._lock_key)\",\n \"def pop_all(self):\\n with self.lock:\\n output = list(self.queue)\\n self.queue.clear()\\n\\n return output\",\n \"async def delAllMsg(self, waitingTime=0):\\n for msg in self.msgToDelete:\\n await msg.delete(delay=waitingTime)\",\n \"def purce_all_dropped_messages(self) -> None:\\n for mrec in _utils.getsome(self.droppedmsgs.pop):\\n self.msgmap.remove_instance(mrec.id, mrec) # O(log(n))\",\n \"def clearQueue(targets):\",\n \"def drain(queue):\\n while not queue.is_empty():\\n queue.remove()\",\n \"async def clear(ctx, amount=10):\\n\\tawait ctx.channel.purge(limit=amount + 1)\",\n \"async def purge(self, ctx, count: int):\\n await ctx.channel.purge(limit=count+1)\",\n \"def unsubscribe(self):\\n\\n # Unsubscribe\\n self.pyrps.redis.srem(self.pyrps._ns_subscriptions(self.queue), self.consumer_id) \\n\\n # Remove message queue\\n self.pyrps.redis.delete(self.pyrps._ns_queue(self.queue, self.consumer_id))\",\n \"def clearDownloadQueue(self):\\n #print(\\\"CLEAR DOWNLOAD QUEUE\\\")\\n self.downloadQueue = []\\n self.clearEvents()\",\n \"async def purge(self, ctx, limit: int, flags=\\\"\\\"):\\n\\n await ctx.message.delete()\\n if \\\"all\\\" in flags:\\n await ctx.message.channel.purge(limit=limit)\\n else:\\n await ctx.message.channel.purge(limit=limit,\\n check=lambda msg: not msg.pinned\\n and not msg.attachments)\",\n \"def _cleanUp(self):\\r\\n limit = datetime.now() - timedelta(seconds=self._timeout)\\r\\n\\r\\n toClean = [msg for msg in self._incompleteMsgs if msg.older(limit)]\\r\\n\\r\\n if toClean:\\r\\n for msg in toClean:\\r\\n self._incompleteMsgs.remove(msg)\\r\\n\\r\\n log.msg('{0} incomplete messages have been dropped '\\r\\n 'from assembler.'.format(len(toClean)))\\r\\n\\r\\n toClean = [uri for uri, (_, timestamp) in self._binaries.iteritems()\\r\\n if timestamp < limit]\\r\\n\\r\\n if toClean:\\r\\n for uri in toClean:\\r\\n del self._binaries[uri]\\r\\n\\r\\n log.msg('{0} unused binaries have been dropped '\\r\\n 'from assembler.'.format(len(toClean)))\",\n \"async def purge(\\n self, no_wait: bool = False, timeout: TimeoutType = None,\\n ) -> aiormq.spec.Queue.PurgeOk:\\n\\n log.info(\\\"Purging queue: %r\\\", self)\\n\\n channel = await self.channel.get_underlay_channel()\\n return await channel.queue_purge(\\n self.name, nowait=no_wait, timeout=timeout,\\n )\",\n \"def clean_queue(queue):\\n yield queue\\n\\n # Clean the dirty queue\\n queue.join()\\n\\n # Check for clean shutdown\\n assert queue.qsize == 0\\n assert queue.inprogress_size == 0\",\n \"def clear(self):\\n self.background_scheduler.remove_all_jobs()\",\n \"def surge_purge(self):\\n\\n # Sends all packets!\\n for x in self.packet_pool:\\n self.accept(x)\\n\\n pool_len = len(self.packet_pool)\\n\\n self.print_clear()\\n self.print(\\\"[!] Packets sent: {} - Surge Interval: {:.2f}s\\\".format(pool_len, self.collection_period), end='\\\\r')\\n\\n self.packet_pool = []\\n self.start_purge_monitor()\",\n \"def _purge():\\r\\n _cache.clear()\",\n \"async def clear(self, ctx, amount: int = 2):\\n loading_msg = await ctx.send(content=f\\\"Deleting {amount} messages.\\\")\\n\\n def check(m):\\n return m.id != loading_msg.id\\n\\n await ctx.channel.purge(limit=amount, check=check)\\n await loading_msg.edit(content=f\\\"{amount} messages have been deleted.\\\")\",\n \"def reset_queue(self, db_session):\\n for player in self.player_queue.queue:\\n self.command_queue.appendleft(('_delete_last_row', {}))\\n self.player_queue = PlayerQueue.PlayerQueue()\\n db_session.execute(sqlalchemy.update(db.User.__table__, values={db.User.__table__.c.times_played: 0}))\\n self._add_to_chat_queue('The queue has been emptied and all players start fresh.')\",\n \"def on_queue_clear_command(self, event):\\n self.pre_check(event)\\n self.same_channel_check(event)\\n if self.get_player(event.guild.id).queue:\\n self.get_player(event.guild.id).queue.clear()\\n api_loop(event.channel.send_message, \\\"The queue has been cleared.\\\")\\n else:\\n api_loop(event.channel.send_message, \\\"The queue is already empty.\\\")\",\n \"def shutdown(self):\\n self.log.info(\\\"Purging event queue...\\\")\\n self.kill_all()\\n self.log.info(\\\"done\\\")\\n self.log.info(\\\"Exiting...\\\")\\n sys.exit()\",\n \"async def purge(self, context: Context, amount: int) -> None:\\n await context.send(\\n \\\"Deleting messages...\\\"\\n ) # Bit of a hacky way to make sure the bot responds to the interaction and doens't get a \\\"Unknown Interaction\\\" response\\n purged_messages = await context.channel.purge(limit=amount + 1)\\n embed = discord.Embed(\\n description=f\\\"**{context.author}** cleared **{len(purged_messages)-1}** messages!\\\",\\n color=0x9C84EF,\\n )\\n await context.channel.send(embed=embed)\",\n \"def sqs_delete_all(session, domain):\\n client = session.client('sqs')\\n resp = client.list_queues(QueueNamePrefix=domain.replace('.','-'))\\n\\n for url in resp.get('QueueUrls', []):\\n client.delete_queue(QueueUrl=url)\",\n \"def remove_all(self):\\n # Post a delete all notice to the manager\\n self._remove_all()\",\n \"def remove_all(self):\\n # Post a delete all notice to the manager\\n self._remove_all()\",\n \"def cleanup():\\n redis_client.flushall()\",\n \"def tearDownClass(cls):\\n cls.producer.channel.queue_purge(queue='files_to_database')\\n cls.producer.channel.close()\",\n \"def clear_all(self):\\n self.clear_redis()\\n self.clear_cache()\",\n \"async def purge(self, ctx, num_msg: int = 100):\\n if num_msg > 100:\\n return await ctx.error('Number of messages to be deleted must not exceed 100.')\\n\\n try:\\n await ctx.channel.purge(limit=num_msg)\\n except Exception as e:\\n await ctx.error(f'Failed to delete messages.\\\\n ```py\\\\n{e}```')\",\n \"def push_cleaning_signal_to_slack_bot(self) -> None:\\n\\n item = [self.name, None, None, \\\"Purge\\\", -1]\\n if self.slack_queue:\\n self.push_information_to_slack_bot(self.slack_queue, item)\\n else:\\n self.logger.debug(f\\\"No Slack Queue detected in {self.name}\\\")\",\n \"def _drain_queue(self):\\n while self.queue:\\n self._export_batch()\",\n \"def purge(self, **options):\\n pass\",\n \"def clear_jobs(self):\\n with self._mutex:\\n self._jobs = []\",\n \"async def purge(self, ctx, msg_number: int = 10):\\n\\n if ctx.guild.id == 202724765218242560:\\n return\\n\\n if msg_number > 100:\\n await ctx.error(\\\"No more than 100 messages can be purged at a time.\\\")\\n return\\n\\n deleted = await ctx.channel.purge(limit=msg_number)\\n s = \\\"s\\\" if len(deleted) > 1 else \\\"\\\"\\n result_msg = await ctx.info(f'Deleted {len(deleted)} message{s}.')\\n await asyncio.sleep(3)\\n await result_msg.delete()\",\n \"def RemoveAll(self):\\n\\t\\tcontacts = self.GetContactList()\\n\\t\\t\\n\\t\\tfor contact in contacts:\\n\\t\\t\\tself.BatchEnqueue('delete', contact)\\n\\t\\tself.ExecuteBatchQueue()\",\n \"def remove_all():\\n \\\"\\\"\\\" Removes all from the database \\\"\\\"\\\"\\n redis_store.flushall()\",\n \"def ClearBatchQueue(self):\\n\\t\\tself.batch_queue = gdata.contacts.data.ContactsFeed()\",\n \"def clean_queue(self):\\n self._stdin_queue.put_nowait(None) # Release thread\",\n \"def clear_redis(self):\\n self.redis_conn.flushall()\",\n \"def delete_all(self):\\n with self.__lock:\\n self.__data = dict()\\n self.flush()\",\n \"def purge_queue(queue_name: str,\\n limit: int = 0,\\n message_filter: Optional[Tuple[str, str]] = None,\\n server_url: Optional[str] = None):\\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\\n server_url)\\n method_arguments = {'request': limit} # type: dict\\n if message_filter:\\n method_arguments['filter'] = _build_message_filter(*message_filter)\\n\\n rpc = RemoteProcedure(handle_QMF2_exception,\\n 'qmf.default.direct', server_url)\\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\\n 'purge', method_arguments),\\n timedelta(seconds=5))\",\n \"def flush(self):\\n size = self.queue.qsize()\\n self.queue.join()\\n logger.debug(f'[Analytics Client] Forcefully flushed {size} events')\",\n \"def flush(self):\\n if not self.isqueue:\\n self.connection.flush()\",\n \"def purge_all(self, ctx, limit: int = 100):\\r\\n if ctx.invoked_subcommand is None:\\r\\n date_limit = datetime.today() - timedelta(days=12)\\r\\n yield from ctx.message.channel.purge(after=date_limit, bulk=True)\\r\\n yield from ctx.author.send('Purge Complete')\",\n \"def queue_delete(queue):\\n\\n for job in queue.jobs:\\n job_delete(job)\\n if os.path.exists(queue.data_abspath):\\n os.rmdir(queue.data_abspath)\\n db.session.delete(queue)\\n db.session.commit()\",\n \"def cleanup(self):\\n self.msgmap.clear()\\n self.droppedmsgs.clear()\\n self.chan.stop_receiving_messages()\\n\\n # TODO: enable\\n #self.cmdMap.clear()\\n #self.cmdCliSubmitQueue.clear()\\n #self.cmdSvrComputeQueue.clear()\\n #self.droppedCommands.clear()\\n #self.ch.stop_receiving_commands()\",\n \"async def purge(self, ctx, amount: int = 1):\\r\\n if amount > 500:\\r\\n return await ctx.reply(\\\"Too many messages, limit is 500\\\", delete_after=3)\\r\\n await ctx.message.delete()\\r\\n await ctx.channel.purge(limit=amount)\\r\\n if amount >= 2:\\r\\n await ctx.send(f\\\"Purged {amount} mesages\\\", delete_after=3)\\r\\n else:\\r\\n await ctx.send(f\\\"Purged {amount} message\\\", delete_after=3)\",\n \"async def clear_all(self) -> None:\",\n \"def purge_cache(self):\\n\\n self.local_store.purge_cache()\",\n \"def destroy_queue(self):\\n response = self.queue.delete()\\n if self._is_error_call(response):\\n raise RuntimeError('SQS could not delete queue: %s' % response)\\n self.queue, self.queue_name = None, None\",\n \"def terminateAll(self):\\n with self.__queueLock:\\n for queue in [self.__queue, self.__clientQueue]:\\n queue.clear()\\n\\n for runList in [self.__running, self.__clientRunning]:\\n unfinishedRuns = [run for run in runList if run is not None]\\n for run in unfinishedRuns:\\n run.kill()\",\n \"def deQueue(self):\\n\\t\\tif self.isEmpty():\\n\\t\\t\\tprint(\\\"Queue already empty: Queue Empty\\\")\\n\\t\\t\\texit(1)\\n\\t\\tprint(\\\"Dequeueing: \\\", self.queue[self.front])\\n\\t\\tself.queue[self.front] = None\\n\\t\\tself.front = self.front + 1\\n\\t\\tself.size = self.size - 1\",\n \"def purge(self):\\n self.remaining = 0\",\n \"async def cleanup(self, ctx):\\r\\n msgs = await ctx.message.channel.history(limit=100).flatten()\\r\\n msgs = [msg for msg in msgs if msg.author.id == self.amethyst.user.id]\\r\\n\\r\\n if (len(msgs) > 0 and\\r\\n ctx.me.permissions_in(ctx.channel).manage_messages):\\r\\n await ctx.channel.delete_messages(msgs)\\r\\n elif len(msgs) > 0:\\r\\n for msg in msgs:\\r\\n await msg.delete()\\r\\n else:\\r\\n return\\r\\n\\r\\n msg = await ctx.send(\\\"Cleaned `{}`\\\".format(len(msgs)))\\r\\n await asyncio.sleep(2.5)\\r\\n await msg.delete()\",\n \"def _flush_enqueued(self):\\n\\n msgs = self.RPC.query.all()\\n for msg in msgs:\\n if msg.enqueued:\\n if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object\\n LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))\\n elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object\\n LOG.info('Plan name: {}'.format(msg.args['plan_name']))\\n msg.delete()\",\n \"def reset_queueing(self):\\n self._num_queued = 0\",\n \"def purge() -> None:\\r\\n _purge_func(False)\",\n \"def flushall(self) -> Response:\\n\\n self.queue.r.flushall()\\n return self.return_ok(\\\"Sucesfully flushed all data in redis pipeline\\\")\",\n \"def purge_pending_jobs(event=None, site=None, queue=None):\\n\\tpurged_task_count = 0\\n\\tfor _queue in get_queue_list(queue):\\n\\t\\tq = get_queue(_queue)\\n\\t\\tfor job in q.jobs:\\n\\t\\t\\tif site and event:\\n\\t\\t\\t\\tif job.kwargs[\\\"site\\\"] == site and job.kwargs[\\\"event\\\"] == event:\\n\\t\\t\\t\\t\\tjob.delete()\\n\\t\\t\\t\\t\\tpurged_task_count += 1\\n\\t\\t\\telif site:\\n\\t\\t\\t\\tif job.kwargs[\\\"site\\\"] == site:\\n\\t\\t\\t\\t\\tjob.delete()\\n\\t\\t\\t\\t\\tpurged_task_count += 1\\n\\t\\t\\telif event:\\n\\t\\t\\t\\tif job.kwargs[\\\"event\\\"] == event:\\n\\t\\t\\t\\t\\tjob.delete()\\n\\t\\t\\t\\t\\tpurged_task_count += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tpurged_task_count += q.count\\n\\t\\t\\t\\tq.empty()\\n\\n\\treturn purged_task_count\",\n \"def _gc(self):\\n remove_before = time.time() - self._keep_for\\n for item in self._queue:\\n # Time for the sequence to be removed?\\n if item[1] < remove_before:\\n # Sequence data is old, so remove it\\n self._queue.remove(item)\\n else:\\n # Sequence number was added recently, so don't remove it. Also\\n # stop processing the queue because all later items will be\\n # newer\\n break\",\n \"def purge(self):\\n sql = \\\"DELETE FROM {t_id}\\\".format(t_id=self.table_id)\\n self.fusiontables.query().sql(sql=sql).execute()\",\n \"def sipserver_purge(self) -> None:\",\n \"def clear(self, key):\\n cache_key = make_key('queue-' + self.name, key)\\n memcache.delete(cache_key)\",\n \"def flush_email_queue():\\n from indico.core.emails import store_failed_email, update_email_log_state\\n queue = g.get('email_queue', [])\\n if not queue:\\n return\\n logger.debug('Sending %d queued emails', len(queue))\\n for fn, email, log_entry in queue:\\n try:\\n fn(email, log_entry)\\n except Exception:\\n # Flushing the email queue happens after a commit.\\n # If anything goes wrong here we keep going and just log\\n # it to avoid losing (more) emails in case celery is not\\n # used for email sending or there is a temporary issue\\n # with celery.\\n if log_entry:\\n update_email_log_state(log_entry, failed=True)\\n path = store_failed_email(email, log_entry)\\n logger.exception('Flushing queued email \\\"%s\\\" failed; stored data in %s',\\n truncate(email['subject'], 100), path)\\n # Wait for a short moment in case it's a very temporary issue\\n time.sleep(0.25)\\n del queue[:]\\n db.session.commit()\",\n \"def remove_to_deletes(self):\\n go = True\\n while go:\\n go = False\\n for op in self.queue:\\n if op.delete:\\n self.queue.remove(op)\\n go = True\\n break\",\n \"async def delete_bot_msg(self, channel):\\n await channel.purge(limit=100, check=self.is_me)\",\n \"def clearQueue(self, queue_name, project_id=None):\\n if project_id is None:\\n project_id = self.project_id\\n\\n url = \\\"%sprojects/%s/queues/%s/clear?oauth=%s\\\" % (self.url, project_id, queue_name, self.token)\\n body = self.__post(url)\\n return json.loads(body)\",\n \"def delete_all_exchanges(self) -> None:\\n self.connected_exchanges.clear()\",\n \"def clear(self):\\n with self._lock:\\n for key in self._get_keys():\\n self.cache.delete(self.make_key(key))\\n self._set_keys([])\",\n \"def clean_test_queues(prefix=TEST_NAME_PREFIX, region_name=None):\\n sqs = boto3.resource('sqs', region_name=region_name)\\n num_queues = 0\\n try:\\n for queue in sqs.queues.all():\\n if re.match(r'.+%s\\\\d+' % TEST_NAME_PREFIX, queue.url):\\n queue.delete()\\n num_queues += 1\\n finally:\\n log.info('deleted %s test queues' % num_queues)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7505619","0.72489685","0.7197505","0.7081021","0.70500505","0.7026544","0.6947277","0.692343","0.69218075","0.68953866","0.6863806","0.6734934","0.66792786","0.66656256","0.6581635","0.6553705","0.65511155","0.6539296","0.65362954","0.65359545","0.65193224","0.6464087","0.6446329","0.6443138","0.643585","0.6431749","0.6381484","0.63695675","0.63674885","0.6339982","0.6312153","0.62957025","0.6255737","0.6227455","0.6216211","0.62011325","0.6194022","0.61908954","0.61856234","0.6167434","0.61429965","0.61403364","0.6136161","0.61131513","0.6090834","0.6087822","0.6076115","0.6065581","0.6033557","0.6032875","0.6027977","0.6021756","0.60179067","0.6011474","0.6011474","0.6007566","0.6006576","0.5999913","0.5979774","0.59785694","0.59760046","0.5973005","0.59382474","0.59096813","0.590414","0.59014577","0.5882199","0.58643645","0.58614296","0.585585","0.5853398","0.5851192","0.5849445","0.5846881","0.5846717","0.58449864","0.5835975","0.58111763","0.58003277","0.5785998","0.5783372","0.57744926","0.5762226","0.57579035","0.57544327","0.5750969","0.5750635","0.5730636","0.57211274","0.5716342","0.57113594","0.5704712","0.56996983","0.5685543","0.568416","0.56724614","0.56704456","0.56606627","0.5651414","0.5643857"],"string":"[\n \"0.7505619\",\n \"0.72489685\",\n \"0.7197505\",\n \"0.7081021\",\n \"0.70500505\",\n \"0.7026544\",\n \"0.6947277\",\n \"0.692343\",\n \"0.69218075\",\n \"0.68953866\",\n \"0.6863806\",\n \"0.6734934\",\n \"0.66792786\",\n \"0.66656256\",\n \"0.6581635\",\n \"0.6553705\",\n \"0.65511155\",\n \"0.6539296\",\n \"0.65362954\",\n \"0.65359545\",\n \"0.65193224\",\n \"0.6464087\",\n \"0.6446329\",\n \"0.6443138\",\n \"0.643585\",\n \"0.6431749\",\n \"0.6381484\",\n \"0.63695675\",\n \"0.63674885\",\n \"0.6339982\",\n \"0.6312153\",\n \"0.62957025\",\n \"0.6255737\",\n \"0.6227455\",\n \"0.6216211\",\n \"0.62011325\",\n \"0.6194022\",\n \"0.61908954\",\n \"0.61856234\",\n \"0.6167434\",\n \"0.61429965\",\n \"0.61403364\",\n \"0.6136161\",\n \"0.61131513\",\n \"0.6090834\",\n \"0.6087822\",\n \"0.6076115\",\n \"0.6065581\",\n \"0.6033557\",\n \"0.6032875\",\n \"0.6027977\",\n \"0.6021756\",\n \"0.60179067\",\n \"0.6011474\",\n \"0.6011474\",\n \"0.6007566\",\n \"0.6006576\",\n \"0.5999913\",\n \"0.5979774\",\n \"0.59785694\",\n \"0.59760046\",\n \"0.5973005\",\n \"0.59382474\",\n \"0.59096813\",\n \"0.590414\",\n \"0.59014577\",\n \"0.5882199\",\n \"0.58643645\",\n \"0.58614296\",\n \"0.585585\",\n \"0.5853398\",\n \"0.5851192\",\n \"0.5849445\",\n \"0.5846881\",\n \"0.5846717\",\n \"0.58449864\",\n \"0.5835975\",\n \"0.58111763\",\n \"0.58003277\",\n \"0.5785998\",\n \"0.5783372\",\n \"0.57744926\",\n \"0.5762226\",\n \"0.57579035\",\n \"0.57544327\",\n \"0.5750969\",\n \"0.5750635\",\n \"0.5730636\",\n \"0.57211274\",\n \"0.5716342\",\n \"0.57113594\",\n \"0.5704712\",\n \"0.56996983\",\n \"0.5685543\",\n \"0.568416\",\n \"0.56724614\",\n \"0.56704456\",\n \"0.56606627\",\n \"0.5651414\",\n \"0.5643857\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8184247"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93087,"cells":{"query":{"kind":"string","value":"Unbind queue from the specified exchange where it is bound the routing key. If routing key is None, use the queue name."},"document":{"kind":"string","value":"def unbind(self, source, routing_key=None):\n if hasattr(source, 'name'):\n source = source.name\n self._rpc(specification.Queue.Bind(queue=self.name,\n exchange=source,\n routing_key=routing_key or\n self.name))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def bind(\n self,\n exchange: ExchangeParamType,\n routing_key: Optional[str] = None,\n *,\n arguments: Arguments = None,\n timeout: TimeoutType = None,\n ) -> aiormq.spec.Queue.BindOk:\n\n if routing_key is None:\n routing_key = self.name\n\n log.debug(\n \"Binding queue %r: exchange=%r, routing_key=%r, arguments=%r\",\n self,\n exchange,\n routing_key,\n arguments,\n )\n\n channel = await self.channel.get_underlay_channel()\n return await channel.queue_bind(\n self.name,\n exchange=get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n timeout=timeout,\n )","def bind_queue_to_exchange(self, channel, exchange, queue_name, routing_key):\n logger.info('Binding %s to %s with %s',\n exchange, queue_name, routing_key)\n channel.queue_bind(queue=queue_name,\n exchange=exchange,\n routing_key=routing_key)","def unbind(self, uid):\r\n if self.bind_uid == uid:\r\n self.bind_uid = ''\r\n if len(self.queue_applicants) > 0:\r\n self.queue_applicants.reverse()\r\n self.bind_uid = self.queue_applicants.pop()\r\n self.queue_applicants.reverse()\r\n else:\r\n if uid in self.queue_applicants:\r\n self.queue_applicants.remove(uid)\r\n return self.bind_uid","def bind_queue(self, exchange_name, queue_name, bind_key):\n self.logger.info('Subscribed to topic: {}'.format(bind_key))\n try:\n self._channel.queue_bind(\n exchange=exchange_name, queue=queue_name, routing_key=bind_key)\n except Exception as exc:\n raise exc","def remove_queue(self, queue) -> None:\r\n self.receive_queues.remove(queue)","def remove_binding(ctx, binding_name):\n\n entryFound = False\n table = 'NAT_BINDINGS'\n key = binding_name\n\n if len(binding_name) > 32:\n ctx.fail(\"Invalid binding name. Maximum allowed binding name is 32 characters !!\")\n\n config_db = ConfigDBConnector()\n config_db.connect()\n\n data = config_db.get_entry(table, key)\n if not data:\n click.echo(\"Trying to delete binding, which is not present.\")\n entryFound = True\n\n if entryFound == False:\n config_db.set_entry(table, key, None)","def _remove_exchange(self, message):\n key = (message.remote, message.mid)\n\n if key not in self._active_exchanges:\n # Before turning this up to a warning, consider https://github.com/chrysn/aiocoap/issues/288\n self.log.info(\"Received %s from %s, but could not match it to a running exchange.\", message.mtype, message.remote)\n return\n\n messageerror_monitor, next_retransmission = self._active_exchanges.pop(key)\n next_retransmission.cancel()\n if message.mtype is RST:\n messageerror_monitor()\n self.log.debug(\"Exchange removed, message ID: %d.\", message.mid)\n\n self._continue_backlog(message.remote)","def unbindGateway(self, system_id):\r\n bind_mgr = self.getBoundConnections(system_id)\r\n if bind_mgr:\r\n unbinds_list = []\r\n for bind in bind_mgr:\r\n unbinds_list.append(bind.getDisconnectedDeferred())\r\n bind.unbindAndDisconnect()\r\n d = defer.DeferredList(unbinds_list)\r\n else:\r\n d = defer.succeed(None)\r\n \r\n return d","def clear_broadcast(param=None):\n global command_queue\n for i, command in enumerate(command_queue):\n if (command['param'] == param or param is None) and command['type'] == RECURRING:\n command_queue.pop(i)\n break","def unbind(cls, name: str):\n if cls.instance() is None:\n return\n\n if not name in cls.instance().m_axis_bindings and not name in cls.instance().m_button_bindings:\n print( 'Unable to unbind: {}. Name not bound to axis or button.'.format( name ) )\n return\n\n if name in cls.instance().m_axis_bindings:\n axis = cls.instance().m_axis_bindings[ name ].axis\n del cls.instance().m_axis_bindings[ name ]\n del cls.instance().m_axis_name_table[ axis ]\n if name in cls.instance().m_button_bindings:\n button = cls.instance().m_button_bindings[ name ].button\n del cls.instance().m_button_bindings[ name ]\n del cls.instance().m_button_name_table[ button ]","def del_queue(self, queue_id):\n del self.queue_dict[queue_id]","def RemoveFromQueue(self, addr):\n if addr in self.connection_queue:\n self.connection_queue.remove(addr)","def unlisten(self, prefix: str) -> None:\n assert len(prefix) == 1\n del self.queues[prefix]\n self.logger.info(\"No longer polling for message type: %s\", prefix)","def RemoveIamPolicyBinding(task_ref, member, role):\n policy = GetIamPolicy(task_ref)\n iam_util.RemoveBindingFromIamPolicy(policy, member, role)\n return SetIamPolicy(task_ref, policy)","def _unbind_event(\r\n self, handler: Handler, event_type: EventType,\r\n handlers_dict: Dict[str, HandlerData]) -> None:\r\n from apysc.event.handler import append_unbinding_expression\r\n from apysc.event.handler import get_handler_name\r\n self_instance: VariableNameInterface = \\\r\n self._validate_self_is_variable_name_interface()\r\n name: str = get_handler_name(handler=handler, instance=self)\r\n if name in handlers_dict:\r\n del handlers_dict[name]\r\n append_unbinding_expression(\r\n this=self_instance, handler_name=name,\r\n event_type=event_type)","def release_bound_key(self, event):\n try:\n if event.key in [key[0] for key in self.key_bindings]:\n self.unpress()\n except TypeError:\n if event.key in self.key_bindings:\n self.unpress()","def bind(self, source, routing_key=None, arguments=None):\n if hasattr(source, 'name'):\n source = source.name\n frame = specification.Queue.Bind(queue=self.name,\n exchange=source,\n routing_key=routing_key or '',\n arguments=arguments)\n response = self._rpc(frame)\n return isinstance(response, specification.Queue.BindOk)","def remove_queue(self, queue):\n with self.mutex:\n self.queues.remove(queue)","def unbind_receive_response(self, msg_tag):\n if self._callable:\n del self._response_bindings[msg_tag]\n else:\n raise SAMPClientError(\"Client not callable.\")","def unbind(self, name):\n remove = []\n for n in name:\n if not self.is_array(n): continue\n self.drop(n, ignore_items=True)\n remove.append(n)\n if remove and self._verbose_infos:\n print(\"Remove mask structure for: '{}'\".format(\"', '\".join(remove)))\n return None","def unsubscribe(self):\n\n # Unsubscribe\n self.pyrps.redis.srem(self.pyrps._ns_subscriptions(self.queue), self.consumer_id) \n\n # Remove message queue\n self.pyrps.redis.delete(self.pyrps._ns_queue(self.queue, self.consumer_id))","def unbind(self, sequence, funcid=None):\n return self._widget_unbind(sequence, funcid, internal=False)","def unregister_router(self, hostname):","def RemoveIamPolicyBinding(zone_ref, member, role):\n policy = GetIamPolicy(zone_ref)\n iam_util.RemoveBindingFromIamPolicy(policy, member, role)\n return SetIamPolicy(zone_ref, policy)","def unbind(self, binding_id):\n\n if binding_id not in self._bindings:\n return False\n\n event_props = self._bindings[binding_id][1]\n del self._bindings[binding_id]\n\n if event_props in self._active_bindings:\n self.ignore(event_props)\n\n return True","def async_clear_address(self, address: str) -> None:\n self._matched.pop(address, None)\n self._matched_connectable.pop(address, None)","def unbindWidget(self, widget):\n\n # Figure out the index into __boundWidgets,\n # as we need this to pass to __unbindWidget,\n # which does the real work.\n index = -1\n\n for i, bw in enumerate(self.__boundWidgets):\n if bw.widget == widget:\n index = i\n break\n\n if index == -1:\n raise ValueError('Widget {} [{}] is not bound'\n .format(type(widget).__name__, id(widget)))\n\n self.__unbindWidget( index)\n self.__boundWidgets.pop(index)","def forget(self, req, ino, nlookup):\r\n self.reply_none(req)","def unsubscribe_symbol(self, symbol):\n try:\n self.symbol.pop(symbol, None)\n self.symbol_data.pop(symbol, None)\n except KeyError:\n print(\"Could not unsubscribe symbol {} as it was never subscribed.\".format(str(symbol)))","def bind(self, exchange, routing_key='', arguments=None, timeout=None):\n\n log.debug(\"Binding exchange %r to exchange %r, routing_key=%r, arguments=%r\", self, exchange, routing_key,\n arguments)\n\n f = self._create_future(timeout)\n\n self._channel.exchange_bind(\n destination=self.name,\n source=self._get_exchange_name(exchange),\n routing_key=routing_key,\n arguments=arguments,\n callback=f.set_result,\n )\n\n return f","def _do_backend_unbind(self, backend, port_id):\n\n driver = self.backend_manager.get_backend_driver(backend)\n driver.unbind(port_id)","def unbind(self, svc, svc_ref):\n with self._lock:\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\n targets = svc_ref.get_property(ORDER_TARGETS)\n if isinstance(targets, (list, tuple)):\n for target in targets:\n associates = self._target_handlers.get(target, None)\n if svc in associates:\n del associates[svc]\n\n else:\n associates = self._target_handlers.get(str(targets), None)\n if svc in associates:\n del associates[svc]","def deregister(self, queue, project=None):\n\n # TODO(kgriffs): SHARDING - Implement this!\n pass","def storage_import_unbind(self, target_lun_path, vserver_name=None):\n return self.request( \"storage-import-unbind\", {\n 'target_lun_path': [ target_lun_path, 'target-lun-path', [ basestring, 'None' ], False ],\n 'vserver_name': [ vserver_name, 'vserver-name', [ basestring, 'None' ], False ],\n }, {\n } )","def port_unbind(endpoint_id, neutron_port, **kwargs):\n\n vif_type = neutron_port.get(constants.VIF_TYPE_KEY,\n constants.FALLBACK_VIF_TYPE)\n vif_details = lib_utils.string_mappings(neutron_port.get(\n constants.VIF_DETAILS_KEY))\n unbinding_exec_path = os.path.join(cfg.CONF.bindir, vif_type)\n\n port_id = neutron_port['id']\n ifname, _ = utils.get_veth_pair_names(port_id)\n\n mac_address = neutron_port['mac_address']\n network_id = neutron_port['network_id']\n stdout, stderr = processutils.execute(\n unbinding_exec_path, constants.UNBINDING_SUBCOMMAND, port_id, ifname,\n endpoint_id, mac_address, vif_details, network_id)\n try:\n utils.remove_device(ifname)\n except pyroute2.NetlinkError:\n LOG.exception(\"Error happened during deleting the veth pair\")\n raise exceptions.VethDeletionFailure(\n 'Deleting the veth pair failed.')\n return (stdout, stderr)","def clear_bound_event(self, name: str):\n assert self.is_websocket_state, Exception(\"Cannot bind events in non websocket state. See is_websocket_state\")\n\n if isinstance(name, Enum):\n name = str(name)\n\n assert isinstance(name, str), ValueError(\"The event name must be a string or enum.\")\n\n if name in self._bind_events:\n del self._bind_events[name]","def unsubscribe(self, tag):\n self.socket.setsockopt(constants.UNSUBSCRIBE, tag)","def removeConnection(self, connection):\r\n if connection.system_id is None:\r\n self.log.debug(\"SMPP connection attempt failed without binding.\")\r\n else:\r\n system_id = connection.system_id\r\n bind_type = connection.bind_type\r\n self.bound_connections[system_id].removeBinding(connection)\r\n self.log.info(\"Dropped %s bind for '%s'. Active binds: %s. Max binds: %s\" % (bind_type, system_id, self.getBoundConnectionCountsStr(system_id), self.config.systems[system_id]['max_bindings']))\r\n # If this is the last binding for this service then remove the BindManager\r\n if self.bound_connections[system_id].getBindingCount() == 0:\r\n self.bound_connections.pop(system_id)","def delete_queue(self, queue_name: str) -> None:\n if queue_name is None:\n raise TypeError(\"Queue name cannot be None.\")\n\n with self.get_conn() as service_mgmt_conn:\n service_mgmt_conn.delete_queue(queue_name)","def remove(self, destination: n):\n try:\n self.connections.pop(destination)\n except KeyError:\n pass","def remove(self, v: Route): # pylint: disable=arguments-differ, undefined-variable\n i = hash(str(v.addr) + str(v.nh))\n if i not in self._destinations:\n raise KeyError(\"{} key not found in the history RIB\".format(i))\n if v in self._destinations[i]:\n self._destinations[i].remove(v)\n if len(self._destinations[i]) == 0:\n del self._destinations[i]\n return None\n return v","def unbind_receive_notification(self, mtype, declare=True):\n if self._callable:\n del self._notification_bindings[mtype]\n if declare:\n self._declare_subscriptions()\n else:\n raise SAMPClientError(\"Client not callable.\")","def get_queue(self, task_name):\n for name, queue in self.queues.items():\n if task_name in queue:\n return name\n return self.default_queue","def query_queue(self, queue_name, alt_exchange_name=None):\n return self._query(queue_name, \"queue\", \"org.apache.qpid.broker\", alt_exchange_name)","def unbind_receive_call(self, mtype, declare=True):\n if self._callable:\n del self._call_bindings[mtype]\n if declare:\n self._declare_subscriptions()\n else:\n raise SAMPClientError(\"Client not callable.\")","def unset_cipher(self, key_name=None):\n if key_name is None:\n if self.key_name is not None:\n message_key_types.unset_cipher(self.key_name)\n if self.pending_key_name is not None:\n message_key_types.unset_cipher(self.pending_key_name)\n else:\n message_key_types.unset_cipher(key_name)","def clear(self, key):\n cache_key = make_key('queue-' + self.name, key)\n memcache.delete(cache_key)","def unsubscribe(self, destination, extra_headers=None):\n unsubscribe = frame.UnsubscribeFrame(destination, extra_headers=extra_headers)\n res = self.send_frame(unsubscribe)\n with self.subscription_lock:\n self.subscribed_destinations.pop(destination)\n return res","def __delitem__(self, i: Route) -> None:\n i = hash(i.addr)\n if i not in self._destinations:\n raise KeyError(\"{} key not found in the RIB\".format(i))\n del self._destinations[i]","def free_queue(self, sycl_queue_val):\n fn = DpctlCAPIFnBuilder.get_dpctl_queue_delete(\n builder=self.builder, context=self.context\n )\n self.builder.call(fn, [self.builder.load(sycl_queue_val)])","def deregister(self, queue, project=None):\n self._invalidate_cached_id(queue, project)\n self._catalogue_ctrl.delete(project, queue)","def deregister(self, queue, project=None):\n self._catalogue_ctrl.delete(project, queue)","def ungraded_response(self, queue_msg, queuekey):\r\n # check the queuekey against the saved queuekey\r\n if('queuestate' in self.input_state and self.input_state['queuestate'] == 'queued'\r\n and self.input_state['queuekey'] == queuekey):\r\n msg = self._parse_data(queue_msg)\r\n # save the queue message so that it can be rendered later\r\n self.input_state['queue_msg'] = msg\r\n self.input_state['queuestate'] = None\r\n self.input_state['queuekey'] = None","def __delitem__(self, key_mac):\n self.ingress_tbl.pop(key_mac, None)\n rsw = self.rootsw_tbl.pop(key_mac, None)\n if rsw:\n rsw.leaf_macs.discard(key_mac)","def reset_queue(self, name, namespace):\n raise RuntimeError('Archives are read-only')","def unbind(self):\n\n logging.debug('Unbind client {uid}...'.format(uid=self.uid))\n p = smpp.make_pdu('unbind', client=self)\n self.send_pdu(p)\n\n try:\n return self.read_pdu()\n except socket.timeout:\n raise exceptions.ConnectionError()","def __unbindWidget(self, index):\n\n bw = self.__boundWidgets[index]\n\n # Only attempt to unbind if the parent\n # and widget have not been destroyed\n if bw.isAlive():\n bw.parent.Unbind(bw.evType, source=bw.widget)","def reroute_queue(queue_name: str, exchange_name: str,\n limit: int = 0,\n message_filter: Optional[Tuple[str, str]] = None,\n server_url: Optional[str] = None):\n # Gather queue & exchange info + existance check\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\n server_url)\n get_object('org.apache.qpid.broker', 'exchange',\n exchange_name, server_url)\n\n method_arguments = {'request': limit} # type: dict\n\n if exchange_name:\n method_arguments['useAltExchange'] = False\n method_arguments['exchange'] = exchange_name\n else:\n method_arguments['useAltExchange'] = True\n method_arguments['exchange'] = ''\n\n if message_filter:\n method_arguments['filter'] = _build_message_filter(*message_filter)\n\n rpc = RemoteProcedure(handle_QMF2_exception,\n 'qmf.default.direct', server_url)\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\n 'reroute', method_arguments),\n timedelta(seconds=5))","async def deregister_route(self, handle: str) -> None:\n await self.AD.http.deregister_route(handle, self.name)","def detach_intent(self, intent_name):\n self.bus.emit(Message(\"detach_intent\", {\"intent_name\": intent_name}))","def desubscribe(self, subscription):\n try:\n if isinstance(subscription, Subscription):\n sub = DeSubscribe(subscription, self.__pool, self.myAddress)\n self.send(self.__pool, sub)\n except Exception:\n handle_actor_system_fail()","def unbind_policy(self, policy, vserver):\n log.info(\"Unbinding %s from %s\", policy, vserver)\n return self.delete(\"/lbvserver_responderpolicy_binding/{0}?args=policyname:{1}\".format(vserver, policy), content_type=self.content_type(\"lbvserver_responderpolicy_binding\"))","def unsubscribe(self, requestName: str, function: RequestFunction):\n if requestName not in self.requests:\n raise KeyError(f\"Cannot unsubscribe name {requestName} as it is not subscribed\")\n if function is None or function == self.requests[requestName]:\n del self.requests[requestName]\n else:\n raise ValueError(f\"Optional function {function} check does not match the function \"\n f\"{self.requests[requestName]} for request name {requestName}\")","def delete_queue(client, vhost, queue):\n client.delete_queue(vhost, queue)","def purge_mailbox(self):\n self._mailbox.clear()","def delete_queue(self, queue_name):\n amqp_session = self.__broker.getAmqpSession()\n amqp_session.queue_delete(queue_name)","def RoutingInterfaceNotificationUnregister(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def from_queue_key(cls, queue_key, connection=None):\n prefix = cls.redis_queue_namespace_prefix\n if not queue_key.startswith(prefix):\n raise ValueError('Not a valid RQ queue key: %s' % (queue_key,))\n name = queue_key[len(prefix):]\n return cls(name)","def dequeue(self, server_id):\n srv = self.get_server_dict(server_id)\n if len(srv['queue']) <= 0:\n return None\n return srv['queue'].popleft()","def unassign_global_ip(self, global_ip_id):\r\n return self.client['Network_Subnet_IpAddress_Global'].unroute(\r\n id=global_ip_id)","def disassociate_fleet(FleetName=None, StackName=None):\n pass","def exit_queue(self, name=None):\r\n if(name):\r\n self.log.debug(\"EXITING queue: (%s)\" % (name))\r\n self._queues[name].release()\r\n self.log.debug(\"SUCCESS EXITING queue: (%s)\" % (name))","def test_queue():\n mq = IPCComm.get_queue()\n key = str(mq.key)\n assert(CommBase.is_registered('IPCComm', key))\n CommBase.unregister_comm('IPCComm', key, dont_close=True)\n nt.assert_raises(KeyError, IPCComm.remove_queue, mq)\n CommBase.register_comm('IPCComm', key, mq)\n IPCComm.remove_queue(mq)\n assert(not CommBase.is_registered('IPCComm', key))","def unset(self, name, level=None):\n level = level or self.local_variables\n assert isinstance(level, EnvironmentLevel)\n\n # TODO need to remove from the expressions list as well?\n return level.bindings.pop(name, None)","def unsubscribe(self, observer, name=None):\n if name is None:\n name = 'default'\n if observer in self._observers:\n del self._observers[observer][name]","def query_exchange(self, exchange_name, alt_exchange_name=None):\n return self._query(exchange_name, \"exchange\", \"org.apache.qpid.broker\", alt_exchange_name)","def remove_bindings(ctx):\n\n config_db = ConfigDBConnector()\n config_db.connect()\n\n binding_table_name = 'NAT_BINDINGS'\n binding_dict = config_db.get_table(binding_table_name)\n if binding_dict:\n for binding_key_name in binding_dict:\n config_db.set_entry(binding_table_name, binding_key_name, None)","def __remove_request_from_queue(self, sender):\n with self.__queue.mutex:\n for x in self.__queue.queue:\n if x[1] == sender:\n self.__queue.queue.remove(x)\n return True\n return False","def do_rm_route(self, line):\n items = line.split(' ')\n if len(items) == 1:\n ans = raw_input('Remove the WHOLE fibbing route for %s ? (y/N)'\n % line)\n if ans == 'y':\n self.fibbing.remove_route(line)\n else:\n self.fibbing.remove_route_part(items[0], *items[1:])","def delete_queue(queue_name: str, server_url: Optional[str] = None):\n rpc = RemoteProcedure(handle_QMF2_exception,\n 'qmf.default.direct', server_url)\n delete_queue_message = create_QMF2_method_invoke(\n get_broker_id(server_url),\n 'delete', {\n 'type': 'queue',\n 'name': queue_name\n }\n )\n rpc.call(delete_queue_message, timedelta(seconds=5))","def _del_bgp_speaker_fip_route(self, context, bgp_speaker_id, topic, cidr):\n\n bgp_speaker = self.nb_api.get(bgp.BGPSpeaker(id=bgp_speaker_id,\n topic=topic))\n current_routes = {str(r.destination): r\n for r in bgp_speaker.host_routes}\n if cidr not in current_routes:\n # Route has not been added, skip.\n return\n\n del current_routes[cidr]\n bgp_speaker.host_routes = current_routes.values()\n self.nb_api.update(bgp_speaker, skip_send_event=True)","def pop(name, key, default=None):\n\n return get_component(CachingPackage.COMPONENT_NAME).pop(name, key, default=default)","def route_removed(self, prefix, next_hop, as_path):","def remove(self, key_name: str):\n pass","def remove(self, v: Route) -> insertion_response: # pylint: disable=arguments-differ, undefined-variable\n i = hash(v.addr)\n if i not in self._destinations:\n raise KeyError(\"{} key not found in the RIB\".format(i))\n if v in self._destinations[i]:\n self._destinations[i].remove(v)\n return None\n return v","def remove_from_usage_queue(self, md5_hash):\n self.usage_queue.remove(md5_hash)","def remove_gateway(self, network_ref):\n raise NotImplementedError()","def discard(self, key: KT) -> None:\n discard(self, key)","def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')","def remove(self, key):\n h = key%self.m\n a = self.a\n if a[h]:\n a[h] = None","def unlisten(cls, name: str):\r\n cls.Unlisten(name)","def deactivate(ctx: CLIContext, access_key):\n with Session() as session:\n try:\n data = session.KeyPair.deactivate(access_key)\n except Exception as e:\n ctx.output.print_mutation_error(\n e,\n item_name='keypair',\n action_name='deactivation',\n )\n sys.exit(1)\n if not data['ok']:\n ctx.output.print_mutation_error(\n msg=data['msg'],\n item_name='keypair',\n action_name='deactivation',\n )\n sys.exit(1)\n ctx.output.print_mutation_result(\n data,\n extra_info={\n 'access_key': access_key,\n },\n )","def dequeue(self, irc, msg, args):\n pos = self._find_in_queue(msg.nick)\n if pos < 0:\n irc.reply(\"You're not in the queue, did your nick change?\")\n return\n self._queue.pop(pos)\n self._count -= 1\n self._dump_queue()\n irc.reply(\"Removed you from the queue as requested\")","def pop_queue(self, queue=None):\n if not queue:\n return False\n \n cur = self.conn.cursor()\n cur.execute(\"LOCK TABLE \" + queue + \" IN ACCESS EXCLUSIVE MODE;\")\n\n cur.execute(\"SELECT id FROM \" + queue + \" LIMIT 1;\")\n row = cur.fetchone()\n self.conn.commit()\n \n if row:\n cur.execute(\"DELETE FROM \" + queue + \" WHERE id='\"+str(row[0])+\"';\")\n return row[0]\n else:\n return False","def unsubscribe(self, item_name):\n self.subscribed = None","def purge(self):\n self._rpc(specification.Queue.Purge())","def block_unbinding2(x,y):\n res = inv_binding_circular(x,y)\n return res","def deactivate(self, address):\n with self.lock:\n try:\n connections = self.connections[address]\n except KeyError: # already removed from the connection pool\n return\n for conn in list(connections):\n if not conn.in_use:\n connections.remove(conn)\n try:\n conn.close()\n except IOError:\n pass\n if not connections:\n self.remove(address)","def pop_postfix_arg(self, name):\n return self._postfix_kwargs.pop(name, None)","def purge_queue(queue_name: str,\n limit: int = 0,\n message_filter: Optional[Tuple[str, str]] = None,\n server_url: Optional[str] = None):\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\n server_url)\n method_arguments = {'request': limit} # type: dict\n if message_filter:\n method_arguments['filter'] = _build_message_filter(*message_filter)\n\n rpc = RemoteProcedure(handle_QMF2_exception,\n 'qmf.default.direct', server_url)\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\n 'purge', method_arguments),\n timedelta(seconds=5))"],"string":"[\n \"async def bind(\\n self,\\n exchange: ExchangeParamType,\\n routing_key: Optional[str] = None,\\n *,\\n arguments: Arguments = None,\\n timeout: TimeoutType = None,\\n ) -> aiormq.spec.Queue.BindOk:\\n\\n if routing_key is None:\\n routing_key = self.name\\n\\n log.debug(\\n \\\"Binding queue %r: exchange=%r, routing_key=%r, arguments=%r\\\",\\n self,\\n exchange,\\n routing_key,\\n arguments,\\n )\\n\\n channel = await self.channel.get_underlay_channel()\\n return await channel.queue_bind(\\n self.name,\\n exchange=get_exchange_name(exchange),\\n routing_key=routing_key,\\n arguments=arguments,\\n timeout=timeout,\\n )\",\n \"def bind_queue_to_exchange(self, channel, exchange, queue_name, routing_key):\\n logger.info('Binding %s to %s with %s',\\n exchange, queue_name, routing_key)\\n channel.queue_bind(queue=queue_name,\\n exchange=exchange,\\n routing_key=routing_key)\",\n \"def unbind(self, uid):\\r\\n if self.bind_uid == uid:\\r\\n self.bind_uid = ''\\r\\n if len(self.queue_applicants) > 0:\\r\\n self.queue_applicants.reverse()\\r\\n self.bind_uid = self.queue_applicants.pop()\\r\\n self.queue_applicants.reverse()\\r\\n else:\\r\\n if uid in self.queue_applicants:\\r\\n self.queue_applicants.remove(uid)\\r\\n return self.bind_uid\",\n \"def bind_queue(self, exchange_name, queue_name, bind_key):\\n self.logger.info('Subscribed to topic: {}'.format(bind_key))\\n try:\\n self._channel.queue_bind(\\n exchange=exchange_name, queue=queue_name, routing_key=bind_key)\\n except Exception as exc:\\n raise exc\",\n \"def remove_queue(self, queue) -> None:\\r\\n self.receive_queues.remove(queue)\",\n \"def remove_binding(ctx, binding_name):\\n\\n entryFound = False\\n table = 'NAT_BINDINGS'\\n key = binding_name\\n\\n if len(binding_name) > 32:\\n ctx.fail(\\\"Invalid binding name. Maximum allowed binding name is 32 characters !!\\\")\\n\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n\\n data = config_db.get_entry(table, key)\\n if not data:\\n click.echo(\\\"Trying to delete binding, which is not present.\\\")\\n entryFound = True\\n\\n if entryFound == False:\\n config_db.set_entry(table, key, None)\",\n \"def _remove_exchange(self, message):\\n key = (message.remote, message.mid)\\n\\n if key not in self._active_exchanges:\\n # Before turning this up to a warning, consider https://github.com/chrysn/aiocoap/issues/288\\n self.log.info(\\\"Received %s from %s, but could not match it to a running exchange.\\\", message.mtype, message.remote)\\n return\\n\\n messageerror_monitor, next_retransmission = self._active_exchanges.pop(key)\\n next_retransmission.cancel()\\n if message.mtype is RST:\\n messageerror_monitor()\\n self.log.debug(\\\"Exchange removed, message ID: %d.\\\", message.mid)\\n\\n self._continue_backlog(message.remote)\",\n \"def unbindGateway(self, system_id):\\r\\n bind_mgr = self.getBoundConnections(system_id)\\r\\n if bind_mgr:\\r\\n unbinds_list = []\\r\\n for bind in bind_mgr:\\r\\n unbinds_list.append(bind.getDisconnectedDeferred())\\r\\n bind.unbindAndDisconnect()\\r\\n d = defer.DeferredList(unbinds_list)\\r\\n else:\\r\\n d = defer.succeed(None)\\r\\n \\r\\n return d\",\n \"def clear_broadcast(param=None):\\n global command_queue\\n for i, command in enumerate(command_queue):\\n if (command['param'] == param or param is None) and command['type'] == RECURRING:\\n command_queue.pop(i)\\n break\",\n \"def unbind(cls, name: str):\\n if cls.instance() is None:\\n return\\n\\n if not name in cls.instance().m_axis_bindings and not name in cls.instance().m_button_bindings:\\n print( 'Unable to unbind: {}. Name not bound to axis or button.'.format( name ) )\\n return\\n\\n if name in cls.instance().m_axis_bindings:\\n axis = cls.instance().m_axis_bindings[ name ].axis\\n del cls.instance().m_axis_bindings[ name ]\\n del cls.instance().m_axis_name_table[ axis ]\\n if name in cls.instance().m_button_bindings:\\n button = cls.instance().m_button_bindings[ name ].button\\n del cls.instance().m_button_bindings[ name ]\\n del cls.instance().m_button_name_table[ button ]\",\n \"def del_queue(self, queue_id):\\n del self.queue_dict[queue_id]\",\n \"def RemoveFromQueue(self, addr):\\n if addr in self.connection_queue:\\n self.connection_queue.remove(addr)\",\n \"def unlisten(self, prefix: str) -> None:\\n assert len(prefix) == 1\\n del self.queues[prefix]\\n self.logger.info(\\\"No longer polling for message type: %s\\\", prefix)\",\n \"def RemoveIamPolicyBinding(task_ref, member, role):\\n policy = GetIamPolicy(task_ref)\\n iam_util.RemoveBindingFromIamPolicy(policy, member, role)\\n return SetIamPolicy(task_ref, policy)\",\n \"def _unbind_event(\\r\\n self, handler: Handler, event_type: EventType,\\r\\n handlers_dict: Dict[str, HandlerData]) -> None:\\r\\n from apysc.event.handler import append_unbinding_expression\\r\\n from apysc.event.handler import get_handler_name\\r\\n self_instance: VariableNameInterface = \\\\\\r\\n self._validate_self_is_variable_name_interface()\\r\\n name: str = get_handler_name(handler=handler, instance=self)\\r\\n if name in handlers_dict:\\r\\n del handlers_dict[name]\\r\\n append_unbinding_expression(\\r\\n this=self_instance, handler_name=name,\\r\\n event_type=event_type)\",\n \"def release_bound_key(self, event):\\n try:\\n if event.key in [key[0] for key in self.key_bindings]:\\n self.unpress()\\n except TypeError:\\n if event.key in self.key_bindings:\\n self.unpress()\",\n \"def bind(self, source, routing_key=None, arguments=None):\\n if hasattr(source, 'name'):\\n source = source.name\\n frame = specification.Queue.Bind(queue=self.name,\\n exchange=source,\\n routing_key=routing_key or '',\\n arguments=arguments)\\n response = self._rpc(frame)\\n return isinstance(response, specification.Queue.BindOk)\",\n \"def remove_queue(self, queue):\\n with self.mutex:\\n self.queues.remove(queue)\",\n \"def unbind_receive_response(self, msg_tag):\\n if self._callable:\\n del self._response_bindings[msg_tag]\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def unbind(self, name):\\n remove = []\\n for n in name:\\n if not self.is_array(n): continue\\n self.drop(n, ignore_items=True)\\n remove.append(n)\\n if remove and self._verbose_infos:\\n print(\\\"Remove mask structure for: '{}'\\\".format(\\\"', '\\\".join(remove)))\\n return None\",\n \"def unsubscribe(self):\\n\\n # Unsubscribe\\n self.pyrps.redis.srem(self.pyrps._ns_subscriptions(self.queue), self.consumer_id) \\n\\n # Remove message queue\\n self.pyrps.redis.delete(self.pyrps._ns_queue(self.queue, self.consumer_id))\",\n \"def unbind(self, sequence, funcid=None):\\n return self._widget_unbind(sequence, funcid, internal=False)\",\n \"def unregister_router(self, hostname):\",\n \"def RemoveIamPolicyBinding(zone_ref, member, role):\\n policy = GetIamPolicy(zone_ref)\\n iam_util.RemoveBindingFromIamPolicy(policy, member, role)\\n return SetIamPolicy(zone_ref, policy)\",\n \"def unbind(self, binding_id):\\n\\n if binding_id not in self._bindings:\\n return False\\n\\n event_props = self._bindings[binding_id][1]\\n del self._bindings[binding_id]\\n\\n if event_props in self._active_bindings:\\n self.ignore(event_props)\\n\\n return True\",\n \"def async_clear_address(self, address: str) -> None:\\n self._matched.pop(address, None)\\n self._matched_connectable.pop(address, None)\",\n \"def unbindWidget(self, widget):\\n\\n # Figure out the index into __boundWidgets,\\n # as we need this to pass to __unbindWidget,\\n # which does the real work.\\n index = -1\\n\\n for i, bw in enumerate(self.__boundWidgets):\\n if bw.widget == widget:\\n index = i\\n break\\n\\n if index == -1:\\n raise ValueError('Widget {} [{}] is not bound'\\n .format(type(widget).__name__, id(widget)))\\n\\n self.__unbindWidget( index)\\n self.__boundWidgets.pop(index)\",\n \"def forget(self, req, ino, nlookup):\\r\\n self.reply_none(req)\",\n \"def unsubscribe_symbol(self, symbol):\\n try:\\n self.symbol.pop(symbol, None)\\n self.symbol_data.pop(symbol, None)\\n except KeyError:\\n print(\\\"Could not unsubscribe symbol {} as it was never subscribed.\\\".format(str(symbol)))\",\n \"def bind(self, exchange, routing_key='', arguments=None, timeout=None):\\n\\n log.debug(\\\"Binding exchange %r to exchange %r, routing_key=%r, arguments=%r\\\", self, exchange, routing_key,\\n arguments)\\n\\n f = self._create_future(timeout)\\n\\n self._channel.exchange_bind(\\n destination=self.name,\\n source=self._get_exchange_name(exchange),\\n routing_key=routing_key,\\n arguments=arguments,\\n callback=f.set_result,\\n )\\n\\n return f\",\n \"def _do_backend_unbind(self, backend, port_id):\\n\\n driver = self.backend_manager.get_backend_driver(backend)\\n driver.unbind(port_id)\",\n \"def unbind(self, svc, svc_ref):\\n with self._lock:\\n if ORDER_HANDLER in svc_ref.get_property(pelix.OBJECTCLASS):\\n targets = svc_ref.get_property(ORDER_TARGETS)\\n if isinstance(targets, (list, tuple)):\\n for target in targets:\\n associates = self._target_handlers.get(target, None)\\n if svc in associates:\\n del associates[svc]\\n\\n else:\\n associates = self._target_handlers.get(str(targets), None)\\n if svc in associates:\\n del associates[svc]\",\n \"def deregister(self, queue, project=None):\\n\\n # TODO(kgriffs): SHARDING - Implement this!\\n pass\",\n \"def storage_import_unbind(self, target_lun_path, vserver_name=None):\\n return self.request( \\\"storage-import-unbind\\\", {\\n 'target_lun_path': [ target_lun_path, 'target-lun-path', [ basestring, 'None' ], False ],\\n 'vserver_name': [ vserver_name, 'vserver-name', [ basestring, 'None' ], False ],\\n }, {\\n } )\",\n \"def port_unbind(endpoint_id, neutron_port, **kwargs):\\n\\n vif_type = neutron_port.get(constants.VIF_TYPE_KEY,\\n constants.FALLBACK_VIF_TYPE)\\n vif_details = lib_utils.string_mappings(neutron_port.get(\\n constants.VIF_DETAILS_KEY))\\n unbinding_exec_path = os.path.join(cfg.CONF.bindir, vif_type)\\n\\n port_id = neutron_port['id']\\n ifname, _ = utils.get_veth_pair_names(port_id)\\n\\n mac_address = neutron_port['mac_address']\\n network_id = neutron_port['network_id']\\n stdout, stderr = processutils.execute(\\n unbinding_exec_path, constants.UNBINDING_SUBCOMMAND, port_id, ifname,\\n endpoint_id, mac_address, vif_details, network_id)\\n try:\\n utils.remove_device(ifname)\\n except pyroute2.NetlinkError:\\n LOG.exception(\\\"Error happened during deleting the veth pair\\\")\\n raise exceptions.VethDeletionFailure(\\n 'Deleting the veth pair failed.')\\n return (stdout, stderr)\",\n \"def clear_bound_event(self, name: str):\\n assert self.is_websocket_state, Exception(\\\"Cannot bind events in non websocket state. See is_websocket_state\\\")\\n\\n if isinstance(name, Enum):\\n name = str(name)\\n\\n assert isinstance(name, str), ValueError(\\\"The event name must be a string or enum.\\\")\\n\\n if name in self._bind_events:\\n del self._bind_events[name]\",\n \"def unsubscribe(self, tag):\\n self.socket.setsockopt(constants.UNSUBSCRIBE, tag)\",\n \"def removeConnection(self, connection):\\r\\n if connection.system_id is None:\\r\\n self.log.debug(\\\"SMPP connection attempt failed without binding.\\\")\\r\\n else:\\r\\n system_id = connection.system_id\\r\\n bind_type = connection.bind_type\\r\\n self.bound_connections[system_id].removeBinding(connection)\\r\\n self.log.info(\\\"Dropped %s bind for '%s'. Active binds: %s. Max binds: %s\\\" % (bind_type, system_id, self.getBoundConnectionCountsStr(system_id), self.config.systems[system_id]['max_bindings']))\\r\\n # If this is the last binding for this service then remove the BindManager\\r\\n if self.bound_connections[system_id].getBindingCount() == 0:\\r\\n self.bound_connections.pop(system_id)\",\n \"def delete_queue(self, queue_name: str) -> None:\\n if queue_name is None:\\n raise TypeError(\\\"Queue name cannot be None.\\\")\\n\\n with self.get_conn() as service_mgmt_conn:\\n service_mgmt_conn.delete_queue(queue_name)\",\n \"def remove(self, destination: n):\\n try:\\n self.connections.pop(destination)\\n except KeyError:\\n pass\",\n \"def remove(self, v: Route): # pylint: disable=arguments-differ, undefined-variable\\n i = hash(str(v.addr) + str(v.nh))\\n if i not in self._destinations:\\n raise KeyError(\\\"{} key not found in the history RIB\\\".format(i))\\n if v in self._destinations[i]:\\n self._destinations[i].remove(v)\\n if len(self._destinations[i]) == 0:\\n del self._destinations[i]\\n return None\\n return v\",\n \"def unbind_receive_notification(self, mtype, declare=True):\\n if self._callable:\\n del self._notification_bindings[mtype]\\n if declare:\\n self._declare_subscriptions()\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def get_queue(self, task_name):\\n for name, queue in self.queues.items():\\n if task_name in queue:\\n return name\\n return self.default_queue\",\n \"def query_queue(self, queue_name, alt_exchange_name=None):\\n return self._query(queue_name, \\\"queue\\\", \\\"org.apache.qpid.broker\\\", alt_exchange_name)\",\n \"def unbind_receive_call(self, mtype, declare=True):\\n if self._callable:\\n del self._call_bindings[mtype]\\n if declare:\\n self._declare_subscriptions()\\n else:\\n raise SAMPClientError(\\\"Client not callable.\\\")\",\n \"def unset_cipher(self, key_name=None):\\n if key_name is None:\\n if self.key_name is not None:\\n message_key_types.unset_cipher(self.key_name)\\n if self.pending_key_name is not None:\\n message_key_types.unset_cipher(self.pending_key_name)\\n else:\\n message_key_types.unset_cipher(key_name)\",\n \"def clear(self, key):\\n cache_key = make_key('queue-' + self.name, key)\\n memcache.delete(cache_key)\",\n \"def unsubscribe(self, destination, extra_headers=None):\\n unsubscribe = frame.UnsubscribeFrame(destination, extra_headers=extra_headers)\\n res = self.send_frame(unsubscribe)\\n with self.subscription_lock:\\n self.subscribed_destinations.pop(destination)\\n return res\",\n \"def __delitem__(self, i: Route) -> None:\\n i = hash(i.addr)\\n if i not in self._destinations:\\n raise KeyError(\\\"{} key not found in the RIB\\\".format(i))\\n del self._destinations[i]\",\n \"def free_queue(self, sycl_queue_val):\\n fn = DpctlCAPIFnBuilder.get_dpctl_queue_delete(\\n builder=self.builder, context=self.context\\n )\\n self.builder.call(fn, [self.builder.load(sycl_queue_val)])\",\n \"def deregister(self, queue, project=None):\\n self._invalidate_cached_id(queue, project)\\n self._catalogue_ctrl.delete(project, queue)\",\n \"def deregister(self, queue, project=None):\\n self._catalogue_ctrl.delete(project, queue)\",\n \"def ungraded_response(self, queue_msg, queuekey):\\r\\n # check the queuekey against the saved queuekey\\r\\n if('queuestate' in self.input_state and self.input_state['queuestate'] == 'queued'\\r\\n and self.input_state['queuekey'] == queuekey):\\r\\n msg = self._parse_data(queue_msg)\\r\\n # save the queue message so that it can be rendered later\\r\\n self.input_state['queue_msg'] = msg\\r\\n self.input_state['queuestate'] = None\\r\\n self.input_state['queuekey'] = None\",\n \"def __delitem__(self, key_mac):\\n self.ingress_tbl.pop(key_mac, None)\\n rsw = self.rootsw_tbl.pop(key_mac, None)\\n if rsw:\\n rsw.leaf_macs.discard(key_mac)\",\n \"def reset_queue(self, name, namespace):\\n raise RuntimeError('Archives are read-only')\",\n \"def unbind(self):\\n\\n logging.debug('Unbind client {uid}...'.format(uid=self.uid))\\n p = smpp.make_pdu('unbind', client=self)\\n self.send_pdu(p)\\n\\n try:\\n return self.read_pdu()\\n except socket.timeout:\\n raise exceptions.ConnectionError()\",\n \"def __unbindWidget(self, index):\\n\\n bw = self.__boundWidgets[index]\\n\\n # Only attempt to unbind if the parent\\n # and widget have not been destroyed\\n if bw.isAlive():\\n bw.parent.Unbind(bw.evType, source=bw.widget)\",\n \"def reroute_queue(queue_name: str, exchange_name: str,\\n limit: int = 0,\\n message_filter: Optional[Tuple[str, str]] = None,\\n server_url: Optional[str] = None):\\n # Gather queue & exchange info + existance check\\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\\n server_url)\\n get_object('org.apache.qpid.broker', 'exchange',\\n exchange_name, server_url)\\n\\n method_arguments = {'request': limit} # type: dict\\n\\n if exchange_name:\\n method_arguments['useAltExchange'] = False\\n method_arguments['exchange'] = exchange_name\\n else:\\n method_arguments['useAltExchange'] = True\\n method_arguments['exchange'] = ''\\n\\n if message_filter:\\n method_arguments['filter'] = _build_message_filter(*message_filter)\\n\\n rpc = RemoteProcedure(handle_QMF2_exception,\\n 'qmf.default.direct', server_url)\\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\\n 'reroute', method_arguments),\\n timedelta(seconds=5))\",\n \"async def deregister_route(self, handle: str) -> None:\\n await self.AD.http.deregister_route(handle, self.name)\",\n \"def detach_intent(self, intent_name):\\n self.bus.emit(Message(\\\"detach_intent\\\", {\\\"intent_name\\\": intent_name}))\",\n \"def desubscribe(self, subscription):\\n try:\\n if isinstance(subscription, Subscription):\\n sub = DeSubscribe(subscription, self.__pool, self.myAddress)\\n self.send(self.__pool, sub)\\n except Exception:\\n handle_actor_system_fail()\",\n \"def unbind_policy(self, policy, vserver):\\n log.info(\\\"Unbinding %s from %s\\\", policy, vserver)\\n return self.delete(\\\"/lbvserver_responderpolicy_binding/{0}?args=policyname:{1}\\\".format(vserver, policy), content_type=self.content_type(\\\"lbvserver_responderpolicy_binding\\\"))\",\n \"def unsubscribe(self, requestName: str, function: RequestFunction):\\n if requestName not in self.requests:\\n raise KeyError(f\\\"Cannot unsubscribe name {requestName} as it is not subscribed\\\")\\n if function is None or function == self.requests[requestName]:\\n del self.requests[requestName]\\n else:\\n raise ValueError(f\\\"Optional function {function} check does not match the function \\\"\\n f\\\"{self.requests[requestName]} for request name {requestName}\\\")\",\n \"def delete_queue(client, vhost, queue):\\n client.delete_queue(vhost, queue)\",\n \"def purge_mailbox(self):\\n self._mailbox.clear()\",\n \"def delete_queue(self, queue_name):\\n amqp_session = self.__broker.getAmqpSession()\\n amqp_session.queue_delete(queue_name)\",\n \"def RoutingInterfaceNotificationUnregister(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def from_queue_key(cls, queue_key, connection=None):\\n prefix = cls.redis_queue_namespace_prefix\\n if not queue_key.startswith(prefix):\\n raise ValueError('Not a valid RQ queue key: %s' % (queue_key,))\\n name = queue_key[len(prefix):]\\n return cls(name)\",\n \"def dequeue(self, server_id):\\n srv = self.get_server_dict(server_id)\\n if len(srv['queue']) <= 0:\\n return None\\n return srv['queue'].popleft()\",\n \"def unassign_global_ip(self, global_ip_id):\\r\\n return self.client['Network_Subnet_IpAddress_Global'].unroute(\\r\\n id=global_ip_id)\",\n \"def disassociate_fleet(FleetName=None, StackName=None):\\n pass\",\n \"def exit_queue(self, name=None):\\r\\n if(name):\\r\\n self.log.debug(\\\"EXITING queue: (%s)\\\" % (name))\\r\\n self._queues[name].release()\\r\\n self.log.debug(\\\"SUCCESS EXITING queue: (%s)\\\" % (name))\",\n \"def test_queue():\\n mq = IPCComm.get_queue()\\n key = str(mq.key)\\n assert(CommBase.is_registered('IPCComm', key))\\n CommBase.unregister_comm('IPCComm', key, dont_close=True)\\n nt.assert_raises(KeyError, IPCComm.remove_queue, mq)\\n CommBase.register_comm('IPCComm', key, mq)\\n IPCComm.remove_queue(mq)\\n assert(not CommBase.is_registered('IPCComm', key))\",\n \"def unset(self, name, level=None):\\n level = level or self.local_variables\\n assert isinstance(level, EnvironmentLevel)\\n\\n # TODO need to remove from the expressions list as well?\\n return level.bindings.pop(name, None)\",\n \"def unsubscribe(self, observer, name=None):\\n if name is None:\\n name = 'default'\\n if observer in self._observers:\\n del self._observers[observer][name]\",\n \"def query_exchange(self, exchange_name, alt_exchange_name=None):\\n return self._query(exchange_name, \\\"exchange\\\", \\\"org.apache.qpid.broker\\\", alt_exchange_name)\",\n \"def remove_bindings(ctx):\\n\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n\\n binding_table_name = 'NAT_BINDINGS'\\n binding_dict = config_db.get_table(binding_table_name)\\n if binding_dict:\\n for binding_key_name in binding_dict:\\n config_db.set_entry(binding_table_name, binding_key_name, None)\",\n \"def __remove_request_from_queue(self, sender):\\n with self.__queue.mutex:\\n for x in self.__queue.queue:\\n if x[1] == sender:\\n self.__queue.queue.remove(x)\\n return True\\n return False\",\n \"def do_rm_route(self, line):\\n items = line.split(' ')\\n if len(items) == 1:\\n ans = raw_input('Remove the WHOLE fibbing route for %s ? (y/N)'\\n % line)\\n if ans == 'y':\\n self.fibbing.remove_route(line)\\n else:\\n self.fibbing.remove_route_part(items[0], *items[1:])\",\n \"def delete_queue(queue_name: str, server_url: Optional[str] = None):\\n rpc = RemoteProcedure(handle_QMF2_exception,\\n 'qmf.default.direct', server_url)\\n delete_queue_message = create_QMF2_method_invoke(\\n get_broker_id(server_url),\\n 'delete', {\\n 'type': 'queue',\\n 'name': queue_name\\n }\\n )\\n rpc.call(delete_queue_message, timedelta(seconds=5))\",\n \"def _del_bgp_speaker_fip_route(self, context, bgp_speaker_id, topic, cidr):\\n\\n bgp_speaker = self.nb_api.get(bgp.BGPSpeaker(id=bgp_speaker_id,\\n topic=topic))\\n current_routes = {str(r.destination): r\\n for r in bgp_speaker.host_routes}\\n if cidr not in current_routes:\\n # Route has not been added, skip.\\n return\\n\\n del current_routes[cidr]\\n bgp_speaker.host_routes = current_routes.values()\\n self.nb_api.update(bgp_speaker, skip_send_event=True)\",\n \"def pop(name, key, default=None):\\n\\n return get_component(CachingPackage.COMPONENT_NAME).pop(name, key, default=default)\",\n \"def route_removed(self, prefix, next_hop, as_path):\",\n \"def remove(self, key_name: str):\\n pass\",\n \"def remove(self, v: Route) -> insertion_response: # pylint: disable=arguments-differ, undefined-variable\\n i = hash(v.addr)\\n if i not in self._destinations:\\n raise KeyError(\\\"{} key not found in the RIB\\\".format(i))\\n if v in self._destinations[i]:\\n self._destinations[i].remove(v)\\n return None\\n return v\",\n \"def remove_from_usage_queue(self, md5_hash):\\n self.usage_queue.remove(md5_hash)\",\n \"def remove_gateway(self, network_ref):\\n raise NotImplementedError()\",\n \"def discard(self, key: KT) -> None:\\n discard(self, key)\",\n \"def on_queue_declared(frame):\\n channel.basic_consume(handle_delivery, queue='test')\",\n \"def remove(self, key):\\n h = key%self.m\\n a = self.a\\n if a[h]:\\n a[h] = None\",\n \"def unlisten(cls, name: str):\\r\\n cls.Unlisten(name)\",\n \"def deactivate(ctx: CLIContext, access_key):\\n with Session() as session:\\n try:\\n data = session.KeyPair.deactivate(access_key)\\n except Exception as e:\\n ctx.output.print_mutation_error(\\n e,\\n item_name='keypair',\\n action_name='deactivation',\\n )\\n sys.exit(1)\\n if not data['ok']:\\n ctx.output.print_mutation_error(\\n msg=data['msg'],\\n item_name='keypair',\\n action_name='deactivation',\\n )\\n sys.exit(1)\\n ctx.output.print_mutation_result(\\n data,\\n extra_info={\\n 'access_key': access_key,\\n },\\n )\",\n \"def dequeue(self, irc, msg, args):\\n pos = self._find_in_queue(msg.nick)\\n if pos < 0:\\n irc.reply(\\\"You're not in the queue, did your nick change?\\\")\\n return\\n self._queue.pop(pos)\\n self._count -= 1\\n self._dump_queue()\\n irc.reply(\\\"Removed you from the queue as requested\\\")\",\n \"def pop_queue(self, queue=None):\\n if not queue:\\n return False\\n \\n cur = self.conn.cursor()\\n cur.execute(\\\"LOCK TABLE \\\" + queue + \\\" IN ACCESS EXCLUSIVE MODE;\\\")\\n\\n cur.execute(\\\"SELECT id FROM \\\" + queue + \\\" LIMIT 1;\\\")\\n row = cur.fetchone()\\n self.conn.commit()\\n \\n if row:\\n cur.execute(\\\"DELETE FROM \\\" + queue + \\\" WHERE id='\\\"+str(row[0])+\\\"';\\\")\\n return row[0]\\n else:\\n return False\",\n \"def unsubscribe(self, item_name):\\n self.subscribed = None\",\n \"def purge(self):\\n self._rpc(specification.Queue.Purge())\",\n \"def block_unbinding2(x,y):\\n res = inv_binding_circular(x,y)\\n return res\",\n \"def deactivate(self, address):\\n with self.lock:\\n try:\\n connections = self.connections[address]\\n except KeyError: # already removed from the connection pool\\n return\\n for conn in list(connections):\\n if not conn.in_use:\\n connections.remove(conn)\\n try:\\n conn.close()\\n except IOError:\\n pass\\n if not connections:\\n self.remove(address)\",\n \"def pop_postfix_arg(self, name):\\n return self._postfix_kwargs.pop(name, None)\",\n \"def purge_queue(queue_name: str,\\n limit: int = 0,\\n message_filter: Optional[Tuple[str, str]] = None,\\n server_url: Optional[str] = None):\\n queue = get_object('org.apache.qpid.broker', 'queue', queue_name,\\n server_url)\\n method_arguments = {'request': limit} # type: dict\\n if message_filter:\\n method_arguments['filter'] = _build_message_filter(*message_filter)\\n\\n rpc = RemoteProcedure(handle_QMF2_exception,\\n 'qmf.default.direct', server_url)\\n rpc.call(create_QMF2_method_invoke(queue['_object_id'],\\n 'purge', method_arguments),\\n timedelta(seconds=5))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5841196","0.5779545","0.5448614","0.5320331","0.52993155","0.5290274","0.51541996","0.51409155","0.5094225","0.4963937","0.49457547","0.4868611","0.48207507","0.48195007","0.48154044","0.48097736","0.4786163","0.47184947","0.47171628","0.47167245","0.46891996","0.46758026","0.46731448","0.4625122","0.4613626","0.4613463","0.460915","0.4598541","0.45925996","0.4588057","0.4587823","0.4581647","0.45750883","0.4572816","0.45688346","0.45565167","0.45281357","0.45168456","0.45046353","0.44966087","0.449482","0.44862655","0.44804","0.4439095","0.44300342","0.4424693","0.44220573","0.44106132","0.4408428","0.4405126","0.4402392","0.4400993","0.43923908","0.4388102","0.43855143","0.43750745","0.43743888","0.43711758","0.43709728","0.43618372","0.43572783","0.43508178","0.4347788","0.43388435","0.43378383","0.43348527","0.43303207","0.43262577","0.4321739","0.43216112","0.43050295","0.42961964","0.4292655","0.42849666","0.42734474","0.42720336","0.42571992","0.42519194","0.4234207","0.42326745","0.42045116","0.4198423","0.41848394","0.4184011","0.4178655","0.41541645","0.4142738","0.41350985","0.41331062","0.41299966","0.41215578","0.41157088","0.4109701","0.41021818","0.41006863","0.40977186","0.40963224","0.40939957","0.40937757","0.40932047"],"string":"[\n \"0.5841196\",\n \"0.5779545\",\n \"0.5448614\",\n \"0.5320331\",\n \"0.52993155\",\n \"0.5290274\",\n \"0.51541996\",\n \"0.51409155\",\n \"0.5094225\",\n \"0.4963937\",\n \"0.49457547\",\n \"0.4868611\",\n \"0.48207507\",\n \"0.48195007\",\n \"0.48154044\",\n \"0.48097736\",\n \"0.4786163\",\n \"0.47184947\",\n \"0.47171628\",\n \"0.47167245\",\n \"0.46891996\",\n \"0.46758026\",\n \"0.46731448\",\n \"0.4625122\",\n \"0.4613626\",\n \"0.4613463\",\n \"0.460915\",\n \"0.4598541\",\n \"0.45925996\",\n \"0.4588057\",\n \"0.4587823\",\n \"0.4581647\",\n \"0.45750883\",\n \"0.4572816\",\n \"0.45688346\",\n \"0.45565167\",\n \"0.45281357\",\n \"0.45168456\",\n \"0.45046353\",\n \"0.44966087\",\n \"0.449482\",\n \"0.44862655\",\n \"0.44804\",\n \"0.4439095\",\n \"0.44300342\",\n \"0.4424693\",\n \"0.44220573\",\n \"0.44106132\",\n \"0.4408428\",\n \"0.4405126\",\n \"0.4402392\",\n \"0.4400993\",\n \"0.43923908\",\n \"0.4388102\",\n \"0.43855143\",\n \"0.43750745\",\n \"0.43743888\",\n \"0.43711758\",\n \"0.43709728\",\n \"0.43618372\",\n \"0.43572783\",\n \"0.43508178\",\n \"0.4347788\",\n \"0.43388435\",\n \"0.43378383\",\n \"0.43348527\",\n \"0.43303207\",\n \"0.43262577\",\n \"0.4321739\",\n \"0.43216112\",\n \"0.43050295\",\n \"0.42961964\",\n \"0.4292655\",\n \"0.42849666\",\n \"0.42734474\",\n \"0.42720336\",\n \"0.42571992\",\n \"0.42519194\",\n \"0.4234207\",\n \"0.42326745\",\n \"0.42045116\",\n \"0.4198423\",\n \"0.41848394\",\n \"0.4184011\",\n \"0.4178655\",\n \"0.41541645\",\n \"0.4142738\",\n \"0.41350985\",\n \"0.41331062\",\n \"0.41299966\",\n \"0.41215578\",\n \"0.41157088\",\n \"0.4109701\",\n \"0.41021818\",\n \"0.41006863\",\n \"0.40977186\",\n \"0.40963224\",\n \"0.40939957\",\n \"0.40937757\",\n \"0.40932047\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77533823"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93088,"cells":{"query":{"kind":"string","value":"Return a specification.Queue.Declare class precomposed for the rpc method since this can be called multiple times."},"document":{"kind":"string","value":"def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_exchange()\n\n if self.name is not None:\n await self.declare_queue()\n\n if self.exchange:\n await self.bind_queue()\n\n return self","def _queue_create(self, **kwargs):\n name = self.generate_random_name()\n return self.clients(\"zaqar\").queue(name, **kwargs)","def new_queue() -> Queue:\n return multiprocessing.Queue()","def get_queue():\n\n return multiprocessing.Queue()","def _create_queue(self):\n # Instantiate\n queue = pbs.queue(verbose=not self.quiet)\n\n if self.q == 'ember':\n # Submitting to Utah ember cluster\n ppn = 12\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n walltime = self.walltime if int(self.walltime.split(':')[0]) < 72 else '72:00:00'\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\n walltime=walltime, ppn=ppn, cpus=cpus, partition='ember', alloc='sdss')\n elif self.q is not None:\n # All other self.q values expected for Portsmouth cluster,\n # sciama. In this case, the number of nodes is queue\n # dependent, and qos is not set\n if self.q == 'sciama1.q':\n ppn = 12\n elif self.q == 'sciama3.q':\n ppn = 20\n else:\n ppn = 16\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n queue.create(label=self.label, nodes=self.nodes, umask=self.umask,\n walltime=self.walltime, queue=self.q, ppn=ppn, cpus=cpus)\n else:\n # self.q can be None when submitting to both the Portsmouth\n # and Utah clusters. In this case, the default queue\n # destination and ppn is correct. qos is also set, but this\n # should only be used when submitting to Utah.\n ppn = 16\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\n walltime=self.walltime, ppn=ppn, cpus=cpus)\n\n return queue","def setup_queue(self, method_frame):\n logger.info('Declaring queue %s', self.queue_name)\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\n\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)","def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")","def instantiate_queue(self):\n serialized_queue = self.cache.get('queue')\n queue = ast.literal_eval(serialized_queue.decode('utf-8'))\n return queue","def serialize(self):\n return self.instantiate_queue()","def get(queue_name: str, **kwargs) -> Queue:\n return Queue(queue_name, **kwargs)","def setup_queue(self):\n self.logger.info('declaring queue %s', self.queue)\n if self.otq:\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\n else:\n self._channel.queue_declare(self.on_queue_declareok, self.queue)","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue(self):\n return self.__queue","def _get_queue_kwargs(self):\n executor = self.cloudify_context['executor']\n node_instance_id = self.cloudify_context['node_id']\n\n if executor == 'auto':\n # for executor=auto, we'll be a host_agent script if we do have\n # a host, otherwise CDA\n client = get_rest_client()\n node_instance = client.node_instances.get(node_instance_id)\n if node_instance.host_id:\n executor = 'host_agent'\n else:\n executor = 'central_deployment_agent'\n\n if executor == 'host_agent':\n if self._cloudify_agent is None:\n self._cloudify_agent, tenant = self._get_agent_settings(\n node_instance_id=node_instance_id,\n deployment_id=self.cloudify_context['deployment_id'],\n tenant=None)\n return (self._cloudify_agent['queue'],\n self._cloudify_agent['name'],\n tenant,\n self._cloudify_agent['rest_host'])\n else:\n return MGMTWORKER_QUEUE, MGMTWORKER_QUEUE, None, \\\n self.workflow_context.rest_host","def rpc(self) -> global___Rpc:","def queue():\n\n # Check if the client is connected.\n if not session.is_connected():\n return dict(ok=False, error=\"Client not connected\")\n\n # Add the operation to the local queue.\n operation = manager.enqueue(session.get_sid())\n\n # If the local list of operation to solve is empty the Mmanager.enqueue`\n # method returns `None`, ence if the value of `operation` is `None`\n # the client should stop.\n return dict(ok=True, operation=operation, halt=operation is None)","def queue(self, sid):\r\n return queues.Queue(self, sid)","def __init__(self):\n self.dequeue = DeQueue()","def queue(self, name):\n # First create a queue\n queue = self.inbound_channel.declare_queue(name)\n\n # Create the registry for the queue\n registry = Registry(self, queue)\n\n # Prepare consuming queue with registry\n self.inbound_channel.consume(queue=queue, callback=registry)\n\n # Then, return the Registry object.\n return registry","def queue_maker(queue, bucket_name):\n scraper = key_scraper.KaleidoscopeKeyScraper(\n bucket_name=bucket_name,\n queue=queue,\n )\n scraper.add_keys_to_queue()\n\n return None","def __init__(self):\n queue = collections.deque()","def _get_queue_type(self):\n return self.__queue_type","def _get_queue_type(self):\n return self.__queue_type","def _get_queue_type(self):\n return self.__queue_type","def _get_queue_type(self):\n return self.__queue_type","def _get_queue_type(self):\n return self.__queue_type","def _get_queue_type(self):\n return self.__queue_type","def __init__(self):\n self.queue = Queue()","def get_queue(self):\n if self.queue is not None:\n return self.queue\n state = self.get_state()\n self.queue = state.get_queue()\n # print(\"IQ\", self.queue)\n return self.queue","def create_queue(self, queue_name, visibility_timeout=None):\r\n params = {'QueueName': queue_name}\r\n if visibility_timeout:\r\n params['DefaultVisibilityTimeout'] = '%d' % (visibility_timeout,)\r\n return self.get_object('CreateQueue', params, Queue)","def __init__(self, queue: CityOverheadTimeQueue, name: int):\n super().__init__()\n self._name = name\n self._queue = queue\n self.data_incoming = True","def __init__(self):\n self._queue = defaultdict(\n OrderedDict\n ) # type: Dict[OrderedDict[TelnetCommand, ExpectedResponse]]","def __init__(self):\n Queue.__init__(self)","def declare_queue(self, c, queue_name):\n return self._management_req(\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\n {\"auto_delete\": False, \"durable\": False, \"arguments\": {}})","def create(cls, process_name=\"ReceiverSender\",queue_send=None, queue_receive=None): #pensar em mais parametros\n cls.instance = cls(process_name, queue_send, queue_receive)\n return cls.instance","def queue(self):\n if self._queue is None:\n qstr = self.query_queue(user=self._user)\n self._queue = self.parse_queue_str(qstr, keys=self.QSTAT_KEYS)\n\n return self._queue","def __init__(self):\n self.queue = []","def __init__(self):\n self.queue = []","def __init__(self):\n self.queue = []","def __init__(self):\n self.queue = []","def __init__(self):\n self.queue = []","def queue(self):\n if self._queue is None:\n qstr = self.query_queue(user=self._user)\n self._queue = self.parse_queue_str(qstr)\n\n return self._queue","def __init__(self):\n self.queue = []\n self.queue.append(Queue())\n self.queue.append(Queue())\n self.tag = 0 # using to record which queue contain the data","def __init__(self) -> None:\n self._queue = []","def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )","def enqueue(self, name):\n pass","def __init__(self):\r\n self.queue = []","def __init__(self):\r\n self.queue = []","def __init__(self):\n self.queue = deque()","def __init__(self):\n self.queue = deque()","def __init__(self):\n self.queue = deque()","def __init__(self):\n self.queue = deque()","def get_cmds_queue(self):\n\t\t\n\t\treturn Queue()","def _push_queue(self):\n\n self.add_cons_vars(self._var_queue, sloppy=self.sloppy)\n self.add_cons_vars(self._cons_queue, sloppy = self.sloppy)\n\n if len(self._var_queue) > 0:\n self.regenerate_variables()\n if len(self._cons_queue) > 0:\n self.regenerate_constraints()\n\n self._var_queue = list()\n self._cons_queue = list()","def get_queue(self):\n return self.queue","def get_queue(self):\n return self.queue","def __init__(__self__, *,\n endpoint_type: pulumi.Input[str],\n queue_name: Optional[pulumi.Input[str]] = None,\n resource_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"endpoint_type\", 'StorageQueue')\n if queue_name is not None:\n pulumi.set(__self__, \"queue_name\", queue_name)\n if resource_id is not None:\n pulumi.set(__self__, \"resource_id\", resource_id)","def create_queue(self):\n queue_name = self.generate_name()\n try:\n queue = self.sqs.create_queue(QueueName=queue_name)\n except Exception as e:\n raise RuntimeError('SQS could create queue: %s' % e)\n self.queue_name, self.queue = queue_name, queue","def priority_queue():\n from src.priorityq import PriorityQueue\n priority_queue = PriorityQueue()\n return priority_queue","def declare(self):\n self.channel.queue_declare(queue='files_to_database')","def declare_queue(self, queue_name):\n if queue_name not in self.queues:\n self.emit_before(\"declare_queue\", queue_name)\n self.queues.add(queue_name)\n self.emit_after(\"declare_queue\", queue_name)\n\n delayed_name = dq_name(queue_name)\n self.delay_queues.add(delayed_name)\n self.emit_after(\"declare_delay_queue\", delayed_name)","def __init__(self): \n self.queue = []","def __init__(self, name=None, queue_mode=None, description=None, redrive_policy=None, max_consume_count=None, retention_hours=None):\n \n \n\n self._name = None\n self._queue_mode = None\n self._description = None\n self._redrive_policy = None\n self._max_consume_count = None\n self._retention_hours = None\n self.discriminator = None\n\n self.name = name\n if queue_mode is not None:\n self.queue_mode = queue_mode\n if description is not None:\n self.description = description\n if redrive_policy is not None:\n self.redrive_policy = redrive_policy\n if max_consume_count is not None:\n self.max_consume_count = max_consume_count\n if retention_hours is not None:\n self.retention_hours = retention_hours","def small_queue():\n que = Queue()\n que.enqueue(1)\n que.enqueue(2)\n que.enqueue(3)\n que.enqueue(4)\n que.enqueue(5)\n return que","def declare_queue(self, topic):\n #from trove.rpc.impl_kombu import Connection\n from trove.openstack.common.rpc import create_connection\n with create_connection() as conn:\n consumer = conn.declare_topic_consumer(topic=topic)","def new_dque():\n from dqueue import Dque\n return Dque()","def empty_queue():\n return Queue()","def empty_queue():\n return Queue()","def small_queue():\n queue = Queue()\n queue.enqueue(1)\n queue.enqueue(2)\n queue.enqueue(3)\n queue.enqueue(4)\n return queue","def __init__(self, prod_func, prod_kwargs, prod_use_threads, cons_func, cons_kwargs, cons_use_threads):\n\n self.cons_func = cons_func\n self.cons_kwargs = cons_kwargs\n self.cons_use_threads = cons_use_threads\n\n self.prod_func = prod_func\n self.prod_kwargs = prod_kwargs\n self.prod_use_threads = prod_use_threads\n\n self.queue = Queue()","def support_queue(self, queue_id):\r\n return support_queues.SupportQueue(self, queue_id)","def __init__(__self__,\n resource_name: str,\n args: EndpointServicebusQueueArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def create_queue(self, queue_name='', exclusive=True, queue_size=10,\n message_ttl=60000, overflow_behaviour='drop-head',\n expires=600000):\n args = {\n 'x-max-length': queue_size,\n 'x-overflow': overflow_behaviour,\n 'x-message-ttl': message_ttl,\n 'x-expires': expires\n }\n\n result = self._channel.queue_declare(\n exclusive=exclusive,\n queue=queue_name,\n durable=False,\n auto_delete=True,\n arguments=args)\n queue_name = result.method.queue\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\n queue_name, queue_size, message_ttl))\n return queue_name","def queue(self):\n return self._queue","def queue(self):\n return self._queue","def queue(self):\n return self._queue","def queue(self):\n return self._queue","def __init__(self, queue_id):\n self.queue_id = queue_id\n self.action_type = 'set_queue'","def __init__(self):\n self.queues=[]","def __init__(self, queue_name, **kwargs):\n super(Queue, self).__init__(**kwargs)\n self.value = queue_name","def __init__(self):\n self.data = Queue()","async def get_queue(self, ctx: commands.Context) -> Optional[QueueManager]:\n\n return self.queue[ctx.guild.id]","def get_declared_queues(self):\n return self.queues.copy()","def runQueueEnqueue(self):\n raise NotImplementedError","def support_queue(self, queue_id):\n return support_queues.SupportQueue(self, queue_id)","def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\n durable=durable, arguments=arguments)\n else:\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)","def __init__(self):\n self._queue_items = []"],"string":"[\n \"async def declare(self) -> 'Queue':\\n # we are relying to this in other functions\\n self._channel = await self._backend.channel()\\n self.log.debug(\\\"Channel acquired CHANNEL%i\\\",\\n self._channel.channel_number)\\n\\n if self.exchange:\\n await self.declare_exchange()\\n\\n if self.name is not None:\\n await self.declare_queue()\\n\\n if self.exchange:\\n await self.bind_queue()\\n\\n return self\",\n \"def _queue_create(self, **kwargs):\\n name = self.generate_random_name()\\n return self.clients(\\\"zaqar\\\").queue(name, **kwargs)\",\n \"def new_queue() -> Queue:\\n return multiprocessing.Queue()\",\n \"def get_queue():\\n\\n return multiprocessing.Queue()\",\n \"def _create_queue(self):\\n # Instantiate\\n queue = pbs.queue(verbose=not self.quiet)\\n\\n if self.q == 'ember':\\n # Submitting to Utah ember cluster\\n ppn = 12\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n walltime = self.walltime if int(self.walltime.split(':')[0]) < 72 else '72:00:00'\\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\\n walltime=walltime, ppn=ppn, cpus=cpus, partition='ember', alloc='sdss')\\n elif self.q is not None:\\n # All other self.q values expected for Portsmouth cluster,\\n # sciama. In this case, the number of nodes is queue\\n # dependent, and qos is not set\\n if self.q == 'sciama1.q':\\n ppn = 12\\n elif self.q == 'sciama3.q':\\n ppn = 20\\n else:\\n ppn = 16\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n queue.create(label=self.label, nodes=self.nodes, umask=self.umask,\\n walltime=self.walltime, queue=self.q, ppn=ppn, cpus=cpus)\\n else:\\n # self.q can be None when submitting to both the Portsmouth\\n # and Utah clusters. In this case, the default queue\\n # destination and ppn is correct. qos is also set, but this\\n # should only be used when submitting to Utah.\\n ppn = 16\\n cpus = ppn if self.cpus is None else min(self.cpus, ppn)\\n queue.create(label=self.label, nodes=self.nodes, qos=self.qos, umask=self.umask,\\n walltime=self.walltime, ppn=ppn, cpus=cpus)\\n\\n return queue\",\n \"def setup_queue(self, method_frame):\\n logger.info('Declaring queue %s', self.queue_name)\\n # self._channel.queue_declare(self.on_queue_declareok, queue_name)\\n\\n self._channel.queue_declare(self.on_queue_declareok, exclusive=False, durable=True, queue=self.queue_name)\",\n \"def declare_queue(self):\\n\\n self._channel.queue_declare(queue=self._queue_name, durable=True)\\n print(\\\"Queue declared....\\\")\",\n \"def instantiate_queue(self):\\n serialized_queue = self.cache.get('queue')\\n queue = ast.literal_eval(serialized_queue.decode('utf-8'))\\n return queue\",\n \"def serialize(self):\\n return self.instantiate_queue()\",\n \"def get(queue_name: str, **kwargs) -> Queue:\\n return Queue(queue_name, **kwargs)\",\n \"def setup_queue(self):\\n self.logger.info('declaring queue %s', self.queue)\\n if self.otq:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue, auto_delete=True)\\n else:\\n self._channel.queue_declare(self.on_queue_declareok, self.queue)\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue(self):\\n return self.__queue\",\n \"def _get_queue_kwargs(self):\\n executor = self.cloudify_context['executor']\\n node_instance_id = self.cloudify_context['node_id']\\n\\n if executor == 'auto':\\n # for executor=auto, we'll be a host_agent script if we do have\\n # a host, otherwise CDA\\n client = get_rest_client()\\n node_instance = client.node_instances.get(node_instance_id)\\n if node_instance.host_id:\\n executor = 'host_agent'\\n else:\\n executor = 'central_deployment_agent'\\n\\n if executor == 'host_agent':\\n if self._cloudify_agent is None:\\n self._cloudify_agent, tenant = self._get_agent_settings(\\n node_instance_id=node_instance_id,\\n deployment_id=self.cloudify_context['deployment_id'],\\n tenant=None)\\n return (self._cloudify_agent['queue'],\\n self._cloudify_agent['name'],\\n tenant,\\n self._cloudify_agent['rest_host'])\\n else:\\n return MGMTWORKER_QUEUE, MGMTWORKER_QUEUE, None, \\\\\\n self.workflow_context.rest_host\",\n \"def rpc(self) -> global___Rpc:\",\n \"def queue():\\n\\n # Check if the client is connected.\\n if not session.is_connected():\\n return dict(ok=False, error=\\\"Client not connected\\\")\\n\\n # Add the operation to the local queue.\\n operation = manager.enqueue(session.get_sid())\\n\\n # If the local list of operation to solve is empty the Mmanager.enqueue`\\n # method returns `None`, ence if the value of `operation` is `None`\\n # the client should stop.\\n return dict(ok=True, operation=operation, halt=operation is None)\",\n \"def queue(self, sid):\\r\\n return queues.Queue(self, sid)\",\n \"def __init__(self):\\n self.dequeue = DeQueue()\",\n \"def queue(self, name):\\n # First create a queue\\n queue = self.inbound_channel.declare_queue(name)\\n\\n # Create the registry for the queue\\n registry = Registry(self, queue)\\n\\n # Prepare consuming queue with registry\\n self.inbound_channel.consume(queue=queue, callback=registry)\\n\\n # Then, return the Registry object.\\n return registry\",\n \"def queue_maker(queue, bucket_name):\\n scraper = key_scraper.KaleidoscopeKeyScraper(\\n bucket_name=bucket_name,\\n queue=queue,\\n )\\n scraper.add_keys_to_queue()\\n\\n return None\",\n \"def __init__(self):\\n queue = collections.deque()\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def _get_queue_type(self):\\n return self.__queue_type\",\n \"def __init__(self):\\n self.queue = Queue()\",\n \"def get_queue(self):\\n if self.queue is not None:\\n return self.queue\\n state = self.get_state()\\n self.queue = state.get_queue()\\n # print(\\\"IQ\\\", self.queue)\\n return self.queue\",\n \"def create_queue(self, queue_name, visibility_timeout=None):\\r\\n params = {'QueueName': queue_name}\\r\\n if visibility_timeout:\\r\\n params['DefaultVisibilityTimeout'] = '%d' % (visibility_timeout,)\\r\\n return self.get_object('CreateQueue', params, Queue)\",\n \"def __init__(self, queue: CityOverheadTimeQueue, name: int):\\n super().__init__()\\n self._name = name\\n self._queue = queue\\n self.data_incoming = True\",\n \"def __init__(self):\\n self._queue = defaultdict(\\n OrderedDict\\n ) # type: Dict[OrderedDict[TelnetCommand, ExpectedResponse]]\",\n \"def __init__(self):\\n Queue.__init__(self)\",\n \"def declare_queue(self, c, queue_name):\\n return self._management_req(\\n c, 'PUT', ['queues', urlquote(c.vhost, safe=''), queue_name],\\n {\\\"auto_delete\\\": False, \\\"durable\\\": False, \\\"arguments\\\": {}})\",\n \"def create(cls, process_name=\\\"ReceiverSender\\\",queue_send=None, queue_receive=None): #pensar em mais parametros\\n cls.instance = cls(process_name, queue_send, queue_receive)\\n return cls.instance\",\n \"def queue(self):\\n if self._queue is None:\\n qstr = self.query_queue(user=self._user)\\n self._queue = self.parse_queue_str(qstr, keys=self.QSTAT_KEYS)\\n\\n return self._queue\",\n \"def __init__(self):\\n self.queue = []\",\n \"def __init__(self):\\n self.queue = []\",\n \"def __init__(self):\\n self.queue = []\",\n \"def __init__(self):\\n self.queue = []\",\n \"def __init__(self):\\n self.queue = []\",\n \"def queue(self):\\n if self._queue is None:\\n qstr = self.query_queue(user=self._user)\\n self._queue = self.parse_queue_str(qstr)\\n\\n return self._queue\",\n \"def __init__(self):\\n self.queue = []\\n self.queue.append(Queue())\\n self.queue.append(Queue())\\n self.tag = 0 # using to record which queue contain the data\",\n \"def __init__(self) -> None:\\n self._queue = []\",\n \"def on_exchange_declareok(self, _unused_frame):\\n self._channel_ctrl.queue_declare(\\n '',\\n exclusive=True,\\n auto_delete=True,\\n callback=self.on_queue_declareok\\n )\",\n \"def enqueue(self, name):\\n pass\",\n \"def __init__(self):\\r\\n self.queue = []\",\n \"def __init__(self):\\r\\n self.queue = []\",\n \"def __init__(self):\\n self.queue = deque()\",\n \"def __init__(self):\\n self.queue = deque()\",\n \"def __init__(self):\\n self.queue = deque()\",\n \"def __init__(self):\\n self.queue = deque()\",\n \"def get_cmds_queue(self):\\n\\t\\t\\n\\t\\treturn Queue()\",\n \"def _push_queue(self):\\n\\n self.add_cons_vars(self._var_queue, sloppy=self.sloppy)\\n self.add_cons_vars(self._cons_queue, sloppy = self.sloppy)\\n\\n if len(self._var_queue) > 0:\\n self.regenerate_variables()\\n if len(self._cons_queue) > 0:\\n self.regenerate_constraints()\\n\\n self._var_queue = list()\\n self._cons_queue = list()\",\n \"def get_queue(self):\\n return self.queue\",\n \"def get_queue(self):\\n return self.queue\",\n \"def __init__(__self__, *,\\n endpoint_type: pulumi.Input[str],\\n queue_name: Optional[pulumi.Input[str]] = None,\\n resource_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"endpoint_type\\\", 'StorageQueue')\\n if queue_name is not None:\\n pulumi.set(__self__, \\\"queue_name\\\", queue_name)\\n if resource_id is not None:\\n pulumi.set(__self__, \\\"resource_id\\\", resource_id)\",\n \"def create_queue(self):\\n queue_name = self.generate_name()\\n try:\\n queue = self.sqs.create_queue(QueueName=queue_name)\\n except Exception as e:\\n raise RuntimeError('SQS could create queue: %s' % e)\\n self.queue_name, self.queue = queue_name, queue\",\n \"def priority_queue():\\n from src.priorityq import PriorityQueue\\n priority_queue = PriorityQueue()\\n return priority_queue\",\n \"def declare(self):\\n self.channel.queue_declare(queue='files_to_database')\",\n \"def declare_queue(self, queue_name):\\n if queue_name not in self.queues:\\n self.emit_before(\\\"declare_queue\\\", queue_name)\\n self.queues.add(queue_name)\\n self.emit_after(\\\"declare_queue\\\", queue_name)\\n\\n delayed_name = dq_name(queue_name)\\n self.delay_queues.add(delayed_name)\\n self.emit_after(\\\"declare_delay_queue\\\", delayed_name)\",\n \"def __init__(self): \\n self.queue = []\",\n \"def __init__(self, name=None, queue_mode=None, description=None, redrive_policy=None, max_consume_count=None, retention_hours=None):\\n \\n \\n\\n self._name = None\\n self._queue_mode = None\\n self._description = None\\n self._redrive_policy = None\\n self._max_consume_count = None\\n self._retention_hours = None\\n self.discriminator = None\\n\\n self.name = name\\n if queue_mode is not None:\\n self.queue_mode = queue_mode\\n if description is not None:\\n self.description = description\\n if redrive_policy is not None:\\n self.redrive_policy = redrive_policy\\n if max_consume_count is not None:\\n self.max_consume_count = max_consume_count\\n if retention_hours is not None:\\n self.retention_hours = retention_hours\",\n \"def small_queue():\\n que = Queue()\\n que.enqueue(1)\\n que.enqueue(2)\\n que.enqueue(3)\\n que.enqueue(4)\\n que.enqueue(5)\\n return que\",\n \"def declare_queue(self, topic):\\n #from trove.rpc.impl_kombu import Connection\\n from trove.openstack.common.rpc import create_connection\\n with create_connection() as conn:\\n consumer = conn.declare_topic_consumer(topic=topic)\",\n \"def new_dque():\\n from dqueue import Dque\\n return Dque()\",\n \"def empty_queue():\\n return Queue()\",\n \"def empty_queue():\\n return Queue()\",\n \"def small_queue():\\n queue = Queue()\\n queue.enqueue(1)\\n queue.enqueue(2)\\n queue.enqueue(3)\\n queue.enqueue(4)\\n return queue\",\n \"def __init__(self, prod_func, prod_kwargs, prod_use_threads, cons_func, cons_kwargs, cons_use_threads):\\n\\n self.cons_func = cons_func\\n self.cons_kwargs = cons_kwargs\\n self.cons_use_threads = cons_use_threads\\n\\n self.prod_func = prod_func\\n self.prod_kwargs = prod_kwargs\\n self.prod_use_threads = prod_use_threads\\n\\n self.queue = Queue()\",\n \"def support_queue(self, queue_id):\\r\\n return support_queues.SupportQueue(self, queue_id)\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: EndpointServicebusQueueArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def create_queue(self, queue_name='', exclusive=True, queue_size=10,\\n message_ttl=60000, overflow_behaviour='drop-head',\\n expires=600000):\\n args = {\\n 'x-max-length': queue_size,\\n 'x-overflow': overflow_behaviour,\\n 'x-message-ttl': message_ttl,\\n 'x-expires': expires\\n }\\n\\n result = self._channel.queue_declare(\\n exclusive=exclusive,\\n queue=queue_name,\\n durable=False,\\n auto_delete=True,\\n arguments=args)\\n queue_name = result.method.queue\\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\\n queue_name, queue_size, message_ttl))\\n return queue_name\",\n \"def queue(self):\\n return self._queue\",\n \"def queue(self):\\n return self._queue\",\n \"def queue(self):\\n return self._queue\",\n \"def queue(self):\\n return self._queue\",\n \"def __init__(self, queue_id):\\n self.queue_id = queue_id\\n self.action_type = 'set_queue'\",\n \"def __init__(self):\\n self.queues=[]\",\n \"def __init__(self, queue_name, **kwargs):\\n super(Queue, self).__init__(**kwargs)\\n self.value = queue_name\",\n \"def __init__(self):\\n self.data = Queue()\",\n \"async def get_queue(self, ctx: commands.Context) -> Optional[QueueManager]:\\n\\n return self.queue[ctx.guild.id]\",\n \"def get_declared_queues(self):\\n return self.queues.copy()\",\n \"def runQueueEnqueue(self):\\n raise NotImplementedError\",\n \"def support_queue(self, queue_id):\\n return support_queues.SupportQueue(self, queue_id)\",\n \"def add_queue(self, queue_name, alt_exchange_name=None, passive=False, durable=False, arguments = None):\\n amqp_session = self.__broker.getAmqpSession()\\n if arguments == None:\\n arguments = {}\\n if alt_exchange_name:\\n amqp_session.queue_declare(queue_name, alternate_exchange=alt_exchange_name, passive=passive,\\n durable=durable, arguments=arguments)\\n else:\\n amqp_session.queue_declare(queue_name, passive=passive, durable=durable, arguments=arguments)\",\n \"def __init__(self):\\n self._queue_items = []\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67236507","0.66197556","0.64929247","0.6260047","0.6201118","0.5973525","0.59200746","0.5897509","0.5897299","0.5760605","0.5723684","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.57159436","0.5614134","0.54763395","0.5475687","0.5466806","0.54567546","0.54539645","0.5449487","0.5447363","0.54427516","0.54427516","0.54427516","0.54427516","0.54427516","0.54427516","0.54372114","0.5421477","0.54126847","0.53924114","0.53888667","0.53845066","0.5377061","0.53515404","0.53239435","0.52984357","0.52984357","0.52984357","0.52984357","0.52984357","0.5290666","0.528814","0.5281799","0.5280216","0.5270601","0.5269328","0.5269328","0.52654153","0.52654153","0.52654153","0.52654153","0.5255168","0.525203","0.5245557","0.5245557","0.52416545","0.5224702","0.52172655","0.5205985","0.52050054","0.5202657","0.5202203","0.51994115","0.51943207","0.5173098","0.5163042","0.5163042","0.5161347","0.51569897","0.51315653","0.5130359","0.512529","0.51229906","0.51229906","0.51229906","0.51229906","0.51220256","0.51208204","0.51183784","0.51015836","0.5079033","0.50676954","0.5067681","0.5054107","0.5053655","0.5032451"],"string":"[\n \"0.67236507\",\n \"0.66197556\",\n \"0.64929247\",\n \"0.6260047\",\n \"0.6201118\",\n \"0.5973525\",\n \"0.59200746\",\n \"0.5897509\",\n \"0.5897299\",\n \"0.5760605\",\n \"0.5723684\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.57159436\",\n \"0.5614134\",\n \"0.54763395\",\n \"0.5475687\",\n \"0.5466806\",\n \"0.54567546\",\n \"0.54539645\",\n \"0.5449487\",\n \"0.5447363\",\n \"0.54427516\",\n \"0.54427516\",\n \"0.54427516\",\n \"0.54427516\",\n \"0.54427516\",\n \"0.54427516\",\n \"0.54372114\",\n \"0.5421477\",\n \"0.54126847\",\n \"0.53924114\",\n \"0.53888667\",\n \"0.53845066\",\n \"0.5377061\",\n \"0.53515404\",\n \"0.53239435\",\n \"0.52984357\",\n \"0.52984357\",\n \"0.52984357\",\n \"0.52984357\",\n \"0.52984357\",\n \"0.5290666\",\n \"0.528814\",\n \"0.5281799\",\n \"0.5280216\",\n \"0.5270601\",\n \"0.5269328\",\n \"0.5269328\",\n \"0.52654153\",\n \"0.52654153\",\n \"0.52654153\",\n \"0.52654153\",\n \"0.5255168\",\n \"0.525203\",\n \"0.5245557\",\n \"0.5245557\",\n \"0.52416545\",\n \"0.5224702\",\n \"0.52172655\",\n \"0.5205985\",\n \"0.52050054\",\n \"0.5202657\",\n \"0.5202203\",\n \"0.51994115\",\n \"0.51943207\",\n \"0.5173098\",\n \"0.5163042\",\n \"0.5163042\",\n \"0.5161347\",\n \"0.51569897\",\n \"0.51315653\",\n \"0.5130359\",\n \"0.512529\",\n \"0.51229906\",\n \"0.51229906\",\n \"0.51229906\",\n \"0.51229906\",\n \"0.51220256\",\n \"0.51208204\",\n \"0.51183784\",\n \"0.51015836\",\n \"0.5079033\",\n \"0.50676954\",\n \"0.5067681\",\n \"0.5054107\",\n \"0.5053655\",\n \"0.5032451\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6956101"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93089,"cells":{"query":{"kind":"string","value":"Called when exiting the consumer iterator"},"document":{"kind":"string","value":"def __exit__(self, exc_type, exc_val, exc_tb):\n self.queue.channel.rpc(self._basic_cancel)\n self.queue.consuming = False"},"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 end_iter(self):\n raise NotImplementedError","def __exit__(self, *_) -> None:\n self.__cursor.top.pop()","def end(self) -> None:","def end(self):\n ...","def _finish(self):\n if self.consumer:\n self.consumer.unregisterProducer()\n self.consumer = None\n\n if not self.deferred.called:\n self.deferred.callback(None)","def my_consumer(q):\n while True:\n data = q.get()\n print('data found to be processed: {}'.format(data))\n processed = data * 2\n print(processed)\n\n if data is sentinel:\n break","def __exit__(self, exc_type, exc_value, traceback):\n self._reader.__exit__(exc_type, exc_value, traceback)","def end(self):\n pass","def end(self):\n pass","def end(self):\n pass","def finalize(self):\n self.isOver = True\n self.currentIteration = -1","def stop():\n raise StopIteration","def _consumer(self) -> None:\n while (data := self._q.get()) is not None:\n write_data(data, self.writer)\n self._q.task_done()\n else:\n logging.info(\"None received. Queue consumed.\")\n self._q.task_done()\n return","def __exit__(self, *_) -> None:\n for component in self.__traverse_backward():\n component.__exit__(*_)","def _finished(self) -> None:","def end(self):\n log.info(\"Shard reader for %s stoping\", self.shard_id)","def __exit__(self, exc_type, exc_value, traceback):\n\t\tself.pop()","def finished(self):","def end(self) -> None:\n return","def finish(self) -> None:\n self.__exit__(None, None, None)","def finish(self) -> None:","def finish(self) -> None:","def finish(self):","def finish(self):","def main_thread_exit(self):\n ...","def finish(self):\n pass","def finish(self):\n pass","def close(self):\n try:\n self.throw(GeneratorExit)\n except (GeneratorExit, StopIteration):\n pass\n else:\n raise RuntimeError(\"generator ignored GeneratorExit\")","def finished(self):\n pass","def finish():","def finish():","def finish():","def finish():","def endRead(self):\n self.readerCount -= 1\n if self.readerCount == 0:\n self.okToWrite.notify()\n self.okToWrite.release()\n self.okToRead.release()","def __exit__(self, *args, **kwargs):\n\n pass","def consume(iterator):\n deque(iterator, maxlen=0)","def cleanup(self):\n self.result.extend(self.endTagList)","def remove(self):\n self.iterator.remove()","def __exit__(self, *args):\n pass","def finished(self):\r\n raise NotImplementedError","def finalize(self):","def finalize(self):","def Finish(self):\n pass","def stop(self):\n self.logger.debug(\"Stopping request consumer\")\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))","def __exit__(self, ex_type, ex_value, traceback):\n self._distrubtor.stop()","def finalize(self, interrupted=False):\n pass","def __exit__(self, *args):\n self.stop()","def endDocument(self):\n self.return_q.put(self.obj_depth[-1])","def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.events.pause.set()\n\n while True:\n self.events.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n partition, message = self.queue.get(block=True, timeout=1)\n except queue.Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[partition] = message.offset + 1\n self.events.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.events.start.clear()","def handle_termination(self):\n pass","def registration_iteration_ended(self):\n pass","def finished(self):\n raise NotImplementedError()","def finalise(self):","def __exit__(self, exc_type, exc_val, exc_tb):\r\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n pass","def nextIter(self):\n\t\tpass","def __exit__(self, exc_type, exc_value, traceback):\r\n pass","def __exit__(self, exc_type, exc_value, traceback):\r\n pass","def __exit__(self, exc_type, exc_value, traceback):\r\n pass","def __exit__(self, type, value, traceback):\n self.pop()","def finish():\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n\n self.quit()","def __exit__(self, *exc):\n return self._lock.__exit__(*exc)","def __exit__(self, type_, value, traceback):\n self.close()","def __exit__(self, exc_type, exc_val, exc_tb) -> None:\n self.stop()","def interrupted(self):\n self.end()","def __exit__(self, type, value, traceback):\n self.close()","def __exit__(self, type, value, traceback):\n self.close()","def __exit__(self, type, value, traceback):\n self.close()","def __exit__(self, type, value, traceback):\n self.close()","def __exit__(self, type, value, traceback):\n self.close()","def __exit__(self, exc_type, exc_value, traceback):\n pass","def __exit__(self, exc_type, exc_value, exc_traceback):\n self.end = self()\n print(str(self))","def exit(self):\n self.current.exit()","def _end(self):\n\n self.logger.msg1(\"Done\")","def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.pause.set()\n\n while True:\n self.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n meta, message = self.queue.get(block=True, timeout=1)\n except Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[meta.partition] = message.offset + 1\n self.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.start.clear()","def __exit__(self, exc_type, exc_value, traceback):\n self.close()","def __exit__(self, exc_type, exc_value, traceback):\n self.close()","def __exit__(self, exc_type, exc_value, traceback):\n self.close()","def __exit__(self, exc_type, exc_value, traceback):\n self.close()","def stopProducing(self):\n pass","def end(self):\n self._log.debug('doing ..')\n super().end()\n\n self._log.debug('done')","def iterator(self):\n yield","def close():\n # self.consumer.close()\n # close file handler\n LOGGER.info(\"consumer is closed!!\")","def finalize(self):\n return","def finalize(self):\r\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n self.close()","def _get_outputs(self, iterator, pre_dispatch):\n dispatch_thread_id = threading.get_ident()\n detach_generator_exit = False\n try:\n self._start(iterator, pre_dispatch)\n # first yield returns None, for internal use only. This ensures\n # that we enter the try/except block and start dispatching the\n # tasks.\n yield\n\n with self._backend.retrieval_context():\n yield from self._retrieve()\n\n except GeneratorExit:\n # The generator has been garbage collected before being fully\n # consumed. This aborts the remaining tasks if possible and warn\n # the user if necessary.\n self._exception = True\n\n # In some interpreters such as PyPy, GeneratorExit can be raised in\n # a different thread than the one used to start the dispatch of the\n # parallel tasks. This can lead to hang when a thread attempts to\n # join itself. As workaround, we detach the execution of the\n # aborting code to a dedicated thread. We then need to make sure\n # the rest of the function does not call `_terminate_and_reset`\n # in finally.\n if dispatch_thread_id != threading.get_ident():\n if not IS_PYPY:\n warnings.warn(\n \"A generator produced by joblib.Parallel has been \"\n \"gc'ed in an unexpected thread. This behavior should \"\n \"not cause major -issues but to make sure, please \"\n \"report this warning and your use case at \"\n \"https://github.com/joblib/joblib/issues so it can \"\n \"be investigated.\"\n )\n\n detach_generator_exit = True\n _parallel = self\n\n class _GeneratorExitThread(threading.Thread):\n def run(self):\n _parallel._abort()\n if _parallel.return_generator:\n _parallel._warn_exit_early()\n _parallel._terminate_and_reset()\n\n _GeneratorExitThread(\n name=\"GeneratorExitThread\"\n ).start()\n return\n\n # Otherwise, we are in the thread that started the dispatch: we can\n # safely abort the execution and warn the user.\n self._abort()\n if self.return_generator:\n self._warn_exit_early()\n\n raise\n\n # Note: we catch any BaseException instead of just Exception instances\n # to also include KeyboardInterrupt\n except BaseException:\n self._exception = True\n self._abort()\n raise\n finally:\n # Store the unconsumed tasks and terminate the workers if necessary\n _remaining_outputs = ([] if self._exception else self._jobs)\n self._jobs = collections.deque()\n self._running = False\n if not detach_generator_exit:\n self._terminate_and_reset()\n\n while len(_remaining_outputs) > 0:\n batched_results = _remaining_outputs.popleft()\n batched_results = batched_results.get_result(self.timeout)\n for result in batched_results:\n yield result","def __exit__(self, type, value, traceback):\n\n self.close()","def __exit__(self):\n self._stop_all()","def __exit__(self, exc_type, exc_val, exc_tb):\n if self.event_loop:\n self.event_loop.stop()","def consume(self):\n self._stored = self._stored - 1","def process_data_callback(self, res):\n self.current_in_progress -= 1","def finalize(self):\n self.stop()","def consumer(self):\n while not self.stop_operation:\n try:\n candidate = self.q.get(timeout = 0.25)\n self.q.task_done()\n try:\n with tempfile.NamedTemporaryFile('w', suffix = '.smt2') as tmp:\n tmp.write(parser.render_smtlib(candidate.exprs))\n tmp.flush()\n res = checker.execute(options.args().cmd, tmp.name)\n except FileNotFoundError:\n logging.info('Removing the temporary file failed.')\n if checker.matches_reference(res):\n with self.result_lock:\n if self.result is None:\n self.stop_operation = True\n self.result = candidate\n except queue.Empty:\n if self.finished_generation:\n break\n self.__empty_queue()","def reached_end_of_stream(self):\n pass","def Finish(self):\n\t\n self.queue.join()","def exit(self):\n pass","def __exit__(self, *_exc):\r\n self.release()","def done(self):"],"string":"[\n \"def end_iter(self):\\n raise NotImplementedError\",\n \"def __exit__(self, *_) -> None:\\n self.__cursor.top.pop()\",\n \"def end(self) -> None:\",\n \"def end(self):\\n ...\",\n \"def _finish(self):\\n if self.consumer:\\n self.consumer.unregisterProducer()\\n self.consumer = None\\n\\n if not self.deferred.called:\\n self.deferred.callback(None)\",\n \"def my_consumer(q):\\n while True:\\n data = q.get()\\n print('data found to be processed: {}'.format(data))\\n processed = data * 2\\n print(processed)\\n\\n if data is sentinel:\\n break\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n self._reader.__exit__(exc_type, exc_value, traceback)\",\n \"def end(self):\\n pass\",\n \"def end(self):\\n pass\",\n \"def end(self):\\n pass\",\n \"def finalize(self):\\n self.isOver = True\\n self.currentIteration = -1\",\n \"def stop():\\n raise StopIteration\",\n \"def _consumer(self) -> None:\\n while (data := self._q.get()) is not None:\\n write_data(data, self.writer)\\n self._q.task_done()\\n else:\\n logging.info(\\\"None received. Queue consumed.\\\")\\n self._q.task_done()\\n return\",\n \"def __exit__(self, *_) -> None:\\n for component in self.__traverse_backward():\\n component.__exit__(*_)\",\n \"def _finished(self) -> None:\",\n \"def end(self):\\n log.info(\\\"Shard reader for %s stoping\\\", self.shard_id)\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n\\t\\tself.pop()\",\n \"def finished(self):\",\n \"def end(self) -> None:\\n return\",\n \"def finish(self) -> None:\\n self.__exit__(None, None, None)\",\n \"def finish(self) -> None:\",\n \"def finish(self) -> None:\",\n \"def finish(self):\",\n \"def finish(self):\",\n \"def main_thread_exit(self):\\n ...\",\n \"def finish(self):\\n pass\",\n \"def finish(self):\\n pass\",\n \"def close(self):\\n try:\\n self.throw(GeneratorExit)\\n except (GeneratorExit, StopIteration):\\n pass\\n else:\\n raise RuntimeError(\\\"generator ignored GeneratorExit\\\")\",\n \"def finished(self):\\n pass\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def endRead(self):\\n self.readerCount -= 1\\n if self.readerCount == 0:\\n self.okToWrite.notify()\\n self.okToWrite.release()\\n self.okToRead.release()\",\n \"def __exit__(self, *args, **kwargs):\\n\\n pass\",\n \"def consume(iterator):\\n deque(iterator, maxlen=0)\",\n \"def cleanup(self):\\n self.result.extend(self.endTagList)\",\n \"def remove(self):\\n self.iterator.remove()\",\n \"def __exit__(self, *args):\\n pass\",\n \"def finished(self):\\r\\n raise NotImplementedError\",\n \"def finalize(self):\",\n \"def finalize(self):\",\n \"def Finish(self):\\n pass\",\n \"def stop(self):\\n self.logger.debug(\\\"Stopping request consumer\\\")\\n self._connection.ioloop.add_callback_threadsafe(partial(self._connection.close))\",\n \"def __exit__(self, ex_type, ex_value, traceback):\\n self._distrubtor.stop()\",\n \"def finalize(self, interrupted=False):\\n pass\",\n \"def __exit__(self, *args):\\n self.stop()\",\n \"def endDocument(self):\\n self.return_q.put(self.obj_depth[-1])\",\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.events.pause.set()\\n\\n while True:\\n self.events.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n partition, message = self.queue.get(block=True, timeout=1)\\n except queue.Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[partition] = message.offset + 1\\n self.events.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.events.start.clear()\",\n \"def handle_termination(self):\\n pass\",\n \"def registration_iteration_ended(self):\\n pass\",\n \"def finished(self):\\n raise NotImplementedError()\",\n \"def finalise(self):\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\r\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n pass\",\n \"def nextIter(self):\\n\\t\\tpass\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\r\\n pass\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\r\\n pass\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\r\\n pass\",\n \"def __exit__(self, type, value, traceback):\\n self.pop()\",\n \"def finish():\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n\\n self.quit()\",\n \"def __exit__(self, *exc):\\n return self._lock.__exit__(*exc)\",\n \"def __exit__(self, type_, value, traceback):\\n self.close()\",\n \"def __exit__(self, exc_type, exc_val, exc_tb) -> None:\\n self.stop()\",\n \"def interrupted(self):\\n self.end()\",\n \"def __exit__(self, type, value, traceback):\\n self.close()\",\n \"def __exit__(self, type, value, traceback):\\n self.close()\",\n \"def __exit__(self, type, value, traceback):\\n self.close()\",\n \"def __exit__(self, type, value, traceback):\\n self.close()\",\n \"def __exit__(self, type, value, traceback):\\n self.close()\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n pass\",\n \"def __exit__(self, exc_type, exc_value, exc_traceback):\\n self.end = self()\\n print(str(self))\",\n \"def exit(self):\\n self.current.exit()\",\n \"def _end(self):\\n\\n self.logger.msg1(\\\"Done\\\")\",\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.pause.set()\\n\\n while True:\\n self.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n meta, message = self.queue.get(block=True, timeout=1)\\n except Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[meta.partition] = message.offset + 1\\n self.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.start.clear()\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n self.close()\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n self.close()\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n self.close()\",\n \"def __exit__(self, exc_type, exc_value, traceback):\\n self.close()\",\n \"def stopProducing(self):\\n pass\",\n \"def end(self):\\n self._log.debug('doing ..')\\n super().end()\\n\\n self._log.debug('done')\",\n \"def iterator(self):\\n yield\",\n \"def close():\\n # self.consumer.close()\\n # close file handler\\n LOGGER.info(\\\"consumer is closed!!\\\")\",\n \"def finalize(self):\\n return\",\n \"def finalize(self):\\r\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.close()\",\n \"def _get_outputs(self, iterator, pre_dispatch):\\n dispatch_thread_id = threading.get_ident()\\n detach_generator_exit = False\\n try:\\n self._start(iterator, pre_dispatch)\\n # first yield returns None, for internal use only. This ensures\\n # that we enter the try/except block and start dispatching the\\n # tasks.\\n yield\\n\\n with self._backend.retrieval_context():\\n yield from self._retrieve()\\n\\n except GeneratorExit:\\n # The generator has been garbage collected before being fully\\n # consumed. This aborts the remaining tasks if possible and warn\\n # the user if necessary.\\n self._exception = True\\n\\n # In some interpreters such as PyPy, GeneratorExit can be raised in\\n # a different thread than the one used to start the dispatch of the\\n # parallel tasks. This can lead to hang when a thread attempts to\\n # join itself. As workaround, we detach the execution of the\\n # aborting code to a dedicated thread. We then need to make sure\\n # the rest of the function does not call `_terminate_and_reset`\\n # in finally.\\n if dispatch_thread_id != threading.get_ident():\\n if not IS_PYPY:\\n warnings.warn(\\n \\\"A generator produced by joblib.Parallel has been \\\"\\n \\\"gc'ed in an unexpected thread. This behavior should \\\"\\n \\\"not cause major -issues but to make sure, please \\\"\\n \\\"report this warning and your use case at \\\"\\n \\\"https://github.com/joblib/joblib/issues so it can \\\"\\n \\\"be investigated.\\\"\\n )\\n\\n detach_generator_exit = True\\n _parallel = self\\n\\n class _GeneratorExitThread(threading.Thread):\\n def run(self):\\n _parallel._abort()\\n if _parallel.return_generator:\\n _parallel._warn_exit_early()\\n _parallel._terminate_and_reset()\\n\\n _GeneratorExitThread(\\n name=\\\"GeneratorExitThread\\\"\\n ).start()\\n return\\n\\n # Otherwise, we are in the thread that started the dispatch: we can\\n # safely abort the execution and warn the user.\\n self._abort()\\n if self.return_generator:\\n self._warn_exit_early()\\n\\n raise\\n\\n # Note: we catch any BaseException instead of just Exception instances\\n # to also include KeyboardInterrupt\\n except BaseException:\\n self._exception = True\\n self._abort()\\n raise\\n finally:\\n # Store the unconsumed tasks and terminate the workers if necessary\\n _remaining_outputs = ([] if self._exception else self._jobs)\\n self._jobs = collections.deque()\\n self._running = False\\n if not detach_generator_exit:\\n self._terminate_and_reset()\\n\\n while len(_remaining_outputs) > 0:\\n batched_results = _remaining_outputs.popleft()\\n batched_results = batched_results.get_result(self.timeout)\\n for result in batched_results:\\n yield result\",\n \"def __exit__(self, type, value, traceback):\\n\\n self.close()\",\n \"def __exit__(self):\\n self._stop_all()\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n if self.event_loop:\\n self.event_loop.stop()\",\n \"def consume(self):\\n self._stored = self._stored - 1\",\n \"def process_data_callback(self, res):\\n self.current_in_progress -= 1\",\n \"def finalize(self):\\n self.stop()\",\n \"def consumer(self):\\n while not self.stop_operation:\\n try:\\n candidate = self.q.get(timeout = 0.25)\\n self.q.task_done()\\n try:\\n with tempfile.NamedTemporaryFile('w', suffix = '.smt2') as tmp:\\n tmp.write(parser.render_smtlib(candidate.exprs))\\n tmp.flush()\\n res = checker.execute(options.args().cmd, tmp.name)\\n except FileNotFoundError:\\n logging.info('Removing the temporary file failed.')\\n if checker.matches_reference(res):\\n with self.result_lock:\\n if self.result is None:\\n self.stop_operation = True\\n self.result = candidate\\n except queue.Empty:\\n if self.finished_generation:\\n break\\n self.__empty_queue()\",\n \"def reached_end_of_stream(self):\\n pass\",\n \"def Finish(self):\\n\\t\\n self.queue.join()\",\n \"def exit(self):\\n pass\",\n \"def __exit__(self, *_exc):\\r\\n self.release()\",\n \"def done(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71276844","0.64325505","0.6416023","0.63907677","0.6312287","0.6300143","0.6271744","0.6212424","0.6212424","0.6212424","0.6162212","0.61339283","0.6100264","0.6042454","0.6037785","0.6007991","0.6005878","0.6001117","0.5998288","0.59981495","0.5981218","0.5981218","0.59706485","0.59706485","0.59615767","0.59170204","0.59170204","0.59128726","0.5901254","0.5866167","0.5866167","0.5866167","0.5866167","0.5844152","0.58383","0.58347726","0.58233654","0.582291","0.5816635","0.5761568","0.5761508","0.5761508","0.574209","0.57242036","0.5723021","0.5714753","0.57071865","0.5704138","0.57027984","0.5698297","0.5691654","0.5691466","0.56824607","0.5681358","0.56641346","0.5654347","0.56491464","0.56491464","0.56491464","0.5644265","0.56442505","0.56353295","0.5628439","0.5626983","0.5626487","0.56255","0.5620836","0.5620836","0.5620836","0.5620836","0.5620836","0.5615603","0.5615176","0.5613756","0.56083167","0.56037545","0.56023484","0.56023484","0.56023484","0.56023484","0.5595258","0.5593643","0.5591869","0.5589438","0.55881","0.5578981","0.5576987","0.55761063","0.55669385","0.5566439","0.55568653","0.5556603","0.5555681","0.55524224","0.5551739","0.55446315","0.55411077","0.5537802","0.5536464","0.5533164"],"string":"[\n \"0.71276844\",\n \"0.64325505\",\n \"0.6416023\",\n \"0.63907677\",\n \"0.6312287\",\n \"0.6300143\",\n \"0.6271744\",\n \"0.6212424\",\n \"0.6212424\",\n \"0.6212424\",\n \"0.6162212\",\n \"0.61339283\",\n \"0.6100264\",\n \"0.6042454\",\n \"0.6037785\",\n \"0.6007991\",\n \"0.6005878\",\n \"0.6001117\",\n \"0.5998288\",\n \"0.59981495\",\n \"0.5981218\",\n \"0.5981218\",\n \"0.59706485\",\n \"0.59706485\",\n \"0.59615767\",\n \"0.59170204\",\n \"0.59170204\",\n \"0.59128726\",\n \"0.5901254\",\n \"0.5866167\",\n \"0.5866167\",\n \"0.5866167\",\n \"0.5866167\",\n \"0.5844152\",\n \"0.58383\",\n \"0.58347726\",\n \"0.58233654\",\n \"0.582291\",\n \"0.5816635\",\n \"0.5761568\",\n \"0.5761508\",\n \"0.5761508\",\n \"0.574209\",\n \"0.57242036\",\n \"0.5723021\",\n \"0.5714753\",\n \"0.57071865\",\n \"0.5704138\",\n \"0.57027984\",\n \"0.5698297\",\n \"0.5691654\",\n \"0.5691466\",\n \"0.56824607\",\n \"0.5681358\",\n \"0.56641346\",\n \"0.5654347\",\n \"0.56491464\",\n \"0.56491464\",\n \"0.56491464\",\n \"0.5644265\",\n \"0.56442505\",\n \"0.56353295\",\n \"0.5628439\",\n \"0.5626983\",\n \"0.5626487\",\n \"0.56255\",\n \"0.5620836\",\n \"0.5620836\",\n \"0.5620836\",\n \"0.5620836\",\n \"0.5620836\",\n \"0.5615603\",\n \"0.5615176\",\n \"0.5613756\",\n \"0.56083167\",\n \"0.56037545\",\n \"0.56023484\",\n \"0.56023484\",\n \"0.56023484\",\n \"0.56023484\",\n \"0.5595258\",\n \"0.5593643\",\n \"0.5591869\",\n \"0.5589438\",\n \"0.55881\",\n \"0.5578981\",\n \"0.5576987\",\n \"0.55761063\",\n \"0.55669385\",\n \"0.5566439\",\n \"0.55568653\",\n \"0.5556603\",\n \"0.5555681\",\n \"0.55524224\",\n \"0.5551739\",\n \"0.55446315\",\n \"0.55411077\",\n \"0.5537802\",\n \"0.5536464\",\n \"0.5533164\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6188529"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":93090,"cells":{"query":{"kind":"string","value":"Retrieve the nest message from the queue as an iterator, blocking until the next message is available."},"document":{"kind":"string","value":"def next_message(self):\n while self.queue.consuming:\n yield self.queue.channel._consume_message()"},"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 next(self): # wait for 5 minutes after sending message\n if self.queue:\n messages = self.queue.get_messages(1,visibility_timeout=self.visibility_timeout)\n if messages:\n for m in messages:\n return m\n raise StopIteration","def read(self):\n if not self._consuming:\n yield from self._begin_consuming()\n return (yield from self._message_queue.get())","def __iter__(self):\n while True:\n m = self.recv(timeout=1.0)\n if m is not None:\n yield m\n logger.debug(\"done iterating over bus messages\")","def retrieve(self) -> Iterator[SQSMessage]:\n while True:\n try:\n sqs = SQSClientFactory(boto3).from_env()\n\n res = sqs.receive_message(\n QueueUrl=self.queue_url,\n WaitTimeSeconds=3,\n MaxNumberOfMessages=10,\n )\n\n messages = res.get(\"Messages\", [])\n if not messages:\n LOGGER.info(\"queue was empty\")\n\n s3_events = [SQSMessage(msg) for msg in messages]\n for sqs_message in s3_events:\n yield sqs_message\n\n sqs.delete_message(\n QueueUrl=self.queue_url,\n ReceiptHandle=sqs_message.receipt_handle,\n )\n\n except Exception as e:\n LOGGER.error(traceback.format_exc())\n time.sleep(2)","def next(self):\n try:\n return self.queue.get()\n except Empty:\n raise StopIteration","def __iter__(self):\n return iter(self.queue)","def next(self):\n return self.read_message()","def _consume(self):\n # HACK: run_in_executor is used as a workaround to use boto\n # inside a coroutine. This is a stopgap solution that should be\n # replaced once boto has support for asyncio or aiobotocore has\n # a stable release.\n loop = asyncio.get_event_loop()\n receive_message = partial(\n self.client.receive_message,\n QueueUrl=self.app.settings['SQS_INBOUND_QUEUE_URL'],\n AttributeNames=self.app.settings['SQS_ATTRIBUTE_NAMES'],\n MessageAttributeNames=self.app.settings['SQS_MESSAGE_ATTRIBUTES'],\n MaxNumberOfMessages=self.app.settings['SQS_MESSAGE_BATCH_SIZE'],\n VisibilityTimeout=self.app.settings['SQS_VISIBILITY_TIMEOUT'],\n WaitTimeSeconds=self.app.settings['SQS_WAIT_TIME'],\n )\n while True:\n future = loop.run_in_executor(None, receive_message)\n messages = yield from future\n for message in messages.get('Messages', []):\n message['Body'] = json.loads(message['Body'])\n yield from self._message_queue.put(message)","def queue_peek(queue_instance, timeout=60):\r\n while True:\r\n try:\r\n yield queue_instance.get(timeout=timeout)\r\n except Empty:\r\n break","def queue_iter(queue: Queue) -> Generator[T, None, None]:\n while True:\n val = queue.get()\n yield val","def process(self, message=None):\n\n while self.running:\n message = self.channel.basic.get(self.queue)\n if message:\n content = message.body\n\n # log message\n if self.debug:\n self.log(\"Recieved: \" + str(content))\n\n # send to child nodes\n self.scatter(Message(**self.parse(content)))\n else:\n # yield to other greenlet\n # self.tick()\n self.sleep(1)","def wait_for_messages(self):\n msg = self.inbox.get()\n return msg","def next_message(self) -> Optional[MessageQueueItem]:\n if self._message_queue:\n return self._message_queue[0]\n return None","def pop_next_message(self):\n messages = self._msq_queue.receive_messages(\n AttributeNames=['All'],\n MessageAttributeNames=['All'],\n MaxNumberOfMessages=1,\n VisibilityTimeout=self._vis_timeout,\n WaitTimeSeconds=self._wait_time,\n )\n if not messages:\n raise NoMessagesAfterLongPollingAvailableException(\"No Messages receivable from Queue\")\n elif len(messages) == 1:\n return dict_for_message(messages[0])\n else:\n raise Exception(\"Received more Messages than intended\")","def sqs_messages(queue: str) -> Generator[Dict[str, Any], None, None]:\n\n while True:\n response = get_client(\"sqs\").receive_message(QueueUrl=queue)\n if \"Messages\" not in response:\n break\n msg = json.loads(response[\"Messages\"][0][\"Body\"])\n records = json.loads(msg[\"Message\"])\n retd = {}\n retd[\"key\"] = records[\"Records\"][0][\"s3\"][\"object\"][\"key\"]\n retd[\"bucket\"] = records[\"Records\"][0][\"s3\"][\"bucket\"][\"name\"]\n retd[\"ReceiptHandle\"] = response[\"Messages\"][0][\"ReceiptHandle\"]\n yield retd","def get_from_queue(self):\n while not self.receive_queue.empty():\n cmd, kwargs = bcp.decode_command_string(\n self.receive_queue.get(False))\n self._process_command(cmd, **kwargs)","def receive(self):\n while True:\n if self.pending_request:\n request = self.unpack(self.pending_request)\n self.pending_request = None\n else: \n request = self.unpack(self.mh.receive_message())\n if request:\n yield request\n else: break","def __iter__(self):\n root = self.root()\n queue = Queue()\n queue.enqueue(root)\n return self._breadth_first(queue)","def _generator(self):\n\t\twhile(1):\n\t\t\ttry:\n\t\t\t\tm = self.messages.pop(0) # pop the first Flash2Message in the list\n\t\t\t\tyield m\n\t\t\texcept IndexError:\n\t\t\t\traise StopIteration","def _dispatch_messages(self):\n while True:\n select_obj = (yield)\n if select_obj == self._message_queue.selobj:\n msg = self._message_queue.get_nowait()\n if msg is not None:\n msg_type = msg.get('type', None)\n if msg_type is not None:\n msg_handler = self._message_handlers.get(msg_type, None)\n if msg_handler is not None:\n msg_handler(msg['data'])","def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.pause.set()\n\n while True:\n self.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n meta, message = self.queue.get(block=True, timeout=1)\n except Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[meta.partition] = message.offset + 1\n self.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.start.clear()","def get(self) -> Optional[Message]:\n self._recv()\n if not self.inq:\n return None\n return self.inq.popleft()","def get_messages_from_queue(fx):\n\n for msg in queue.receive_messages():\n fx(msg)","def next_ele(self):\n\t\ttry:\n\t\t\tret = self._queue.get(block = True, timeout=0.5)\n\t\t\tself._queue.task_done()\n\t\t\treturn ret\n\t\texcept queue.Empty:\n\t\t\tif not self.is_running():\n\t\t\t\traise\n\t\t\telse:\n\t\t\t\treturn None","async def get_iter(self) -> AsyncIterator[Data]:\n async with self.read_mutex:\n if self.get_in_progress:\n # This should be guarded against with the read_mutex,\n # exception is only here as a failsafe\n raise ServerError(\n \"Called get_iter on Websocket frame assembler \"\n \"while asynchronous get is already in progress.\"\n )\n self.get_in_progress = True\n\n chunks = self.chunks\n self.chunks = []\n self.chunks_queue = asyncio.Queue()\n\n # Sending None in chunk_queue supersedes setting message_complete\n # when switching to \"streaming\". If message is already complete\n # when the switch happens, put() didn't send None, so we have to.\n if self.message_complete.is_set():\n await self.chunks_queue.put(None)\n\n # Locking with get_in_progress ensures only one task can get here\n for c in chunks:\n yield c\n while True:\n chunk = await self.chunks_queue.get()\n if chunk is None:\n break\n yield chunk\n\n # Unpause the transport, if its paused\n if self.paused:\n self.protocol.resume_frames()\n self.paused = False\n if not self.get_in_progress: # no cov\n # This should be guarded against with the read_mutex,\n # exception is here as a failsafe\n raise ServerError(\n \"State of Websocket frame assembler was modified while an \"\n \"asynchronous get was in progress.\"\n )\n self.get_in_progress = False\n if not self.message_complete.is_set(): # no cov\n # This should be guarded against with the read_mutex,\n # exception is here as a failsafe\n raise ServerError(\n \"Websocket frame assembler chunks queue ended before \"\n \"message was complete.\"\n )\n self.message_complete.clear()\n if self.message_fetched.is_set(): # no cov\n # This should be guarded against with the read_mutex,\n # and get_in_progress check, this exception is\n # here as a failsafe\n raise ServerError(\n \"Websocket get_iter() found a message when state was \"\n \"already fetched.\"\n )\n\n self.message_fetched.set()\n # this should already be empty, but set it here for safety\n self.chunks = []\n self.chunks_queue = None","def next_ele(self):\n\t\ttry:\n\t\t\tret = self._queue.get(block=True, timeout=0.5)\n\t\t\tself._queue.task_done()\n\t\t\treturn ret\n\t\texcept queue.Empty:\n\t\t\tif not self.isAlive():\n\t\t\t\traise\n\t\t\telse:\n\t\t\t\treturn None","def get_generator(self):\n while self._is_running():\n yield self._queue.get()","def get_generator(self):\n while self._is_running():\n yield self._queue.get()","def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.events.pause.set()\n\n while True:\n self.events.start.set()\n try:\n # We will block for a small while so that the consumers get\n # a chance to run and put some messages in the queue\n # TODO: This is a hack and will make the consumer block for\n # at least one second. Need to find a better way of doing this\n partition, message = self.queue.get(block=True, timeout=1)\n except queue.Empty:\n break\n\n # Count, check and commit messages if necessary\n self.offsets[partition] = message.offset + 1\n self.events.start.clear()\n self.count_since_commit += 1\n self._auto_commit()\n yield message\n\n self.events.start.clear()","async def read(self) -> None:\n make_non_blocking(self.stream)\n\n while not self.stream.closed:\n message = None\n try:\n message = await self.read_one()\n\n if not message:\n await self.sleep()\n continue\n else:\n self.wake()\n\n IOLoop.current().add_callback(self.queue.put_nowait, message)\n except Exception as e: # pragma: no cover\n self.log.exception(\n \"%s couldn't enqueue message: %s (%s)\", self, message, e\n )\n await self.sleep()","def get(self):\n while self.is_running():\n try:\n inputs = self.queue.get(block=True, timeout=5).get()\n if self.is_running():\n self.queue.task_done()\n if inputs is not None:\n yield inputs\n except queue.Empty:\n pass\n except Exception as e: # pylint: disable=broad-except\n self.stop()\n raise e","def peek(self):\n if self._peeked is None:\n handle = self._next_handle()\n if handle is not None:\n self._peeked = GRIBMessage(handle)\n return self._peeked","def Peek(self):\n\t\tif not self.first:\n\t\t\traise ValueError(\"Empty Queue\")\n\t\treturn self.first.data","def get_msg(self, block=True, timeout=None):\n return self.in_queue.get(block, timeout)","def get_msg(self, block=True, timeout=None):\n return self.in_queue.get(block, timeout)","def run(self):\n while self._msg_queue:\n actor, msg = self._msg_queue.popleft()\n try:\n actor.send(msg)\n except StopIteration:\n pass","def _iterate_messages(self):\n if not self.targets:\n raise sex.SullyRuntimeError(\"No targets specified in session\")\n\n if not self.edges_from(self.root.id):\n raise sex.SullyRuntimeError(\"No requests specified in session\")\n\n self._reset_fuzz_state()\n\n for x in self._iterate_messages_recursive(this_node=self.root, path=[]):\n yield x","def consume(self, block=True, timeout=0):\n\n # We need to repeat this step, because there may be messages\n # that expired, and we expect this method to always return message.\n while True:\n # Retrieve last message ID\n if block:\n # Blocking query, wait until message is available.\n message_id = self.pyrps.redis.blpop(self.pyrps._ns_queue(self.queue, self.consumer_id), timeout)\n\n # blpop returns tuple(key, value), we need only value.\n message_id = message_id[1]\n else:\n # Non blocking query. Return if there is no message in queue.\n message_id = self.pyrps.redis.lpop(self.pyrps._ns_queue(self.queue, self.consumer_id))\n\n # If there is no message in the queue, return None.\n if message_id is None:\n return None\n\n # Retrieve the message\n message = self.pyrps.redis.get(self.pyrps._ns_message(self.queue, message_id))\n \n # If message still exists (no TTL has been reached), return it.\n if message is not None:\n return message","def _recv(self) -> None:\n if not self.connected or now() < self.next_poll:\n return\n self.next_poll += self.poll_interval\n data = []\n while True:\n try:\n data.append(self.endpoint.recv(BUFFSIZE))\n except BlockingIOError:\n break\n if data:\n stream = io.BytesIO(b\"\".join(data))\n while True:\n try:\n info = pickle.load(stream)\n msg = Message(*info)\n self.inq.append(msg)\n except EOFError:\n break","def wait_for_message(self, tag, timeout=None):\n def done_check():\n if self._message_queue.setdefault(tag,[]):\n value=heapq.heappop(self._message_queue[tag])[-1]\n return True,value\n return False,None\n return self._wait_in_process_loop(done_check,timeout=timeout)","def receive_message(self):\n return self.receive_message_queue.get()","def __iter__(self):\n if not self.is_alive() and not self.finished.is_set():\n self.start()\n # if there is an item in the queue, yield it, otherwise wait\n while not self.finished.is_set():\n try:\n yield self.queue.get(True, 0.25)\n except queue.Empty:\n pass\n except KeyboardInterrupt:\n self.stop()","def get_nowait(self):\r\n if self.empty():\r\n raise QueueEmpty\r\n item = self._get()\r\n self._wakeup_next(self._putters)\r\n return item","def server_message_iterator(self) -> Iterator[ServerMessage]:\n while not self._is_closed():\n with self._cv:\n self._cv.wait_for(\n lambda: self._status\n in [Status.CLOSED, Status.SERVER_MESSAGE_AVAILABLE]\n )\n\n self._raise_if_closed()\n\n server_message = self._server_message # Read\n self._server_message = None # Reset\n\n # Transition before yielding as after the yield the execution of this\n # function is paused and will resume when next is called again.\n # Also release condition variable by exiting the context\n self._transition(Status.AWAITING_CLIENT_MESSAGE)\n\n if server_message is None:\n raise Exception(\"Server message can not be None\")\n\n yield server_message","def __next__(self):\n return self.read_message()","def get(self, block=True, timeout=None):\n if block:\n message = self.redis.blpop(self.queue, timeout=timeout)\n else:\n message = self.redis.lpop(self.queue)\n\n parsed_message = self.parse(message[1])\n return parsed_message","async def Read(self) -> Optional[Message]:\n return await self._read_queue.Get()","def get_msgs(self):\n msgs = []\n while True:\n try:\n msgs.append(self.get_msg(block=False))\n except Empty:\n break\n return msgs","def get_msgs(self):\n msgs = []\n while True:\n try:\n msgs.append(self.get_msg(block=False))\n except Empty:\n break\n return msgs","def peek(self):\r\n return self.queue[0]","def peek(self):\r\n return self.queue[0]","def iterate_msgs(stream):\n while True:\n item = None\n buf = bytearray()\n stall_timer = None\n\n while True:\n # read bytes until item boundary reached\n buf += stream.read(1)\n if not buf:\n # check for stall (i.e. no data for 90 seconds)\n if not stall_timer:\n stall_timer = time.time()\n elif time.time() - stall_timer > TwitterAPI.STREAMING_TIMEOUT:\n raise TwitterConnectionError(\"Twitter stream stalled\")\n elif stall_timer:\n stall_timer = None\n if buf[-2:] == b\"\\r\\n\":\n item = buf[0:-2]\n if item.isdigit():\n # use byte size to read next item\n nbytes = int(item)\n item = None\n item = stream.read(nbytes)\n yield item\n else:\n yield b\"\" # keepalive\n break","def sender_iter(self):\n while 1:\n yield self.send_next()","def tagged_messages(client: SlackClient, user_id: str):\n while True:\n for data in client.rtm_read():\n if data.get(\"type\") == \"message\" and user_id in data.get(\"text\"):\n yield data\n\n time.sleep(RTM_READ_DELAY)","def recv_messages(self):\n while True:\n b = unwrap_read(self.sock.recv(4096))\n msgs = self.parser.feed(b)\n if msgs:\n for msg in msgs:\n self.router.incoming(msg)\n return","def get(self):\n with self.__lock:\n while True:\n try:\n job = self.__queue.get(False)\n self.__lock.notify_all()\n return job\n except Queue.Empty:\n self.__lock.wait()","def get_next_message(self):\n newest_available_offset = self.broker.get_last_offset(self.topic_name)\n if self.offset <= newest_available_offset:\n msg = self.broker.read_message(self.topic_name, self.offset)\n self.offset += 1\n return msg","def results_q_get(self):\n while not self.stopped():\n try:\n return self.results_queue.get(timeout=self.heart_beat)\n except queue.Empty:\n pass\n raise StopIteration()","def _next_message(self):\n msg = yield self._read_message()\n message = self._slack_to_chat(msg)\n\n raise gen.Return(message)","def get_message_from_queue(self):\n message = None, None\n\n try:\n message = self.queue.get(block=True, timeout=3)\n except Empty:\n self.fail(msg='Queue get() failed empty')\n\n return message","def consume(self, **kwargs):\n kwargs.setdefault('block', True)\n try:\n while True:\n msg = self.get(**kwargs)\n if msg is None:\n break\n yield msg\n except KeyboardInterrupt: # pragma: no cover\n print()\n return","def readline(self):\n try:\n return self.queue.get_nowait()\n except Empty:\n return None","def getAllFromQueue(self, Q):\n try:\n while True:\n yield Q.get_nowait()\n except Queue.Empty:\n raise StopIteration","def start_operation(self):\n # Prevent message streak (for debugging purposes)\n msg_streak = 0\n max_streak = 10\n msg = Message.connect\n while True:\n # If completed return\n if self.completed:\n break\n\n # Read from the queue\n obj = self.msg_q.get()\n edge_id = obj['sender']\n message = obj['message']\n pl = obj['pl']\n\n # Wake process first before processing any message\n if self.state == State.sleep:\n self.wakeup()\n\n # Find the edge index which sent this message\n for _in in range(self.num_neighbors):\n edge = self.edges[_in]\n if edge.get_id() == edge_id:\n edge_index = _in\n break\n\n # Check message streak\n if message == msg:\n msg_streak += 1\n else:\n msg = message\n msg_streak = 0\n if msg_streak >= max_streak:\n msg_streak = 0\n time.sleep(0.01)\n\n # Process each message accordingly\n print_level(\n 'info', self.node_id,\n 'Received from edge ' + str(edge_index) + ' ' + str(message))\n if message == Message.connect:\n self.process_connect(edge_index, pl[0])\n elif message == Message.initiate:\n self.process_initiate(edge_index, pl[0], pl[1], pl[2])\n elif message == Message.test:\n self.process_test(edge_index, pl[0], pl[1])\n elif message == Message.accept:\n self.process_accept(edge_index)\n elif message == Message.reject:\n self.process_reject(edge_index)\n elif message == Message.report:\n self.process_report(edge_index, pl[0])\n elif message == Message.changeroot:\n self.process_changeroot()\n elif message == Message.halt:\n self.__complete()\n\n # Return the number of messages sent by this node\n print_level('info', self.node_id, 'Completed for this node')\n return self.num_messages","def peek(self):\n return self.the_queue[0]","def get_msg(self, my_queue):\n self.channel.basic_qos(prefetch_count=COUNT)\n try:\n for method_frame, properties, body in self.channel.consume(my_queue):\n self.channel.basic_ack(method_frame.delivery_tag)\n return body\n except pika.exceptions, err_msg:\n log.error(err_msg)\n return False","def _pull_batch_from_queue(self):\n rollout = self.explorer.queue.get( timeout = 600.0 )\n while not rollout.terminal:\n try: \n rollout.extend( self.explorer.queue.get_nowait() )\n except queue.Empty:\n break\n print(rollout.size())\n return rollout","def peek(self):\n return self.queue[0]","def pop_message(self, queue_name):\r\n messages = self.pop_messages(queue_name, count=1)\r\n if messages['item_count'] > 0:\r\n return messages['items'][0]\r\n else:\r\n return None","def read(self):\n # return next frame in the queue\n return self.Q.get()","def get_all_from_queue(Q):\n try:\n while True:\n yield Q.get_nowait()\n except queue.Empty:\n raise StopIteration","def _messages_list(self, queue):\n\n return queue.messages()","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","async def poll_message(self):\n message_cache = self.message_cache\n if (message_cache is not None) and message_cache:\n return message_cache.pop()\n \n if not self.message_request_more:\n return\n \n message_cache = await self.client.message_get_chunk(self.source_channel, after = self.last_message_id)\n self.message_cache = message_cache\n \n if len(message_cache) < 100:\n self.message_request_more = False\n \n if message_cache:\n return message_cache.pop()","def get_all_from_queue(Q):\n try:\n while True:\n yield Q.get_nowait()\n except Queue.Empty:\n raise StopIteration","def receive():\n now = time.time()\n end = now + MAX_DURATION\n tmp = None\n # Heroku doesn't notify when clients disconnect so we have to impose a\n # maximum connection duration.\n while now < end:\n if not tmp:\n tmp = AsyncResult()\n BROADCAST_QUEUE.put(tmp)\n try:\n yield tmp.get(timeout=KEEP_ALIVE_DELAY)\n tmp = None\n except Timeout:\n yield ''\n now = time.time()","def __iter__(self):\n while True:\n if self.stop:\n return\n for item in self.get_next_batch():\n yield item","def receive(self):\n try:\n itr = 0\n while self.connected:\n \n r, w, e = select.select(\n (self.sock, ), (), (), 10.0)\n \n if r:\n message = json.loads(self.recv())\n \n if 'fetch' in message:\n self.fetch_id = message['fetch']\n \n if 'failure' in message:\n raise InvalidFetch(message['failure'])\n \n if 'records' in message:\n if 'added' in message['records']:\n num = len(message['records']['added'])\n else:\n num = len(message['records'])\n \n logger.debug('Query returned %s records.', num)\n if self.max_recv:\n itr += 1\n \n if 'end' in message:\n logger.debug('Received end message: %s' % message['end'])\n yield message\n break\n \n yield message\n if self.max_recv and self.max_recv <= itr:\n break \n\n except (Exception, KeyboardInterrupt, SystemExit, FetchAborted) as e:\n logger.info('Caught exception in receive: %s -> %s', type(e), str(e))\n if isinstance(e, (SystemExit, InvalidFetch)):\n # propagate SystemExit, InvalidFetch\n raise\n finally:\n if self.connected:\n if self.fetch_id:\n self.send(json.dumps({'abort': self.fetch_id}))\n self.close()\n \n if self.thread:\n self.event.set()\n while self.thread.isAlive():\n self.event.wait(1)\n \n logger.info('Closed web socket connection normally.')","def _get_message(self, block=True, timeout=0.1, get_partition_info=None,\n update_offset=True):\n if self.got_error:\n raise self.error\n try:\n meta, message = self.queue.get(timeout=timeout)\n\n if update_offset:\n # Update partition offset\n self.offsets[meta.partition] = message.offset + 1\n\n # Count, check and commit messages if necessary\n self.count_since_commit += 1\n self._auto_commit()\n\n if get_partition_info is None:\n get_partition_info = self.partition_info\n if get_partition_info:\n return meta, message\n else:\n return message\n except Empty:\n return None","def work(self):\n while True:\n message = self.get()\n self.handle(message)","def _iterate_messages_recursive(self, this_node, path):\n # step through every edge from the current node.\n for edge in self.edges_from(this_node.id):\n # keep track of the path as we walk through it\n # we keep track of edges as opposed to nodes because if there is more then one path through a set of\n # given nodes we don't want any ambiguity.\n path.append(edge)\n\n message_path = \"->\".join([self.nodes[e.dst].name for e in path])\n logging.debug('checking: {0}'.format(message_path))\n\n self.fuzz_node = self.nodes[path[-1].dst]\n self.total_mutant_index += 1\n yield (path,)\n\n for x in self._iterate_messages_recursive(self.fuzz_node, path):\n yield x\n\n # finished with the last node on the path, pop it off the path stack.\n if path:\n path.pop()","def ecute(self):\n msg = self.up_queue_recv_socket.recv()\n result, e = self.up_queue.get()\n if e is not None:\n raise e\n return result","def consume(iterator):\n deque(iterator, maxlen=0)","def getfrom(self,room,last_check=None):\n\n log.debug('getting: %s %s' % (room,last_check))\n log.debug('messages: %s' % (0 if not room in self.rooms\n else len(self.rooms.get(room))))\n \n # see if we have any messages for that room\n last_check = int(last_check) or 0\n\n # go through the message's in the room\n if room in self.rooms and len(self.rooms.get(room)) > 0:\n # messages are ordered newest to oldest\n for msg in self.rooms.get(room):\n if msg.timestamp > last_check:\n yield msg.body","def dequeue_message(self) -> MessageQueueItem:\n return heapq.heappop(self._message_queue)","def asyncRead(self, timeout=5000, staging=False, attr=None):\n if self.isConnected():\n turns = 0\n while True:\n turns += 1\n if turns > 100:\n logging.debug(\"Timeout on read after 100 iterations\")\n return None\n\n result = True\n logging.debug(\"MessageOutput size: %i\", len(self.messageOutput))\n if len(self.messageOutput) == 0 and not self.containsAttr(attr):\n logging.debug(\"Waiting for new message.\")\n if not staging:\n # spy = QSignalSpy(self._stopWaiting)\n spy = QSignalSpy(self.bufferReady)\n else:\n spy = QSignalSpy(self._staging)\n result = spy.wait(timeout) # Asynchronous wait, Timeout 5s\n\n if result and not self._hasError:\n self.lock.acquire()\n if len(self.messageOutput) == 0:\n self.lock.release()\n logging.debug(\"Race condition triggered. Wait for next message.\")\n continue\n found = False\n result = self.messageOutput[0]\n if attr is not None:\n for msg in self.messageOutput:\n if attr[0] in msg:\n if attr[1] == msg[attr[0]]:\n found = True\n result = msg\n break\n if found or attr is None:\n del self.messageOutput[self.messageOutput.index(result)]\n logging.debug(\"MessageOutput size: %i\", len(self.messageOutput))\n self.lock.release()\n\n if \"error\" not in result:\n result[\"error\"] = []\n if \"status\" not in result:\n result[\"status\"] = True\n\n return result\n else:\n logging.debug(\"Message not found. Release of lock.\")\n if attr is not None:\n logging.debug(\"Miss '%s' with value '%s'\", str(attr[0]), str(attr[1]))\n self.lock.release()\n self.bufferReady.emit()\n qApp.processEvents()\n else:\n logging.debug(\"Nothing to read.\")\n break\n else:\n logging.debug(\"Not connected. Did not read.\")\n return None","def dispatchMessageLoop(self, tree):\n self.fill(\"for (const auto& \")\n self.dispatch(tree.target)\n self.write(\" : \")\n # if simple message iterator\n if isinstance(tree.iter, ast.Name):\n if not tree.iter.id == self._input_message_var:\n self.RaiseError(t, f\"Message input loop requires use of '{self._input_message_var}' as iterator.\")\n # write with prefix\n self.write(f\"FLAMEGPU->{self._input_message_var}\")\n # if it is a call then handle the different cases\n elif isinstance(tree.iter, ast.Call):\n self.dispatchMessageIteratorCall(tree.iter)\n #otherwise not supported\n else :\n self.RaiseError(tree, f\"Message input loop iterator in unsupported format\")\n self.write(\")\")\n self._message_iterator_var = tree.target.id\n self.enter()\n self.dispatch(tree.body)\n self.leave()\n self._message_iterator_var = None","def popMsg(self):\n\n if not self.queue:\n return []\n returned_msgs = []\n for msg, delay in self.queue:\n delay -= 1\n if delay < 1:\n returned_msgs.append(msg)\n else:\n self.pushMsg(msg, delay)\n self.queue = []\n return returned_msgs","def dequeue(self):\n return self._queue.dequeue()","def __iter__(self):\n return iter([self.format_message(record) for record in self._messages])","def get(self):\r\n try:\r\n # get with block=False returns an item if one\r\n # is immediately available, else raises the Empty exception\r\n return self._queue.get(block=False)\r\n except queue.Empty:\r\n return self._create_connection()","def get_messages(self, max_messages):\n raw = self.redis_client.lrange(self.message_list, 0, max_messages)\n messages = (m for m in raw if m != b\"null\")\n messages = (m.decode(\"utf-8\") for m in messages)\n yield from map(json.loads, messages)","def blocking_read_elem(self):\n _, read_str = self.redis_client.blpop(self.buffer_name)\n return self.deserialize_elem(read_str)","def use_queue():\n q = queue.Queue()\n for i in range(10):\n q.put_nowait(i)\n while q.qsize() > 0:\n element = q.get_nowait()\n sys.stdout.write(\"poping out from queue: {0}\\n\".format(element))","def pop_message(self):\n app_process = sqlite3.connect('app_process::memory:', check_same_thread=False)\n app_process_cursor = app_process.cursor()\n app_process_cursor.execute(\"SELECT * FROM message_queue WHERE tstamp==(:first)\", {\"first\":self.mq_first}) \n item = app_process_cursor.fetchone()\n if item == None:\n return\n app_process_cursor.execute(\"DELETE FROM message_queue WHERE tstamp==(:first)\", {\"first\":self.mq_first})\n self.mq_first = item[4] #now sets first to next item pointed to\n app_process.commit()\n app_process.close()\n return item","def next(self):\n nxt = self.readentry()\n if nxt is None:\n raise StopIteration\n return nxt","def wait_message(self):\n if self._state != states['open']:\n return False\n if len(self._read_queue) > 0:\n return True\n\n assert self._read_waiter is None or self._read_waiter.cancelled(), \\\n \"You may only use one wait_message() per connection.\"\n\n self._read_waiter = asyncio.Future(loop=self._loop)\n yield from self._read_waiter\n return self.wait_message()","def yield_messages(self, *, mailbox=DEFAULT_MAILBOX):\n with imaplib.IMAP4_SSL(\n host=self.host, port=self.port,\n ssl_context=ssl.create_default_context()) as ic:\n logger.debug(f'Logging in as {self.user}')\n restype, _ = ic.login(user=self.user, password=self.password)\n check_restype(restype, f'failed to LOGIN as {self.user}')\n\n logger.debug(f'Selecting mailbox {mailbox}')\n restype, _ = ic.select(mailbox=mailbox)\n check_restype(restype, f'failed to SELECT mailbox {mailbox}')\n\n # First, query for *all* message UIDs in the selected mailbox.\n # Interpret the response as a list of integers.\n logger.debug('Getting UID list')\n restype, [uids] = ic.uid('SEARCH', 'ALL')\n check_restype(restype, 'failed to execute SEARCH')\n uids = [*map(int, filter(None, uids.split(b' ')))]\n\n # In the event that the mailbox is empty, there will be no UIDs and\n # nothing more to do.\n if not uids:\n logger.debug('No messages in this mailbox')\n raise NoMessages\n\n # Fetch a range of message headers, from the smallest UID to the\n # largest UID. Build a structure that links each UID to the `Date`\n # header on the message it refers to.\n message_set = f'{min(uids)}:{max(uids)}'\n logger.debug(f'Fetching headers in UID range {message_set}')\n restype, resdata = ic.uid('FETCH', message_set, '(BODY.PEEK[HEADER])')\n check_restype(restype, f'failed to execute FETCH UIDs {message_set} (peek)')\n uids_dated = self.date_uid_map(data=resdata)\n\n # Iterate over all UIDs in date order, oldest to newest.\n for _, uid in sorted(uids_dated, key=itemgetter(0)):\n # Fetch the full message content, wrap it in an IMAPMessage and\n # yield it to the caller.\n logger.debug(f'Fetching message UID {int(uid)}')\n restype, resdata = ic.uid('FETCH', uid, '(RFC822)')\n check_restype(restype, f'failed to execute FETCH UID {int(uid)} (full)')\n\n yield IMAPMessage(data=resdata, imap_connection=ic, uid=uid)","def q_get(self):\n while not self.stopped():\n try:\n return self.in_q.get(timeout=self.heart_beat)\n except queue.Empty:\n pass","def next(self):\n if self.pointer > len(self.queue) - 1:\n self.pointer = 0\n raise StopIteration\n val = self.queue[self.pointer]\n self.pointer += 1\n return val"],"string":"[\n \"def next(self): # wait for 5 minutes after sending message\\n if self.queue:\\n messages = self.queue.get_messages(1,visibility_timeout=self.visibility_timeout)\\n if messages:\\n for m in messages:\\n return m\\n raise StopIteration\",\n \"def read(self):\\n if not self._consuming:\\n yield from self._begin_consuming()\\n return (yield from self._message_queue.get())\",\n \"def __iter__(self):\\n while True:\\n m = self.recv(timeout=1.0)\\n if m is not None:\\n yield m\\n logger.debug(\\\"done iterating over bus messages\\\")\",\n \"def retrieve(self) -> Iterator[SQSMessage]:\\n while True:\\n try:\\n sqs = SQSClientFactory(boto3).from_env()\\n\\n res = sqs.receive_message(\\n QueueUrl=self.queue_url,\\n WaitTimeSeconds=3,\\n MaxNumberOfMessages=10,\\n )\\n\\n messages = res.get(\\\"Messages\\\", [])\\n if not messages:\\n LOGGER.info(\\\"queue was empty\\\")\\n\\n s3_events = [SQSMessage(msg) for msg in messages]\\n for sqs_message in s3_events:\\n yield sqs_message\\n\\n sqs.delete_message(\\n QueueUrl=self.queue_url,\\n ReceiptHandle=sqs_message.receipt_handle,\\n )\\n\\n except Exception as e:\\n LOGGER.error(traceback.format_exc())\\n time.sleep(2)\",\n \"def next(self):\\n try:\\n return self.queue.get()\\n except Empty:\\n raise StopIteration\",\n \"def __iter__(self):\\n return iter(self.queue)\",\n \"def next(self):\\n return self.read_message()\",\n \"def _consume(self):\\n # HACK: run_in_executor is used as a workaround to use boto\\n # inside a coroutine. This is a stopgap solution that should be\\n # replaced once boto has support for asyncio or aiobotocore has\\n # a stable release.\\n loop = asyncio.get_event_loop()\\n receive_message = partial(\\n self.client.receive_message,\\n QueueUrl=self.app.settings['SQS_INBOUND_QUEUE_URL'],\\n AttributeNames=self.app.settings['SQS_ATTRIBUTE_NAMES'],\\n MessageAttributeNames=self.app.settings['SQS_MESSAGE_ATTRIBUTES'],\\n MaxNumberOfMessages=self.app.settings['SQS_MESSAGE_BATCH_SIZE'],\\n VisibilityTimeout=self.app.settings['SQS_VISIBILITY_TIMEOUT'],\\n WaitTimeSeconds=self.app.settings['SQS_WAIT_TIME'],\\n )\\n while True:\\n future = loop.run_in_executor(None, receive_message)\\n messages = yield from future\\n for message in messages.get('Messages', []):\\n message['Body'] = json.loads(message['Body'])\\n yield from self._message_queue.put(message)\",\n \"def queue_peek(queue_instance, timeout=60):\\r\\n while True:\\r\\n try:\\r\\n yield queue_instance.get(timeout=timeout)\\r\\n except Empty:\\r\\n break\",\n \"def queue_iter(queue: Queue) -> Generator[T, None, None]:\\n while True:\\n val = queue.get()\\n yield val\",\n \"def process(self, message=None):\\n\\n while self.running:\\n message = self.channel.basic.get(self.queue)\\n if message:\\n content = message.body\\n\\n # log message\\n if self.debug:\\n self.log(\\\"Recieved: \\\" + str(content))\\n\\n # send to child nodes\\n self.scatter(Message(**self.parse(content)))\\n else:\\n # yield to other greenlet\\n # self.tick()\\n self.sleep(1)\",\n \"def wait_for_messages(self):\\n msg = self.inbox.get()\\n return msg\",\n \"def next_message(self) -> Optional[MessageQueueItem]:\\n if self._message_queue:\\n return self._message_queue[0]\\n return None\",\n \"def pop_next_message(self):\\n messages = self._msq_queue.receive_messages(\\n AttributeNames=['All'],\\n MessageAttributeNames=['All'],\\n MaxNumberOfMessages=1,\\n VisibilityTimeout=self._vis_timeout,\\n WaitTimeSeconds=self._wait_time,\\n )\\n if not messages:\\n raise NoMessagesAfterLongPollingAvailableException(\\\"No Messages receivable from Queue\\\")\\n elif len(messages) == 1:\\n return dict_for_message(messages[0])\\n else:\\n raise Exception(\\\"Received more Messages than intended\\\")\",\n \"def sqs_messages(queue: str) -> Generator[Dict[str, Any], None, None]:\\n\\n while True:\\n response = get_client(\\\"sqs\\\").receive_message(QueueUrl=queue)\\n if \\\"Messages\\\" not in response:\\n break\\n msg = json.loads(response[\\\"Messages\\\"][0][\\\"Body\\\"])\\n records = json.loads(msg[\\\"Message\\\"])\\n retd = {}\\n retd[\\\"key\\\"] = records[\\\"Records\\\"][0][\\\"s3\\\"][\\\"object\\\"][\\\"key\\\"]\\n retd[\\\"bucket\\\"] = records[\\\"Records\\\"][0][\\\"s3\\\"][\\\"bucket\\\"][\\\"name\\\"]\\n retd[\\\"ReceiptHandle\\\"] = response[\\\"Messages\\\"][0][\\\"ReceiptHandle\\\"]\\n yield retd\",\n \"def get_from_queue(self):\\n while not self.receive_queue.empty():\\n cmd, kwargs = bcp.decode_command_string(\\n self.receive_queue.get(False))\\n self._process_command(cmd, **kwargs)\",\n \"def receive(self):\\n while True:\\n if self.pending_request:\\n request = self.unpack(self.pending_request)\\n self.pending_request = None\\n else: \\n request = self.unpack(self.mh.receive_message())\\n if request:\\n yield request\\n else: break\",\n \"def __iter__(self):\\n root = self.root()\\n queue = Queue()\\n queue.enqueue(root)\\n return self._breadth_first(queue)\",\n \"def _generator(self):\\n\\t\\twhile(1):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tm = self.messages.pop(0) # pop the first Flash2Message in the list\\n\\t\\t\\t\\tyield m\\n\\t\\t\\texcept IndexError:\\n\\t\\t\\t\\traise StopIteration\",\n \"def _dispatch_messages(self):\\n while True:\\n select_obj = (yield)\\n if select_obj == self._message_queue.selobj:\\n msg = self._message_queue.get_nowait()\\n if msg is not None:\\n msg_type = msg.get('type', None)\\n if msg_type is not None:\\n msg_handler = self._message_handlers.get(msg_type, None)\\n if msg_handler is not None:\\n msg_handler(msg['data'])\",\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.pause.set()\\n\\n while True:\\n self.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n meta, message = self.queue.get(block=True, timeout=1)\\n except Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[meta.partition] = message.offset + 1\\n self.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.start.clear()\",\n \"def get(self) -> Optional[Message]:\\n self._recv()\\n if not self.inq:\\n return None\\n return self.inq.popleft()\",\n \"def get_messages_from_queue(fx):\\n\\n for msg in queue.receive_messages():\\n fx(msg)\",\n \"def next_ele(self):\\n\\t\\ttry:\\n\\t\\t\\tret = self._queue.get(block = True, timeout=0.5)\\n\\t\\t\\tself._queue.task_done()\\n\\t\\t\\treturn ret\\n\\t\\texcept queue.Empty:\\n\\t\\t\\tif not self.is_running():\\n\\t\\t\\t\\traise\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn None\",\n \"async def get_iter(self) -> AsyncIterator[Data]:\\n async with self.read_mutex:\\n if self.get_in_progress:\\n # This should be guarded against with the read_mutex,\\n # exception is only here as a failsafe\\n raise ServerError(\\n \\\"Called get_iter on Websocket frame assembler \\\"\\n \\\"while asynchronous get is already in progress.\\\"\\n )\\n self.get_in_progress = True\\n\\n chunks = self.chunks\\n self.chunks = []\\n self.chunks_queue = asyncio.Queue()\\n\\n # Sending None in chunk_queue supersedes setting message_complete\\n # when switching to \\\"streaming\\\". If message is already complete\\n # when the switch happens, put() didn't send None, so we have to.\\n if self.message_complete.is_set():\\n await self.chunks_queue.put(None)\\n\\n # Locking with get_in_progress ensures only one task can get here\\n for c in chunks:\\n yield c\\n while True:\\n chunk = await self.chunks_queue.get()\\n if chunk is None:\\n break\\n yield chunk\\n\\n # Unpause the transport, if its paused\\n if self.paused:\\n self.protocol.resume_frames()\\n self.paused = False\\n if not self.get_in_progress: # no cov\\n # This should be guarded against with the read_mutex,\\n # exception is here as a failsafe\\n raise ServerError(\\n \\\"State of Websocket frame assembler was modified while an \\\"\\n \\\"asynchronous get was in progress.\\\"\\n )\\n self.get_in_progress = False\\n if not self.message_complete.is_set(): # no cov\\n # This should be guarded against with the read_mutex,\\n # exception is here as a failsafe\\n raise ServerError(\\n \\\"Websocket frame assembler chunks queue ended before \\\"\\n \\\"message was complete.\\\"\\n )\\n self.message_complete.clear()\\n if self.message_fetched.is_set(): # no cov\\n # This should be guarded against with the read_mutex,\\n # and get_in_progress check, this exception is\\n # here as a failsafe\\n raise ServerError(\\n \\\"Websocket get_iter() found a message when state was \\\"\\n \\\"already fetched.\\\"\\n )\\n\\n self.message_fetched.set()\\n # this should already be empty, but set it here for safety\\n self.chunks = []\\n self.chunks_queue = None\",\n \"def next_ele(self):\\n\\t\\ttry:\\n\\t\\t\\tret = self._queue.get(block=True, timeout=0.5)\\n\\t\\t\\tself._queue.task_done()\\n\\t\\t\\treturn ret\\n\\t\\texcept queue.Empty:\\n\\t\\t\\tif not self.isAlive():\\n\\t\\t\\t\\traise\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn None\",\n \"def get_generator(self):\\n while self._is_running():\\n yield self._queue.get()\",\n \"def get_generator(self):\\n while self._is_running():\\n yield self._queue.get()\",\n \"def __iter__(self):\\n # Trigger the consumer procs to start off.\\n # We will iterate till there are no more messages available\\n self.size.value = 0\\n self.events.pause.set()\\n\\n while True:\\n self.events.start.set()\\n try:\\n # We will block for a small while so that the consumers get\\n # a chance to run and put some messages in the queue\\n # TODO: This is a hack and will make the consumer block for\\n # at least one second. Need to find a better way of doing this\\n partition, message = self.queue.get(block=True, timeout=1)\\n except queue.Empty:\\n break\\n\\n # Count, check and commit messages if necessary\\n self.offsets[partition] = message.offset + 1\\n self.events.start.clear()\\n self.count_since_commit += 1\\n self._auto_commit()\\n yield message\\n\\n self.events.start.clear()\",\n \"async def read(self) -> None:\\n make_non_blocking(self.stream)\\n\\n while not self.stream.closed:\\n message = None\\n try:\\n message = await self.read_one()\\n\\n if not message:\\n await self.sleep()\\n continue\\n else:\\n self.wake()\\n\\n IOLoop.current().add_callback(self.queue.put_nowait, message)\\n except Exception as e: # pragma: no cover\\n self.log.exception(\\n \\\"%s couldn't enqueue message: %s (%s)\\\", self, message, e\\n )\\n await self.sleep()\",\n \"def get(self):\\n while self.is_running():\\n try:\\n inputs = self.queue.get(block=True, timeout=5).get()\\n if self.is_running():\\n self.queue.task_done()\\n if inputs is not None:\\n yield inputs\\n except queue.Empty:\\n pass\\n except Exception as e: # pylint: disable=broad-except\\n self.stop()\\n raise e\",\n \"def peek(self):\\n if self._peeked is None:\\n handle = self._next_handle()\\n if handle is not None:\\n self._peeked = GRIBMessage(handle)\\n return self._peeked\",\n \"def Peek(self):\\n\\t\\tif not self.first:\\n\\t\\t\\traise ValueError(\\\"Empty Queue\\\")\\n\\t\\treturn self.first.data\",\n \"def get_msg(self, block=True, timeout=None):\\n return self.in_queue.get(block, timeout)\",\n \"def get_msg(self, block=True, timeout=None):\\n return self.in_queue.get(block, timeout)\",\n \"def run(self):\\n while self._msg_queue:\\n actor, msg = self._msg_queue.popleft()\\n try:\\n actor.send(msg)\\n except StopIteration:\\n pass\",\n \"def _iterate_messages(self):\\n if not self.targets:\\n raise sex.SullyRuntimeError(\\\"No targets specified in session\\\")\\n\\n if not self.edges_from(self.root.id):\\n raise sex.SullyRuntimeError(\\\"No requests specified in session\\\")\\n\\n self._reset_fuzz_state()\\n\\n for x in self._iterate_messages_recursive(this_node=self.root, path=[]):\\n yield x\",\n \"def consume(self, block=True, timeout=0):\\n\\n # We need to repeat this step, because there may be messages\\n # that expired, and we expect this method to always return message.\\n while True:\\n # Retrieve last message ID\\n if block:\\n # Blocking query, wait until message is available.\\n message_id = self.pyrps.redis.blpop(self.pyrps._ns_queue(self.queue, self.consumer_id), timeout)\\n\\n # blpop returns tuple(key, value), we need only value.\\n message_id = message_id[1]\\n else:\\n # Non blocking query. Return if there is no message in queue.\\n message_id = self.pyrps.redis.lpop(self.pyrps._ns_queue(self.queue, self.consumer_id))\\n\\n # If there is no message in the queue, return None.\\n if message_id is None:\\n return None\\n\\n # Retrieve the message\\n message = self.pyrps.redis.get(self.pyrps._ns_message(self.queue, message_id))\\n \\n # If message still exists (no TTL has been reached), return it.\\n if message is not None:\\n return message\",\n \"def _recv(self) -> None:\\n if not self.connected or now() < self.next_poll:\\n return\\n self.next_poll += self.poll_interval\\n data = []\\n while True:\\n try:\\n data.append(self.endpoint.recv(BUFFSIZE))\\n except BlockingIOError:\\n break\\n if data:\\n stream = io.BytesIO(b\\\"\\\".join(data))\\n while True:\\n try:\\n info = pickle.load(stream)\\n msg = Message(*info)\\n self.inq.append(msg)\\n except EOFError:\\n break\",\n \"def wait_for_message(self, tag, timeout=None):\\n def done_check():\\n if self._message_queue.setdefault(tag,[]):\\n value=heapq.heappop(self._message_queue[tag])[-1]\\n return True,value\\n return False,None\\n return self._wait_in_process_loop(done_check,timeout=timeout)\",\n \"def receive_message(self):\\n return self.receive_message_queue.get()\",\n \"def __iter__(self):\\n if not self.is_alive() and not self.finished.is_set():\\n self.start()\\n # if there is an item in the queue, yield it, otherwise wait\\n while not self.finished.is_set():\\n try:\\n yield self.queue.get(True, 0.25)\\n except queue.Empty:\\n pass\\n except KeyboardInterrupt:\\n self.stop()\",\n \"def get_nowait(self):\\r\\n if self.empty():\\r\\n raise QueueEmpty\\r\\n item = self._get()\\r\\n self._wakeup_next(self._putters)\\r\\n return item\",\n \"def server_message_iterator(self) -> Iterator[ServerMessage]:\\n while not self._is_closed():\\n with self._cv:\\n self._cv.wait_for(\\n lambda: self._status\\n in [Status.CLOSED, Status.SERVER_MESSAGE_AVAILABLE]\\n )\\n\\n self._raise_if_closed()\\n\\n server_message = self._server_message # Read\\n self._server_message = None # Reset\\n\\n # Transition before yielding as after the yield the execution of this\\n # function is paused and will resume when next is called again.\\n # Also release condition variable by exiting the context\\n self._transition(Status.AWAITING_CLIENT_MESSAGE)\\n\\n if server_message is None:\\n raise Exception(\\\"Server message can not be None\\\")\\n\\n yield server_message\",\n \"def __next__(self):\\n return self.read_message()\",\n \"def get(self, block=True, timeout=None):\\n if block:\\n message = self.redis.blpop(self.queue, timeout=timeout)\\n else:\\n message = self.redis.lpop(self.queue)\\n\\n parsed_message = self.parse(message[1])\\n return parsed_message\",\n \"async def Read(self) -> Optional[Message]:\\n return await self._read_queue.Get()\",\n \"def get_msgs(self):\\n msgs = []\\n while True:\\n try:\\n msgs.append(self.get_msg(block=False))\\n except Empty:\\n break\\n return msgs\",\n \"def get_msgs(self):\\n msgs = []\\n while True:\\n try:\\n msgs.append(self.get_msg(block=False))\\n except Empty:\\n break\\n return msgs\",\n \"def peek(self):\\r\\n return self.queue[0]\",\n \"def peek(self):\\r\\n return self.queue[0]\",\n \"def iterate_msgs(stream):\\n while True:\\n item = None\\n buf = bytearray()\\n stall_timer = None\\n\\n while True:\\n # read bytes until item boundary reached\\n buf += stream.read(1)\\n if not buf:\\n # check for stall (i.e. no data for 90 seconds)\\n if not stall_timer:\\n stall_timer = time.time()\\n elif time.time() - stall_timer > TwitterAPI.STREAMING_TIMEOUT:\\n raise TwitterConnectionError(\\\"Twitter stream stalled\\\")\\n elif stall_timer:\\n stall_timer = None\\n if buf[-2:] == b\\\"\\\\r\\\\n\\\":\\n item = buf[0:-2]\\n if item.isdigit():\\n # use byte size to read next item\\n nbytes = int(item)\\n item = None\\n item = stream.read(nbytes)\\n yield item\\n else:\\n yield b\\\"\\\" # keepalive\\n break\",\n \"def sender_iter(self):\\n while 1:\\n yield self.send_next()\",\n \"def tagged_messages(client: SlackClient, user_id: str):\\n while True:\\n for data in client.rtm_read():\\n if data.get(\\\"type\\\") == \\\"message\\\" and user_id in data.get(\\\"text\\\"):\\n yield data\\n\\n time.sleep(RTM_READ_DELAY)\",\n \"def recv_messages(self):\\n while True:\\n b = unwrap_read(self.sock.recv(4096))\\n msgs = self.parser.feed(b)\\n if msgs:\\n for msg in msgs:\\n self.router.incoming(msg)\\n return\",\n \"def get(self):\\n with self.__lock:\\n while True:\\n try:\\n job = self.__queue.get(False)\\n self.__lock.notify_all()\\n return job\\n except Queue.Empty:\\n self.__lock.wait()\",\n \"def get_next_message(self):\\n newest_available_offset = self.broker.get_last_offset(self.topic_name)\\n if self.offset <= newest_available_offset:\\n msg = self.broker.read_message(self.topic_name, self.offset)\\n self.offset += 1\\n return msg\",\n \"def results_q_get(self):\\n while not self.stopped():\\n try:\\n return self.results_queue.get(timeout=self.heart_beat)\\n except queue.Empty:\\n pass\\n raise StopIteration()\",\n \"def _next_message(self):\\n msg = yield self._read_message()\\n message = self._slack_to_chat(msg)\\n\\n raise gen.Return(message)\",\n \"def get_message_from_queue(self):\\n message = None, None\\n\\n try:\\n message = self.queue.get(block=True, timeout=3)\\n except Empty:\\n self.fail(msg='Queue get() failed empty')\\n\\n return message\",\n \"def consume(self, **kwargs):\\n kwargs.setdefault('block', True)\\n try:\\n while True:\\n msg = self.get(**kwargs)\\n if msg is None:\\n break\\n yield msg\\n except KeyboardInterrupt: # pragma: no cover\\n print()\\n return\",\n \"def readline(self):\\n try:\\n return self.queue.get_nowait()\\n except Empty:\\n return None\",\n \"def getAllFromQueue(self, Q):\\n try:\\n while True:\\n yield Q.get_nowait()\\n except Queue.Empty:\\n raise StopIteration\",\n \"def start_operation(self):\\n # Prevent message streak (for debugging purposes)\\n msg_streak = 0\\n max_streak = 10\\n msg = Message.connect\\n while True:\\n # If completed return\\n if self.completed:\\n break\\n\\n # Read from the queue\\n obj = self.msg_q.get()\\n edge_id = obj['sender']\\n message = obj['message']\\n pl = obj['pl']\\n\\n # Wake process first before processing any message\\n if self.state == State.sleep:\\n self.wakeup()\\n\\n # Find the edge index which sent this message\\n for _in in range(self.num_neighbors):\\n edge = self.edges[_in]\\n if edge.get_id() == edge_id:\\n edge_index = _in\\n break\\n\\n # Check message streak\\n if message == msg:\\n msg_streak += 1\\n else:\\n msg = message\\n msg_streak = 0\\n if msg_streak >= max_streak:\\n msg_streak = 0\\n time.sleep(0.01)\\n\\n # Process each message accordingly\\n print_level(\\n 'info', self.node_id,\\n 'Received from edge ' + str(edge_index) + ' ' + str(message))\\n if message == Message.connect:\\n self.process_connect(edge_index, pl[0])\\n elif message == Message.initiate:\\n self.process_initiate(edge_index, pl[0], pl[1], pl[2])\\n elif message == Message.test:\\n self.process_test(edge_index, pl[0], pl[1])\\n elif message == Message.accept:\\n self.process_accept(edge_index)\\n elif message == Message.reject:\\n self.process_reject(edge_index)\\n elif message == Message.report:\\n self.process_report(edge_index, pl[0])\\n elif message == Message.changeroot:\\n self.process_changeroot()\\n elif message == Message.halt:\\n self.__complete()\\n\\n # Return the number of messages sent by this node\\n print_level('info', self.node_id, 'Completed for this node')\\n return self.num_messages\",\n \"def peek(self):\\n return self.the_queue[0]\",\n \"def get_msg(self, my_queue):\\n self.channel.basic_qos(prefetch_count=COUNT)\\n try:\\n for method_frame, properties, body in self.channel.consume(my_queue):\\n self.channel.basic_ack(method_frame.delivery_tag)\\n return body\\n except pika.exceptions, err_msg:\\n log.error(err_msg)\\n return False\",\n \"def _pull_batch_from_queue(self):\\n rollout = self.explorer.queue.get( timeout = 600.0 )\\n while not rollout.terminal:\\n try: \\n rollout.extend( self.explorer.queue.get_nowait() )\\n except queue.Empty:\\n break\\n print(rollout.size())\\n return rollout\",\n \"def peek(self):\\n return self.queue[0]\",\n \"def pop_message(self, queue_name):\\r\\n messages = self.pop_messages(queue_name, count=1)\\r\\n if messages['item_count'] > 0:\\r\\n return messages['items'][0]\\r\\n else:\\r\\n return None\",\n \"def read(self):\\n # return next frame in the queue\\n return self.Q.get()\",\n \"def get_all_from_queue(Q):\\n try:\\n while True:\\n yield Q.get_nowait()\\n except queue.Empty:\\n raise StopIteration\",\n \"def _messages_list(self, queue):\\n\\n return queue.messages()\",\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 \"async def poll_message(self):\\n message_cache = self.message_cache\\n if (message_cache is not None) and message_cache:\\n return message_cache.pop()\\n \\n if not self.message_request_more:\\n return\\n \\n message_cache = await self.client.message_get_chunk(self.source_channel, after = self.last_message_id)\\n self.message_cache = message_cache\\n \\n if len(message_cache) < 100:\\n self.message_request_more = False\\n \\n if message_cache:\\n return message_cache.pop()\",\n \"def get_all_from_queue(Q):\\n try:\\n while True:\\n yield Q.get_nowait()\\n except Queue.Empty:\\n raise StopIteration\",\n \"def receive():\\n now = time.time()\\n end = now + MAX_DURATION\\n tmp = None\\n # Heroku doesn't notify when clients disconnect so we have to impose a\\n # maximum connection duration.\\n while now < end:\\n if not tmp:\\n tmp = AsyncResult()\\n BROADCAST_QUEUE.put(tmp)\\n try:\\n yield tmp.get(timeout=KEEP_ALIVE_DELAY)\\n tmp = None\\n except Timeout:\\n yield ''\\n now = time.time()\",\n \"def __iter__(self):\\n while True:\\n if self.stop:\\n return\\n for item in self.get_next_batch():\\n yield item\",\n \"def receive(self):\\n try:\\n itr = 0\\n while self.connected:\\n \\n r, w, e = select.select(\\n (self.sock, ), (), (), 10.0)\\n \\n if r:\\n message = json.loads(self.recv())\\n \\n if 'fetch' in message:\\n self.fetch_id = message['fetch']\\n \\n if 'failure' in message:\\n raise InvalidFetch(message['failure'])\\n \\n if 'records' in message:\\n if 'added' in message['records']:\\n num = len(message['records']['added'])\\n else:\\n num = len(message['records'])\\n \\n logger.debug('Query returned %s records.', num)\\n if self.max_recv:\\n itr += 1\\n \\n if 'end' in message:\\n logger.debug('Received end message: %s' % message['end'])\\n yield message\\n break\\n \\n yield message\\n if self.max_recv and self.max_recv <= itr:\\n break \\n\\n except (Exception, KeyboardInterrupt, SystemExit, FetchAborted) as e:\\n logger.info('Caught exception in receive: %s -> %s', type(e), str(e))\\n if isinstance(e, (SystemExit, InvalidFetch)):\\n # propagate SystemExit, InvalidFetch\\n raise\\n finally:\\n if self.connected:\\n if self.fetch_id:\\n self.send(json.dumps({'abort': self.fetch_id}))\\n self.close()\\n \\n if self.thread:\\n self.event.set()\\n while self.thread.isAlive():\\n self.event.wait(1)\\n \\n logger.info('Closed web socket connection normally.')\",\n \"def _get_message(self, block=True, timeout=0.1, get_partition_info=None,\\n update_offset=True):\\n if self.got_error:\\n raise self.error\\n try:\\n meta, message = self.queue.get(timeout=timeout)\\n\\n if update_offset:\\n # Update partition offset\\n self.offsets[meta.partition] = message.offset + 1\\n\\n # Count, check and commit messages if necessary\\n self.count_since_commit += 1\\n self._auto_commit()\\n\\n if get_partition_info is None:\\n get_partition_info = self.partition_info\\n if get_partition_info:\\n return meta, message\\n else:\\n return message\\n except Empty:\\n return None\",\n \"def work(self):\\n while True:\\n message = self.get()\\n self.handle(message)\",\n \"def _iterate_messages_recursive(self, this_node, path):\\n # step through every edge from the current node.\\n for edge in self.edges_from(this_node.id):\\n # keep track of the path as we walk through it\\n # we keep track of edges as opposed to nodes because if there is more then one path through a set of\\n # given nodes we don't want any ambiguity.\\n path.append(edge)\\n\\n message_path = \\\"->\\\".join([self.nodes[e.dst].name for e in path])\\n logging.debug('checking: {0}'.format(message_path))\\n\\n self.fuzz_node = self.nodes[path[-1].dst]\\n self.total_mutant_index += 1\\n yield (path,)\\n\\n for x in self._iterate_messages_recursive(self.fuzz_node, path):\\n yield x\\n\\n # finished with the last node on the path, pop it off the path stack.\\n if path:\\n path.pop()\",\n \"def ecute(self):\\n msg = self.up_queue_recv_socket.recv()\\n result, e = self.up_queue.get()\\n if e is not None:\\n raise e\\n return result\",\n \"def consume(iterator):\\n deque(iterator, maxlen=0)\",\n \"def getfrom(self,room,last_check=None):\\n\\n log.debug('getting: %s %s' % (room,last_check))\\n log.debug('messages: %s' % (0 if not room in self.rooms\\n else len(self.rooms.get(room))))\\n \\n # see if we have any messages for that room\\n last_check = int(last_check) or 0\\n\\n # go through the message's in the room\\n if room in self.rooms and len(self.rooms.get(room)) > 0:\\n # messages are ordered newest to oldest\\n for msg in self.rooms.get(room):\\n if msg.timestamp > last_check:\\n yield msg.body\",\n \"def dequeue_message(self) -> MessageQueueItem:\\n return heapq.heappop(self._message_queue)\",\n \"def asyncRead(self, timeout=5000, staging=False, attr=None):\\n if self.isConnected():\\n turns = 0\\n while True:\\n turns += 1\\n if turns > 100:\\n logging.debug(\\\"Timeout on read after 100 iterations\\\")\\n return None\\n\\n result = True\\n logging.debug(\\\"MessageOutput size: %i\\\", len(self.messageOutput))\\n if len(self.messageOutput) == 0 and not self.containsAttr(attr):\\n logging.debug(\\\"Waiting for new message.\\\")\\n if not staging:\\n # spy = QSignalSpy(self._stopWaiting)\\n spy = QSignalSpy(self.bufferReady)\\n else:\\n spy = QSignalSpy(self._staging)\\n result = spy.wait(timeout) # Asynchronous wait, Timeout 5s\\n\\n if result and not self._hasError:\\n self.lock.acquire()\\n if len(self.messageOutput) == 0:\\n self.lock.release()\\n logging.debug(\\\"Race condition triggered. Wait for next message.\\\")\\n continue\\n found = False\\n result = self.messageOutput[0]\\n if attr is not None:\\n for msg in self.messageOutput:\\n if attr[0] in msg:\\n if attr[1] == msg[attr[0]]:\\n found = True\\n result = msg\\n break\\n if found or attr is None:\\n del self.messageOutput[self.messageOutput.index(result)]\\n logging.debug(\\\"MessageOutput size: %i\\\", len(self.messageOutput))\\n self.lock.release()\\n\\n if \\\"error\\\" not in result:\\n result[\\\"error\\\"] = []\\n if \\\"status\\\" not in result:\\n result[\\\"status\\\"] = True\\n\\n return result\\n else:\\n logging.debug(\\\"Message not found. Release of lock.\\\")\\n if attr is not None:\\n logging.debug(\\\"Miss '%s' with value '%s'\\\", str(attr[0]), str(attr[1]))\\n self.lock.release()\\n self.bufferReady.emit()\\n qApp.processEvents()\\n else:\\n logging.debug(\\\"Nothing to read.\\\")\\n break\\n else:\\n logging.debug(\\\"Not connected. Did not read.\\\")\\n return None\",\n \"def dispatchMessageLoop(self, tree):\\n self.fill(\\\"for (const auto& \\\")\\n self.dispatch(tree.target)\\n self.write(\\\" : \\\")\\n # if simple message iterator\\n if isinstance(tree.iter, ast.Name):\\n if not tree.iter.id == self._input_message_var:\\n self.RaiseError(t, f\\\"Message input loop requires use of '{self._input_message_var}' as iterator.\\\")\\n # write with prefix\\n self.write(f\\\"FLAMEGPU->{self._input_message_var}\\\")\\n # if it is a call then handle the different cases\\n elif isinstance(tree.iter, ast.Call):\\n self.dispatchMessageIteratorCall(tree.iter)\\n #otherwise not supported\\n else :\\n self.RaiseError(tree, f\\\"Message input loop iterator in unsupported format\\\")\\n self.write(\\\")\\\")\\n self._message_iterator_var = tree.target.id\\n self.enter()\\n self.dispatch(tree.body)\\n self.leave()\\n self._message_iterator_var = None\",\n \"def popMsg(self):\\n\\n if not self.queue:\\n return []\\n returned_msgs = []\\n for msg, delay in self.queue:\\n delay -= 1\\n if delay < 1:\\n returned_msgs.append(msg)\\n else:\\n self.pushMsg(msg, delay)\\n self.queue = []\\n return returned_msgs\",\n \"def dequeue(self):\\n return self._queue.dequeue()\",\n \"def __iter__(self):\\n return iter([self.format_message(record) for record in self._messages])\",\n \"def get(self):\\r\\n try:\\r\\n # get with block=False returns an item if one\\r\\n # is immediately available, else raises the Empty exception\\r\\n return self._queue.get(block=False)\\r\\n except queue.Empty:\\r\\n return self._create_connection()\",\n \"def get_messages(self, max_messages):\\n raw = self.redis_client.lrange(self.message_list, 0, max_messages)\\n messages = (m for m in raw if m != b\\\"null\\\")\\n messages = (m.decode(\\\"utf-8\\\") for m in messages)\\n yield from map(json.loads, messages)\",\n \"def blocking_read_elem(self):\\n _, read_str = self.redis_client.blpop(self.buffer_name)\\n return self.deserialize_elem(read_str)\",\n \"def use_queue():\\n q = queue.Queue()\\n for i in range(10):\\n q.put_nowait(i)\\n while q.qsize() > 0:\\n element = q.get_nowait()\\n sys.stdout.write(\\\"poping out from queue: {0}\\\\n\\\".format(element))\",\n \"def pop_message(self):\\n app_process = sqlite3.connect('app_process::memory:', check_same_thread=False)\\n app_process_cursor = app_process.cursor()\\n app_process_cursor.execute(\\\"SELECT * FROM message_queue WHERE tstamp==(:first)\\\", {\\\"first\\\":self.mq_first}) \\n item = app_process_cursor.fetchone()\\n if item == None:\\n return\\n app_process_cursor.execute(\\\"DELETE FROM message_queue WHERE tstamp==(:first)\\\", {\\\"first\\\":self.mq_first})\\n self.mq_first = item[4] #now sets first to next item pointed to\\n app_process.commit()\\n app_process.close()\\n return item\",\n \"def next(self):\\n nxt = self.readentry()\\n if nxt is None:\\n raise StopIteration\\n return nxt\",\n \"def wait_message(self):\\n if self._state != states['open']:\\n return False\\n if len(self._read_queue) > 0:\\n return True\\n\\n assert self._read_waiter is None or self._read_waiter.cancelled(), \\\\\\n \\\"You may only use one wait_message() per connection.\\\"\\n\\n self._read_waiter = asyncio.Future(loop=self._loop)\\n yield from self._read_waiter\\n return self.wait_message()\",\n \"def yield_messages(self, *, mailbox=DEFAULT_MAILBOX):\\n with imaplib.IMAP4_SSL(\\n host=self.host, port=self.port,\\n ssl_context=ssl.create_default_context()) as ic:\\n logger.debug(f'Logging in as {self.user}')\\n restype, _ = ic.login(user=self.user, password=self.password)\\n check_restype(restype, f'failed to LOGIN as {self.user}')\\n\\n logger.debug(f'Selecting mailbox {mailbox}')\\n restype, _ = ic.select(mailbox=mailbox)\\n check_restype(restype, f'failed to SELECT mailbox {mailbox}')\\n\\n # First, query for *all* message UIDs in the selected mailbox.\\n # Interpret the response as a list of integers.\\n logger.debug('Getting UID list')\\n restype, [uids] = ic.uid('SEARCH', 'ALL')\\n check_restype(restype, 'failed to execute SEARCH')\\n uids = [*map(int, filter(None, uids.split(b' ')))]\\n\\n # In the event that the mailbox is empty, there will be no UIDs and\\n # nothing more to do.\\n if not uids:\\n logger.debug('No messages in this mailbox')\\n raise NoMessages\\n\\n # Fetch a range of message headers, from the smallest UID to the\\n # largest UID. Build a structure that links each UID to the `Date`\\n # header on the message it refers to.\\n message_set = f'{min(uids)}:{max(uids)}'\\n logger.debug(f'Fetching headers in UID range {message_set}')\\n restype, resdata = ic.uid('FETCH', message_set, '(BODY.PEEK[HEADER])')\\n check_restype(restype, f'failed to execute FETCH UIDs {message_set} (peek)')\\n uids_dated = self.date_uid_map(data=resdata)\\n\\n # Iterate over all UIDs in date order, oldest to newest.\\n for _, uid in sorted(uids_dated, key=itemgetter(0)):\\n # Fetch the full message content, wrap it in an IMAPMessage and\\n # yield it to the caller.\\n logger.debug(f'Fetching message UID {int(uid)}')\\n restype, resdata = ic.uid('FETCH', uid, '(RFC822)')\\n check_restype(restype, f'failed to execute FETCH UID {int(uid)} (full)')\\n\\n yield IMAPMessage(data=resdata, imap_connection=ic, uid=uid)\",\n \"def q_get(self):\\n while not self.stopped():\\n try:\\n return self.in_q.get(timeout=self.heart_beat)\\n except queue.Empty:\\n pass\",\n \"def next(self):\\n if self.pointer > len(self.queue) - 1:\\n self.pointer = 0\\n raise StopIteration\\n val = self.queue[self.pointer]\\n self.pointer += 1\\n return val\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7556442","0.7009815","0.6816463","0.674572","0.6724379","0.66346157","0.660066","0.64881974","0.63246495","0.63130015","0.62896055","0.6209126","0.6189926","0.61867803","0.60752857","0.60651827","0.6057777","0.6036472","0.5981971","0.59722316","0.59631646","0.59544075","0.59367734","0.592681","0.59243137","0.5922335","0.59223247","0.59223247","0.5884398","0.58835363","0.5879567","0.5850578","0.5833742","0.57841265","0.57841265","0.57820386","0.5742891","0.57195634","0.57019717","0.5697721","0.56925374","0.56921715","0.5690952","0.56554365","0.5650218","0.5637691","0.56246734","0.56190234","0.56190234","0.5613634","0.5613634","0.56044066","0.55978066","0.5587893","0.55874884","0.5585759","0.55829793","0.55799437","0.55757546","0.5575473","0.5575286","0.55520856","0.55491126","0.5548565","0.5532175","0.5530425","0.5526815","0.5519132","0.54907686","0.549059","0.548326","0.5481132","0.54767245","0.5476468","0.5470182","0.5451235","0.54434127","0.54361236","0.5435182","0.5434538","0.5423428","0.53960794","0.53793895","0.5375373","0.5370619","0.5363309","0.53589803","0.5355975","0.5355813","0.5351507","0.5351355","0.53492206","0.5343625","0.53403234","0.5322399","0.5314897","0.5312748","0.5309949","0.53085405","0.5304931"],"string":"[\n \"0.7556442\",\n \"0.7009815\",\n \"0.6816463\",\n \"0.674572\",\n \"0.6724379\",\n \"0.66346157\",\n \"0.660066\",\n \"0.64881974\",\n \"0.63246495\",\n \"0.63130015\",\n \"0.62896055\",\n \"0.6209126\",\n \"0.6189926\",\n \"0.61867803\",\n \"0.60752857\",\n \"0.60651827\",\n \"0.6057777\",\n \"0.6036472\",\n \"0.5981971\",\n \"0.59722316\",\n \"0.59631646\",\n \"0.59544075\",\n \"0.59367734\",\n \"0.592681\",\n \"0.59243137\",\n \"0.5922335\",\n \"0.59223247\",\n \"0.59223247\",\n \"0.5884398\",\n \"0.58835363\",\n \"0.5879567\",\n \"0.5850578\",\n \"0.5833742\",\n \"0.57841265\",\n \"0.57841265\",\n \"0.57820386\",\n \"0.5742891\",\n \"0.57195634\",\n \"0.57019717\",\n \"0.5697721\",\n \"0.56925374\",\n \"0.56921715\",\n \"0.5690952\",\n \"0.56554365\",\n \"0.5650218\",\n \"0.5637691\",\n \"0.56246734\",\n \"0.56190234\",\n \"0.56190234\",\n \"0.5613634\",\n \"0.5613634\",\n \"0.56044066\",\n \"0.55978066\",\n \"0.5587893\",\n \"0.55874884\",\n \"0.5585759\",\n \"0.55829793\",\n \"0.55799437\",\n \"0.55757546\",\n \"0.5575473\",\n \"0.5575286\",\n \"0.55520856\",\n \"0.55491126\",\n \"0.5548565\",\n \"0.5532175\",\n \"0.5530425\",\n \"0.5526815\",\n \"0.5519132\",\n \"0.54907686\",\n \"0.549059\",\n \"0.548326\",\n \"0.5481132\",\n \"0.54767245\",\n \"0.5476468\",\n \"0.5470182\",\n \"0.5451235\",\n \"0.54434127\",\n \"0.54361236\",\n \"0.5435182\",\n \"0.5434538\",\n \"0.5423428\",\n \"0.53960794\",\n \"0.53793895\",\n \"0.5375373\",\n \"0.5370619\",\n \"0.5363309\",\n \"0.53589803\",\n \"0.5355975\",\n \"0.5355813\",\n \"0.5351507\",\n \"0.5351355\",\n \"0.53492206\",\n \"0.5343625\",\n \"0.53403234\",\n \"0.5322399\",\n \"0.5314897\",\n \"0.5312748\",\n \"0.5309949\",\n \"0.53085405\",\n \"0.5304931\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7156374"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93091,"cells":{"query":{"kind":"string","value":"This is initialization method of the algorithm's class."},"document":{"kind":"string","value":"def __init__(self, filename='', limit=0.80, members=3, delimiter=','):\n self.count = 0 # counter for correct predictions\n self.results = self.load_data(filename=filename, limit=limit, delim=delimiter) # load data and receive response\n self.test_data = self.results[1]\n self.training_data = self.results[0]\n # get data neighbours of each member of the test data set.\n for x in range(len(self.test_data)):\n neighbours = self.get_neighbours(training_data=self.training_data, instance=self.test_data[x], k=members)\n # make a prediction.\n label = self.count_votes(neighbours=neighbours)\n # compare predicted outcome to actual outcome.\n print(\"{}). Actual outcome => '{}' & Predicted outcome => '{}'\".format(x + 1, self.test_data[x][-1], label))\n if self.test_data[x][-1] == label:\n self.count = self.count + 1\n\n # Calculate accuracy percentage.\n self.accuracy = (self.count / len(self.test_data)) * 100\n print(\"\\nAccuracy = {0:.2f}%\".format(self.accuracy))"},"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 init_algorithm(self):\n pass","def initialize(self):\n\t\tpass","def init(self) -> None:","def initialize(self):\r\n pass","def initialize(self):\r\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def initialize(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def init(self):\n pass","def _init(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def initialize(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def init(self):\n raise NotImplementedError","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def initialise(self):","def _init(self):\n pass","def initialize(self) -> None:\n pass","def initialize(self): \r\n pass","def init(self) -> None:\n ...","def init(self):","def init(self):","def initialize(self):\n pass # pragma: no cover","def _initialize(self):\n pass","def _initialize(self):\n pass","def _initialize(self):\n pass","def initialize(self):\n return","def __init__(self):\n self.n=0\n self.K=0\n self.tuple_data=False\n self.optimal=0","def __init__():","def initialize(cls):","def initialize(self):\n self.initialize_edges()\n self.initialize_prob()\n self.initialize_total_input_dict()\n\n self.initialize_fpmusigv_dict()","def _init(self):","def init(self) -> Tuple[bool, str]:\n self.change_ltm()\n return self.algorithm.init()","def __init__(self, algorithm_name):\r\n super().__init__()\r\n self.algorithm_name = algorithm_name","def initialise(self):\r\n return","def initialise(self):\r\n return","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__ (self):\n pass","def __init__(self):\n self.param_names = []\n self.param_values = []\n self.param_settings = []\n self.result = []\n self.best_params = None\n self.best_score = None\n self.max_reps = 5\n self.num_values = False\n self.algorithm_done = False","def initialize(self, *args, **kwargs):","def __init__(self, iter = 10):\n #We start calling the base constructor\n super(RandAlgo,self).__init__()\n #We then define the algorithm 'private' data members\n self.__iter = iter","def initialize(self, *args, **kwargs):\n pass","def initialize(self, **kwargs):","def initialize(self, args):\n\t\tpass","def __init__(self):\n self._initialized = False\n self.init()","def __init__(self):\n self._initialized = False\n self.init()","def init():","def do_init(self):\n\n pass","def __init__(self):\n raise NotImplementedError(\"This class cannot be instantiated!\")","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def initialize(self):\n pass","def __init__ (self) :","def _real_initialize(self):\n pass","def init(self, *args, **kwds):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(__self__):\n pass","def __init__(self):\n BasicEngine.__init__(self)\n self._active_qubits = 0\n self._num_rotations = 0\n self._rotations = []","def __init__(self, **kwargs):\n\n # call base class constructor registering that this tool performs everything.\n Algorithm.__init__(\n self,\n performs_projection = True,\n use_projected_features_for_enrollment = True,\n requires_enroller_training = True\n )","def __init__(self):\n\n self.result = None # To store the result\n self.predictor = None # To store the fit predictor","def init(self, parameters):\n pass","def __init__(self):\n raise NoInitiation","def __init__(self):\n self.weights = None\n self._epsilon = None\n self._num_training = None\n self._lambda = None\n return None","def initialize(self):\r\n self.bucket_array.initialize()","def __init__(self):\n self.initialized = False","def __init__(self):\n self.initialized = False","def __init__(self, **kwargs):\n\t\tUtility.__init__(self)\n\t\tself.D, self.Lower, self.Upper, self.bRange = 0, full(0, 0.0), full(0, 0.0), full(0, 0.0)\n\t\tself.Iters, self.Evals = 0, 0\n\t\tself.nGEN, self.nFES = inf, inf","def __init__(self):\n # Create an 8-byte initialization vector","def _initialize(self):\n self._solution = self._problem_instance.build_solution(method=\"Greedy\")\n\n while not self._problem_instance.is_admissible(self._solution):\n self._solution = self._problem_instance.build_solution(method=\"Greedy\")\n \n self._problem_instance.evaluate_solution(self._solution, feedback=self._feedback)","def __init__(self, **kwds):\n raise NotImplementedError","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass","def __init__(self):\n\t\tpass"],"string":"[\n \"def init_algorithm(self):\\n pass\",\n \"def initialize(self):\\n\\t\\tpass\",\n \"def init(self) -> None:\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\r\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def initialize(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def init(self):\\n pass\",\n \"def _init(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def initialize(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def init(self):\\n raise NotImplementedError\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialise(self):\",\n \"def _init(self):\\n pass\",\n \"def initialize(self) -> None:\\n pass\",\n \"def initialize(self): \\r\\n pass\",\n \"def init(self) -> None:\\n ...\",\n \"def init(self):\",\n \"def init(self):\",\n \"def initialize(self):\\n pass # pragma: no cover\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def _initialize(self):\\n pass\",\n \"def initialize(self):\\n return\",\n \"def __init__(self):\\n self.n=0\\n self.K=0\\n self.tuple_data=False\\n self.optimal=0\",\n \"def __init__():\",\n \"def initialize(cls):\",\n \"def initialize(self):\\n self.initialize_edges()\\n self.initialize_prob()\\n self.initialize_total_input_dict()\\n\\n self.initialize_fpmusigv_dict()\",\n \"def _init(self):\",\n \"def init(self) -> Tuple[bool, str]:\\n self.change_ltm()\\n return self.algorithm.init()\",\n \"def __init__(self, algorithm_name):\\r\\n super().__init__()\\r\\n self.algorithm_name = algorithm_name\",\n \"def initialise(self):\\r\\n return\",\n \"def initialise(self):\\r\\n return\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__ (self):\\n pass\",\n \"def __init__(self):\\n self.param_names = []\\n self.param_values = []\\n self.param_settings = []\\n self.result = []\\n self.best_params = None\\n self.best_score = None\\n self.max_reps = 5\\n self.num_values = False\\n self.algorithm_done = False\",\n \"def initialize(self, *args, **kwargs):\",\n \"def __init__(self, iter = 10):\\n #We start calling the base constructor\\n super(RandAlgo,self).__init__()\\n #We then define the algorithm 'private' data members\\n self.__iter = iter\",\n \"def initialize(self, *args, **kwargs):\\n pass\",\n \"def initialize(self, **kwargs):\",\n \"def initialize(self, args):\\n\\t\\tpass\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def __init__(self):\\n self._initialized = False\\n self.init()\",\n \"def init():\",\n \"def do_init(self):\\n\\n pass\",\n \"def __init__(self):\\n raise NotImplementedError(\\\"This class cannot be instantiated!\\\")\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def initialize(self):\\n pass\",\n \"def __init__ (self) :\",\n \"def _real_initialize(self):\\n pass\",\n \"def init(self, *args, **kwds):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(__self__):\\n pass\",\n \"def __init__(self):\\n BasicEngine.__init__(self)\\n self._active_qubits = 0\\n self._num_rotations = 0\\n self._rotations = []\",\n \"def __init__(self, **kwargs):\\n\\n # call base class constructor registering that this tool performs everything.\\n Algorithm.__init__(\\n self,\\n performs_projection = True,\\n use_projected_features_for_enrollment = True,\\n requires_enroller_training = True\\n )\",\n \"def __init__(self):\\n\\n self.result = None # To store the result\\n self.predictor = None # To store the fit predictor\",\n \"def init(self, parameters):\\n pass\",\n \"def __init__(self):\\n raise NoInitiation\",\n \"def __init__(self):\\n self.weights = None\\n self._epsilon = None\\n self._num_training = None\\n self._lambda = None\\n return None\",\n \"def initialize(self):\\r\\n self.bucket_array.initialize()\",\n \"def __init__(self):\\n self.initialized = False\",\n \"def __init__(self):\\n self.initialized = False\",\n \"def __init__(self, **kwargs):\\n\\t\\tUtility.__init__(self)\\n\\t\\tself.D, self.Lower, self.Upper, self.bRange = 0, full(0, 0.0), full(0, 0.0), full(0, 0.0)\\n\\t\\tself.Iters, self.Evals = 0, 0\\n\\t\\tself.nGEN, self.nFES = inf, inf\",\n \"def __init__(self):\\n # Create an 8-byte initialization vector\",\n \"def _initialize(self):\\n self._solution = self._problem_instance.build_solution(method=\\\"Greedy\\\")\\n\\n while not self._problem_instance.is_admissible(self._solution):\\n self._solution = self._problem_instance.build_solution(method=\\\"Greedy\\\")\\n \\n self._problem_instance.evaluate_solution(self._solution, feedback=self._feedback)\",\n \"def __init__(self, **kwds):\\n raise NotImplementedError\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\",\n \"def __init__(self):\\n\\t\\tpass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8788583","0.78260493","0.7767065","0.77532625","0.77532625","0.77265584","0.77265584","0.77265584","0.77265584","0.77265584","0.7675273","0.7675273","0.7675273","0.7675273","0.7675273","0.7675273","0.7675273","0.7675273","0.7666846","0.7661625","0.7661625","0.7661625","0.7616752","0.7616752","0.76160645","0.76160645","0.76160645","0.76160645","0.7603252","0.7572567","0.7569646","0.75634915","0.7522223","0.74770087","0.74770087","0.74587053","0.7457624","0.7457624","0.7457624","0.74372005","0.7359896","0.734567","0.7322589","0.72987735","0.7293552","0.72362614","0.7228408","0.72151536","0.72151536","0.7186468","0.7186468","0.7186468","0.7186468","0.717883","0.7166853","0.7150886","0.71489525","0.7144314","0.7141968","0.71391135","0.71356255","0.71356255","0.7133709","0.71052086","0.7069459","0.7061054","0.70486695","0.70464975","0.70388603","0.70341754","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.70236605","0.700063","0.6993627","0.6989285","0.69737107","0.6968368","0.6950226","0.6941989","0.69364864","0.69364864","0.6906157","0.6900419","0.68882453","0.6885295","0.6879006","0.6879006","0.6879006","0.6879006","0.6879006","0.6879006","0.6879006","0.6879006"],"string":"[\n \"0.8788583\",\n \"0.78260493\",\n \"0.7767065\",\n \"0.77532625\",\n \"0.77532625\",\n \"0.77265584\",\n \"0.77265584\",\n \"0.77265584\",\n \"0.77265584\",\n \"0.77265584\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7675273\",\n \"0.7666846\",\n \"0.7661625\",\n \"0.7661625\",\n \"0.7661625\",\n \"0.7616752\",\n \"0.7616752\",\n \"0.76160645\",\n \"0.76160645\",\n \"0.76160645\",\n \"0.76160645\",\n \"0.7603252\",\n \"0.7572567\",\n \"0.7569646\",\n \"0.75634915\",\n \"0.7522223\",\n \"0.74770087\",\n \"0.74770087\",\n \"0.74587053\",\n \"0.7457624\",\n \"0.7457624\",\n \"0.7457624\",\n \"0.74372005\",\n \"0.7359896\",\n \"0.734567\",\n \"0.7322589\",\n \"0.72987735\",\n \"0.7293552\",\n \"0.72362614\",\n \"0.7228408\",\n \"0.72151536\",\n \"0.72151536\",\n \"0.7186468\",\n \"0.7186468\",\n \"0.7186468\",\n \"0.7186468\",\n \"0.717883\",\n \"0.7166853\",\n \"0.7150886\",\n \"0.71489525\",\n \"0.7144314\",\n \"0.7141968\",\n \"0.71391135\",\n \"0.71356255\",\n \"0.71356255\",\n \"0.7133709\",\n \"0.71052086\",\n \"0.7069459\",\n \"0.7061054\",\n \"0.70486695\",\n \"0.70464975\",\n \"0.70388603\",\n \"0.70341754\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.70236605\",\n \"0.700063\",\n \"0.6993627\",\n \"0.6989285\",\n \"0.69737107\",\n \"0.6968368\",\n \"0.6950226\",\n \"0.6941989\",\n \"0.69364864\",\n \"0.69364864\",\n \"0.6906157\",\n \"0.6900419\",\n \"0.68882453\",\n \"0.6885295\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\",\n \"0.6879006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93092,"cells":{"query":{"kind":"string","value":"This method loads data from the file. A ny number of columns is accepted but provided the labels are on the last columns to the right."},"document":{"kind":"string","value":"def load_data(self, filename='', limit=0.75, delim=','):\n with open(filename) as data:\n reader = csv.reader(data, delimiter=delim)\n f = list(reader)\n for x in range(len(f)):\n for y in range(len(f[0]) - 1):\n f[x][y] = float(f[x][y]) # convert elements of each array to type float except the last one\n\n lim = limit * (len(f)) # calculate where the training data and test data are divided\n lim = int(lim) # convert limit for indexing purposes\n results = (f[:lim], f[lim:]) # append training data and test data to tuple\n\n # for x in range(len(f)):\n # print(f[x])\n\n del f # delete f array which was temporary\n\n return results # return value"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _read_column_labels(self):\n\n # read the label line (should be at row 15 of the file at this point)\n label_list = self._stream_handle.readline().strip().split()\n self.num_columns = len(label_list)\n self._header_dict['labels'] = label_list\n\n # the m_present_time label is required to generate particles, raise an exception if it is not found\n if GliderParticleKey.M_PRESENT_TIME not in label_list:\n raise DatasetParserException('The m_present_time label has not been found, which means the timestamp '\n 'cannot be determined for any particles')\n\n # read the units line (should be at row 16 of the file at this point)\n data_unit_list = self._stream_handle.readline().strip().split()\n data_unit_list_length = len(data_unit_list)\n\n # read the number of bytes line (should be at row 17 of the file at this point)\n num_of_bytes_list = self._stream_handle.readline().strip().split()\n num_of_bytes_list_length = len(num_of_bytes_list)\n\n # number of labels for name, unit, and number of bytes must match\n if data_unit_list_length != self.num_columns or self.num_columns != num_of_bytes_list_length:\n raise DatasetParserException(\"The number of columns in the labels row: %d, units row: %d, \"\n \"and number of bytes row: %d are not equal.\"\n % (self.num_columns, data_unit_list_length, num_of_bytes_list_length))\n\n # if the number of columns from the header does not match that in the data, but the rest of the file has\n # the same number of columns in each line this is not a fatal error, just parse the columns that are present\n if self._header_dict['sensors_per_cycle'] != self.num_columns:\n msg = 'sensors_per_cycle from header %d does not match the number of data label columns %d' % \\\n (self._header_dict['sensors_per_cycle'], self.num_columns)\n self._exception_callback(SampleException(msg))\n\n log.debug(\"Label count: %d\", self.num_columns)","def load_data(filename, use_labels=True):\n # load column 1 to 8 (ignore last one)\n data = np.loadtxt(open( filename), delimiter=',',\n usecols=range(1, 9), skiprows=1)\n if use_labels:\n labels = np.loadtxt(open( filename), delimiter=',',\n usecols=[0], skiprows=1)\n else:\n labels = np.zeros(data.shape[0])\n return labels, data","def load_data_and_labels(data_file, labels_file):\r\n x_text = []\r\n y = []\r\n \r\n with open(data_file, encoding = \"utf-8\") as csvFile:\r\n readCSV = csv.reader(csvFile, delimiter = \",\")\r\n for row in readCSV:\r\n row = \"\".join(row)\r\n x_text.append(row) \r\n \r\n with open(labels_file, encoding = \"utf-8\") as csvFile2:\r\n readCSV = csv.reader(csvFile2, delimiter = \",\")\r\n for row in readCSV:\r\n d = defaultdict(list)\r\n for k,va in [(v,i) for i,v in enumerate(row)]:\r\n d[k].append(va)\r\n \r\n for k in range(len(d.get(\"1.0\"))):\r\n index = d.get(\"1.0\")[k]\r\n row[index] = 1\r\n for k in range(len(d.get(\"0.0\"))):\r\n index = d.get(\"0.0\")[k]\r\n row[index] = 0\r\n \r\n# print(len(row))\r\n y.append(row)\r\n \r\n\r\n\r\n\r\n \r\n print(\"x = {}\".format(len(x_text)))\r\n print(\"y = {}\".format(len(y)))\r\n \r\n return x_text, y","def read_data(feature_file, label_file):","def load_data(self):\n with open(self.file_name) as f:\n lines = f.readlines()\n\n labels = list()\n all_dat = list()\n for i, l in enumerate(lines):\n\n labels.append(int(l[0]))\n\n l = gensim.utils.any2unicode(l)\n all_dat.append(LabeledSentence(l.split(\"\\t\")[-1], [i]))\n\n return all_dat, np.asarray(labels)","def load_labels(label_file) :\n df = pd.read_csv(label_file, index_col=\"p_index\",\n dtype=str, na_values=['nan', 'NaN', '']).dropna()\n\n return df","def load_test(data_file, labels=True, skip_rows=0):\n dat = iter_loadtxt(data_file, delimiter='\\t', skiprows=skip_rows)\n if labels:\n Dat = DataSet(images=dat[:, 0:-1], labels=dat[:, -1].astype(int), reshape=False)\n else:\n nrow = dat.shape[0]\n Dat = DataSet(images=dat, labels=np.full(nrow, np.nan), reshape=False)\n return Dat","def load_data(self):\n \n # only loader implemented so far !\n try:\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep='')\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\n\n _tof_column = _ascii_array[start_row:, 0]\n\n if not TOF._is_this_numeric(_tof_column[0]):\n start_row += 1\n\n _tof_column = _ascii_array[start_row:, 0]\n _counts_column = _ascii_array[start_row:, 1]\n\n self.tof_array = _tof_column\n self.counts_array = _counts_column\n return\n\n except IndexError:\n pass # try another format\n\n try:\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep=',')\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\n\n _tof_column = _ascii_array[start_row:, 0] # first row must be excluded in this format\n\n if not TOF._is_this_numeric(_tof_column[0]):\n start_row += 1\n\n _tof_column = _ascii_array[start_row:, 0]\n _counts_column = _ascii_array[start_row:, 1]\n\n self.tof_array = _tof_column\n self.counts_array = _counts_column\n return\n\n except IndexError:\n raise IndexError(\"Format not implemented!\")","def load_data_and_labels(data_file):\n # Load data from files\n obj = open(data_file, \"r\")\n y, x_text, query= [],[],[]\n for ele in obj:\n ele = ele.strip().split(\"\\t\")\n if len(ele) !=5 or ele[0].strip() not in [\"1\", \"-1\"]:\n #print ele\n continue\n if (ele[0].strip() == \"1\"):\n y.append([0])\n else:\n y.append([1])\n\n query_text = ele[1].strip().decode(\"utf8\")\n doc_text = ele[2].strip().decode(\"utf8\")\n x_text.append( \" \".join( jieba.cut(doc_text) ) )\n query.append( \" \".join( jieba.cut(query_text) ) )\n return [x_text, np.array(y), np.array(query)]","def load(self, filename) :\r\n \r\n # determine filename\r\n dir = os.path.dirname(__file__)\r\n f = os.path.join(dir, '..', 'data', filename)\r\n \r\n # load data\r\n with open(f, 'r') as fid :\r\n data = np.loadtxt(fid, delimiter=\",\")\r\n \r\n # separate features and labels\r\n self.X = data[:,:-1]\r\n self.y = data[:,-1]","def load(self, filename) :\n\n # determine filename\n dir = os.path.dirname('__file__')\n f = os.path.join(dir, '..', 'data', filename)\n\n # load data\n with open(f, 'r') as fid :\n data = np.loadtxt(fid, delimiter=\",\")\n\n # separate features and labels\n self.X = data[:,:-1]\n self.y = data[:,-1]","def load_data_file(data_file):\n print(\"Loading from {} ...\".format(data_file.name), end=\"\")\n text_col = \"news_title\"\n theme1_col = \"Q3 Theme1\"\n\n with open(data_file) as f:\n df = pd.read_csv(f, sep=\"\\t\")\n X = df[text_col].tolist()\n y = None\n if theme1_col in df.columns:\n y = df[theme1_col].tolist()\n\n print(\n \"loaded {} lines {} labels ... done\".format(\n len(X), \"with\" if y is not None else \"without\"\n )\n )\n\n print(len(X))\n print(len(y))\n return (X, y)","def load_file(filename):\n\tlabels = []\n\tdocs = []\n\n\twith open(filename) as f:\n\t\tfor line in f:\n\t\t\tcontent = line.split('\\t')\n\n\t\t\tif len(content) > 2:\n\t\t\t\tprint('incorrect read')\n\t\t\t\texit()\n\n\t\t\tif len(content[1]) == 0: continue\n\n\t\t\tdocs.append(str(content[1]).strip('\\r').strip('\\n').strip('\\r\\n'))\n\t\t\tlabels.append(content[0])\n\n\treturn docs, labels","def read_traindata (filename, labels = ['pos', 'neg']):\n def split (l):\n \"\"\"split one line into words and label\"\"\"\n segs = l.strip().split ('\\t')\n label = segs [-1]\n words = segs [:-1]\n return words, label\n \n encoding = chardet.detect(open (filename).read ()) ['encoding']\n \n with codecs.open (filename, 'r', encoding) as f:\n for line in f.readlines ():\n row = split (line)\n assert len (row) == 2\n assert isinstance(row [0], list)\n assert isinstance(row [1], basestring)\n print row [1]\n assert row [1] in labels\n yield row","def load_labels(self, labels):\n self.labels = pd.DataFrame(labels, index=[\"label\"]).T","def read_from(self, filename):\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))","def loader(filename,sep=',',rowskip=[], colskip=[], axis=1,names=1,fromstring=0):\n\n #manages excpetions to the csv file incase of missing data\n if (type(filename)==str) and (fromstring==1):\n iterable=filename.strip('\\n').split('\\n')\n content=np.array([i for i in csv.reader(iterable,delimiter=sep)])\n elif type(filename)==np.ndarray:\n content=filename\n else:\n content=np.array([i for i in\\\n csv.reader(open(filename,'r'),delimiter=sep)])\n #content=np.genfromtxt(filename,delimiter=sep,dtype=str)\n\n if rowskip:\n #rowskip.sort(reverse=True)\n content=np.delete(content,rowskip,0)\n #for i in rowskip: content.pop(i)\n\n if colskip:\n #colskip.sort(reverse=True)\n content=np.delete(content,colskip,1)\n #for i in colskip: content.pop(i)\n\n if axis==0: # if the file oriented column-wise\n #content=list(map(list,zip(*content)))\n content=content.T\n\n\n\n if names is 0:\n variables=np.arange(content.shape[1]).tolist()\n offset=0\n else:\n variables=content[0].tolist()\n offset=1\n\n try:\n content=np.array([conv_col(col) for col in\n content[offset:].T],dtype='object')\n arity=np.array([np.unique(i).size for i in content])\n return dataset(variables,content.T,arity)\n except ValueError: \n print( 'Data could not be loaded, failed converting to float.')\n return content","def read_data(filename):\n data = np.genfromtxt(filename, delimiter=',', dtype = str)\n X = data[1:,2:].astype(np.float)\n y = data[1:,0]\n y[y==label0]='0' \n y[y==label1]='1' \n y[y==label2]='2'\n y.astype(np.float) \n return X, y","def read_data(filename):\n data = np.genfromtxt(filename, delimiter=',', dtype=str)\n X = data[1:,2:].astype(np.float)\n y = data[1:,0]\n y[y==label0]='0'\n y[y==label1]='1'\n y[y==label2]='2'\n y=y.astype(np.float)\n return X, y","def load_data(self, dropna=False):\r\n # Load data, delete Ml index, get number of channels, add\r\n df = pd.read_csv(self.file_path, header=None, index_col=0, dtype='float64')\r\n\r\n cols = df.shape[1]\r\n if cols < 2:\r\n raise ValueError(f'{self} wrong file type.')\r\n\r\n df.columns = ['t'] + [f\"c{i}\" for i in range(1, cols)]\r\n df.index = df.index.astype(int)\r\n df.index.name = 'r'\r\n\r\n if dropna:\r\n df.dropna(axis=1, how='all', inplace=True)\r\n\r\n self.set_data(df)","def load_data_part(fname):\n if \"_data\" not in fname:\n return None\n # Read data\n data = pd.read_csv(fname)\n # events file\n events_fname = fname.replace('_data', '_events')\n # read event file\n labels = pd.read_csv(events_fname)\n clean = data.drop(['id'], axis=1) # remove id\n labels = labels.drop(['id'], axis=1) # remove id\n return clean, labels","def read_data(feats_file, labels_file, size=None):\n feats = np.loadtxt(feats_file)\n labels = np.loadtxt(labels_file, ndmin=2)\n if size:\n feats = feats[:size, :]\n labels = labels[:size, :]\n return np.concatenate((feats, labels), axis=1)","def load_data_and_labels():\n # Load data from files\n positive_examples = []\n for file in os.listdir('with_datarace'):\n filename = os.fsdecode(file)\n ast_file = open('with_datarace\\\\' + filename, 'r')\n token_vector = ast_file.read()\n positive_examples.append(token_vector)\n file_names.append(filename)\n\n negative_examples = []\n for file in os.listdir('without_datarace\\\\'):\n filename = os.fsdecode(file)\n ast_file = open('without_datarace\\\\' + filename, 'r')\n token_vector = ast_file.read()\n negative_examples.append(token_vector) # List of lists\n file_names.append(filename)\n\n positive_examples = [s.strip() for s in positive_examples]\n negative_examples = [s.strip() for s in negative_examples]\n\n # Split by words\n x_text = positive_examples + negative_examples # why we didn't cobine it from the beginning?\n x_text = [clean_str(sent) for sent in x_text]\n x_text = [s.split(\" \") for s in x_text]\n\n # Generate labels\n positive_labels = [[0, 1] for _ in positive_examples]\n negative_labels = [[1, 0] for _ in negative_examples]\n y = np.concatenate([positive_labels, negative_labels], 0)\n\n return [x_text, y]","def load_data_and_labels(data_file=train_file):\n \"\"\"\n There are 7 categories - \n 1. DEMO\n 2. DISE\n 3. TRMT\n 4. GOAL\n 5. PREG\n 6. FMLY\n 7. SOCL\n \"\"\"\n d = {}\n d['DEMO'] = [1, 0, 0, 0, 0, 0, 0]\n d['DISE'] = [0, 1, 0, 0, 0, 0, 0]\n d['TRMT'] = [0, 0, 1, 0, 0, 0, 0]\n d['GOAL'] = [0, 0, 0, 1, 0, 0, 0]\n d['PREG'] = [0, 0, 0, 0, 1, 0, 0]\n d['FAML'] = [0, 0, 0, 0, 0, 1, 0]\n d['SOCL'] = [0, 0, 0, 0, 0, 0, 1]\n\n max_len = -1\n\n #Load data from files\n samples = []\n with open(data_file, 'rb') as csvfile:\n spamreader = csv.reader(csvfile, delimiter='\\t', quotechar='|')\n for i, row in enumerate(spamreader):\n if (row[0] == \"Category\"):\n continue\n print (i, row[1])\n #samples.append([row[0], row[2]])\n #getting class and title = row[0] and row[1] respectively\n samples.append([row[1], row[2], row[0]])\n #split by words\n\n return samples","def read_labels(labels_path):\n with open(labels_path, 'r') as file:\n data = file.read()\n data = data.split()\n data = np.array(data)\n data = np.reshape(data, (-1, 2))\n return data","def load():\n filepath = dirname(abspath(__file__))\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\n data = recfromtxt(open(filepath + '/spector.csv',\"rb\"), delimiter=\" \",\n names=True, dtype=float, usecols=(1,2,3,4))\n names = list(data.dtype.names)\n endog = array(data[names[3]], dtype=float)\n endog_name = names[3]\n exog = column_stack(data[i] for i in names[:3]).astype(float)\n exog_name = names[:3]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def load_data_and_labels(filename, dataset_name,is_train):\n label_count={}\n parameter_file = \"./parameters.json\"\n params = json.loads(open(parameter_file).read())\n if dataset_name == 'ag_news' or dataset_name == 'dbpedia' or dataset_name == 'sogou_news' or dataset_name == 'amazon_review_full' or dataset_name == 'amazon_review_polarity' :\n df = pd.read_csv(filename, names=['label', 'title', 'text'], dtype={'title': object,'text': object})\n selected = ['label', 'title','text','too_short','to_drop']\n\n non_selected = list(set(df.columns) - set(selected))\n df = df.drop(non_selected, axis=1) # Drop non selected columns \n df['too_short']= df[selected[2]].apply(lambda x: (remove_short(x,params['min_length'])))\n df['too_short']=df['too_short'].replace('N/A',np.NaN)\n if is_train:\n df = df.dropna(axis=0, how='any') # Drop null rows \n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN)\n if is_train:\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\n for key,value in label_count.items():\n print(\"{} : {}\".format(key,value))\n # Map the actual labels to one hot labels\n labels = sorted(list(set(df[selected[0]].tolist())))\n one_hot = np.zeros((len(labels), len(labels)), int)\n np.fill_diagonal(one_hot, 1)\n label_dict = dict(zip(labels, one_hot))\n if params['use_summary']==1:\n x_raw = df[selected[2]].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\n else:\n x_raw = df[selected[2]].apply(lambda x: clean_str(x,params['max_length'])).tolist()\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\n \n elif dataset_name == 'yelp_review_full' or dataset_name == 'yelp_review_polarity':\n df = pd.read_csv(filename, names=['label','text'], dtype={'text': object})\n selected = ['label','text','too_short','to_drop']\n non_selected = list(set(df.columns) - set(selected))\n df = df.drop(non_selected, axis=1) # Drop non selected columns \n df['too_short']= df[selected[1]].apply(lambda x: (remove_short(x,params['min_length'])))\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \n if is_train:\n df = df.dropna(axis=0, how='any') # Drop null rows \n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \n if is_train:\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\n for key,value in label_count.items():\n print(\"{} : {}\".format(key,value))\n # Map the actual labels to one hot labels\n labels = sorted(list(set(df[selected[0]].tolist())))\n one_hot = np.zeros((len(labels), len(labels)), int)\n np.fill_diagonal(one_hot, 1)\n label_dict = dict(zip(labels, one_hot))\n if params['use_summary']==1:\n x_raw = df['text'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\n else:\n x_raw = df['text'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\n\n elif dataset_name == 'yahoo_answers':\n df = pd.read_csv(filename, names=['label', 'title', 'content','answer'], dtype={'title': object,'answer': object,'content': object})\n selected = ['label', 'title','content','answer','too_short','to_drop'] \n non_selected = list(set(df.columns) - set(selected))\n df = df.drop(non_selected, axis=1) # Drop non selected columns \n df['temp'] = df[['content','answer']].apply(lambda x: ' '.join(str(v) for v in x), axis=1)\n df['too_short']= df['temp'].apply(lambda x: (remove_short(x,params['min_length'])))\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \n if is_train:\n df = df.dropna(axis=0, how='any') # Drop null rows \n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \n if is_train:\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\n for key,value in label_count.items():\n print(\"{} : {}\".format(key,value))\n labels = sorted(list(set(df[selected[0]].tolist())))\n one_hot = np.zeros((len(labels), len(labels)), int)\n np.fill_diagonal(one_hot, 1)\n label_dict = dict(zip(labels, one_hot))\n if params['use_summary']==1:\n x_raw = df['temp'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\n else:\n x_raw = df['temp'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\n\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\n\n return x_raw, y_raw, df, labels","def load_labels(labels_dir, trial_name):\n labels_path = labels_dir + trial_name + \".txt\"\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\n converters=LABELS_CONVERTERS,\n usecols=LABELS_USECOLS)\n #print(\"rawlabelsdata: \", raw_labels_data)\n #print(get_first_frame(labels_path))\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\n #print(\"frames: \", frames)\n #print(frames.shape)\n #labels = np.zeros(frames.shape, dtype=np.int)\n labels1 = []\n #print(labels)\n for start, end, label in raw_labels_data:\n #mask = (frames >= start) & (frames <= end)\n #print(start)\n #print(end)\n i = start\n while(i<end):\n if(i%6 == 0):\n labels1.append(label)\n i = i+1\n\n #labels[mask] = label\n #print(\"labels[mask]: \",labels[mask])\n labels1 = np.array(labels1)\n #print(labels1)\n labels_data = labels1.reshape(-1,1)\n #print(labels1.shape)\n #print(\"labels: \", labels_data)\n \n return labels_data","def load_labels(path):\n with open(path, 'r', encoding='utf-8') as f:\n lines = f.readlines()\n labels = []\n for row_number, content in enumerate(lines):\n pair = re.split(r'[:\\s]+', content.strip(), maxsplit=1)\n #if len(pair) == 2 and pair[0].strip().isdigit():\n labels.append(np.array([int(pair[0].strip()),pair[1].strip()]))\n #else:\n # labels.append(pair[0].strip())\n return np.array(labels)","def read_label_file(self, label_file_name = None): #completed\n if label_file_name is None:\n label_file_name = self.label_file_name\n try:\n label_data = sp.loadmat(label_file_name)['labels'].astype(np.int32)\n return label_data#[:,1], label_data[:,0]#in MATLAB format\n except IOError:\n print \"Unable to open \", label_file_name, \"... Exiting now\"\n sys.exit()","def load_data_file(data_file):\n print(\"Loading from {} ...\".format(data_file.name), end=\"\")\n text_col = \"news_title\"\n theme1_col = \"Q3 Theme1\"\n\n with open(data_file, encoding=\"utf8\") as f:\n df = pd.read_csv(f, sep=\"\\t\")\n X = df[text_col].tolist()\n\n y = None\n if theme1_col in df.columns:\n y = df[theme1_col].tolist()\n\n print(\n \"loaded {} lines {} labels ... done\".format(\n len(X), \"with\" if y is not None else \"without\"\n )\n )\n return (X, y)","def load_file(self, dset_type):\r\n path = './data/{0}.{1}'.format(self.name, dset_type)\r\n try:\r\n file_contents = np.genfromtxt(path, missing_values=0, skip_header=0,\r\n dtype=int, delimiter=\",\")\r\n self.labels[dset_type] = file_contents[:, 0]\r\n self.examples[dset_type] = file_contents[:, 1:]\r\n\r\n except RuntimeError:\r\n print('ERROR: Unable to load file ''{0}''. Check path and try again.'.format(path))","def load_test_data(label_fname, data_fname):\n labels = load_csv(label_fname)\n data = load_csv(data_fname, 'excel-tab')\n\n # Join all data together on the ids given in the files\n joined_data = {}\n for label in labels:\n id = label[0]\n joined_data[id] = {'class': label[1]}\n for rec in data:\n id = rec[0]\n if id in joined_data:\n joined_data[id]['data'] = rec[1]\n\n # Clean and convert the data to reals\n max_features = 0\n for id in joined_data:\n words = clean_text(joined_data[id]['data'])\n reals = convert_to_reals(words)\n joined_data[id]['data'] = reals\n if len(reals) > max_features:\n max_features = len(reals)\n\n # Pad the data\n for id in joined_data:\n reals = joined_data[id]['data']\n joined_data[id]['data'] = reals + (max_features - len(reals)) * [0.0]\n\n # Prepare the data for training\n training_data = np.array([joined_data[id]['data'] for id in joined_data])\n training_labels = [joined_data[id]['class'] == 'OFF' for id in joined_data]\n return training_labels, training_data, max_features","def load_label_columns(self):\n with open(self.config.labels_local_path, 'r') as f:\n label_columns = yaml.safe_load(f)\n return label_columns","def labels(labels_file, labels = []):\n\n print(f\"Parsing labels '{labels_file}'\")\n with open(labels_file, 'r') as f:\n for i, line in enumerate(f):\n labels.append(line.split(':')[-1].strip())\n return pd.Series(labels)","def load_data(filename):\n\n evidance = list()\n labels = list()\n row = list()\n\n with open(filename) as file:\n for j, item in enumerate(file):\n if(j == 0):\n continue\n row = []\n for i, el in enumerate(item.split(',')):\n # print(el)\n if(i in {0,2,4,11,12,13,14}):\n row.append(int(el))\n elif(i in {1,3,5,6,7,8,9}):\n row.append(float(el))\n elif(i==10):\n if(el == \"Jan\"):\n row.append(int(0))\n elif(el == \"Feb\"): \n row.append(int(1))\n elif(el == \"Mar\"): \n row.append(int(2))\n elif(el == \"Apr\"): \n row.append(int(3))\n elif(el == \"May\"): \n row.append(int(4))\n elif(el == \"June\"): \n row.append(int(5))\n elif(el == \"Jul\"): \n row.append(int(6))\n elif(el == \"Aug\"): \n row.append(int(7))\n elif(el == \"Sep\"): \n row.append(int(8))\n elif(el == \"Oct\"): \n row.append(int(9))\n elif(el == \"Nov\"): \n row.append(int(10))\n elif(el == \"Dec\"): \n row.append(int(11))\n else:\n print(\"wrong month Exit\")\n quit()\n elif(i==15):\n if(el == 'Returning_Visitor'):\n row.append(int(1))\n else:\n row.append(int(0))\n elif(i==16):\n if(el == 'TRUE'):\n row.append(int(1))\n else:\n row.append(int(0)) \n elif(i==17):\n if(el == 'TRUE\\n' or el == 'TRUE'):\n row.append(int(1))\n else:\n row.append(int(0))\n else:\n print(\"Incorrect value\")\n\n evidance.append(row)\n # print(item.split(',')[-1])\n if(item.split(',')[-1] == 'FALSE\\n'):\n labels.append(0)\n else:\n labels.append(1)\n\n # print(labels)\n return (evidance, labels)","def parse_labels(file: str) -> ndarray:\n rows = []\n with open(file, 'r', encoding='utf-8') as f:\n for row in f:\n rows.append(row.strip())\n return array(rows)","def load_samples_and_labels(data_path, header=True, col=1, train=True):\n if header:\n start_index = 1\n else:\n start_index = 0\n\n with open(data_path, 'r', encoding='utf-8') as f:\n lines = f.read().splitlines()[start_index:]\n samples = [line.split(',')[col] for line in lines]\n samples = [sample.split() for sample in samples]\n\n if train:\n labels = [int(line.split(',')[3]) for line in lines]\n else:\n labels = []\n\n return samples, labels","def load_data_set(filename):\n\n input_file = open(filename)\n\n num_features = len(input_file.readline().split('\\t')) - 1\n input_file.seek(0)\n data_mat = []\n label_mat = []\n\n for line in input_file.readlines():\n line_arr = []\n curr_line = line.strip().split('\\t')\n for i in range(num_features):\n line_arr.append(float(curr_line[i]))\n data_mat.append(line_arr)\n label_mat.append(float(curr_line[-1]))\n\n return data_mat, label_mat","def read_data(path):\n with h5py.File(path, 'r') as hf:\n data = np.array(hf.get('data'))\n label = np.array(hf.get('label'))\n\n data, label=data[:,:,:,0:2], label[:,:,:,0]\n #data=np.expand_dims(data,axis=-1)\n label=np.expand_dims(label,axis=-1)\n\n return data, label","def load_labels(path):\n with open(path, \"r\", encoding=\"utf-8\") as f:\n lines = f.readlines()\n labels = {}\n for row_number, content in enumerate(lines):\n pair = re.split(r\"[:\\s]+\", content.strip(), maxsplit=1)\n if len(pair) == 2 and pair[0].strip().isdigit():\n labels[int(pair[0])] = pair[1].strip()\n else:\n labels[row_number] = pair[0].strip()\n # print(labels)\n return labels","def read_from_file(self,fn):\n fh = open(fn,\"r\")\n labels = []\n xyz = []\n sizes = []\n colors = []\n for line in fh.readlines():\n try:\n if not line.startswith(\"#\"):\n label,x,y,z,size,r,g,b = line.split(\",\")\n labels.append(label)\n xyz.append([x,y,z])\n sizes.append(size)\n colors.append((float(r),float(g),float(b)))\n except IOError, ioe:\n print \"IOError:\", ioe\n self._labels = np.array(labels)\n self._xyz = np.array(xyz).astype(\"f\")\n self._sizes = np.array(sizes).astype(\"f\")\n self._colors = np.array(colors)","def load():\n filepath = dirname(abspath(__file__))\n data = recfromtxt(filepath + '/scotvote.csv', delimiter=\",\",\n names=True, dtype=float, usecols=(1,2,3,4,5,6,7,8))\n names = list(data.dtype.names)\n endog = array(data[names[0]], dtype=float)\n endog_name = names[0]\n exog = column_stack(data[i] for i in names[1:]).astype(float)\n exog_name = names[1:]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def load_tfile_data(self, path, start=None, stop=None, dss=28):\n filename = path+\".\"+str(int(self.name))\n datafile = open(filename,\"r\")\n labels = datafile.readline().strip().split()\n logger.debug(\"load_tfile_data: labels: %s\", labels)\n datafile.close()\n labels.insert(0,'DOY')\n labels.insert(0,'Year')\n logger.debug(\"load_tfile_data: new labels: %s\", labels)\n \n # colums are: Year DOY UTC Epoch Chan Tsys Int Az El Diode Level CryoTemp\n # i4 i4 S8 f8 S2 f4 f4 f4 f4 i4 f4 f4\n data = numpy.loadtxt(filename,skiprows=1,\n dtype = {'names': tuple(labels),\n 'formats': ('i4','i4','S8','f8',\n 'S2','f4','f4','f4','f4','i4','f4', 'f4')})\n return data","def load_labels(filename):\n\n file_path = os.path.join(DATA_DIR, filename)\n with open(file_path, 'rb') as f:\n b = f.read()\n\n magic, n_labels = (struct.unpack('>i', b[i*4:(i+1)*4]) for i in range(2))\n\n assert magic[0] == 2049, \"bad magic number, what do?\"\n\n label_stream = array.array('B', b[8:])\n \n assert len(label_stream) == n_labels[0], \"mismatch in label length\"\n \n # label_stream is actually type array.array, which is iterable surely.\n # i'll convert it anyway...\n return tuple(label_stream)","def loadDataFromFile(self, filename, axis=0):\n # Load\n file = \"/Users/Septien/Documents/Tesis/code/data/\" + filename + \".data\"\n with open(file) as dataFile:\n for line in dataFile:\n row = line.split(\",\")\n self.numAxes = len(row)\n d = row[axis]\n if (d != '?'):\n self.data.append(float(d))\n # Sort for further computation\n self.data.sort()\n # Get the range\n self.xAxisRange = [self.data[0], self.data[-1]]","def _read_train_datas(self):\r\n with open(self.train_label_path, 'r') as fb:\r\n lines = fb.readlines()\r\n return self._parse_raw_labels(lines)","def read_data(data_path, filename,feature_number):\n\n with open(data_path + \"/\" + filename, 'r', encoding='utf-8-sig') as f: \n X = np.genfromtxt(f, delimiter=',')[:,0:feature_number]\n\n\n # Last column of datafile contains output labels\n Y = np.genfromtxt(data_path + \"/\" + filename,delimiter=\",\")[:,feature_number]\n Y = Y.reshape(X.shape[0])\n\n return X,Y","def load_labeled_data(files):\n\tx = []\n\ty = []\n\tfor filename in files:\n\t\tdata = []\n\t\twith open(filename) as infile:\n\t\t\tlabel = int(infile.readline())\n\t\t\tfor line in infile:\t\n\t\t\t\tdata.append(dna_string_to_array(line.strip()))\n\t\ty += [label]*len(data)\n\t\tx += data\n\n\treturn (np.array(x), np.array(y))","def load_data(self):\n print(\"Loading dataset...\")\n # Load the dataset\n subIDs, data, labels = dl.load_processed_data_N_subjects_allchans(\n '../data_5sec_100Hz_bipolar/', Nsub=14)\n\n if len(data) > 1:\n\n # If more than one patient loaded, append data to single array\n data_arr = np.array(data[0])\n label_arr = labels[0]\n\n for sub in range(1, len(data)):\n data_arr = np.append(data_arr, data[sub], axis=1)\n label_arr = np.append(label_arr, labels[sub], axis=0)\n\n else:\n # Remove the extra dimension at axis=0\n data_array = np.squeeze(data)\n labels = np.squeeze(labels)\n\n # Move trials to the end so data array is 'nchan x timeseries x trials'\n self.data = np.moveaxis(data_arr, 1, -1)\n self.labels = np.array(label_arr)\n\n self.label_strings = dl.available_stringlabels\n\n valid_indices = np.sum(self.labels, axis=0)\n names = [[self.label_strings[i], i, valid_indices[i]] for i in range(len(valid_indices)) if valid_indices[i] > 0]\n print(\"A summary of valid labels is below: \\nFormat: [Label name, label index, Label count]\")\n for i in range(len(names)):\n print(names[i])\n return","def loadData( self, fileName, colClass, feaRowStart = None, \n feaRowEnd = None, delimiter=','):\n self.dF = pd.read_csv( fileName, delimiter = delimiter)\n if feaRowStart is not None and feaRowEnd is not None:\n self.feature = self.dF.iloc[feaRowStart:feaRowEnd, 0:colClass-1]\n self.Class = self.dF.loc[feaRowStart:feaRowEnd, colClass]\n else:\n self.feature = self.dF.iloc[:,1:29]\n self.Class = self.dF.Class \n #self.feature = self.dF.iloc[:, 0:self.dF.shape[1]-1]\n #self.Class = self.dF.loc[:, self.dF.shape[1]-1:self.dF.shape[1]] \n \n self.dataConvertToNumpy()","def load_data(fname, skip_header=0, delimiter=','):\n\n data = np.genfromtxt(fname, dtype=str, comments=None, delimiter=delimiter, skip_header=skip_header)\n\n pathes = data[:, 0]\n labels = data[:, 1]\n\n return pathes, labels","def load_data(self):\n filename = filedialog.askopenfilename(title=\"Select A File\",\n file=((\"csv files\", \"*.csv\"),\n (\"dat files\", \"*.dat\"),\n (\"excel files\", \"*.xlsx\"),\n (\"All Files\", \"*.*\")))\n file_path = filename\n try:\n filename = f\"{file_path}\"\n name = os.path.splitext(os.path.basename(filename))[0]\n if name in ['h2o', 'KED', 'financial']:\n DataLoader.data = load_data(name)\n else:\n DataLoader.data = pd.read_csv(filename)\n except ValueError:\n messagebox.showerror(\"Information\", \"The file you have chosen is invalid.\")\n except FileNotFoundError:\n messagebox.showerror(\"Information\", f\"No such file as {file_path}\")\n self.clear_tree()\n\n self.treeview['columns'] = list(DataLoader.data.columns)\n for i in self.treeview['columns']:\n self.treeview.column(i, anchor=\"w\")\n self.treeview.heading(i, text=i, anchor='w')\n\n for index, row in DataLoader.data.iterrows():\n self.treeview.insert(\"\", 0, text=self.data.shape[0] - 1 - index, values=list(row))\n self.treeview.column('#0', width=100)\n\n self.summary_label = ttk.Label(self, text=f'Data shape: {DataLoader.data.shape}', width=40)\n self.summary_label.grid(row=2, column=0, columnspan=2, sticky=tk.S + tk.N)","def __row_loading(self, filename=None, PC=-1, top=50, bot=50, label_key=None, all=False, **kargs):\n assert not self.rowwise, \"loading(): You probably don't mean to use this when rowwise=True\"\n assert PC >= 0, \"loading(): PC of <1 specified\"\n \n if \"aspect\" not in kargs:\n kargs[\"aspect\"] = \"long\"\n \n data = self.__u[:,PC]\n labs = self.parent[label_key]\n packed_data = [{label_key: i[0], \"l\": i[1]} for i in zip(labs, data)]\n \n sorted_data = sorted(packed_data, key=itemgetter(\"l\"))\n data = [i[\"l\"] for i in sorted_data]\n labs = [i[label_key] for i in sorted_data]\n \n if all:\n data = data\n labs = labs\n else:\n if bot > 0 and top > 0: # data[-0:] returns the entire list and data[0:0] returns [] !\n data = data[0:top] + data[-bot:]\n labs = labs[0:top] + labs[-bot:]\n elif top > 0:\n data = data[0:top]\n labs = labs[0:top] \n elif bot > 0:\n data = data[-bot:]\n labs = labs[-bot:] \n \n if filename:\n fig = self.__draw.getfigure(**kargs)\n ax = fig.add_subplot(111)\n ax.set_position([0.3,0.03,0.6,0.96])\n \n x = numpy.arange(len(data))\n ax.barh(x-0.4, data, ec=\"black\", color=\"grey\")\n ax.set_ylabel(\"Rows\")\n ax.set_xlabel(\"Loading\")\n ax.set_yticklabels(labs)\n ax.set_yticks(x)\n ax.set_ylim([-0.5, len(data)-0.5])\n [t.set_fontsize(6) for t in ax.get_yticklabels()]\n \n self.__draw.do_common_args(ax, **kargs)\n real_filename = self.__draw.savefigure(fig, filename)\n \n config.log.info(\"loading(): Saved PC loading '%s'\" % real_filename)\n \n # work out the list to return\n newgl = genelist()\n newgl.load_list([{label_key: i[0], \"pc_loading\": i[1]} for i in zip(labs, data)]) # relist it so that top bot are used\n newexpn = newgl.map(genelist=self.parent, key=label_key, greedy=False)\n newexpn.sort(\"pc_loading\")\n return(newexpn)","def load_data(self) -> tuple:\n label_num = {}\n data_set = pathlib.Path(self.path)\n data = []\n\n # create the label lookup dict for verifcation later\n for i, v in enumerate(data_set.iterdir()):\n label_num[v.name] = i\n self.labels[i] = v.name\n # end\n\n # read images\n for img_path in data_set.rglob(\"*.jpg\"):\n lbl = label_num[str(img_path.parent.stem)]\n img = cv2.imread(str(img_path))\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\n\n # flatten RGB data into a vector\n # NOTE: NOT ACTUALLY NECESSARY! \n img.flatten()\n\n # label the sample and append to temp data list\n sample = np.append(lbl, img)\n data.append(sample)\n # end\n\n # partition and package the data (*_ ensures safe unpacking)\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\n self.train = Data(train)\n self.test = Data(test)\n self.validate = Data(validate)","def get_labeled_data(filename):\n e = []\n y = []\n with open(filename) as f:\n for line in f:\n e.append(line[1:-1])\n y.append(category_mapping[abbreviation_mapping[line[0]]])\n return e, y","def loadTestData():\n path = raw_input(\"Enter the path of Test Data: \")\n data = np.genfromtxt(path, delimiter=',', dtype=int)\n\n labels = data[:, -1]\n\n unwantedLabels = [4, 5, 6, 7, 8, 9]\n listToDelete = []\n for i, line in enumerate(range(len(data))):\n if labels[i] in unwantedLabels:\n listToDelete.append(i)\n\n actualData = np.delete(data, listToDelete, axis=0)\n\n # print(actualData.shape)\n # Separating the labels and data into different arrays\n actualLabels = actualData[:, -1]\n actualData = actualData[:, :-1]\n\n actualData = pre.scale(actualData)\n\n # Change the label vector to label matrix\n # If Label is 2 then it becomes [0, 1, 0]\n labelMatrix = np.zeros((actualLabels.shape[0], 4))\n for j in range(len(actualLabels)):\n if actualLabels[j] == 0:\n labelMatrix[j][0] = 1\n if actualLabels[j] == 1:\n labelMatrix[j][1] = 1\n if actualLabels[j] == 2:\n labelMatrix[j][2] = 1\n if actualLabels[j] == 3:\n labelMatrix[j][3] = 1\n\n return actualData, actualLabels","def data_parser(data):\n\n with open(data, 'r') as inp:\n\n # take every sample\n # the last line in the text file is empty, so reading until -1\n samples = inp.read().split('\\n')[:-1]\n\n vec = []\n labels = []\n for sample in samples:\n # file is tab delimited\n split_samples = sample.split('\\t')\n # last column contains the label\n labels.append(int(split_samples[-1]))\n\n features = []\n for feature in split_samples[:-1]:\n features.append(float(feature))\n vec.append(features)\n\n # make the features and labels as a numpy array\n vec = np.array(vec)\n labels = np.array(labels)\n return vec, labels","def readfile(self, path, filename):\n # The DataStudio software uses ISO-8859-1 encoding (especially for the degree sign in temperature files)\n file = open(path + filename, encoding=\"iso-8859-1\")\n rowlist = file.readlines()\n\n title = rowlist[0].strip(\"\\n\")\n labels = rowlist[1].strip(\"\\n\").split(sep=\"\\t\")\n\n data = np.zeros((len(rowlist)-2, 2))\n\n for i in range(2, len(rowlist)):\n columns = rowlist[i].split(sep=\"\\t\")\n data[i-2, 0] = float(columns[0].replace(\",\", \".\"))\n data[i-2, 1] = float(columns[1].replace(\",\", \".\"))\n\n return data, title, labels","def LoadLabels(filepath):\n with open(filepath, 'r') as datafile:\n lines = [line.strip() for line in datafile.readlines()]\n # filter for empty lines\n return [line for line in lines if line]","def load_labels(label_path):\r\n\r\n with open(label_path, \"r\") as f:\r\n\r\n lines = f.readlines()\r\n \r\n label = {}\r\n index = []\r\n for i, line in enumerate(lines):\r\n sp = line.split()\r\n label[sp[0]] = [int(sp[1]),int(sp[2]),int(sp[3])]\r\n index.append([int(sp[3]),int(sp[2]),int(sp[1])])\r\n\r\n return label, index","def load_batch(fpath, label_key='labels'):\n f = open(fpath, 'rb')\n if sys.version_info < (3,):\n d = cPickle.load(f)\n else:\n d = cPickle.load(f, encoding='bytes')\n # decode utf8\n d_decoded = {}\n for k, v in d.items():\n d_decoded[k.decode('utf8')] = v\n d = d_decoded\n f.close()\n data = d['data']\n labels = d[label_key]\n\n data = data.reshape(data.shape[0], 3, 32, 32)\n return data, labels","def readBMdata(self, filename=None):\n if filename == None:\n filename = self.ifilename\n\n try:\n ifile = open(filename, 'r')\n except IOError:\n raise IOError('cannot find: %s. Either put the file in the working directory or fix the input file.' % filename)\n\n self.t = []\n self.b = []\n self.h = []\n self.m = []\n\n max_ic = max( self.ic_t, self.ic_b, self.ic_h, self.ic_m )\n i_line = 0\n for line in ifile:\n i_line += 1\n if (i_line < self.start_line):\n continue\n\n data = line.strip().split()\n if len(data) <= max_ic:\n raise IOError('Not enough collumns in %s based on input information.' % filename)\n\n if self.ic_t >= 0:\n self.t.append( float( data[self.ic_t] ) * self.t_conversion)\n if self.ic_b >= 0:\n self.b.append( float( data[self.ic_b] ))\n if self.ic_h >= 0:\n self.h.append( float( data[self.ic_h] ))\n if self.ic_m >= 0:\n self.m.append( float( data[self.ic_m] ))\n\n ifile.close()","def _read(self, source, label_source=None):\n filename = os.path.join(\"data\", \"sources\", source+\".csv\")\n if label_source is None:\n label_filename = os.path.join(\"data\", \"labels\", source + \".columnmap.txt\")\n else:\n label_filename = os.path.join(\"data\", \"labels\", label_source)\n df = pd.read_csv(filename, dtype=str) # read the data source as a DataFrame\n # labels = pd.read_csv(label_filename) # read the semantic labels of columns in df\n\n labels_frame = pd.read_csv(label_filename, na_values=[\"\"], dtype={'column_name': 'str'})\n # dictionary (column_name, class_label)\n labels = labels_frame[['column_name', 'semantic_type']].dropna().set_index('column_name')['semantic_type'].to_dict()\n # logging.info(\"labels:{}\".format(labels))\n\n source_cols = []\n for c in df.columns:\n # label = str(labels.get_value(labels[labels['column_name'] == c].index[0], 'semantic_type')) # extract semantic label of column c\n if c in labels:\n label = labels[c]\n else:\n label = 'unknown'\n col = Column(filename=filename, colname=c, title=label, lines=list(df[c]))\n source_cols.append(col)\n\n return source_cols","def load_input(self, number_of_rows_to_read):\n self.dataframe = pandas.read_csv(self.filename, nrows=number_of_rows_to_read)\n #self._describe_input_data()","def load_data_multilabel(traning_data_path,vocab_word2index, vocab_label2index,sentence_len,training_portion=0.95):\n file_object = codecs.open(traning_data_path, mode='r', encoding='utf-8')\n lines = file_object.readlines()\n random.shuffle(lines)\n label_size=len(vocab_label2index)\n X = []\n Y = []\n for i,line in enumerate(lines):\n raw_list = line.strip().split(\"__label__\")\n input_list = raw_list[0].strip().split(\" \")\n input_list = [x.strip().replace(\" \", \"\") for x in input_list if x != '']\n x=[vocab_word2index.get(x,UNK_ID) for x in input_list]\n label_list = raw_list[1:]\n label_list=[l.strip().replace(\" \", \"\") for l in label_list if l != '']\n label_list=[vocab_label2index[label] for label in label_list]\n y=transform_multilabel_as_multihot(label_list,label_size)\n X.append(x)\n Y.append(y)\n if i<10:print(i,\"line:\",line)\n\n X = pad_sequences(X, maxlen=sentence_len, value=0.) # padding to max length\n number_examples = len(lines)\n training_number=int(training_portion* number_examples)\n train = (X[0:training_number], Y[0:training_number])\n\n test_number=int((number_examples-training_number)/2)\n\n\n test = (X[training_number+ 1:training_number+test_number], Y[training_number + 1:training_number+test_number])\n valid = (X[training_number + test_number + 1:],\n Y[training_number + test_number + 1:])\n\n return train,test,valid","def load_dataset(filename):\n return [(\n lambda point: {\n 'coordinate': tuple(map(float, point[:-1])),\n 'label': int(point[-1])})\n (string.strip().rstrip().split(','))\n for string in open(filename, 'r').read()\n .strip().rstrip().split('\\n')]","def load_data(file_name):\r\n with open(str(file_name)) as f:\r\n file = f.readlines()\r\n label = file[0].strip().split(\",\")[1:-1]\r\n file = file[1:]\r\n row = len(file)\r\n col = len(file[0].strip().split(\",\"))-1\r\n mat = np.zeros((row, col))\r\n for i in range(len(file)):\r\n row = file[i].strip()\r\n cols = row.split(\",\")[1:]\r\n for j in range(len(cols)):\r\n mat[i][j] = int(cols[j])\r\n np.random.seed(10)\r\n np.random.shuffle(mat)\r\n X = mat[:, 0:-1]\r\n y = mat[:, -1]\r\n\r\n return X, y, label","def _load_data(self):\n\n path_data_x = \\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_feature_data' \\\n '.csv'\n path_data_y = \\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_label_data' \\\n '.csv'\n path_meta = '/workspace/base-ml/data/tadpole' \\\n '/adni_one_baseline_meta_data' \\\n '.csv'\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y) # 0 NL, 1, MCI, 2 Dementia\n read_data_meta = pd.read_csv(path_meta)[['AGE', 'PTGENDER', 'APOE4']]\n\n # Replace gender to numeric\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Male', 0)\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Female', 1)\n\n new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n # Concat meta-information with feature vector input\n concat_meta = pd.DataFrame(new_data_meta)\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(0, 'zero')\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(1, 'one')\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(2, 'two')\n concat_meta = concat_meta.to_numpy()\n new_data_x = np.concatenate([concat_meta, new_data_x], 1)\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n self.orig_column_names = ['Age', 'Gender', 'APOE4'] + \\\n list(read_data_x.columns)\n self.data_x = new_data_x\n self.data_y = self.to_one_hot_encoding(new_data_y)\n self.numerical_idx = np.arange(new_data_x.shape[-1])\n self.numerical_idx = np.delete(self.numerical_idx, [2]) # Remove APOE column idx\n self.non_num_idx = np.array([2])\n self.all_non_numerical_idx = None\n\n # self.numerical_idx = np.arange(self.data_x.shape[-1])\n # self.non_num_idx = None\n # self.all_non_numerical_idx = None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32')\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def _load_data(self):\n\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\n self.task_num\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\n\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y)\n read_data_meta = pd.read_csv(path_meta)\n\n # Drop columns if it only contains 1 unique element\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\n\n num_col = pd.read_csv(path_numerical_columns)\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\n col_idx = np.arange(read_data_x.shape[-1])\n non_num_col = np.setdiff1d(col_idx, num_col)\n\n # new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_x = np.array(read_data_x)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n\n # Winsorize dataset\n len_feat = new_data_x.shape[-1]\n idx_list = list(num_col)\n for i in range(len_feat):\n if i in idx_list:\n cur_data = new_data_x[:, i]\n cur_data = np.array(cur_data)\n lower_p = np.percentile(cur_data, 5)\n higher_p = np.percentile(cur_data, 95)\n cur_data[cur_data < lower_p] = lower_p\n cur_data[cur_data > higher_p] = higher_p\n new_data_x[:, i] = cur_data\n\n # Make sure target data is one-hot encoded\n if new_data_y.shape[-1] == 1:\n num_class = len(np.unique(new_data_y))\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\n new_data_y = new_data_y.astype('float32')\n self.orig_column_names = read_data_x.columns\n self.data_x = new_data_x # N x F\n self.data_y = new_data_y # N x C\n self.numerical_idx = num_col # list of idx\n self.non_num_idx = non_num_col # None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32') # N x 3\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def load_data(filename):\r\n with open(filename,'rb') as f:\r\n data = pk.load(f,encoding='bytes')\r\n return data[b'data'],data[b'labels']","def load_tagged_data(filename, desc_col, alphabet, char_seq_length, ispickle=True, **kwargs):\n logger = logging.getLogger(__name__)\n logger.info(\"Reading data file\")\n \n if ispickle:\n with open(filename, 'rb') as f:\n df = pickle.load(f, encoding='UTF-8')\n \n else:\n if \"sep\" in kwargs:\n sep = kwargs[\"sep\"]\n else:\n sep = ','\n df = pd.read_csv(filename, sep=sep)\n \n logger.info(\"number of rows in file {}\".format(df.shape[0]))\n df.columns = [col.lower() for col in df.columns]\n \n # Map the actual labels to one hot labels\n labels = sorted(df['res_category'].unique())\n logger.info(\"numbers of distinct categories value {}\".format(len(labels)))\n one_hot = np.zeros((len(labels), len(labels)), int)\n np.fill_diagonal(one_hot, 1)\n label_dict = dict(zip(labels, one_hot))\n\n # converting labels to one hot encoded values\n y_raw = df['res_category'].apply(lambda y: label_dict[y]).tolist()\n \n x_raw = df[desc_col]\n x_raw = x_raw.apply(lambda x: str(x))\n logging.info(\"applying padding\")\n x_raw = [pad_sentence(x, char_seq_length) for x in x_raw]\n\n alphabet_to_int = {}\n\n for i, char in enumerate(alphabet):\n alphabet_to_int[char] = i\n\n logging.info(\"converting to int\")\n x_raw = [string_to_int8_conversion(x, alphabet_to_int) for x in x_raw]\n\n #logging.info(\"converting character sequences to one-hot vectors for cnn input\")\n #x_raw = [get_one_hot(x, alphabet, char_seq_length) for x in x_raw]\n\n logging.info(\"data loading complete\")\n return x_raw, y_raw, labels","def load_training_data(fname):\n all_data = load_csv(fname, 'excel-tab')\n\n labels = [rec[2] == 'OFF' for rec in all_data]\n data = [convert_to_reals(clean_text(rec[1])) for rec in all_data]\n max_features = max([len(rec) for rec in data])\n\n # Pad the data\n for rec in data:\n rec.extend([0.0] * (max_features - len(rec)))\n\n return labels, data, max_features","def load_data_multilabel(traning_data_path,vocab_word2index, vocab_label2index,sentence_len,training_portion=0.95):\n file_object = codecs.open(traning_data_path, mode='r', encoding='utf-8')\n lines = file_object.readlines()\n random.shuffle(lines)\n label_size=len(vocab_label2index)\n X = []\n Y = []\n for i,line in enumerate(lines):\n raw_list = line.strip().split(\"__label__\")\n input_list = raw_list[0].strip().split(\" \")\n input_list = [x.strip().replace(\" \", \"\") for x in input_list if x != '']\n x=[vocab_word2index.get(x,UNK_ID) for x in input_list]\n label_list = raw_list[1:]\n label_list=[l.strip().replace(\" \", \"\") for l in label_list if l != '']\n label_list=[vocab_label2index[label] for label in label_list]\n y=transform_multilabel_as_multihot(label_list,label_size)\n X.append(x)\n Y.append(y)\n if i<10:print(i,\"line:\",line)\n\n X = pad_sequences(X, maxlen=sentence_len, value=0.) # padding to max length\n number_examples = len(lines)\n training_number=int(training_portion* number_examples)\n train = (X[0:training_number], Y[0:training_number])\n valid_number=min(1000,number_examples-training_number)\n test = (X[training_number+ 1:training_number+valid_number+1], Y[training_number + 1:training_number+valid_number+1])\n return train,test","def load_expected(filename):\n\n all_labels = sorted([int(k) for k in open(filename).readline().split()[1:]])\n data = numpy.loadtxt(filename, dtype='float64', skiprows=1)\n return all_labels, data[:,0].astype('int64'), data[:,1:]","def from_label_file(cls, label_file_path, out_path=FEATURES_DATA_PATH, source_path=RAW_DATA_PATH):\n df = pd.read_csv(label_file_path)\n filenames = df['filename']\n labels = df['label']\n return cls(filenames, labels, out_path=out_path, source_path=source_path)","def load_data():\r\n global labelNames\r\n print(\"Loading Data...\")\r\n\r\n fnpath = \"rawdata\\\\cifar-10-batches-py\"\r\n fnprefix = 'data_batch_'\r\n fnlblnames = 'batches.meta'\r\n fntstbatch = 'test_batch'\r\n\r\n labelNames = unpickle(path.join(fnpath, fnlblnames))\r\n label_names = []\r\n for label in labelNames['label_names']:\r\n label_names.append(\"\".join(map(chr, label)))\r\n labelNames['label_names'] = label_names\r\n\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\r\n for n in range(1, 6):\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))","def load_dataset(filepath):\n \n X = list()\n x = list()\n\n Y = list()\n y = list()\n \n for line in open(filepath):\n # blank lines separate sequences\n if len(line) <= 1:\n X.append(x)\n Y.append(y)\n\n x = list()\n y = list()\n else:\n a, b = line.strip().split('\\t')\n x.append(a)\n y.append(b)\n \n return X, Y","def read_data(self,filename):\n self.x = [] #Input values\n self.t = [] #Target values\n\n with open(filename, \"r\") as infile:\n lines = infile.readlines()\n self.n = len(lines)\n for line in lines:\n words = line.split()\n self.x.append(float(words[0]))\n self.t.append(float(words[1]))\n\n self.x = np.array(self.x)\n self.t = np.array(self.t)\n self.create_design_matrix()","def load_labels(path):\n with open(path, 'r', encoding='utf-8') as f:\n lines = f.readlines()\n labels = {}\n for row_number, content in enumerate(lines):\n pair = re.split(r'[:\\s]+', content.strip(), maxsplit=1)\n if len(pair) == 2 and pair[0].strip().isdigit():\n labels[int(pair[0])] = pair[1].strip()\n else:\n labels[row_number] = pair[0].strip()\n return labels","def load_data():\n x = np.genfromtxt(X_FILE, usecols=(0, 1))\n y = np.genfromtxt(Y_FILE, usecols=(0))\n\n return x, y","def read_label(filepath, read_scalars=False):\n label_array = np.loadtxt(filepath, dtype=np.int, skiprows=2, usecols=[0])\n if read_scalars:\n scalar_array = np.loadtxt(filepath, skiprows=2, usecols=[-1])\n return label_array, scalar_array\n return label_array","def load_data(filename):\n assert os.path.exists(filename)==True\n dat = scipy.io.loadmat(filename)\n inputs = dat['inputs']\n #print len(inputs)\n targets = dat['targets']\n #print len(targets)\n assert len(inputs)==len(targets)\n\n global alldata\n global indim \n global outdim\n\n indim = len(inputs[0])\n outdim = 1\n #print indim\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\n alldata.setField('input',inputs)\n alldata.setField('target',targets)\n\n assert len(alldata['input'])==len(alldata['target'])\n print type(alldata)","def read_file(filename):\n contents, labels = [], []\n with open_file(filename) as f:\n for line in f:\n try:\n label,content = line.strip().split('\\t')\n contents.append(list(content))\n labels.append(label)\n except:\n pass\n return contents,labels","def read_labels(labels_file):\n if not labels_file:\n print 'WARNING: No labels file provided. Results will be difficult to interpret.'\n return None\n\n labels = []\n with open(labels_file) as infile:\n for line in infile:\n label = line.strip()\n if label:\n labels.append(label)\n assert len(labels), 'No labels found'\n return labels","def load_data(self):\n print('Loading {} dataset'.format(self.split))\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\n with open(data_split_path,'r') as f:\n reader = csv.reader(f, delimiter=',')\n data_classes = {}\n for i,row in enumerate(reader):\n if i==0:\n continue\n data_classes[row[1]] = 1\n data_classes = data_classes.keys()\n print(data_classes)\n\n n_classes = len(data_classes)\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\n if self.n_unlabel>0:\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\n else:\n dataset_u = []\n\n for i, cls in enumerate(data_classes):\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\n for j, im_file in enumerate(im_files):\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \n np.float32, copy=False)\n if j<self.n_label:\n dataset_l[i, j] = im\n else:\n dataset_u[i,j-self.n_label] = im\n print('labeled data:', np.shape(dataset_l))\n print('unlabeled data:', np.shape(dataset_u))\n \n self.dataset_l = dataset_l\n self.dataset_u = dataset_u\n self.n_classes = n_classes","def _read_labels(test_data=False):\n if not test_data:\n filename = os.path.join(FOLDER_PATH, 'train-labels.idx1-ubyte')\n else:\n filename = os.path.join(FOLDER_PATH, 't10k-labels.idx1-ubyte')\n if not os.path.exists(filename):\n raise ValueError('The file dose not exist.')\n \n # Create a queue that produces the filenames to read.\n filename_queue = tf.train.string_input_producer([filename])\n \n # The first 8 bytes contain file information:\n # [offset] [type] [value] [description]\n # 0000 32 bit integer 0x00000801(2049) magic number\n # 0004 32 bit integer 60000/10000 number of items \n # ...(label value)\n header_bytes = 8\n # Every record consists of a label, with a fixed number of bytes for each.\n record_bytes = 1\n \n # Create a FixedLengthRecordReader to read record.\n reader = tf.FixedLengthRecordReader(record_bytes=record_bytes,\n header_bytes=header_bytes)\n _, value = reader.read(filename_queue)\n\n # Convert from a string to a vector of uint8, then cast to int32.\n record = tf.cast(tf.decode_raw(value, tf.uint8), tf.int32)\n \n # Reshape from [1] to a scalar shape [].\n label = tf.reshape(record, [])\n\n return label","def load_data_and_labels():\n # Load data from files\n positive_examples = list(\n open(\"./data/rt-polarity.pos\", \"r\", encoding='latin-1').readlines())\n positive_examples = [s.strip() for s in positive_examples]\n negative_examples = list(\n open(\"./data/rt-polarity.neg\", \"r\", encoding='latin-1').readlines())\n negative_examples = [s.strip() for s in negative_examples]\n # Split by words\n x_text = positive_examples + negative_examples\n x_text = [clean_str(sent) for sent in x_text]\n x_text = [s.split(\" \") for s in x_text]\n # Generate labels\n positive_labels = [[0, 1] for _ in positive_examples]\n negative_labels = [[1, 0] for _ in negative_examples]\n y = np.concatenate([positive_labels, negative_labels], 0)\n return [x_text, y]","def _load_data(self):\n data_x, data_y = make_classification(n_samples=5000, n_features=20,\n n_informative=10,\n n_redundant=0, n_repeated=0,\n n_classes=2,\n n_clusters_per_class=4,\n weights=None, flip_y=0.01,\n class_sep=1.0, hypercube=True,\n shift=0.0, scale=1.0,\n shuffle=True,\n random_state=self.args.rand_seed)\n\n self.orig_column_names = np.arange(data_x.shape[-1])\n self.data_x = data_x\n self.data_y = self.to_one_hot_encoding(data_y)\n self.numerical_idx = np.arange(data_x.shape[-1])\n self.non_num_idx = None\n self.all_non_numerical_idx = None\n\n # Calculate adjacency matrix\n self.meta_inf = data_x[:, :1].astype('float32')\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def load_label(path_file):\n if '.csv' not in path_file:\n raise FileNotFoundError('Only CSV format is supported currently')\n\n t0 = time()\n df = pd.DataFrame()\n\n with open(path_file, 'r') as f:\n # TODO: Implement the logic once the format is finalised\n pass\n\n logging.info('Loading label data with {} rows from {} takes {} secs'.format(df.shape[0],\n path_file, time() - t0))\n return df","def ReadAndReshape(dataFile):\n raw_data = scio.loadmat(dataFile)\n data = raw_data['data']\n data = data.astype(np.float64)\n data = data / 255\n raw_label = raw_data['labels']\n label = list()\n for value in raw_label:\n l = np.zeros(10)\n l[value] = 1\n label.append(l)\n label = np.array(label)\n return data, label","def readFromFile(self,ffile,nbcolumns=None,columnsNames='yes',name='no',columnsUnits='no'):\n from exceptions import IOError\n try:\n if self.data.shape != (0,0):\n raise Exception(\"The table already contains values\")\n file = open(ffile, 'r')\n except :\n msg=\"can't open file <%s>...\\n\"%ffile\n raise IOError(msg)\n\n\n fileNameColumns=[]\n fileNameUnits=[]\n fileName=None\n \n filemaxnbcol=0\n fileminnbcol=100\n isonvalues=0\n allvaluesbycolonne=[]\n nbvalueline=0\n cpt=1\n for line in file.readlines():\n separe = line.split()\n if (len(separe) == 0 ):\n # blank line\n continue\n \n \n if ( separe[0] == '#' ):\n # comment line\n cpt=cpt+1\n continue\n elif ( separe[0] == '#TITLE:' ):\n # name line\n separe = separe[1:]\n s=''\n for isep in range(len(separe)):\n s=s+separe[isep]+' '\n fileName=s\n pass\n elif ( separe[0] == '#COLUMN_TITLES:' ):\n # column name line\n separe = separe[1:]\n s=''\n for isep in range(len(separe)):\n s=s+separe[isep]\n s=string.strip(s)\n if ( len(s) == 0 ):\n fileNameColumns=[]\n continue\n fileNameColumns = s.split('|')\n pass\n pass\n elif ( separe[0] == '#columnUnits:' ):\n # unit name line\n fileNameUnits = separe[1:]\n pass\n elif ( cpt == 1 ):\n # column name line\n pass\n else:\n # values line\n nbvalueline=nbvalueline+1\n linenbcol=len(separe)\n filemaxnbcol=max(linenbcol,filemaxnbcol)\n fileminnbcol=min(linenbcol,fileminnbcol)\n linevalues=[]\n \n for isep in range(linenbcol): linevalues.append(float(separe[isep]))\n \n # adjust nb columns if not the same on each line\n # or if the first value's line\n if ( filemaxnbcol < len(allvaluesbycolonne) ):\n for icol in range(filemaxnbcol,len(allvaluesbycolonne)):\n allvaluesbycolonne.append([])\n for il in range(nbvalueline-1):\n allvaluesbycolonne[il].append(0)\n pass\n pass\n elif ( filemaxnbcol > len(allvaluesbycolonne) ):\n for icol in range(len(allvaluesbycolonne),filemaxnbcol):\n allvaluesbycolonne.append([])\n for il in range(nbvalueline-1):\n allvaluesbycolonne[icol].append(0)\n pass\n pass\n pass\n # add values\n for icol in range(linenbcol): allvaluesbycolonne[icol].append(linevalues[icol])\n for icol in range(linenbcol,filemaxnbcol): allvaluesbycolonne[icol].append(0)\n \n cpt=cpt+1\n pass\n file.close()\n #\n # check consistency beetwen arguments and file contents\n #\n # controlling the table parameters\n # \n if ( fileminnbcol != filemaxnbcol ):\n raise IOError(\"colums must have the same number of rows\")\n \n if nbcolumns:\n if ( filemaxnbcol != nbcolumns ):\n raise IOError(\" problem with the number of columns\")\n pass\n \n # Warnings\n if ( ( columnsNames.lower() == 'no' ) and ( len(fileNameColumns) > 0 ) ):\n raise Warning(\" you should specify column names\")\n \n if ( ( columnsNames.lower() == 'yes' ) and ( len(fileNameColumns) == 0 ) ):\n raise Warning(\"you specified columnName(s) but the file doesn\\'t entail column names\")\n \n if ( len(fileNameColumns) < filemaxnbcol ):\n nbcol=len(fileNameColumns)\n for icol in range (nbcol,filemaxnbcol): fileNameColumns.append('col'+str(icol+1))\n \n effectivecolumnNames=fileNameColumns\n \n \n if ( ( name.lower() == 'no' ) and fileName ):\n msg='WARNING: you specified no name but there is name in file'\n print(msg)\n \n if ( ( name.lower() == 'yes' ) and ( fileName == None ) ):\n msg='WARNING: you specified name but there is no name in file'\n print(msg)\n \n if ( ( columnsUnits.lower() == 'no' ) and ( len(fileNameUnits) > 0 ) ):\n msg='WARNING: you specified no units name but there are units name in file'\n print(msg)\n \n if ( ( columnsUnits.lower() == 'yes' ) and ( len(fileNameUnits) == 0 ) ):\n msg='WARNING: you specified units name but there are no units name in file'\n print(msg)\n \n if ( ( len(fileNameUnits) > 0 ) and ( len(fileNameUnits) < filemaxnbcol ) ):\n nbcol=len(fileNameUnits)\n for icol in range (nbcol,filemaxnbcol): fileNameUnits.append('col'+str(icol+1))\n pass\n \n\n\n if fileName:\n self.setName(fileName)\n pass\n if len(fileNameUnits):\n self.setColumnUnits(fileNameUnits)\n\n for i in range(filemaxnbcol):\n if columnsNames.lower()=='yes':\n self.addColumn(effectivecolumnNames[i],allvaluesbycolonne[i])\n pass\n else:\n self.addColumnValues(allvaluesbycolonne[i])\n pass\n return","def load_label_data(config):\n label_data = pd.read_csv(config.LabelDataConfig.data_path)\n ids = list(label_data['Training cases final'])\n labels = config.build_labels(label_data)\n\n train_ids, val_ids, train_labels, val_labels = train_test_split(\n ids,\n labels,\n stratify=labels,\n train_size=config.ImageDataConfig.train_percent)\n\n train_label_data = {image_id.upper(): label\n for image_id, label in izip(train_ids, train_labels)}\n val_label_data = {image_id.upper(): label\n for image_id, label in izip(val_ids, val_labels)}\n\n return train_label_data, val_label_data","def load_data(self, filename):\r\n #sqlcontext = SQLContext(self.sc)\r\n #df = sqlcontext.read.format('com.databricks.spark.csv').options(header='false', inferschema='true').load(filename)\r\n #df = sc.textFile(r\"C:\\Users\\mohan\\Downloads\\patches.csv\").map(lambda line: line.split(\",\"))\r\n #print (df.count())\r\n df = self.sc.textFile(filename).map(lambda line: line.split(\",\"))\r\n l = df.map(lambda w: [int(float(c)) for c in w]).zipWithIndex()\r\n return l\r\n raise NotImplementedError","def loadData ( self ) :\n df = pd.read_json ( self.dataset )\n df = df[pd.notnull ( df[2] )]\n df[1] = df[1].apply ( self.clean_text )\n\n self.X = df[1]\n self.y = df[2]","def load_text_and_label(data_file):\n # load data from file\n\n # splite by word\n dfRaw = pd.read_csv(data_file)\n dfRec = dfRaw[['Review Text', 'Recommended IND']].dropna()\n pos_examples = dfRec[dfRec['Recommended IND'] == 1]['Review Text'].tolist()\n neg_examples = dfRec[dfRec['Recommended IND'] == 0]['Review Text'].tolist()\n\n x_text = pos_examples + neg_examples\n x_text = np.array([clean_str(sentence) for sentence in x_text])\n # generate label (y)\n pos_labels = [[0,1] for _ in pos_examples]\n neg_labels = [[1,0] for _ in neg_examples]\n y = np.array(pos_labels + neg_labels)\n return [x_text, y]","def load(self, path=\"../data_set/final-train-dataset.csv\", shuffle=False,\n onlyLabelToUse=None, useOnlyBestIndicators=False, binary=False):\n data = []\n labels = []\n\n with open(path) as csvfile:\n reader = csv.reader(csvfile, delimiter=',')\n skip = True\n\n for row in reader:\n if skip:\n skip = False\n continue\n\n entries = []\n\n for i in range(SAMPLES_OF_DATA_TO_LOOK_AT):\n # Get one time point's data, including indicators:\n if useOnlyBestIndicators:\n # entries.append(\n # [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\n #\n entries.append(\n [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\n j in [0, 1, 2, 5, 7]])\n else:\n entries.append(\n [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\n j in range(INPUT_CHANNELS)])\n\n data.append(np.array(entries))\n\n if onlyLabelToUse is not None:\n if binary:\n label = [int(float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + onlyLabelToUse]) > 0.5)]\n else:\n label = [float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + onlyLabelToUse])]\n else:\n if binary:\n label = [int(float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + j]) > 0.5) for j in range(OUTPUT_CHANNELS)]\n else:\n label = [float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + j]) for j in range(OUTPUT_CHANNELS)]\n\n labels.append(label)\n\n if shuffle:\n indices = [i for i in range(len(data))]\n np.random.shuffle(indices)\n labels = np.array([labels[i] for i in indices])\n data = np.array([data[i] for i in indices])\n else:\n data = np.array(data)\n labels = np.array(labels)\n\n return data, labels","def load_data_csv(self, filename):\n import csv\n\n self.begin_batch() #avoid unecessary updates\n\n #delete old data\n #TODO: check of deleting data is really what user wants\n #TODO: create method for clearing data\n msg = wx.grid.GridTableMessage(self,\n wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED,\n 0,\n self.GetNumberRows())\n self.rowmask = numpy.array([], dtype = numpy.bool)\n self.data = numpy.empty(shape = (0, len(self.colLabels)), dtype = numpy.object)\n self.GetView().ProcessTableMessage(msg)\n \n #process file\n with open(filename, 'rb') as f:\n\n #read first row to extract fieldnames\n header = csv.reader(f).next()\n\n #parse field header \"name [dynamic] (custom label)\"\n pattern = re.compile(r\"(?P<name>\\w+(\\s\\w+)?)\\s*(\\[(?P<dynamic>.*)\\])?\\s*(\\((?P<label>.*)\\))?\\s*(\\{(?P<options>.*)\\})?\",\n re.VERBOSE)\n fields = []\n dyn_expr = {}\n cust_label = {}\n vis_cols = {}\n for entry in header:\n r = pattern.match(entry)\n d = r.groupdict()\n name = d['name']\n if name:\n fields.append(name)\n if d['dynamic']: dyn_expr[name] = d['dynamic']\n if d['label']: cust_label[name] = d['label']\n if d['options']:\n if '*' in d['options']: vis_cols[name] = True\n\n #set dynamic expressions\n for k, col in enumerate(self.dynamic_cols):\n dexpr = dyn_expr.get(self.colLabels[col])\n if dexpr:\n self.dynamic_expressions[k] = dexpr\n\n #set custom column labels\n for k, label in enumerate(self.colLabels):\n clabel = cust_label.get(label)\n if clabel:\n self.column_labels_custom[k] = clabel\n\n #also show columns which are marked as visible in csv file\n colsel = set(self.colsel)\n for k, label in enumerate(self.colLabels):\n if vis_cols.get(label):\n colsel.add(k)\n colsel = list(colsel)\n colsel.sort()\n self.View.SetColumnSelection(colsel)\n\n #read data\n reader = csv.DictReader(f, fieldnames = fields)\n\n row = -1\n for rowdict in reader:\n row += 1\n self.AppendRows()\n\n if rowdict.get('masked') == 'True':\n self.maskrows(row)\n\n #loop over columns in _actual_ table, \n for col, typelabel in enumerate(zip(self.dataTypes, self.colLabels)):\n datatype, label = typelabel\n\n #ask csv reader whether corresponding entry exists \n value = rowdict.get(label)\n if value is None or value == '':\n continue\n\n try:\n #convert string value to proper type\n #TODO: optimize it by creating a table of conversion functions\n #or a table method that takes a string\n if wx.grid.GRID_VALUE_FLOAT in datatype:\n val = float(value)\n elif wx.grid.GRID_VALUE_NUMBER in datatype:\n val = int(value)\n elif wx.grid.GRID_VALUE_BOOL in datatype:\n if value == '1' or value == 'True':\n val = True\n else:\n val = False\n elif wx.grid.GRID_VALUE_STRING in datatype:\n val = value\n else:\n print \"loading of type %s is not supported\"%datatype\n continue\n\n self.SetValueRaw(row, col, val)\n except ValueError:\n print \"warning reading csv: cannot convert value '%s' to type %s\"%(value, datatype)\n\n self.AppendRows(2) \n self.end_batch()\n self.modified = False","def labels_data(protein_data_path, columns):\n labels = pd.read_csv(protein_data_path, sep=\"\\t\").fillna(0)\n return labels[columns].astype(int).values","def load_file(filename,label_len):\n embedding = np.load(filename)\n# sample_frames = hp.sample_frames\n# while(1):\n# n_frames = (embedding.shape[0]-1)/sample_frames + 1\n# if (embedding.shape[0]-1)%sample_frames!=0:\n# n_frames += 1\n# if n_frames>=label_len:\n# break\n# sample_frames-=1\n \n arr = []\n for i in range(0,embedding.shape[0],hp.sample_frames):\n arr.append(embedding[i])\n \n #always include ending frame\n if (embedding.shape[0]-1)%hp.sample_frames!=0:\n arr.append(embedding[-1])\n \n length = len(arr)\n arr = np.array(arr) \n \n return arr, length","def process_dataset_file(data, label):\n\n # Select only required columns\n data = select_columns(data)\n\n # Colums are divided into features and labels\n data_x, data_y = divide_x_y(data, label)\n data_y = adjust_labels(data_y, label)\n data_y = data_y.astype(int)\n\n # Perform linear interpolation\n data_x = np.array([Series(i).interpolate() for i in data_x.T]).T\n\n # Remaining missing data is replaced with 0\n data_x[np.isnan(data_x)] = 0\n\n # Normalize sensor channels\n data_x = norm(data_x, MAX_THRESHOLDS, MIN_THRESHOLDS)\n\n return data_x, data_y"],"string":"[\n \"def _read_column_labels(self):\\n\\n # read the label line (should be at row 15 of the file at this point)\\n label_list = self._stream_handle.readline().strip().split()\\n self.num_columns = len(label_list)\\n self._header_dict['labels'] = label_list\\n\\n # the m_present_time label is required to generate particles, raise an exception if it is not found\\n if GliderParticleKey.M_PRESENT_TIME not in label_list:\\n raise DatasetParserException('The m_present_time label has not been found, which means the timestamp '\\n 'cannot be determined for any particles')\\n\\n # read the units line (should be at row 16 of the file at this point)\\n data_unit_list = self._stream_handle.readline().strip().split()\\n data_unit_list_length = len(data_unit_list)\\n\\n # read the number of bytes line (should be at row 17 of the file at this point)\\n num_of_bytes_list = self._stream_handle.readline().strip().split()\\n num_of_bytes_list_length = len(num_of_bytes_list)\\n\\n # number of labels for name, unit, and number of bytes must match\\n if data_unit_list_length != self.num_columns or self.num_columns != num_of_bytes_list_length:\\n raise DatasetParserException(\\\"The number of columns in the labels row: %d, units row: %d, \\\"\\n \\\"and number of bytes row: %d are not equal.\\\"\\n % (self.num_columns, data_unit_list_length, num_of_bytes_list_length))\\n\\n # if the number of columns from the header does not match that in the data, but the rest of the file has\\n # the same number of columns in each line this is not a fatal error, just parse the columns that are present\\n if self._header_dict['sensors_per_cycle'] != self.num_columns:\\n msg = 'sensors_per_cycle from header %d does not match the number of data label columns %d' % \\\\\\n (self._header_dict['sensors_per_cycle'], self.num_columns)\\n self._exception_callback(SampleException(msg))\\n\\n log.debug(\\\"Label count: %d\\\", self.num_columns)\",\n \"def load_data(filename, use_labels=True):\\n # load column 1 to 8 (ignore last one)\\n data = np.loadtxt(open( filename), delimiter=',',\\n usecols=range(1, 9), skiprows=1)\\n if use_labels:\\n labels = np.loadtxt(open( filename), delimiter=',',\\n usecols=[0], skiprows=1)\\n else:\\n labels = np.zeros(data.shape[0])\\n return labels, data\",\n \"def load_data_and_labels(data_file, labels_file):\\r\\n x_text = []\\r\\n y = []\\r\\n \\r\\n with open(data_file, encoding = \\\"utf-8\\\") as csvFile:\\r\\n readCSV = csv.reader(csvFile, delimiter = \\\",\\\")\\r\\n for row in readCSV:\\r\\n row = \\\"\\\".join(row)\\r\\n x_text.append(row) \\r\\n \\r\\n with open(labels_file, encoding = \\\"utf-8\\\") as csvFile2:\\r\\n readCSV = csv.reader(csvFile2, delimiter = \\\",\\\")\\r\\n for row in readCSV:\\r\\n d = defaultdict(list)\\r\\n for k,va in [(v,i) for i,v in enumerate(row)]:\\r\\n d[k].append(va)\\r\\n \\r\\n for k in range(len(d.get(\\\"1.0\\\"))):\\r\\n index = d.get(\\\"1.0\\\")[k]\\r\\n row[index] = 1\\r\\n for k in range(len(d.get(\\\"0.0\\\"))):\\r\\n index = d.get(\\\"0.0\\\")[k]\\r\\n row[index] = 0\\r\\n \\r\\n# print(len(row))\\r\\n y.append(row)\\r\\n \\r\\n\\r\\n\\r\\n\\r\\n \\r\\n print(\\\"x = {}\\\".format(len(x_text)))\\r\\n print(\\\"y = {}\\\".format(len(y)))\\r\\n \\r\\n return x_text, y\",\n \"def read_data(feature_file, label_file):\",\n \"def load_data(self):\\n with open(self.file_name) as f:\\n lines = f.readlines()\\n\\n labels = list()\\n all_dat = list()\\n for i, l in enumerate(lines):\\n\\n labels.append(int(l[0]))\\n\\n l = gensim.utils.any2unicode(l)\\n all_dat.append(LabeledSentence(l.split(\\\"\\\\t\\\")[-1], [i]))\\n\\n return all_dat, np.asarray(labels)\",\n \"def load_labels(label_file) :\\n df = pd.read_csv(label_file, index_col=\\\"p_index\\\",\\n dtype=str, na_values=['nan', 'NaN', '']).dropna()\\n\\n return df\",\n \"def load_test(data_file, labels=True, skip_rows=0):\\n dat = iter_loadtxt(data_file, delimiter='\\\\t', skiprows=skip_rows)\\n if labels:\\n Dat = DataSet(images=dat[:, 0:-1], labels=dat[:, -1].astype(int), reshape=False)\\n else:\\n nrow = dat.shape[0]\\n Dat = DataSet(images=dat, labels=np.full(nrow, np.nan), reshape=False)\\n return Dat\",\n \"def load_data(self):\\n \\n # only loader implemented so far !\\n try:\\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep='')\\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n\\n if not TOF._is_this_numeric(_tof_column[0]):\\n start_row += 1\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n _counts_column = _ascii_array[start_row:, 1]\\n\\n self.tof_array = _tof_column\\n self.counts_array = _counts_column\\n return\\n\\n except IndexError:\\n pass # try another format\\n\\n try:\\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep=',')\\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\\n\\n _tof_column = _ascii_array[start_row:, 0] # first row must be excluded in this format\\n\\n if not TOF._is_this_numeric(_tof_column[0]):\\n start_row += 1\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n _counts_column = _ascii_array[start_row:, 1]\\n\\n self.tof_array = _tof_column\\n self.counts_array = _counts_column\\n return\\n\\n except IndexError:\\n raise IndexError(\\\"Format not implemented!\\\")\",\n \"def load_data_and_labels(data_file):\\n # Load data from files\\n obj = open(data_file, \\\"r\\\")\\n y, x_text, query= [],[],[]\\n for ele in obj:\\n ele = ele.strip().split(\\\"\\\\t\\\")\\n if len(ele) !=5 or ele[0].strip() not in [\\\"1\\\", \\\"-1\\\"]:\\n #print ele\\n continue\\n if (ele[0].strip() == \\\"1\\\"):\\n y.append([0])\\n else:\\n y.append([1])\\n\\n query_text = ele[1].strip().decode(\\\"utf8\\\")\\n doc_text = ele[2].strip().decode(\\\"utf8\\\")\\n x_text.append( \\\" \\\".join( jieba.cut(doc_text) ) )\\n query.append( \\\" \\\".join( jieba.cut(query_text) ) )\\n return [x_text, np.array(y), np.array(query)]\",\n \"def load(self, filename) :\\r\\n \\r\\n # determine filename\\r\\n dir = os.path.dirname(__file__)\\r\\n f = os.path.join(dir, '..', 'data', filename)\\r\\n \\r\\n # load data\\r\\n with open(f, 'r') as fid :\\r\\n data = np.loadtxt(fid, delimiter=\\\",\\\")\\r\\n \\r\\n # separate features and labels\\r\\n self.X = data[:,:-1]\\r\\n self.y = data[:,-1]\",\n \"def load(self, filename) :\\n\\n # determine filename\\n dir = os.path.dirname('__file__')\\n f = os.path.join(dir, '..', 'data', filename)\\n\\n # load data\\n with open(f, 'r') as fid :\\n data = np.loadtxt(fid, delimiter=\\\",\\\")\\n\\n # separate features and labels\\n self.X = data[:,:-1]\\n self.y = data[:,-1]\",\n \"def load_data_file(data_file):\\n print(\\\"Loading from {} ...\\\".format(data_file.name), end=\\\"\\\")\\n text_col = \\\"news_title\\\"\\n theme1_col = \\\"Q3 Theme1\\\"\\n\\n with open(data_file) as f:\\n df = pd.read_csv(f, sep=\\\"\\\\t\\\")\\n X = df[text_col].tolist()\\n y = None\\n if theme1_col in df.columns:\\n y = df[theme1_col].tolist()\\n\\n print(\\n \\\"loaded {} lines {} labels ... done\\\".format(\\n len(X), \\\"with\\\" if y is not None else \\\"without\\\"\\n )\\n )\\n\\n print(len(X))\\n print(len(y))\\n return (X, y)\",\n \"def load_file(filename):\\n\\tlabels = []\\n\\tdocs = []\\n\\n\\twith open(filename) as f:\\n\\t\\tfor line in f:\\n\\t\\t\\tcontent = line.split('\\\\t')\\n\\n\\t\\t\\tif len(content) > 2:\\n\\t\\t\\t\\tprint('incorrect read')\\n\\t\\t\\t\\texit()\\n\\n\\t\\t\\tif len(content[1]) == 0: continue\\n\\n\\t\\t\\tdocs.append(str(content[1]).strip('\\\\r').strip('\\\\n').strip('\\\\r\\\\n'))\\n\\t\\t\\tlabels.append(content[0])\\n\\n\\treturn docs, labels\",\n \"def read_traindata (filename, labels = ['pos', 'neg']):\\n def split (l):\\n \\\"\\\"\\\"split one line into words and label\\\"\\\"\\\"\\n segs = l.strip().split ('\\\\t')\\n label = segs [-1]\\n words = segs [:-1]\\n return words, label\\n \\n encoding = chardet.detect(open (filename).read ()) ['encoding']\\n \\n with codecs.open (filename, 'r', encoding) as f:\\n for line in f.readlines ():\\n row = split (line)\\n assert len (row) == 2\\n assert isinstance(row [0], list)\\n assert isinstance(row [1], basestring)\\n print row [1]\\n assert row [1] in labels\\n yield row\",\n \"def load_labels(self, labels):\\n self.labels = pd.DataFrame(labels, index=[\\\"label\\\"]).T\",\n \"def read_from(self, filename):\\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))\",\n \"def loader(filename,sep=',',rowskip=[], colskip=[], axis=1,names=1,fromstring=0):\\n\\n #manages excpetions to the csv file incase of missing data\\n if (type(filename)==str) and (fromstring==1):\\n iterable=filename.strip('\\\\n').split('\\\\n')\\n content=np.array([i for i in csv.reader(iterable,delimiter=sep)])\\n elif type(filename)==np.ndarray:\\n content=filename\\n else:\\n content=np.array([i for i in\\\\\\n csv.reader(open(filename,'r'),delimiter=sep)])\\n #content=np.genfromtxt(filename,delimiter=sep,dtype=str)\\n\\n if rowskip:\\n #rowskip.sort(reverse=True)\\n content=np.delete(content,rowskip,0)\\n #for i in rowskip: content.pop(i)\\n\\n if colskip:\\n #colskip.sort(reverse=True)\\n content=np.delete(content,colskip,1)\\n #for i in colskip: content.pop(i)\\n\\n if axis==0: # if the file oriented column-wise\\n #content=list(map(list,zip(*content)))\\n content=content.T\\n\\n\\n\\n if names is 0:\\n variables=np.arange(content.shape[1]).tolist()\\n offset=0\\n else:\\n variables=content[0].tolist()\\n offset=1\\n\\n try:\\n content=np.array([conv_col(col) for col in\\n content[offset:].T],dtype='object')\\n arity=np.array([np.unique(i).size for i in content])\\n return dataset(variables,content.T,arity)\\n except ValueError: \\n print( 'Data could not be loaded, failed converting to float.')\\n return content\",\n \"def read_data(filename):\\n data = np.genfromtxt(filename, delimiter=',', dtype = str)\\n X = data[1:,2:].astype(np.float)\\n y = data[1:,0]\\n y[y==label0]='0' \\n y[y==label1]='1' \\n y[y==label2]='2'\\n y.astype(np.float) \\n return X, y\",\n \"def read_data(filename):\\n data = np.genfromtxt(filename, delimiter=',', dtype=str)\\n X = data[1:,2:].astype(np.float)\\n y = data[1:,0]\\n y[y==label0]='0'\\n y[y==label1]='1'\\n y[y==label2]='2'\\n y=y.astype(np.float)\\n return X, y\",\n \"def load_data(self, dropna=False):\\r\\n # Load data, delete Ml index, get number of channels, add\\r\\n df = pd.read_csv(self.file_path, header=None, index_col=0, dtype='float64')\\r\\n\\r\\n cols = df.shape[1]\\r\\n if cols < 2:\\r\\n raise ValueError(f'{self} wrong file type.')\\r\\n\\r\\n df.columns = ['t'] + [f\\\"c{i}\\\" for i in range(1, cols)]\\r\\n df.index = df.index.astype(int)\\r\\n df.index.name = 'r'\\r\\n\\r\\n if dropna:\\r\\n df.dropna(axis=1, how='all', inplace=True)\\r\\n\\r\\n self.set_data(df)\",\n \"def load_data_part(fname):\\n if \\\"_data\\\" not in fname:\\n return None\\n # Read data\\n data = pd.read_csv(fname)\\n # events file\\n events_fname = fname.replace('_data', '_events')\\n # read event file\\n labels = pd.read_csv(events_fname)\\n clean = data.drop(['id'], axis=1) # remove id\\n labels = labels.drop(['id'], axis=1) # remove id\\n return clean, labels\",\n \"def read_data(feats_file, labels_file, size=None):\\n feats = np.loadtxt(feats_file)\\n labels = np.loadtxt(labels_file, ndmin=2)\\n if size:\\n feats = feats[:size, :]\\n labels = labels[:size, :]\\n return np.concatenate((feats, labels), axis=1)\",\n \"def load_data_and_labels():\\n # Load data from files\\n positive_examples = []\\n for file in os.listdir('with_datarace'):\\n filename = os.fsdecode(file)\\n ast_file = open('with_datarace\\\\\\\\' + filename, 'r')\\n token_vector = ast_file.read()\\n positive_examples.append(token_vector)\\n file_names.append(filename)\\n\\n negative_examples = []\\n for file in os.listdir('without_datarace\\\\\\\\'):\\n filename = os.fsdecode(file)\\n ast_file = open('without_datarace\\\\\\\\' + filename, 'r')\\n token_vector = ast_file.read()\\n negative_examples.append(token_vector) # List of lists\\n file_names.append(filename)\\n\\n positive_examples = [s.strip() for s in positive_examples]\\n negative_examples = [s.strip() for s in negative_examples]\\n\\n # Split by words\\n x_text = positive_examples + negative_examples # why we didn't cobine it from the beginning?\\n x_text = [clean_str(sent) for sent in x_text]\\n x_text = [s.split(\\\" \\\") for s in x_text]\\n\\n # Generate labels\\n positive_labels = [[0, 1] for _ in positive_examples]\\n negative_labels = [[1, 0] for _ in negative_examples]\\n y = np.concatenate([positive_labels, negative_labels], 0)\\n\\n return [x_text, y]\",\n \"def load_data_and_labels(data_file=train_file):\\n \\\"\\\"\\\"\\n There are 7 categories - \\n 1. DEMO\\n 2. DISE\\n 3. TRMT\\n 4. GOAL\\n 5. PREG\\n 6. FMLY\\n 7. SOCL\\n \\\"\\\"\\\"\\n d = {}\\n d['DEMO'] = [1, 0, 0, 0, 0, 0, 0]\\n d['DISE'] = [0, 1, 0, 0, 0, 0, 0]\\n d['TRMT'] = [0, 0, 1, 0, 0, 0, 0]\\n d['GOAL'] = [0, 0, 0, 1, 0, 0, 0]\\n d['PREG'] = [0, 0, 0, 0, 1, 0, 0]\\n d['FAML'] = [0, 0, 0, 0, 0, 1, 0]\\n d['SOCL'] = [0, 0, 0, 0, 0, 0, 1]\\n\\n max_len = -1\\n\\n #Load data from files\\n samples = []\\n with open(data_file, 'rb') as csvfile:\\n spamreader = csv.reader(csvfile, delimiter='\\\\t', quotechar='|')\\n for i, row in enumerate(spamreader):\\n if (row[0] == \\\"Category\\\"):\\n continue\\n print (i, row[1])\\n #samples.append([row[0], row[2]])\\n #getting class and title = row[0] and row[1] respectively\\n samples.append([row[1], row[2], row[0]])\\n #split by words\\n\\n return samples\",\n \"def read_labels(labels_path):\\n with open(labels_path, 'r') as file:\\n data = file.read()\\n data = data.split()\\n data = np.array(data)\\n data = np.reshape(data, (-1, 2))\\n return data\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\\n data = recfromtxt(open(filepath + '/spector.csv',\\\"rb\\\"), delimiter=\\\" \\\",\\n names=True, dtype=float, usecols=(1,2,3,4))\\n names = list(data.dtype.names)\\n endog = array(data[names[3]], dtype=float)\\n endog_name = names[3]\\n exog = column_stack(data[i] for i in names[:3]).astype(float)\\n exog_name = names[:3]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def load_data_and_labels(filename, dataset_name,is_train):\\n label_count={}\\n parameter_file = \\\"./parameters.json\\\"\\n params = json.loads(open(parameter_file).read())\\n if dataset_name == 'ag_news' or dataset_name == 'dbpedia' or dataset_name == 'sogou_news' or dataset_name == 'amazon_review_full' or dataset_name == 'amazon_review_polarity' :\\n df = pd.read_csv(filename, names=['label', 'title', 'text'], dtype={'title': object,'text': object})\\n selected = ['label', 'title','text','too_short','to_drop']\\n\\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['too_short']= df[selected[2]].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN)\\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN)\\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n # Map the actual labels to one hot labels\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df[selected[2]].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df[selected[2]].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n \\n elif dataset_name == 'yelp_review_full' or dataset_name == 'yelp_review_polarity':\\n df = pd.read_csv(filename, names=['label','text'], dtype={'text': object})\\n selected = ['label','text','too_short','to_drop']\\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['too_short']= df[selected[1]].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n # Map the actual labels to one hot labels\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df['text'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df['text'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n\\n elif dataset_name == 'yahoo_answers':\\n df = pd.read_csv(filename, names=['label', 'title', 'content','answer'], dtype={'title': object,'answer': object,'content': object})\\n selected = ['label', 'title','content','answer','too_short','to_drop'] \\n non_selected = list(set(df.columns) - set(selected))\\n df = df.drop(non_selected, axis=1) # Drop non selected columns \\n df['temp'] = df[['content','answer']].apply(lambda x: ' '.join(str(v) for v in x), axis=1)\\n df['too_short']= df['temp'].apply(lambda x: (remove_short(x,params['min_length'])))\\n df['too_short']=df['too_short'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any') # Drop null rows \\n df['to_drop']= df[selected[0]].apply(lambda y: (shrink_df(y,label_count,params['data_per_class'])))\\n df['to_drop']=df['to_drop'].replace('N/A',np.NaN) \\n if is_train:\\n df = df.dropna(axis=0, how='any', subset=selected) # Drop null rows\\n df = df.reindex(np.random.permutation(df.index)) # Shuffle the dataframe\\n for key,value in label_count.items():\\n print(\\\"{} : {}\\\".format(key,value))\\n labels = sorted(list(set(df[selected[0]].tolist())))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n if params['use_summary']==1:\\n x_raw = df['temp'].apply(lambda x: gen_summary(x,params['max_length'])).tolist()\\n else:\\n x_raw = df['temp'].apply(lambda x: clean_str(x,params['max_length'])).tolist()\\n\\n y_raw = df[selected[0]].apply(lambda y: label_dict[y]).tolist()\\n\\n return x_raw, y_raw, df, labels\",\n \"def load_labels(labels_dir, trial_name):\\n labels_path = labels_dir + trial_name + \\\".txt\\\"\\n raw_labels_data = np.genfromtxt(labels_path, dtype=np.int,\\n converters=LABELS_CONVERTERS,\\n usecols=LABELS_USECOLS)\\n #print(\\\"rawlabelsdata: \\\", raw_labels_data)\\n #print(get_first_frame(labels_path))\\n frames = np.arange(get_first_frame(labels_path), get_last_frame(labels_path)+1, dtype=np.int)\\n #print(\\\"frames: \\\", frames)\\n #print(frames.shape)\\n #labels = np.zeros(frames.shape, dtype=np.int)\\n labels1 = []\\n #print(labels)\\n for start, end, label in raw_labels_data:\\n #mask = (frames >= start) & (frames <= end)\\n #print(start)\\n #print(end)\\n i = start\\n while(i<end):\\n if(i%6 == 0):\\n labels1.append(label)\\n i = i+1\\n\\n #labels[mask] = label\\n #print(\\\"labels[mask]: \\\",labels[mask])\\n labels1 = np.array(labels1)\\n #print(labels1)\\n labels_data = labels1.reshape(-1,1)\\n #print(labels1.shape)\\n #print(\\\"labels: \\\", labels_data)\\n \\n return labels_data\",\n \"def load_labels(path):\\n with open(path, 'r', encoding='utf-8') as f:\\n lines = f.readlines()\\n labels = []\\n for row_number, content in enumerate(lines):\\n pair = re.split(r'[:\\\\s]+', content.strip(), maxsplit=1)\\n #if len(pair) == 2 and pair[0].strip().isdigit():\\n labels.append(np.array([int(pair[0].strip()),pair[1].strip()]))\\n #else:\\n # labels.append(pair[0].strip())\\n return np.array(labels)\",\n \"def read_label_file(self, label_file_name = None): #completed\\n if label_file_name is None:\\n label_file_name = self.label_file_name\\n try:\\n label_data = sp.loadmat(label_file_name)['labels'].astype(np.int32)\\n return label_data#[:,1], label_data[:,0]#in MATLAB format\\n except IOError:\\n print \\\"Unable to open \\\", label_file_name, \\\"... Exiting now\\\"\\n sys.exit()\",\n \"def load_data_file(data_file):\\n print(\\\"Loading from {} ...\\\".format(data_file.name), end=\\\"\\\")\\n text_col = \\\"news_title\\\"\\n theme1_col = \\\"Q3 Theme1\\\"\\n\\n with open(data_file, encoding=\\\"utf8\\\") as f:\\n df = pd.read_csv(f, sep=\\\"\\\\t\\\")\\n X = df[text_col].tolist()\\n\\n y = None\\n if theme1_col in df.columns:\\n y = df[theme1_col].tolist()\\n\\n print(\\n \\\"loaded {} lines {} labels ... done\\\".format(\\n len(X), \\\"with\\\" if y is not None else \\\"without\\\"\\n )\\n )\\n return (X, y)\",\n \"def load_file(self, dset_type):\\r\\n path = './data/{0}.{1}'.format(self.name, dset_type)\\r\\n try:\\r\\n file_contents = np.genfromtxt(path, missing_values=0, skip_header=0,\\r\\n dtype=int, delimiter=\\\",\\\")\\r\\n self.labels[dset_type] = file_contents[:, 0]\\r\\n self.examples[dset_type] = file_contents[:, 1:]\\r\\n\\r\\n except RuntimeError:\\r\\n print('ERROR: Unable to load file ''{0}''. Check path and try again.'.format(path))\",\n \"def load_test_data(label_fname, data_fname):\\n labels = load_csv(label_fname)\\n data = load_csv(data_fname, 'excel-tab')\\n\\n # Join all data together on the ids given in the files\\n joined_data = {}\\n for label in labels:\\n id = label[0]\\n joined_data[id] = {'class': label[1]}\\n for rec in data:\\n id = rec[0]\\n if id in joined_data:\\n joined_data[id]['data'] = rec[1]\\n\\n # Clean and convert the data to reals\\n max_features = 0\\n for id in joined_data:\\n words = clean_text(joined_data[id]['data'])\\n reals = convert_to_reals(words)\\n joined_data[id]['data'] = reals\\n if len(reals) > max_features:\\n max_features = len(reals)\\n\\n # Pad the data\\n for id in joined_data:\\n reals = joined_data[id]['data']\\n joined_data[id]['data'] = reals + (max_features - len(reals)) * [0.0]\\n\\n # Prepare the data for training\\n training_data = np.array([joined_data[id]['data'] for id in joined_data])\\n training_labels = [joined_data[id]['class'] == 'OFF' for id in joined_data]\\n return training_labels, training_data, max_features\",\n \"def load_label_columns(self):\\n with open(self.config.labels_local_path, 'r') as f:\\n label_columns = yaml.safe_load(f)\\n return label_columns\",\n \"def labels(labels_file, labels = []):\\n\\n print(f\\\"Parsing labels '{labels_file}'\\\")\\n with open(labels_file, 'r') as f:\\n for i, line in enumerate(f):\\n labels.append(line.split(':')[-1].strip())\\n return pd.Series(labels)\",\n \"def load_data(filename):\\n\\n evidance = list()\\n labels = list()\\n row = list()\\n\\n with open(filename) as file:\\n for j, item in enumerate(file):\\n if(j == 0):\\n continue\\n row = []\\n for i, el in enumerate(item.split(',')):\\n # print(el)\\n if(i in {0,2,4,11,12,13,14}):\\n row.append(int(el))\\n elif(i in {1,3,5,6,7,8,9}):\\n row.append(float(el))\\n elif(i==10):\\n if(el == \\\"Jan\\\"):\\n row.append(int(0))\\n elif(el == \\\"Feb\\\"): \\n row.append(int(1))\\n elif(el == \\\"Mar\\\"): \\n row.append(int(2))\\n elif(el == \\\"Apr\\\"): \\n row.append(int(3))\\n elif(el == \\\"May\\\"): \\n row.append(int(4))\\n elif(el == \\\"June\\\"): \\n row.append(int(5))\\n elif(el == \\\"Jul\\\"): \\n row.append(int(6))\\n elif(el == \\\"Aug\\\"): \\n row.append(int(7))\\n elif(el == \\\"Sep\\\"): \\n row.append(int(8))\\n elif(el == \\\"Oct\\\"): \\n row.append(int(9))\\n elif(el == \\\"Nov\\\"): \\n row.append(int(10))\\n elif(el == \\\"Dec\\\"): \\n row.append(int(11))\\n else:\\n print(\\\"wrong month Exit\\\")\\n quit()\\n elif(i==15):\\n if(el == 'Returning_Visitor'):\\n row.append(int(1))\\n else:\\n row.append(int(0))\\n elif(i==16):\\n if(el == 'TRUE'):\\n row.append(int(1))\\n else:\\n row.append(int(0)) \\n elif(i==17):\\n if(el == 'TRUE\\\\n' or el == 'TRUE'):\\n row.append(int(1))\\n else:\\n row.append(int(0))\\n else:\\n print(\\\"Incorrect value\\\")\\n\\n evidance.append(row)\\n # print(item.split(',')[-1])\\n if(item.split(',')[-1] == 'FALSE\\\\n'):\\n labels.append(0)\\n else:\\n labels.append(1)\\n\\n # print(labels)\\n return (evidance, labels)\",\n \"def parse_labels(file: str) -> ndarray:\\n rows = []\\n with open(file, 'r', encoding='utf-8') as f:\\n for row in f:\\n rows.append(row.strip())\\n return array(rows)\",\n \"def load_samples_and_labels(data_path, header=True, col=1, train=True):\\n if header:\\n start_index = 1\\n else:\\n start_index = 0\\n\\n with open(data_path, 'r', encoding='utf-8') as f:\\n lines = f.read().splitlines()[start_index:]\\n samples = [line.split(',')[col] for line in lines]\\n samples = [sample.split() for sample in samples]\\n\\n if train:\\n labels = [int(line.split(',')[3]) for line in lines]\\n else:\\n labels = []\\n\\n return samples, labels\",\n \"def load_data_set(filename):\\n\\n input_file = open(filename)\\n\\n num_features = len(input_file.readline().split('\\\\t')) - 1\\n input_file.seek(0)\\n data_mat = []\\n label_mat = []\\n\\n for line in input_file.readlines():\\n line_arr = []\\n curr_line = line.strip().split('\\\\t')\\n for i in range(num_features):\\n line_arr.append(float(curr_line[i]))\\n data_mat.append(line_arr)\\n label_mat.append(float(curr_line[-1]))\\n\\n return data_mat, label_mat\",\n \"def read_data(path):\\n with h5py.File(path, 'r') as hf:\\n data = np.array(hf.get('data'))\\n label = np.array(hf.get('label'))\\n\\n data, label=data[:,:,:,0:2], label[:,:,:,0]\\n #data=np.expand_dims(data,axis=-1)\\n label=np.expand_dims(label,axis=-1)\\n\\n return data, label\",\n \"def load_labels(path):\\n with open(path, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n lines = f.readlines()\\n labels = {}\\n for row_number, content in enumerate(lines):\\n pair = re.split(r\\\"[:\\\\s]+\\\", content.strip(), maxsplit=1)\\n if len(pair) == 2 and pair[0].strip().isdigit():\\n labels[int(pair[0])] = pair[1].strip()\\n else:\\n labels[row_number] = pair[0].strip()\\n # print(labels)\\n return labels\",\n \"def read_from_file(self,fn):\\n fh = open(fn,\\\"r\\\")\\n labels = []\\n xyz = []\\n sizes = []\\n colors = []\\n for line in fh.readlines():\\n try:\\n if not line.startswith(\\\"#\\\"):\\n label,x,y,z,size,r,g,b = line.split(\\\",\\\")\\n labels.append(label)\\n xyz.append([x,y,z])\\n sizes.append(size)\\n colors.append((float(r),float(g),float(b)))\\n except IOError, ioe:\\n print \\\"IOError:\\\", ioe\\n self._labels = np.array(labels)\\n self._xyz = np.array(xyz).astype(\\\"f\\\")\\n self._sizes = np.array(sizes).astype(\\\"f\\\")\\n self._colors = np.array(colors)\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n data = recfromtxt(filepath + '/scotvote.csv', delimiter=\\\",\\\",\\n names=True, dtype=float, usecols=(1,2,3,4,5,6,7,8))\\n names = list(data.dtype.names)\\n endog = array(data[names[0]], dtype=float)\\n endog_name = names[0]\\n exog = column_stack(data[i] for i in names[1:]).astype(float)\\n exog_name = names[1:]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def load_tfile_data(self, path, start=None, stop=None, dss=28):\\n filename = path+\\\".\\\"+str(int(self.name))\\n datafile = open(filename,\\\"r\\\")\\n labels = datafile.readline().strip().split()\\n logger.debug(\\\"load_tfile_data: labels: %s\\\", labels)\\n datafile.close()\\n labels.insert(0,'DOY')\\n labels.insert(0,'Year')\\n logger.debug(\\\"load_tfile_data: new labels: %s\\\", labels)\\n \\n # colums are: Year DOY UTC Epoch Chan Tsys Int Az El Diode Level CryoTemp\\n # i4 i4 S8 f8 S2 f4 f4 f4 f4 i4 f4 f4\\n data = numpy.loadtxt(filename,skiprows=1,\\n dtype = {'names': tuple(labels),\\n 'formats': ('i4','i4','S8','f8',\\n 'S2','f4','f4','f4','f4','i4','f4', 'f4')})\\n return data\",\n \"def load_labels(filename):\\n\\n file_path = os.path.join(DATA_DIR, filename)\\n with open(file_path, 'rb') as f:\\n b = f.read()\\n\\n magic, n_labels = (struct.unpack('>i', b[i*4:(i+1)*4]) for i in range(2))\\n\\n assert magic[0] == 2049, \\\"bad magic number, what do?\\\"\\n\\n label_stream = array.array('B', b[8:])\\n \\n assert len(label_stream) == n_labels[0], \\\"mismatch in label length\\\"\\n \\n # label_stream is actually type array.array, which is iterable surely.\\n # i'll convert it anyway...\\n return tuple(label_stream)\",\n \"def loadDataFromFile(self, filename, axis=0):\\n # Load\\n file = \\\"/Users/Septien/Documents/Tesis/code/data/\\\" + filename + \\\".data\\\"\\n with open(file) as dataFile:\\n for line in dataFile:\\n row = line.split(\\\",\\\")\\n self.numAxes = len(row)\\n d = row[axis]\\n if (d != '?'):\\n self.data.append(float(d))\\n # Sort for further computation\\n self.data.sort()\\n # Get the range\\n self.xAxisRange = [self.data[0], self.data[-1]]\",\n \"def _read_train_datas(self):\\r\\n with open(self.train_label_path, 'r') as fb:\\r\\n lines = fb.readlines()\\r\\n return self._parse_raw_labels(lines)\",\n \"def read_data(data_path, filename,feature_number):\\n\\n with open(data_path + \\\"/\\\" + filename, 'r', encoding='utf-8-sig') as f: \\n X = np.genfromtxt(f, delimiter=',')[:,0:feature_number]\\n\\n\\n # Last column of datafile contains output labels\\n Y = np.genfromtxt(data_path + \\\"/\\\" + filename,delimiter=\\\",\\\")[:,feature_number]\\n Y = Y.reshape(X.shape[0])\\n\\n return X,Y\",\n \"def load_labeled_data(files):\\n\\tx = []\\n\\ty = []\\n\\tfor filename in files:\\n\\t\\tdata = []\\n\\t\\twith open(filename) as infile:\\n\\t\\t\\tlabel = int(infile.readline())\\n\\t\\t\\tfor line in infile:\\t\\n\\t\\t\\t\\tdata.append(dna_string_to_array(line.strip()))\\n\\t\\ty += [label]*len(data)\\n\\t\\tx += data\\n\\n\\treturn (np.array(x), np.array(y))\",\n \"def load_data(self):\\n print(\\\"Loading dataset...\\\")\\n # Load the dataset\\n subIDs, data, labels = dl.load_processed_data_N_subjects_allchans(\\n '../data_5sec_100Hz_bipolar/', Nsub=14)\\n\\n if len(data) > 1:\\n\\n # If more than one patient loaded, append data to single array\\n data_arr = np.array(data[0])\\n label_arr = labels[0]\\n\\n for sub in range(1, len(data)):\\n data_arr = np.append(data_arr, data[sub], axis=1)\\n label_arr = np.append(label_arr, labels[sub], axis=0)\\n\\n else:\\n # Remove the extra dimension at axis=0\\n data_array = np.squeeze(data)\\n labels = np.squeeze(labels)\\n\\n # Move trials to the end so data array is 'nchan x timeseries x trials'\\n self.data = np.moveaxis(data_arr, 1, -1)\\n self.labels = np.array(label_arr)\\n\\n self.label_strings = dl.available_stringlabels\\n\\n valid_indices = np.sum(self.labels, axis=0)\\n names = [[self.label_strings[i], i, valid_indices[i]] for i in range(len(valid_indices)) if valid_indices[i] > 0]\\n print(\\\"A summary of valid labels is below: \\\\nFormat: [Label name, label index, Label count]\\\")\\n for i in range(len(names)):\\n print(names[i])\\n return\",\n \"def loadData( self, fileName, colClass, feaRowStart = None, \\n feaRowEnd = None, delimiter=','):\\n self.dF = pd.read_csv( fileName, delimiter = delimiter)\\n if feaRowStart is not None and feaRowEnd is not None:\\n self.feature = self.dF.iloc[feaRowStart:feaRowEnd, 0:colClass-1]\\n self.Class = self.dF.loc[feaRowStart:feaRowEnd, colClass]\\n else:\\n self.feature = self.dF.iloc[:,1:29]\\n self.Class = self.dF.Class \\n #self.feature = self.dF.iloc[:, 0:self.dF.shape[1]-1]\\n #self.Class = self.dF.loc[:, self.dF.shape[1]-1:self.dF.shape[1]] \\n \\n self.dataConvertToNumpy()\",\n \"def load_data(fname, skip_header=0, delimiter=','):\\n\\n data = np.genfromtxt(fname, dtype=str, comments=None, delimiter=delimiter, skip_header=skip_header)\\n\\n pathes = data[:, 0]\\n labels = data[:, 1]\\n\\n return pathes, labels\",\n \"def load_data(self):\\n filename = filedialog.askopenfilename(title=\\\"Select A File\\\",\\n file=((\\\"csv files\\\", \\\"*.csv\\\"),\\n (\\\"dat files\\\", \\\"*.dat\\\"),\\n (\\\"excel files\\\", \\\"*.xlsx\\\"),\\n (\\\"All Files\\\", \\\"*.*\\\")))\\n file_path = filename\\n try:\\n filename = f\\\"{file_path}\\\"\\n name = os.path.splitext(os.path.basename(filename))[0]\\n if name in ['h2o', 'KED', 'financial']:\\n DataLoader.data = load_data(name)\\n else:\\n DataLoader.data = pd.read_csv(filename)\\n except ValueError:\\n messagebox.showerror(\\\"Information\\\", \\\"The file you have chosen is invalid.\\\")\\n except FileNotFoundError:\\n messagebox.showerror(\\\"Information\\\", f\\\"No such file as {file_path}\\\")\\n self.clear_tree()\\n\\n self.treeview['columns'] = list(DataLoader.data.columns)\\n for i in self.treeview['columns']:\\n self.treeview.column(i, anchor=\\\"w\\\")\\n self.treeview.heading(i, text=i, anchor='w')\\n\\n for index, row in DataLoader.data.iterrows():\\n self.treeview.insert(\\\"\\\", 0, text=self.data.shape[0] - 1 - index, values=list(row))\\n self.treeview.column('#0', width=100)\\n\\n self.summary_label = ttk.Label(self, text=f'Data shape: {DataLoader.data.shape}', width=40)\\n self.summary_label.grid(row=2, column=0, columnspan=2, sticky=tk.S + tk.N)\",\n \"def __row_loading(self, filename=None, PC=-1, top=50, bot=50, label_key=None, all=False, **kargs):\\n assert not self.rowwise, \\\"loading(): You probably don't mean to use this when rowwise=True\\\"\\n assert PC >= 0, \\\"loading(): PC of <1 specified\\\"\\n \\n if \\\"aspect\\\" not in kargs:\\n kargs[\\\"aspect\\\"] = \\\"long\\\"\\n \\n data = self.__u[:,PC]\\n labs = self.parent[label_key]\\n packed_data = [{label_key: i[0], \\\"l\\\": i[1]} for i in zip(labs, data)]\\n \\n sorted_data = sorted(packed_data, key=itemgetter(\\\"l\\\"))\\n data = [i[\\\"l\\\"] for i in sorted_data]\\n labs = [i[label_key] for i in sorted_data]\\n \\n if all:\\n data = data\\n labs = labs\\n else:\\n if bot > 0 and top > 0: # data[-0:] returns the entire list and data[0:0] returns [] !\\n data = data[0:top] + data[-bot:]\\n labs = labs[0:top] + labs[-bot:]\\n elif top > 0:\\n data = data[0:top]\\n labs = labs[0:top] \\n elif bot > 0:\\n data = data[-bot:]\\n labs = labs[-bot:] \\n \\n if filename:\\n fig = self.__draw.getfigure(**kargs)\\n ax = fig.add_subplot(111)\\n ax.set_position([0.3,0.03,0.6,0.96])\\n \\n x = numpy.arange(len(data))\\n ax.barh(x-0.4, data, ec=\\\"black\\\", color=\\\"grey\\\")\\n ax.set_ylabel(\\\"Rows\\\")\\n ax.set_xlabel(\\\"Loading\\\")\\n ax.set_yticklabels(labs)\\n ax.set_yticks(x)\\n ax.set_ylim([-0.5, len(data)-0.5])\\n [t.set_fontsize(6) for t in ax.get_yticklabels()]\\n \\n self.__draw.do_common_args(ax, **kargs)\\n real_filename = self.__draw.savefigure(fig, filename)\\n \\n config.log.info(\\\"loading(): Saved PC loading '%s'\\\" % real_filename)\\n \\n # work out the list to return\\n newgl = genelist()\\n newgl.load_list([{label_key: i[0], \\\"pc_loading\\\": i[1]} for i in zip(labs, data)]) # relist it so that top bot are used\\n newexpn = newgl.map(genelist=self.parent, key=label_key, greedy=False)\\n newexpn.sort(\\\"pc_loading\\\")\\n return(newexpn)\",\n \"def load_data(self) -> tuple:\\n label_num = {}\\n data_set = pathlib.Path(self.path)\\n data = []\\n\\n # create the label lookup dict for verifcation later\\n for i, v in enumerate(data_set.iterdir()):\\n label_num[v.name] = i\\n self.labels[i] = v.name\\n # end\\n\\n # read images\\n for img_path in data_set.rglob(\\\"*.jpg\\\"):\\n lbl = label_num[str(img_path.parent.stem)]\\n img = cv2.imread(str(img_path))\\n img = cv2.resize(img, self.dims, interpolation=cv2.INTER_AREA)\\n\\n # flatten RGB data into a vector\\n # NOTE: NOT ACTUALLY NECESSARY! \\n img.flatten()\\n\\n # label the sample and append to temp data list\\n sample = np.append(lbl, img)\\n data.append(sample)\\n # end\\n\\n # partition and package the data (*_ ensures safe unpacking)\\n train, test, validate, *_ = Data.partition(data, self.parts, 0.7, 0.2)\\n self.train = Data(train)\\n self.test = Data(test)\\n self.validate = Data(validate)\",\n \"def get_labeled_data(filename):\\n e = []\\n y = []\\n with open(filename) as f:\\n for line in f:\\n e.append(line[1:-1])\\n y.append(category_mapping[abbreviation_mapping[line[0]]])\\n return e, y\",\n \"def loadTestData():\\n path = raw_input(\\\"Enter the path of Test Data: \\\")\\n data = np.genfromtxt(path, delimiter=',', dtype=int)\\n\\n labels = data[:, -1]\\n\\n unwantedLabels = [4, 5, 6, 7, 8, 9]\\n listToDelete = []\\n for i, line in enumerate(range(len(data))):\\n if labels[i] in unwantedLabels:\\n listToDelete.append(i)\\n\\n actualData = np.delete(data, listToDelete, axis=0)\\n\\n # print(actualData.shape)\\n # Separating the labels and data into different arrays\\n actualLabels = actualData[:, -1]\\n actualData = actualData[:, :-1]\\n\\n actualData = pre.scale(actualData)\\n\\n # Change the label vector to label matrix\\n # If Label is 2 then it becomes [0, 1, 0]\\n labelMatrix = np.zeros((actualLabels.shape[0], 4))\\n for j in range(len(actualLabels)):\\n if actualLabels[j] == 0:\\n labelMatrix[j][0] = 1\\n if actualLabels[j] == 1:\\n labelMatrix[j][1] = 1\\n if actualLabels[j] == 2:\\n labelMatrix[j][2] = 1\\n if actualLabels[j] == 3:\\n labelMatrix[j][3] = 1\\n\\n return actualData, actualLabels\",\n \"def data_parser(data):\\n\\n with open(data, 'r') as inp:\\n\\n # take every sample\\n # the last line in the text file is empty, so reading until -1\\n samples = inp.read().split('\\\\n')[:-1]\\n\\n vec = []\\n labels = []\\n for sample in samples:\\n # file is tab delimited\\n split_samples = sample.split('\\\\t')\\n # last column contains the label\\n labels.append(int(split_samples[-1]))\\n\\n features = []\\n for feature in split_samples[:-1]:\\n features.append(float(feature))\\n vec.append(features)\\n\\n # make the features and labels as a numpy array\\n vec = np.array(vec)\\n labels = np.array(labels)\\n return vec, labels\",\n \"def readfile(self, path, filename):\\n # The DataStudio software uses ISO-8859-1 encoding (especially for the degree sign in temperature files)\\n file = open(path + filename, encoding=\\\"iso-8859-1\\\")\\n rowlist = file.readlines()\\n\\n title = rowlist[0].strip(\\\"\\\\n\\\")\\n labels = rowlist[1].strip(\\\"\\\\n\\\").split(sep=\\\"\\\\t\\\")\\n\\n data = np.zeros((len(rowlist)-2, 2))\\n\\n for i in range(2, len(rowlist)):\\n columns = rowlist[i].split(sep=\\\"\\\\t\\\")\\n data[i-2, 0] = float(columns[0].replace(\\\",\\\", \\\".\\\"))\\n data[i-2, 1] = float(columns[1].replace(\\\",\\\", \\\".\\\"))\\n\\n return data, title, labels\",\n \"def LoadLabels(filepath):\\n with open(filepath, 'r') as datafile:\\n lines = [line.strip() for line in datafile.readlines()]\\n # filter for empty lines\\n return [line for line in lines if line]\",\n \"def load_labels(label_path):\\r\\n\\r\\n with open(label_path, \\\"r\\\") as f:\\r\\n\\r\\n lines = f.readlines()\\r\\n \\r\\n label = {}\\r\\n index = []\\r\\n for i, line in enumerate(lines):\\r\\n sp = line.split()\\r\\n label[sp[0]] = [int(sp[1]),int(sp[2]),int(sp[3])]\\r\\n index.append([int(sp[3]),int(sp[2]),int(sp[1])])\\r\\n\\r\\n return label, index\",\n \"def load_batch(fpath, label_key='labels'):\\n f = open(fpath, 'rb')\\n if sys.version_info < (3,):\\n d = cPickle.load(f)\\n else:\\n d = cPickle.load(f, encoding='bytes')\\n # decode utf8\\n d_decoded = {}\\n for k, v in d.items():\\n d_decoded[k.decode('utf8')] = v\\n d = d_decoded\\n f.close()\\n data = d['data']\\n labels = d[label_key]\\n\\n data = data.reshape(data.shape[0], 3, 32, 32)\\n return data, labels\",\n \"def readBMdata(self, filename=None):\\n if filename == None:\\n filename = self.ifilename\\n\\n try:\\n ifile = open(filename, 'r')\\n except IOError:\\n raise IOError('cannot find: %s. Either put the file in the working directory or fix the input file.' % filename)\\n\\n self.t = []\\n self.b = []\\n self.h = []\\n self.m = []\\n\\n max_ic = max( self.ic_t, self.ic_b, self.ic_h, self.ic_m )\\n i_line = 0\\n for line in ifile:\\n i_line += 1\\n if (i_line < self.start_line):\\n continue\\n\\n data = line.strip().split()\\n if len(data) <= max_ic:\\n raise IOError('Not enough collumns in %s based on input information.' % filename)\\n\\n if self.ic_t >= 0:\\n self.t.append( float( data[self.ic_t] ) * self.t_conversion)\\n if self.ic_b >= 0:\\n self.b.append( float( data[self.ic_b] ))\\n if self.ic_h >= 0:\\n self.h.append( float( data[self.ic_h] ))\\n if self.ic_m >= 0:\\n self.m.append( float( data[self.ic_m] ))\\n\\n ifile.close()\",\n \"def _read(self, source, label_source=None):\\n filename = os.path.join(\\\"data\\\", \\\"sources\\\", source+\\\".csv\\\")\\n if label_source is None:\\n label_filename = os.path.join(\\\"data\\\", \\\"labels\\\", source + \\\".columnmap.txt\\\")\\n else:\\n label_filename = os.path.join(\\\"data\\\", \\\"labels\\\", label_source)\\n df = pd.read_csv(filename, dtype=str) # read the data source as a DataFrame\\n # labels = pd.read_csv(label_filename) # read the semantic labels of columns in df\\n\\n labels_frame = pd.read_csv(label_filename, na_values=[\\\"\\\"], dtype={'column_name': 'str'})\\n # dictionary (column_name, class_label)\\n labels = labels_frame[['column_name', 'semantic_type']].dropna().set_index('column_name')['semantic_type'].to_dict()\\n # logging.info(\\\"labels:{}\\\".format(labels))\\n\\n source_cols = []\\n for c in df.columns:\\n # label = str(labels.get_value(labels[labels['column_name'] == c].index[0], 'semantic_type')) # extract semantic label of column c\\n if c in labels:\\n label = labels[c]\\n else:\\n label = 'unknown'\\n col = Column(filename=filename, colname=c, title=label, lines=list(df[c]))\\n source_cols.append(col)\\n\\n return source_cols\",\n \"def load_input(self, number_of_rows_to_read):\\n self.dataframe = pandas.read_csv(self.filename, nrows=number_of_rows_to_read)\\n #self._describe_input_data()\",\n \"def load_data_multilabel(traning_data_path,vocab_word2index, vocab_label2index,sentence_len,training_portion=0.95):\\n file_object = codecs.open(traning_data_path, mode='r', encoding='utf-8')\\n lines = file_object.readlines()\\n random.shuffle(lines)\\n label_size=len(vocab_label2index)\\n X = []\\n Y = []\\n for i,line in enumerate(lines):\\n raw_list = line.strip().split(\\\"__label__\\\")\\n input_list = raw_list[0].strip().split(\\\" \\\")\\n input_list = [x.strip().replace(\\\" \\\", \\\"\\\") for x in input_list if x != '']\\n x=[vocab_word2index.get(x,UNK_ID) for x in input_list]\\n label_list = raw_list[1:]\\n label_list=[l.strip().replace(\\\" \\\", \\\"\\\") for l in label_list if l != '']\\n label_list=[vocab_label2index[label] for label in label_list]\\n y=transform_multilabel_as_multihot(label_list,label_size)\\n X.append(x)\\n Y.append(y)\\n if i<10:print(i,\\\"line:\\\",line)\\n\\n X = pad_sequences(X, maxlen=sentence_len, value=0.) # padding to max length\\n number_examples = len(lines)\\n training_number=int(training_portion* number_examples)\\n train = (X[0:training_number], Y[0:training_number])\\n\\n test_number=int((number_examples-training_number)/2)\\n\\n\\n test = (X[training_number+ 1:training_number+test_number], Y[training_number + 1:training_number+test_number])\\n valid = (X[training_number + test_number + 1:],\\n Y[training_number + test_number + 1:])\\n\\n return train,test,valid\",\n \"def load_dataset(filename):\\n return [(\\n lambda point: {\\n 'coordinate': tuple(map(float, point[:-1])),\\n 'label': int(point[-1])})\\n (string.strip().rstrip().split(','))\\n for string in open(filename, 'r').read()\\n .strip().rstrip().split('\\\\n')]\",\n \"def load_data(file_name):\\r\\n with open(str(file_name)) as f:\\r\\n file = f.readlines()\\r\\n label = file[0].strip().split(\\\",\\\")[1:-1]\\r\\n file = file[1:]\\r\\n row = len(file)\\r\\n col = len(file[0].strip().split(\\\",\\\"))-1\\r\\n mat = np.zeros((row, col))\\r\\n for i in range(len(file)):\\r\\n row = file[i].strip()\\r\\n cols = row.split(\\\",\\\")[1:]\\r\\n for j in range(len(cols)):\\r\\n mat[i][j] = int(cols[j])\\r\\n np.random.seed(10)\\r\\n np.random.shuffle(mat)\\r\\n X = mat[:, 0:-1]\\r\\n y = mat[:, -1]\\r\\n\\r\\n return X, y, label\",\n \"def _load_data(self):\\n\\n path_data_x = \\\\\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_feature_data' \\\\\\n '.csv'\\n path_data_y = \\\\\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_label_data' \\\\\\n '.csv'\\n path_meta = '/workspace/base-ml/data/tadpole' \\\\\\n '/adni_one_baseline_meta_data' \\\\\\n '.csv'\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y) # 0 NL, 1, MCI, 2 Dementia\\n read_data_meta = pd.read_csv(path_meta)[['AGE', 'PTGENDER', 'APOE4']]\\n\\n # Replace gender to numeric\\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Male', 0)\\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Female', 1)\\n\\n new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n # Concat meta-information with feature vector input\\n concat_meta = pd.DataFrame(new_data_meta)\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(0, 'zero')\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(1, 'one')\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(2, 'two')\\n concat_meta = concat_meta.to_numpy()\\n new_data_x = np.concatenate([concat_meta, new_data_x], 1)\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n self.orig_column_names = ['Age', 'Gender', 'APOE4'] + \\\\\\n list(read_data_x.columns)\\n self.data_x = new_data_x\\n self.data_y = self.to_one_hot_encoding(new_data_y)\\n self.numerical_idx = np.arange(new_data_x.shape[-1])\\n self.numerical_idx = np.delete(self.numerical_idx, [2]) # Remove APOE column idx\\n self.non_num_idx = np.array([2])\\n self.all_non_numerical_idx = None\\n\\n # self.numerical_idx = np.arange(self.data_x.shape[-1])\\n # self.non_num_idx = None\\n # self.all_non_numerical_idx = None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32')\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def _load_data(self):\\n\\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\\\\n self.task_num\\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\\n\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y)\\n read_data_meta = pd.read_csv(path_meta)\\n\\n # Drop columns if it only contains 1 unique element\\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\\n\\n num_col = pd.read_csv(path_numerical_columns)\\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\\n col_idx = np.arange(read_data_x.shape[-1])\\n non_num_col = np.setdiff1d(col_idx, num_col)\\n\\n # new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_x = np.array(read_data_x)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n\\n # Winsorize dataset\\n len_feat = new_data_x.shape[-1]\\n idx_list = list(num_col)\\n for i in range(len_feat):\\n if i in idx_list:\\n cur_data = new_data_x[:, i]\\n cur_data = np.array(cur_data)\\n lower_p = np.percentile(cur_data, 5)\\n higher_p = np.percentile(cur_data, 95)\\n cur_data[cur_data < lower_p] = lower_p\\n cur_data[cur_data > higher_p] = higher_p\\n new_data_x[:, i] = cur_data\\n\\n # Make sure target data is one-hot encoded\\n if new_data_y.shape[-1] == 1:\\n num_class = len(np.unique(new_data_y))\\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\\n new_data_y = new_data_y.astype('float32')\\n self.orig_column_names = read_data_x.columns\\n self.data_x = new_data_x # N x F\\n self.data_y = new_data_y # N x C\\n self.numerical_idx = num_col # list of idx\\n self.non_num_idx = non_num_col # None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32') # N x 3\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def load_data(filename):\\r\\n with open(filename,'rb') as f:\\r\\n data = pk.load(f,encoding='bytes')\\r\\n return data[b'data'],data[b'labels']\",\n \"def load_tagged_data(filename, desc_col, alphabet, char_seq_length, ispickle=True, **kwargs):\\n logger = logging.getLogger(__name__)\\n logger.info(\\\"Reading data file\\\")\\n \\n if ispickle:\\n with open(filename, 'rb') as f:\\n df = pickle.load(f, encoding='UTF-8')\\n \\n else:\\n if \\\"sep\\\" in kwargs:\\n sep = kwargs[\\\"sep\\\"]\\n else:\\n sep = ','\\n df = pd.read_csv(filename, sep=sep)\\n \\n logger.info(\\\"number of rows in file {}\\\".format(df.shape[0]))\\n df.columns = [col.lower() for col in df.columns]\\n \\n # Map the actual labels to one hot labels\\n labels = sorted(df['res_category'].unique())\\n logger.info(\\\"numbers of distinct categories value {}\\\".format(len(labels)))\\n one_hot = np.zeros((len(labels), len(labels)), int)\\n np.fill_diagonal(one_hot, 1)\\n label_dict = dict(zip(labels, one_hot))\\n\\n # converting labels to one hot encoded values\\n y_raw = df['res_category'].apply(lambda y: label_dict[y]).tolist()\\n \\n x_raw = df[desc_col]\\n x_raw = x_raw.apply(lambda x: str(x))\\n logging.info(\\\"applying padding\\\")\\n x_raw = [pad_sentence(x, char_seq_length) for x in x_raw]\\n\\n alphabet_to_int = {}\\n\\n for i, char in enumerate(alphabet):\\n alphabet_to_int[char] = i\\n\\n logging.info(\\\"converting to int\\\")\\n x_raw = [string_to_int8_conversion(x, alphabet_to_int) for x in x_raw]\\n\\n #logging.info(\\\"converting character sequences to one-hot vectors for cnn input\\\")\\n #x_raw = [get_one_hot(x, alphabet, char_seq_length) for x in x_raw]\\n\\n logging.info(\\\"data loading complete\\\")\\n return x_raw, y_raw, labels\",\n \"def load_training_data(fname):\\n all_data = load_csv(fname, 'excel-tab')\\n\\n labels = [rec[2] == 'OFF' for rec in all_data]\\n data = [convert_to_reals(clean_text(rec[1])) for rec in all_data]\\n max_features = max([len(rec) for rec in data])\\n\\n # Pad the data\\n for rec in data:\\n rec.extend([0.0] * (max_features - len(rec)))\\n\\n return labels, data, max_features\",\n \"def load_data_multilabel(traning_data_path,vocab_word2index, vocab_label2index,sentence_len,training_portion=0.95):\\n file_object = codecs.open(traning_data_path, mode='r', encoding='utf-8')\\n lines = file_object.readlines()\\n random.shuffle(lines)\\n label_size=len(vocab_label2index)\\n X = []\\n Y = []\\n for i,line in enumerate(lines):\\n raw_list = line.strip().split(\\\"__label__\\\")\\n input_list = raw_list[0].strip().split(\\\" \\\")\\n input_list = [x.strip().replace(\\\" \\\", \\\"\\\") for x in input_list if x != '']\\n x=[vocab_word2index.get(x,UNK_ID) for x in input_list]\\n label_list = raw_list[1:]\\n label_list=[l.strip().replace(\\\" \\\", \\\"\\\") for l in label_list if l != '']\\n label_list=[vocab_label2index[label] for label in label_list]\\n y=transform_multilabel_as_multihot(label_list,label_size)\\n X.append(x)\\n Y.append(y)\\n if i<10:print(i,\\\"line:\\\",line)\\n\\n X = pad_sequences(X, maxlen=sentence_len, value=0.) # padding to max length\\n number_examples = len(lines)\\n training_number=int(training_portion* number_examples)\\n train = (X[0:training_number], Y[0:training_number])\\n valid_number=min(1000,number_examples-training_number)\\n test = (X[training_number+ 1:training_number+valid_number+1], Y[training_number + 1:training_number+valid_number+1])\\n return train,test\",\n \"def load_expected(filename):\\n\\n all_labels = sorted([int(k) for k in open(filename).readline().split()[1:]])\\n data = numpy.loadtxt(filename, dtype='float64', skiprows=1)\\n return all_labels, data[:,0].astype('int64'), data[:,1:]\",\n \"def from_label_file(cls, label_file_path, out_path=FEATURES_DATA_PATH, source_path=RAW_DATA_PATH):\\n df = pd.read_csv(label_file_path)\\n filenames = df['filename']\\n labels = df['label']\\n return cls(filenames, labels, out_path=out_path, source_path=source_path)\",\n \"def load_data():\\r\\n global labelNames\\r\\n print(\\\"Loading Data...\\\")\\r\\n\\r\\n fnpath = \\\"rawdata\\\\\\\\cifar-10-batches-py\\\"\\r\\n fnprefix = 'data_batch_'\\r\\n fnlblnames = 'batches.meta'\\r\\n fntstbatch = 'test_batch'\\r\\n\\r\\n labelNames = unpickle(path.join(fnpath, fnlblnames))\\r\\n label_names = []\\r\\n for label in labelNames['label_names']:\\r\\n label_names.append(\\\"\\\".join(map(chr, label)))\\r\\n labelNames['label_names'] = label_names\\r\\n\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\\r\\n for n in range(1, 6):\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))\",\n \"def load_dataset(filepath):\\n \\n X = list()\\n x = list()\\n\\n Y = list()\\n y = list()\\n \\n for line in open(filepath):\\n # blank lines separate sequences\\n if len(line) <= 1:\\n X.append(x)\\n Y.append(y)\\n\\n x = list()\\n y = list()\\n else:\\n a, b = line.strip().split('\\\\t')\\n x.append(a)\\n y.append(b)\\n \\n return X, Y\",\n \"def read_data(self,filename):\\n self.x = [] #Input values\\n self.t = [] #Target values\\n\\n with open(filename, \\\"r\\\") as infile:\\n lines = infile.readlines()\\n self.n = len(lines)\\n for line in lines:\\n words = line.split()\\n self.x.append(float(words[0]))\\n self.t.append(float(words[1]))\\n\\n self.x = np.array(self.x)\\n self.t = np.array(self.t)\\n self.create_design_matrix()\",\n \"def load_labels(path):\\n with open(path, 'r', encoding='utf-8') as f:\\n lines = f.readlines()\\n labels = {}\\n for row_number, content in enumerate(lines):\\n pair = re.split(r'[:\\\\s]+', content.strip(), maxsplit=1)\\n if len(pair) == 2 and pair[0].strip().isdigit():\\n labels[int(pair[0])] = pair[1].strip()\\n else:\\n labels[row_number] = pair[0].strip()\\n return labels\",\n \"def load_data():\\n x = np.genfromtxt(X_FILE, usecols=(0, 1))\\n y = np.genfromtxt(Y_FILE, usecols=(0))\\n\\n return x, y\",\n \"def read_label(filepath, read_scalars=False):\\n label_array = np.loadtxt(filepath, dtype=np.int, skiprows=2, usecols=[0])\\n if read_scalars:\\n scalar_array = np.loadtxt(filepath, skiprows=2, usecols=[-1])\\n return label_array, scalar_array\\n return label_array\",\n \"def load_data(filename):\\n assert os.path.exists(filename)==True\\n dat = scipy.io.loadmat(filename)\\n inputs = dat['inputs']\\n #print len(inputs)\\n targets = dat['targets']\\n #print len(targets)\\n assert len(inputs)==len(targets)\\n\\n global alldata\\n global indim \\n global outdim\\n\\n indim = len(inputs[0])\\n outdim = 1\\n #print indim\\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\\n alldata.setField('input',inputs)\\n alldata.setField('target',targets)\\n\\n assert len(alldata['input'])==len(alldata['target'])\\n print type(alldata)\",\n \"def read_file(filename):\\n contents, labels = [], []\\n with open_file(filename) as f:\\n for line in f:\\n try:\\n label,content = line.strip().split('\\\\t')\\n contents.append(list(content))\\n labels.append(label)\\n except:\\n pass\\n return contents,labels\",\n \"def read_labels(labels_file):\\n if not labels_file:\\n print 'WARNING: No labels file provided. Results will be difficult to interpret.'\\n return None\\n\\n labels = []\\n with open(labels_file) as infile:\\n for line in infile:\\n label = line.strip()\\n if label:\\n labels.append(label)\\n assert len(labels), 'No labels found'\\n return labels\",\n \"def load_data(self):\\n print('Loading {} dataset'.format(self.split))\\n data_split_path = os.path.join(self.root_dir, 'splits', '{}.csv'.format(self.split))\\n with open(data_split_path,'r') as f:\\n reader = csv.reader(f, delimiter=',')\\n data_classes = {}\\n for i,row in enumerate(reader):\\n if i==0:\\n continue\\n data_classes[row[1]] = 1\\n data_classes = data_classes.keys()\\n print(data_classes)\\n\\n n_classes = len(data_classes)\\n print('n_classes:{}, n_label:{}, n_unlabel:{}'.format(n_classes,self.n_label,self.n_unlabel))\\n dataset_l = np.zeros([n_classes, self.n_label, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n if self.n_unlabel>0:\\n dataset_u = np.zeros([n_classes, self.n_unlabel, self.im_height, self.im_width, self.channels], dtype=np.float32)\\n else:\\n dataset_u = []\\n\\n for i, cls in enumerate(data_classes):\\n im_dir = os.path.join(self.root_dir, 'data/{}/'.format(self.split), cls)\\n im_files = sorted(glob.glob(os.path.join(im_dir, '*.jpg')))\\n np.random.RandomState(self.seed).shuffle(im_files) # fix the seed to keep label,unlabel fixed\\n for j, im_file in enumerate(im_files):\\n im = np.array(Image.open(im_file).resize((self.im_width, self.im_height)), \\n np.float32, copy=False)\\n if j<self.n_label:\\n dataset_l[i, j] = im\\n else:\\n dataset_u[i,j-self.n_label] = im\\n print('labeled data:', np.shape(dataset_l))\\n print('unlabeled data:', np.shape(dataset_u))\\n \\n self.dataset_l = dataset_l\\n self.dataset_u = dataset_u\\n self.n_classes = n_classes\",\n \"def _read_labels(test_data=False):\\n if not test_data:\\n filename = os.path.join(FOLDER_PATH, 'train-labels.idx1-ubyte')\\n else:\\n filename = os.path.join(FOLDER_PATH, 't10k-labels.idx1-ubyte')\\n if not os.path.exists(filename):\\n raise ValueError('The file dose not exist.')\\n \\n # Create a queue that produces the filenames to read.\\n filename_queue = tf.train.string_input_producer([filename])\\n \\n # The first 8 bytes contain file information:\\n # [offset] [type] [value] [description]\\n # 0000 32 bit integer 0x00000801(2049) magic number\\n # 0004 32 bit integer 60000/10000 number of items \\n # ...(label value)\\n header_bytes = 8\\n # Every record consists of a label, with a fixed number of bytes for each.\\n record_bytes = 1\\n \\n # Create a FixedLengthRecordReader to read record.\\n reader = tf.FixedLengthRecordReader(record_bytes=record_bytes,\\n header_bytes=header_bytes)\\n _, value = reader.read(filename_queue)\\n\\n # Convert from a string to a vector of uint8, then cast to int32.\\n record = tf.cast(tf.decode_raw(value, tf.uint8), tf.int32)\\n \\n # Reshape from [1] to a scalar shape [].\\n label = tf.reshape(record, [])\\n\\n return label\",\n \"def load_data_and_labels():\\n # Load data from files\\n positive_examples = list(\\n open(\\\"./data/rt-polarity.pos\\\", \\\"r\\\", encoding='latin-1').readlines())\\n positive_examples = [s.strip() for s in positive_examples]\\n negative_examples = list(\\n open(\\\"./data/rt-polarity.neg\\\", \\\"r\\\", encoding='latin-1').readlines())\\n negative_examples = [s.strip() for s in negative_examples]\\n # Split by words\\n x_text = positive_examples + negative_examples\\n x_text = [clean_str(sent) for sent in x_text]\\n x_text = [s.split(\\\" \\\") for s in x_text]\\n # Generate labels\\n positive_labels = [[0, 1] for _ in positive_examples]\\n negative_labels = [[1, 0] for _ in negative_examples]\\n y = np.concatenate([positive_labels, negative_labels], 0)\\n return [x_text, y]\",\n \"def _load_data(self):\\n data_x, data_y = make_classification(n_samples=5000, n_features=20,\\n n_informative=10,\\n n_redundant=0, n_repeated=0,\\n n_classes=2,\\n n_clusters_per_class=4,\\n weights=None, flip_y=0.01,\\n class_sep=1.0, hypercube=True,\\n shift=0.0, scale=1.0,\\n shuffle=True,\\n random_state=self.args.rand_seed)\\n\\n self.orig_column_names = np.arange(data_x.shape[-1])\\n self.data_x = data_x\\n self.data_y = self.to_one_hot_encoding(data_y)\\n self.numerical_idx = np.arange(data_x.shape[-1])\\n self.non_num_idx = None\\n self.all_non_numerical_idx = None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = data_x[:, :1].astype('float32')\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def load_label(path_file):\\n if '.csv' not in path_file:\\n raise FileNotFoundError('Only CSV format is supported currently')\\n\\n t0 = time()\\n df = pd.DataFrame()\\n\\n with open(path_file, 'r') as f:\\n # TODO: Implement the logic once the format is finalised\\n pass\\n\\n logging.info('Loading label data with {} rows from {} takes {} secs'.format(df.shape[0],\\n path_file, time() - t0))\\n return df\",\n \"def ReadAndReshape(dataFile):\\n raw_data = scio.loadmat(dataFile)\\n data = raw_data['data']\\n data = data.astype(np.float64)\\n data = data / 255\\n raw_label = raw_data['labels']\\n label = list()\\n for value in raw_label:\\n l = np.zeros(10)\\n l[value] = 1\\n label.append(l)\\n label = np.array(label)\\n return data, label\",\n \"def readFromFile(self,ffile,nbcolumns=None,columnsNames='yes',name='no',columnsUnits='no'):\\n from exceptions import IOError\\n try:\\n if self.data.shape != (0,0):\\n raise Exception(\\\"The table already contains values\\\")\\n file = open(ffile, 'r')\\n except :\\n msg=\\\"can't open file <%s>...\\\\n\\\"%ffile\\n raise IOError(msg)\\n\\n\\n fileNameColumns=[]\\n fileNameUnits=[]\\n fileName=None\\n \\n filemaxnbcol=0\\n fileminnbcol=100\\n isonvalues=0\\n allvaluesbycolonne=[]\\n nbvalueline=0\\n cpt=1\\n for line in file.readlines():\\n separe = line.split()\\n if (len(separe) == 0 ):\\n # blank line\\n continue\\n \\n \\n if ( separe[0] == '#' ):\\n # comment line\\n cpt=cpt+1\\n continue\\n elif ( separe[0] == '#TITLE:' ):\\n # name line\\n separe = separe[1:]\\n s=''\\n for isep in range(len(separe)):\\n s=s+separe[isep]+' '\\n fileName=s\\n pass\\n elif ( separe[0] == '#COLUMN_TITLES:' ):\\n # column name line\\n separe = separe[1:]\\n s=''\\n for isep in range(len(separe)):\\n s=s+separe[isep]\\n s=string.strip(s)\\n if ( len(s) == 0 ):\\n fileNameColumns=[]\\n continue\\n fileNameColumns = s.split('|')\\n pass\\n pass\\n elif ( separe[0] == '#columnUnits:' ):\\n # unit name line\\n fileNameUnits = separe[1:]\\n pass\\n elif ( cpt == 1 ):\\n # column name line\\n pass\\n else:\\n # values line\\n nbvalueline=nbvalueline+1\\n linenbcol=len(separe)\\n filemaxnbcol=max(linenbcol,filemaxnbcol)\\n fileminnbcol=min(linenbcol,fileminnbcol)\\n linevalues=[]\\n \\n for isep in range(linenbcol): linevalues.append(float(separe[isep]))\\n \\n # adjust nb columns if not the same on each line\\n # or if the first value's line\\n if ( filemaxnbcol < len(allvaluesbycolonne) ):\\n for icol in range(filemaxnbcol,len(allvaluesbycolonne)):\\n allvaluesbycolonne.append([])\\n for il in range(nbvalueline-1):\\n allvaluesbycolonne[il].append(0)\\n pass\\n pass\\n elif ( filemaxnbcol > len(allvaluesbycolonne) ):\\n for icol in range(len(allvaluesbycolonne),filemaxnbcol):\\n allvaluesbycolonne.append([])\\n for il in range(nbvalueline-1):\\n allvaluesbycolonne[icol].append(0)\\n pass\\n pass\\n pass\\n # add values\\n for icol in range(linenbcol): allvaluesbycolonne[icol].append(linevalues[icol])\\n for icol in range(linenbcol,filemaxnbcol): allvaluesbycolonne[icol].append(0)\\n \\n cpt=cpt+1\\n pass\\n file.close()\\n #\\n # check consistency beetwen arguments and file contents\\n #\\n # controlling the table parameters\\n # \\n if ( fileminnbcol != filemaxnbcol ):\\n raise IOError(\\\"colums must have the same number of rows\\\")\\n \\n if nbcolumns:\\n if ( filemaxnbcol != nbcolumns ):\\n raise IOError(\\\" problem with the number of columns\\\")\\n pass\\n \\n # Warnings\\n if ( ( columnsNames.lower() == 'no' ) and ( len(fileNameColumns) > 0 ) ):\\n raise Warning(\\\" you should specify column names\\\")\\n \\n if ( ( columnsNames.lower() == 'yes' ) and ( len(fileNameColumns) == 0 ) ):\\n raise Warning(\\\"you specified columnName(s) but the file doesn\\\\'t entail column names\\\")\\n \\n if ( len(fileNameColumns) < filemaxnbcol ):\\n nbcol=len(fileNameColumns)\\n for icol in range (nbcol,filemaxnbcol): fileNameColumns.append('col'+str(icol+1))\\n \\n effectivecolumnNames=fileNameColumns\\n \\n \\n if ( ( name.lower() == 'no' ) and fileName ):\\n msg='WARNING: you specified no name but there is name in file'\\n print(msg)\\n \\n if ( ( name.lower() == 'yes' ) and ( fileName == None ) ):\\n msg='WARNING: you specified name but there is no name in file'\\n print(msg)\\n \\n if ( ( columnsUnits.lower() == 'no' ) and ( len(fileNameUnits) > 0 ) ):\\n msg='WARNING: you specified no units name but there are units name in file'\\n print(msg)\\n \\n if ( ( columnsUnits.lower() == 'yes' ) and ( len(fileNameUnits) == 0 ) ):\\n msg='WARNING: you specified units name but there are no units name in file'\\n print(msg)\\n \\n if ( ( len(fileNameUnits) > 0 ) and ( len(fileNameUnits) < filemaxnbcol ) ):\\n nbcol=len(fileNameUnits)\\n for icol in range (nbcol,filemaxnbcol): fileNameUnits.append('col'+str(icol+1))\\n pass\\n \\n\\n\\n if fileName:\\n self.setName(fileName)\\n pass\\n if len(fileNameUnits):\\n self.setColumnUnits(fileNameUnits)\\n\\n for i in range(filemaxnbcol):\\n if columnsNames.lower()=='yes':\\n self.addColumn(effectivecolumnNames[i],allvaluesbycolonne[i])\\n pass\\n else:\\n self.addColumnValues(allvaluesbycolonne[i])\\n pass\\n return\",\n \"def load_label_data(config):\\n label_data = pd.read_csv(config.LabelDataConfig.data_path)\\n ids = list(label_data['Training cases final'])\\n labels = config.build_labels(label_data)\\n\\n train_ids, val_ids, train_labels, val_labels = train_test_split(\\n ids,\\n labels,\\n stratify=labels,\\n train_size=config.ImageDataConfig.train_percent)\\n\\n train_label_data = {image_id.upper(): label\\n for image_id, label in izip(train_ids, train_labels)}\\n val_label_data = {image_id.upper(): label\\n for image_id, label in izip(val_ids, val_labels)}\\n\\n return train_label_data, val_label_data\",\n \"def load_data(self, filename):\\r\\n #sqlcontext = SQLContext(self.sc)\\r\\n #df = sqlcontext.read.format('com.databricks.spark.csv').options(header='false', inferschema='true').load(filename)\\r\\n #df = sc.textFile(r\\\"C:\\\\Users\\\\mohan\\\\Downloads\\\\patches.csv\\\").map(lambda line: line.split(\\\",\\\"))\\r\\n #print (df.count())\\r\\n df = self.sc.textFile(filename).map(lambda line: line.split(\\\",\\\"))\\r\\n l = df.map(lambda w: [int(float(c)) for c in w]).zipWithIndex()\\r\\n return l\\r\\n raise NotImplementedError\",\n \"def loadData ( self ) :\\n df = pd.read_json ( self.dataset )\\n df = df[pd.notnull ( df[2] )]\\n df[1] = df[1].apply ( self.clean_text )\\n\\n self.X = df[1]\\n self.y = df[2]\",\n \"def load_text_and_label(data_file):\\n # load data from file\\n\\n # splite by word\\n dfRaw = pd.read_csv(data_file)\\n dfRec = dfRaw[['Review Text', 'Recommended IND']].dropna()\\n pos_examples = dfRec[dfRec['Recommended IND'] == 1]['Review Text'].tolist()\\n neg_examples = dfRec[dfRec['Recommended IND'] == 0]['Review Text'].tolist()\\n\\n x_text = pos_examples + neg_examples\\n x_text = np.array([clean_str(sentence) for sentence in x_text])\\n # generate label (y)\\n pos_labels = [[0,1] for _ in pos_examples]\\n neg_labels = [[1,0] for _ in neg_examples]\\n y = np.array(pos_labels + neg_labels)\\n return [x_text, y]\",\n \"def load(self, path=\\\"../data_set/final-train-dataset.csv\\\", shuffle=False,\\n onlyLabelToUse=None, useOnlyBestIndicators=False, binary=False):\\n data = []\\n labels = []\\n\\n with open(path) as csvfile:\\n reader = csv.reader(csvfile, delimiter=',')\\n skip = True\\n\\n for row in reader:\\n if skip:\\n skip = False\\n continue\\n\\n entries = []\\n\\n for i in range(SAMPLES_OF_DATA_TO_LOOK_AT):\\n # Get one time point's data, including indicators:\\n if useOnlyBestIndicators:\\n # entries.append(\\n # [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\\n #\\n entries.append(\\n [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\\n j in [0, 1, 2, 5, 7]])\\n else:\\n entries.append(\\n [float(row[i + j * SAMPLES_OF_DATA_TO_LOOK_AT]) for\\n j in range(INPUT_CHANNELS)])\\n\\n data.append(np.array(entries))\\n\\n if onlyLabelToUse is not None:\\n if binary:\\n label = [int(float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + onlyLabelToUse]) > 0.5)]\\n else:\\n label = [float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + onlyLabelToUse])]\\n else:\\n if binary:\\n label = [int(float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + j]) > 0.5) for j in range(OUTPUT_CHANNELS)]\\n else:\\n label = [float(row[SAMPLES_OF_DATA_TO_LOOK_AT * TOTAL_INPUTS_IN_DATASET + j]) for j in range(OUTPUT_CHANNELS)]\\n\\n labels.append(label)\\n\\n if shuffle:\\n indices = [i for i in range(len(data))]\\n np.random.shuffle(indices)\\n labels = np.array([labels[i] for i in indices])\\n data = np.array([data[i] for i in indices])\\n else:\\n data = np.array(data)\\n labels = np.array(labels)\\n\\n return data, labels\",\n \"def load_data_csv(self, filename):\\n import csv\\n\\n self.begin_batch() #avoid unecessary updates\\n\\n #delete old data\\n #TODO: check of deleting data is really what user wants\\n #TODO: create method for clearing data\\n msg = wx.grid.GridTableMessage(self,\\n wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED,\\n 0,\\n self.GetNumberRows())\\n self.rowmask = numpy.array([], dtype = numpy.bool)\\n self.data = numpy.empty(shape = (0, len(self.colLabels)), dtype = numpy.object)\\n self.GetView().ProcessTableMessage(msg)\\n \\n #process file\\n with open(filename, 'rb') as f:\\n\\n #read first row to extract fieldnames\\n header = csv.reader(f).next()\\n\\n #parse field header \\\"name [dynamic] (custom label)\\\"\\n pattern = re.compile(r\\\"(?P<name>\\\\w+(\\\\s\\\\w+)?)\\\\s*(\\\\[(?P<dynamic>.*)\\\\])?\\\\s*(\\\\((?P<label>.*)\\\\))?\\\\s*(\\\\{(?P<options>.*)\\\\})?\\\",\\n re.VERBOSE)\\n fields = []\\n dyn_expr = {}\\n cust_label = {}\\n vis_cols = {}\\n for entry in header:\\n r = pattern.match(entry)\\n d = r.groupdict()\\n name = d['name']\\n if name:\\n fields.append(name)\\n if d['dynamic']: dyn_expr[name] = d['dynamic']\\n if d['label']: cust_label[name] = d['label']\\n if d['options']:\\n if '*' in d['options']: vis_cols[name] = True\\n\\n #set dynamic expressions\\n for k, col in enumerate(self.dynamic_cols):\\n dexpr = dyn_expr.get(self.colLabels[col])\\n if dexpr:\\n self.dynamic_expressions[k] = dexpr\\n\\n #set custom column labels\\n for k, label in enumerate(self.colLabels):\\n clabel = cust_label.get(label)\\n if clabel:\\n self.column_labels_custom[k] = clabel\\n\\n #also show columns which are marked as visible in csv file\\n colsel = set(self.colsel)\\n for k, label in enumerate(self.colLabels):\\n if vis_cols.get(label):\\n colsel.add(k)\\n colsel = list(colsel)\\n colsel.sort()\\n self.View.SetColumnSelection(colsel)\\n\\n #read data\\n reader = csv.DictReader(f, fieldnames = fields)\\n\\n row = -1\\n for rowdict in reader:\\n row += 1\\n self.AppendRows()\\n\\n if rowdict.get('masked') == 'True':\\n self.maskrows(row)\\n\\n #loop over columns in _actual_ table, \\n for col, typelabel in enumerate(zip(self.dataTypes, self.colLabels)):\\n datatype, label = typelabel\\n\\n #ask csv reader whether corresponding entry exists \\n value = rowdict.get(label)\\n if value is None or value == '':\\n continue\\n\\n try:\\n #convert string value to proper type\\n #TODO: optimize it by creating a table of conversion functions\\n #or a table method that takes a string\\n if wx.grid.GRID_VALUE_FLOAT in datatype:\\n val = float(value)\\n elif wx.grid.GRID_VALUE_NUMBER in datatype:\\n val = int(value)\\n elif wx.grid.GRID_VALUE_BOOL in datatype:\\n if value == '1' or value == 'True':\\n val = True\\n else:\\n val = False\\n elif wx.grid.GRID_VALUE_STRING in datatype:\\n val = value\\n else:\\n print \\\"loading of type %s is not supported\\\"%datatype\\n continue\\n\\n self.SetValueRaw(row, col, val)\\n except ValueError:\\n print \\\"warning reading csv: cannot convert value '%s' to type %s\\\"%(value, datatype)\\n\\n self.AppendRows(2) \\n self.end_batch()\\n self.modified = False\",\n \"def labels_data(protein_data_path, columns):\\n labels = pd.read_csv(protein_data_path, sep=\\\"\\\\t\\\").fillna(0)\\n return labels[columns].astype(int).values\",\n \"def load_file(filename,label_len):\\n embedding = np.load(filename)\\n# sample_frames = hp.sample_frames\\n# while(1):\\n# n_frames = (embedding.shape[0]-1)/sample_frames + 1\\n# if (embedding.shape[0]-1)%sample_frames!=0:\\n# n_frames += 1\\n# if n_frames>=label_len:\\n# break\\n# sample_frames-=1\\n \\n arr = []\\n for i in range(0,embedding.shape[0],hp.sample_frames):\\n arr.append(embedding[i])\\n \\n #always include ending frame\\n if (embedding.shape[0]-1)%hp.sample_frames!=0:\\n arr.append(embedding[-1])\\n \\n length = len(arr)\\n arr = np.array(arr) \\n \\n return arr, length\",\n \"def process_dataset_file(data, label):\\n\\n # Select only required columns\\n data = select_columns(data)\\n\\n # Colums are divided into features and labels\\n data_x, data_y = divide_x_y(data, label)\\n data_y = adjust_labels(data_y, label)\\n data_y = data_y.astype(int)\\n\\n # Perform linear interpolation\\n data_x = np.array([Series(i).interpolate() for i in data_x.T]).T\\n\\n # Remaining missing data is replaced with 0\\n data_x[np.isnan(data_x)] = 0\\n\\n # Normalize sensor channels\\n data_x = norm(data_x, MAX_THRESHOLDS, MIN_THRESHOLDS)\\n\\n return data_x, data_y\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74831015","0.7439754","0.69201815","0.68371534","0.68163675","0.6701311","0.665933","0.65913653","0.65871","0.6568758","0.6536346","0.653422","0.65012157","0.648894","0.6411348","0.63984174","0.63932616","0.63891995","0.63853955","0.63792837","0.63691723","0.63664657","0.6349134","0.6314104","0.631195","0.62986743","0.6272563","0.62699866","0.625377","0.62291026","0.6228861","0.6214645","0.62059397","0.6187067","0.6161736","0.61615133","0.61407363","0.6139268","0.613182","0.6128728","0.61190206","0.61181724","0.61011916","0.6096533","0.6095406","0.60911465","0.6089582","0.6088926","0.60880685","0.60848624","0.60713476","0.6050581","0.60504586","0.6046235","0.6039309","0.6033385","0.60330254","0.60294604","0.600898","0.5998791","0.5996453","0.5977997","0.5975531","0.5970771","0.59666145","0.5962685","0.5956014","0.59533274","0.595163","0.59499246","0.59322536","0.5928067","0.59266037","0.59094423","0.59005207","0.58952534","0.5884407","0.58812666","0.5869453","0.5868894","0.58684796","0.58598053","0.5849753","0.5839454","0.5838847","0.583675","0.58366275","0.5836248","0.58339274","0.5829122","0.580901","0.58087975","0.5790248","0.5789281","0.57852215","0.57761085","0.57567734","0.5750294","0.57408947","0.5739753","0.5738203"],"string":"[\n \"0.74831015\",\n \"0.7439754\",\n \"0.69201815\",\n \"0.68371534\",\n \"0.68163675\",\n \"0.6701311\",\n \"0.665933\",\n \"0.65913653\",\n \"0.65871\",\n \"0.6568758\",\n \"0.6536346\",\n \"0.653422\",\n \"0.65012157\",\n \"0.648894\",\n \"0.6411348\",\n \"0.63984174\",\n \"0.63932616\",\n \"0.63891995\",\n \"0.63853955\",\n \"0.63792837\",\n \"0.63691723\",\n \"0.63664657\",\n \"0.6349134\",\n \"0.6314104\",\n \"0.631195\",\n \"0.62986743\",\n \"0.6272563\",\n \"0.62699866\",\n \"0.625377\",\n \"0.62291026\",\n \"0.6228861\",\n \"0.6214645\",\n \"0.62059397\",\n \"0.6187067\",\n \"0.6161736\",\n \"0.61615133\",\n \"0.61407363\",\n \"0.6139268\",\n \"0.613182\",\n \"0.6128728\",\n \"0.61190206\",\n \"0.61181724\",\n \"0.61011916\",\n \"0.6096533\",\n \"0.6095406\",\n \"0.60911465\",\n \"0.6089582\",\n \"0.6088926\",\n \"0.60880685\",\n \"0.60848624\",\n \"0.60713476\",\n \"0.6050581\",\n \"0.60504586\",\n \"0.6046235\",\n \"0.6039309\",\n \"0.6033385\",\n \"0.60330254\",\n \"0.60294604\",\n \"0.600898\",\n \"0.5998791\",\n \"0.5996453\",\n \"0.5977997\",\n \"0.5975531\",\n \"0.5970771\",\n \"0.59666145\",\n \"0.5962685\",\n \"0.5956014\",\n \"0.59533274\",\n \"0.595163\",\n \"0.59499246\",\n \"0.59322536\",\n \"0.5928067\",\n \"0.59266037\",\n \"0.59094423\",\n \"0.59005207\",\n \"0.58952534\",\n \"0.5884407\",\n \"0.58812666\",\n \"0.5869453\",\n \"0.5868894\",\n \"0.58684796\",\n \"0.58598053\",\n \"0.5849753\",\n \"0.5839454\",\n \"0.5838847\",\n \"0.583675\",\n \"0.58366275\",\n \"0.5836248\",\n \"0.58339274\",\n \"0.5829122\",\n \"0.580901\",\n \"0.58087975\",\n \"0.5790248\",\n \"0.5789281\",\n \"0.57852215\",\n \"0.57761085\",\n \"0.57567734\",\n \"0.5750294\",\n \"0.57408947\",\n \"0.5739753\",\n \"0.5738203\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93093,"cells":{"query":{"kind":"string","value":"This method receives the whole training data set, the data instance being predicted and the cluster member size."},"document":{"kind":"string","value":"def get_neighbours(self, training_data=(), instance=(), k=3):\n data = []\n neighbours = []\n # calculate the query distance\n for x in range(len(training_data)):\n distance = self.query_distance(instance1=training_data[x][:-1], instance2=instance[:-1])\n data.append([training_data[x], distance])\n # sort the neighbours based on key which is the distance in ascending\n data = sorted(data, key=itemgetter(-1))\n\n # pick the top neighbours of the test data\n for x in range(k):\n neighbours.append(data[:k][x][0])\n\n # return the neighbours of the test data\n return neighbours"},"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 num_train_instances(self):\n raise NotImplementedError()","def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n for i in range(test_data.shape[0]):\n dists=[]\n for c in range(self.centroids_.shape[0]):\n # compute distance between current train_data instance and each cluster\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\n \n # assign point to cluster with minimal distance\n part_of_cluster[i]=dists.index(min(dists))\n\n return part_of_cluster","def __len__(self):\r\n return len(self.train_data)","def n_train(self):\n return self.factors[0].shape[0]","def estimate_label_proportion(source_loader,target_loader,feat_extract,cuda,n_clusters,cluster_param): \n feat_extract.eval()\n #n_clusters = 3\n from sklearn.cluster import AgglomerativeClustering\n \n \n X_s,y_s = extract_feature(source_loader,feat_extract,cuda) \n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \n \n \n \n cluster = AgglomerativeClustering(n_clusters=n_clusters,linkage=cluster_param)\n label_t = cluster.fit_predict(X_t)\n #print(np.unique(label_t))\n mean_mat_S, num_in_class_S = extract_prototypes(X_s,y_s,n_clusters)\n mean_mat_T, num_in_class_T = extract_prototypes(X_t,label_t,n_clusters)\n \n \"\"\"\n We assume that prototypes of classes have been transported in some in the feature\n space \n \"\"\"\n \n import ot\n M = ot.dist(mean_mat_S, mean_mat_T)\n M /= M.max()\n \n n_1 = n_clusters\n a = np.ones((n_1,)) / n_1\n b = np.ones((n_1,)) / n_1\n \n \n gamma = ot.emd(a,b,M)\n nb_sample_S = [ np.sum(y_s==i) for i in range(n_clusters) ]\n proportion_T = num_in_class_T/np.sum(num_in_class_T)\n assignement_source_to_target = gamma.argmax(axis=1)\n \n # proportions are arranged directly per class\n proportion_T = proportion_T[assignement_source_to_target]\n print(proportion_T,assignement_source_to_target)\n \n\n return proportion_T,nb_sample_S, assignement_source_to_target","def predict(self, instances):\r\n raise NotImplementedError","def num_training_examples(self):","def train(self):\n\n print \"==> Running Kmeans on data set of shape: {}\".format(self.data.shape)\n km = KMeans(n_clusters = self.n_clusters)\n km.fit(self.data.values)\n self.labels = km.labels_\n self.inertia = km.inertia_","def get_train_data_size(self):\n return len(self.pipeline.data['train'])","def _predict_feature_sizes(self):\n return self._feature_sizes","def size(self):\r\n return len(self._train_datas)","def training_start(self, dataloader):\n self.datasize = len(dataloader)","def _check_data_size(self):\n if len(self.list_data) < self.n_cluster:\n self.n_cluster = len(self.list_data)","def predict(toPredict=None):\n\tif not toPredict:\n\t\ttoPredict = gc.generate_test_cases(1)[0]\n\ttoPredict = np.asarray(toPredict)\n\ttoPredict = toPredict.reshape(1, -1)\t\n\tclusterer = joblib.load(\"training_data.pkl\")\n\tprint(clusterer.predict(toPredict))","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def supervised_fit(self, x, y):\n self.cluster_label_map = np.random.rand(self._n_components).tolist()\n\n # Perform EM in dataset\n # self.fit(x)\n\n # Get z_{ik} after performing EM algorithm\n z_ik = self.get_posterior(x)\n\n # Get the highest probability of k^th GMM for each data points\n # Assign labels for data points\n em_label = np.argmax(z_ik, axis=1)\n\n # Check with grountruth labels\n for k in range(self._n_components):\n data_idx = np.where(em_label == k)\n if data_idx[0].size:\n coor_data = y[data_idx]\n vote_label = scipy.stats.mode(coor_data)[0][0]\n self.cluster_label_map[k] = vote_label","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def test_predict(self):\n # Check build does not raise errors\n dataset = KDDCupDataset()\n dataset.create_fixed_samples(\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\n dataset.set_current_sample(0)\n model = self.MODEL(dataset, **self.model_arguments)\n model.fit(training_epochs=50)\n true, predictions = model.predict('test')\n expected_size = ((dataset.num_examples('test') //\n model.batch_size) * model.batch_size)\n self.assertEqual(true.shape[0], expected_size)\n self.assertEqual(true.shape, predictions.shape)","def __len__(self):\n return len(self.train) + len(self.val) + len(self.test)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def data_size(self) -> int:\n return len(self.__labels)","def predict(self, X, pred_batch_size=None):","def fit(self, **kwargs):\r\n\r\n self.stats[\"dataset_size\"] = self.user_to_size\r\n\r\n super(DatabasePreferenceLearnerFeatureless, self).fit(**kwargs)","def estimate_label_proportion_GMM(source_loader,target_loader,feat_extract,cuda,n_clusters,prediction=False,n_max=2000): \n feat_extract.eval()\n \n \n X_s,y_s = extract_feature(source_loader,feat_extract,cuda) \n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \n \n if X_s.shape[0]>n_max:\n X_s = X_s[0:n_max,:]\n X_t = X_t[0:n_max,:]\n y_s = y_s[0:n_max]\n y_t = y_t[0:n_max]\n\n gmm = GaussianMixture(n_components=n_clusters,n_init=10)# means_init = mean_mat_S)\n label_t = gmm.fit_predict(X_t) \n mean_mat_S, num_in_class_S = extract_prototypes(X_s,y_s,n_clusters)\n mean_mat_T, num_in_class_T = extract_prototypes(X_t,label_t,n_clusters)\n \n \"\"\"\n We assume that prototypes of classes have been transported in some in the feature\n space \n \"\"\"\n \n import ot\n M = ot.dist(mean_mat_S, mean_mat_T)\n M /= M.max()\n \n n_1 = n_clusters\n a = np.ones((n_1,)) / n_1\n b = np.ones((n_1,)) / n_1\n \n \n gamma = ot.emd(a,b,M)\n proportion_T = num_in_class_T/np.sum(num_in_class_T)\n assignement_source_to_target = gamma.argmax(axis=1)\n \n # proportions are arranged directly per class\n proportion_T = torch.from_numpy(proportion_T[assignement_source_to_target]).float()\n print(proportion_T,assignement_source_to_target)\n \n \n \n if prediction:\n #print('predition',gamma)\n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \n label_t = gmm.predict(X_t) \n\n assignement_target_to_source = gamma.argmax(axis=0)\n for i,yi in enumerate(label_t):\n label_t[i] = assignement_target_to_source[yi]\n MAP = balanced_accuracy_score(y_t,label_t) \n return MAP\n \n return proportion_T","def fit(self, trainingFeatures, trainingTargets):\r\n\r\n \"\"\" Implement kNN learning below. \"\"\"\r\n\r\n self._fitCalled = True\r\n self.labels = trainingTargets\r\n self.data = trainingFeatures","def train(self, num_batches: int):","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def __init__(self,training_data):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n self.n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #pre-processing data\n X = preprocessing.scale(np.hsplit(my_data,[self.n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[self.n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[self.n_features,n_col])[0])\n #define classifier\n self.classifier = svm.SVR(kernel='linear', C=1e3, cache_size=DEFAULT_CACHE_SIZE)\n #self.classifier = svm.SVR(kernel='rbf', C=1e3, gamma=0.1, cache_size=DEFAULT_CACHE_SIZE)\n self.classifier.fit(X, Y)","def predict_cluster(self, inputs):\n if not self.trained:\n if self.verbose:\n print(\"KMeans Model Class - Predict Cluster Function: No trained model\")\n return -1\n\n\n return self.model.predict(inputs)","def num_eval_instances(self):\n return self.num_train_instances // 4","def __init__(self,training_data):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #preprocessing data\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\n #define classifier\n self.classifier = svm.LinearSVC(class_weight='auto',C=1.0)\n self.classifier.fit(X, Y)","def test_train_data_length(self):\n total_count = 0\n for batch in self._dataset.get_train():\n total_count += len(batch['label'])\n\n self.assertEqual(total_count, self._dataset.get_train_len())","def assign_labels_to_centroids(self):\n labelled_centroids = []\n for i in range(len(self.final_clusters)):\n labels = map(lambda x: x[0], self.final_clusters[i])\n # pick the most common label\n most_common = Counter(labels).most_common(1)[0][0]\n c = np.round(len([item for item in self.final_clusters[i] if item[0]==1])/len(self.final_clusters[i]),2)\n if c>=0.46:\n most_common = 1.0\n centroid = (most_common, self.final_centroids[i])\n labelled_centroids.append(centroid)\n\n self.labelled_centroids = labelled_centroids\n print(\"cluster_0: \", np.round(len([item for item in self.final_clusters[0] if item[0]==1])/len(self.final_clusters[0]),2), \"size_0: \", len(self.final_clusters[0]))\n print(\"cluster_1: \", np.round(len([item for item in self.final_clusters[1] if item[0]==1])/len(self.final_clusters[1]),2), \"size_1: \", len(self.final_clusters[1]))\n #print(\"cluster_2: \", np.round(len([item for item in self.final_clusters[2] if item[0]==1])/len(self.final_clusters[2]),2), \"size_2: \", len(self.final_clusters[2]))\n #print(\"cluster_3: \", np.round(len([item for item in self.final_clusters[3] if item[0]==1])/len(self.final_clusters[3]),2), \"size_2: \", len(self.final_clusters[3]))","def __len__(self):\n return len(self.dataset) * self.samples_per_pair","def predict(self, dataset, batch_size):\n self.eval()\n yhat = torch.Tensor().to(self.device)\n with torch.no_grad():\n for i in tqdm(range(0,len(dataset.X),batch_size)):\n batch_X = dataset.X[i:i+batch_size].view(-1,1,self.input_rows,self.input_cols).to(self.device)\n batch_y = dataset.y[i:i+batch_size].to(self.device)\n\n batch_ls_embed = dataset.ls[i:i+batch_size].to(self.device) if self.type == \"listener\" or self.type == \"both\" else None\n batch_sp_embed = dataset.sp[i:i+batch_size].to(self.device) if self.type == \"speaker\" or self.type == \"both\" else None\n\n outputs = self(batch_X, batch_ls_embed, batch_sp_embed)\n\n yhat = torch.cat((yhat, outputs), 0)\n\n\n\n yf = dataset.y[:, 1]\n yhatf = torch.argmax(yhat, 1).cpu()\n stats = precision_recall_fscore_support(yf, yhatf)\n\n tp = 0\n tn = 0\n fn = 0\n fp = 0\n for i, j in zip(yhat, dataset.y):\n if torch.argmax(i) == torch.argmax(j):\n if j.data.numpy()[0] == 1: # positive instance\n tp += 1\n else:\n tn += 1\n else:\n if j.data.numpy()[0] == 1:\n fn += 1\n else:\n fp += 1\n acc = (tp + tn) / (tp + tn + fp + fn)\n\n print(f\"Accuracy: {round(acc*100,4)}\")\n print(f\"Confusion: TP: {tp}, FP: {fp}, FN: {fn}, TN: {tn}\")\n\n print(f\"Precision BC: {round(stats[0][0]*100,4)}\")\n print(f\"Precision NO BC: {round(stats[0][1]*100,4)}\")\n print(f\"Recall BC: {round(stats[1][0]*100,4)}\")\n print(f\"Recall No BC: {round(stats[1][1]*100,4)}\")\n print(f\"F-score BC: {round(stats[2][0]*100,4)}\")\n print(f\"F-score No BC: {round(stats[2][1]*100,4)}\")","def __init__(self,training_data,default_kernel=\"rbf\"):\n my_data = genfromtxt(training_data, delimiter='\\t',skip_header=0)\n n_col = my_data.shape[1]\n n_features=n_col-1 #assuming that the latest column\n #contains the the outputs \n #preprocessing data\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\n #defining scaling\n self.scaler = preprocessing.Scaler()\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\n #define classifier\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\n self.classifier.fit(X, Y)","def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n\n # Scale the data so that Euclidian distance makes sense\n means = np.mean(data, axis = 0)\n stddevs = np.std(data, axis = 0, ddof = 1)\n\n #print(means)\n #print(stddevs)\n\n data_scaled = np.zeros((n_examples, n_features))\n\n for i in range(n_features):\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\n\n study_correlation(data_scaled)\n\n # Initialize the centroids\n idx = np.random.randint(n_examples, size = n_clusters)\n centroids = data_scaled[idx, :]\n\n counter = 0\n\n while True:\n\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\n centroid_idx = np.argmin(distances, axis = 1)\n old_centroids = centroids\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\n #displacement = get_displacement(old_centroids, centroids)\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\n\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\n\n if counter == 0:\n# print(\"Initial displacement = {}\".format(displacement))\n initial_displacement = displacement\n\n counter += 1\n\n if displacement < (initial_displacement / 10000): break\n\n #print(\"Total number of loops before ending : {}\".format(counter))\n converted_predictions = convert_predictions(centroid_idx)\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def predict(self, images, batch_size):\n pass","def train(self, training_data, testData, classNum, batchSize):\n # find the numbers for feature and label\n featureNum = training_data.shape[1] - 1\n\n # #this will find all the unique labels automatically, but will have problem when training data is lacking some labels\n # labelNum = len(np.unique(training_data[:, :1]))\n labelNum = classNum\n\n # get the number of nodes for each layer\n if \"hidden_layer\" in self.params and self.params[\"hidden_layer\"] is not None:\n nodeNum = [featureNum] + self.params[\"hidden_layer\"] + [labelNum]\n else:\n nodeNum = [featureNum, featureNum * 2, labelNum]\n\n # get the mode for initializing the weight\n if \"weightInitMode\" in self.params and self.params[\"weightInitMode\"] is not None:\n weightInitMode = self.params[\"weightInitMode\"]\n else:\n weightInitMode = None\n\n # get the momentum factor\n if \"momentumFactor\" in self.params:\n momentumFactor = self.params[\"momentumFactor\"]\n else:\n momentumFactor = 0.0\n\n self.clf = NeuralNetwork(training_data, nodeNum, weightInitMode, momentumFactor)\n iteration = 5\n totalIter = 0\n testSize = 100000\n while iteration > 0:\n\n if iteration < 10:\n self.clf.train(iteration, batchSize)\n totalIter += iteration\n print \"---------- Settings ----------\"\n print \"Examples :\", training_data.shape[0]\n print \"Batch size :\", batchSize\n print \"Alpha :\", self.clf.getAlpha()\n print \"Momentum factor :\", momentumFactor\n print \"# of Nodes in all layers :\", nodeNum\n print \"Training iteration so far:\", totalIter\n self.file.write(\"\\n\")\n self.file.write(\"---------- Settings ----------\" + \"\\n\")\n self.file.write(\"Examples : \" + str(training_data.shape[0]) + \"\\n\")\n self.file.write(\"Batch size : \" + str(batchSize) + \"\\n\")\n self.file.write(\"Alpha : \" + str(self.clf.getAlpha()) + \"\\n\")\n self.file.write(\"Momentum factor : \" + str(momentumFactor) + \"\\n\")\n self.file.write(\"# of Nodes in all layers : \" + str(nodeNum) + \"\\n\")\n self.file.write(\"Training iteration so far: \" + str(totalIter) + \"\\n\")\n self.test(training_data, \"training\")\n self.test(testData, \"testing\")\n iteration = 0\n\n while iteration >= testSize:\n self.clf.train(testSize, batchSize)\n totalIter += testSize\n print \"---------- Settings ----------\"\n print \"Examples :\", training_data.shape[0]\n print \"Batch size :\", batchSize\n print \"Alpha :\", self.clf.getAlpha()\n print \"Momentum factor :\", momentumFactor\n print \"# of Nodes in all layers :\", nodeNum\n print \"Training iteration so far:\", totalIter\n self.file.write(\"\\n\")\n self.file.write(\"---------- Settings ----------\" + \"\\n\")\n self.file.write(\"Examples : \" + str(training_data.shape[0]) + \"\\n\")\n self.file.write(\"Batch size : \" + str(batchSize) + \"\\n\")\n self.file.write(\"Alpha : \" + str(self.clf.getAlpha()) + \"\\n\")\n self.file.write(\"Momentum factor : \" + str(momentumFactor) + \"\\n\")\n self.file.write(\"# of Nodes in all layers : \" + str(nodeNum) + \"\\n\")\n self.file.write(\"Training iteration so far: \" + str(totalIter) + \"\\n\")\n self.test(training_data, \"training\")\n self.test(testData, \"testing\")\n iteration -= testSize\n\n if iteration > 0:\n self.clf.train(iteration, batchSize)\n totalIter += iteration\n print \"---------- Settings ----------\"\n print \"Examples :\", training_data.shape[0]\n print \"Batch size :\", batchSize\n print \"Alpha :\", self.clf.getAlpha()\n print \"Momentum factor :\", momentumFactor\n print \"# of Nodes in all layers :\", nodeNum\n print \"Training iteration so far:\", totalIter\n self.file.write(\"\\n\")\n self.file.write(\"---------- Settings ----------\" + \"\\n\")\n self.file.write(\"Examples : \" + str(training_data.shape[0]) + \"\\n\")\n self.file.write(\"Batch size : \" + str(batchSize) + \"\\n\")\n self.file.write(\"Alpha : \" + str(self.clf.getAlpha()) + \"\\n\")\n self.file.write(\"Momentum factor : \" + str(momentumFactor) + \"\\n\")\n self.file.write(\"# of Nodes in all layers : \" + str(nodeNum) + \"\\n\")\n self.file.write(\"Training iteration so far: \" + str(totalIter) + \"\\n\")\n self.test(training_data, \"training\")\n self.test(testData, \"testing\")\n iteration = 0\n\n print \"\"\n restart = raw_input(\"Do you want to restart? (Y/N)\")\n if restart.upper() == \"Y\":\n totalIter = 0\n print \"Current Alpha is\", self.clf.getAlpha()\n alpha = raw_input(\"What alpha ?\")\n self.clf.setAlpha(float(alpha))\n self.clf.initTheta()\n self.file.write(\"\\n\")\n self.file.write(\"*****************************************************\\n\")\n self.file.write(\"Re-initialize trail with alpha = \" + str(alpha) + \"\\n\")\n self.file.write(\"*****************************************************\\n\")\n\n print \"\"\n iteration = raw_input(\"How many iteration do you want to train the model?\")\n try:\n iteration = int(iteration)\n except:\n iteration = raw_input(\"Please input an integer\")\n iteration = 1\n print \"Total training iterations:\", totalIter","def test_len_trainset(self):\n self.assertEqual(self.__dataset.get_train_len, 10000)","def __init__(\n self, n_clusters: int, batch_size: int, is_batched: bool = False):\n super().__init__()\n self.n_clusters = n_clusters\n self.batch_size = batch_size\n self.is_batched = is_batched","def predict(self, data):\r\n\r\n distances = [np.linalg.norm(data-self.centroids[centroid]) for centroid in self.centroids]\r\n classification = distances.index(min(distances))\r\n return classification","def __init__(self,\n d_feature,\n total_kv_pooling,\n max_inference_length=3072,\n chunk_len=None,\n chunk_offset=None,\n n_raw_tokens_generated=1,\n mode='train'):\n super().__init__(n_in=1, n_out=1)\n self._d_feature = d_feature\n self._total_kv_pooling = total_kv_pooling\n self._max_len = max_inference_length\n self._chunk_len = chunk_len\n self._chunk_offset = chunk_offset\n self._n_raw_tokens_generated = n_raw_tokens_generated\n self._mode = mode","def get_num_train_samples(self):\n raise NotImplementedError","def split_data(self,test=False):\n shuffle_index = torch.randperm(self.train_target.shape[0])\n load = shuffle_index.shape[0]\n train_input_shuffle = self.train_input[shuffle_index]\n train_target_shuffle = self.train_target[shuffle_index]\n train_classes_shuffle = self.train_classes[shuffle_index]\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\n train_input = train_input_shuffle[index_train]\n train_target = train_target_shuffle[index_train]\n train_classes = train_classes_shuffle[index_train]\n if not test:\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\n test_input = train_input_shuffle[index_test]\n test_target = train_target_shuffle[index_test]\n test_classes = train_classes_shuffle[index_test]\n else:\n index_test = self.index_for_equal_class(self.test_target)\n test_input = self.test_input[index_test]\n test_target = self.test_target[index_test]\n test_classes = self.test_classes[index_test]\n train_input, mean, std = normalize(train_input)\n test_input, _, _ = normalize(test_input,mean,std)\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes","def batch_size(self) -> int:\n ...","def predict_random_chunk(self, dataset , optimizer, loss_function, size=32):\n # get a random chunk from the test data\n random_start = numpy.random.randint(len(dataset.X)-size)\n X = dataset.X[random_start:random_start+size].view(-1,1,self.input_rows,self.input_cols).to(self.device)\n y = dataset.y[random_start:random_start+size].to(self.device)\n ls_emb = dataset.ls[random_start:random_start+size].to(self.device) if self.type == \"listener\" or self.type == \"both\" else None\n sp_emb = dataset.sp[random_start:random_start+size].to(self.device) if self.type == \"speaker\" or self.type == \"both\" else None\n\n # grant no learning\n with torch.no_grad():\n acc, loss, conf = self.fwd_pass(X, ls_emb, sp_emb, y, optimizer, loss_function)\n return acc, loss, conf","def predict(self, data):\n\t\treturn closestCluster(data, self.centers)","def knn(train_data, train_labels, test_data, test_labels, k):\n pred_labels = []\n for t in test_data:\n dist = calculate_distances(train_data, t)\n pred_class = majority_voting(dist, train_labels, k)\n pred_labels.append(pred_class)\n correct_pred_count = np.sum(pred_labels == test_labels)\n acc = correct_pred_count/len(test_labels)\n return acc","def __len__(self):\n if self.settype == \"train\":\n return 64000\n else:\n return len(self.list_ids)","def __len__(self):\n if self.TRAIN_BOOL is True:\n count = len(self.dict_batch_1[b'data'])\n count += len(self.dict_batch_2[b'data'])\n count += len(self.dict_batch_3[b'data'])\n count += len(self.dict_batch_4[b'data'])\n count += len(self.dict_batch_5[b'data'])\n else:\n count = len(self.dict_batch_test[b'data'])\n return count","def predict_class(self, inputs):\n if not self.trained:\n if self.verbose:\n print(\"KMeans Model Class - Predict Class Function: No trained model\")\n return -1\n\n\n return self.cluster_classes[self.model.predict(inputs)]","def __len__(self):\n return self.dataset.shape[0]","def predict(self, model, arg):\n prediction = model.predict(arg)\n\n return prediction\n\n #def getAccuracyScore(self, n_splits):\n \"\"\"\n Gives an cross-validated accuracy score for the new model.\n\n Inputs:\n n_splits: number of sets to split the data into\n\n Returns:\n score: the accuracy score of the model.\n \"\"\"","def get_total_item_size(info, split):\n assert split in [\"train\", \"train+validation\", \"validation\", \"test\"]\n if split == \"train+validation\":\n return info.splits[\"train\"].num_examples + info.splits[\"validation\"].num_examples\n return info.splits[split].num_examples","def train_size(self) -> int:\n return int(self.data_size * self.__train_fraction)","def set_nb_clusters(self):\n \n print(\"Finding the optimal number of clusters...\")\n \n sample = ro.r.matrix(self.df[self.df[\"filename\"].between(1, 4)][\"active_power\"].to_numpy())\n \n r=ro.r(\"\"\"\n check = function(matrix) {\n n_clust = fviz_nbclust(matrix, kmeans, k.max = 15)\n\n n_clust = n_clust$data\n\n max_cluster = as.numeric(n_clust$clusters[which.max(n_clust$y)])\n return(max_cluster)\n }\n \"\"\")\n\n result = r(sample)\n self.conf[\"nb_clust\"] = int(result[0])\n \n print(f\"Optimal number of clusters is {self.conf['nb_clust']}\\n\")","def num_training_batches(self, edge_type: Tuple[int, int], edge_class: int) -> int:\n return len(self.train_edges[edge_type][edge_class]) // self.batch_size","def train(self, training_data):\n pass","def process_sample_train(self):\n raise NotImplementedError","def knn(trainingSetData, testSetData, k):\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\n testSet = testSetData.drop([14], axis=1) # drop income\n\n distances = {}\n # this will store the distances re-sorted in ascending/descending order\n sort = {}\n # income band results (>=50k or <50K)\n incomePredictions = []\n\n # Calculating euclidean distance between each row of training data and test data instance\n for testInstance in range(len(testSet)): # len(testSet)\n \n # Store current test Point:\n testInstance = testSet.iloc[testInstance] \n \n distances = euclideanDistanceRow(testInstance, trainingSet)\n\n # sort the distances in order of smallest first:\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\n\n neighbors = []\n\n # Extracting top k neighbors\n for x in range(k):\n neighbors.append(sorted_d[x])\n\n\n classVotes = {}\n\n # Calculating the most freq class in the neighbors\n results = {\"lessThan50\": 0, \"moreThan50\": 0}\n\n # creating a dataframe to which we will add the income values:\n\n for x in range(len(neighbors)):\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\n results[\"lessThan50\"] += 1\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\n results[\"moreThan50\"] += 1\n\n print('results',results)\n\n if (results[\"lessThan50\"] > results[\"moreThan50\"]):\n incomePredictions.append(0.0)\n elif (results[\"lessThan50\"] < results[\"moreThan50\"]):\n incomePredictions.append(1.0)\n\n return incomePredictions","def n_clusters(self):\n return self.model.n_clusters","def __init__(self, training_set, k=5):\n super(Knn, self).__init__(training_set)\n self.k = k","def train(self, trainData):\n pass","def train(self, training_data, chunk_size=100):\n # For some reason, for the SVM to work, the keys need to be in alphabetical order\n training_data = {k : training_data[k] for k in sorted(training_data)}\n\n # Compile all author texts into one large text to then be broken down\n for auth in training_data:\n training_data[auth] = '\\n\\n'.join(training_data[auth])\n\n self.auths = list(training_data.keys())\n self.chunk_size = chunk_size\n\n # Creates two lists, one of the texts and one of the corresponding author labels.\n labels = []\n texts = []\n for auth in training_data:\n lines = training_data[auth].split('\\n')\n for p in range( chunk_size, len(lines), chunk_size ):\n labels.append(auth) # authors per text in the training corpus\n texts.append('\\n'.join(lines[p-chunk_size : p])) # texts in the training corpus\n labels = array(labels)\n texts = array(texts)\n\n # Cleans the texts\n for i in range(len(texts)):\n texts[i] = self._clean(texts[i])\n\n # Generates the profiles from these tests\n profiles = zeros((len(texts), len(self.alph)**self.N))\n for i in range(len(texts)):\n profiles[i] = self._profile(texts[i])\n\n\n # Reduces the features and fits the model\n self.train_data = [profiles, labels]\n self._reduceFeatures()\n\n self.model = SVC(kernel='linear')\n self.model.probability = True\n self.model.fit(self.train_data[0], self.train_data[1])","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def __init__(self, trainset, k=3):\n self._trainset = trainset\n self.k = k","def __init__(self,\n dataset,\n samples_per_gpu=1,\n num_replicas=None,\n rank=None):\n _rank, _num_replicas = get_dist_info()\n if num_replicas is None:\n num_replicas = _num_replicas\n if rank is None:\n rank = _rank\n self.dataset = dataset\n self.samples_per_gpu = samples_per_gpu\n self.num_replicas = num_replicas\n self.rank = rank\n self.epoch = 0\n if not hasattr(self.dataset, 'flag'):\n raise ValueError(\"the dataset doesn't have a atrribute named 'flag'\")\n self.flag = self.dataset.flag\n self.group_sizes = np.bincount(self.flag)\n\n self.num_samples = 0\n for i, j in enumerate(self.group_sizes):\n self.num_samples += int(math.ceil(\n self.group_sizes[i] * 1.0 / self.samples_per_gpu / self.num_replicas\n )) * self.samples_per_gpu\n self.total_size = self.num_samples * self.num_replicas","def run(self):\n for i,p in enumerate(self.pairs):\n self.forPointPair(i)\n if i % 100000 == 0:\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))","def fit(self, data, labels, labels_pred):\n self.n_samples, dim = data.shape\n self.labels_unique = np.unique(labels)\n self.n_classes = len(self.labels_unique)\n if self.n_neighbors is None:\n # Set number of nearest neighbors based on the maximum number of samples per class and the neighborhood\n # constant\n num = 0\n for c in self.labels_unique:\n ind = np.where(labels == c)[0]\n if ind.shape[0] > num:\n num = ind.shape[0]\n\n self.n_neighbors = int(np.ceil(num ** self.neighborhood_constant))\n\n logger.info(\"Number of samples: {:d}. Data dimension = {:d}.\".format(self.n_samples, dim))\n logger.info(\"Number of classes: {:d}.\".format(self.n_classes))\n logger.info(\"Number of neighbors (k): {:d}.\".format(self.n_neighbors))\n logger.info(\"Fraction of outliers (alpha): {:.4f}.\".format(self.alpha))\n if self.model_dim_reduction:\n data = transform_data_from_model(data, self.model_dim_reduction)\n dim = data.shape[1]\n logger.info(\"Applying dimension reduction to the data. Projected dimension = {:d}.\".format(dim))\n\n # Distance from each sample in `data` to the `1 - alpha` level sets corresponding to each class\n distance_level_sets = np.zeros((self.n_samples, self.n_classes))\n self.index_knn = dict()\n self.epsilon = dict()\n indices_sub = dict()\n for j, c in enumerate(self.labels_unique):\n logger.info(\"Processing data from class '{}':\".format(c))\n logger.info(\"Building a KNN index for all the samples from class '{}'.\".format(c))\n indices_sub[c] = np.where(labels == c)[0]\n data_sub = data[indices_sub[c], :]\n self.index_knn[c] = KNNIndex(\n data_sub, n_neighbors=self.n_neighbors,\n metric=self.metric, metric_kwargs=self.metric_kwargs,\n approx_nearest_neighbors=self.approx_nearest_neighbors,\n n_jobs=self.n_jobs,\n low_memory=self.low_memory,\n seed_rng=self.seed_rng\n )\n # Distances to the k nearest neighbors of each sample\n _, nn_distances = self.index_knn[c].query_self(k=self.n_neighbors)\n # Radius or distance to the k-th nearest neighbor for each sample\n radius_arr = nn_distances[:, self.n_neighbors - 1]\n\n # Smallest radius `epsilon` such that only `alpha` fraction of the samples from class `c` have radius\n # greater than `epsilon`\n if self.alpha > 0.:\n self.epsilon[c] = np.percentile(radius_arr, 100 * (1 - self.alpha), interpolation='midpoint')\n\n # Exclude the outliers and build a KNN index with the remaining samples\n mask_incl = radius_arr <= self.epsilon[c]\n mask_excl = np.logical_not(mask_incl)\n num_excl = mask_excl[mask_excl].shape[0]\n else:\n # Slightly larger value than the largest radius\n self.epsilon[c] = 1.0001 * np.max(radius_arr)\n\n # All samples are included in the density level set\n mask_incl = np.ones(indices_sub[c].shape[0], dtype=np.bool)\n mask_excl = np.logical_not(mask_incl)\n num_excl = 0\n\n if num_excl:\n logger.info(\"Excluding {:d} samples with radius larger than {:.6f} and building a KNN index with \"\n \"the remaining samples.\".format(num_excl, self.epsilon[c]))\n self.index_knn[c] = KNNIndex(\n data_sub[mask_incl, :], n_neighbors=self.n_neighbors,\n metric=self.metric, metric_kwargs=self.metric_kwargs,\n approx_nearest_neighbors=self.approx_nearest_neighbors,\n n_jobs=self.n_jobs,\n low_memory=self.low_memory,\n seed_rng=self.seed_rng\n )\n # Distance to the nearest neighbor of each sample that is part of the KNN index\n _, dist_temp = self.index_knn[c].query_self(k=1)\n ind = indices_sub[c][mask_incl]\n distance_level_sets[ind, j] = dist_temp[:, 0]\n\n # Distance to the nearest neighbor of each sample that is not a part of the KNN index (outliers)\n _, dist_temp = self.index_knn[c].query(data_sub[mask_excl, :], k=1)\n ind = indices_sub[c][mask_excl]\n distance_level_sets[ind, j] = dist_temp[:, 0]\n else:\n # No need to rebuild the KNN index because no samples are excluded.\n # Distance to the nearest neighbor of each sample\n distance_level_sets[indices_sub[c], j] = nn_distances[:, 0]\n\n logger.info(\"Calculating the trust score for the estimation data.\")\n for c in self.labels_unique:\n # Compute the distance from each sample from class `c` to the level sets from the remaining classes\n data_sub = data[indices_sub[c], :]\n for j, c_hat in enumerate(self.labels_unique):\n if c_hat == c:\n continue\n\n _, dist_temp = self.index_knn[c_hat].query(data_sub, k=1)\n distance_level_sets[indices_sub[c], j] = dist_temp[:, 0]\n\n self.scores_estim = self._score_helper(distance_level_sets, labels_pred)\n return self","def _extend_label_set(self, data, trainer_cls, session):\n # Select which nodes to label next, and predict their labels.\n selected_samples, selected_labels = self._select_samples_to_label(\n data, trainer_cls, session)\n # Replace the labels of the new nodes with the predicted labels.\n if selected_samples.shape[0] > 0:\n data.label_samples(selected_samples, selected_labels)\n return selected_samples","def run(\n self,\n number_of_clusters=None,\n max_K=8,\n method_clustering=\"pam\",\n init_clustering=\"random\",\n max_iter_clustering=100,\n discart_value_JI=0.6,\n bootstraps_JI=100,\n bootstraps_p_value=100,\n n_jobs=1,\n verbose=1,\n ):\n\n if number_of_clusters is None:\n self.k = optimizer.optimizeK(\n self.distance_matrix,\n self.y.to_numpy(),\n self.model_type,\n max_K,\n method_clustering,\n init_clustering,\n max_iter_clustering,\n discart_value_JI,\n bootstraps_JI,\n self.random_state,\n n_jobs,\n verbose,\n )\n\n if self.k == 1:\n warnings.warn(\"No stable clusters were found!\")\n return\n\n print(f\"Optimal number of cluster is: {self.k}\")\n\n else:\n self.k = number_of_clusters\n print(f\"Use {self.k} as number of cluster\")\n\n self.cluster_labels = (\n kmedoids.KMedoids(\n n_clusters=self.k,\n method=method_clustering,\n init=init_clustering,\n metric=\"precomputed\",\n max_iter=max_iter_clustering,\n random_state=self.random_state,\n )\n .fit(self.distance_matrix)\n .labels_\n )\n\n (\n self._data_clustering_ranked,\n self.p_value_of_features,\n ) = stats.calculate_global_feature_importance(\n self.X, self.y, self.cluster_labels, self.model_type\n )\n self._p_value_of_features_per_cluster = (\n stats.calculate_local_feature_importance(\n self._data_clustering_ranked, bootstraps_p_value\n )\n )","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def setUp(self):\n self.batch_size = 8\n num_keypoints = 16\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints + 1.0\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def partition_data(self):\n\n _header_ = self._header_ + 'partition_data(): '\n\n if self.verbose:\n print(_header_ + 'Partitioning data ...')\n\n network = self._useful_network()\n\n if self.nidx_train:\n # The only reason that allows .nidx to not be empty would be that a training Data was copied over\n # hence, the training node indices are retained and need to be excluded\n print(_header_ + 'Excluding %d training nodes transfered from training dataset ...' % len(self.nidx_train))\n nidx = set(self.nidx2lidx.keys()) - set(self.nidx_train)\n self.nidx_exclude += self.nidx_train\n self.nidx_train = []\n else:\n nidx = set(self.nidx2lidx.keys())\n\n for l in nidx:\n if l in network:\n if self.node_labels[l]:\n self.nidx_train.append(l)\n else:\n self.nidx_exclude.append(l)\n\n if self.verbose:\n print(_header_ + 'Found %d nodes' % len(self.nidx2lidx))\n print(' %d nodes with labels of interest' % len(self.nidx_train))\n print(' %d nodes can be used to predict' % len(self.nidx_pred))\n print(' %d nodes cannot be mapped due to lack of mappable links' % len(self.nidx_exclude))\n\n return self","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def final_evaluation(self):\n print(\"\\n=== Assign final labels ===\")\n\n # skip if there is only one cluster\n n_cluster = len(set(self.label[self.label != -1]))\n if n_cluster < 2:\n print(f\"Skip final evaluation because only {n_cluster} cluster label exist.\")\n # name all cluster as c0\n self.label = np.zeros(self.label.size, dtype=int)\n self.cv_predicted_label = [f\"c{label}\" for label in self.label]\n self.label_proba = np.ones(self.label.size, dtype=int)\n self.final_accuracy = 1\n else:\n # predict outliers\n outlier_x = self.X[self.label == -1]\n outlier_idx = np.where(self.label == -1)[0]\n if len(outlier_idx) != 0:\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\n for cell, pred_label in outlier_predict.items():\n self.label[cell] = pred_label\n print(\n \"Assigned all the multi-leiden clustering outliers into clusters \"\n \"using the prediction model from final clustering version.\"\n )\n\n # final evaluation of non-outliers using cross val predict\n final_predict_proba = cross_val_predict(\n self.supervise_model,\n self.X,\n y=self.label,\n method=\"predict_proba\",\n n_jobs=self.n_jobs,\n verbose=0,\n cv=10,\n )\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\n print(f\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\")\n self.cv_predicted_label = [f\"c{label}\" for label in final_predict]\n self.label_proba = final_cell_proba.values\n self.final_accuracy = final_acc\n\n self.label = [f\"c{label}\" for label in self.label]\n return","def __init__(self, filename='', limit=0.80, members=3, delimiter=','):\n self.count = 0 # counter for correct predictions\n self.results = self.load_data(filename=filename, limit=limit, delim=delimiter) # load data and receive response\n self.test_data = self.results[1]\n self.training_data = self.results[0]\n # get data neighbours of each member of the test data set.\n for x in range(len(self.test_data)):\n neighbours = self.get_neighbours(training_data=self.training_data, instance=self.test_data[x], k=members)\n # make a prediction.\n label = self.count_votes(neighbours=neighbours)\n # compare predicted outcome to actual outcome.\n print(\"{}). Actual outcome => '{}' & Predicted outcome => '{}'\".format(x + 1, self.test_data[x][-1], label))\n if self.test_data[x][-1] == label:\n self.count = self.count + 1\n\n # Calculate accuracy percentage.\n self.accuracy = (self.count / len(self.test_data)) * 100\n print(\"\\nAccuracy = {0:.2f}%\".format(self.accuracy))","def train(self, train_set) -> None:\n super().train(train_set)\n # split into data and target\n xlist, y = zip(*train_set)\n x = sparse.vstack(xlist)\n self._classifier.fit(x, y)","def supervise_learning(self):\n if self._multi_leiden_clusters is None:\n raise ValueError(\n \"Run multi_leiden_clustering first to get a \" \"clustering assignment before run supervise_learning.\"\n )\n\n n_cluster = np.unique(self._multi_leiden_clusters[self._multi_leiden_clusters != -1]).size\n if n_cluster == 1:\n print(\"There is only one cluster except for outliers, can not train supervise model on that.\")\n self.label = np.zeros(self.n_obs, dtype=int)\n return\n print(\"\\n=== Start supervise model training and cluster merging ===\")\n\n x = self.X\n cur_y = self._multi_leiden_clusters.copy()\n score = None\n step = 0.1\n\n if self.supervise_model is None:\n # create default model if no model provided\n clf = self._create_model(n_estimators=500)\n else:\n clf = self.supervise_model\n for cur_iter in range(1, self.max_iter + 1):\n print(f\"\\n=== iteration {cur_iter} ===\")\n n_labels = np.unique(cur_y[cur_y != -1]).size\n print(f\"{n_labels} non-outlier labels\")\n if n_labels < 2:\n print(f\"Stop iteration because only {n_labels} cluster remain.\")\n break\n\n x_train, y_train, x_test, y_test = _split_train_test_per_group(\n x=x,\n y=cur_y,\n frac=self.train_frac,\n max_train=self.train_max_n,\n random_state=self.random_state + cur_iter,\n # every time train-test split got a different random state\n )\n (\n clf,\n score,\n cluster_map,\n cmat,\n r1_cmat,\n r2_cmat,\n ) = single_supervise_evaluation(\n clf,\n x_train,\n y_train,\n x_test,\n y_test,\n r1_norm_step=step,\n r2_norm_step=step,\n )\n step = min(0.2, max(0.05, 2 * (self.target_accuracy - score)))\n\n # save step data for plotting\n self.step_data[cur_iter] = [\n cur_y,\n cmat,\n r1_cmat,\n r2_cmat,\n cluster_map,\n score,\n step,\n ]\n\n if score > self.target_accuracy:\n print(\n f\"Stop iteration because current accuracy {score:.3f}\"\n f\" > target accuracy {self.target_accuracy:.3f}.\"\n )\n break\n\n # judge results\n if len(cluster_map) > 0:\n print(f\"Merging {len(cluster_map)} clusters.\")\n cur_y = pd.Series(cur_y).apply(lambda i: cluster_map[i] if i in cluster_map else i)\n # renumber labels from large to small\n ordered_map = {c: i for i, c in enumerate(cur_y[cur_y != -1].value_counts().index)}\n cur_y = pd.Series(cur_y).apply(lambda i: ordered_map[i] if i in ordered_map else i).values\n else:\n print(\"Stop iteration because there is no cluster to merge\")\n break\n else:\n print(\"Stop iteration because reaching maximum iteration.\")\n self._label_with_leiden_outliers = cur_y\n self.label = cur_y\n self.supervise_model = clf\n self.final_accuracy = score\n return","def cluster_data(data, num_clusters, batch_size, shuffle=True, verbose=True):\n clusters = ClusterData(data, num_clusters, recursive=True, save_dir=None)\n if verbose:\n for cluster in clusters:\n print(cluster)\n return ClusterLoader(clusters, batch_size=batch_size)","def pre_train(self, dataset):\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\n pe = principleextractor.PrincipleExtractor()\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\n # not in the .json; or with argument given TODO\n self.skm.add_syllogistic_data(data=pd_dataset)\n\n self.skm.generate_clusters(cutoff=self.cutoff)\n\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\n\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\n self.skm.final_clusters_num)\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\n participant_correspondence)\n\n self.k_clusters = self.skm.final_clusters_syll_list\n\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\n gen_skm.add_syllogistic_data(data=pd_dataset)\n\n gen_skm.generate_clusters(cutoff=self.cutoff)\n\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]","def run(self, X_train, Y_train, X_test, Y_test, **kwargs):\n if self.clf is None:\n self.hidden_layer_sizes = (X_train.shape[1], X_train.shape[1])\n self.initMLPClassifier(**kwargs)\n\n self.clf.fit(X_train, Y_train.astype(int))\n Y_pred = self.clf.predict(X_test)\n return ClassificationResult(Y_test, Y_pred), self","def run(self, data):\n\t\treduced_data = PCA(n_components=2).fit_transform(data)\n\n\t\t# Run the algorithm\n\t\tself.estimator.fit_transform(reduced_data)\n\n\t\t# Save all relevent properties\n\t\tself.input_data = data\n\t\tself.centroids = self.estimator.cluster_centers_\n\t\tself.node_positions = reduced_data\n\t\tself.labels = self.estimator.labels_\n\n\t\t# Enable visualising when debugging\n\t\t# self.visualize(reduced_data)","def total_predict_batches(self) -> int:\n return sum(self.trainer.num_predict_batches)","def glasses_data_preprocessing(data_directory, filename_column, target_column, training_percentage_size=0.85,\n batches_size=16, validation_split=0.15, img_size=(96, 96), color_mode='rgb',\n horizontal_flip=True):\n # Loading the csv file\n path = os.path.join('../Datasets', data_directory)\n # The sep parameter chosen according to the delimiter adopted in labels.csv\n # Take the first 600 examples\n dataset_labels = pd.read_csv(os.path.join(path, 'labels.csv'), sep='\\t', dtype='str').head(600)\n dataset_labels[target_column] = list(map(str, [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,\n 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,\n 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,\n 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,\n 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\n 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\n 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0,\n # Others 300\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0,\n 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,\n 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,\n 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,\n 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0\n ]))\n # Divide data in two sets: one for training and one for testing\n train_folder = os.path.join(path, 'img')\n test_folder = os.path.join(path + '_test', 'img')\n # Division will be made only if the testing directory does not already exist\n if not os.path.isdir(test_folder):\n # Create the Test dataset folder\n # If parents is True, any missing parents of the folder will be created\n # If exist_ok is True, an Error is raised if the directory already exists\n Path(test_folder).mkdir(parents=True, exist_ok=True)\n # Sorted list of all the images available\n files = sorted(os.listdir(train_folder), key=lambda x: int(x.split(\".\")[0]))\n # Simple random sampling to select examples for the test dataset\n images_testing = sorted(sample(files, round(len(files) * (1 - training_percentage_size))))\n # Move all the test images into the related folder\n for file in images_testing:\n shutil.move(os.path.join(train_folder, file), test_folder)\n # List of all the images within the training and testing folders\n random_test_list = sorted([dataset_labels[dataset_labels[filename_column] == i].index[0]\n for i in os.listdir(test_folder)])\n random_training_list = sorted([dataset_labels[dataset_labels[filename_column] == i].index[0]\n for i in os.listdir(train_folder)])\n\n # Prepare the training, test and validation batches\n # Select labels associated to the images inside the training and test folders\n training_labels = dataset_labels.iloc[[i for i in random_training_list]]\n test_labels = dataset_labels.iloc[[i for i in random_test_list]]\n # With the following line the validation_split passed as argument becomes equal to the percentage of the total\n # dataset (and not anymore to the percentage of the training dataset dedicated to the validation dataset)\n validation_split = validation_split / training_percentage_size\n # ImageDataGenerator generates batches of images with real-time data augmentation\n image_generator = ImageDataGenerator(rescale=1. / 255., validation_split=validation_split,\n horizontal_flip=horizontal_flip)\n # It produces batches of images everytime it is called\n training_batches = image_generator.flow_from_dataframe(dataframe=training_labels, directory=train_folder,\n x_col=filename_column, y_col=target_column,\n subset=\"training\", batch_size=batches_size, seed=42,\n color_mode=color_mode, shuffle=True, target_size=img_size)\n # No data augmentation applied for validation and test data\n image_generator = ImageDataGenerator(rescale=1. / 255., validation_split=validation_split)\n valid_batches = image_generator.flow_from_dataframe(dataframe=training_labels, directory=train_folder,\n x_col=filename_column, y_col=target_column, subset=\"validation\",\n batch_size=batches_size, seed=42, shuffle=True,\n color_mode=color_mode, target_size=img_size)\n test_batches = image_generator.flow_from_dataframe(dataframe=test_labels, directory=test_folder,\n x_col=filename_column, y_col=target_column,\n color_mode=color_mode, batch_size=batches_size,\n shuffle=False, target_size=img_size)\n return training_batches, valid_batches, test_batches","def predict(self):\n raise NotImplementedError","def create_array_for_training(self, predicted_data, batch_size=1):\r\n return predicted_data","def _cluster(self):\n self._not_included = self.data\n self.leaves = []\n flag = int(rand() * len(self.data))\n flag = self._generate(flag)\n while len(self._not_included) > 0:\n flag = self._generate(flag)\n if flag == -1:\n break\n pass\n self._remember.append({\n 'threshold': self._base_threshold,\n 'result': len(self.leaves)\n })\n print(len(self._remember), {\n 'threshold': self._base_threshold,\n 'result': len(self.leaves)\n })\n return","def split_data(self):\n if not self.load_data:\n raise AttributeError('Preprocessor has not loaded any data.')\n \n # 3 - Find example counts for each set\n self.n_examples = self.data[0].shape[0]\n self.n_train = int(self.n_examples * self.train_ratio)\n self.n_val = int(self.n_examples * self.val_ratio)\n self.n_test = self.n_examples - self.n_train - self.n_val\n \n logger.info(f'Set sizes:')\n logger.info(f'train: {self.n_train}')\n logger.info(f'val: {self.n_val}')\n logger.info(f'test: {self.n_test}')\n if self.n_test < 0:\n raise ValueError('Train + validation ratios must bef < 1')\n\n # 4 - Separate data into train, test, val\n if isinstance(self.data[0], pd.DataFrame):\n logger.info('Dataset is in a dataframe.')\n self.isdataframe = True\n\n self.train_data = [self.data[0].iloc[:self.n_train],\n self.data[1].iloc[:self.n_train]]\n \n self.val_data = [self.data[0].iloc[self.n_train:self.n_val + self.n_train],\n self.data[1].iloc[self.n_train:self.n_val + self.n_train]]\n \n self.test_data = [self.data[0].iloc[self.n_val + self.n_train:],\n self.data[1].iloc[self.n_val + self.n_train:]]\n logger.info('Data was split into train, val, test.')\n else:\n self.isdataframe = False\n logger.info('Dataset is in a numpy array.')\n \n # If datasets are numpy array or sparse\n self.train_data = [self.data[0][:self.n_train],\n self.data[1][:self.n_train]]\n \n self.val_data = [self.data[0][self.n_train:self.n_val + self.n_train],\n self.data[1][self.n_train:self.n_val + self.n_train]]\n \n self.test_data = [self.data[0][self.n_val + self.n_train:],\n self.data[1][self.n_val + self.n_train:]]\n logger.info('Data was split into train, val, test.')\n \n assert(self.n_train == self.train_data[0].shape[0])\n assert(self.n_val == self.val_data[0].shape[0])\n assert(self.n_test == self.test_data[0].shape[0])\n \n # Free memory\n del self.data\n \n if self.save_sets:\n self.save_datasets()","def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\n stratified=False, random_seed=None, batch_size = 64,\n maxsize = None, maxsize_test=None, num_workers = 0):\n\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\n\n if type(train.targets) is list or type(train.targets) is np.ndarray:\n train.targets = torch.LongTensor(train.targets)\n test.targets = torch.LongTensor(test.targets)\n\n if not hasattr(train, 'classes') or not train.classes:\n train.classes = sorted(torch.unique(train.targets).tolist())\n test.classes = sorted(torch.unique(train.targets).tolist())\n\n ### Data splitting\n fold_idxs = {}\n if splits is None and valid_size == 0:\n ## Only train\n fold_idxs['train'] = np.arange(len(train))\n elif splits is None and valid_size > 0:\n ## Train/Valid\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\n fold_idxs['train'] = train_idx\n fold_idxs['valid'] = valid_idx\n\n for k, idxs in fold_idxs.items():\n if maxsize and maxsize < len(idxs):\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\n\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\n\n ### Create DataLoaders\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\n\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\n for k,sampler in fold_samplers.items()}\n\n if maxsize_test and maxsize_test < len(test):\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\n dataloader_args['sampler'] = sampler_test\n else:\n dataloader_args['shuffle'] = False\n test_loader = dataloader.DataLoader(test, **dataloader_args)\n fold_loaders['test'] = test_loader\n\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\n fnames = '/'.join(list(fnames) + ['test'])\n flens = '/'.join(map(str, list(flens) + [len(test)]))\n\n if hasattr(train, 'data'):\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\n print(f'Fold Sizes: {flens} ({fnames})')\n\n return fold_loaders, {'train': train, 'test':test}","def fit(self, X, y=None):\n X = self._validate_data(X, ensure_min_features=2)\n super()._fit(X.T)\n self._n_features_out = self.n_clusters_\n return self","def __init__(self, vein: Vein, cluster_size: int = 8, **kwargs):\n super().__init__(vein, **kwargs)\n\n self.cluster_size = cluster_size","def do_instance_pruning(self):\n\n # retrieve the probability of predicting fraud for each model (K models)\n # size: K x ChunkSize x 2 (2 for binary labels)\n predict_proba_fraud = [-1] * self.K\n\n # for each instance in the data chunk\n for i, instance in enumerate(self.y_chunk):\n sum_weight = 0\n current_F = 0\n F_vect = np.zeros(self.K) # Fk at each stage\n\n # compute F_k(y) for k = 1...K - the classifiers are sorted in DESCENDING order of weights\n k = -1\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\n k += 1\n clf = model.clf\n sum_weight += model.weight\n\n # compute the current probability\n # if the probability is not initialized we call the `predict_proba` method\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\n or (predict_proba_fraud[k].shape[0] != self.S):\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\n\n # check if we have the probabilities of 2 labels (because we're working with BINARY classification)\n # if we don't have the probability of predicting fraud it will be 0 so we don't do anything\n if len(predict_proba_fraud[k][i]) == 2:\n current_F += model.weight * predict_proba_fraud[k][i][1]\n\n # (2) compute the Fk for each example seen at each stage\n F_k = current_F / sum_weight\n F_vect[k] = F_k\n\n # (3) compute the error\n err_x = F_vect - F_vect[-1]\n\n # (4) update the mean and the variance of the error of these training examples for each bin (i,k)\n # we look at the error at each step for the given example\n for k, err in enumerate(err_x):\n # 1 --> we assign Fk to the corresponding bin (i,k) or (j,k)here because we used i index before\n eps = len(self.bins)\n\n for j in range(0, eps):\n if (j / eps) <= F_vect[k] < ((j + 1) / eps):\n self.bins[j][k]['num'] += 1\n\n # 2--> we compute the mean error in this bin\n self.bins[j][k]['mean'] += err\n\n # 2--> we compute the variance of the error in this bin\n # (basically we will just compute the squared error and do the division later)\n self.bins[j][k]['var'] += err ** 2\n\n # if we've assigned it to a bin, break and go to the next stage\n break\n\n # after computing everything we do the division by the total number assigned to a bin\n for i in range(0, len(self.bins)):\n # a bit tricky because sometimes we have bins that don't have any input example --> remains at 0\n for k in range(self.K):\n if self.bins[i][k]['num'] > 0:\n # divide the sum of error by the number of examples in the bin\n self.bins[i][k]['mean'] = self.bins[i][k]['mean'] / self.bins[i][k]['num']\n\n # compute the variance\n self.bins[i][k]['var'] = (self.bins[i][k]['var'] / self.bins[i][k]['num']) - \\\n (self.bins[i][k]['mean']) ** 2","def __init__(\n self, k_list, data, epoch=0, init_centroids=None, frozen_centroids=False\n ):\n super().__init__()\n self.k_list = k_list\n self.data = data\n self.d = data.shape[-1]\n self.init_centroids = init_centroids\n self.frozen_centroids = frozen_centroids\n\n self.logger = logging.getLogger(\"Kmeans\")\n self.debug = False\n self.epoch = epoch + 1","def train_test_split(self):\n random.seed(self.args.seed)\n nodes = [node for node in range(self.ncount)]\n random.shuffle(nodes)\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])","def fit_predict(self):\n raise AttributeError","def get_data_ninstances(self):\n return self.data_ninstances","def fiedler_clustering(self, num_clusters):\n\n clusters = MiniBatchKMeans(n_clusters=num_clusters).fit_predict(self.graph)\n\n return clusters"],"string":"[\n \"def num_train_instances(self):\\n raise NotImplementedError()\",\n \"def predict(self, test_data):\\n if self.centroids_.shape[0]==0:\\n raise ValueError(\\\"No centroids present. Run KMeans.fit first.\\\")\\n\\n print test_data.shape\\n part_of_cluster=np.zeros(test_data.shape[0])\\n for i in range(test_data.shape[0]):\\n dists=[]\\n for c in range(self.centroids_.shape[0]):\\n # compute distance between current train_data instance and each cluster\\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\\n \\n # assign point to cluster with minimal distance\\n part_of_cluster[i]=dists.index(min(dists))\\n\\n return part_of_cluster\",\n \"def __len__(self):\\r\\n return len(self.train_data)\",\n \"def n_train(self):\\n return self.factors[0].shape[0]\",\n \"def estimate_label_proportion(source_loader,target_loader,feat_extract,cuda,n_clusters,cluster_param): \\n feat_extract.eval()\\n #n_clusters = 3\\n from sklearn.cluster import AgglomerativeClustering\\n \\n \\n X_s,y_s = extract_feature(source_loader,feat_extract,cuda) \\n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \\n \\n \\n \\n cluster = AgglomerativeClustering(n_clusters=n_clusters,linkage=cluster_param)\\n label_t = cluster.fit_predict(X_t)\\n #print(np.unique(label_t))\\n mean_mat_S, num_in_class_S = extract_prototypes(X_s,y_s,n_clusters)\\n mean_mat_T, num_in_class_T = extract_prototypes(X_t,label_t,n_clusters)\\n \\n \\\"\\\"\\\"\\n We assume that prototypes of classes have been transported in some in the feature\\n space \\n \\\"\\\"\\\"\\n \\n import ot\\n M = ot.dist(mean_mat_S, mean_mat_T)\\n M /= M.max()\\n \\n n_1 = n_clusters\\n a = np.ones((n_1,)) / n_1\\n b = np.ones((n_1,)) / n_1\\n \\n \\n gamma = ot.emd(a,b,M)\\n nb_sample_S = [ np.sum(y_s==i) for i in range(n_clusters) ]\\n proportion_T = num_in_class_T/np.sum(num_in_class_T)\\n assignement_source_to_target = gamma.argmax(axis=1)\\n \\n # proportions are arranged directly per class\\n proportion_T = proportion_T[assignement_source_to_target]\\n print(proportion_T,assignement_source_to_target)\\n \\n\\n return proportion_T,nb_sample_S, assignement_source_to_target\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def num_training_examples(self):\",\n \"def train(self):\\n\\n print \\\"==> Running Kmeans on data set of shape: {}\\\".format(self.data.shape)\\n km = KMeans(n_clusters = self.n_clusters)\\n km.fit(self.data.values)\\n self.labels = km.labels_\\n self.inertia = km.inertia_\",\n \"def get_train_data_size(self):\\n return len(self.pipeline.data['train'])\",\n \"def _predict_feature_sizes(self):\\n return self._feature_sizes\",\n \"def size(self):\\r\\n return len(self._train_datas)\",\n \"def training_start(self, dataloader):\\n self.datasize = len(dataloader)\",\n \"def _check_data_size(self):\\n if len(self.list_data) < self.n_cluster:\\n self.n_cluster = len(self.list_data)\",\n \"def predict(toPredict=None):\\n\\tif not toPredict:\\n\\t\\ttoPredict = gc.generate_test_cases(1)[0]\\n\\ttoPredict = np.asarray(toPredict)\\n\\ttoPredict = toPredict.reshape(1, -1)\\t\\n\\tclusterer = joblib.load(\\\"training_data.pkl\\\")\\n\\tprint(clusterer.predict(toPredict))\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def supervised_fit(self, x, y):\\n self.cluster_label_map = np.random.rand(self._n_components).tolist()\\n\\n # Perform EM in dataset\\n # self.fit(x)\\n\\n # Get z_{ik} after performing EM algorithm\\n z_ik = self.get_posterior(x)\\n\\n # Get the highest probability of k^th GMM for each data points\\n # Assign labels for data points\\n em_label = np.argmax(z_ik, axis=1)\\n\\n # Check with grountruth labels\\n for k in range(self._n_components):\\n data_idx = np.where(em_label == k)\\n if data_idx[0].size:\\n coor_data = y[data_idx]\\n vote_label = scipy.stats.mode(coor_data)[0][0]\\n self.cluster_label_map[k] = vote_label\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def test_predict(self):\\n # Check build does not raise errors\\n dataset = KDDCupDataset()\\n dataset.create_fixed_samples(\\n *self.data, samples_num=1, partition_sizes=self.partition_sizes)\\n dataset.set_current_sample(0)\\n model = self.MODEL(dataset, **self.model_arguments)\\n model.fit(training_epochs=50)\\n true, predictions = model.predict('test')\\n expected_size = ((dataset.num_examples('test') //\\n model.batch_size) * model.batch_size)\\n self.assertEqual(true.shape[0], expected_size)\\n self.assertEqual(true.shape, predictions.shape)\",\n \"def __len__(self):\\n return len(self.train) + len(self.val) + len(self.test)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def data_size(self) -> int:\\n return len(self.__labels)\",\n \"def predict(self, X, pred_batch_size=None):\",\n \"def fit(self, **kwargs):\\r\\n\\r\\n self.stats[\\\"dataset_size\\\"] = self.user_to_size\\r\\n\\r\\n super(DatabasePreferenceLearnerFeatureless, self).fit(**kwargs)\",\n \"def estimate_label_proportion_GMM(source_loader,target_loader,feat_extract,cuda,n_clusters,prediction=False,n_max=2000): \\n feat_extract.eval()\\n \\n \\n X_s,y_s = extract_feature(source_loader,feat_extract,cuda) \\n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \\n \\n if X_s.shape[0]>n_max:\\n X_s = X_s[0:n_max,:]\\n X_t = X_t[0:n_max,:]\\n y_s = y_s[0:n_max]\\n y_t = y_t[0:n_max]\\n\\n gmm = GaussianMixture(n_components=n_clusters,n_init=10)# means_init = mean_mat_S)\\n label_t = gmm.fit_predict(X_t) \\n mean_mat_S, num_in_class_S = extract_prototypes(X_s,y_s,n_clusters)\\n mean_mat_T, num_in_class_T = extract_prototypes(X_t,label_t,n_clusters)\\n \\n \\\"\\\"\\\"\\n We assume that prototypes of classes have been transported in some in the feature\\n space \\n \\\"\\\"\\\"\\n \\n import ot\\n M = ot.dist(mean_mat_S, mean_mat_T)\\n M /= M.max()\\n \\n n_1 = n_clusters\\n a = np.ones((n_1,)) / n_1\\n b = np.ones((n_1,)) / n_1\\n \\n \\n gamma = ot.emd(a,b,M)\\n proportion_T = num_in_class_T/np.sum(num_in_class_T)\\n assignement_source_to_target = gamma.argmax(axis=1)\\n \\n # proportions are arranged directly per class\\n proportion_T = torch.from_numpy(proportion_T[assignement_source_to_target]).float()\\n print(proportion_T,assignement_source_to_target)\\n \\n \\n \\n if prediction:\\n #print('predition',gamma)\\n X_t,y_t = extract_feature(target_loader,feat_extract,cuda) \\n label_t = gmm.predict(X_t) \\n\\n assignement_target_to_source = gamma.argmax(axis=0)\\n for i,yi in enumerate(label_t):\\n label_t[i] = assignement_target_to_source[yi]\\n MAP = balanced_accuracy_score(y_t,label_t) \\n return MAP\\n \\n return proportion_T\",\n \"def fit(self, trainingFeatures, trainingTargets):\\r\\n\\r\\n \\\"\\\"\\\" Implement kNN learning below. \\\"\\\"\\\"\\r\\n\\r\\n self._fitCalled = True\\r\\n self.labels = trainingTargets\\r\\n self.data = trainingFeatures\",\n \"def train(self, num_batches: int):\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def __init__(self,training_data):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n self.n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #pre-processing data\\n X = preprocessing.scale(np.hsplit(my_data,[self.n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[self.n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[self.n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.SVR(kernel='linear', C=1e3, cache_size=DEFAULT_CACHE_SIZE)\\n #self.classifier = svm.SVR(kernel='rbf', C=1e3, gamma=0.1, cache_size=DEFAULT_CACHE_SIZE)\\n self.classifier.fit(X, Y)\",\n \"def predict_cluster(self, inputs):\\n if not self.trained:\\n if self.verbose:\\n print(\\\"KMeans Model Class - Predict Cluster Function: No trained model\\\")\\n return -1\\n\\n\\n return self.model.predict(inputs)\",\n \"def num_eval_instances(self):\\n return self.num_train_instances // 4\",\n \"def __init__(self,training_data):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #preprocessing data\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.LinearSVC(class_weight='auto',C=1.0)\\n self.classifier.fit(X, Y)\",\n \"def test_train_data_length(self):\\n total_count = 0\\n for batch in self._dataset.get_train():\\n total_count += len(batch['label'])\\n\\n self.assertEqual(total_count, self._dataset.get_train_len())\",\n \"def assign_labels_to_centroids(self):\\n labelled_centroids = []\\n for i in range(len(self.final_clusters)):\\n labels = map(lambda x: x[0], self.final_clusters[i])\\n # pick the most common label\\n most_common = Counter(labels).most_common(1)[0][0]\\n c = np.round(len([item for item in self.final_clusters[i] if item[0]==1])/len(self.final_clusters[i]),2)\\n if c>=0.46:\\n most_common = 1.0\\n centroid = (most_common, self.final_centroids[i])\\n labelled_centroids.append(centroid)\\n\\n self.labelled_centroids = labelled_centroids\\n print(\\\"cluster_0: \\\", np.round(len([item for item in self.final_clusters[0] if item[0]==1])/len(self.final_clusters[0]),2), \\\"size_0: \\\", len(self.final_clusters[0]))\\n print(\\\"cluster_1: \\\", np.round(len([item for item in self.final_clusters[1] if item[0]==1])/len(self.final_clusters[1]),2), \\\"size_1: \\\", len(self.final_clusters[1]))\\n #print(\\\"cluster_2: \\\", np.round(len([item for item in self.final_clusters[2] if item[0]==1])/len(self.final_clusters[2]),2), \\\"size_2: \\\", len(self.final_clusters[2]))\\n #print(\\\"cluster_3: \\\", np.round(len([item for item in self.final_clusters[3] if item[0]==1])/len(self.final_clusters[3]),2), \\\"size_2: \\\", len(self.final_clusters[3]))\",\n \"def __len__(self):\\n return len(self.dataset) * self.samples_per_pair\",\n \"def predict(self, dataset, batch_size):\\n self.eval()\\n yhat = torch.Tensor().to(self.device)\\n with torch.no_grad():\\n for i in tqdm(range(0,len(dataset.X),batch_size)):\\n batch_X = dataset.X[i:i+batch_size].view(-1,1,self.input_rows,self.input_cols).to(self.device)\\n batch_y = dataset.y[i:i+batch_size].to(self.device)\\n\\n batch_ls_embed = dataset.ls[i:i+batch_size].to(self.device) if self.type == \\\"listener\\\" or self.type == \\\"both\\\" else None\\n batch_sp_embed = dataset.sp[i:i+batch_size].to(self.device) if self.type == \\\"speaker\\\" or self.type == \\\"both\\\" else None\\n\\n outputs = self(batch_X, batch_ls_embed, batch_sp_embed)\\n\\n yhat = torch.cat((yhat, outputs), 0)\\n\\n\\n\\n yf = dataset.y[:, 1]\\n yhatf = torch.argmax(yhat, 1).cpu()\\n stats = precision_recall_fscore_support(yf, yhatf)\\n\\n tp = 0\\n tn = 0\\n fn = 0\\n fp = 0\\n for i, j in zip(yhat, dataset.y):\\n if torch.argmax(i) == torch.argmax(j):\\n if j.data.numpy()[0] == 1: # positive instance\\n tp += 1\\n else:\\n tn += 1\\n else:\\n if j.data.numpy()[0] == 1:\\n fn += 1\\n else:\\n fp += 1\\n acc = (tp + tn) / (tp + tn + fp + fn)\\n\\n print(f\\\"Accuracy: {round(acc*100,4)}\\\")\\n print(f\\\"Confusion: TP: {tp}, FP: {fp}, FN: {fn}, TN: {tn}\\\")\\n\\n print(f\\\"Precision BC: {round(stats[0][0]*100,4)}\\\")\\n print(f\\\"Precision NO BC: {round(stats[0][1]*100,4)}\\\")\\n print(f\\\"Recall BC: {round(stats[1][0]*100,4)}\\\")\\n print(f\\\"Recall No BC: {round(stats[1][1]*100,4)}\\\")\\n print(f\\\"F-score BC: {round(stats[2][0]*100,4)}\\\")\\n print(f\\\"F-score No BC: {round(stats[2][1]*100,4)}\\\")\",\n \"def __init__(self,training_data,default_kernel=\\\"rbf\\\"):\\n my_data = genfromtxt(training_data, delimiter='\\\\t',skip_header=0)\\n n_col = my_data.shape[1]\\n n_features=n_col-1 #assuming that the latest column\\n #contains the the outputs \\n #preprocessing data\\n X = preprocessing.scale(np.hsplit(my_data,[n_features,n_col])[0])\\n Y = np.squeeze(np.asarray(np.hsplit(my_data,[n_features,n_col])[1]))\\n #defining scaling\\n self.scaler = preprocessing.Scaler()\\n self.scaler.fit(np.hsplit(my_data,[n_features,n_col])[0])\\n #define classifier\\n self.classifier = svm.SVC(class_weight='auto',cache_size=DEFAULT_CACHE_SIZE, kernel=default_kernel)\\n self.classifier.fit(X, Y)\",\n \"def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n\\n # Scale the data so that Euclidian distance makes sense\\n means = np.mean(data, axis = 0)\\n stddevs = np.std(data, axis = 0, ddof = 1)\\n\\n #print(means)\\n #print(stddevs)\\n\\n data_scaled = np.zeros((n_examples, n_features))\\n\\n for i in range(n_features):\\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\\n\\n study_correlation(data_scaled)\\n\\n # Initialize the centroids\\n idx = np.random.randint(n_examples, size = n_clusters)\\n centroids = data_scaled[idx, :]\\n\\n counter = 0\\n\\n while True:\\n\\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\\n centroid_idx = np.argmin(distances, axis = 1)\\n old_centroids = centroids\\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\\n #displacement = get_displacement(old_centroids, centroids)\\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\\n\\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\\n\\n if counter == 0:\\n# print(\\\"Initial displacement = {}\\\".format(displacement))\\n initial_displacement = displacement\\n\\n counter += 1\\n\\n if displacement < (initial_displacement / 10000): break\\n\\n #print(\\\"Total number of loops before ending : {}\\\".format(counter))\\n converted_predictions = convert_predictions(centroid_idx)\\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def predict(self, images, batch_size):\\n pass\",\n \"def train(self, training_data, testData, classNum, batchSize):\\n # find the numbers for feature and label\\n featureNum = training_data.shape[1] - 1\\n\\n # #this will find all the unique labels automatically, but will have problem when training data is lacking some labels\\n # labelNum = len(np.unique(training_data[:, :1]))\\n labelNum = classNum\\n\\n # get the number of nodes for each layer\\n if \\\"hidden_layer\\\" in self.params and self.params[\\\"hidden_layer\\\"] is not None:\\n nodeNum = [featureNum] + self.params[\\\"hidden_layer\\\"] + [labelNum]\\n else:\\n nodeNum = [featureNum, featureNum * 2, labelNum]\\n\\n # get the mode for initializing the weight\\n if \\\"weightInitMode\\\" in self.params and self.params[\\\"weightInitMode\\\"] is not None:\\n weightInitMode = self.params[\\\"weightInitMode\\\"]\\n else:\\n weightInitMode = None\\n\\n # get the momentum factor\\n if \\\"momentumFactor\\\" in self.params:\\n momentumFactor = self.params[\\\"momentumFactor\\\"]\\n else:\\n momentumFactor = 0.0\\n\\n self.clf = NeuralNetwork(training_data, nodeNum, weightInitMode, momentumFactor)\\n iteration = 5\\n totalIter = 0\\n testSize = 100000\\n while iteration > 0:\\n\\n if iteration < 10:\\n self.clf.train(iteration, batchSize)\\n totalIter += iteration\\n print \\\"---------- Settings ----------\\\"\\n print \\\"Examples :\\\", training_data.shape[0]\\n print \\\"Batch size :\\\", batchSize\\n print \\\"Alpha :\\\", self.clf.getAlpha()\\n print \\\"Momentum factor :\\\", momentumFactor\\n print \\\"# of Nodes in all layers :\\\", nodeNum\\n print \\\"Training iteration so far:\\\", totalIter\\n self.file.write(\\\"\\\\n\\\")\\n self.file.write(\\\"---------- Settings ----------\\\" + \\\"\\\\n\\\")\\n self.file.write(\\\"Examples : \\\" + str(training_data.shape[0]) + \\\"\\\\n\\\")\\n self.file.write(\\\"Batch size : \\\" + str(batchSize) + \\\"\\\\n\\\")\\n self.file.write(\\\"Alpha : \\\" + str(self.clf.getAlpha()) + \\\"\\\\n\\\")\\n self.file.write(\\\"Momentum factor : \\\" + str(momentumFactor) + \\\"\\\\n\\\")\\n self.file.write(\\\"# of Nodes in all layers : \\\" + str(nodeNum) + \\\"\\\\n\\\")\\n self.file.write(\\\"Training iteration so far: \\\" + str(totalIter) + \\\"\\\\n\\\")\\n self.test(training_data, \\\"training\\\")\\n self.test(testData, \\\"testing\\\")\\n iteration = 0\\n\\n while iteration >= testSize:\\n self.clf.train(testSize, batchSize)\\n totalIter += testSize\\n print \\\"---------- Settings ----------\\\"\\n print \\\"Examples :\\\", training_data.shape[0]\\n print \\\"Batch size :\\\", batchSize\\n print \\\"Alpha :\\\", self.clf.getAlpha()\\n print \\\"Momentum factor :\\\", momentumFactor\\n print \\\"# of Nodes in all layers :\\\", nodeNum\\n print \\\"Training iteration so far:\\\", totalIter\\n self.file.write(\\\"\\\\n\\\")\\n self.file.write(\\\"---------- Settings ----------\\\" + \\\"\\\\n\\\")\\n self.file.write(\\\"Examples : \\\" + str(training_data.shape[0]) + \\\"\\\\n\\\")\\n self.file.write(\\\"Batch size : \\\" + str(batchSize) + \\\"\\\\n\\\")\\n self.file.write(\\\"Alpha : \\\" + str(self.clf.getAlpha()) + \\\"\\\\n\\\")\\n self.file.write(\\\"Momentum factor : \\\" + str(momentumFactor) + \\\"\\\\n\\\")\\n self.file.write(\\\"# of Nodes in all layers : \\\" + str(nodeNum) + \\\"\\\\n\\\")\\n self.file.write(\\\"Training iteration so far: \\\" + str(totalIter) + \\\"\\\\n\\\")\\n self.test(training_data, \\\"training\\\")\\n self.test(testData, \\\"testing\\\")\\n iteration -= testSize\\n\\n if iteration > 0:\\n self.clf.train(iteration, batchSize)\\n totalIter += iteration\\n print \\\"---------- Settings ----------\\\"\\n print \\\"Examples :\\\", training_data.shape[0]\\n print \\\"Batch size :\\\", batchSize\\n print \\\"Alpha :\\\", self.clf.getAlpha()\\n print \\\"Momentum factor :\\\", momentumFactor\\n print \\\"# of Nodes in all layers :\\\", nodeNum\\n print \\\"Training iteration so far:\\\", totalIter\\n self.file.write(\\\"\\\\n\\\")\\n self.file.write(\\\"---------- Settings ----------\\\" + \\\"\\\\n\\\")\\n self.file.write(\\\"Examples : \\\" + str(training_data.shape[0]) + \\\"\\\\n\\\")\\n self.file.write(\\\"Batch size : \\\" + str(batchSize) + \\\"\\\\n\\\")\\n self.file.write(\\\"Alpha : \\\" + str(self.clf.getAlpha()) + \\\"\\\\n\\\")\\n self.file.write(\\\"Momentum factor : \\\" + str(momentumFactor) + \\\"\\\\n\\\")\\n self.file.write(\\\"# of Nodes in all layers : \\\" + str(nodeNum) + \\\"\\\\n\\\")\\n self.file.write(\\\"Training iteration so far: \\\" + str(totalIter) + \\\"\\\\n\\\")\\n self.test(training_data, \\\"training\\\")\\n self.test(testData, \\\"testing\\\")\\n iteration = 0\\n\\n print \\\"\\\"\\n restart = raw_input(\\\"Do you want to restart? (Y/N)\\\")\\n if restart.upper() == \\\"Y\\\":\\n totalIter = 0\\n print \\\"Current Alpha is\\\", self.clf.getAlpha()\\n alpha = raw_input(\\\"What alpha ?\\\")\\n self.clf.setAlpha(float(alpha))\\n self.clf.initTheta()\\n self.file.write(\\\"\\\\n\\\")\\n self.file.write(\\\"*****************************************************\\\\n\\\")\\n self.file.write(\\\"Re-initialize trail with alpha = \\\" + str(alpha) + \\\"\\\\n\\\")\\n self.file.write(\\\"*****************************************************\\\\n\\\")\\n\\n print \\\"\\\"\\n iteration = raw_input(\\\"How many iteration do you want to train the model?\\\")\\n try:\\n iteration = int(iteration)\\n except:\\n iteration = raw_input(\\\"Please input an integer\\\")\\n iteration = 1\\n print \\\"Total training iterations:\\\", totalIter\",\n \"def test_len_trainset(self):\\n self.assertEqual(self.__dataset.get_train_len, 10000)\",\n \"def __init__(\\n self, n_clusters: int, batch_size: int, is_batched: bool = False):\\n super().__init__()\\n self.n_clusters = n_clusters\\n self.batch_size = batch_size\\n self.is_batched = is_batched\",\n \"def predict(self, data):\\r\\n\\r\\n distances = [np.linalg.norm(data-self.centroids[centroid]) for centroid in self.centroids]\\r\\n classification = distances.index(min(distances))\\r\\n return classification\",\n \"def __init__(self,\\n d_feature,\\n total_kv_pooling,\\n max_inference_length=3072,\\n chunk_len=None,\\n chunk_offset=None,\\n n_raw_tokens_generated=1,\\n mode='train'):\\n super().__init__(n_in=1, n_out=1)\\n self._d_feature = d_feature\\n self._total_kv_pooling = total_kv_pooling\\n self._max_len = max_inference_length\\n self._chunk_len = chunk_len\\n self._chunk_offset = chunk_offset\\n self._n_raw_tokens_generated = n_raw_tokens_generated\\n self._mode = mode\",\n \"def get_num_train_samples(self):\\n raise NotImplementedError\",\n \"def split_data(self,test=False):\\n shuffle_index = torch.randperm(self.train_target.shape[0])\\n load = shuffle_index.shape[0]\\n train_input_shuffle = self.train_input[shuffle_index]\\n train_target_shuffle = self.train_target[shuffle_index]\\n train_classes_shuffle = self.train_classes[shuffle_index]\\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\\n train_input = train_input_shuffle[index_train]\\n train_target = train_target_shuffle[index_train]\\n train_classes = train_classes_shuffle[index_train]\\n if not test:\\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\\n test_input = train_input_shuffle[index_test]\\n test_target = train_target_shuffle[index_test]\\n test_classes = train_classes_shuffle[index_test]\\n else:\\n index_test = self.index_for_equal_class(self.test_target)\\n test_input = self.test_input[index_test]\\n test_target = self.test_target[index_test]\\n test_classes = self.test_classes[index_test]\\n train_input, mean, std = normalize(train_input)\\n test_input, _, _ = normalize(test_input,mean,std)\\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes\",\n \"def batch_size(self) -> int:\\n ...\",\n \"def predict_random_chunk(self, dataset , optimizer, loss_function, size=32):\\n # get a random chunk from the test data\\n random_start = numpy.random.randint(len(dataset.X)-size)\\n X = dataset.X[random_start:random_start+size].view(-1,1,self.input_rows,self.input_cols).to(self.device)\\n y = dataset.y[random_start:random_start+size].to(self.device)\\n ls_emb = dataset.ls[random_start:random_start+size].to(self.device) if self.type == \\\"listener\\\" or self.type == \\\"both\\\" else None\\n sp_emb = dataset.sp[random_start:random_start+size].to(self.device) if self.type == \\\"speaker\\\" or self.type == \\\"both\\\" else None\\n\\n # grant no learning\\n with torch.no_grad():\\n acc, loss, conf = self.fwd_pass(X, ls_emb, sp_emb, y, optimizer, loss_function)\\n return acc, loss, conf\",\n \"def predict(self, data):\\n\\t\\treturn closestCluster(data, self.centers)\",\n \"def knn(train_data, train_labels, test_data, test_labels, k):\\n pred_labels = []\\n for t in test_data:\\n dist = calculate_distances(train_data, t)\\n pred_class = majority_voting(dist, train_labels, k)\\n pred_labels.append(pred_class)\\n correct_pred_count = np.sum(pred_labels == test_labels)\\n acc = correct_pred_count/len(test_labels)\\n return acc\",\n \"def __len__(self):\\n if self.settype == \\\"train\\\":\\n return 64000\\n else:\\n return len(self.list_ids)\",\n \"def __len__(self):\\n if self.TRAIN_BOOL is True:\\n count = len(self.dict_batch_1[b'data'])\\n count += len(self.dict_batch_2[b'data'])\\n count += len(self.dict_batch_3[b'data'])\\n count += len(self.dict_batch_4[b'data'])\\n count += len(self.dict_batch_5[b'data'])\\n else:\\n count = len(self.dict_batch_test[b'data'])\\n return count\",\n \"def predict_class(self, inputs):\\n if not self.trained:\\n if self.verbose:\\n print(\\\"KMeans Model Class - Predict Class Function: No trained model\\\")\\n return -1\\n\\n\\n return self.cluster_classes[self.model.predict(inputs)]\",\n \"def __len__(self):\\n return self.dataset.shape[0]\",\n \"def predict(self, model, arg):\\n prediction = model.predict(arg)\\n\\n return prediction\\n\\n #def getAccuracyScore(self, n_splits):\\n \\\"\\\"\\\"\\n Gives an cross-validated accuracy score for the new model.\\n\\n Inputs:\\n n_splits: number of sets to split the data into\\n\\n Returns:\\n score: the accuracy score of the model.\\n \\\"\\\"\\\"\",\n \"def get_total_item_size(info, split):\\n assert split in [\\\"train\\\", \\\"train+validation\\\", \\\"validation\\\", \\\"test\\\"]\\n if split == \\\"train+validation\\\":\\n return info.splits[\\\"train\\\"].num_examples + info.splits[\\\"validation\\\"].num_examples\\n return info.splits[split].num_examples\",\n \"def train_size(self) -> int:\\n return int(self.data_size * self.__train_fraction)\",\n \"def set_nb_clusters(self):\\n \\n print(\\\"Finding the optimal number of clusters...\\\")\\n \\n sample = ro.r.matrix(self.df[self.df[\\\"filename\\\"].between(1, 4)][\\\"active_power\\\"].to_numpy())\\n \\n r=ro.r(\\\"\\\"\\\"\\n check = function(matrix) {\\n n_clust = fviz_nbclust(matrix, kmeans, k.max = 15)\\n\\n n_clust = n_clust$data\\n\\n max_cluster = as.numeric(n_clust$clusters[which.max(n_clust$y)])\\n return(max_cluster)\\n }\\n \\\"\\\"\\\")\\n\\n result = r(sample)\\n self.conf[\\\"nb_clust\\\"] = int(result[0])\\n \\n print(f\\\"Optimal number of clusters is {self.conf['nb_clust']}\\\\n\\\")\",\n \"def num_training_batches(self, edge_type: Tuple[int, int], edge_class: int) -> int:\\n return len(self.train_edges[edge_type][edge_class]) // self.batch_size\",\n \"def train(self, training_data):\\n pass\",\n \"def process_sample_train(self):\\n raise NotImplementedError\",\n \"def knn(trainingSetData, testSetData, k):\\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\\n testSet = testSetData.drop([14], axis=1) # drop income\\n\\n distances = {}\\n # this will store the distances re-sorted in ascending/descending order\\n sort = {}\\n # income band results (>=50k or <50K)\\n incomePredictions = []\\n\\n # Calculating euclidean distance between each row of training data and test data instance\\n for testInstance in range(len(testSet)): # len(testSet)\\n \\n # Store current test Point:\\n testInstance = testSet.iloc[testInstance] \\n \\n distances = euclideanDistanceRow(testInstance, trainingSet)\\n\\n # sort the distances in order of smallest first:\\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\\n\\n neighbors = []\\n\\n # Extracting top k neighbors\\n for x in range(k):\\n neighbors.append(sorted_d[x])\\n\\n\\n classVotes = {}\\n\\n # Calculating the most freq class in the neighbors\\n results = {\\\"lessThan50\\\": 0, \\\"moreThan50\\\": 0}\\n\\n # creating a dataframe to which we will add the income values:\\n\\n for x in range(len(neighbors)):\\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\\n results[\\\"lessThan50\\\"] += 1\\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\\n results[\\\"moreThan50\\\"] += 1\\n\\n print('results',results)\\n\\n if (results[\\\"lessThan50\\\"] > results[\\\"moreThan50\\\"]):\\n incomePredictions.append(0.0)\\n elif (results[\\\"lessThan50\\\"] < results[\\\"moreThan50\\\"]):\\n incomePredictions.append(1.0)\\n\\n return incomePredictions\",\n \"def n_clusters(self):\\n return self.model.n_clusters\",\n \"def __init__(self, training_set, k=5):\\n super(Knn, self).__init__(training_set)\\n self.k = k\",\n \"def train(self, trainData):\\n pass\",\n \"def train(self, training_data, chunk_size=100):\\n # For some reason, for the SVM to work, the keys need to be in alphabetical order\\n training_data = {k : training_data[k] for k in sorted(training_data)}\\n\\n # Compile all author texts into one large text to then be broken down\\n for auth in training_data:\\n training_data[auth] = '\\\\n\\\\n'.join(training_data[auth])\\n\\n self.auths = list(training_data.keys())\\n self.chunk_size = chunk_size\\n\\n # Creates two lists, one of the texts and one of the corresponding author labels.\\n labels = []\\n texts = []\\n for auth in training_data:\\n lines = training_data[auth].split('\\\\n')\\n for p in range( chunk_size, len(lines), chunk_size ):\\n labels.append(auth) # authors per text in the training corpus\\n texts.append('\\\\n'.join(lines[p-chunk_size : p])) # texts in the training corpus\\n labels = array(labels)\\n texts = array(texts)\\n\\n # Cleans the texts\\n for i in range(len(texts)):\\n texts[i] = self._clean(texts[i])\\n\\n # Generates the profiles from these tests\\n profiles = zeros((len(texts), len(self.alph)**self.N))\\n for i in range(len(texts)):\\n profiles[i] = self._profile(texts[i])\\n\\n\\n # Reduces the features and fits the model\\n self.train_data = [profiles, labels]\\n self._reduceFeatures()\\n\\n self.model = SVC(kernel='linear')\\n self.model.probability = True\\n self.model.fit(self.train_data[0], self.train_data[1])\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def __init__(self, trainset, k=3):\\n self._trainset = trainset\\n self.k = k\",\n \"def __init__(self,\\n dataset,\\n samples_per_gpu=1,\\n num_replicas=None,\\n rank=None):\\n _rank, _num_replicas = get_dist_info()\\n if num_replicas is None:\\n num_replicas = _num_replicas\\n if rank is None:\\n rank = _rank\\n self.dataset = dataset\\n self.samples_per_gpu = samples_per_gpu\\n self.num_replicas = num_replicas\\n self.rank = rank\\n self.epoch = 0\\n if not hasattr(self.dataset, 'flag'):\\n raise ValueError(\\\"the dataset doesn't have a atrribute named 'flag'\\\")\\n self.flag = self.dataset.flag\\n self.group_sizes = np.bincount(self.flag)\\n\\n self.num_samples = 0\\n for i, j in enumerate(self.group_sizes):\\n self.num_samples += int(math.ceil(\\n self.group_sizes[i] * 1.0 / self.samples_per_gpu / self.num_replicas\\n )) * self.samples_per_gpu\\n self.total_size = self.num_samples * self.num_replicas\",\n \"def run(self):\\n for i,p in enumerate(self.pairs):\\n self.forPointPair(i)\\n if i % 100000 == 0:\\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))\",\n \"def fit(self, data, labels, labels_pred):\\n self.n_samples, dim = data.shape\\n self.labels_unique = np.unique(labels)\\n self.n_classes = len(self.labels_unique)\\n if self.n_neighbors is None:\\n # Set number of nearest neighbors based on the maximum number of samples per class and the neighborhood\\n # constant\\n num = 0\\n for c in self.labels_unique:\\n ind = np.where(labels == c)[0]\\n if ind.shape[0] > num:\\n num = ind.shape[0]\\n\\n self.n_neighbors = int(np.ceil(num ** self.neighborhood_constant))\\n\\n logger.info(\\\"Number of samples: {:d}. Data dimension = {:d}.\\\".format(self.n_samples, dim))\\n logger.info(\\\"Number of classes: {:d}.\\\".format(self.n_classes))\\n logger.info(\\\"Number of neighbors (k): {:d}.\\\".format(self.n_neighbors))\\n logger.info(\\\"Fraction of outliers (alpha): {:.4f}.\\\".format(self.alpha))\\n if self.model_dim_reduction:\\n data = transform_data_from_model(data, self.model_dim_reduction)\\n dim = data.shape[1]\\n logger.info(\\\"Applying dimension reduction to the data. Projected dimension = {:d}.\\\".format(dim))\\n\\n # Distance from each sample in `data` to the `1 - alpha` level sets corresponding to each class\\n distance_level_sets = np.zeros((self.n_samples, self.n_classes))\\n self.index_knn = dict()\\n self.epsilon = dict()\\n indices_sub = dict()\\n for j, c in enumerate(self.labels_unique):\\n logger.info(\\\"Processing data from class '{}':\\\".format(c))\\n logger.info(\\\"Building a KNN index for all the samples from class '{}'.\\\".format(c))\\n indices_sub[c] = np.where(labels == c)[0]\\n data_sub = data[indices_sub[c], :]\\n self.index_knn[c] = KNNIndex(\\n data_sub, n_neighbors=self.n_neighbors,\\n metric=self.metric, metric_kwargs=self.metric_kwargs,\\n approx_nearest_neighbors=self.approx_nearest_neighbors,\\n n_jobs=self.n_jobs,\\n low_memory=self.low_memory,\\n seed_rng=self.seed_rng\\n )\\n # Distances to the k nearest neighbors of each sample\\n _, nn_distances = self.index_knn[c].query_self(k=self.n_neighbors)\\n # Radius or distance to the k-th nearest neighbor for each sample\\n radius_arr = nn_distances[:, self.n_neighbors - 1]\\n\\n # Smallest radius `epsilon` such that only `alpha` fraction of the samples from class `c` have radius\\n # greater than `epsilon`\\n if self.alpha > 0.:\\n self.epsilon[c] = np.percentile(radius_arr, 100 * (1 - self.alpha), interpolation='midpoint')\\n\\n # Exclude the outliers and build a KNN index with the remaining samples\\n mask_incl = radius_arr <= self.epsilon[c]\\n mask_excl = np.logical_not(mask_incl)\\n num_excl = mask_excl[mask_excl].shape[0]\\n else:\\n # Slightly larger value than the largest radius\\n self.epsilon[c] = 1.0001 * np.max(radius_arr)\\n\\n # All samples are included in the density level set\\n mask_incl = np.ones(indices_sub[c].shape[0], dtype=np.bool)\\n mask_excl = np.logical_not(mask_incl)\\n num_excl = 0\\n\\n if num_excl:\\n logger.info(\\\"Excluding {:d} samples with radius larger than {:.6f} and building a KNN index with \\\"\\n \\\"the remaining samples.\\\".format(num_excl, self.epsilon[c]))\\n self.index_knn[c] = KNNIndex(\\n data_sub[mask_incl, :], n_neighbors=self.n_neighbors,\\n metric=self.metric, metric_kwargs=self.metric_kwargs,\\n approx_nearest_neighbors=self.approx_nearest_neighbors,\\n n_jobs=self.n_jobs,\\n low_memory=self.low_memory,\\n seed_rng=self.seed_rng\\n )\\n # Distance to the nearest neighbor of each sample that is part of the KNN index\\n _, dist_temp = self.index_knn[c].query_self(k=1)\\n ind = indices_sub[c][mask_incl]\\n distance_level_sets[ind, j] = dist_temp[:, 0]\\n\\n # Distance to the nearest neighbor of each sample that is not a part of the KNN index (outliers)\\n _, dist_temp = self.index_knn[c].query(data_sub[mask_excl, :], k=1)\\n ind = indices_sub[c][mask_excl]\\n distance_level_sets[ind, j] = dist_temp[:, 0]\\n else:\\n # No need to rebuild the KNN index because no samples are excluded.\\n # Distance to the nearest neighbor of each sample\\n distance_level_sets[indices_sub[c], j] = nn_distances[:, 0]\\n\\n logger.info(\\\"Calculating the trust score for the estimation data.\\\")\\n for c in self.labels_unique:\\n # Compute the distance from each sample from class `c` to the level sets from the remaining classes\\n data_sub = data[indices_sub[c], :]\\n for j, c_hat in enumerate(self.labels_unique):\\n if c_hat == c:\\n continue\\n\\n _, dist_temp = self.index_knn[c_hat].query(data_sub, k=1)\\n distance_level_sets[indices_sub[c], j] = dist_temp[:, 0]\\n\\n self.scores_estim = self._score_helper(distance_level_sets, labels_pred)\\n return self\",\n \"def _extend_label_set(self, data, trainer_cls, session):\\n # Select which nodes to label next, and predict their labels.\\n selected_samples, selected_labels = self._select_samples_to_label(\\n data, trainer_cls, session)\\n # Replace the labels of the new nodes with the predicted labels.\\n if selected_samples.shape[0] > 0:\\n data.label_samples(selected_samples, selected_labels)\\n return selected_samples\",\n \"def run(\\n self,\\n number_of_clusters=None,\\n max_K=8,\\n method_clustering=\\\"pam\\\",\\n init_clustering=\\\"random\\\",\\n max_iter_clustering=100,\\n discart_value_JI=0.6,\\n bootstraps_JI=100,\\n bootstraps_p_value=100,\\n n_jobs=1,\\n verbose=1,\\n ):\\n\\n if number_of_clusters is None:\\n self.k = optimizer.optimizeK(\\n self.distance_matrix,\\n self.y.to_numpy(),\\n self.model_type,\\n max_K,\\n method_clustering,\\n init_clustering,\\n max_iter_clustering,\\n discart_value_JI,\\n bootstraps_JI,\\n self.random_state,\\n n_jobs,\\n verbose,\\n )\\n\\n if self.k == 1:\\n warnings.warn(\\\"No stable clusters were found!\\\")\\n return\\n\\n print(f\\\"Optimal number of cluster is: {self.k}\\\")\\n\\n else:\\n self.k = number_of_clusters\\n print(f\\\"Use {self.k} as number of cluster\\\")\\n\\n self.cluster_labels = (\\n kmedoids.KMedoids(\\n n_clusters=self.k,\\n method=method_clustering,\\n init=init_clustering,\\n metric=\\\"precomputed\\\",\\n max_iter=max_iter_clustering,\\n random_state=self.random_state,\\n )\\n .fit(self.distance_matrix)\\n .labels_\\n )\\n\\n (\\n self._data_clustering_ranked,\\n self.p_value_of_features,\\n ) = stats.calculate_global_feature_importance(\\n self.X, self.y, self.cluster_labels, self.model_type\\n )\\n self._p_value_of_features_per_cluster = (\\n stats.calculate_local_feature_importance(\\n self._data_clustering_ranked, bootstraps_p_value\\n )\\n )\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 16\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints + 1.0\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def partition_data(self):\\n\\n _header_ = self._header_ + 'partition_data(): '\\n\\n if self.verbose:\\n print(_header_ + 'Partitioning data ...')\\n\\n network = self._useful_network()\\n\\n if self.nidx_train:\\n # The only reason that allows .nidx to not be empty would be that a training Data was copied over\\n # hence, the training node indices are retained and need to be excluded\\n print(_header_ + 'Excluding %d training nodes transfered from training dataset ...' % len(self.nidx_train))\\n nidx = set(self.nidx2lidx.keys()) - set(self.nidx_train)\\n self.nidx_exclude += self.nidx_train\\n self.nidx_train = []\\n else:\\n nidx = set(self.nidx2lidx.keys())\\n\\n for l in nidx:\\n if l in network:\\n if self.node_labels[l]:\\n self.nidx_train.append(l)\\n else:\\n self.nidx_exclude.append(l)\\n\\n if self.verbose:\\n print(_header_ + 'Found %d nodes' % len(self.nidx2lidx))\\n print(' %d nodes with labels of interest' % len(self.nidx_train))\\n print(' %d nodes can be used to predict' % len(self.nidx_pred))\\n print(' %d nodes cannot be mapped due to lack of mappable links' % len(self.nidx_exclude))\\n\\n return self\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def final_evaluation(self):\\n print(\\\"\\\\n=== Assign final labels ===\\\")\\n\\n # skip if there is only one cluster\\n n_cluster = len(set(self.label[self.label != -1]))\\n if n_cluster < 2:\\n print(f\\\"Skip final evaluation because only {n_cluster} cluster label exist.\\\")\\n # name all cluster as c0\\n self.label = np.zeros(self.label.size, dtype=int)\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in self.label]\\n self.label_proba = np.ones(self.label.size, dtype=int)\\n self.final_accuracy = 1\\n else:\\n # predict outliers\\n outlier_x = self.X[self.label == -1]\\n outlier_idx = np.where(self.label == -1)[0]\\n if len(outlier_idx) != 0:\\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\\n for cell, pred_label in outlier_predict.items():\\n self.label[cell] = pred_label\\n print(\\n \\\"Assigned all the multi-leiden clustering outliers into clusters \\\"\\n \\\"using the prediction model from final clustering version.\\\"\\n )\\n\\n # final evaluation of non-outliers using cross val predict\\n final_predict_proba = cross_val_predict(\\n self.supervise_model,\\n self.X,\\n y=self.label,\\n method=\\\"predict_proba\\\",\\n n_jobs=self.n_jobs,\\n verbose=0,\\n cv=10,\\n )\\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\\n print(f\\\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\\\")\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in final_predict]\\n self.label_proba = final_cell_proba.values\\n self.final_accuracy = final_acc\\n\\n self.label = [f\\\"c{label}\\\" for label in self.label]\\n return\",\n \"def __init__(self, filename='', limit=0.80, members=3, delimiter=','):\\n self.count = 0 # counter for correct predictions\\n self.results = self.load_data(filename=filename, limit=limit, delim=delimiter) # load data and receive response\\n self.test_data = self.results[1]\\n self.training_data = self.results[0]\\n # get data neighbours of each member of the test data set.\\n for x in range(len(self.test_data)):\\n neighbours = self.get_neighbours(training_data=self.training_data, instance=self.test_data[x], k=members)\\n # make a prediction.\\n label = self.count_votes(neighbours=neighbours)\\n # compare predicted outcome to actual outcome.\\n print(\\\"{}). Actual outcome => '{}' & Predicted outcome => '{}'\\\".format(x + 1, self.test_data[x][-1], label))\\n if self.test_data[x][-1] == label:\\n self.count = self.count + 1\\n\\n # Calculate accuracy percentage.\\n self.accuracy = (self.count / len(self.test_data)) * 100\\n print(\\\"\\\\nAccuracy = {0:.2f}%\\\".format(self.accuracy))\",\n \"def train(self, train_set) -> None:\\n super().train(train_set)\\n # split into data and target\\n xlist, y = zip(*train_set)\\n x = sparse.vstack(xlist)\\n self._classifier.fit(x, y)\",\n \"def supervise_learning(self):\\n if self._multi_leiden_clusters is None:\\n raise ValueError(\\n \\\"Run multi_leiden_clustering first to get a \\\" \\\"clustering assignment before run supervise_learning.\\\"\\n )\\n\\n n_cluster = np.unique(self._multi_leiden_clusters[self._multi_leiden_clusters != -1]).size\\n if n_cluster == 1:\\n print(\\\"There is only one cluster except for outliers, can not train supervise model on that.\\\")\\n self.label = np.zeros(self.n_obs, dtype=int)\\n return\\n print(\\\"\\\\n=== Start supervise model training and cluster merging ===\\\")\\n\\n x = self.X\\n cur_y = self._multi_leiden_clusters.copy()\\n score = None\\n step = 0.1\\n\\n if self.supervise_model is None:\\n # create default model if no model provided\\n clf = self._create_model(n_estimators=500)\\n else:\\n clf = self.supervise_model\\n for cur_iter in range(1, self.max_iter + 1):\\n print(f\\\"\\\\n=== iteration {cur_iter} ===\\\")\\n n_labels = np.unique(cur_y[cur_y != -1]).size\\n print(f\\\"{n_labels} non-outlier labels\\\")\\n if n_labels < 2:\\n print(f\\\"Stop iteration because only {n_labels} cluster remain.\\\")\\n break\\n\\n x_train, y_train, x_test, y_test = _split_train_test_per_group(\\n x=x,\\n y=cur_y,\\n frac=self.train_frac,\\n max_train=self.train_max_n,\\n random_state=self.random_state + cur_iter,\\n # every time train-test split got a different random state\\n )\\n (\\n clf,\\n score,\\n cluster_map,\\n cmat,\\n r1_cmat,\\n r2_cmat,\\n ) = single_supervise_evaluation(\\n clf,\\n x_train,\\n y_train,\\n x_test,\\n y_test,\\n r1_norm_step=step,\\n r2_norm_step=step,\\n )\\n step = min(0.2, max(0.05, 2 * (self.target_accuracy - score)))\\n\\n # save step data for plotting\\n self.step_data[cur_iter] = [\\n cur_y,\\n cmat,\\n r1_cmat,\\n r2_cmat,\\n cluster_map,\\n score,\\n step,\\n ]\\n\\n if score > self.target_accuracy:\\n print(\\n f\\\"Stop iteration because current accuracy {score:.3f}\\\"\\n f\\\" > target accuracy {self.target_accuracy:.3f}.\\\"\\n )\\n break\\n\\n # judge results\\n if len(cluster_map) > 0:\\n print(f\\\"Merging {len(cluster_map)} clusters.\\\")\\n cur_y = pd.Series(cur_y).apply(lambda i: cluster_map[i] if i in cluster_map else i)\\n # renumber labels from large to small\\n ordered_map = {c: i for i, c in enumerate(cur_y[cur_y != -1].value_counts().index)}\\n cur_y = pd.Series(cur_y).apply(lambda i: ordered_map[i] if i in ordered_map else i).values\\n else:\\n print(\\\"Stop iteration because there is no cluster to merge\\\")\\n break\\n else:\\n print(\\\"Stop iteration because reaching maximum iteration.\\\")\\n self._label_with_leiden_outliers = cur_y\\n self.label = cur_y\\n self.supervise_model = clf\\n self.final_accuracy = score\\n return\",\n \"def cluster_data(data, num_clusters, batch_size, shuffle=True, verbose=True):\\n clusters = ClusterData(data, num_clusters, recursive=True, save_dir=None)\\n if verbose:\\n for cluster in clusters:\\n print(cluster)\\n return ClusterLoader(clusters, batch_size=batch_size)\",\n \"def pre_train(self, dataset):\\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\\n pe = principleextractor.PrincipleExtractor()\\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\\n # not in the .json; or with argument given TODO\\n self.skm.add_syllogistic_data(data=pd_dataset)\\n\\n self.skm.generate_clusters(cutoff=self.cutoff)\\n\\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\\n\\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\\n self.skm.final_clusters_num)\\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\\n participant_correspondence)\\n\\n self.k_clusters = self.skm.final_clusters_syll_list\\n\\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\\n gen_skm.add_syllogistic_data(data=pd_dataset)\\n\\n gen_skm.generate_clusters(cutoff=self.cutoff)\\n\\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]\",\n \"def run(self, X_train, Y_train, X_test, Y_test, **kwargs):\\n if self.clf is None:\\n self.hidden_layer_sizes = (X_train.shape[1], X_train.shape[1])\\n self.initMLPClassifier(**kwargs)\\n\\n self.clf.fit(X_train, Y_train.astype(int))\\n Y_pred = self.clf.predict(X_test)\\n return ClassificationResult(Y_test, Y_pred), self\",\n \"def run(self, data):\\n\\t\\treduced_data = PCA(n_components=2).fit_transform(data)\\n\\n\\t\\t# Run the algorithm\\n\\t\\tself.estimator.fit_transform(reduced_data)\\n\\n\\t\\t# Save all relevent properties\\n\\t\\tself.input_data = data\\n\\t\\tself.centroids = self.estimator.cluster_centers_\\n\\t\\tself.node_positions = reduced_data\\n\\t\\tself.labels = self.estimator.labels_\\n\\n\\t\\t# Enable visualising when debugging\\n\\t\\t# self.visualize(reduced_data)\",\n \"def total_predict_batches(self) -> int:\\n return sum(self.trainer.num_predict_batches)\",\n \"def glasses_data_preprocessing(data_directory, filename_column, target_column, training_percentage_size=0.85,\\n batches_size=16, validation_split=0.15, img_size=(96, 96), color_mode='rgb',\\n horizontal_flip=True):\\n # Loading the csv file\\n path = os.path.join('../Datasets', data_directory)\\n # The sep parameter chosen according to the delimiter adopted in labels.csv\\n # Take the first 600 examples\\n dataset_labels = pd.read_csv(os.path.join(path, 'labels.csv'), sep='\\\\t', dtype='str').head(600)\\n dataset_labels[target_column] = list(map(str, [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,\\n 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,\\n 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,\\n 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\\n 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,\\n 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\\n 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,\\n 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0,\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0,\\n 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\\n 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\\n 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0,\\n # Others 300\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0,\\n 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,\\n 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,\\n 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\\n 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,\\n 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,\\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0\\n ]))\\n # Divide data in two sets: one for training and one for testing\\n train_folder = os.path.join(path, 'img')\\n test_folder = os.path.join(path + '_test', 'img')\\n # Division will be made only if the testing directory does not already exist\\n if not os.path.isdir(test_folder):\\n # Create the Test dataset folder\\n # If parents is True, any missing parents of the folder will be created\\n # If exist_ok is True, an Error is raised if the directory already exists\\n Path(test_folder).mkdir(parents=True, exist_ok=True)\\n # Sorted list of all the images available\\n files = sorted(os.listdir(train_folder), key=lambda x: int(x.split(\\\".\\\")[0]))\\n # Simple random sampling to select examples for the test dataset\\n images_testing = sorted(sample(files, round(len(files) * (1 - training_percentage_size))))\\n # Move all the test images into the related folder\\n for file in images_testing:\\n shutil.move(os.path.join(train_folder, file), test_folder)\\n # List of all the images within the training and testing folders\\n random_test_list = sorted([dataset_labels[dataset_labels[filename_column] == i].index[0]\\n for i in os.listdir(test_folder)])\\n random_training_list = sorted([dataset_labels[dataset_labels[filename_column] == i].index[0]\\n for i in os.listdir(train_folder)])\\n\\n # Prepare the training, test and validation batches\\n # Select labels associated to the images inside the training and test folders\\n training_labels = dataset_labels.iloc[[i for i in random_training_list]]\\n test_labels = dataset_labels.iloc[[i for i in random_test_list]]\\n # With the following line the validation_split passed as argument becomes equal to the percentage of the total\\n # dataset (and not anymore to the percentage of the training dataset dedicated to the validation dataset)\\n validation_split = validation_split / training_percentage_size\\n # ImageDataGenerator generates batches of images with real-time data augmentation\\n image_generator = ImageDataGenerator(rescale=1. / 255., validation_split=validation_split,\\n horizontal_flip=horizontal_flip)\\n # It produces batches of images everytime it is called\\n training_batches = image_generator.flow_from_dataframe(dataframe=training_labels, directory=train_folder,\\n x_col=filename_column, y_col=target_column,\\n subset=\\\"training\\\", batch_size=batches_size, seed=42,\\n color_mode=color_mode, shuffle=True, target_size=img_size)\\n # No data augmentation applied for validation and test data\\n image_generator = ImageDataGenerator(rescale=1. / 255., validation_split=validation_split)\\n valid_batches = image_generator.flow_from_dataframe(dataframe=training_labels, directory=train_folder,\\n x_col=filename_column, y_col=target_column, subset=\\\"validation\\\",\\n batch_size=batches_size, seed=42, shuffle=True,\\n color_mode=color_mode, target_size=img_size)\\n test_batches = image_generator.flow_from_dataframe(dataframe=test_labels, directory=test_folder,\\n x_col=filename_column, y_col=target_column,\\n color_mode=color_mode, batch_size=batches_size,\\n shuffle=False, target_size=img_size)\\n return training_batches, valid_batches, test_batches\",\n \"def predict(self):\\n raise NotImplementedError\",\n \"def create_array_for_training(self, predicted_data, batch_size=1):\\r\\n return predicted_data\",\n \"def _cluster(self):\\n self._not_included = self.data\\n self.leaves = []\\n flag = int(rand() * len(self.data))\\n flag = self._generate(flag)\\n while len(self._not_included) > 0:\\n flag = self._generate(flag)\\n if flag == -1:\\n break\\n pass\\n self._remember.append({\\n 'threshold': self._base_threshold,\\n 'result': len(self.leaves)\\n })\\n print(len(self._remember), {\\n 'threshold': self._base_threshold,\\n 'result': len(self.leaves)\\n })\\n return\",\n \"def split_data(self):\\n if not self.load_data:\\n raise AttributeError('Preprocessor has not loaded any data.')\\n \\n # 3 - Find example counts for each set\\n self.n_examples = self.data[0].shape[0]\\n self.n_train = int(self.n_examples * self.train_ratio)\\n self.n_val = int(self.n_examples * self.val_ratio)\\n self.n_test = self.n_examples - self.n_train - self.n_val\\n \\n logger.info(f'Set sizes:')\\n logger.info(f'train: {self.n_train}')\\n logger.info(f'val: {self.n_val}')\\n logger.info(f'test: {self.n_test}')\\n if self.n_test < 0:\\n raise ValueError('Train + validation ratios must bef < 1')\\n\\n # 4 - Separate data into train, test, val\\n if isinstance(self.data[0], pd.DataFrame):\\n logger.info('Dataset is in a dataframe.')\\n self.isdataframe = True\\n\\n self.train_data = [self.data[0].iloc[:self.n_train],\\n self.data[1].iloc[:self.n_train]]\\n \\n self.val_data = [self.data[0].iloc[self.n_train:self.n_val + self.n_train],\\n self.data[1].iloc[self.n_train:self.n_val + self.n_train]]\\n \\n self.test_data = [self.data[0].iloc[self.n_val + self.n_train:],\\n self.data[1].iloc[self.n_val + self.n_train:]]\\n logger.info('Data was split into train, val, test.')\\n else:\\n self.isdataframe = False\\n logger.info('Dataset is in a numpy array.')\\n \\n # If datasets are numpy array or sparse\\n self.train_data = [self.data[0][:self.n_train],\\n self.data[1][:self.n_train]]\\n \\n self.val_data = [self.data[0][self.n_train:self.n_val + self.n_train],\\n self.data[1][self.n_train:self.n_val + self.n_train]]\\n \\n self.test_data = [self.data[0][self.n_val + self.n_train:],\\n self.data[1][self.n_val + self.n_train:]]\\n logger.info('Data was split into train, val, test.')\\n \\n assert(self.n_train == self.train_data[0].shape[0])\\n assert(self.n_val == self.val_data[0].shape[0])\\n assert(self.n_test == self.test_data[0].shape[0])\\n \\n # Free memory\\n del self.data\\n \\n if self.save_sets:\\n self.save_datasets()\",\n \"def load_torchvision_data(data, label, test_size = 0.2, valid_size=0.1, splits=None, shuffle=True,\\n stratified=False, random_seed=None, batch_size = 64,\\n maxsize = None, maxsize_test=None, num_workers = 0):\\n\\n x_train, x_test, y_train, y_test = train_test_split(data, label, test_size = test_size, stratify=label)\\n train, test = CERDataset(x_train, y_train), CERDataset(x_test, y_test)\\n\\n if type(train.targets) is list or type(train.targets) is np.ndarray:\\n train.targets = torch.LongTensor(train.targets)\\n test.targets = torch.LongTensor(test.targets)\\n\\n if not hasattr(train, 'classes') or not train.classes:\\n train.classes = sorted(torch.unique(train.targets).tolist())\\n test.classes = sorted(torch.unique(train.targets).tolist())\\n\\n ### Data splitting\\n fold_idxs = {}\\n if splits is None and valid_size == 0:\\n ## Only train\\n fold_idxs['train'] = np.arange(len(train))\\n elif splits is None and valid_size > 0:\\n ## Train/Valid\\n train_idx, valid_idx = random_index_split(len(train), 1-valid_size, (maxsize, None)) # No maxsize for validation\\n fold_idxs['train'] = train_idx\\n fold_idxs['valid'] = valid_idx\\n\\n for k, idxs in fold_idxs.items():\\n if maxsize and maxsize < len(idxs):\\n fold_idxs[k] = np.sort(np.random.choice(idxs, maxsize, replace = False))\\n\\n sampler_class = SubsetRandomSampler if shuffle else SubsetSampler\\n fold_samplers = {k: sampler_class(idxs) for k,idxs in fold_idxs.items()}\\n\\n ### Create DataLoaders\\n dataloader_args = dict(batch_size=batch_size,num_workers=num_workers)\\n\\n fold_loaders = {k:dataloader.DataLoader(train, sampler=sampler,**dataloader_args)\\n for k,sampler in fold_samplers.items()}\\n\\n if maxsize_test and maxsize_test < len(test):\\n test_idxs = np.sort(np.random.choice(len(test), maxsize_test, replace = False))\\n sampler_test = SubsetSampler(test_idxs) # For test don't want Random\\n dataloader_args['sampler'] = sampler_test\\n else:\\n dataloader_args['shuffle'] = False\\n test_loader = dataloader.DataLoader(test, **dataloader_args)\\n fold_loaders['test'] = test_loader\\n\\n fnames, flens = zip(*[[k,len(v)] for k,v in fold_idxs.items()])\\n fnames = '/'.join(list(fnames) + ['test'])\\n flens = '/'.join(map(str, list(flens) + [len(test)]))\\n\\n if hasattr(train, 'data'):\\n logger.info('Input Dim: {}'.format(train.data.shape[1:]))\\n logger.info('Classes: {} (effective: {})'.format(len(train.classes), len(torch.unique(train.targets))))\\n print(f'Fold Sizes: {flens} ({fnames})')\\n\\n return fold_loaders, {'train': train, 'test':test}\",\n \"def fit(self, X, y=None):\\n X = self._validate_data(X, ensure_min_features=2)\\n super()._fit(X.T)\\n self._n_features_out = self.n_clusters_\\n return self\",\n \"def __init__(self, vein: Vein, cluster_size: int = 8, **kwargs):\\n super().__init__(vein, **kwargs)\\n\\n self.cluster_size = cluster_size\",\n \"def do_instance_pruning(self):\\n\\n # retrieve the probability of predicting fraud for each model (K models)\\n # size: K x ChunkSize x 2 (2 for binary labels)\\n predict_proba_fraud = [-1] * self.K\\n\\n # for each instance in the data chunk\\n for i, instance in enumerate(self.y_chunk):\\n sum_weight = 0\\n current_F = 0\\n F_vect = np.zeros(self.K) # Fk at each stage\\n\\n # compute F_k(y) for k = 1...K - the classifiers are sorted in DESCENDING order of weights\\n k = -1\\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\\n k += 1\\n clf = model.clf\\n sum_weight += model.weight\\n\\n # compute the current probability\\n # if the probability is not initialized we call the `predict_proba` method\\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\\\\n or (predict_proba_fraud[k].shape[0] != self.S):\\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\\n\\n # check if we have the probabilities of 2 labels (because we're working with BINARY classification)\\n # if we don't have the probability of predicting fraud it will be 0 so we don't do anything\\n if len(predict_proba_fraud[k][i]) == 2:\\n current_F += model.weight * predict_proba_fraud[k][i][1]\\n\\n # (2) compute the Fk for each example seen at each stage\\n F_k = current_F / sum_weight\\n F_vect[k] = F_k\\n\\n # (3) compute the error\\n err_x = F_vect - F_vect[-1]\\n\\n # (4) update the mean and the variance of the error of these training examples for each bin (i,k)\\n # we look at the error at each step for the given example\\n for k, err in enumerate(err_x):\\n # 1 --> we assign Fk to the corresponding bin (i,k) or (j,k)here because we used i index before\\n eps = len(self.bins)\\n\\n for j in range(0, eps):\\n if (j / eps) <= F_vect[k] < ((j + 1) / eps):\\n self.bins[j][k]['num'] += 1\\n\\n # 2--> we compute the mean error in this bin\\n self.bins[j][k]['mean'] += err\\n\\n # 2--> we compute the variance of the error in this bin\\n # (basically we will just compute the squared error and do the division later)\\n self.bins[j][k]['var'] += err ** 2\\n\\n # if we've assigned it to a bin, break and go to the next stage\\n break\\n\\n # after computing everything we do the division by the total number assigned to a bin\\n for i in range(0, len(self.bins)):\\n # a bit tricky because sometimes we have bins that don't have any input example --> remains at 0\\n for k in range(self.K):\\n if self.bins[i][k]['num'] > 0:\\n # divide the sum of error by the number of examples in the bin\\n self.bins[i][k]['mean'] = self.bins[i][k]['mean'] / self.bins[i][k]['num']\\n\\n # compute the variance\\n self.bins[i][k]['var'] = (self.bins[i][k]['var'] / self.bins[i][k]['num']) - \\\\\\n (self.bins[i][k]['mean']) ** 2\",\n \"def __init__(\\n self, k_list, data, epoch=0, init_centroids=None, frozen_centroids=False\\n ):\\n super().__init__()\\n self.k_list = k_list\\n self.data = data\\n self.d = data.shape[-1]\\n self.init_centroids = init_centroids\\n self.frozen_centroids = frozen_centroids\\n\\n self.logger = logging.getLogger(\\\"Kmeans\\\")\\n self.debug = False\\n self.epoch = epoch + 1\",\n \"def train_test_split(self):\\n random.seed(self.args.seed)\\n nodes = [node for node in range(self.ncount)]\\n random.shuffle(nodes)\\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])\",\n \"def fit_predict(self):\\n raise AttributeError\",\n \"def get_data_ninstances(self):\\n return self.data_ninstances\",\n \"def fiedler_clustering(self, num_clusters):\\n\\n clusters = MiniBatchKMeans(n_clusters=num_clusters).fit_predict(self.graph)\\n\\n return clusters\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64410335","0.6329403","0.6253084","0.6185533","0.6177989","0.61298734","0.6108489","0.61044306","0.61016464","0.606673","0.6049881","0.6038121","0.60097194","0.60030633","0.59279317","0.59199035","0.5886591","0.5773972","0.5772074","0.57601804","0.57601804","0.57574743","0.5753299","0.5730244","0.5718103","0.57179326","0.5709638","0.56814766","0.5676092","0.56547284","0.56107116","0.5601713","0.5599482","0.5593107","0.55921066","0.55832154","0.55807525","0.55766493","0.55432916","0.55348206","0.55336064","0.5516271","0.55142766","0.5513121","0.5504018","0.54853356","0.5477575","0.54731536","0.54630005","0.5459605","0.54581785","0.5455819","0.54455227","0.54181427","0.5417088","0.5415082","0.5413194","0.5412938","0.54127216","0.5412595","0.5412011","0.54078573","0.54074097","0.540432","0.54029924","0.54027617","0.5400788","0.5393581","0.53909546","0.53843117","0.53777766","0.5373574","0.53645575","0.5360039","0.5357966","0.53493565","0.53492594","0.53492594","0.5348219","0.53464115","0.53402686","0.533922","0.5338975","0.53354627","0.53338945","0.5333022","0.5332924","0.533264","0.53204614","0.53171337","0.53128153","0.53111076","0.53086233","0.5307676","0.5304727","0.5295057","0.529482","0.52930766","0.5292916","0.52925974","0.5289099"],"string":"[\n \"0.64410335\",\n \"0.6329403\",\n \"0.6253084\",\n \"0.6185533\",\n \"0.6177989\",\n \"0.61298734\",\n \"0.6108489\",\n \"0.61044306\",\n \"0.61016464\",\n \"0.606673\",\n \"0.6049881\",\n \"0.6038121\",\n \"0.60097194\",\n \"0.60030633\",\n \"0.59279317\",\n \"0.59199035\",\n \"0.5886591\",\n \"0.5773972\",\n \"0.5772074\",\n \"0.57601804\",\n \"0.57601804\",\n \"0.57574743\",\n \"0.5753299\",\n \"0.5730244\",\n \"0.5718103\",\n \"0.57179326\",\n \"0.5709638\",\n \"0.56814766\",\n \"0.5676092\",\n \"0.56547284\",\n \"0.56107116\",\n \"0.5601713\",\n \"0.5599482\",\n \"0.5593107\",\n \"0.55921066\",\n \"0.55832154\",\n \"0.55807525\",\n \"0.55766493\",\n \"0.55432916\",\n \"0.55348206\",\n \"0.55336064\",\n \"0.5516271\",\n \"0.55142766\",\n \"0.5513121\",\n \"0.5504018\",\n \"0.54853356\",\n \"0.5477575\",\n \"0.54731536\",\n \"0.54630005\",\n \"0.5459605\",\n \"0.54581785\",\n \"0.5455819\",\n \"0.54455227\",\n \"0.54181427\",\n \"0.5417088\",\n \"0.5415082\",\n \"0.5413194\",\n \"0.5412938\",\n \"0.54127216\",\n \"0.5412595\",\n \"0.5412011\",\n \"0.54078573\",\n \"0.54074097\",\n \"0.540432\",\n \"0.54029924\",\n \"0.54027617\",\n \"0.5400788\",\n \"0.5393581\",\n \"0.53909546\",\n \"0.53843117\",\n \"0.53777766\",\n \"0.5373574\",\n \"0.53645575\",\n \"0.5360039\",\n \"0.5357966\",\n \"0.53493565\",\n \"0.53492594\",\n \"0.53492594\",\n \"0.5348219\",\n \"0.53464115\",\n \"0.53402686\",\n \"0.533922\",\n \"0.5338975\",\n \"0.53354627\",\n \"0.53338945\",\n \"0.5333022\",\n \"0.5332924\",\n \"0.533264\",\n \"0.53204614\",\n \"0.53171337\",\n \"0.53128153\",\n \"0.53111076\",\n \"0.53086233\",\n \"0.5307676\",\n \"0.5304727\",\n \"0.5295057\",\n \"0.529482\",\n \"0.52930766\",\n \"0.5292916\",\n \"0.52925974\",\n \"0.5289099\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":93094,"cells":{"query":{"kind":"string","value":"This method calculates the query distance between the current data in the training set and the test data in question"},"document":{"kind":"string","value":"def query_distance(self, instance1=(), instance2=()):\n distance = sum([pow((a - b), 2) for a, b in zip(instance1, instance2)])\n return distance"},"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 getDistanceM(self, test, train):\n p = 2 # TUNE currently euclidian distance\n distanceM = pd.DataFrame(index=test.index.values, columns=train.index.values)\n for testrow, testing in test.iterrows():\n for trainrow, training in train.iterrows():\n tot = 0\n for indexc, column in test.iteritems():\n #print(indexc)\n if indexc in self.discrete: # need to reference VDM\n datapoint = self.VDMdict.get(indexc)\n dif = datapoint[testing[indexc]][training[indexc]]\n elif indexc != \"class\": #get distance beween 2 points\n dif = abs(float(testing[indexc]) - float(training[indexc]))\n\n tot += dif ** p\n distance = tot ** (1 / p) #distance is calculated\n distanceM.at[testrow, trainrow] = distance #put in distance matrix\n return(distanceM)","def calculate_distances(train_data, test_datum):\n n = train_data.shape[0]\n dist = []\n for i in range(n):\n distance = np.sqrt(np.sum(np.square(train_data[i]-test_datum)))\n dist.append(distance)\n dist = np.asarray(dist)\n return dist","def euclideanDistance(data1, data2):\n distance = 0\n for x in range(14):\n data1[x] = truncate(data1[x], 3)\n data2[x] = truncate(data2[x], 3)\n dist = truncate((data1[x] - data2[x]) ** 2, 3)\n distance = truncate(distance + dist, 3)\n\n # Final Euclidean distance between train poing and test point:\n distance = truncate(np.sqrt(distance), 3)\n return distance","def compute_distances(self, X):\n num_test = X.shape[0]\n num_train = self.X_train.shape[0]\n dists = np.zeros((num_test, num_train))\n \n sum_test_square = np.sum(np.square(X), axis=1).reshape(-1, 1)\n sum_train_square = np.sum(np.square(self.X_train), axis=1).reshape(-1, 1)\n product_test_train = X @ self.X_train.T\n \n sum_test_square = np.repeat(sum_test_square, num_train, axis=1)\n sum_train_square = np.repeat(sum_train_square, num_test, axis=1).T\n \n dists_square = sum_test_square - 2 * product_test_train + sum_train_square\n \n dists = np.sqrt(dists_square)\n \n return dists","def test_distances(self):\n sf = make_classifier_data(n=10, d=2, seed=37)\n sf.remove_column(\"class\", inplace=True)\n\n numeric_features = [\"int0\", \"int1\", \"float0\", \"float1\"]\n array_features = [\"array0\"]\n string_features = [\"str0\"]\n dict_features = [\"dict0\"]\n\n ## Numeric standard distances should work for numeric columns\n for d in [\n \"euclidean\",\n \"squared_euclidean\",\n \"manhattan\",\n \"cosine\",\n \"transformed_dot_product\",\n ]:\n try:\n m = tc.dbscan.create(\n sf,\n features=numeric_features,\n distance=d,\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n except:\n assert False, \"Standard distance {} failed.\".format(d)\n\n ## Numeric standard distances should work for array columns\n for d in [\n \"euclidean\",\n \"squared_euclidean\",\n \"manhattan\",\n \"cosine\",\n \"transformed_dot_product\",\n ]:\n try:\n m = tc.dbscan.create(\n sf,\n features=array_features,\n distance=d,\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n except:\n assert False, \"Standard distance {} failed.\".format(d)\n\n ## String standard distances should work.\n for d in [\"levenshtein\"]:\n try:\n m = tc.dbscan.create(\n sf,\n features=string_features,\n distance=d,\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n except:\n assert False, \"Standard distance {} failed.\".format(d)\n\n ## Dictionary standard distances should work.\n for d in [\"jaccard\", \"weighted_jaccard\", \"cosine\", \"transformed_dot_product\"]:\n try:\n m = tc.dbscan.create(\n sf,\n features=dict_features,\n distance=d,\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n except:\n assert False, \"Standard distance {} failed.\".format(d)\n\n # Nonsensical combinations of feature types and distances should fail.\n with self.assertRaises(ValueError):\n m = tc.dbscan.create(\n sf,\n features=numeric_features,\n distance=\"levenshtein\",\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n\n with self.assertRaises(ToolkitError):\n m = tc.dbscan.create(\n sf,\n features=dict_features,\n distance=\"levenshtein\",\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n\n with self.assertRaises(ToolkitError):\n m = tc.dbscan.create(\n sf,\n features=string_features,\n distance=\"euclidean\",\n radius=1,\n min_core_neighbors=3,\n verbose=False,\n )\n\n # If no distance is specified, the automatic distance construction\n # should kick in and be correct.\n correct_dist = [\n [[\"str0\"], \"levenshtein\", 1],\n [[\"str1\"], \"levenshtein\", 1],\n [[\"dict0\"], \"jaccard\", 1],\n [[\"int0\", \"int1\", \"float0\", \"float1\"], \"euclidean\", 1],\n [[\"array0\"], \"euclidean\", 1],\n ]\n\n m = tc.dbscan.create(\n sf, radius=1, distance=None, min_core_neighbors=3, verbose=False\n )\n\n self.assertItemsEqual(m.distance, correct_dist)\n\n m = tc.dbscan.create(\n sf, radius=1, distance=\"auto\", min_core_neighbors=3, verbose=False\n )\n self.assertItemsEqual(m.distance, correct_dist)","def _get_dst(self, df_train, df_test):\n #train NearestNeighbors(Unsupervised learner)\n neigh = NearestNeighbors(1)\n neigh.fit(df_train[['longitude', 'latitude']])\n #find the K-neighbors of points in df_test\n distances, indices = neigh.kneighbors(df_test[['longitude', 'latitude']])\n return distances","def getDistances(trainingSet, testInstance, distances):\n # Empty list to store distances of between testInstance and each trainSet item\n # Number of dimensions to check\n length=len(testInstance) - 1\n # Iterate through all items in trainingSet and compute the distance, then append to the distances list\n for x in range(len(trainingSet)):\n dist=calculateDistance(testInstance, trainingSet[x], length)\n distances.append((trainingSet[x], dist))\n return distances","def dist_calc(self,Xtest):\n d,i = self.knn.kneighbors(Xtest)\n\n self.dist = d\n self.ind = i\n\n self.Xtest = Xtest","def dist_calc(self,Xtest):\n d,i = self.knn.kneighbors(Xtest)\n\n self.dist = d\n self.ind = i\n\n self.Xtest = Xtest","def test_distance(self):\n for emb_vals, point, dist_gt in self.DISTANCE_EXAMPLES:\n print(emb_vals, point, dist_gt)\n emb = to_emb(emb_vals)\n dist = emb.distance(point)\n assert np.allclose(dist, dist_gt), \\\n (\"Wrong distance for point {}: expected {} but was {};\"\n \"\\nembedding:\\n{}\").format(point, dist_gt, dist, str(emb))","def compute_distances_one_loop(self, X):\n num_test = X.shape[0]\n num_train = self.X_train.shape[0]\n dists = np.zeros((num_test, num_train))\n for i in range(num_test):\n dists[i, :] = np.sqrt(np.sum(np.square(X[i, :] - self.X_train), axis=1)).transpose()\n return dists","def compute_distances_two_loops(self, X):\n num_test = X.shape[0]\n num_train = self.X_train.shape[0]\n dists = np.zeros((num_test, num_train))\n for i in range(num_test):\n for j in range(num_train):\n dists[i, j] = np.sqrt(np.sum(np.square(X[i] - self.X_train[j])))\n return dists","def compute_distances_no_loops(self, X):\n num_test = X.shape[0]\n num_train = self.X_train.shape[0]\n dists = np.zeros((num_test, num_train))\n tDot = np.multiply(np.dot(X, self.X_train.T), -2)\n t1 = np.sum(np.square(X), axis=1, keepdims=True)\n t2 = np.sum(np.square(self.X_train), axis=1)\n tDot = np.add(t1, tDot)\n tDot = np.add(tDot, t2)\n dists = np.sqrt(tDot)\n #########################################################################\n # TODO: #\n # Compute the l2 distance between all test points and all training #\n # points without using any explicit loops, and store the result in #\n # dists. #\n # #\n # You should implement this function using only basic array operations; #\n # in particular you should not use functions from scipy. #\n # #\n # HINT: Try to formulate the l2 distance using matrix multiplication #\n # and two broadcast sums. #\n #########################################################################\n # pass\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n return dists","def test_distances(self):\n\t\tm1 = models.vgg11()\n\t\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\n\t\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2)\n\t\n\t\tprint(avg_dW,avg_db)\n\t\tactual_mean_distance = avg_dW\n\t\texpected_mean_distance = 46.485\n\t\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\n\t\t\n\t\tactual_mean_distance = avg_db\n\t\texpected_mean_distance = 0.67622\n\t\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\n\t\t\n\t\tprint(distances)","def compute_distances(self, x_q):\n # get distances of nearest neighbors in Benchmark from Query points\n distances_B, _ = self.nbrs_benchmark.kneighbors(x_q)\n radii_B = distances_B[:,-1] # distances of Kth-NN\n \n # get distances of nearest neighbors in Trial from Query points\n distances_T, _ = self.nbrs_trial.kneighbors(x_q)\n radii_T = distances_T[:,-1] # distances of Kth-NN\n \n coords = x_q\n \n return(radii_B, radii_T, coords)","def distance_train(self):\n\n for self.epoch in range(self.args.epochs):\n # switch to train mode\n self.set_train()\n data_loading_time = 0\n gpu_time = 0\n before_op_time = time.time()\n\n for batch_idx, inputs in enumerate(self.train_loader):\n data_loading_time += (time.time() - before_op_time)\n before_op_time = time.time()\n # -- PUSH INPUTS DICT TO DEVICE --\n self.inputs_to_device(inputs)\n\n # -- DISTANCE ESTIMATION --\n outputs, features = self.predict_distances(inputs)\n\n # -- POSE ESTIMATION --\n outputs.update(self.predict_poses(inputs, features))\n\n # -- PHOTOMETRIC LOSSES --\n losses, outputs = self.photometric_losses(inputs, outputs)\n\n # -- COMPUTE GRADIENT AND DO OPTIMIZER STEP --\n self.optimizer.zero_grad()\n losses[\"distance_loss\"].mean().backward()\n self.optimizer.step()\n\n duration = time.time() - before_op_time\n gpu_time += duration\n\n if batch_idx % self.args.log_frequency == 0:\n self.log_time(batch_idx, duration, losses[\"distance_loss\"].mean().cpu().data,\n data_loading_time, gpu_time)\n self.distance_statistics(\"train\", inputs, outputs, losses)\n data_loading_time = 0\n gpu_time = 0\n\n self.step += 1\n before_op_time = time.time()\n\n self.lr_scheduler.step()\n\n if (self.epoch + 1) % self.args.save_frequency == 0:\n self.save_model()\n\n print(\"Training complete!\")","def test_same_distances(self):\n \n\t\tm1 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\n\t\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\n\t\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2)\n\t\t\n\t\tactual_mean_distance = avg_dW\n\t\texpected_mean_distance = 0.0\t \n\t\tself.assertEqual(actual_mean_distance,expected_mean_distance)\n\t\t\n\t\tactual_mean_distance = avg_db\n\t\texpected_mean_distance = 0.0\t \n\t\tself.assertEqual(actual_mean_distance,expected_mean_distance)\n\t\t\n\t\tprint(distances)","def distance(self):\n return self.value * len(self.alignment.query)","def distance_metric(y_true, y_pred):\n diff = y_true - y_pred\n sqr = K.square(diff)\n total = K.sum(sqr, axis=1)\n return K.sqrt(total)","def test_distance_query(self):\n locations = [\n Location.objects.create(name=\"The Piton Foundation\", lat=39.7438167, lng=-104.9884953),\n Location.objects.create(name=\"Hull House\", lat=41.8716782, lng=-87.6474517)\n ]\n story = create_story(title=\"Test Story\", summary=\"Test Summary\",\n byline=\"Test Byline\", status='published')\n story.locations.add(locations[0])\n story.save()\n story2 = create_story(title=\"Test Story 2\", summary=\"Test Summary 2\",\n byline=\"Test Byline 2\", status='published')\n story2.locations.add(locations[1])\n story2.save()\n # If south migrations are enabled, we need to explicitly rebuild\n # the indexes because the RealTimeIndex signal handlers don't get\n # wired up. \n # See https://github.com/toastdriven/django-haystack/issues/599\n # In general, I think we can work around this by just setting\n # SOUTH_TESTS_MIGRATE = False in the settings\n #self._rebuild_index()\n req = RequestFactory().get('/explore/?near=39.7414581054089@-104.9877892025,1')\n resp = self.resource.explore_get_list(req)\n dehydrated = simplejson.loads(resp.content)\n self.assertEqual(len(dehydrated['objects']), 1)\n self.assertEqual(dehydrated['objects'][0]['story_id'], story.story_id)","def calculateDistances(df):\n return","def calcDistance(self):\n # Initialize the distance matrix\n arr = np.repeat(0, self.num_col)\n result_mat = np.repeat(arr, self.num_col)\n result_mat = np.reshape(result_mat, (self.num_col, self.num_col))\n trinary_mat = self.df_trinary.values\n for left_val in TRINARY_VALUES:\n left_func = lambda v: 1 if v==left_val else 0\n left_mat = np.transpose(np.vectorize(left_func)(trinary_mat))\n for right_val in TRINARY_VALUES:\n if left_val == right_val:\n continue\n right_func = lambda v: 1 if v==right_val else 0\n right_mat = np.vectorize(right_func)(trinary_mat)\n # Count the number of occurrences of this combination of values\n # by doing a matrix multiply\n new_mat = np.matmul(left_mat, right_mat)\n # Multiply by the squared distance between the values\n squared_distance = (left_val - right_val)**2\n new_mat = new_mat*squared_distance\n # Accumulate the result\n result_mat = result_mat + new_mat\n # Convert to dataframe\n result_mat = np.vectorize(lambda v: np.sqrt(v)) (result_mat)\n self.df_distance = pd.DataFrame(result_mat, columns=self.columns,\n index=self.columns)","def compute_distances_no_loops(self, X):\n num_test = X.shape[0]\n num_train = self.X_train.shape[0]\n dists = np.zeros((num_test, num_train))\n #########################################################################\n dists = np.sqrt((X ** 2).sum(axis=1, keepdims=1) + (self.X_train ** 2).sum(axis=1) - 2 * X.dot(self.X_train.T))\n\n return dists","def test_euclidean_distance(self):\n knn = Knn(n_neighbors=3)\n knn.fit(np.array(little_X), little_Y)\n d = knn._euclidean_distance(np.array([5, 6]))\n assert (d == [5,5]).all(), \"Euclidean Distance is not correct\"","def test_distance_function(self):\n if connection.ops.oracle:\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\n elif connection.ops.spatialite:\n if connection.ops.spatial_version < (5,):\n # SpatiaLite < 5 returns non-zero distance for polygons and points\n # covered by that polygon.\n ref_dists = [326.61, 4899.68, 8081.30, 9115.15]\n else:\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\n else:\n ref_dists = [0, 4891.20, 8071.64, 9123.95]\n htown = City.objects.get(name=\"Houston\")\n qs = Zipcode.objects.annotate(\n distance=Distance(\"poly\", htown.point),\n distance2=Distance(htown.point, \"poly\"),\n )\n for z, ref in zip(qs, ref_dists):\n self.assertAlmostEqual(z.distance.m, ref, 2)\n\n if connection.ops.postgis:\n # PostGIS casts geography to geometry when distance2 is calculated.\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\n for z, ref in zip(qs, ref_dists):\n self.assertAlmostEqual(z.distance2.m, ref, 2)\n\n if not connection.ops.spatialite:\n # Distance function combined with a lookup.\n hzip = Zipcode.objects.get(code=\"77002\")\n self.assertEqual(qs.get(distance__lte=0), hzip)","def distances(self):","def get_distance(self,row_vector):\n d = row_vector-self.X_test\n \n return np.sqrt(np.dot(d,d)) # return the euclidean distance","def compute_distance(df):\n pass","def euclideanDistanceRow(testInstance, trainingSet):\n distances = {}\n\n for x in range(trainingSet.shape[0]):\n dist = euclideanDistance(testInstance, trainingSet.iloc[x])\n distances[x] = dist\n\n return distances","def _distorted_distance(self):\n distance = 0\n for i, pixel in enumerate(self.training_set):\n distance += self._euclid_distance(\n pixel, self.clusters[self.labels[i]], axis=0)\n return distance","def _distance_last_evaluations(self):\n if self.X.shape[0] < 2:\n # less than 2 evaluations\n return np.inf\n return np.sqrt(np.sum((self.X[-1, :] - self.X[-2, :]) ** 2))","def test_distance(self):\n self.assertTrue(np.allclose(self.vectors.distance('dog.n.01', 'mammal.n.01'), 4.5278745))\n self.assertEqual(self.vectors.distance('dog.n.01', 'dog.n.01'), 0)","def get_distance(self, sess, eps, x_test, y_test, order = float(\"inf\")):\n self.logger.info(\"Getting activation distances between regular and FGSM data\")\n x_test_adv = self.fgsm_np(sess, x_test, y_test, eps)\n\n pred = self.get_prediction(sess, x_test_adv)\n\n self.logger.debug(\"Found correct and incorrect indices\")\n incorrect_indices = [i for i,v in enumerate(pred) if np.argmax(v) != np.argmax(y_test[i])]\n correct_indices = [i for i,v in enumerate(pred) if np.argmax(v) == np.argmax(y_test[i])]\n\n overall, overall_std = self.dist_average(sess, x_test, x_test_adv, order = order)\n correct_dist, correct_std = self.dist_average(sess, x_test[correct_indices], x_test_adv[correct_indices], order)\n incorrect_dist, incorrect_std = self.dist_average(sess, x_test[incorrect_indices], x_test_adv[incorrect_indices], order)\n\n return overall, overall_std, correct_dist, correct_std, incorrect_dist, incorrect_std","def _calc_distance(self, checkpoint_loc):\n return N.sqrt((self.current_location[1] - checkpoint_loc[1])**2 \\\n + (self.current_location[0] - checkpoint_loc[0])**2)","def calc_distance(\n target_batch_keys, target_keys_pred, batch_assignments_gt, src_key_num_gt\n):\n batch_keys_gt = torch.bmm(batch_assignments_gt, target_batch_keys[:, :, :2])\n err = distance(target_keys_pred, batch_keys_gt, src_key_num_gt)\n return err","def _distance_from_weights(self, data):\n input_data = array(data)\n weights_flat = self._weights.reshape(-1, self._weights.shape[2])\n input_data_sq = power(input_data, 2).sum(axis=1, keepdims=True)\n weights_flat_sq = power(weights_flat, 2).sum(axis=1, keepdims=True)\n cross_term = dot(input_data, weights_flat.T)\n return sqrt(-2 * cross_term + input_data_sq + weights_flat_sq.T)","def node_distance(self, inputs):\n tmp = 0\n for i in len(self.inputs):\n tmp += np.power(data[i] - self.weights[i], 2)\n return np.sqrt(tmp)","def usefulness_score(model, test, train, k=20):\n distances = []\n test = test.tocsr()\n train = train.tocsr()\n (x, y, z) = sp.find(train.T)\n counts = np.bincount(x)\n counts += 1\n sums = np.bincount(x, weights=z)\n averages = sums / counts\n\n for user_id, row in enumerate(test):\n\n if not len(row.indices):\n continue\n\n predictions = -model.predict(user_id)\n\n if train is not None:\n rated = train[user_id].indices\n predictions[rated] = FLOAT_MAX\n\n rec_list = predictions.argsort()[:k]\n distances.append(np.mean(averages[rec_list]))\n return np.array(distances)","def _get_distance_diff(self, input):\n nbatch = input.shape[0]\n in1 = input.unsqueeze(1).expand(\n nbatch, self.nelec, self.nelec, self.ndim)\n in2 = input.unsqueeze(2).expand(\n nbatch, self.nelec, self.nelec, self.ndim)\n dist = torch.pow(in1 - in2, 2).sum(3)\n return dist","def experiment(ww_train, rw_train, ww_test, rw_test):\n # First train the data on the training set\n\n ww_centroid = compute_centroid(ww_train)\n rw_centroid = compute_centroid(rw_train)\n correct_count = 0\n count = 0\n for row in ww_test:\n if euclidean_distance(row, ww_centroid) <= euclidean_distance(row, rw_centroid):\n correct_count+=1\n count+=1\n for row in rw_test:\n if euclidean_distance(row, rw_centroid) <= euclidean_distance(row, ww_centroid):\n correct_count+=1\n count+=1\n accuracy = correct_count/count\n result = \"{} total guesses, {} correct guesses, accuracy is {}\".format(count, correct_count, accuracy)\n print(result)\n return accuracy","def get_distance(self, anchor_in, pos_in):\n feed_dict = {self.anchor: anchor_in, self.pos: pos_in}\n distances = - self.sess.run(self.score_anchor_pos, feed_dict=feed_dict)\n return distances","def test_distances(self):\n distances = self.vectors.distances('dog.n.01', ['mammal.n.01', 'dog.n.01'])\n self.assertTrue(np.allclose(distances, [4.5278745, 0]))\n\n distances = self.vectors.distances('dog.n.01')\n self.assertEqual(len(distances), len(self.vectors.vocab))\n self.assertTrue(np.allclose(distances[-1], 10.04756))","def distance(self, source, target):\r\n raise NotImplementedError('Distance calculation not implemented yet')","def test_Euclidian_distances(self):\n \n\t\tm1 = models.vgg11()\n\t\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\n\t\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2, method=EUCLIDEAN)\n\t\t\n\t\tactual_mean_distance = avg_dW\n\t\texpected_mean_distance = 30.2\n\t\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\n\t\t\n\t\t# biased not implemented yet in layers\n\t\tactual_mean_distance = avg_db\n\t\texpected_mean_distance = 0.00\n\t\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)","def test_distance_source(self):\n s1 = Source([[10, 10], [10, 20]], values=[1.0, 2.0])\n s2 = Source([[20, 20], [20, 30]], values=[1.0, 2.0])\n assert(s1.distance(s2) == sqrt(200))","def distance(cls,config_1, config_2):\n\t\tsorted_data_1 = (config_1.data).sort_values('item')\n\t\tsorted_data_2 = (config_2.data).sort_values('item')\n\t\tdr = sorted_data_1 - sorted_data_2\n\t\treturn np.linalg.norm(dr)","def predict(self, query: np.ndarray):\n assert query.shape == self._training_set[1, :-1].shape, \"Size of the query does not match the size of the\" \\\n \" training set, Which is: \"\\\n + str(self._training_set[1, :-1].shape)\n tmp = (self._training_set[:, :-1] - query).astype(float)\n distances = np.linalg.norm(tmp, axis=1)\n\n index = np.argsort(distances)\n sorted_set = self._training_set[index, :]\n\n (unique, counts) = np.unique(sorted_set[:self._k, -1], return_counts=True)\n\n return unique[counts == np.max(counts)][0]","def nearest_district(df_training, df_test, categories, training_embedding, test_embedding):\n # Creates an empty matrix distance.\n labels = [None] * len(test_embedding)\n for index, test in enumerate(test_embedding):\n # Recover the non-zero indexes.\n non_zero_indexes = np.nonzero(test)[0]\n labels[index] = np.argmin(euclidean_distances(test[non_zero_indexes].reshape(1, -1),\n training_embedding[:, non_zero_indexes]))\n return labels","def knn_distance(query, key, k, transpose=True):\n if transpose:\n query = query.transpose(1, 2)\n key = key.transpose(1, 2)\n query = query.contiguous()\n key = key.contiguous()\n # pdb.set_trace()\n index, distance = KNNDistanceFunction.apply(query, key, k)\n return index, distance","def get_query_accuracy(self) -> int:\n return self.query_accuracy","def CalculateDistance(q1, q2):\r\n return np.sqrt((q1[0] - q2[0])**2 + (q1[1] - q2[1])**2)","def test_distances(self):\n for p1, p2, distance in DISTANCES:\n calculated = p1.approximate_distance_meters(p2)\n self.assertAlmostEqual(distance, calculated, delta=5)","def calculate_distance(a,b,data):\r\n d=0 #distance\r\n for i in range(data.numAttributes):\r\n if a[i]!=data.labelMissingData and b[i]!=data.labelMissingData: \r\n if not data.attributeInfo[i][0]: #Discrete Attribute\r\n if a[i] != b[i]:\r\n d+=1\r\n else: #Continuous Attribute\r\n min_bound=float(data.attributeInfo[i][1][0])\r\n max_bound=float(data.attributeInfo[i][1][1])\r\n d+=abs(float(a[i])-float(b[i]))/float(max_bound-min_bound) #Kira & Rendell, 1992 -handling continiuous attributes\r\n return d","def distance_score(x_embeddings_test, x_embeddings_train, y_true_train, K=50):\n num_samples = x_embeddings_test.shape[0]\n num_classes = y_true_train.shape[1]\n y_test_confidence = []\n for i in range(num_samples):\n sample_embedding = x_embeddings_test[i]\n distances = np.square(sample_embedding - x_embeddings_train).sum(axis=-1)\n K_nn = np.argsort(distances)[:K]\n K_nn_distances = np.exp(-np.sqrt(distances[K_nn]))\n K_nn_labels = y_true_train[K_nn, :]\n\n class_indicators = np.eye(num_classes)\n classes_masks = np.matmul(class_indicators, np.transpose(K_nn_labels))\n\n # foreach class we mask away the samples in Knn that belong to other classes\n class_samples_distances = classes_masks * np.expand_dims(K_nn_distances, axis=0) # this gives num_classes X K (100 X 50 matrix)\n sum_distances = np.sum(K_nn_distances)\n D_x = np.sum(class_samples_distances, axis=-1)/sum_distances\n\n y_test_confidence.append(D_x)\n\n return np.vstack(y_test_confidence)","def calculate(self):\n\n distance_filter = sitk.HausdorffDistanceImageFilter()\n distance_filter.Execute(self.ground_truth, self.segmentation)\n return distance_filter.GetHausdorffDistance()","def _distance(self, new_pt):\n\t\tnew_pt = np.resize(new_point, (self.n_row, new_pt.shape[0]))\n\t\tdist = euclidean_distance(self.data[:,0:-1], new_pt)\n\n\t\treturn dist","def calculateDistance(toPredict, toCompare):\n totalDist = 0\n\n #Calculate the matching score for each attribute\n runtimeDist = matchRuntime(toPredict['runtime'], toCompare['runtime'])\n budgetDist = matchBudget(toPredict['budget'], toCompare['budget_adj'])\n directorDist = matchDirector(toPredict['director'], toCompare['director'])\n genreDist = matchGenres(toPredict['genres'], toCompare['genres'])\n actorDist = matchActors(toPredict['cast'], toCompare['cast'])\n companyDist = matchCompanies(toPredict['production_companies'], toCompare['production_companies'])\n\n #Sum up the individual attribute matching scores time their weights\n totalDist += runtimeDist * RUNTIME_WEIGHT\n totalDist += budgetDist * BUDGET_WEIGHT\n totalDist += directorDist * DIRECTOR_WEIGHT\n totalDist += genreDist * GENRE_WEIGHT\n totalDist += actorDist * ACTOR_WEIGHT\n totalDist += companyDist * COMPANIES_WEIGHT\n\n return totalDist","def distance(keys_pred, keys_gt, key_num_gt):\n mask = (keys_gt > 1e-10).float()\n dif = keys_pred * mask - keys_gt\n err = dif.norm(dim=2)\n err = err.sum(dim=1)\n err = torch.div(err, key_num_gt)\n return err","def get_distance(self, anchor_in, pos_in):\n feed_dict = {self.anchor: anchor_in, self.pos: pos_in}\n distances = self.sess.run(self.score_anchor_pos, feed_dict=feed_dict)\n return distances","def augmentDistance(self):\n\n for key,value in self._models.iteritems():\n src=[float(i) for i in value['src'].replace('#',' ').split()]\n tgt=[float(i) for i in value['tgt'].replace('#',' ').split()]\n\n dist = haversine((np.mean(src[0:2]),np.mean(src[2:])),\n (np.mean(tgt[0:2]),np.mean(tgt[2:])),\n miles=True)\n self._models[key]['distance'] = dist\n\n return","def __calculate_estimation(self):\r\n estimation = 0.0\r\n for index_cluster in range(0, len(self.__clusters)):\r\n cluster = self.__clusters[index_cluster]\r\n index_medoid = self.__current[index_cluster]\r\n for index_point in cluster:\r\n estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])\r\n\r\n return estimation","def test_poincare_distances_batch(self):\n vector_1 = self.vectors['dog.n.01']\n vectors_2 = self.vectors[['mammal.n.01', 'dog.n.01']]\n distances = self.vectors.vector_distance_batch(vector_1, vectors_2)\n self.assertTrue(np.allclose(distances, [4.5278745, 0]))","def compute_distance(self, data):\n logger.info('Computing Distances')\n self.num_points = len(data)\n # TODO: Maybe make this into a single mapping function and remove elif\n # ladder\n if self.distance == 'mahalanobis':\n data = np.exp(-1 * data / data.std())\n self.conden_dist_mat = pdist(data, self.distance)\n elif self.distance in ['euclidean', 'cosine']:\n self.conden_dist_mat = pdist(data, self.distance)\n elif self.distance == 'chisqr':\n self.conden_dist_mat = pdist(data, chisqr)\n elif self.distance == 'intersection':\n self.conden_dist_mat = pdist(data, intersection)\n else:\n raise ValueError(\"distance type not supported\")\n self._cleanse_dist_mat()","def _kendall_distance(Y_true, Y_pred, normalize=True, sample_weight=None):\n (n_samples, n_classes) = Y_true.shape\n dists = np.zeros(n_samples)\n\n for sample in range(n_samples):\n for f_class in range(n_classes - 1):\n for s_class in range(f_class + 1, n_classes):\n a = Y_true[sample, f_class] - Y_true[sample, s_class]\n b = Y_pred[sample, f_class] - Y_pred[sample, s_class]\n\n if a * b < 0:\n dists[sample] += 1\n\n if normalize:\n dists[sample] /= n_classes * (n_classes-1) / 2\n\n return np.average(a=dists, weights=sample_weight)","def get_distance(user_id1: str, user_id2: str) -> float:\n features1 = get_feature_vector(user_id1)\n features2 = get_feature_vector(user_id2)\n pass","def distance_to_data(X, x):\n ## homework:start\n result = \n ## homework:end\n return result","def test_dqn(self):\n model = DQNLightning(self.hparams)\n result = self.trainer.fit(model)\n\n self.assertEqual(result, 1)","def test_get_distance() -> None:\n meters = location_util.distance(\n COORDINATES_PARIS[0],\n COORDINATES_PARIS[1],\n COORDINATES_NEW_YORK[0],\n COORDINATES_NEW_YORK[1],\n )\n\n assert meters / 1000 - DISTANCE_KM < 0.01","def __calculate_estimation(self):\n estimation = 0.0\n for index_cluster in range(0, len(self.__clusters)):\n cluster = self.__clusters[index_cluster]\n index_medoid = self.__current[index_cluster]\n for index_point in cluster:\n estimation += euclidean_distance_square(\n self.__pointer_data[index_point],\n self.__pointer_data[index_medoid],\n )\n\n return estimation","def get_distance_metrics(source_embeddings, target_embeddings):\n cosine_avg, euclidean_avg = 0.0, 0.0\n for i in range(len(source_embeddings)):\n cosine_avg += cosine(source_embeddings[i], target_embeddings[i])\n euclidean_avg += euclidean(source_embeddings[i], target_embeddings[i])\n return (cosine_avg / len(source_embeddings)), (euclidean_avg / len(source_embeddings))","def compute_l2_distance_matrix(features_queries, features_dataset):\n sx = np.sum(features_queries ** 2, axis=1, keepdims=True)\n sy = np.sum(features_dataset ** 2, axis=1, keepdims=True)\n\n return np.sqrt(-2 * features_queries.dot(features_dataset.T) + sx + sy.T)","def test_result_n(self):\r\n saber = self.saber\r\n movies = self.movies\r\n res = nearest_n(movies, saber, PRED).drop(\"genres\", axis=1)\r\n intersection = res.merge(self.training, how=\"left\", on=\"movieId\").dropna()\r\n self.assertTrue(not intersection.empty)","def distance_between(self, n1, n2):\n if self.distance_method == 'direct':\n n1_relevants = 0\n n2_relevants = 0\n for i in range(len(self.sample)):\n if is_relevant(self.sample.iloc[i], n1.anchor):\n n1_relevants += 1\n if is_relevant(self.sample.iloc[i], n2.anchor):\n n2_relevants += 1\n return (n1_relevants - n2_relevants)/len(self.sample)\n else:\n return 0.5","def distances(self):\n self._sort_measurements()\n return self._distances","def calculate_dist_from_eqm(distance_from_eqm, variable_mask):","def compute_distance(self):\n loc = np.extend_dims(self.state[:, :, Boids.Attr.LOC], axis=-1)\n m = np.tile(loc, (1, 1, self.num_boids))\n pos_diff = m-m.transpose(0, 2, 1)\n self.distance = np.linalg.norm(pos_diff, axis=0)","def test_get_distance(self):\n meters = location_util.distance(COORDINATES_PARIS[0],\n COORDINATES_PARIS[1],\n COORDINATES_NEW_YORK[0],\n COORDINATES_NEW_YORK[1])\n self.assertAlmostEqual(meters / 1000, DISTANCE_KM, places=2)","def evaluate_distance(self):\n\n fitness = 0\n routes = split_to_routes(self)\n\n for route in routes:\n route = [home] + route + [home]\n for i in range(1,len(route)):\n # Calculates full distance, including from last city\n # to first, to terminate the trip\n pos_from = route[i - 1]\n pos_to = route[i]\n distance = dm[pos_from][pos_to]\n fitness += distance\n\n return int(fitness)","def dataset_query_similarity(query_file, dataset_root, sim_measure):\n\n scorer = SimilarityScorer(query_file)\n score_func = getattr(scorer, sim_measure)\n dataloader = DirectoryTxtDataLoader(dataset_root)\n sentence_iter = dataloader.sentence_iter()\n all_scores = [score_func(sent.split(' ')) for sent in sentence_iter]\n return np.mean(all_scores)","def test_per_dqn(self):\n model = PERDQNLightning(self.hparams)\n result = self.trainer.fit(model)\n\n self.assertEqual(result, 1)","def get_distance(self) -> int:\n return self.get_measurement_data().distance","def _euclidian_classifier(self, X_test: np.array, y_test: np.array):\r\n dist = np.empty([X_test.shape[0], y_test.shape[0]])\r\n for index, target in enumerate(self.targets):\r\n dist[:, index] = np.array([euclidian_distance(sample, self.features[np.where(self.labels == target)])\r\n for sample in X_test])\r\n return dist","def performace_measure(data,pred):\n true = data['clicks']\n weights = weighting(data)\n diff = true-pred.astype(int)\n return np.sqrt(np.inner(weights,diff*diff)/weights.sum())","def test_distances(self):\n\n cent_1 = np.array([0.5, 0.5])\n verts_1 = np.array([[0., 1.], [0., 0.], [1., 0.], [1., 1.]])\n cent_2 = cent_1 - 0.5\n verts_2 = verts_1 - np.array([0.5, 0.5])\n\n # Compare the center-vertex distances between point sets with rigidly shifted coordinates\n self.assertTrue(all(po.cvdist(verts_1, cent_1) == po.cvdist(verts_2, cent_2)))\n # Compare the vertex-vertex distances between point sets with rigidly shifted coordinates\n self.assertTrue(all(po.vvdist(verts_1) == po.vvdist(verts_2)))","def distance(self):\n _, _, costs = self.calculate_costs()\n return np.sum(costs)","def _compute_results(self):\n self.Y_best = best_value(self.Y)\n self.x_opt = self.X[np.argmin(self.Y),:]\n self.fx_opt = np.min(self.Y)\n self.distance = self._compute_distance_betw_consecutive_x()","def getDistance(self):\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])","def nearest_district_for_all_categories(df_training, df_test, categories, district_embedding, test_embedding):\n distance_matrix = euclidean_distances(district_embedding, test_embedding).transpose()\n # print(\"categories:\\n\", categories)\n # print('-' * 50)\n # print(\"district_embedding:\\n\", district_embedding.shape)\n # print('-' * 50)\n # print(\"test_embedding:\\n\", test_embedding.shape)\n # print('-' * 50)\n # print(\"distance_matrix:\\n\", distance_matrix.shape)\n return [np.argmin(distance_matrix[x]) for x in range(len(distance_matrix))]","def test_EstimateDistances(self):\n d = EstimateDistances(self.al, JC69())\n d.run()\n canned_result = {('b', 'e'): 0.440840,\n ('c', 'e'): 0.440840,\n ('a', 'c'): 0.088337,\n ('a', 'b'): 0.188486,\n ('a', 'e'): 0.440840,\n ('b', 'c'): 0.0883373}\n result = d.getPairwiseDistances()\n self.assertDistsAlmostEqual(canned_result, result)\n \n # excercise writing to file\n d.writeToFile('junk.txt')\n try:\n os.remove('junk.txt')\n except OSError:\n pass # probably parallel","def calculate_all_distances(self):\n self.close_distance = self.calculate_distance(self.close_distance_factor)\n self.medium_distance = self.calculate_distance(self.medium_distance_factor)\n self.far_distance = self.calculate_distance(self.far_distance_factor)","def clusterAndDistance(self, data):\n\t\treturn closestClusterAndDistance(data, self.centers)","def calculate(self):\n\n distance_filter = sitk.HausdorffDistanceImageFilter()\n distance_filter.Execute(self.ground_truth, self.segmentation)\n return distance_filter.GetAverageHausdorffDistance()","def rms(trained_data, dist):\n sum = 0\n for i in trained_data:\n point = i[:-2]\n centroid = i[-1]\n distance = (calculate_distance(point,centroid, dist)**2)\n sum +=distance\n return sum","def _computeDistances(self) -> None:\n length = len(self.data)\n for i, sequenceOne in enumerate(self.data):\n print(f\"[SeqCluBaselineOffline] Computing distances is at iteration {i} of {length}.\")\n for j, sequenceTwo in enumerate(self.data):\n if i == j:\n self.distances[i][j] = 0\n continue\n distance = self.distanceMeasure.calculateDistance(sequenceOne, sequenceTwo)\n self.distances[i][j] = distance\n self.distances[j][i] = distance","def _calc_distance_features(self):\n d = ()\n for dx, dy in DIRECTIONS:\n if dx and dy:\n d += (list(self.__calc_distance(direction_x=dx, direction_y=dy)), )\n elif dx:\n tmp, _, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\n d += (tmp, )\n elif dy:\n _, tmp, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\n d += (tmp, )\n\n self.dist_features = d\n\n self.direc_dist = self.__calc_direc_distance()","def getNearestSampleIndex(test, trainX):\n dist_matrix = test - trainX\n dist_square = dist_matrix ** 2\n dist_sums = dist_square.sum(axis=1)\n distance_vector = np.sqrt(dist_sums)\n return (distance_vector).argmin()","def exact_distance_matcher_inefficient(database, query):\n from scipy.spatial.distance import cdist\n distances = cdist(query.reshape(1, -1), database.T)\n list_refined = np.argsort(distances, axis=1).T\n return list_refined","def test_model(data_table, test_length, min_impression, min_clicks,\n keyphrase_ratings, avarage_ctr):\n\n # Variables to calculate accuracy\n square_erros = 0\n square_erros_avarage = 0\n test_samples_num = 0\n\n # Iterate first test_length rows of data_table\n for index, row in data_table.head(test_length).iterrows():\n\n # In case we want to specify how much sample to choose\n # if test_samples_num == test_length: break\n\n # Choose ads whos impression > min_impression\n if row['clicks'] >= min_clicks and\\\n row['impression'] >= min_impression:\n\n # Set found row as new_keyphrase\n new_keyphrase = row\n\n # Calculate similarities dictionary for new_keyphrase\n similarities = calculate_similarities(new_keyphrase,\n keyphrase_ratings)\n\n # Predict CTR by using calculate_ctr\n predicted_ctr = calculate_ctr(similarities)\n\n # Calculate real CTR of new_keyphrase\n real_ctr = float(new_keyphrase['clicks']) /\\\n float(new_keyphrase['impression'])\n\n # Mean square error calculation\n if predicted_ctr is not None:\n\n # Sum up square of errors\n square_erros += (predicted_ctr - real_ctr) ** 2\n square_erros_avarage += (avarage_ctr - real_ctr) ** 2\n\n # Increment number of found test samples\n test_samples_num += 1\n\n # Display some infromations\n print('Predicted CTR: %f - Real CTR: %f for sample: %d'\n % (predicted_ctr, real_ctr, test_samples_num))\n\n else:\n print('No similarity found...')\n\n print(\"\\nMean Square Error: %f\\n\" % (float(square_erros) /\n float(test_samples_num)))\n print(\"w/ Avarage CTR prediction %f\\n\" % (float(square_erros_avarage)/\n float(test_samples_num)))","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def _calc_distances(preds, targets, mask, normalize):\n N, K, _ = preds.shape\n _mask = mask.copy()\n _mask[np.where((normalize == 0).sum(1))[0], :] = False\n distances = np.full((N, K), -1, dtype=np.float32)\n normalize[np.where(normalize <= 0)] = 1000000.0\n distances[_mask] = np.linalg.norm(((preds - targets) / normalize[:, None, :])[_mask], axis=-1)\n return distances.T"],"string":"[\n \"def getDistanceM(self, test, train):\\n p = 2 # TUNE currently euclidian distance\\n distanceM = pd.DataFrame(index=test.index.values, columns=train.index.values)\\n for testrow, testing in test.iterrows():\\n for trainrow, training in train.iterrows():\\n tot = 0\\n for indexc, column in test.iteritems():\\n #print(indexc)\\n if indexc in self.discrete: # need to reference VDM\\n datapoint = self.VDMdict.get(indexc)\\n dif = datapoint[testing[indexc]][training[indexc]]\\n elif indexc != \\\"class\\\": #get distance beween 2 points\\n dif = abs(float(testing[indexc]) - float(training[indexc]))\\n\\n tot += dif ** p\\n distance = tot ** (1 / p) #distance is calculated\\n distanceM.at[testrow, trainrow] = distance #put in distance matrix\\n return(distanceM)\",\n \"def calculate_distances(train_data, test_datum):\\n n = train_data.shape[0]\\n dist = []\\n for i in range(n):\\n distance = np.sqrt(np.sum(np.square(train_data[i]-test_datum)))\\n dist.append(distance)\\n dist = np.asarray(dist)\\n return dist\",\n \"def euclideanDistance(data1, data2):\\n distance = 0\\n for x in range(14):\\n data1[x] = truncate(data1[x], 3)\\n data2[x] = truncate(data2[x], 3)\\n dist = truncate((data1[x] - data2[x]) ** 2, 3)\\n distance = truncate(distance + dist, 3)\\n\\n # Final Euclidean distance between train poing and test point:\\n distance = truncate(np.sqrt(distance), 3)\\n return distance\",\n \"def compute_distances(self, X):\\n num_test = X.shape[0]\\n num_train = self.X_train.shape[0]\\n dists = np.zeros((num_test, num_train))\\n \\n sum_test_square = np.sum(np.square(X), axis=1).reshape(-1, 1)\\n sum_train_square = np.sum(np.square(self.X_train), axis=1).reshape(-1, 1)\\n product_test_train = X @ self.X_train.T\\n \\n sum_test_square = np.repeat(sum_test_square, num_train, axis=1)\\n sum_train_square = np.repeat(sum_train_square, num_test, axis=1).T\\n \\n dists_square = sum_test_square - 2 * product_test_train + sum_train_square\\n \\n dists = np.sqrt(dists_square)\\n \\n return dists\",\n \"def test_distances(self):\\n sf = make_classifier_data(n=10, d=2, seed=37)\\n sf.remove_column(\\\"class\\\", inplace=True)\\n\\n numeric_features = [\\\"int0\\\", \\\"int1\\\", \\\"float0\\\", \\\"float1\\\"]\\n array_features = [\\\"array0\\\"]\\n string_features = [\\\"str0\\\"]\\n dict_features = [\\\"dict0\\\"]\\n\\n ## Numeric standard distances should work for numeric columns\\n for d in [\\n \\\"euclidean\\\",\\n \\\"squared_euclidean\\\",\\n \\\"manhattan\\\",\\n \\\"cosine\\\",\\n \\\"transformed_dot_product\\\",\\n ]:\\n try:\\n m = tc.dbscan.create(\\n sf,\\n features=numeric_features,\\n distance=d,\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n except:\\n assert False, \\\"Standard distance {} failed.\\\".format(d)\\n\\n ## Numeric standard distances should work for array columns\\n for d in [\\n \\\"euclidean\\\",\\n \\\"squared_euclidean\\\",\\n \\\"manhattan\\\",\\n \\\"cosine\\\",\\n \\\"transformed_dot_product\\\",\\n ]:\\n try:\\n m = tc.dbscan.create(\\n sf,\\n features=array_features,\\n distance=d,\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n except:\\n assert False, \\\"Standard distance {} failed.\\\".format(d)\\n\\n ## String standard distances should work.\\n for d in [\\\"levenshtein\\\"]:\\n try:\\n m = tc.dbscan.create(\\n sf,\\n features=string_features,\\n distance=d,\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n except:\\n assert False, \\\"Standard distance {} failed.\\\".format(d)\\n\\n ## Dictionary standard distances should work.\\n for d in [\\\"jaccard\\\", \\\"weighted_jaccard\\\", \\\"cosine\\\", \\\"transformed_dot_product\\\"]:\\n try:\\n m = tc.dbscan.create(\\n sf,\\n features=dict_features,\\n distance=d,\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n except:\\n assert False, \\\"Standard distance {} failed.\\\".format(d)\\n\\n # Nonsensical combinations of feature types and distances should fail.\\n with self.assertRaises(ValueError):\\n m = tc.dbscan.create(\\n sf,\\n features=numeric_features,\\n distance=\\\"levenshtein\\\",\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n with self.assertRaises(ToolkitError):\\n m = tc.dbscan.create(\\n sf,\\n features=dict_features,\\n distance=\\\"levenshtein\\\",\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n with self.assertRaises(ToolkitError):\\n m = tc.dbscan.create(\\n sf,\\n features=string_features,\\n distance=\\\"euclidean\\\",\\n radius=1,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n # If no distance is specified, the automatic distance construction\\n # should kick in and be correct.\\n correct_dist = [\\n [[\\\"str0\\\"], \\\"levenshtein\\\", 1],\\n [[\\\"str1\\\"], \\\"levenshtein\\\", 1],\\n [[\\\"dict0\\\"], \\\"jaccard\\\", 1],\\n [[\\\"int0\\\", \\\"int1\\\", \\\"float0\\\", \\\"float1\\\"], \\\"euclidean\\\", 1],\\n [[\\\"array0\\\"], \\\"euclidean\\\", 1],\\n ]\\n\\n m = tc.dbscan.create(\\n sf, radius=1, distance=None, min_core_neighbors=3, verbose=False\\n )\\n\\n self.assertItemsEqual(m.distance, correct_dist)\\n\\n m = tc.dbscan.create(\\n sf, radius=1, distance=\\\"auto\\\", min_core_neighbors=3, verbose=False\\n )\\n self.assertItemsEqual(m.distance, correct_dist)\",\n \"def _get_dst(self, df_train, df_test):\\n #train NearestNeighbors(Unsupervised learner)\\n neigh = NearestNeighbors(1)\\n neigh.fit(df_train[['longitude', 'latitude']])\\n #find the K-neighbors of points in df_test\\n distances, indices = neigh.kneighbors(df_test[['longitude', 'latitude']])\\n return distances\",\n \"def getDistances(trainingSet, testInstance, distances):\\n # Empty list to store distances of between testInstance and each trainSet item\\n # Number of dimensions to check\\n length=len(testInstance) - 1\\n # Iterate through all items in trainingSet and compute the distance, then append to the distances list\\n for x in range(len(trainingSet)):\\n dist=calculateDistance(testInstance, trainingSet[x], length)\\n distances.append((trainingSet[x], dist))\\n return distances\",\n \"def dist_calc(self,Xtest):\\n d,i = self.knn.kneighbors(Xtest)\\n\\n self.dist = d\\n self.ind = i\\n\\n self.Xtest = Xtest\",\n \"def dist_calc(self,Xtest):\\n d,i = self.knn.kneighbors(Xtest)\\n\\n self.dist = d\\n self.ind = i\\n\\n self.Xtest = Xtest\",\n \"def test_distance(self):\\n for emb_vals, point, dist_gt in self.DISTANCE_EXAMPLES:\\n print(emb_vals, point, dist_gt)\\n emb = to_emb(emb_vals)\\n dist = emb.distance(point)\\n assert np.allclose(dist, dist_gt), \\\\\\n (\\\"Wrong distance for point {}: expected {} but was {};\\\"\\n \\\"\\\\nembedding:\\\\n{}\\\").format(point, dist_gt, dist, str(emb))\",\n \"def compute_distances_one_loop(self, X):\\n num_test = X.shape[0]\\n num_train = self.X_train.shape[0]\\n dists = np.zeros((num_test, num_train))\\n for i in range(num_test):\\n dists[i, :] = np.sqrt(np.sum(np.square(X[i, :] - self.X_train), axis=1)).transpose()\\n return dists\",\n \"def compute_distances_two_loops(self, X):\\n num_test = X.shape[0]\\n num_train = self.X_train.shape[0]\\n dists = np.zeros((num_test, num_train))\\n for i in range(num_test):\\n for j in range(num_train):\\n dists[i, j] = np.sqrt(np.sum(np.square(X[i] - self.X_train[j])))\\n return dists\",\n \"def compute_distances_no_loops(self, X):\\n num_test = X.shape[0]\\n num_train = self.X_train.shape[0]\\n dists = np.zeros((num_test, num_train))\\n tDot = np.multiply(np.dot(X, self.X_train.T), -2)\\n t1 = np.sum(np.square(X), axis=1, keepdims=True)\\n t2 = np.sum(np.square(self.X_train), axis=1)\\n tDot = np.add(t1, tDot)\\n tDot = np.add(tDot, t2)\\n dists = np.sqrt(tDot)\\n #########################################################################\\n # TODO: #\\n # Compute the l2 distance between all test points and all training #\\n # points without using any explicit loops, and store the result in #\\n # dists. #\\n # #\\n # You should implement this function using only basic array operations; #\\n # in particular you should not use functions from scipy. #\\n # #\\n # HINT: Try to formulate the l2 distance using matrix multiplication #\\n # and two broadcast sums. #\\n #########################################################################\\n # pass\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n return dists\",\n \"def test_distances(self):\\n\\t\\tm1 = models.vgg11()\\n\\t\\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\\n\\t\\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2)\\n\\t\\n\\t\\tprint(avg_dW,avg_db)\\n\\t\\tactual_mean_distance = avg_dW\\n\\t\\texpected_mean_distance = 46.485\\n\\t\\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\\n\\t\\t\\n\\t\\tactual_mean_distance = avg_db\\n\\t\\texpected_mean_distance = 0.67622\\n\\t\\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\\n\\t\\t\\n\\t\\tprint(distances)\",\n \"def compute_distances(self, x_q):\\n # get distances of nearest neighbors in Benchmark from Query points\\n distances_B, _ = self.nbrs_benchmark.kneighbors(x_q)\\n radii_B = distances_B[:,-1] # distances of Kth-NN\\n \\n # get distances of nearest neighbors in Trial from Query points\\n distances_T, _ = self.nbrs_trial.kneighbors(x_q)\\n radii_T = distances_T[:,-1] # distances of Kth-NN\\n \\n coords = x_q\\n \\n return(radii_B, radii_T, coords)\",\n \"def distance_train(self):\\n\\n for self.epoch in range(self.args.epochs):\\n # switch to train mode\\n self.set_train()\\n data_loading_time = 0\\n gpu_time = 0\\n before_op_time = time.time()\\n\\n for batch_idx, inputs in enumerate(self.train_loader):\\n data_loading_time += (time.time() - before_op_time)\\n before_op_time = time.time()\\n # -- PUSH INPUTS DICT TO DEVICE --\\n self.inputs_to_device(inputs)\\n\\n # -- DISTANCE ESTIMATION --\\n outputs, features = self.predict_distances(inputs)\\n\\n # -- POSE ESTIMATION --\\n outputs.update(self.predict_poses(inputs, features))\\n\\n # -- PHOTOMETRIC LOSSES --\\n losses, outputs = self.photometric_losses(inputs, outputs)\\n\\n # -- COMPUTE GRADIENT AND DO OPTIMIZER STEP --\\n self.optimizer.zero_grad()\\n losses[\\\"distance_loss\\\"].mean().backward()\\n self.optimizer.step()\\n\\n duration = time.time() - before_op_time\\n gpu_time += duration\\n\\n if batch_idx % self.args.log_frequency == 0:\\n self.log_time(batch_idx, duration, losses[\\\"distance_loss\\\"].mean().cpu().data,\\n data_loading_time, gpu_time)\\n self.distance_statistics(\\\"train\\\", inputs, outputs, losses)\\n data_loading_time = 0\\n gpu_time = 0\\n\\n self.step += 1\\n before_op_time = time.time()\\n\\n self.lr_scheduler.step()\\n\\n if (self.epoch + 1) % self.args.save_frequency == 0:\\n self.save_model()\\n\\n print(\\\"Training complete!\\\")\",\n \"def test_same_distances(self):\\n \\n\\t\\tm1 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\\n\\t\\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\\n\\t\\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2)\\n\\t\\t\\n\\t\\tactual_mean_distance = avg_dW\\n\\t\\texpected_mean_distance = 0.0\\t \\n\\t\\tself.assertEqual(actual_mean_distance,expected_mean_distance)\\n\\t\\t\\n\\t\\tactual_mean_distance = avg_db\\n\\t\\texpected_mean_distance = 0.0\\t \\n\\t\\tself.assertEqual(actual_mean_distance,expected_mean_distance)\\n\\t\\t\\n\\t\\tprint(distances)\",\n \"def distance(self):\\n return self.value * len(self.alignment.query)\",\n \"def distance_metric(y_true, y_pred):\\n diff = y_true - y_pred\\n sqr = K.square(diff)\\n total = K.sum(sqr, axis=1)\\n return K.sqrt(total)\",\n \"def test_distance_query(self):\\n locations = [\\n Location.objects.create(name=\\\"The Piton Foundation\\\", lat=39.7438167, lng=-104.9884953),\\n Location.objects.create(name=\\\"Hull House\\\", lat=41.8716782, lng=-87.6474517)\\n ]\\n story = create_story(title=\\\"Test Story\\\", summary=\\\"Test Summary\\\",\\n byline=\\\"Test Byline\\\", status='published')\\n story.locations.add(locations[0])\\n story.save()\\n story2 = create_story(title=\\\"Test Story 2\\\", summary=\\\"Test Summary 2\\\",\\n byline=\\\"Test Byline 2\\\", status='published')\\n story2.locations.add(locations[1])\\n story2.save()\\n # If south migrations are enabled, we need to explicitly rebuild\\n # the indexes because the RealTimeIndex signal handlers don't get\\n # wired up. \\n # See https://github.com/toastdriven/django-haystack/issues/599\\n # In general, I think we can work around this by just setting\\n # SOUTH_TESTS_MIGRATE = False in the settings\\n #self._rebuild_index()\\n req = RequestFactory().get('/explore/?near=39.7414581054089@-104.9877892025,1')\\n resp = self.resource.explore_get_list(req)\\n dehydrated = simplejson.loads(resp.content)\\n self.assertEqual(len(dehydrated['objects']), 1)\\n self.assertEqual(dehydrated['objects'][0]['story_id'], story.story_id)\",\n \"def calculateDistances(df):\\n return\",\n \"def calcDistance(self):\\n # Initialize the distance matrix\\n arr = np.repeat(0, self.num_col)\\n result_mat = np.repeat(arr, self.num_col)\\n result_mat = np.reshape(result_mat, (self.num_col, self.num_col))\\n trinary_mat = self.df_trinary.values\\n for left_val in TRINARY_VALUES:\\n left_func = lambda v: 1 if v==left_val else 0\\n left_mat = np.transpose(np.vectorize(left_func)(trinary_mat))\\n for right_val in TRINARY_VALUES:\\n if left_val == right_val:\\n continue\\n right_func = lambda v: 1 if v==right_val else 0\\n right_mat = np.vectorize(right_func)(trinary_mat)\\n # Count the number of occurrences of this combination of values\\n # by doing a matrix multiply\\n new_mat = np.matmul(left_mat, right_mat)\\n # Multiply by the squared distance between the values\\n squared_distance = (left_val - right_val)**2\\n new_mat = new_mat*squared_distance\\n # Accumulate the result\\n result_mat = result_mat + new_mat\\n # Convert to dataframe\\n result_mat = np.vectorize(lambda v: np.sqrt(v)) (result_mat)\\n self.df_distance = pd.DataFrame(result_mat, columns=self.columns,\\n index=self.columns)\",\n \"def compute_distances_no_loops(self, X):\\n num_test = X.shape[0]\\n num_train = self.X_train.shape[0]\\n dists = np.zeros((num_test, num_train))\\n #########################################################################\\n dists = np.sqrt((X ** 2).sum(axis=1, keepdims=1) + (self.X_train ** 2).sum(axis=1) - 2 * X.dot(self.X_train.T))\\n\\n return dists\",\n \"def test_euclidean_distance(self):\\n knn = Knn(n_neighbors=3)\\n knn.fit(np.array(little_X), little_Y)\\n d = knn._euclidean_distance(np.array([5, 6]))\\n assert (d == [5,5]).all(), \\\"Euclidean Distance is not correct\\\"\",\n \"def test_distance_function(self):\\n if connection.ops.oracle:\\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\\n elif connection.ops.spatialite:\\n if connection.ops.spatial_version < (5,):\\n # SpatiaLite < 5 returns non-zero distance for polygons and points\\n # covered by that polygon.\\n ref_dists = [326.61, 4899.68, 8081.30, 9115.15]\\n else:\\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\\n else:\\n ref_dists = [0, 4891.20, 8071.64, 9123.95]\\n htown = City.objects.get(name=\\\"Houston\\\")\\n qs = Zipcode.objects.annotate(\\n distance=Distance(\\\"poly\\\", htown.point),\\n distance2=Distance(htown.point, \\\"poly\\\"),\\n )\\n for z, ref in zip(qs, ref_dists):\\n self.assertAlmostEqual(z.distance.m, ref, 2)\\n\\n if connection.ops.postgis:\\n # PostGIS casts geography to geometry when distance2 is calculated.\\n ref_dists = [0, 4899.68, 8081.30, 9115.15]\\n for z, ref in zip(qs, ref_dists):\\n self.assertAlmostEqual(z.distance2.m, ref, 2)\\n\\n if not connection.ops.spatialite:\\n # Distance function combined with a lookup.\\n hzip = Zipcode.objects.get(code=\\\"77002\\\")\\n self.assertEqual(qs.get(distance__lte=0), hzip)\",\n \"def distances(self):\",\n \"def get_distance(self,row_vector):\\n d = row_vector-self.X_test\\n \\n return np.sqrt(np.dot(d,d)) # return the euclidean distance\",\n \"def compute_distance(df):\\n pass\",\n \"def euclideanDistanceRow(testInstance, trainingSet):\\n distances = {}\\n\\n for x in range(trainingSet.shape[0]):\\n dist = euclideanDistance(testInstance, trainingSet.iloc[x])\\n distances[x] = dist\\n\\n return distances\",\n \"def _distorted_distance(self):\\n distance = 0\\n for i, pixel in enumerate(self.training_set):\\n distance += self._euclid_distance(\\n pixel, self.clusters[self.labels[i]], axis=0)\\n return distance\",\n \"def _distance_last_evaluations(self):\\n if self.X.shape[0] < 2:\\n # less than 2 evaluations\\n return np.inf\\n return np.sqrt(np.sum((self.X[-1, :] - self.X[-2, :]) ** 2))\",\n \"def test_distance(self):\\n self.assertTrue(np.allclose(self.vectors.distance('dog.n.01', 'mammal.n.01'), 4.5278745))\\n self.assertEqual(self.vectors.distance('dog.n.01', 'dog.n.01'), 0)\",\n \"def get_distance(self, sess, eps, x_test, y_test, order = float(\\\"inf\\\")):\\n self.logger.info(\\\"Getting activation distances between regular and FGSM data\\\")\\n x_test_adv = self.fgsm_np(sess, x_test, y_test, eps)\\n\\n pred = self.get_prediction(sess, x_test_adv)\\n\\n self.logger.debug(\\\"Found correct and incorrect indices\\\")\\n incorrect_indices = [i for i,v in enumerate(pred) if np.argmax(v) != np.argmax(y_test[i])]\\n correct_indices = [i for i,v in enumerate(pred) if np.argmax(v) == np.argmax(y_test[i])]\\n\\n overall, overall_std = self.dist_average(sess, x_test, x_test_adv, order = order)\\n correct_dist, correct_std = self.dist_average(sess, x_test[correct_indices], x_test_adv[correct_indices], order)\\n incorrect_dist, incorrect_std = self.dist_average(sess, x_test[incorrect_indices], x_test_adv[incorrect_indices], order)\\n\\n return overall, overall_std, correct_dist, correct_std, incorrect_dist, incorrect_std\",\n \"def _calc_distance(self, checkpoint_loc):\\n return N.sqrt((self.current_location[1] - checkpoint_loc[1])**2 \\\\\\n + (self.current_location[0] - checkpoint_loc[0])**2)\",\n \"def calc_distance(\\n target_batch_keys, target_keys_pred, batch_assignments_gt, src_key_num_gt\\n):\\n batch_keys_gt = torch.bmm(batch_assignments_gt, target_batch_keys[:, :, :2])\\n err = distance(target_keys_pred, batch_keys_gt, src_key_num_gt)\\n return err\",\n \"def _distance_from_weights(self, data):\\n input_data = array(data)\\n weights_flat = self._weights.reshape(-1, self._weights.shape[2])\\n input_data_sq = power(input_data, 2).sum(axis=1, keepdims=True)\\n weights_flat_sq = power(weights_flat, 2).sum(axis=1, keepdims=True)\\n cross_term = dot(input_data, weights_flat.T)\\n return sqrt(-2 * cross_term + input_data_sq + weights_flat_sq.T)\",\n \"def node_distance(self, inputs):\\n tmp = 0\\n for i in len(self.inputs):\\n tmp += np.power(data[i] - self.weights[i], 2)\\n return np.sqrt(tmp)\",\n \"def usefulness_score(model, test, train, k=20):\\n distances = []\\n test = test.tocsr()\\n train = train.tocsr()\\n (x, y, z) = sp.find(train.T)\\n counts = np.bincount(x)\\n counts += 1\\n sums = np.bincount(x, weights=z)\\n averages = sums / counts\\n\\n for user_id, row in enumerate(test):\\n\\n if not len(row.indices):\\n continue\\n\\n predictions = -model.predict(user_id)\\n\\n if train is not None:\\n rated = train[user_id].indices\\n predictions[rated] = FLOAT_MAX\\n\\n rec_list = predictions.argsort()[:k]\\n distances.append(np.mean(averages[rec_list]))\\n return np.array(distances)\",\n \"def _get_distance_diff(self, input):\\n nbatch = input.shape[0]\\n in1 = input.unsqueeze(1).expand(\\n nbatch, self.nelec, self.nelec, self.ndim)\\n in2 = input.unsqueeze(2).expand(\\n nbatch, self.nelec, self.nelec, self.ndim)\\n dist = torch.pow(in1 - in2, 2).sum(3)\\n return dist\",\n \"def experiment(ww_train, rw_train, ww_test, rw_test):\\n # First train the data on the training set\\n\\n ww_centroid = compute_centroid(ww_train)\\n rw_centroid = compute_centroid(rw_train)\\n correct_count = 0\\n count = 0\\n for row in ww_test:\\n if euclidean_distance(row, ww_centroid) <= euclidean_distance(row, rw_centroid):\\n correct_count+=1\\n count+=1\\n for row in rw_test:\\n if euclidean_distance(row, rw_centroid) <= euclidean_distance(row, ww_centroid):\\n correct_count+=1\\n count+=1\\n accuracy = correct_count/count\\n result = \\\"{} total guesses, {} correct guesses, accuracy is {}\\\".format(count, correct_count, accuracy)\\n print(result)\\n return accuracy\",\n \"def get_distance(self, anchor_in, pos_in):\\n feed_dict = {self.anchor: anchor_in, self.pos: pos_in}\\n distances = - self.sess.run(self.score_anchor_pos, feed_dict=feed_dict)\\n return distances\",\n \"def test_distances(self):\\n distances = self.vectors.distances('dog.n.01', ['mammal.n.01', 'dog.n.01'])\\n self.assertTrue(np.allclose(distances, [4.5278745, 0]))\\n\\n distances = self.vectors.distances('dog.n.01')\\n self.assertEqual(len(distances), len(self.vectors.vocab))\\n self.assertTrue(np.allclose(distances[-1], 10.04756))\",\n \"def distance(self, source, target):\\r\\n raise NotImplementedError('Distance calculation not implemented yet')\",\n \"def test_Euclidian_distances(self):\\n \\n\\t\\tm1 = models.vgg11()\\n\\t\\tm2 = models.vgg11(weights='VGG11_Weights.IMAGENET1K_V1')\\n\\t\\tavg_dW, avg_db, distances = self.watcher.distances(m1, m2, method=EUCLIDEAN)\\n\\t\\t\\n\\t\\tactual_mean_distance = avg_dW\\n\\t\\texpected_mean_distance = 30.2\\n\\t\\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\\n\\t\\t\\n\\t\\t# biased not implemented yet in layers\\n\\t\\tactual_mean_distance = avg_db\\n\\t\\texpected_mean_distance = 0.00\\n\\t\\tself.assertAlmostEqual(actual_mean_distance,expected_mean_distance, places=1)\",\n \"def test_distance_source(self):\\n s1 = Source([[10, 10], [10, 20]], values=[1.0, 2.0])\\n s2 = Source([[20, 20], [20, 30]], values=[1.0, 2.0])\\n assert(s1.distance(s2) == sqrt(200))\",\n \"def distance(cls,config_1, config_2):\\n\\t\\tsorted_data_1 = (config_1.data).sort_values('item')\\n\\t\\tsorted_data_2 = (config_2.data).sort_values('item')\\n\\t\\tdr = sorted_data_1 - sorted_data_2\\n\\t\\treturn np.linalg.norm(dr)\",\n \"def predict(self, query: np.ndarray):\\n assert query.shape == self._training_set[1, :-1].shape, \\\"Size of the query does not match the size of the\\\" \\\\\\n \\\" training set, Which is: \\\"\\\\\\n + str(self._training_set[1, :-1].shape)\\n tmp = (self._training_set[:, :-1] - query).astype(float)\\n distances = np.linalg.norm(tmp, axis=1)\\n\\n index = np.argsort(distances)\\n sorted_set = self._training_set[index, :]\\n\\n (unique, counts) = np.unique(sorted_set[:self._k, -1], return_counts=True)\\n\\n return unique[counts == np.max(counts)][0]\",\n \"def nearest_district(df_training, df_test, categories, training_embedding, test_embedding):\\n # Creates an empty matrix distance.\\n labels = [None] * len(test_embedding)\\n for index, test in enumerate(test_embedding):\\n # Recover the non-zero indexes.\\n non_zero_indexes = np.nonzero(test)[0]\\n labels[index] = np.argmin(euclidean_distances(test[non_zero_indexes].reshape(1, -1),\\n training_embedding[:, non_zero_indexes]))\\n return labels\",\n \"def knn_distance(query, key, k, transpose=True):\\n if transpose:\\n query = query.transpose(1, 2)\\n key = key.transpose(1, 2)\\n query = query.contiguous()\\n key = key.contiguous()\\n # pdb.set_trace()\\n index, distance = KNNDistanceFunction.apply(query, key, k)\\n return index, distance\",\n \"def get_query_accuracy(self) -> int:\\n return self.query_accuracy\",\n \"def CalculateDistance(q1, q2):\\r\\n return np.sqrt((q1[0] - q2[0])**2 + (q1[1] - q2[1])**2)\",\n \"def test_distances(self):\\n for p1, p2, distance in DISTANCES:\\n calculated = p1.approximate_distance_meters(p2)\\n self.assertAlmostEqual(distance, calculated, delta=5)\",\n \"def calculate_distance(a,b,data):\\r\\n d=0 #distance\\r\\n for i in range(data.numAttributes):\\r\\n if a[i]!=data.labelMissingData and b[i]!=data.labelMissingData: \\r\\n if not data.attributeInfo[i][0]: #Discrete Attribute\\r\\n if a[i] != b[i]:\\r\\n d+=1\\r\\n else: #Continuous Attribute\\r\\n min_bound=float(data.attributeInfo[i][1][0])\\r\\n max_bound=float(data.attributeInfo[i][1][1])\\r\\n d+=abs(float(a[i])-float(b[i]))/float(max_bound-min_bound) #Kira & Rendell, 1992 -handling continiuous attributes\\r\\n return d\",\n \"def distance_score(x_embeddings_test, x_embeddings_train, y_true_train, K=50):\\n num_samples = x_embeddings_test.shape[0]\\n num_classes = y_true_train.shape[1]\\n y_test_confidence = []\\n for i in range(num_samples):\\n sample_embedding = x_embeddings_test[i]\\n distances = np.square(sample_embedding - x_embeddings_train).sum(axis=-1)\\n K_nn = np.argsort(distances)[:K]\\n K_nn_distances = np.exp(-np.sqrt(distances[K_nn]))\\n K_nn_labels = y_true_train[K_nn, :]\\n\\n class_indicators = np.eye(num_classes)\\n classes_masks = np.matmul(class_indicators, np.transpose(K_nn_labels))\\n\\n # foreach class we mask away the samples in Knn that belong to other classes\\n class_samples_distances = classes_masks * np.expand_dims(K_nn_distances, axis=0) # this gives num_classes X K (100 X 50 matrix)\\n sum_distances = np.sum(K_nn_distances)\\n D_x = np.sum(class_samples_distances, axis=-1)/sum_distances\\n\\n y_test_confidence.append(D_x)\\n\\n return np.vstack(y_test_confidence)\",\n \"def calculate(self):\\n\\n distance_filter = sitk.HausdorffDistanceImageFilter()\\n distance_filter.Execute(self.ground_truth, self.segmentation)\\n return distance_filter.GetHausdorffDistance()\",\n \"def _distance(self, new_pt):\\n\\t\\tnew_pt = np.resize(new_point, (self.n_row, new_pt.shape[0]))\\n\\t\\tdist = euclidean_distance(self.data[:,0:-1], new_pt)\\n\\n\\t\\treturn dist\",\n \"def calculateDistance(toPredict, toCompare):\\n totalDist = 0\\n\\n #Calculate the matching score for each attribute\\n runtimeDist = matchRuntime(toPredict['runtime'], toCompare['runtime'])\\n budgetDist = matchBudget(toPredict['budget'], toCompare['budget_adj'])\\n directorDist = matchDirector(toPredict['director'], toCompare['director'])\\n genreDist = matchGenres(toPredict['genres'], toCompare['genres'])\\n actorDist = matchActors(toPredict['cast'], toCompare['cast'])\\n companyDist = matchCompanies(toPredict['production_companies'], toCompare['production_companies'])\\n\\n #Sum up the individual attribute matching scores time their weights\\n totalDist += runtimeDist * RUNTIME_WEIGHT\\n totalDist += budgetDist * BUDGET_WEIGHT\\n totalDist += directorDist * DIRECTOR_WEIGHT\\n totalDist += genreDist * GENRE_WEIGHT\\n totalDist += actorDist * ACTOR_WEIGHT\\n totalDist += companyDist * COMPANIES_WEIGHT\\n\\n return totalDist\",\n \"def distance(keys_pred, keys_gt, key_num_gt):\\n mask = (keys_gt > 1e-10).float()\\n dif = keys_pred * mask - keys_gt\\n err = dif.norm(dim=2)\\n err = err.sum(dim=1)\\n err = torch.div(err, key_num_gt)\\n return err\",\n \"def get_distance(self, anchor_in, pos_in):\\n feed_dict = {self.anchor: anchor_in, self.pos: pos_in}\\n distances = self.sess.run(self.score_anchor_pos, feed_dict=feed_dict)\\n return distances\",\n \"def augmentDistance(self):\\n\\n for key,value in self._models.iteritems():\\n src=[float(i) for i in value['src'].replace('#',' ').split()]\\n tgt=[float(i) for i in value['tgt'].replace('#',' ').split()]\\n\\n dist = haversine((np.mean(src[0:2]),np.mean(src[2:])),\\n (np.mean(tgt[0:2]),np.mean(tgt[2:])),\\n miles=True)\\n self._models[key]['distance'] = dist\\n\\n return\",\n \"def __calculate_estimation(self):\\r\\n estimation = 0.0\\r\\n for index_cluster in range(0, len(self.__clusters)):\\r\\n cluster = self.__clusters[index_cluster]\\r\\n index_medoid = self.__current[index_cluster]\\r\\n for index_point in cluster:\\r\\n estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])\\r\\n\\r\\n return estimation\",\n \"def test_poincare_distances_batch(self):\\n vector_1 = self.vectors['dog.n.01']\\n vectors_2 = self.vectors[['mammal.n.01', 'dog.n.01']]\\n distances = self.vectors.vector_distance_batch(vector_1, vectors_2)\\n self.assertTrue(np.allclose(distances, [4.5278745, 0]))\",\n \"def compute_distance(self, data):\\n logger.info('Computing Distances')\\n self.num_points = len(data)\\n # TODO: Maybe make this into a single mapping function and remove elif\\n # ladder\\n if self.distance == 'mahalanobis':\\n data = np.exp(-1 * data / data.std())\\n self.conden_dist_mat = pdist(data, self.distance)\\n elif self.distance in ['euclidean', 'cosine']:\\n self.conden_dist_mat = pdist(data, self.distance)\\n elif self.distance == 'chisqr':\\n self.conden_dist_mat = pdist(data, chisqr)\\n elif self.distance == 'intersection':\\n self.conden_dist_mat = pdist(data, intersection)\\n else:\\n raise ValueError(\\\"distance type not supported\\\")\\n self._cleanse_dist_mat()\",\n \"def _kendall_distance(Y_true, Y_pred, normalize=True, sample_weight=None):\\n (n_samples, n_classes) = Y_true.shape\\n dists = np.zeros(n_samples)\\n\\n for sample in range(n_samples):\\n for f_class in range(n_classes - 1):\\n for s_class in range(f_class + 1, n_classes):\\n a = Y_true[sample, f_class] - Y_true[sample, s_class]\\n b = Y_pred[sample, f_class] - Y_pred[sample, s_class]\\n\\n if a * b < 0:\\n dists[sample] += 1\\n\\n if normalize:\\n dists[sample] /= n_classes * (n_classes-1) / 2\\n\\n return np.average(a=dists, weights=sample_weight)\",\n \"def get_distance(user_id1: str, user_id2: str) -> float:\\n features1 = get_feature_vector(user_id1)\\n features2 = get_feature_vector(user_id2)\\n pass\",\n \"def distance_to_data(X, x):\\n ## homework:start\\n result = \\n ## homework:end\\n return result\",\n \"def test_dqn(self):\\n model = DQNLightning(self.hparams)\\n result = self.trainer.fit(model)\\n\\n self.assertEqual(result, 1)\",\n \"def test_get_distance() -> None:\\n meters = location_util.distance(\\n COORDINATES_PARIS[0],\\n COORDINATES_PARIS[1],\\n COORDINATES_NEW_YORK[0],\\n COORDINATES_NEW_YORK[1],\\n )\\n\\n assert meters / 1000 - DISTANCE_KM < 0.01\",\n \"def __calculate_estimation(self):\\n estimation = 0.0\\n for index_cluster in range(0, len(self.__clusters)):\\n cluster = self.__clusters[index_cluster]\\n index_medoid = self.__current[index_cluster]\\n for index_point in cluster:\\n estimation += euclidean_distance_square(\\n self.__pointer_data[index_point],\\n self.__pointer_data[index_medoid],\\n )\\n\\n return estimation\",\n \"def get_distance_metrics(source_embeddings, target_embeddings):\\n cosine_avg, euclidean_avg = 0.0, 0.0\\n for i in range(len(source_embeddings)):\\n cosine_avg += cosine(source_embeddings[i], target_embeddings[i])\\n euclidean_avg += euclidean(source_embeddings[i], target_embeddings[i])\\n return (cosine_avg / len(source_embeddings)), (euclidean_avg / len(source_embeddings))\",\n \"def compute_l2_distance_matrix(features_queries, features_dataset):\\n sx = np.sum(features_queries ** 2, axis=1, keepdims=True)\\n sy = np.sum(features_dataset ** 2, axis=1, keepdims=True)\\n\\n return np.sqrt(-2 * features_queries.dot(features_dataset.T) + sx + sy.T)\",\n \"def test_result_n(self):\\r\\n saber = self.saber\\r\\n movies = self.movies\\r\\n res = nearest_n(movies, saber, PRED).drop(\\\"genres\\\", axis=1)\\r\\n intersection = res.merge(self.training, how=\\\"left\\\", on=\\\"movieId\\\").dropna()\\r\\n self.assertTrue(not intersection.empty)\",\n \"def distance_between(self, n1, n2):\\n if self.distance_method == 'direct':\\n n1_relevants = 0\\n n2_relevants = 0\\n for i in range(len(self.sample)):\\n if is_relevant(self.sample.iloc[i], n1.anchor):\\n n1_relevants += 1\\n if is_relevant(self.sample.iloc[i], n2.anchor):\\n n2_relevants += 1\\n return (n1_relevants - n2_relevants)/len(self.sample)\\n else:\\n return 0.5\",\n \"def distances(self):\\n self._sort_measurements()\\n return self._distances\",\n \"def calculate_dist_from_eqm(distance_from_eqm, variable_mask):\",\n \"def compute_distance(self):\\n loc = np.extend_dims(self.state[:, :, Boids.Attr.LOC], axis=-1)\\n m = np.tile(loc, (1, 1, self.num_boids))\\n pos_diff = m-m.transpose(0, 2, 1)\\n self.distance = np.linalg.norm(pos_diff, axis=0)\",\n \"def test_get_distance(self):\\n meters = location_util.distance(COORDINATES_PARIS[0],\\n COORDINATES_PARIS[1],\\n COORDINATES_NEW_YORK[0],\\n COORDINATES_NEW_YORK[1])\\n self.assertAlmostEqual(meters / 1000, DISTANCE_KM, places=2)\",\n \"def evaluate_distance(self):\\n\\n fitness = 0\\n routes = split_to_routes(self)\\n\\n for route in routes:\\n route = [home] + route + [home]\\n for i in range(1,len(route)):\\n # Calculates full distance, including from last city\\n # to first, to terminate the trip\\n pos_from = route[i - 1]\\n pos_to = route[i]\\n distance = dm[pos_from][pos_to]\\n fitness += distance\\n\\n return int(fitness)\",\n \"def dataset_query_similarity(query_file, dataset_root, sim_measure):\\n\\n scorer = SimilarityScorer(query_file)\\n score_func = getattr(scorer, sim_measure)\\n dataloader = DirectoryTxtDataLoader(dataset_root)\\n sentence_iter = dataloader.sentence_iter()\\n all_scores = [score_func(sent.split(' ')) for sent in sentence_iter]\\n return np.mean(all_scores)\",\n \"def test_per_dqn(self):\\n model = PERDQNLightning(self.hparams)\\n result = self.trainer.fit(model)\\n\\n self.assertEqual(result, 1)\",\n \"def get_distance(self) -> int:\\n return self.get_measurement_data().distance\",\n \"def _euclidian_classifier(self, X_test: np.array, y_test: np.array):\\r\\n dist = np.empty([X_test.shape[0], y_test.shape[0]])\\r\\n for index, target in enumerate(self.targets):\\r\\n dist[:, index] = np.array([euclidian_distance(sample, self.features[np.where(self.labels == target)])\\r\\n for sample in X_test])\\r\\n return dist\",\n \"def performace_measure(data,pred):\\n true = data['clicks']\\n weights = weighting(data)\\n diff = true-pred.astype(int)\\n return np.sqrt(np.inner(weights,diff*diff)/weights.sum())\",\n \"def test_distances(self):\\n\\n cent_1 = np.array([0.5, 0.5])\\n verts_1 = np.array([[0., 1.], [0., 0.], [1., 0.], [1., 1.]])\\n cent_2 = cent_1 - 0.5\\n verts_2 = verts_1 - np.array([0.5, 0.5])\\n\\n # Compare the center-vertex distances between point sets with rigidly shifted coordinates\\n self.assertTrue(all(po.cvdist(verts_1, cent_1) == po.cvdist(verts_2, cent_2)))\\n # Compare the vertex-vertex distances between point sets with rigidly shifted coordinates\\n self.assertTrue(all(po.vvdist(verts_1) == po.vvdist(verts_2)))\",\n \"def distance(self):\\n _, _, costs = self.calculate_costs()\\n return np.sum(costs)\",\n \"def _compute_results(self):\\n self.Y_best = best_value(self.Y)\\n self.x_opt = self.X[np.argmin(self.Y),:]\\n self.fx_opt = np.min(self.Y)\\n self.distance = self._compute_distance_betw_consecutive_x()\",\n \"def getDistance(self):\\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])\",\n \"def nearest_district_for_all_categories(df_training, df_test, categories, district_embedding, test_embedding):\\n distance_matrix = euclidean_distances(district_embedding, test_embedding).transpose()\\n # print(\\\"categories:\\\\n\\\", categories)\\n # print('-' * 50)\\n # print(\\\"district_embedding:\\\\n\\\", district_embedding.shape)\\n # print('-' * 50)\\n # print(\\\"test_embedding:\\\\n\\\", test_embedding.shape)\\n # print('-' * 50)\\n # print(\\\"distance_matrix:\\\\n\\\", distance_matrix.shape)\\n return [np.argmin(distance_matrix[x]) for x in range(len(distance_matrix))]\",\n \"def test_EstimateDistances(self):\\n d = EstimateDistances(self.al, JC69())\\n d.run()\\n canned_result = {('b', 'e'): 0.440840,\\n ('c', 'e'): 0.440840,\\n ('a', 'c'): 0.088337,\\n ('a', 'b'): 0.188486,\\n ('a', 'e'): 0.440840,\\n ('b', 'c'): 0.0883373}\\n result = d.getPairwiseDistances()\\n self.assertDistsAlmostEqual(canned_result, result)\\n \\n # excercise writing to file\\n d.writeToFile('junk.txt')\\n try:\\n os.remove('junk.txt')\\n except OSError:\\n pass # probably parallel\",\n \"def calculate_all_distances(self):\\n self.close_distance = self.calculate_distance(self.close_distance_factor)\\n self.medium_distance = self.calculate_distance(self.medium_distance_factor)\\n self.far_distance = self.calculate_distance(self.far_distance_factor)\",\n \"def clusterAndDistance(self, data):\\n\\t\\treturn closestClusterAndDistance(data, self.centers)\",\n \"def calculate(self):\\n\\n distance_filter = sitk.HausdorffDistanceImageFilter()\\n distance_filter.Execute(self.ground_truth, self.segmentation)\\n return distance_filter.GetAverageHausdorffDistance()\",\n \"def rms(trained_data, dist):\\n sum = 0\\n for i in trained_data:\\n point = i[:-2]\\n centroid = i[-1]\\n distance = (calculate_distance(point,centroid, dist)**2)\\n sum +=distance\\n return sum\",\n \"def _computeDistances(self) -> None:\\n length = len(self.data)\\n for i, sequenceOne in enumerate(self.data):\\n print(f\\\"[SeqCluBaselineOffline] Computing distances is at iteration {i} of {length}.\\\")\\n for j, sequenceTwo in enumerate(self.data):\\n if i == j:\\n self.distances[i][j] = 0\\n continue\\n distance = self.distanceMeasure.calculateDistance(sequenceOne, sequenceTwo)\\n self.distances[i][j] = distance\\n self.distances[j][i] = distance\",\n \"def _calc_distance_features(self):\\n d = ()\\n for dx, dy in DIRECTIONS:\\n if dx and dy:\\n d += (list(self.__calc_distance(direction_x=dx, direction_y=dy)), )\\n elif dx:\\n tmp, _, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\\n d += (tmp, )\\n elif dy:\\n _, tmp, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\\n d += (tmp, )\\n\\n self.dist_features = d\\n\\n self.direc_dist = self.__calc_direc_distance()\",\n \"def getNearestSampleIndex(test, trainX):\\n dist_matrix = test - trainX\\n dist_square = dist_matrix ** 2\\n dist_sums = dist_square.sum(axis=1)\\n distance_vector = np.sqrt(dist_sums)\\n return (distance_vector).argmin()\",\n \"def exact_distance_matcher_inefficient(database, query):\\n from scipy.spatial.distance import cdist\\n distances = cdist(query.reshape(1, -1), database.T)\\n list_refined = np.argsort(distances, axis=1).T\\n return list_refined\",\n \"def test_model(data_table, test_length, min_impression, min_clicks,\\n keyphrase_ratings, avarage_ctr):\\n\\n # Variables to calculate accuracy\\n square_erros = 0\\n square_erros_avarage = 0\\n test_samples_num = 0\\n\\n # Iterate first test_length rows of data_table\\n for index, row in data_table.head(test_length).iterrows():\\n\\n # In case we want to specify how much sample to choose\\n # if test_samples_num == test_length: break\\n\\n # Choose ads whos impression > min_impression\\n if row['clicks'] >= min_clicks and\\\\\\n row['impression'] >= min_impression:\\n\\n # Set found row as new_keyphrase\\n new_keyphrase = row\\n\\n # Calculate similarities dictionary for new_keyphrase\\n similarities = calculate_similarities(new_keyphrase,\\n keyphrase_ratings)\\n\\n # Predict CTR by using calculate_ctr\\n predicted_ctr = calculate_ctr(similarities)\\n\\n # Calculate real CTR of new_keyphrase\\n real_ctr = float(new_keyphrase['clicks']) /\\\\\\n float(new_keyphrase['impression'])\\n\\n # Mean square error calculation\\n if predicted_ctr is not None:\\n\\n # Sum up square of errors\\n square_erros += (predicted_ctr - real_ctr) ** 2\\n square_erros_avarage += (avarage_ctr - real_ctr) ** 2\\n\\n # Increment number of found test samples\\n test_samples_num += 1\\n\\n # Display some infromations\\n print('Predicted CTR: %f - Real CTR: %f for sample: %d'\\n % (predicted_ctr, real_ctr, test_samples_num))\\n\\n else:\\n print('No similarity found...')\\n\\n print(\\\"\\\\nMean Square Error: %f\\\\n\\\" % (float(square_erros) /\\n float(test_samples_num)))\\n print(\\\"w/ Avarage CTR prediction %f\\\\n\\\" % (float(square_erros_avarage)/\\n float(test_samples_num)))\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def _calc_distances(preds, targets, mask, normalize):\\n N, K, _ = preds.shape\\n _mask = mask.copy()\\n _mask[np.where((normalize == 0).sum(1))[0], :] = False\\n distances = np.full((N, K), -1, dtype=np.float32)\\n normalize[np.where(normalize <= 0)] = 1000000.0\\n distances[_mask] = np.linalg.norm(((preds - targets) / normalize[:, None, :])[_mask], axis=-1)\\n return distances.T\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7019203","0.6988815","0.68354094","0.66117215","0.64914435","0.6445621","0.6380863","0.6360921","0.6360921","0.6267546","0.619195","0.6135691","0.60662866","0.6063706","0.60594213","0.60494125","0.5988632","0.5947215","0.59445816","0.594229","0.5941032","0.59226173","0.5912849","0.58939195","0.588871","0.58775014","0.5876006","0.5850758","0.58379954","0.58329344","0.5810167","0.57944685","0.5789451","0.57848555","0.5775371","0.57597715","0.5729686","0.57251626","0.57225573","0.571923","0.57096225","0.5694787","0.5691795","0.5685525","0.56788766","0.5657531","0.56562024","0.5646906","0.56462175","0.5617765","0.5603787","0.5599507","0.5590289","0.5580286","0.55671656","0.5566801","0.55644107","0.55592656","0.55543554","0.55478","0.55418855","0.55330604","0.55318356","0.55306196","0.5524155","0.55212957","0.5520813","0.55184937","0.54904705","0.5482685","0.547824","0.5476933","0.5475804","0.5470114","0.5452305","0.5444715","0.54388213","0.5435113","0.5430874","0.54298437","0.5428516","0.5428227","0.54277295","0.5422386","0.5418513","0.5413706","0.54136175","0.54121","0.54073673","0.5399987","0.53926295","0.5391328","0.53900343","0.53810585","0.5374937","0.53723437","0.5367524","0.5367227","0.536678","0.5363549"],"string":"[\n \"0.7019203\",\n \"0.6988815\",\n \"0.68354094\",\n \"0.66117215\",\n \"0.64914435\",\n \"0.6445621\",\n \"0.6380863\",\n \"0.6360921\",\n \"0.6360921\",\n \"0.6267546\",\n \"0.619195\",\n \"0.6135691\",\n \"0.60662866\",\n \"0.6063706\",\n \"0.60594213\",\n \"0.60494125\",\n \"0.5988632\",\n \"0.5947215\",\n \"0.59445816\",\n \"0.594229\",\n \"0.5941032\",\n \"0.59226173\",\n \"0.5912849\",\n \"0.58939195\",\n \"0.588871\",\n \"0.58775014\",\n \"0.5876006\",\n \"0.5850758\",\n \"0.58379954\",\n \"0.58329344\",\n \"0.5810167\",\n \"0.57944685\",\n \"0.5789451\",\n \"0.57848555\",\n \"0.5775371\",\n \"0.57597715\",\n \"0.5729686\",\n \"0.57251626\",\n \"0.57225573\",\n \"0.571923\",\n \"0.57096225\",\n \"0.5694787\",\n \"0.5691795\",\n \"0.5685525\",\n \"0.56788766\",\n \"0.5657531\",\n \"0.56562024\",\n \"0.5646906\",\n \"0.56462175\",\n \"0.5617765\",\n \"0.5603787\",\n \"0.5599507\",\n \"0.5590289\",\n \"0.5580286\",\n \"0.55671656\",\n \"0.5566801\",\n \"0.55644107\",\n \"0.55592656\",\n \"0.55543554\",\n \"0.55478\",\n \"0.55418855\",\n \"0.55330604\",\n \"0.55318356\",\n \"0.55306196\",\n \"0.5524155\",\n \"0.55212957\",\n \"0.5520813\",\n \"0.55184937\",\n \"0.54904705\",\n \"0.5482685\",\n \"0.547824\",\n \"0.5476933\",\n \"0.5475804\",\n \"0.5470114\",\n \"0.5452305\",\n \"0.5444715\",\n \"0.54388213\",\n \"0.5435113\",\n \"0.5430874\",\n \"0.54298437\",\n \"0.5428516\",\n \"0.5428227\",\n \"0.54277295\",\n \"0.5422386\",\n \"0.5418513\",\n \"0.5413706\",\n \"0.54136175\",\n \"0.54121\",\n \"0.54073673\",\n \"0.5399987\",\n \"0.53926295\",\n \"0.5391328\",\n \"0.53900343\",\n \"0.53810585\",\n \"0.5374937\",\n \"0.53723437\",\n \"0.5367524\",\n \"0.5367227\",\n \"0.536678\",\n \"0.5363549\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56466407"},"document_rank":{"kind":"string","value":"48"}}},{"rowIdx":93095,"cells":{"query":{"kind":"string","value":"This method receives the neighbours of the test data and takes a tally of the votes and makes a decision. The decision is based on the label with the highest count."},"document":{"kind":"string","value":"def count_votes(self, neighbours=()):\n labels = []\n data = neighbours\n # create the list made up of labels.\n for x in range(len(data)):\n labels.append(data[x][-1])\n\n # count the appearance of labels.\n count = [[x, labels.count(x)] for x in set(labels)]\n # Sort the labels in descending order by using their frequency\n vote = sorted(count, key=itemgetter(-1), reverse=True)\n # return the prediction\n # print(\"[{}]\".format(vote[0][0]))\n return vote[0][0]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _vote(self, neighbor_labels):\n counts= torch.bincount(neighbor_labels.int())\n return torch.argmax(counts)","def _tally_votes(self, labels, distances):\n votes = collections.defaultdict(int)\n for i, index in enumerate(distances.order(ascending=True).index):\n if i < self.k:\n votes[labels[index]] += 1\n else:\n break\n return votes","def majority_vote(labels):\n\n conta = Counter(labels)\n\n winner, winner_count = conta.most_common(1)[0]\n\n num_winner = sum([1 for count in conta.values() if count == winner_count])\n\n if num_winner == 1:\n return winner\n else:\n return majority_vote(labels[:-1])","def ensembleVote(x, classes, ensemble):\n votes = np.array([0 for kk in range(len(classes))])\n for i in ensemble:\n votes = votes + classProbs(x, ensemble[i][\"tree\"], classes)\n maxVote = 0\n loc = None\n for ind, vote in enumerate(votes):\n if vote > maxVote:\n maxVote = vote\n loc = ind\n prediction = classes[loc]\n return prediction","def majority_voting(distances, labels, k):\n nearest_index = np.argsort(distances)\n k_neighbor_labels = []\n for i in range(k):\n index = nearest_index[i]\n label = labels[index]\n k_neighbor_labels.append(label)\n major_class = np.argmax(np.bincount(k_neighbor_labels))\n return major_class","def majority_vote(labels):\n vote_counts = Counter(labels)\n winner, winner_count = vote_counts.most_common(1)[0]\n num_winners = len([count for count in vote_counts.values()\n if count == winner_count])\n if num_winners == 1:\n return winner\n else:\n #try again without the farthest\n return majority_vote(labels[:-1])","def predict_with_tree(self, X, ball_tree):\n predicted_y = np.zeros(X.shape[0])\n for i in range(X.shape[0]):\n neighbours = []\n ball_tree.knn_search(X[i], self.k_nearest, neighbours)\n votes = {}\n for neighbour in neighbours:\n if neighbour.classification in votes:\n votes[neighbour.classification] += 1\n else:\n votes[neighbour.classification] = 1\n predicted_y[i] = max(votes, key=votes.get)\n return predicted_y","def predict(self, row):\n label_vote = dict()\n for i in range(len(self.forest)):\n result = self.forest[i].predict(row)\n label = max(result, key=result.get)\n \n if label_vote.get(label, None) is None:\n label_vote[label] = 0\n\n label_vote[label] += 1\n \n return max(label_vote, key=result.get)","def knn(p, k, x, t):\r\n\r\n # Number of instances in data set\r\n N = x.shape[0]\r\n\r\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\r\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\r\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\r\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\r\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\r\n\r\n\r\n #top_class = 0\r\n\r\n return top_class","def __call__(self, clfs, dataset):\n if len(clfs)==0:\n return [] # to don't even bother\n\n all_label_counts = None\n for clf in clfs:\n # Lets check first if necessary conditional attribute is enabled\n if not clf.ca.is_enabled(\"predictions\"):\n raise ValueError, \"MaximalVote needs classifiers (such as \" + \\\n \"%s) with state 'predictions' enabled\" % clf\n predictions = clf.ca.predictions\n if all_label_counts is None:\n all_label_counts = [ {} for i in xrange(len(predictions)) ]\n\n # for every sample\n for i in xrange(len(predictions)):\n prediction = predictions[i]\n # XXX fishy location due to literal labels,\n # TODO simplify assumptions and logic\n if isinstance(prediction, basestring) or \\\n not is_sequence_type(prediction):\n prediction = (prediction,)\n for label in prediction: # for every label\n # XXX we might have multiple labels assigned\n # but might not -- don't remember now\n if not label in all_label_counts[i]:\n all_label_counts[i][label] = 0\n all_label_counts[i][label] += 1\n\n predictions = []\n # select maximal vote now for each sample\n for i in xrange(len(all_label_counts)):\n label_counts = all_label_counts[i]\n # lets do explicit search for max so we know\n # if it is unique\n maxk = [] # labels of elements with max vote\n maxv = -1\n for k, v in label_counts.iteritems():\n if v > maxv:\n maxk = [k]\n maxv = v\n elif v == maxv:\n maxk.append(k)\n\n assert len(maxk) >= 1, \\\n \"We should have obtained at least a single key of max label\"\n\n if len(maxk) > 1:\n warning(\"We got multiple labels %s which have the \" % maxk +\n \"same maximal vote %d. XXX disambiguate. \" % maxv +\n \"Meanwhile selecting the first in sorted order\")\n predictions.append(sorted(maxk)[0])\n\n ca = self.ca\n ca.estimates = all_label_counts\n ca.predictions = predictions\n return predictions","def evaluateVoteCount(toCompare):\n\n #weight = 0\n\n if int(toCompare['vote_count']) >= 5000:\n weight = 100\n elif 3000 <= int(toCompare['vote_count']) < 5000:\n weight = 80\n elif 2000 <= int(toCompare['vote_count']) < 3000:\n weight = 60\n elif 1000 <= int(toCompare['vote_count']) < 2000:\n weight = 40\n elif 500 <= int(toCompare['vote_count']) < 1000:\n weight = 20\n else:\n weight = 0\n return weight","def decision(self, neighbors=None):\n if not neighbors:\n return sorted(self.class_prb.items(), key=lambda n: n[1],\n reverse=True)\n\n else:\n n = len(neighbors)\n prb = {}\n for label in self.labels:\n prb[label] = 0.0\n for kdnode, dist in neighbors:\n index = self.train_data.index(kdnode.data)\n prb[self.train_label[index]] += 1\n for label in self.labels:\n prb[label] = prb[label] / n\n return sorted(prb.items(), key=lambda n: n[1], reverse=True)","def classify(self, data):\n\n \"*** YOUR CODE HERE ***\"\n # should compute (validationData[i] - trainingData[j])^2\n result = np.zeros(data.shape[0])\n for i in range(data.shape[0]):\n distances = np.linalg.norm(self.trainingData - data[i], axis=1)\n nearest = np.argsort(distances)[:self.num_neighbors]\n nearest_tags = [self.trainingLabels[j] for j in nearest]\n result[i] = max(nearest_tags, key=lambda x: nearest_tags.count(x))\n return result","def val_vote_one_epoch(sess, ops, dataset, epoch, split, num_votes=10):\n\n is_training = False\n\n original_labels, original_points, \\\n projection_inds, average_predictions = prepare_testing_structure(dataset, split)\n feed_dict = {ops['is_training_pl']: is_training}\n\n for v in range(num_votes):\n if v == 0:\n sess.run(ops[f'{split}_init_op'])\n else:\n sess.run(ops[f'{split}_vote_init_op'])\n all_predictions = []\n all_obj_inds = []\n all_objects = []\n while True:\n try:\n tower_logits_all_shapes, tower_labels, \\\n tower_object_labels, tower_o_inds, tower_batches = sess.run([ops['tower_logits_all_shapes'],\n ops['tower_labels'],\n ops['tower_super_labels'],\n ops['tower_object_inds'],\n ops['tower_in_batches']],\n feed_dict=feed_dict)\n\n for logits_all_shapes, labels, object_labels, o_inds, batches in zip(tower_logits_all_shapes,\n tower_labels,\n tower_object_labels,\n tower_o_inds,\n tower_batches):\n max_ind = np.max(batches)\n for b_i, b in enumerate(batches):\n # Eliminate shadow indices\n b = b[b < max_ind - 0.5]\n # Get prediction (only for the concerned parts)\n obj = object_labels[b[0]]\n pred = logits_all_shapes[obj][b]\n # Stack all results\n all_objects += [obj]\n all_obj_inds += [o_inds[b_i]]\n all_predictions += [pred]\n except tf.errors.OutOfRangeError:\n break\n\n true_num_test = len(all_predictions)\n num_test = dataset.num_test if split == 'test' else dataset.num_val\n vote_objects = [-1] * num_test\n # Project predictions on original point clouds\n for i, probs in enumerate(all_predictions):\n # Interpolate prediction from current positions to original points\n obj_i = all_obj_inds[i]\n proj_predictions = probs[projection_inds[obj_i]]\n vote_objects[obj_i] = all_objects[i]\n # Average prediction across votes\n average_predictions[obj_i] = average_predictions[obj_i] + \\\n (proj_predictions - average_predictions[obj_i]) / (v + 1)\n\n if true_num_test != num_test:\n logger.warning(\"{} using {}/{} data, \"\n \"this may be caused by multi-gpu testing\".format(split, true_num_test, num_test))\n vote_preds = average_predictions[:true_num_test]\n vote_targets = original_labels[:true_num_test]\n else:\n vote_preds = average_predictions\n vote_targets = original_labels\n\n msIoU, mpIoU, mmsIoU, mmpIoU = partnet_metrics(dataset.num_classes, dataset.num_parts,\n vote_objects, vote_preds, vote_targets)\n logger.info(f'E{epoch} V{v} {split} * mmsIoU {mmsIoU:.3%} mmpIoU {mmpIoU:.3%}')\n logger.info(f'E{epoch} V{v} {split} * msIoU {msIoU}')\n logger.info(f'E{epoch} V{v} {split} * mpIoU {mpIoU}')\n return","def val_vote_one_epoch(sess, ops, dataset, epoch, split, num_votes=10):\n\n is_training = False\n\n original_labels, original_points, \\\n projection_inds, average_predictions = prepare_testing_structure(dataset, split)\n feed_dict = {ops['is_training_pl']: is_training}\n\n for v in range(num_votes):\n if v == 0:\n sess.run(ops[f'{split}_init_op'])\n else:\n sess.run(ops[f'{split}_vote_init_op'])\n all_predictions = []\n all_obj_inds = []\n all_objects = []\n while True:\n try:\n tower_logits_all_shapes, tower_labels, \\\n tower_object_labels, tower_o_inds, tower_batches = sess.run([ops['tower_logits_all_shapes'],\n ops['tower_labels'],\n ops['tower_super_labels'],\n ops['tower_object_inds'],\n ops['tower_in_batches']],\n feed_dict=feed_dict)\n\n for logits_all_shapes, labels, object_labels, o_inds, batches in zip(tower_logits_all_shapes,\n tower_labels,\n tower_object_labels,\n tower_o_inds,\n tower_batches):\n max_ind = np.max(batches)\n for b_i, b in enumerate(batches):\n # Eliminate shadow indices\n b = b[b < max_ind - 0.5]\n # Get prediction (only for the concerned parts)\n obj = object_labels[b[0]]\n pred = logits_all_shapes[obj][b]\n # Stack all results\n all_objects += [obj]\n all_obj_inds += [o_inds[b_i]]\n all_predictions += [pred]\n except tf.errors.OutOfRangeError:\n break\n\n true_num_test = len(all_predictions)\n num_test = dataset.num_test if split == 'test' else dataset.num_val\n vote_objects = [-1] * num_test\n # Project predictions on original point clouds\n for i, probs in enumerate(all_predictions):\n # Interpolate prediction from current positions to original points\n obj_i = all_obj_inds[i]\n proj_predictions = probs[projection_inds[obj_i]]\n vote_objects[obj_i] = all_objects[i]\n # Average prediction across votes\n average_predictions[obj_i] = average_predictions[obj_i] + \\\n (proj_predictions - average_predictions[obj_i]) / (v + 1)\n\n if true_num_test != num_test:\n logger.warning(\"{} using {}/{} data, \"\n \"this may be caused by multi-gpu testing\".format(split, true_num_test, num_test))\n vote_preds = average_predictions[:true_num_test]\n vote_targets = original_labels[:true_num_test]\n else:\n vote_preds = average_predictions\n vote_targets = original_labels\n\n msIoU, mpIoU, mmsIoU, mmpIoU = partnet_metrics(dataset.num_classes, dataset.num_parts,\n vote_objects, vote_preds, vote_targets)\n logger.info(f'E{epoch} V{v} {split} * mmsIoU {mmsIoU:.3%} mmpIoU {mmpIoU:.3%}')\n logger.info(f'E{epoch} V{v} {split} * msIoU {msIoU}')\n logger.info(f'E{epoch} V{v} {split} * mpIoU {mpIoU}')\n return","def score_voting(self, det_bboxes, det_labels, mlvl_bboxes,\n mlvl_nms_scores, score_thr):\n candidate_mask = mlvl_nms_scores > score_thr\n # print(\"candidate_mask\")\n # print(candidate_mask)\n candidate_mask_nozeros = candidate_mask.nonzero()\n # print(\"candidate_mask_nozeros\")\n # print(candidate_mask_nozeros)\n candidate_inds = candidate_mask_nozeros[:, 0]\n candidate_labels = candidate_mask_nozeros[:, 1]\n candidate_bboxes = mlvl_bboxes[candidate_inds]\n candidate_scores = mlvl_nms_scores[candidate_mask]\n det_bboxes_voted = []\n det_labels_voted = []\n # print(\"self.cls_out_channels\")\n # print(self.cls_out_channels)\n for cls in range(self.cls_out_channels):\n candidate_cls_mask = candidate_labels == cls\n if not candidate_cls_mask.any():\n continue\n candidate_cls_scores = candidate_scores[candidate_cls_mask]\n candidate_cls_bboxes = candidate_bboxes[candidate_cls_mask]\n det_cls_mask = det_labels == cls\n det_cls_bboxes = det_bboxes[det_cls_mask].view(\n -1, det_bboxes.size(-1))\n det_candidate_ious = bbox_overlaps(det_cls_bboxes[:, :4],\n candidate_cls_bboxes)\n for det_ind in range(len(det_cls_bboxes)):\n single_det_ious = det_candidate_ious[det_ind]\n pos_ious_mask = single_det_ious > 0.01\n pos_ious = single_det_ious[pos_ious_mask]\n pos_bboxes = candidate_cls_bboxes[pos_ious_mask]\n pos_scores = candidate_cls_scores[pos_ious_mask]\n pis = (torch.exp(-(1 - pos_ious)**2 / 0.025) *\n pos_scores)[:, None]\n voted_box = torch.sum(\n pis * pos_bboxes, dim=0) / torch.sum(\n pis, dim=0)\n voted_score = det_cls_bboxes[det_ind][-1:][None, :]\n det_bboxes_voted.append(\n torch.cat((voted_box[None, :], voted_score), dim=1))\n det_labels_voted.append(cls)\n\n det_bboxes_voted = torch.cat(det_bboxes_voted, dim=0)\n det_labels_voted = det_labels.new_tensor(det_labels_voted)\n return det_bboxes_voted, det_labels_voted","def decision_bound(self, test_data):\n pred = self.w * test_data[:,0] - self.intercept\n self.ret_label = np.zeros((test_data.shape[0], 1))\n self.ret_label[test_data[:,1] > pred] = 1\n self.ret_label[test_data[:,1] <= pred] = 0\n return (self.ret_label)","def give_balanced_classes(reviews, votes, votes_threshold):\n if votes_threshold <= 0:\n print \"Needs positive threshold\"\n return\n\n negative_reviews_indices = []\n\n # Find all the funny reviews we can\n final_reviews = []\n final_labels = []\n for i, review in enumerate(reviews):\n if votes[i] >= votes_threshold:\n final_reviews.append(review)\n final_labels.append(1)\n elif votes[i] == 0:\n negative_reviews_indices.append(i)\n\n # We want balanced classes so take same number\n np.random.shuffle(negative_reviews_indices)\n num_positive_reviews = len(final_reviews)\n for i in range(num_positive_reviews):\n final_reviews.append(reviews[negative_reviews_indices[i]])\n final_labels.append(0)\n\n # Shuffle final reviews and labels\n combined_lists = zip(final_reviews, final_labels)\n np.random.shuffle(combined_lists)\n final_reviews[:], final_labels[:] = zip(*combined_lists)\n\n print \"Returning %d positive reviews and a total of %d reviews\" % (num_positive_reviews, len(final_reviews))\n\n return (final_reviews, final_labels)","def label_top_n(self,n,classifier,labels_to_forget=\"none\"):\n\t\t\tprint \" Pred confs:\",\n\t\t\tlabels = np.ones(self.csr_train_feats.shape[0],int)*-100\n\t\t\tconfidences = np.ones(self.csr_train_feats.shape[0],int)*-100\n\t\t\tlabels[self.bool_train_unlabelled],confidences[self.bool_train_unlabelled]\\\n\t\t\t\t=classifier.predict_labels_and_confidences(self.csr_train_feats[self.bool_train_unlabelled])\n\t\t\t# print \"dtykj labels\", labels\n\t\t\t# print \"asfd confidences\", confidences\n\t\t\tprint \" Sort & label:\",\n\t\t\tconfidences[self.bool_train_labelled]=-1 #So we don't try to re-label these!\n\t\t\tdef label_top_k(k,labels,confidences):\n\t\t\t\tbool_indices_to_label=confidences.argsort()[-k:]\n\t\t\t\tself.train_labels___0_unlab__neg1_exclud[\\\n\t\t\t\t\tbool_indices_to_label]=labels[bool_indices_to_label]\n\t\t\t\tassert not any(self.bool_train_labelled[bool_indices_to_label])\n\t\t\t\tassert all(self.bool_train_unlabelled[bool_indices_to_label])\n\t\t\t\tself.bool_train_labelled[bool_indices_to_label]=True\n\t\t\t\tself.bool_train_unlabelled[bool_indices_to_label]=False\n\t\t\t\tself.num_train_labelled+=k\n\t\t\t\tself.num_train_unlabelled-=k\n\t\t\tif isinstance(n,int):\n\t\t\t\tlabel_top_k(n,labels,confidences)\n\t\t\telif isinstance(n,dict):\n\t\t\t\tassert n.keys()==self.set_labels\n\t\t\t\tfor label, k in n.iteritems():\n\t\t\t\t\tconf_of_label=confidences*(labels==label)\n\t\t\t\t\tassert set(labels[conf_of_label!=0])=={label}\n\t\t\t\t\tlabel_top_k(k,labels,conf_of_label)\n\t\t\telse:\n\t\t\t\traise TypeError(\"Unexpected Type passed to label_top_n. First method argument should be an int or a dictionary\")","def knn_classify(k, labeled_points, new_point):\n by_distance = sorted(labeled_points,\n key=lambda point, _: la.distance(point, new_point))\n\n #find the labels for the k clsest\n k_nearest_labels = [label for _, label in by_distance[:k]]\n #and ket them vote\n return majority_vote(k_nearest_labels)","def voting(y_pred_test, gnd_te):\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\n df.sort_values(by=['y'], inplace=True, ascending=False)\n out = df.groupby(['gnd']).mean()\n return len(out[out['y'] > 0])/float(len(out))","def getMajorityVote(self, knn_ids):\n # local bindings\n _data = self.__data\n labels = _data.labels\n\n # number of occerences for each unique class in kNNs\n votes = self.__votes_init.copy()\n for nn in knn_ids:\n votes[labels[nn]] += 1\n\n # find the class with most votes\n # return votes as well to store them in the state\n return max(votes.iteritems(), key=lambda x:x[1])[0], \\\n [votes[ul] for ul in _data.uniquelabels] # transform into lists","def pick_best_label(self,db,labels,ids):\n self.type = 'v'\n if len(labels) > 0:\n self.value = vote([labels[id] for id in ids])\n else:\n self.value = None\n return","def knn(train_data, train_labels, test_data, test_labels, k):\n pred_labels = []\n for t in test_data:\n dist = calculate_distances(train_data, t)\n pred_class = majority_voting(dist, train_labels, k)\n pred_labels.append(pred_class)\n correct_pred_count = np.sum(pred_labels == test_labels)\n acc = correct_pred_count/len(test_labels)\n return acc","def tally_vote(self, data):\r\n if self.user_voted:\r\n return {'error': 'Sorry, but you have already voted!'}\r\n ans = data['answer']\r\n if not self.validate_answer(ans):\r\n # Uh oh. Invalid answer.\r\n log.exception('Failure in hinter tally_vote: Unable to parse answer: {ans}'.format(ans=ans))\r\n return {'error': 'Failure in voting!'}\r\n hint_pk = str(data['hint'])\r\n # We use temp_dict because we need to do a direct write for the database to update.\r\n temp_dict = self.hints\r\n try:\r\n temp_dict[ans][hint_pk][1] += 1\r\n except KeyError:\r\n log.exception('''Failure in hinter tally_vote: User voted for non-existant hint:\r\n Answer={ans} pk={hint_pk}'''.format(ans=ans, hint_pk=hint_pk))\r\n return {'error': 'Failure in voting!'}\r\n self.hints = temp_dict\r\n # Don't let the user vote again!\r\n self.user_voted = True\r\n\r\n # Return a list of how many votes each hint got.\r\n pk_list = json.loads(data['pk_list'])\r\n hint_and_votes = []\r\n for answer, vote_pk in pk_list:\r\n if not self.validate_answer(answer):\r\n log.exception('In hinter tally_vote, couldn\\'t parse {ans}'.format(ans=answer))\r\n continue\r\n try:\r\n hint_and_votes.append(temp_dict[answer][str(vote_pk)])\r\n except KeyError:\r\n log.exception('In hinter tally_vote, couldn\\'t find: {ans}, {vote_pk}'.format(\r\n ans=answer, vote_pk=str(vote_pk)))\r\n\r\n hint_and_votes.sort(key=lambda pair: pair[1], reverse=True)\r\n # Reset self.previous_answers and user_submissions.\r\n self.previous_answers = []\r\n self.user_submissions = []\r\n return {'hint_and_votes': hint_and_votes}","def predict_bagging_example(x, h_ens):\r\n arr = []\r\n for y in h_ens:\r\n \t# calls predict example repeatedly and stores them in an array\r\n tst_pred = predict_example(x, h_ens[y][1])\r\n arr.append(tst_pred)\r\n # returning the maximum voted\r\n predict_egz = max(set(arr), key=arr.count)\r\n return predict_egz","def t(p, vote_count):\n return vote_count[p]","def labelingLVQ(self):\n numLabels = len(np.unique(self.y))\n for i, x in enumerate(self.x):\n w = self.find_closest(x)[0]\n for nl in range(numLabels):\n if self.y[i] == nl:\n self.labels[nl, w[0], w[1]] += 1\n return self.labels","def getWeightedVote(self, knn_ids):\n # local bindings\n _data = self.__data\n uniquelabels = _data.uniquelabels\n\n # Lazy evaluation\n if self.__weights is None:\n #\n # It seemed to Yarik that this has to be evaluated just once per\n # training dataset.\n #\n self.__labels = labels = self.__data.labels\n Nlabels = len(labels)\n Nuniquelabels = len(uniquelabels)\n\n # TODO: To get proper speed up for the next line only,\n # histogram should be computed\n # via sorting + counting \"same\" elements while reducing.\n # Guaranteed complexity is NlogN whenever now it is N^2\n # compute the relative proportion of samples belonging to each\n # class (do it in one loop to improve speed and reduce readability\n self.__weights = \\\n [ 1.0 - ((labels == label).sum() / Nlabels) \\\n for label in uniquelabels ]\n self.__weights = dict(zip(uniquelabels, self.__weights))\n\n labels = self.__labels\n # number of occerences for each unique class in kNNs\n votes = self.__votes_init.copy()\n for nn in knn_ids:\n votes[labels[nn]] += 1\n\n # weight votes\n votes = [ self.__weights[ul] * votes[ul] for ul in uniquelabels]\n\n # find the class with most votes\n # return votes as well to store them in the state\n return uniquelabels[N.asarray(votes).argmax()], \\\n votes","def get_n_best(self):\n pass","def classify(self, nn=1):\n\t\t#err=0\n\t\tpossibilities=[]\n\t\tfor i in range(len(self.X_test)):\n\t\t\tfor lines in range(len((self.X_train))):\n\t\t\t\tdist=np.linalg.norm(self.X_test[i]-self.X_train[lines])\n\t\t\t\tpossibilities.append([dist,self.Y_train[lines]])\n\t\t\tpossibilities.sort()\n\t\t\tfinal=[]\n\t\t\tfor c in range(0,15):\n\t\t\t\tfinal.append(possibilities[c][1])\n\t\t\t\tprint possibilities[c][1]\n\t\t\tcount=np.zeros(10)\n\t\t\tfor m in final:\n\t\t\t\tcount[m]+=1\n\t\t\t\n\t\t\tans=np.any(count==count.max())\n\t\t\t\n\t\t\tprint \"actual=\",self.Y_test[i]\n\t\t\tif(ans!=self.Y_test[i]):\n\t\t\t\tglobal err\n\t\t\t\terr=err+1","def knn_classification(x_test, df_training, attrib_column, k):\n return majority_vote(k_nearest_neighbors(x_test, df_training,k),df,attrib_column)","def knn_predict(p, points, outcomes, k):\n\tind = find_nearest_neighbors(p, points, k)\n\treturn majority_vote(outcomes[ind])","def predict(self, x_vals):\n if self.vote == 'probability':\n maj_vote = np.argmax(self.predict_proba(x_vals), axis=1)\n else:\n # 'classlabel' vote\n # Collect results from clf.predict calls\n predictions = np.asarray([clf.predict(x_vals) for clf in self.classifiers_]).T\n maj_vote = np.apply_along_axis(lambda x:\n np.argmax(np.bincount(x, weights=self.weights)),\n axis=1, arr=predictions)\n maj_vote = self.lablenc_.inverse_transform(maj_vote)\n return maj_vote","def vis_detections(im, class_name, dets, image_name, thresh=0.5):\n inds = np.where(dets[:, -1] >= thresh)[0]\n max_inds = 0\n max_score = 0.0\n if len(inds) == 0:\n # print('Warning: no target detected!')\n return\n elif len(inds) > 1:\n # print('Warning: ' + str(len(inds)) + ' targets detected! Choose the highest one')\n for i in inds:\n if(dets[i, -1] > max_score):\n max_inds = i\n max_score = dets[i, -1]\n\n# im = im[:, :, (2, 1, 0)]\n# fig, ax = plt.subplots(figsize=(12, 12))\n# ax.imshow(im, aspect='equal')\n # for i in inds:\n # bbox = dets[i, :4]\n # score = dets[i, -1]\n #print max_inds\n bbox = dets[max_inds, :4]\n score = dets[max_inds, -1]\n\n# ax.add_patch(\n# plt.Rectangle((bbox[0], bbox[1]),\n# bbox[2] - bbox[0],\n# bbox[3] - bbox[1], fill=False,\n# edgecolor='red', linewidth=3.5)\n# )\n# ax.text(bbox[0], bbox[1] - 2,\n# '{:s} {:.3f}'.format(class_name, score),\n# bbox=dict(facecolor='blue', alpha=0.5),\n# fontsize=14, color='white')\n\n # end for\n #print image_name, class_name\n #print score\n # file.writelines([image_name,'\\t',class_name,'\\t',str(score),'\\n'])\n # ax.set_title(('{} detections with '\n # 'p({} | box) >= {:.1f}').format(class_name, class_name,\n # thresh),fontsize=14)\n # plt.axis('off')\n # plt.tight_layout()\n # plt.draw()\n\t### SAVE IMAGES ? ###\n save_img_dir = os.path.join(cfg.ROOT_DIR, 'result', 'test_img')\n # if not os.path.exists(save_img_dir):\n # os.makedirs(save_img_dir)\n # plt.savefig(os.path.join(save_img_dir, image_name + '_' + class_name))\n\n boxes = {'boxes': ((bbox[0], bbox[1]), bbox[2] - bbox[0], bbox[3] - bbox[1])}\n \n save_mat_dir = os.path.join(cfg.ROOT_DIR, 'result', 'test_box')","def evaluate(labels, predictions):\n #labels and predictions\n truePos = 0\n trueNeg = 0\n for data in range(len(labels)):\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\n truePos+=1\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\n trueNeg+=1\n sensitivity = truePos/(len(labels) + 1)\n specificity = trueNeg/(len(labels) + 1)\n return (sensitivity, specificity)\n \n\n #raise NotImplementedError","def heuristic2B_label_OBD(n, P, label, critical=None):\n nodes_labeled = []\n\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\n new_label = label + 1\n \n neighbors = P.neighbors(n)\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys(): # if it has a label\n if P.node[neigh]['OBDlabel'] > new_label: # and it is higher than what I would use for labeling\n new_label = P.node[neigh]['OBDlabel']\n # we got maximum of current label or any node that neighbors have - now we label them all with that\n \n neighbors_to_label = []\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\n neighbors_to_label.append(neigh)\n else: # if set and smaller than mine, leave them alone\n pass\n else: # if not set, then not lower and not labelled\n neighbors_to_label.append(neigh)\n # now we have all the neighbors that need to be labeled\n \n if len(neighbors_to_label) > 1:\n flag_critical = True\n # and now labeling all these nodes\n \n for neigh in neighbors_to_label:\n if ('critical' in P.node[neigh].keys()) and (P.node[neigh]['critical']==True) and (P.node[neigh]['OBDlabel'] != new_label) :\n return (False, nodes_labeled) # being critical, we could avoid failure only if the label to set would be the same (it happens)\n else:\n P.node[neigh]['OBDlabel'] = new_label\n nodes_labeled.append(neigh) # this is a list that gets passed through recursions\n if flag_critical == True:\n P.node[neigh]['critical'] = True\n # labeling part done\n \n # and now recursive step - going into each neighbor to continue, in any order if necessary\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\n for perm in permutations:\n this_run_success = True\n this_run_labeled = []\n for el in perm:\n (s, nl) = heuristic2B_label_OBD(el, P, new_label, flag_critical)\n this_run_labeled = this_run_labeled + nl\n if s == False:\n this_run_success = False\n if this_run_success == False:\n # then unlabel all that were labelled up to now\n for nn in this_run_labeled:\n P.node[nn]['OBDlabel'] = None\n P.node[nn]['critical'] = False\n else: # obviously success is True, we managed to label all others...\n nodes_labeled = nodes_labeled + this_run_labeled\n return (True, nodes_labeled)\n break\n # if no permutation is successful, we end up returning the last line\n return (False, nodes_labeled)","def find_response(self, neighbors):\n counts = defaultdict(int)\n for neighbor in neighbors:\n counts[neighbor] += 1 # last item in list is the predicted value\n response = max(counts.items())[0]\n return response","def predict(self, test_data):\n count = 0.0\n for testcase in test_data:\n answer = np.argmax(testcase[1])\n prediction = np.argmax(self.feed_forward(testcase[0]))\n count = count + 1 if (answer - prediction) == 0 else count\n return count","def predict_labels(self, distances, k=1):\n\n num_test = distances.shape[0]\n Y_pred = np.zeros((num_test,))\n\n \n for i in range(num_test):\n # extracting k-nearest-neighbors for each test-point\n kNN_idxs = np.argsort(distances[i,:])[0:k]\n \n # voting among the k-nearest-neighbors\n kNN_labels = {}\n # print(type(kNN_labels))\n\n for j in range(k):\n m_label = self.Y_train[kNN_idxs[j]]\n if m_label in kNN_labels.keys():\n # print(type(kNN_labels))\n kNN_labels[m_label] += 1 # increment count\n else:\n # print(m_label,'....', type(kNN_labels))\n kNN_labels[m_label] = 1 # initial count when the label occurs\n \n # counting the winning label\n\n winning_label = kNN_labels.keys()[0] # initialization\n \n for label in kNN_labels.keys():\n if kNN_labels[label] > kNN_labels[winning_label]:\n winning_label = label\n elif kNN_labels[label] == kNN_labels[winning_label]:\n # tie breaker\n if label < winning_label:\n winning_label = label\n \n\n Y_pred[i] = winning_label # storing winning label for each test-point\n \n return Y_pred","def classify(self, features):\n\n # TODO: finish this.\n class_labels = []\n # TODO: finish this.\n features = np.array(features)\n feat_shape = features.shape\n for i in range(feat_shape[0]):\n vote = np.zeros((self.num_trees))\n for j in range(self.num_trees):\n #print self.trees[j].classify(feat)\n vote[j] = self.trees[j].classify(features[i,self.attr_track[j]].reshape(1,-1))[0]\n counts = np.bincount(vote.astype(int))\n class_labels.append(np.argmax(counts))\n return class_labels","def naive_bayes_classify(df: pd.DataFrame, vect, names):\n features = vect\n target = df.success_lvl\n\n X_train, X_test, y_train, y_test = \\\n train_test_split(features, target, test_size=0.2, random_state=42)\n\n nb_clf = MultinomialNB()\n nb_clf.fit(X_train, y_train)\n nb_predictions = nb_clf.predict(X_test)\n print('Accuracy score for Naive Bayes:', accuracy_score(y_test, nb_predictions))\n\n\n # Find Top/Bottom num of terms used to describe the classes.\n num = 10\n low_class_prob_sorted = nb_clf.feature_log_prob_[0, :].argsort()[::-1]\n hi_class_prob_sorted = nb_clf.feature_log_prob_[1, :].argsort()[::-1]\n print('\\n', f'Low score Top{num} phrases:', np.take(names, low_class_prob_sorted[:num]))\n print('\\n', f'Low score Bot{num} phrases:', np.take(names, low_class_prob_sorted[-num:]))\n print('\\n', f'High score Top{num} phrases:', np.take(names, hi_class_prob_sorted[:num]))\n print('\\n', f'High score Bot{num} phrases:', np.take(names, hi_class_prob_sorted[-num:]))","def predict(self, X):\n predictions = [c.predict(X) for c in self.classifiers]\n votes = np.zeros((len(X),self.label_count), dtype='i8')\n for row in xrange(len(X)):\n for model in xrange(self.model_count):\n for label in xrange(len(self.label_sets[model])):\n votes[row,self.label_sets[model][label]] += predictions[model][row][label]\n\n voters = np.zeros(self.label_count, dtype='i8')\n for label_set in self.label_sets:\n voters[label_set] += 1\n\n for row in xrange(len(X)):\n for label in xrange(self.label_count):\n votes[row, label] = int(float(votes[row, label]) / float(voters[label]) > 0.5)\n\n return votes","def pred_dset_bin_vote(fx_output, dset, fold_set):\n labels = []\n for i,y in dset.split_idx[fold_set]:\n x,yi = dset.get(i)\n assert yi==y\n p = fx_output(dset.reshape_batch(x))\n y_pred = np.bincount(p.argmax(axis=1)).argmax()\n labels += [(y, y_pred)]\n \n return np.asarray(labels)","def getPredictions(self):\n\t\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)","def classify(self, data):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum\n guesses.append(vectors.argMax())\n return guesses","def majority_vote():\n iris = datasets.load_iris()\n x_vals, y_vals = iris.data[50:, [1, 2]], iris.target[50:]\n labenc = LabelEncoder()\n y_vals = labenc.fit_transform(y_vals)\n x_train, x_test, y_train, y_test = train_test_split(x_vals, y_vals,\n test_size=0.5, random_state=1)\n\n clf1 = LogisticRegression(penalty='l2', C=0.001, random_state=0)\n clf2 = DecisionTreeClassifier(max_depth=1, criterion='entropy', random_state=0)\n clf3 = KNeighborsClassifier(n_neighbors=1, p=2, metric='minkowski')\n pipe1 = Pipeline([['sc', StandardScaler()], ['clf', clf1]])\n pipe3 = Pipeline([['sc', StandardScaler()], ['clf', clf3]])\n clf_labels = ['Logistic Regression', 'Decision Tree', 'KNN']\n\n # Majority Rule (hard) Voting\n mv_clf = MajorityVoteClassifier(classifiers=[pipe1, clf2, pipe3])\n\n clf_labels += ['Majority Voting']\n all_clf = [pipe1, clf2, pipe3, mv_clf]\n print('10-fold cross validation:\\n')\n for clf, label in zip(all_clf, clf_labels):\n scores = cross_val_score(estimator=clf, X=x_train, y=y_train, cv=10, scoring='roc_auc')\n print(\"ROC AUC: %0.2f (+/- %0.2f) [%s]\" % (scores.mean(), scores.std(), label))\n\n colors = ['black', 'orange', 'blue', 'green']\n linestyles = [':', '--', '-.', '-']\n for clf, label, clr, lin_style in zip(all_clf, clf_labels, colors, linestyles):\n # assuming the label of the positive class is 1\n y_pred = clf.fit(x_train, y_train).predict_proba(x_test)[:, 1]\n fpr, tpr, _ = roc_curve(y_true=y_test, y_score=y_pred)\n print(y_pred)\n roc_auc = auc(x=fpr, y=tpr)\n plt.plot(fpr, tpr, color=clr, linestyle=lin_style,\n label='%s (auc = %0.2f)' % (label, roc_auc))\n\n plt.legend(loc='lower right')\n plt.plot([0, 1], [0, 1], linestyle='--', color='gray', linewidth=2)\n\n plt.xlim([-0.1, 1.1])\n plt.ylim([-0.1, 1.1])\n plt.grid()\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.tight_layout()\n plt.savefig(IMG_PATH + 'roc.png', dpi=300)\n plt.close()\n\n stdc = StandardScaler()\n x_train_std = stdc.fit_transform(x_train)\n all_clf = [pipe1, clf2, pipe3, mv_clf]\n x_min = x_train_std[:, 0].min() - 1\n x_max = x_train_std[:, 0].max() + 1\n y_min = x_train_std[:, 1].min() - 1\n y_max = x_train_std[:, 1].max() + 1\n xxx, yyy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))\n _, axarr = plt.subplots(nrows=2, ncols=2, sharex='col', sharey='row', figsize=(7, 5))\n for idx, clf, ttt in zip(product([0, 1], [0, 1]), all_clf, clf_labels):\n clf.fit(x_train_std, y_train)\n z_vals = clf.predict(np.c_[xxx.ravel(), yyy.ravel()])\n z_vals = z_vals.reshape(xxx.shape)\n axarr[idx[0], idx[1]].contourf(xxx, yyy, z_vals, alpha=0.3)\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 0, 0], x_train_std[y_train == 0, 1],\n c='blue', marker='^', s=50)\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 1, 0], x_train_std[y_train == 1, 1],\n c='red', marker='o', s=50)\n axarr[idx[0], idx[1]].set_title(ttt)\n plt.text(-3.5, -4.5, s='Sepal width [standardized]', ha='center', va='center', fontsize=12)\n plt.text(-10.5, 4.5, s='Petal length [standardized]', ha='center', va='center',\n fontsize=12, rotation=90)\n plt.tight_layout()\n plt.savefig(IMG_PATH + 'voting_panel.png', bbox_inches='tight', dpi=300)\n # print(mv_clf.get_params())\n params = {'decisiontreeclassifier__max_depth': [1, 2],\n 'pipeline-1__clf__C': [0.001, 0.1, 100.0]}\n grid = GridSearchCV(estimator=mv_clf, param_grid=params, cv=10, scoring='roc_auc')\n grid.fit(x_train, y_train)\n\n for params, mean_score, scores in grid.cv_results_:\n print(\"%0.3f+/-%0.2f %r\" % (mean_score, scores.std() / 2, params))\n print('Best parameters: %s' % grid.best_params_)\n print('Accuracy: %.2f' % grid.best_score_)","def majority_vote(c_pred,m_pred,f_pred,dataset):\n c,m,f = np.argmax(c_pred),np.argmax(m_pred),np.argmax(f_pred)\n coarse = np.zeros(2)\n middle = np.zeros(4)\n fine = np.zeros(10)\n if dataset == 'cifar10':\n middle = np.zeros(5)\n coarse[c] = 1\n middle[m] = 1\n fine[f] = 1\n res = np.zeros(10)\n if dataset == 'cifar10':\n for i in range(10):\n if i <2:\n res[i] = coarse[0] + middle[0] + fine[i]\n elif 2<=i <4:\n res[i] = coarse[0] + middle[1] + fine[i]\n elif 4 <=i<6:\n res[i] = coarse[1] + middle[2] + fine[i]\n elif 6<=i<8:\n res[i] = coarse[1] + middle[3] + fine[i]\n else:\n res[i] = coarse[1] + middle[4] + fine[i]\n else :\n for i in range(10):\n if i <3:\n res[i] = coarse[0] + middle[0] + fine[i]\n elif 3<=i <5:\n res[i] = coarse[0] + middle[1] + fine[i]\n elif 5 <=i<8:\n res[i] = coarse[1] + middle[2] + fine[i]\n else:\n res[i] = coarse[1] + middle[3] + fine[i]\n index = np.argmax(res)\n return(index)","def rank_candidates(table):\n ranking = []\n\n # get list of all candidates who received a vote\n full_list = elim_dupe([name for vote in table for name in vote])\n # print full_list\n \n while len(ranking) < len(full_list):\n \n # All unranked candidates are considered eligible\n eligible = [name for name in full_list if name not in ranking]\n \n while True:\n \n # Remove ineligible and eliminated candidates from votes\n temp_ballots = [[name for name in vote if name in eligible] for vote in table]\n \n # If no candidates on the ballot are eligible and the ballot does not have\n # \"no confidence\" written on it, the ballot is discarded and not considered a vote.\n temp_ballots = [vote for vote in temp_ballots if len(vote) > 0]\n\n total_votes = len(temp_ballots)\n\n if total_votes == 0:\n return ranking\n\n top_choices = [vote[0] for vote in temp_ballots]\n \n # All ballots are considered to be a vote for the\n # highest-ranked eligible candidate on the ballot.\n vote_count = {name: top_choices.count(name) for name in eligible}\n print vote_count\n winner = [k for k in vote_count if (vote_count[k]*2) > total_votes]\n\n if len(winner) > 0:\n # If a single candidate has a majority of the\n # votes, they receive the next highest ranking\n if winner[0] == NO_CONFIDENCE:\n return ranking\n \n ranking += winner\n \n break;\n\n vote_count.pop(NO_CONFIDENCE, None)\n\n # If no single candidate has a majority of the votes,\n # then one will be deemed ineligible.\n\n min_votes = vote_count[min(vote_count, key=vote_count.get)]\n \n least_voted = {k:vote_count[k] for k in vote_count if vote_count[k] == min_votes}\n \n # If a single candidate has the least amount of votes, they become ineligible,\n while len(least_voted) > 1:\n temp_ballots = [vote[1:] for vote in temp_ballots if len(vote[1:]) > 0]\n if len(temp_ballots) == 0:\n return ranking\n next_choices = [vote[0] for vote in temp_ballots if vote[0] in least_voted]\n least_voted = {name: (next_choices.count(name) + least_voted[name]) for name in least_voted}\n min_votes = least_voted[min(least_voted, key=least_voted.get)]\n least_voted = {k: least_voted[k] for k in least_voted if least_voted[k] == min_votes}\n \n remove = least_voted.keys()[0]\n eligible = [name for name in eligible if name != remove]\n\n\n return ranking","def test_score(self, n_neighbors, weights):\n _check_knn_score(\n KNeighborsLabelRanker(n_neighbors, weights), self.X, self.Y)","def knn(trainingSetData, testSetData, k):\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\n testSet = testSetData.drop([14], axis=1) # drop income\n\n distances = {}\n # this will store the distances re-sorted in ascending/descending order\n sort = {}\n # income band results (>=50k or <50K)\n incomePredictions = []\n\n # Calculating euclidean distance between each row of training data and test data instance\n for testInstance in range(len(testSet)): # len(testSet)\n \n # Store current test Point:\n testInstance = testSet.iloc[testInstance] \n \n distances = euclideanDistanceRow(testInstance, trainingSet)\n\n # sort the distances in order of smallest first:\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\n\n neighbors = []\n\n # Extracting top k neighbors\n for x in range(k):\n neighbors.append(sorted_d[x])\n\n\n classVotes = {}\n\n # Calculating the most freq class in the neighbors\n results = {\"lessThan50\": 0, \"moreThan50\": 0}\n\n # creating a dataframe to which we will add the income values:\n\n for x in range(len(neighbors)):\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\n results[\"lessThan50\"] += 1\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\n results[\"moreThan50\"] += 1\n\n print('results',results)\n\n if (results[\"lessThan50\"] > results[\"moreThan50\"]):\n incomePredictions.append(0.0)\n elif (results[\"lessThan50\"] < results[\"moreThan50\"]):\n incomePredictions.append(1.0)\n\n return incomePredictions","def test_score(self, n_neighbors, weights):\n _check_knn_score(\n KNeighborsPartialLabelRanker(n_neighbors, weights), self.X, self.Y)","def classify(self, data ):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum\n guesses.append(vectors.argMax())\n return guesses","def heuristic2_label_OBD(n, P, label, critical=None):\n print \"trying to label \" + str(n) + \" with \" + str(label)\n nodes_labeled = []\n if ('critical' in P.node[n].keys()) and (P.node[n]['critical']==True) and (P.node[n]['OBDlabel'] != label) :\n print \"FAIL on critical and not the same label.\"\n return (False, []) # being critical, we could avoid failure only if the label to set would be the same (it happens)\n else:\n P.node[n]['OBDlabel'] = label\n nodes_labeled.append(n) # this is a list that gets passed through recursions\n if critical == True:\n P.node[n]['critical'] = True\n # labeling part done\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\n new_label = label + 1\n neighbors = P.neighbors(n)\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if P.node[neigh]['OBDlabel'] > new_label:\n new_label = P.node[neigh]['OBDlabel']\n # we got maximum of current label or any node that neighbors have - now we label them all with that\n neighbors_to_label = []\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\n neighbors_to_label.append(neigh)\n else: # if set and smaller than mine, leave them alone\n pass\n else: # if not set, then not lower and not labelled\n neighbors_to_label.append(neigh)\n # now we have all the neighbors that need to be labeled\n if len(neighbors_to_label) > 1:\n flag_critical = True\n # and now the recursive step - labeling all these nodes\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\n for perm in permutations:\n print \"trying perm: \" + str(perm)\n this_run_success = True\n this_run_labeled = []\n for el in perm:\n (s, nl) = heuristic2_label_OBD(el, P, new_label, flag_critical)\n this_run_labeled = this_run_labeled + nl\n if s == False:\n this_run_success = False\n break\n if this_run_success == False:\n # then unlabel all that were labelled up to now\n for nn in this_run_labeled:\n print \"removing label of \" + str(nn)\n P.node[nn]['OBDlabel'] = None\n P.node[nn]['critical'] = False\n else: # obviously success is True, we managed to label all others...\n nodes_labeled = nodes_labeled + this_run_labeled\n print \"Win in labeling neighbors of \" + str(n)\n return (True, nodes_labeled)\n break\n # if no permutation is successful, we end up returning the last line\n return (False, nodes_labeled)\n print \"FAIL of all permutations from \" + str(n)","def ovo_test(dic, x_test, y_test, nb_classes):\n TP = FP = TN = FN = 0\n correct_predict = 0\n for index, value in enumerate(x_test):\n predict = {elem : 0 for elem in nb_classes}\n for key in dic:\n predict[key[0] if dic[key].predict([value]) else key[1]] += 1\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\n if predicted_value == y_test[index]:\n correct_predict += 1\n TP += 1\n else:\n FP += 1\n \n return correct_predict, TP, FP, TN, FN","def propagateLabel(self, l1, l2):\n\n if l1 != l2:\n winner = min(l1, l2)\n loser = max(l1, l2)\n loserN = 0\n superiorN = 0\n for i,l in enumerate(self.labels):\n if l == loser:\n loserN += 1\n self.labels[i] = winner\n if l > loser:\n superiorN += 1\n self.labels[i] = l - 1\n\n # print('Loser Label is ' + str(loser) + ' . With ' + str(loserN) + ' associated cells. Winner label is ' + str(winner))","def evaluate(labels, predictions):\n positive_count = 0\n positive = 0\n negative_count = 0\n negative = 0\n for i in range(len(labels)):\n if labels[i] == 1:\n positive_count+=1\n if predictions[i] == 1:\n positive +=1\n else:\n negative_count+=1\n if predictions[i] == 0:\n negative +=1\n\n sensitivity = positive / positive_count\n specificity = negative / negative_count\n\n return (sensitivity, specificity)","def evaluate(labels, predictions):\n\n truePositiveCounter = 0\n trueNegativeCounter = 0\n truePositiveCorrect = 0\n trueNegativeCorrect = 0\n \n sensitivity = 0\n specificity = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n truePositiveCounter += 1\n if(labels[i] == predictions[i]):\n truePositiveCorrect += 1\n elif labels[i] == 0:\n trueNegativeCounter += 1\n if(labels[i] == predictions[i]):\n trueNegativeCorrect += 1\n\n sensitivity = truePositiveCorrect / truePositiveCounter\n specificity = trueNegativeCorrect / trueNegativeCounter\n\n return sensitivity, specificity","def decision_tree_prediction(example, root, attributes):\n # If reached a leaf node, return the label\n if isinstance(root, str):\n return root\n\n # Attribute that was split on\n attribute = root.attribute\n # Column of the attribute that was split on\n i = get_index(attribute, attributes)\n testValue = example[i]\n # Check every child to see what path the example must take in the decision tree\n for child in root.children:\n if isinstance(child.branch, int):\n if int(testValue) <= child.branch:\n return decision_tree_prediction(example, child.nextTree, attributes)\n elif isinstance(child.branch, float):\n if int(testValue) > child.branch:\n return decision_tree_prediction(example, child.nextTree, attributes)\n# -----------------------------------------------Naive Bayes-------------------------------------------------\n # Naive bayes\n elif child.branch == \"Naive\":\n yes_probability = child.histogram[0]\n no_probability = child.histogram[2]\n i = 0\n for feature in example:\n if feature == \"yes\" or feature == \"no\":\n continue\n if i == 0 or i == 2 or i == 4 or i == 10 or i == 11 or i == 12:\n j = 0\n # Its a float so check\n for key in child.histogram[1][attribute_index[i]]:\n if float(feature) <= float(key) and j == 0:\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][key]\n elif j == 1:\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][key]\n j += 1\n for key in child.histogram[1][attribute_index[i]]:\n if float(feature) <= float(key) and j == 0:\n no_probability = no_probability * child.histogram[1][attribute_index[i]][key]\n elif j == 1:\n no_probability = no_probability * child.histogram[1][attribute_index[i]][key]\n j += 1\n else:\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][feature]\n no_probability = no_probability * child.histogram[3][attribute_index[i]][feature]\n i += 1\n if yes_probability > no_probability:\n return \"yes\"\n elif no_probability >= yes_probability:\n return \"no\"\n# -----------------------------------------------End Naive Bayes-------------------------------------------------\n else:\n if child.branch == testValue:\n return decision_tree_prediction(example, child.nextTree, attributes)","def classify(self, data):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum + self.bias[l]\n guesses.append(vectors.argMax())\n return guesses","def choose_one(self,labels) :\n # Exercise 1: Reduce k until you find a unique winner\n counts = Counter(labels)\n winner, winner_count = counts.most_common(1)[0]\n num_winners = len([count for count in counts.values() if count == winner_count])\n # replace&complete: The winning label has to be found and returned\n if num_winners == 1:\n return winner\n else:\n return self.choose_one(labels[:-1])","def majority_vote(votes):\n vote_counts = {}\n for vote in votes:\n if vote in vote_counts:\n vote_counts[vote] += 1\n else:\n vote_counts[vote] = 1\n\n winners = []\n max_choice = max(vote_counts.values())\n for vote, count in vote_counts.items():\n if count == max_choice:\n winners.append(vote)\n \n import random\n return(random.choice(winners))","def get_best_thresholds(labels, test_y, outputs, plot=False):\n t_max = [0] * len(labels)\n f_max = [0] * len(labels)\n\n for i, label in enumerate(labels):\n ts = []\n fs = []\n\n for t in np.linspace(0.1, 0.99, num=50):\n p, r, f, _ = precision_recall_fscore_support(test_y[:,i], np.where(outputs[:,i]>t, 1, 0), average='micro')\n ts.append(t)\n fs.append(f)\n if f > f_max[i]:\n f_max[i] = f\n t_max[i] = t\n\n if plot:\n print(f'LABEL: {label}')\n print(f'f_max: {f_max[i]}')\n print(f't_max: {t_max[i]}')\n\n plt.scatter(ts, fs)\n plt.show()\n \n return t_max, f_max","def classify(self, instance):\n \"\"\"best stores the pointer to the sequence with maximum final probability from the Viterbi trellis.\n Iterate through the corresponding row in the backtrace_pointers matrix backwards and add its labels to best_sequence list.\n Return the reversed best_sequence list.\n \"\"\"\n backtrace_pointers = self.dynamic_programming_on_trellis(instance, False)\n best_sequence = []\n trellis = backtrace_pointers[0]\n best = trellis[:,len(instance.data)-1].argmax()\n i = best\n best_sequence = [self.labels[best]]\n for j in xrange(len(instance.data)-1, 0, -1):\n i = backtrace_pointers[1][i][j]\n best_sequence.append(self.labels[i])\n return best_sequence[::-1]","def ranked_accuracy(predictions, labels):\n rank1 = 0\n rank5 = 0\n\n for (pred, lbl) in zip(predictions, labels):\n pred = np.argsort(pred)[::-1]\n\n if lbl in pred[:5]:\n rank5+=1\n\n if lbl == pred[0]:\n rank1+=1\n\n rank1 /= float(len(labels))\n rank5 /= float(len(labels))\n\n return (rank1, rank5)","def __count_errors(node, testSet, res):\n training_results = __get_results(node) #Get a dictionary of labels and counts for the *training* data which made it to this node\n leaf_label = None #Initialize a label for this leaf\n majority_count = 0 #Initialize a variable to track the number of observations for the label with the most observations\n #Note that the steps below do not handle ties of the majority count in a nice way.\n for label, count in training_results.items(): #iterate through each pair of labels and counts from the training set\n if count > majority_count: #find the label with the highest count\n leaf_label = label #the label for the leaf is the label with the highest count\n majority_count = count #keep track of the count for the leaf_label\n \n wrong_labels = testSet[res].unique().tolist() #initialize wrong_labels to be all labels in the testSet\n if leaf_label in wrong_labels: #If the leaf label is in the list of labels for the part of the test set that got to this node\n wrong_labels.remove(leaf_label) #remove the leaf_label so that all which remains are incorrect labels\n \n wrong_count = 0 #Initialize a count of how many testSet observations will be classified incorrectly\n testCounts = testSet.groupby(res).size() #Get a series of the testSet labels and how many observations pertain to each label\n for label in wrong_labels: #Iterate over all the labels not equal to the leaf_label\n wrong_count += testCounts[label] #Sum up all of the observations with a label not equal to the leaf_label\n return wrong_count","def pick_largest(self, cut_off):\r\n for i in range(self.dimension):\r\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\r\n ,int(self.rank_yx(self.rank[i])[1])]\r\n if m * self.image_data[i] == self.image_data[i]:\r\n if self.image_data[i] <= cut_off:\r\n print(\"Surveying completed\")\r\n return -1,-1 # returns -1,-1 if scan is completed\r\n else:\r\n return self.image_data[i], np.array(self.rank[i])","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def most_discriminating( features_df, labels_df, top=5):\n \n columns = features_df.shape[1]\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\n qualities = np.zeros(columns)\n \n _left = 0\n _right = 1\n\n _c = 0\n _h = 1\n\n # globals\n cases = float(labels_df['candy_id'].count()) # total cases\n\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\n p_h_A = 1.0 - p_c_A\n\n\n for feature in range(columns):\n\n branch_cases = np.zeros(2) # total on each branch\n pi = np.zeros(2) # proportion on each branch\n\n split = np.array([\n #c, h\n [0, 0], #left\n [0, 0] #right\n ])\n\n for index, value in features_df[feature].iteritems():\n split[value][labels_df.loc[index][0]] += 1\n\n branch_cases[_left] = split[_left].sum()\n branch_cases[_right] = split[_right].sum()\n \n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\n qualities[feature] = 0\n continue\n \n pi[_left] = branch_cases[_left] / cases\n pi[_right] = branch_cases[_right] / cases\n\n p_c_B = split[_left][_c] / branch_cases[_left]\n p_h_B = split[_left][_h] / branch_cases[_left]\n\n p_c_C = split[_right][_c] / branch_cases[_right]\n p_h_C = split[_right][_h] / branch_cases[_right]\n\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\n\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\n\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\n\n qualities[feature] = quality\n return list(reversed(qualities.argsort()))[:top]","def compare_result(res, label):\n infer_res = []\n infer_conf = []\n gt_conf = []\n size = len(label)\n for i in range(size):\n infer_res.append(np.where(res[i] == np.max(res[i]))[3][0])\n infer_conf.append(res[i][0][0][0][infer_res[i]])\n gt_conf.append(res[i][0][0][0][label[i]])\n return infer_res, infer_conf, gt_conf","def majority_vote(votes):\n\n vote_counts = {} # dictionary\n for vote in votes:\n # known word\n if vote in vote_counts:\n vote_counts[vote] += 1\n # unknown word\n else:\n vote_counts[vote] = 1\n\n print(vote_counts)\n # but who is the winner?\n winners = []\n max_votes = max(vote_counts.values())\n\n # for (,) this is a tuple\n for vote, count in vote_counts.items():\n if count == max_votes:\n winners.append(vote)\n\n # what is we have multiply winners? Well we select one randomly\n\n return random.choice(winners)","def predict(self, input: ByteTensor) -> IntTensor:\n clause_outputs = self.evaluate_clauses(input)\n class_votes = self.sum_up_class_votes(clause_outputs)\n _, index = class_votes.max(0)\n return index","def evaluate(labels, predictions):\n TP = 0\n actualP = 0\n TN = 0\n actualN = 0\n for label, prediction in zip(labels, predictions):\n if label ==1:\n actualP +=1\n if prediction == 1:\n TP +=1\n else:\n actualN +=1\n if prediction ==0:\n TN +=1\n \n sensitivity = float(TP/actualP)\n specificity = float(TN/actualN)\n return (sensitivity, specificity)","def predictClass(training_data, test_row, k):\n\n neighbors = getNeighbors(training_data, test_row, k)\n output_vals = [row[-1] for row in neighbors]\n \n counts = dict()\n\n for i in output_vals:\n counts[i] = counts.get(i, 0) + 1\n\n v = [value for value in counts.values()]\n\n #Pick a class on random if ties occur\n prediction = choice([key for key in counts if counts[key] == max(v)])\n\n return prediction","def detection(test_img):\n # TODO: Step 2 : Your Detection code should go here.\n no_row = len(test_img)\n no_col = len(test_img[0])\n thresh = 100\n label_img = np.zeros((no_row, no_col))\n uf = []\n \n #first pass\n l = 1\n for i in range(0, no_row):\n for j in range(0, no_col):\n if test_img[i,j] < 255 - thresh:\n if i == 0 and j == 0:\n label_img[i,j] = l\n l = l+1\n elif i == 0 and j != 0:\n if label_img[i,j-1] == 0:\n label_img[i,j] = l\n l = l+1\n else:\n label_img[i,j] = label_img[i,j-1]\n elif i != 0 and j == 0:\n if label_img[i-1,j] == 0:\n label_img[i,j] = l\n l = l+1\n else:\n label_img[i,j] = label_img[i-1,j]\n else:\n if label_img[i-1,j] == 0 and label_img[i,j-1] == 0:\n label_img[i,j] = l\n l = l+1\n elif label_img[i-1,j] == 0 and label_img[i,j-1] != 0:\n label_img[i,j] = label_img[i,j-1]\n elif label_img[i-1,j] != 0 and label_img[i,j-1] == 0:\n label_img[i,j] = label_img[i-1,j]\n else:\n if label_img[i,j-1] == label_img[i-1,j]:\n label_img[i,j] = label_img[i,j-1]\n else:\n label_img[i,j] = min(label_img[i-1,j],label_img[i,j-1])\n uf.append([min(label_img[i,j-1],label_img[i-1,j]),max(label_img[i,j-1],label_img[i-1,j])])\n l = l - 1\n \n #2nd pass\n def ufds(x,l):\n b = []\n for i in range(1,l+1):\n b.append([i])\n for j in x:\n i1 = 0\n i2 = 0\n for k in range(0,len(b)):\n if j[0] in b[k]:\n i1 = k\n if j[1] in b[k]:\n i2 = k\n if i1 != i2:\n b[i1] = b[i1] + b[i2]\n del b[i2]\n return b\n \n bman = ufds(uf,l)\n \n #3rd pass\n uf_arr = np.zeros(l)\n for i in range(0,len(uf_arr)):\n for j in bman:\n if i+1 in j:\n uf_arr[i] = min(j) \n \n fin_img = np.zeros((no_row, no_col))\n for i in range(0, no_row):\n for j in range(0, no_col):\n if label_img[i,j] != 0:\n fin_img[i,j] = uf_arr[int(label_img[i,j] - 1)]\n \n all_label = []\n '''\n for i in bman:\n all_label.append(min(i))\n ''' \n for i in range(0, no_row):\n for j in range(0, no_col):\n if fin_img[i,j] !=0 and fin_img[i,j] not in all_label:\n all_label.append(fin_img[i,j])\n \n # main image\n k_img = np.zeros((no_row, no_col))\n for i in range(0, no_row):\n for j in range(0, no_col):\n if fin_img[i,j] != 0:\n k_img[i,j] = (all_label.index(fin_img[i,j]) + 1)\n \n k_list = []\n for i in range(1,len(all_label)+1):\n x = None\n y = None\n hx = None\n hy = None\n for j in range(0,no_row):\n for k in range(0,no_col):\n if k_img[j,k] == i:\n if y == None and x == None:\n y = j\n hy = j\n x = k\n hx = k\n else:\n if y > j:\n y = j\n if hy < j:\n hy = j\n if x > k:\n x = k\n if hx < k:\n hx = k\n k_list.append({\"bbox\": [x, y, hx-x, hy-y]})\n \n return k_list\n \n #raise NotImplementedError","def classify(self, data ):\n\t\tguesses = []\n\t\tfor datum in data:\n\t\t\tvectors = util.Counter()\n\t\t\tfor l in self.legalLabels:\n\t\t\t\tvectors[l] = self.weights[l] * datum\n\t\t\tguesses.append(vectors.argMax())\n\t\treturn guesses","def classify(self, data ):\n\t\tguesses = []\n\t\tfor datum in data:\n\t\t\tvectors = util.Counter()\n\t\t\tfor l in self.legalLabels:\n\t\t\t\tvectors[l] = self.weights[l] * datum\n\t\t\tguesses.append(vectors.argMax())\n\t\treturn guesses","def evaluate(y_test, pred_labels):\n \n # Converts one-hot code to a label (the index of 1)\n y_test_labels = np.argmax(y_test, axis=1)\n \n # Compare test labels to predicted labels\n score = accuracy_score(y_test_labels, pred_labels)\n \n return y_test_labels, score","def _detection_scores(inputs, gt_boxes, gt_labels, model):\n model = check_model('model', model, BlackModel)\n boxes_and_confi, pred_labels = model.predict(*inputs)\n det_scores = []\n correct_labels_num = []\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\n iou_thres = 0.5\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\n gt_box_num = gt_box.shape[0]\n score = 0\n box_num = boxes.shape[0]\n correct_label_flag = np.zeros(gt_label.shape)\n for i in range(box_num):\n pred_box = boxes[i]\n max_iou_confi = 0\n for j in range(gt_box_num):\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\n correct_label_flag[j] = 1\n score += max_iou_confi\n det_scores.append(score)\n correct_labels_num.append(np.sum(correct_label_flag))\n return np.array(det_scores), np.array(correct_labels_num)","def train(self, data, labels, validationData, validationLabels): # data x training, y_training\n # ## TODO: Your code here\n count = util.Counter()\n\n #print 'Labels of the data is:', labels #printing all the labels from which the frequency has to be found\n\n for x in labels: # for loop\n count[x] += 1\n\n #print count\n val = count.argMax()\n self.guess = val\n #print val","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def nb_decision(X,p_y,p_x_given_y):\n cases = X.shape[0]\n dims = X.shape[1]\n\n bayes_prob = np.zeros((cases, 2))\n result = np.zeros(cases)\n\n y_values = p_y.size\n\n # find the probability for each y value\n for y_value in range(y_values):\n # iterate through each case and calculate the probability\n for case in range(cases):\n prob = p_y[y_value]\n\n for dim in range(dims):\n if X[case][dim] == 1:\n prob = prob * p_x_given_y[dim][y_value]\n elif X[case][dim] == 0:\n prob = prob * (1 - p_x_given_y[dim][y_value])\n\n\n bayes_prob[case][y_value] = prob\n\n # now find out which class has the biggest probability\n for case in range(cases):\n if bayes_prob[case][0] > bayes_prob[case][1]:\n result[case] = 0\n else:\n result[case] = 1\n\n return result","def greedy_learn(self,node,db,labels,ids):\n if node.depth >= self.maxdepth or len(ids) <= self.minexamples:\n #terminate recursion\n node.pick_best_label(db,labels,ids)\n err = misclassification_error([labels[id] for id in ids])\n if err > 0:\n print \"Reached a leaf and had to make some sacrifices, cost\",err\n print \" depth\",node.depth\n print \" labels\",[labels[id] for id in ids]\n return err\n\n features = self.feature_subset(node,db,labels,ids)\n cost = node.pick_best_split(db,labels,ids,features)\n \n #do a split\n if node.type == 'v':\n #base case: no misclassifications\n \"\"\"\n if cost>0:\n print \"greedy_learn: Warning, pick_best_split indicates a leaf but the cost is nonzero\"\n print \"cost=\",cost,\"misclassification=\",misclassification_error([labels[id] for id in ids])\n print \"# of ids:\",len(ids)\n for i in ids:\n print \"id\",i,\",\",\n for k in range(db.numFeatures()):\n if db[k,i] != None:\n print k,\"=\",db[k,i],\",\",\n print \"label\",labels[i]\n raw_input()\n \"\"\"\n return 0\n elif node.type == 's':\n #print \"Picked feature\",node.feature,\"split\"\n #do a discrete split\n node.children = dict()\n #select sub-indices\n Eids = defaultdict(list)\n noneids = []\n for id in ids:\n v = db[node.feature,id]\n if v is None:\n #item doesn't exist, it's a missing value\n noneids.append(id)\n else:\n Eids[v].append(id)\n #print \" split sizes:\",[len(x) for x in Eids.values()]\n #print \" None ids:\",len(noneids)\n ids = None\n errors = 0\n for v,vids in Eids.iteritems():\n #recurse\n c = DecisionTreeNode(node)\n #print \"Recursing on value\",v\n #print \" ids:\",vids\n errors += self.greedy_learn(c,db,labels,vids+noneids)\n node.children[v] = c\n if c.depth > self.deepest:\n self.deepest = c.depth\n print \"Decision tree learner: Reached node with depth\",self.deepest\n return errors\n else:\n #do an inequality split\n assert node.type == 'i'\n #print \"Picked feature\",node.feature,\"inequality value\",node.value,\"cost\",cost\n leftids = []\n rightids = []\n for id in ids:\n if db[node.feature,id] is not None:\n if db[node.feature,id] <= node.value: leftids.append(id)\n else: rightids.append(id)\n else:\n leftids.append(id)\n rightids.append(id)\n if len(rightids) == len(ids) or len(leftids) == len(ids):\n #due to missing values, this split is useless\n errors = misclassification_error([labels[id] for id in ids])\n print \"useless split on feature\",node.feature,\"value\",node.value,\"misclassification error\",errors\n print \"Left size\",len(leftids),\"right size\",len(rightids)\n raw_input()\n node.pick_best_label(db,labels,ids)\n return errors\n #clear memory associated with ids list\n del ids[:]\n ids = None\n #print \"Left size\",len(leftids),\"right size\",len(rightids)\n c1 = DecisionTreeNode(node)\n c2 = DecisionTreeNode(node)\n #left side\n errors = self.greedy_learn(c1,db,labels,leftids)\n #right side\n errors += self.greedy_learn(c2,db,labels,rightids)\n #restore index\n node.children = {0:c1,1:c2}\n if c1.depth > self.deepest:\n self.deepest = c1.depth\n print \"Decision tree learner: Reached node with depth\",self.deepest\n return errors","def _get_max_answers(self):\n return max([len(x) for x in self.labels])","def optimal_neighbors(X_data,\n y_data,\n standardize = True,\n pct_test=0.25,\n seed=802,\n response_type='reg',\n max_neighbors=20,\n show_viz=True): \n \n \n if standardize == True:\n # optionally standardizing X_data\n scaler = StandardScaler()\n scaler.fit(X_data)\n X_scaled = scaler.transform(X_data)\n X_scaled_df = pd.DataFrame(X_scaled)\n X_data = X_scaled_df\n\n\n\n # train-test split\n X_train, X_test, y_train, y_test = train_test_split(X_data,\n y_data,\n test_size = pct_test,\n random_state = seed)\n\n\n # creating lists for training set accuracy and test set accuracy\n training_accuracy = []\n test_accuracy = []\n \n \n # setting neighbor range\n neighbors_settings = range(1, max_neighbors + 1)\n\n\n for n_neighbors in neighbors_settings:\n # building the model based on response variable type\n if response_type == 'reg':\n clf = KNeighborsRegressor(n_neighbors = n_neighbors)\n clf.fit(X_train, y_train)\n \n elif response_type == 'class':\n clf = KNeighborsClassifier(n_neighbors = n_neighbors)\n clf.fit(X_train, y_train) \n \n else:\n print(\"Error: response_type must be 'reg' or 'class'\")\n \n \n # recording the training set accuracy\n training_accuracy.append(clf.score(X_train, y_train))\n \n # recording the generalization accuracy\n test_accuracy.append(clf.score(X_test, y_test))\n\n\n # optionally displaying visualization\n if show_viz == True:\n # plotting the visualization\n fig, ax = plt.subplots(figsize=(12,8))\n plt.plot(neighbors_settings, training_accuracy, label = \"training accuracy\")\n plt.plot(neighbors_settings, test_accuracy, label = \"test accuracy\")\n plt.ylabel(\"Accuracy\")\n plt.xlabel(\"n_neighbors\")\n plt.legend()\n plt.show()\n \n \n # returning optimal number of neighbors\n print(f\"The optimal number of neighbors is: {test_accuracy.index(max(test_accuracy))+1}\")\n return test_accuracy.index(max(test_accuracy))+1","def add(self, detection_candidates):\n best_cand = None\n best_iou = 0.0\n last_detection = self.get_last_det()\n \n for cand in detection_candidates: \n if cand.label == self.label:\n curr_iou = calculate_IOU(last_detection, cand)\n if curr_iou > best_iou:\n best_iou = curr_iou \n best_cand = cand\n print(\"Best IoU: {}\".format(best_iou))\n if best_iou >= self.threshold:\n self.detection_list.append(best_cand)\n return best_cand\n return None","def _label_rider_by_trip_frequency(self, rider):\n if rider['total_num_trips'] <= 5*self.duration:\n label = 0\n elif rider['total_num_trips'] <= 20*self.duration:\n label = 1\n elif rider['total_num_trips'] > 20*self.duration:\n label = 2\n else:\n label = -1\n return label","def _majority_vote(self, claims):\n c_df = claims[['source_id', 'object_id', 'value']].copy()\n discovered_truths = c_df.groupby(['object_id'\n ]).apply(lambda x: self.elect(x))\n discovered_truths = pd.DataFrame(discovered_truths)\n discovered_truths = discovered_truths.rename(columns={\n 0: 'value'\n }).reset_index()\n return discovered_truths","def plaque_detection_rate(labels, preds, n_classes=5, thres=0):\n if not isinstance(labels, np.ndarray):\n labels = labels.data.cpu().numpy()\n preds = preds.cpu().numpy()\n\n pgt_cnt = [0, 0]\n pp_cnt = [0, 0]\n tp_cnt = [0, 0]\n\n # 5-class segmentation or 2-class segmentation\n plaques = [3, 4] if n_classes == 5 else [0, 1]\n if labels.ndim == 3: # for 2D image\n for label, pred in zip(labels, preds):\n for inx, plaque in enumerate(plaques):\n if np.sum(label == plaque) != 0:\n pgt_cnt[inx] += 1\n if np.sum(pred == plaque) >= thres:\n pp_cnt[inx] += 1\n if np.sum(label == plaque) != 0 and np.sum(pred == plaque) >= thres:\n tp_cnt[inx] += 1\n\n elif labels.ndim == 4:\n for label_vol, pred_vol in zip(labels, preds):\n for label, pred in zip(label_vol, pred_vol):\n for inx, plaque in enumerate(plaques):\n if np.sum(label == plaque) != 0:\n pgt_cnt[inx] += 1\n if np.sum(pred == plaque) >= thres:\n pp_cnt[inx] += 1\n if np.sum(label == plaque) != 0 and np.sum(pred == plaque) >= thres:\n tp_cnt[inx] += 1\n\n return pgt_cnt[0], pp_cnt[0], tp_cnt[0], pgt_cnt[1], pp_cnt[1], tp_cnt[1]","def result_poll(votes):\n return sum(votes) >= 2 / 3 * len(votes)","def predict(self, X):\n preds = self.get_predictions(X)\n\n n_classifiers, n_instances = preds.shape\n\n local_votes = np.empty(self.n_classes, dtype=np.float32)\n global_votes = np.empty(n_instances, dtype=np.int32)\n\n for i in range(n_instances):\n local_votes[:] = 0.\n\n for j in range(n_classifiers):\n local_votes[preds[j, i]] += self.voting_weights[j, preds[j, i]]\n\n global_votes[i] = np.argmax(local_votes)\n\n return global_votes","def prob6(n_neighbors, filename=\"mnist_subset.npz\"):\n #Extract the data\n data = np.load(\"mnist_subset.npz\")\n X_train = data[\"X_train\"].astype(np.float)\n y_train = data[\"y_train\"]\n X_test = data[\"X_test\"].astype(np.float)\n y_test = data[\"y_test\"]\n\n # instantiate a KNeighborsClassifier to hold the data to make predictions\n myClassifier = KNeighborsClassifier(n_neighbors)\n myClassifier.fit(X_train, y_train)\n accurate_trains = 0\n prediction = 0\n # test each label\n for i in range(len(X_test)):\n target = X_test[i]\n #make prediction\n prediction = myClassifier.predict(target)\n # check accuracy\n if prediction == y_test[i]:\n accurate_trains += 1\n # return the accuracy ratio\n return accurate_trains / len(y_test)","def evaluate1_5(self, test_data):\r\n test_results = [(np.argmax(self.feedforward1_5(x)), y)\r\n for (x, y) in test_data]\r\n #print(self.feedforward(test_data[0][0]))\r\n #print(test_data[0][1])\r\n return sum(int(x == y) for (x, y) in test_results)","def ovr_test(dic, x_test, y_test, nb_classes):\n TP = FP = TN = FN = 0\n correct_predict = 0\n for index, value in enumerate(x_test):\n predict = {elem : 0 for elem in nb_classes}\n for key in dic:\n predict[key] = dic[key].predict_proba([value])[0][1]\n\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\n if predicted_value == y_test[index]:\n correct_predict += 1\n TP += 1\n else:\n FP += 1\n \n return correct_predict, TP, FP, TN, FN","def iterative_majority(votes):\n half = len(votes)//2\n counts = defaultdict(lambda: 0)\n for vote in votes:\n counts[vote] += 1\n\n sorted_counts = sorted((count for count in counts.values()), reverse=True)\n return (Outcome.has_majority if sorted_counts[0] > half\n else Outcome.no_majority)","def _score_to_decision(self, score):","def find_best_k(data, anots, neibhours_range):\r\n \r\n best_k = 0\r\n best_acc = 0\r\n for n_neighbors in neibhours_range:\r\n accur = iterate_over_chanels(data, anots, n_neighbors)\r\n mean_acc = accur.mean()\r\n if mean_acc > best_acc:\r\n best_acc = mean_acc\r\n best_k = n_neighbors\r\n return best_k","def nearest_neighbors_metrics(all_pcs, all_labels, this_unit_id, max_spikes_for_nn, n_neighbors):\n\n total_spikes = all_pcs.shape[0]\n ratio = max_spikes_for_nn / total_spikes\n this_unit = all_labels == this_unit_id\n\n X = np.concatenate((all_pcs[this_unit, :], all_pcs[np.invert(this_unit), :]), 0)\n\n n = np.sum(this_unit)\n\n if ratio < 1:\n inds = np.arange(0, X.shape[0] - 1, 1 / ratio).astype('int')\n X = X[inds, :]\n n = int(n * ratio)\n\n nbrs = NearestNeighbors(n_neighbors=n_neighbors, algorithm='ball_tree').fit(X)\n distances, indices = nbrs.kneighbors(X)\n\n this_cluster_inds = np.arange(n)\n\n this_cluster_nearest = indices[:n, 1:].flatten()\n other_cluster_nearest = indices[n:, 1:].flatten()\n\n hit_rate = np.mean(this_cluster_nearest < n)\n miss_rate = np.mean(other_cluster_nearest < n)\n\n return hit_rate, miss_rate","def variable_ranking(self):\n self.grow_trees()\n dist_classes = self.dist_classes\n oob = self.forest.oob_set_generator()\n oob_length, First, elt_vals, var_vals = len(oob), True, {}, {}\n succ_rate, dist_succ_rate, dist_order = 0, 0, 0\n for var in self.variables:\n var_range = list(variable_range(self.data, var))\n range_len = len(var_range)\n print var\n permution = None\n permuted_succ, perm_dist_succ = 0, 0\n for elts in oob:\n if First:\n actual = self.data[elts][self.prediction_index]\n elt_vals[elts] = actual\n predicted = self.forest.test_predict(self.data[elts], elts)\n if actual in dist_classes:\n dist_order += 1\n if actual == predicted:\n succ_rate += 1\n if actual in dist_classes:\n dist_succ_rate += 1\n if var[1] == 'd':\n permution = int(math.floor(uniform(0, 1)*range_len))\n permution = var_range[permution]\n else:\n permution = uniform(0, 1)*(var_range[1] - var_range[0])\n perm_tuple = self.data[elts][:var[0]] + [permution] + self.data[elts][var[0]+1:]\n permuted_prediction = self.forest.predict(perm_tuple)\n actual = elt_vals[elts]\n if actual == permuted_prediction:\n permuted_succ += 1\n if actual in dist_classes:\n perm_dist_succ += 1\n if First:\n succ_rate = float(succ_rate)/oob_length\n dist_succ_rate = float(dist_succ_rate)/dist_order\n First = False\n permuted_succ = float(permuted_succ)/oob_length\n perm_dist_succ = float(perm_dist_succ)/dist_order\n print \"Originally a \", succ_rate, \" success rate, with permution to \", permuted_succ\n print \"A difference of \", succ_rate - permuted_succ\n print \"WRT Distinguised classes, a success rate of:\", dist_succ_rate, 'with permution to ', perm_dist_succ\n print \"A difference of \", dist_succ_rate - perm_dist_succ\n var_vals[var] = succ_rate - permuted_succ\n var_vals[(var, 'd')] = dist_succ_rate - perm_dist_succ\n var_vals = sorted(var_vals.items(), key=lambda x: x[1], reverse=True)\n for x in var_vals:\n print x[0], x[1]","def knnForOne(x_training_data, y_training_data, single_x_test_data, n_neighbors):\n nearest_neighbors = {}\n length = len(x_training_data)\n\n for i in range(length):\n X2 = x_training_data[i,:] # get current row of known data\n Y2 = y_training_data[i] # get current label of known data\n distance = getDistance(single_x_test_data, X2) # compare test to known data\n\n if len(nearest_neighbors) < n_neighbors: # reach capacity of nearest neighbors\n nearest_neighbors[distance] = Y2\n else: # kick out largest distance\n\n # Assumes no two distances are exactly the same, or data point will be overwritten in dictionary\n largest_distance = max(nearest_neighbors)\n if distance < largest_distance:\n del nearest_neighbors[largest_distance]\n nearest_neighbors[distance] = Y2\n\n # nearest_neighbors is a dictionary with the n nearest neighbors \n # as values and their distances from single_x_test_data as keys\n \n counts = {}\n for key in nearest_neighbors: # initialize counts dictionary\n counts[nearest_neighbors[key]] = 0\n\n for key in nearest_neighbors: # count labels within the nearest neighbors\n counts[nearest_neighbors[key]] += 1\n\n max_value = max(counts.values()) # find most frequent label within the nearest neighbors\n for key in counts:\n if counts[key] == max_value:\n return key"],"string":"[\n \"def _vote(self, neighbor_labels):\\n counts= torch.bincount(neighbor_labels.int())\\n return torch.argmax(counts)\",\n \"def _tally_votes(self, labels, distances):\\n votes = collections.defaultdict(int)\\n for i, index in enumerate(distances.order(ascending=True).index):\\n if i < self.k:\\n votes[labels[index]] += 1\\n else:\\n break\\n return votes\",\n \"def majority_vote(labels):\\n\\n conta = Counter(labels)\\n\\n winner, winner_count = conta.most_common(1)[0]\\n\\n num_winner = sum([1 for count in conta.values() if count == winner_count])\\n\\n if num_winner == 1:\\n return winner\\n else:\\n return majority_vote(labels[:-1])\",\n \"def ensembleVote(x, classes, ensemble):\\n votes = np.array([0 for kk in range(len(classes))])\\n for i in ensemble:\\n votes = votes + classProbs(x, ensemble[i][\\\"tree\\\"], classes)\\n maxVote = 0\\n loc = None\\n for ind, vote in enumerate(votes):\\n if vote > maxVote:\\n maxVote = vote\\n loc = ind\\n prediction = classes[loc]\\n return prediction\",\n \"def majority_voting(distances, labels, k):\\n nearest_index = np.argsort(distances)\\n k_neighbor_labels = []\\n for i in range(k):\\n index = nearest_index[i]\\n label = labels[index]\\n k_neighbor_labels.append(label)\\n major_class = np.argmax(np.bincount(k_neighbor_labels))\\n return major_class\",\n \"def majority_vote(labels):\\n vote_counts = Counter(labels)\\n winner, winner_count = vote_counts.most_common(1)[0]\\n num_winners = len([count for count in vote_counts.values()\\n if count == winner_count])\\n if num_winners == 1:\\n return winner\\n else:\\n #try again without the farthest\\n return majority_vote(labels[:-1])\",\n \"def predict_with_tree(self, X, ball_tree):\\n predicted_y = np.zeros(X.shape[0])\\n for i in range(X.shape[0]):\\n neighbours = []\\n ball_tree.knn_search(X[i], self.k_nearest, neighbours)\\n votes = {}\\n for neighbour in neighbours:\\n if neighbour.classification in votes:\\n votes[neighbour.classification] += 1\\n else:\\n votes[neighbour.classification] = 1\\n predicted_y[i] = max(votes, key=votes.get)\\n return predicted_y\",\n \"def predict(self, row):\\n label_vote = dict()\\n for i in range(len(self.forest)):\\n result = self.forest[i].predict(row)\\n label = max(result, key=result.get)\\n \\n if label_vote.get(label, None) is None:\\n label_vote[label] = 0\\n\\n label_vote[label] += 1\\n \\n return max(label_vote, key=result.get)\",\n \"def knn(p, k, x, t):\\r\\n\\r\\n # Number of instances in data set\\r\\n N = x.shape[0]\\r\\n\\r\\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\\r\\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\\r\\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\\r\\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\\r\\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\\r\\n\\r\\n\\r\\n #top_class = 0\\r\\n\\r\\n return top_class\",\n \"def __call__(self, clfs, dataset):\\n if len(clfs)==0:\\n return [] # to don't even bother\\n\\n all_label_counts = None\\n for clf in clfs:\\n # Lets check first if necessary conditional attribute is enabled\\n if not clf.ca.is_enabled(\\\"predictions\\\"):\\n raise ValueError, \\\"MaximalVote needs classifiers (such as \\\" + \\\\\\n \\\"%s) with state 'predictions' enabled\\\" % clf\\n predictions = clf.ca.predictions\\n if all_label_counts is None:\\n all_label_counts = [ {} for i in xrange(len(predictions)) ]\\n\\n # for every sample\\n for i in xrange(len(predictions)):\\n prediction = predictions[i]\\n # XXX fishy location due to literal labels,\\n # TODO simplify assumptions and logic\\n if isinstance(prediction, basestring) or \\\\\\n not is_sequence_type(prediction):\\n prediction = (prediction,)\\n for label in prediction: # for every label\\n # XXX we might have multiple labels assigned\\n # but might not -- don't remember now\\n if not label in all_label_counts[i]:\\n all_label_counts[i][label] = 0\\n all_label_counts[i][label] += 1\\n\\n predictions = []\\n # select maximal vote now for each sample\\n for i in xrange(len(all_label_counts)):\\n label_counts = all_label_counts[i]\\n # lets do explicit search for max so we know\\n # if it is unique\\n maxk = [] # labels of elements with max vote\\n maxv = -1\\n for k, v in label_counts.iteritems():\\n if v > maxv:\\n maxk = [k]\\n maxv = v\\n elif v == maxv:\\n maxk.append(k)\\n\\n assert len(maxk) >= 1, \\\\\\n \\\"We should have obtained at least a single key of max label\\\"\\n\\n if len(maxk) > 1:\\n warning(\\\"We got multiple labels %s which have the \\\" % maxk +\\n \\\"same maximal vote %d. XXX disambiguate. \\\" % maxv +\\n \\\"Meanwhile selecting the first in sorted order\\\")\\n predictions.append(sorted(maxk)[0])\\n\\n ca = self.ca\\n ca.estimates = all_label_counts\\n ca.predictions = predictions\\n return predictions\",\n \"def evaluateVoteCount(toCompare):\\n\\n #weight = 0\\n\\n if int(toCompare['vote_count']) >= 5000:\\n weight = 100\\n elif 3000 <= int(toCompare['vote_count']) < 5000:\\n weight = 80\\n elif 2000 <= int(toCompare['vote_count']) < 3000:\\n weight = 60\\n elif 1000 <= int(toCompare['vote_count']) < 2000:\\n weight = 40\\n elif 500 <= int(toCompare['vote_count']) < 1000:\\n weight = 20\\n else:\\n weight = 0\\n return weight\",\n \"def decision(self, neighbors=None):\\n if not neighbors:\\n return sorted(self.class_prb.items(), key=lambda n: n[1],\\n reverse=True)\\n\\n else:\\n n = len(neighbors)\\n prb = {}\\n for label in self.labels:\\n prb[label] = 0.0\\n for kdnode, dist in neighbors:\\n index = self.train_data.index(kdnode.data)\\n prb[self.train_label[index]] += 1\\n for label in self.labels:\\n prb[label] = prb[label] / n\\n return sorted(prb.items(), key=lambda n: n[1], reverse=True)\",\n \"def classify(self, data):\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n # should compute (validationData[i] - trainingData[j])^2\\n result = np.zeros(data.shape[0])\\n for i in range(data.shape[0]):\\n distances = np.linalg.norm(self.trainingData - data[i], axis=1)\\n nearest = np.argsort(distances)[:self.num_neighbors]\\n nearest_tags = [self.trainingLabels[j] for j in nearest]\\n result[i] = max(nearest_tags, key=lambda x: nearest_tags.count(x))\\n return result\",\n \"def val_vote_one_epoch(sess, ops, dataset, epoch, split, num_votes=10):\\n\\n is_training = False\\n\\n original_labels, original_points, \\\\\\n projection_inds, average_predictions = prepare_testing_structure(dataset, split)\\n feed_dict = {ops['is_training_pl']: is_training}\\n\\n for v in range(num_votes):\\n if v == 0:\\n sess.run(ops[f'{split}_init_op'])\\n else:\\n sess.run(ops[f'{split}_vote_init_op'])\\n all_predictions = []\\n all_obj_inds = []\\n all_objects = []\\n while True:\\n try:\\n tower_logits_all_shapes, tower_labels, \\\\\\n tower_object_labels, tower_o_inds, tower_batches = sess.run([ops['tower_logits_all_shapes'],\\n ops['tower_labels'],\\n ops['tower_super_labels'],\\n ops['tower_object_inds'],\\n ops['tower_in_batches']],\\n feed_dict=feed_dict)\\n\\n for logits_all_shapes, labels, object_labels, o_inds, batches in zip(tower_logits_all_shapes,\\n tower_labels,\\n tower_object_labels,\\n tower_o_inds,\\n tower_batches):\\n max_ind = np.max(batches)\\n for b_i, b in enumerate(batches):\\n # Eliminate shadow indices\\n b = b[b < max_ind - 0.5]\\n # Get prediction (only for the concerned parts)\\n obj = object_labels[b[0]]\\n pred = logits_all_shapes[obj][b]\\n # Stack all results\\n all_objects += [obj]\\n all_obj_inds += [o_inds[b_i]]\\n all_predictions += [pred]\\n except tf.errors.OutOfRangeError:\\n break\\n\\n true_num_test = len(all_predictions)\\n num_test = dataset.num_test if split == 'test' else dataset.num_val\\n vote_objects = [-1] * num_test\\n # Project predictions on original point clouds\\n for i, probs in enumerate(all_predictions):\\n # Interpolate prediction from current positions to original points\\n obj_i = all_obj_inds[i]\\n proj_predictions = probs[projection_inds[obj_i]]\\n vote_objects[obj_i] = all_objects[i]\\n # Average prediction across votes\\n average_predictions[obj_i] = average_predictions[obj_i] + \\\\\\n (proj_predictions - average_predictions[obj_i]) / (v + 1)\\n\\n if true_num_test != num_test:\\n logger.warning(\\\"{} using {}/{} data, \\\"\\n \\\"this may be caused by multi-gpu testing\\\".format(split, true_num_test, num_test))\\n vote_preds = average_predictions[:true_num_test]\\n vote_targets = original_labels[:true_num_test]\\n else:\\n vote_preds = average_predictions\\n vote_targets = original_labels\\n\\n msIoU, mpIoU, mmsIoU, mmpIoU = partnet_metrics(dataset.num_classes, dataset.num_parts,\\n vote_objects, vote_preds, vote_targets)\\n logger.info(f'E{epoch} V{v} {split} * mmsIoU {mmsIoU:.3%} mmpIoU {mmpIoU:.3%}')\\n logger.info(f'E{epoch} V{v} {split} * msIoU {msIoU}')\\n logger.info(f'E{epoch} V{v} {split} * mpIoU {mpIoU}')\\n return\",\n \"def val_vote_one_epoch(sess, ops, dataset, epoch, split, num_votes=10):\\n\\n is_training = False\\n\\n original_labels, original_points, \\\\\\n projection_inds, average_predictions = prepare_testing_structure(dataset, split)\\n feed_dict = {ops['is_training_pl']: is_training}\\n\\n for v in range(num_votes):\\n if v == 0:\\n sess.run(ops[f'{split}_init_op'])\\n else:\\n sess.run(ops[f'{split}_vote_init_op'])\\n all_predictions = []\\n all_obj_inds = []\\n all_objects = []\\n while True:\\n try:\\n tower_logits_all_shapes, tower_labels, \\\\\\n tower_object_labels, tower_o_inds, tower_batches = sess.run([ops['tower_logits_all_shapes'],\\n ops['tower_labels'],\\n ops['tower_super_labels'],\\n ops['tower_object_inds'],\\n ops['tower_in_batches']],\\n feed_dict=feed_dict)\\n\\n for logits_all_shapes, labels, object_labels, o_inds, batches in zip(tower_logits_all_shapes,\\n tower_labels,\\n tower_object_labels,\\n tower_o_inds,\\n tower_batches):\\n max_ind = np.max(batches)\\n for b_i, b in enumerate(batches):\\n # Eliminate shadow indices\\n b = b[b < max_ind - 0.5]\\n # Get prediction (only for the concerned parts)\\n obj = object_labels[b[0]]\\n pred = logits_all_shapes[obj][b]\\n # Stack all results\\n all_objects += [obj]\\n all_obj_inds += [o_inds[b_i]]\\n all_predictions += [pred]\\n except tf.errors.OutOfRangeError:\\n break\\n\\n true_num_test = len(all_predictions)\\n num_test = dataset.num_test if split == 'test' else dataset.num_val\\n vote_objects = [-1] * num_test\\n # Project predictions on original point clouds\\n for i, probs in enumerate(all_predictions):\\n # Interpolate prediction from current positions to original points\\n obj_i = all_obj_inds[i]\\n proj_predictions = probs[projection_inds[obj_i]]\\n vote_objects[obj_i] = all_objects[i]\\n # Average prediction across votes\\n average_predictions[obj_i] = average_predictions[obj_i] + \\\\\\n (proj_predictions - average_predictions[obj_i]) / (v + 1)\\n\\n if true_num_test != num_test:\\n logger.warning(\\\"{} using {}/{} data, \\\"\\n \\\"this may be caused by multi-gpu testing\\\".format(split, true_num_test, num_test))\\n vote_preds = average_predictions[:true_num_test]\\n vote_targets = original_labels[:true_num_test]\\n else:\\n vote_preds = average_predictions\\n vote_targets = original_labels\\n\\n msIoU, mpIoU, mmsIoU, mmpIoU = partnet_metrics(dataset.num_classes, dataset.num_parts,\\n vote_objects, vote_preds, vote_targets)\\n logger.info(f'E{epoch} V{v} {split} * mmsIoU {mmsIoU:.3%} mmpIoU {mmpIoU:.3%}')\\n logger.info(f'E{epoch} V{v} {split} * msIoU {msIoU}')\\n logger.info(f'E{epoch} V{v} {split} * mpIoU {mpIoU}')\\n return\",\n \"def score_voting(self, det_bboxes, det_labels, mlvl_bboxes,\\n mlvl_nms_scores, score_thr):\\n candidate_mask = mlvl_nms_scores > score_thr\\n # print(\\\"candidate_mask\\\")\\n # print(candidate_mask)\\n candidate_mask_nozeros = candidate_mask.nonzero()\\n # print(\\\"candidate_mask_nozeros\\\")\\n # print(candidate_mask_nozeros)\\n candidate_inds = candidate_mask_nozeros[:, 0]\\n candidate_labels = candidate_mask_nozeros[:, 1]\\n candidate_bboxes = mlvl_bboxes[candidate_inds]\\n candidate_scores = mlvl_nms_scores[candidate_mask]\\n det_bboxes_voted = []\\n det_labels_voted = []\\n # print(\\\"self.cls_out_channels\\\")\\n # print(self.cls_out_channels)\\n for cls in range(self.cls_out_channels):\\n candidate_cls_mask = candidate_labels == cls\\n if not candidate_cls_mask.any():\\n continue\\n candidate_cls_scores = candidate_scores[candidate_cls_mask]\\n candidate_cls_bboxes = candidate_bboxes[candidate_cls_mask]\\n det_cls_mask = det_labels == cls\\n det_cls_bboxes = det_bboxes[det_cls_mask].view(\\n -1, det_bboxes.size(-1))\\n det_candidate_ious = bbox_overlaps(det_cls_bboxes[:, :4],\\n candidate_cls_bboxes)\\n for det_ind in range(len(det_cls_bboxes)):\\n single_det_ious = det_candidate_ious[det_ind]\\n pos_ious_mask = single_det_ious > 0.01\\n pos_ious = single_det_ious[pos_ious_mask]\\n pos_bboxes = candidate_cls_bboxes[pos_ious_mask]\\n pos_scores = candidate_cls_scores[pos_ious_mask]\\n pis = (torch.exp(-(1 - pos_ious)**2 / 0.025) *\\n pos_scores)[:, None]\\n voted_box = torch.sum(\\n pis * pos_bboxes, dim=0) / torch.sum(\\n pis, dim=0)\\n voted_score = det_cls_bboxes[det_ind][-1:][None, :]\\n det_bboxes_voted.append(\\n torch.cat((voted_box[None, :], voted_score), dim=1))\\n det_labels_voted.append(cls)\\n\\n det_bboxes_voted = torch.cat(det_bboxes_voted, dim=0)\\n det_labels_voted = det_labels.new_tensor(det_labels_voted)\\n return det_bboxes_voted, det_labels_voted\",\n \"def decision_bound(self, test_data):\\n pred = self.w * test_data[:,0] - self.intercept\\n self.ret_label = np.zeros((test_data.shape[0], 1))\\n self.ret_label[test_data[:,1] > pred] = 1\\n self.ret_label[test_data[:,1] <= pred] = 0\\n return (self.ret_label)\",\n \"def give_balanced_classes(reviews, votes, votes_threshold):\\n if votes_threshold <= 0:\\n print \\\"Needs positive threshold\\\"\\n return\\n\\n negative_reviews_indices = []\\n\\n # Find all the funny reviews we can\\n final_reviews = []\\n final_labels = []\\n for i, review in enumerate(reviews):\\n if votes[i] >= votes_threshold:\\n final_reviews.append(review)\\n final_labels.append(1)\\n elif votes[i] == 0:\\n negative_reviews_indices.append(i)\\n\\n # We want balanced classes so take same number\\n np.random.shuffle(negative_reviews_indices)\\n num_positive_reviews = len(final_reviews)\\n for i in range(num_positive_reviews):\\n final_reviews.append(reviews[negative_reviews_indices[i]])\\n final_labels.append(0)\\n\\n # Shuffle final reviews and labels\\n combined_lists = zip(final_reviews, final_labels)\\n np.random.shuffle(combined_lists)\\n final_reviews[:], final_labels[:] = zip(*combined_lists)\\n\\n print \\\"Returning %d positive reviews and a total of %d reviews\\\" % (num_positive_reviews, len(final_reviews))\\n\\n return (final_reviews, final_labels)\",\n \"def label_top_n(self,n,classifier,labels_to_forget=\\\"none\\\"):\\n\\t\\t\\tprint \\\" Pred confs:\\\",\\n\\t\\t\\tlabels = np.ones(self.csr_train_feats.shape[0],int)*-100\\n\\t\\t\\tconfidences = np.ones(self.csr_train_feats.shape[0],int)*-100\\n\\t\\t\\tlabels[self.bool_train_unlabelled],confidences[self.bool_train_unlabelled]\\\\\\n\\t\\t\\t\\t=classifier.predict_labels_and_confidences(self.csr_train_feats[self.bool_train_unlabelled])\\n\\t\\t\\t# print \\\"dtykj labels\\\", labels\\n\\t\\t\\t# print \\\"asfd confidences\\\", confidences\\n\\t\\t\\tprint \\\" Sort & label:\\\",\\n\\t\\t\\tconfidences[self.bool_train_labelled]=-1 #So we don't try to re-label these!\\n\\t\\t\\tdef label_top_k(k,labels,confidences):\\n\\t\\t\\t\\tbool_indices_to_label=confidences.argsort()[-k:]\\n\\t\\t\\t\\tself.train_labels___0_unlab__neg1_exclud[\\\\\\n\\t\\t\\t\\t\\tbool_indices_to_label]=labels[bool_indices_to_label]\\n\\t\\t\\t\\tassert not any(self.bool_train_labelled[bool_indices_to_label])\\n\\t\\t\\t\\tassert all(self.bool_train_unlabelled[bool_indices_to_label])\\n\\t\\t\\t\\tself.bool_train_labelled[bool_indices_to_label]=True\\n\\t\\t\\t\\tself.bool_train_unlabelled[bool_indices_to_label]=False\\n\\t\\t\\t\\tself.num_train_labelled+=k\\n\\t\\t\\t\\tself.num_train_unlabelled-=k\\n\\t\\t\\tif isinstance(n,int):\\n\\t\\t\\t\\tlabel_top_k(n,labels,confidences)\\n\\t\\t\\telif isinstance(n,dict):\\n\\t\\t\\t\\tassert n.keys()==self.set_labels\\n\\t\\t\\t\\tfor label, k in n.iteritems():\\n\\t\\t\\t\\t\\tconf_of_label=confidences*(labels==label)\\n\\t\\t\\t\\t\\tassert set(labels[conf_of_label!=0])=={label}\\n\\t\\t\\t\\t\\tlabel_top_k(k,labels,conf_of_label)\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise TypeError(\\\"Unexpected Type passed to label_top_n. First method argument should be an int or a dictionary\\\")\",\n \"def knn_classify(k, labeled_points, new_point):\\n by_distance = sorted(labeled_points,\\n key=lambda point, _: la.distance(point, new_point))\\n\\n #find the labels for the k clsest\\n k_nearest_labels = [label for _, label in by_distance[:k]]\\n #and ket them vote\\n return majority_vote(k_nearest_labels)\",\n \"def voting(y_pred_test, gnd_te):\\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\\n df.sort_values(by=['y'], inplace=True, ascending=False)\\n out = df.groupby(['gnd']).mean()\\n return len(out[out['y'] > 0])/float(len(out))\",\n \"def getMajorityVote(self, knn_ids):\\n # local bindings\\n _data = self.__data\\n labels = _data.labels\\n\\n # number of occerences for each unique class in kNNs\\n votes = self.__votes_init.copy()\\n for nn in knn_ids:\\n votes[labels[nn]] += 1\\n\\n # find the class with most votes\\n # return votes as well to store them in the state\\n return max(votes.iteritems(), key=lambda x:x[1])[0], \\\\\\n [votes[ul] for ul in _data.uniquelabels] # transform into lists\",\n \"def pick_best_label(self,db,labels,ids):\\n self.type = 'v'\\n if len(labels) > 0:\\n self.value = vote([labels[id] for id in ids])\\n else:\\n self.value = None\\n return\",\n \"def knn(train_data, train_labels, test_data, test_labels, k):\\n pred_labels = []\\n for t in test_data:\\n dist = calculate_distances(train_data, t)\\n pred_class = majority_voting(dist, train_labels, k)\\n pred_labels.append(pred_class)\\n correct_pred_count = np.sum(pred_labels == test_labels)\\n acc = correct_pred_count/len(test_labels)\\n return acc\",\n \"def tally_vote(self, data):\\r\\n if self.user_voted:\\r\\n return {'error': 'Sorry, but you have already voted!'}\\r\\n ans = data['answer']\\r\\n if not self.validate_answer(ans):\\r\\n # Uh oh. Invalid answer.\\r\\n log.exception('Failure in hinter tally_vote: Unable to parse answer: {ans}'.format(ans=ans))\\r\\n return {'error': 'Failure in voting!'}\\r\\n hint_pk = str(data['hint'])\\r\\n # We use temp_dict because we need to do a direct write for the database to update.\\r\\n temp_dict = self.hints\\r\\n try:\\r\\n temp_dict[ans][hint_pk][1] += 1\\r\\n except KeyError:\\r\\n log.exception('''Failure in hinter tally_vote: User voted for non-existant hint:\\r\\n Answer={ans} pk={hint_pk}'''.format(ans=ans, hint_pk=hint_pk))\\r\\n return {'error': 'Failure in voting!'}\\r\\n self.hints = temp_dict\\r\\n # Don't let the user vote again!\\r\\n self.user_voted = True\\r\\n\\r\\n # Return a list of how many votes each hint got.\\r\\n pk_list = json.loads(data['pk_list'])\\r\\n hint_and_votes = []\\r\\n for answer, vote_pk in pk_list:\\r\\n if not self.validate_answer(answer):\\r\\n log.exception('In hinter tally_vote, couldn\\\\'t parse {ans}'.format(ans=answer))\\r\\n continue\\r\\n try:\\r\\n hint_and_votes.append(temp_dict[answer][str(vote_pk)])\\r\\n except KeyError:\\r\\n log.exception('In hinter tally_vote, couldn\\\\'t find: {ans}, {vote_pk}'.format(\\r\\n ans=answer, vote_pk=str(vote_pk)))\\r\\n\\r\\n hint_and_votes.sort(key=lambda pair: pair[1], reverse=True)\\r\\n # Reset self.previous_answers and user_submissions.\\r\\n self.previous_answers = []\\r\\n self.user_submissions = []\\r\\n return {'hint_and_votes': hint_and_votes}\",\n \"def predict_bagging_example(x, h_ens):\\r\\n arr = []\\r\\n for y in h_ens:\\r\\n \\t# calls predict example repeatedly and stores them in an array\\r\\n tst_pred = predict_example(x, h_ens[y][1])\\r\\n arr.append(tst_pred)\\r\\n # returning the maximum voted\\r\\n predict_egz = max(set(arr), key=arr.count)\\r\\n return predict_egz\",\n \"def t(p, vote_count):\\n return vote_count[p]\",\n \"def labelingLVQ(self):\\n numLabels = len(np.unique(self.y))\\n for i, x in enumerate(self.x):\\n w = self.find_closest(x)[0]\\n for nl in range(numLabels):\\n if self.y[i] == nl:\\n self.labels[nl, w[0], w[1]] += 1\\n return self.labels\",\n \"def getWeightedVote(self, knn_ids):\\n # local bindings\\n _data = self.__data\\n uniquelabels = _data.uniquelabels\\n\\n # Lazy evaluation\\n if self.__weights is None:\\n #\\n # It seemed to Yarik that this has to be evaluated just once per\\n # training dataset.\\n #\\n self.__labels = labels = self.__data.labels\\n Nlabels = len(labels)\\n Nuniquelabels = len(uniquelabels)\\n\\n # TODO: To get proper speed up for the next line only,\\n # histogram should be computed\\n # via sorting + counting \\\"same\\\" elements while reducing.\\n # Guaranteed complexity is NlogN whenever now it is N^2\\n # compute the relative proportion of samples belonging to each\\n # class (do it in one loop to improve speed and reduce readability\\n self.__weights = \\\\\\n [ 1.0 - ((labels == label).sum() / Nlabels) \\\\\\n for label in uniquelabels ]\\n self.__weights = dict(zip(uniquelabels, self.__weights))\\n\\n labels = self.__labels\\n # number of occerences for each unique class in kNNs\\n votes = self.__votes_init.copy()\\n for nn in knn_ids:\\n votes[labels[nn]] += 1\\n\\n # weight votes\\n votes = [ self.__weights[ul] * votes[ul] for ul in uniquelabels]\\n\\n # find the class with most votes\\n # return votes as well to store them in the state\\n return uniquelabels[N.asarray(votes).argmax()], \\\\\\n votes\",\n \"def get_n_best(self):\\n pass\",\n \"def classify(self, nn=1):\\n\\t\\t#err=0\\n\\t\\tpossibilities=[]\\n\\t\\tfor i in range(len(self.X_test)):\\n\\t\\t\\tfor lines in range(len((self.X_train))):\\n\\t\\t\\t\\tdist=np.linalg.norm(self.X_test[i]-self.X_train[lines])\\n\\t\\t\\t\\tpossibilities.append([dist,self.Y_train[lines]])\\n\\t\\t\\tpossibilities.sort()\\n\\t\\t\\tfinal=[]\\n\\t\\t\\tfor c in range(0,15):\\n\\t\\t\\t\\tfinal.append(possibilities[c][1])\\n\\t\\t\\t\\tprint possibilities[c][1]\\n\\t\\t\\tcount=np.zeros(10)\\n\\t\\t\\tfor m in final:\\n\\t\\t\\t\\tcount[m]+=1\\n\\t\\t\\t\\n\\t\\t\\tans=np.any(count==count.max())\\n\\t\\t\\t\\n\\t\\t\\tprint \\\"actual=\\\",self.Y_test[i]\\n\\t\\t\\tif(ans!=self.Y_test[i]):\\n\\t\\t\\t\\tglobal err\\n\\t\\t\\t\\terr=err+1\",\n \"def knn_classification(x_test, df_training, attrib_column, k):\\n return majority_vote(k_nearest_neighbors(x_test, df_training,k),df,attrib_column)\",\n \"def knn_predict(p, points, outcomes, k):\\n\\tind = find_nearest_neighbors(p, points, k)\\n\\treturn majority_vote(outcomes[ind])\",\n \"def predict(self, x_vals):\\n if self.vote == 'probability':\\n maj_vote = np.argmax(self.predict_proba(x_vals), axis=1)\\n else:\\n # 'classlabel' vote\\n # Collect results from clf.predict calls\\n predictions = np.asarray([clf.predict(x_vals) for clf in self.classifiers_]).T\\n maj_vote = np.apply_along_axis(lambda x:\\n np.argmax(np.bincount(x, weights=self.weights)),\\n axis=1, arr=predictions)\\n maj_vote = self.lablenc_.inverse_transform(maj_vote)\\n return maj_vote\",\n \"def vis_detections(im, class_name, dets, image_name, thresh=0.5):\\n inds = np.where(dets[:, -1] >= thresh)[0]\\n max_inds = 0\\n max_score = 0.0\\n if len(inds) == 0:\\n # print('Warning: no target detected!')\\n return\\n elif len(inds) > 1:\\n # print('Warning: ' + str(len(inds)) + ' targets detected! Choose the highest one')\\n for i in inds:\\n if(dets[i, -1] > max_score):\\n max_inds = i\\n max_score = dets[i, -1]\\n\\n# im = im[:, :, (2, 1, 0)]\\n# fig, ax = plt.subplots(figsize=(12, 12))\\n# ax.imshow(im, aspect='equal')\\n # for i in inds:\\n # bbox = dets[i, :4]\\n # score = dets[i, -1]\\n #print max_inds\\n bbox = dets[max_inds, :4]\\n score = dets[max_inds, -1]\\n\\n# ax.add_patch(\\n# plt.Rectangle((bbox[0], bbox[1]),\\n# bbox[2] - bbox[0],\\n# bbox[3] - bbox[1], fill=False,\\n# edgecolor='red', linewidth=3.5)\\n# )\\n# ax.text(bbox[0], bbox[1] - 2,\\n# '{:s} {:.3f}'.format(class_name, score),\\n# bbox=dict(facecolor='blue', alpha=0.5),\\n# fontsize=14, color='white')\\n\\n # end for\\n #print image_name, class_name\\n #print score\\n # file.writelines([image_name,'\\\\t',class_name,'\\\\t',str(score),'\\\\n'])\\n # ax.set_title(('{} detections with '\\n # 'p({} | box) >= {:.1f}').format(class_name, class_name,\\n # thresh),fontsize=14)\\n # plt.axis('off')\\n # plt.tight_layout()\\n # plt.draw()\\n\\t### SAVE IMAGES ? ###\\n save_img_dir = os.path.join(cfg.ROOT_DIR, 'result', 'test_img')\\n # if not os.path.exists(save_img_dir):\\n # os.makedirs(save_img_dir)\\n # plt.savefig(os.path.join(save_img_dir, image_name + '_' + class_name))\\n\\n boxes = {'boxes': ((bbox[0], bbox[1]), bbox[2] - bbox[0], bbox[3] - bbox[1])}\\n \\n save_mat_dir = os.path.join(cfg.ROOT_DIR, 'result', 'test_box')\",\n \"def evaluate(labels, predictions):\\n #labels and predictions\\n truePos = 0\\n trueNeg = 0\\n for data in range(len(labels)):\\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\\n truePos+=1\\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\\n trueNeg+=1\\n sensitivity = truePos/(len(labels) + 1)\\n specificity = trueNeg/(len(labels) + 1)\\n return (sensitivity, specificity)\\n \\n\\n #raise NotImplementedError\",\n \"def heuristic2B_label_OBD(n, P, label, critical=None):\\n nodes_labeled = []\\n\\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\\n new_label = label + 1\\n \\n neighbors = P.neighbors(n)\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys(): # if it has a label\\n if P.node[neigh]['OBDlabel'] > new_label: # and it is higher than what I would use for labeling\\n new_label = P.node[neigh]['OBDlabel']\\n # we got maximum of current label or any node that neighbors have - now we label them all with that\\n \\n neighbors_to_label = []\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\\n neighbors_to_label.append(neigh)\\n else: # if set and smaller than mine, leave them alone\\n pass\\n else: # if not set, then not lower and not labelled\\n neighbors_to_label.append(neigh)\\n # now we have all the neighbors that need to be labeled\\n \\n if len(neighbors_to_label) > 1:\\n flag_critical = True\\n # and now labeling all these nodes\\n \\n for neigh in neighbors_to_label:\\n if ('critical' in P.node[neigh].keys()) and (P.node[neigh]['critical']==True) and (P.node[neigh]['OBDlabel'] != new_label) :\\n return (False, nodes_labeled) # being critical, we could avoid failure only if the label to set would be the same (it happens)\\n else:\\n P.node[neigh]['OBDlabel'] = new_label\\n nodes_labeled.append(neigh) # this is a list that gets passed through recursions\\n if flag_critical == True:\\n P.node[neigh]['critical'] = True\\n # labeling part done\\n \\n # and now recursive step - going into each neighbor to continue, in any order if necessary\\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\\n for perm in permutations:\\n this_run_success = True\\n this_run_labeled = []\\n for el in perm:\\n (s, nl) = heuristic2B_label_OBD(el, P, new_label, flag_critical)\\n this_run_labeled = this_run_labeled + nl\\n if s == False:\\n this_run_success = False\\n if this_run_success == False:\\n # then unlabel all that were labelled up to now\\n for nn in this_run_labeled:\\n P.node[nn]['OBDlabel'] = None\\n P.node[nn]['critical'] = False\\n else: # obviously success is True, we managed to label all others...\\n nodes_labeled = nodes_labeled + this_run_labeled\\n return (True, nodes_labeled)\\n break\\n # if no permutation is successful, we end up returning the last line\\n return (False, nodes_labeled)\",\n \"def find_response(self, neighbors):\\n counts = defaultdict(int)\\n for neighbor in neighbors:\\n counts[neighbor] += 1 # last item in list is the predicted value\\n response = max(counts.items())[0]\\n return response\",\n \"def predict(self, test_data):\\n count = 0.0\\n for testcase in test_data:\\n answer = np.argmax(testcase[1])\\n prediction = np.argmax(self.feed_forward(testcase[0]))\\n count = count + 1 if (answer - prediction) == 0 else count\\n return count\",\n \"def predict_labels(self, distances, k=1):\\n\\n num_test = distances.shape[0]\\n Y_pred = np.zeros((num_test,))\\n\\n \\n for i in range(num_test):\\n # extracting k-nearest-neighbors for each test-point\\n kNN_idxs = np.argsort(distances[i,:])[0:k]\\n \\n # voting among the k-nearest-neighbors\\n kNN_labels = {}\\n # print(type(kNN_labels))\\n\\n for j in range(k):\\n m_label = self.Y_train[kNN_idxs[j]]\\n if m_label in kNN_labels.keys():\\n # print(type(kNN_labels))\\n kNN_labels[m_label] += 1 # increment count\\n else:\\n # print(m_label,'....', type(kNN_labels))\\n kNN_labels[m_label] = 1 # initial count when the label occurs\\n \\n # counting the winning label\\n\\n winning_label = kNN_labels.keys()[0] # initialization\\n \\n for label in kNN_labels.keys():\\n if kNN_labels[label] > kNN_labels[winning_label]:\\n winning_label = label\\n elif kNN_labels[label] == kNN_labels[winning_label]:\\n # tie breaker\\n if label < winning_label:\\n winning_label = label\\n \\n\\n Y_pred[i] = winning_label # storing winning label for each test-point\\n \\n return Y_pred\",\n \"def classify(self, features):\\n\\n # TODO: finish this.\\n class_labels = []\\n # TODO: finish this.\\n features = np.array(features)\\n feat_shape = features.shape\\n for i in range(feat_shape[0]):\\n vote = np.zeros((self.num_trees))\\n for j in range(self.num_trees):\\n #print self.trees[j].classify(feat)\\n vote[j] = self.trees[j].classify(features[i,self.attr_track[j]].reshape(1,-1))[0]\\n counts = np.bincount(vote.astype(int))\\n class_labels.append(np.argmax(counts))\\n return class_labels\",\n \"def naive_bayes_classify(df: pd.DataFrame, vect, names):\\n features = vect\\n target = df.success_lvl\\n\\n X_train, X_test, y_train, y_test = \\\\\\n train_test_split(features, target, test_size=0.2, random_state=42)\\n\\n nb_clf = MultinomialNB()\\n nb_clf.fit(X_train, y_train)\\n nb_predictions = nb_clf.predict(X_test)\\n print('Accuracy score for Naive Bayes:', accuracy_score(y_test, nb_predictions))\\n\\n\\n # Find Top/Bottom num of terms used to describe the classes.\\n num = 10\\n low_class_prob_sorted = nb_clf.feature_log_prob_[0, :].argsort()[::-1]\\n hi_class_prob_sorted = nb_clf.feature_log_prob_[1, :].argsort()[::-1]\\n print('\\\\n', f'Low score Top{num} phrases:', np.take(names, low_class_prob_sorted[:num]))\\n print('\\\\n', f'Low score Bot{num} phrases:', np.take(names, low_class_prob_sorted[-num:]))\\n print('\\\\n', f'High score Top{num} phrases:', np.take(names, hi_class_prob_sorted[:num]))\\n print('\\\\n', f'High score Bot{num} phrases:', np.take(names, hi_class_prob_sorted[-num:]))\",\n \"def predict(self, X):\\n predictions = [c.predict(X) for c in self.classifiers]\\n votes = np.zeros((len(X),self.label_count), dtype='i8')\\n for row in xrange(len(X)):\\n for model in xrange(self.model_count):\\n for label in xrange(len(self.label_sets[model])):\\n votes[row,self.label_sets[model][label]] += predictions[model][row][label]\\n\\n voters = np.zeros(self.label_count, dtype='i8')\\n for label_set in self.label_sets:\\n voters[label_set] += 1\\n\\n for row in xrange(len(X)):\\n for label in xrange(self.label_count):\\n votes[row, label] = int(float(votes[row, label]) / float(voters[label]) > 0.5)\\n\\n return votes\",\n \"def pred_dset_bin_vote(fx_output, dset, fold_set):\\n labels = []\\n for i,y in dset.split_idx[fold_set]:\\n x,yi = dset.get(i)\\n assert yi==y\\n p = fx_output(dset.reshape_batch(x))\\n y_pred = np.bincount(p.argmax(axis=1)).argmax()\\n labels += [(y, y_pred)]\\n \\n return np.asarray(labels)\",\n \"def getPredictions(self):\\n\\t\\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)\",\n \"def classify(self, data):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def majority_vote():\\n iris = datasets.load_iris()\\n x_vals, y_vals = iris.data[50:, [1, 2]], iris.target[50:]\\n labenc = LabelEncoder()\\n y_vals = labenc.fit_transform(y_vals)\\n x_train, x_test, y_train, y_test = train_test_split(x_vals, y_vals,\\n test_size=0.5, random_state=1)\\n\\n clf1 = LogisticRegression(penalty='l2', C=0.001, random_state=0)\\n clf2 = DecisionTreeClassifier(max_depth=1, criterion='entropy', random_state=0)\\n clf3 = KNeighborsClassifier(n_neighbors=1, p=2, metric='minkowski')\\n pipe1 = Pipeline([['sc', StandardScaler()], ['clf', clf1]])\\n pipe3 = Pipeline([['sc', StandardScaler()], ['clf', clf3]])\\n clf_labels = ['Logistic Regression', 'Decision Tree', 'KNN']\\n\\n # Majority Rule (hard) Voting\\n mv_clf = MajorityVoteClassifier(classifiers=[pipe1, clf2, pipe3])\\n\\n clf_labels += ['Majority Voting']\\n all_clf = [pipe1, clf2, pipe3, mv_clf]\\n print('10-fold cross validation:\\\\n')\\n for clf, label in zip(all_clf, clf_labels):\\n scores = cross_val_score(estimator=clf, X=x_train, y=y_train, cv=10, scoring='roc_auc')\\n print(\\\"ROC AUC: %0.2f (+/- %0.2f) [%s]\\\" % (scores.mean(), scores.std(), label))\\n\\n colors = ['black', 'orange', 'blue', 'green']\\n linestyles = [':', '--', '-.', '-']\\n for clf, label, clr, lin_style in zip(all_clf, clf_labels, colors, linestyles):\\n # assuming the label of the positive class is 1\\n y_pred = clf.fit(x_train, y_train).predict_proba(x_test)[:, 1]\\n fpr, tpr, _ = roc_curve(y_true=y_test, y_score=y_pred)\\n print(y_pred)\\n roc_auc = auc(x=fpr, y=tpr)\\n plt.plot(fpr, tpr, color=clr, linestyle=lin_style,\\n label='%s (auc = %0.2f)' % (label, roc_auc))\\n\\n plt.legend(loc='lower right')\\n plt.plot([0, 1], [0, 1], linestyle='--', color='gray', linewidth=2)\\n\\n plt.xlim([-0.1, 1.1])\\n plt.ylim([-0.1, 1.1])\\n plt.grid()\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.tight_layout()\\n plt.savefig(IMG_PATH + 'roc.png', dpi=300)\\n plt.close()\\n\\n stdc = StandardScaler()\\n x_train_std = stdc.fit_transform(x_train)\\n all_clf = [pipe1, clf2, pipe3, mv_clf]\\n x_min = x_train_std[:, 0].min() - 1\\n x_max = x_train_std[:, 0].max() + 1\\n y_min = x_train_std[:, 1].min() - 1\\n y_max = x_train_std[:, 1].max() + 1\\n xxx, yyy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))\\n _, axarr = plt.subplots(nrows=2, ncols=2, sharex='col', sharey='row', figsize=(7, 5))\\n for idx, clf, ttt in zip(product([0, 1], [0, 1]), all_clf, clf_labels):\\n clf.fit(x_train_std, y_train)\\n z_vals = clf.predict(np.c_[xxx.ravel(), yyy.ravel()])\\n z_vals = z_vals.reshape(xxx.shape)\\n axarr[idx[0], idx[1]].contourf(xxx, yyy, z_vals, alpha=0.3)\\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 0, 0], x_train_std[y_train == 0, 1],\\n c='blue', marker='^', s=50)\\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 1, 0], x_train_std[y_train == 1, 1],\\n c='red', marker='o', s=50)\\n axarr[idx[0], idx[1]].set_title(ttt)\\n plt.text(-3.5, -4.5, s='Sepal width [standardized]', ha='center', va='center', fontsize=12)\\n plt.text(-10.5, 4.5, s='Petal length [standardized]', ha='center', va='center',\\n fontsize=12, rotation=90)\\n plt.tight_layout()\\n plt.savefig(IMG_PATH + 'voting_panel.png', bbox_inches='tight', dpi=300)\\n # print(mv_clf.get_params())\\n params = {'decisiontreeclassifier__max_depth': [1, 2],\\n 'pipeline-1__clf__C': [0.001, 0.1, 100.0]}\\n grid = GridSearchCV(estimator=mv_clf, param_grid=params, cv=10, scoring='roc_auc')\\n grid.fit(x_train, y_train)\\n\\n for params, mean_score, scores in grid.cv_results_:\\n print(\\\"%0.3f+/-%0.2f %r\\\" % (mean_score, scores.std() / 2, params))\\n print('Best parameters: %s' % grid.best_params_)\\n print('Accuracy: %.2f' % grid.best_score_)\",\n \"def majority_vote(c_pred,m_pred,f_pred,dataset):\\n c,m,f = np.argmax(c_pred),np.argmax(m_pred),np.argmax(f_pred)\\n coarse = np.zeros(2)\\n middle = np.zeros(4)\\n fine = np.zeros(10)\\n if dataset == 'cifar10':\\n middle = np.zeros(5)\\n coarse[c] = 1\\n middle[m] = 1\\n fine[f] = 1\\n res = np.zeros(10)\\n if dataset == 'cifar10':\\n for i in range(10):\\n if i <2:\\n res[i] = coarse[0] + middle[0] + fine[i]\\n elif 2<=i <4:\\n res[i] = coarse[0] + middle[1] + fine[i]\\n elif 4 <=i<6:\\n res[i] = coarse[1] + middle[2] + fine[i]\\n elif 6<=i<8:\\n res[i] = coarse[1] + middle[3] + fine[i]\\n else:\\n res[i] = coarse[1] + middle[4] + fine[i]\\n else :\\n for i in range(10):\\n if i <3:\\n res[i] = coarse[0] + middle[0] + fine[i]\\n elif 3<=i <5:\\n res[i] = coarse[0] + middle[1] + fine[i]\\n elif 5 <=i<8:\\n res[i] = coarse[1] + middle[2] + fine[i]\\n else:\\n res[i] = coarse[1] + middle[3] + fine[i]\\n index = np.argmax(res)\\n return(index)\",\n \"def rank_candidates(table):\\n ranking = []\\n\\n # get list of all candidates who received a vote\\n full_list = elim_dupe([name for vote in table for name in vote])\\n # print full_list\\n \\n while len(ranking) < len(full_list):\\n \\n # All unranked candidates are considered eligible\\n eligible = [name for name in full_list if name not in ranking]\\n \\n while True:\\n \\n # Remove ineligible and eliminated candidates from votes\\n temp_ballots = [[name for name in vote if name in eligible] for vote in table]\\n \\n # If no candidates on the ballot are eligible and the ballot does not have\\n # \\\"no confidence\\\" written on it, the ballot is discarded and not considered a vote.\\n temp_ballots = [vote for vote in temp_ballots if len(vote) > 0]\\n\\n total_votes = len(temp_ballots)\\n\\n if total_votes == 0:\\n return ranking\\n\\n top_choices = [vote[0] for vote in temp_ballots]\\n \\n # All ballots are considered to be a vote for the\\n # highest-ranked eligible candidate on the ballot.\\n vote_count = {name: top_choices.count(name) for name in eligible}\\n print vote_count\\n winner = [k for k in vote_count if (vote_count[k]*2) > total_votes]\\n\\n if len(winner) > 0:\\n # If a single candidate has a majority of the\\n # votes, they receive the next highest ranking\\n if winner[0] == NO_CONFIDENCE:\\n return ranking\\n \\n ranking += winner\\n \\n break;\\n\\n vote_count.pop(NO_CONFIDENCE, None)\\n\\n # If no single candidate has a majority of the votes,\\n # then one will be deemed ineligible.\\n\\n min_votes = vote_count[min(vote_count, key=vote_count.get)]\\n \\n least_voted = {k:vote_count[k] for k in vote_count if vote_count[k] == min_votes}\\n \\n # If a single candidate has the least amount of votes, they become ineligible,\\n while len(least_voted) > 1:\\n temp_ballots = [vote[1:] for vote in temp_ballots if len(vote[1:]) > 0]\\n if len(temp_ballots) == 0:\\n return ranking\\n next_choices = [vote[0] for vote in temp_ballots if vote[0] in least_voted]\\n least_voted = {name: (next_choices.count(name) + least_voted[name]) for name in least_voted}\\n min_votes = least_voted[min(least_voted, key=least_voted.get)]\\n least_voted = {k: least_voted[k] for k in least_voted if least_voted[k] == min_votes}\\n \\n remove = least_voted.keys()[0]\\n eligible = [name for name in eligible if name != remove]\\n\\n\\n return ranking\",\n \"def test_score(self, n_neighbors, weights):\\n _check_knn_score(\\n KNeighborsLabelRanker(n_neighbors, weights), self.X, self.Y)\",\n \"def knn(trainingSetData, testSetData, k):\\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\\n testSet = testSetData.drop([14], axis=1) # drop income\\n\\n distances = {}\\n # this will store the distances re-sorted in ascending/descending order\\n sort = {}\\n # income band results (>=50k or <50K)\\n incomePredictions = []\\n\\n # Calculating euclidean distance between each row of training data and test data instance\\n for testInstance in range(len(testSet)): # len(testSet)\\n \\n # Store current test Point:\\n testInstance = testSet.iloc[testInstance] \\n \\n distances = euclideanDistanceRow(testInstance, trainingSet)\\n\\n # sort the distances in order of smallest first:\\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\\n\\n neighbors = []\\n\\n # Extracting top k neighbors\\n for x in range(k):\\n neighbors.append(sorted_d[x])\\n\\n\\n classVotes = {}\\n\\n # Calculating the most freq class in the neighbors\\n results = {\\\"lessThan50\\\": 0, \\\"moreThan50\\\": 0}\\n\\n # creating a dataframe to which we will add the income values:\\n\\n for x in range(len(neighbors)):\\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\\n results[\\\"lessThan50\\\"] += 1\\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\\n results[\\\"moreThan50\\\"] += 1\\n\\n print('results',results)\\n\\n if (results[\\\"lessThan50\\\"] > results[\\\"moreThan50\\\"]):\\n incomePredictions.append(0.0)\\n elif (results[\\\"lessThan50\\\"] < results[\\\"moreThan50\\\"]):\\n incomePredictions.append(1.0)\\n\\n return incomePredictions\",\n \"def test_score(self, n_neighbors, weights):\\n _check_knn_score(\\n KNeighborsPartialLabelRanker(n_neighbors, weights), self.X, self.Y)\",\n \"def classify(self, data ):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def heuristic2_label_OBD(n, P, label, critical=None):\\n print \\\"trying to label \\\" + str(n) + \\\" with \\\" + str(label)\\n nodes_labeled = []\\n if ('critical' in P.node[n].keys()) and (P.node[n]['critical']==True) and (P.node[n]['OBDlabel'] != label) :\\n print \\\"FAIL on critical and not the same label.\\\"\\n return (False, []) # being critical, we could avoid failure only if the label to set would be the same (it happens)\\n else:\\n P.node[n]['OBDlabel'] = label\\n nodes_labeled.append(n) # this is a list that gets passed through recursions\\n if critical == True:\\n P.node[n]['critical'] = True\\n # labeling part done\\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\\n new_label = label + 1\\n neighbors = P.neighbors(n)\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if P.node[neigh]['OBDlabel'] > new_label:\\n new_label = P.node[neigh]['OBDlabel']\\n # we got maximum of current label or any node that neighbors have - now we label them all with that\\n neighbors_to_label = []\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\\n neighbors_to_label.append(neigh)\\n else: # if set and smaller than mine, leave them alone\\n pass\\n else: # if not set, then not lower and not labelled\\n neighbors_to_label.append(neigh)\\n # now we have all the neighbors that need to be labeled\\n if len(neighbors_to_label) > 1:\\n flag_critical = True\\n # and now the recursive step - labeling all these nodes\\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\\n for perm in permutations:\\n print \\\"trying perm: \\\" + str(perm)\\n this_run_success = True\\n this_run_labeled = []\\n for el in perm:\\n (s, nl) = heuristic2_label_OBD(el, P, new_label, flag_critical)\\n this_run_labeled = this_run_labeled + nl\\n if s == False:\\n this_run_success = False\\n break\\n if this_run_success == False:\\n # then unlabel all that were labelled up to now\\n for nn in this_run_labeled:\\n print \\\"removing label of \\\" + str(nn)\\n P.node[nn]['OBDlabel'] = None\\n P.node[nn]['critical'] = False\\n else: # obviously success is True, we managed to label all others...\\n nodes_labeled = nodes_labeled + this_run_labeled\\n print \\\"Win in labeling neighbors of \\\" + str(n)\\n return (True, nodes_labeled)\\n break\\n # if no permutation is successful, we end up returning the last line\\n return (False, nodes_labeled)\\n print \\\"FAIL of all permutations from \\\" + str(n)\",\n \"def ovo_test(dic, x_test, y_test, nb_classes):\\n TP = FP = TN = FN = 0\\n correct_predict = 0\\n for index, value in enumerate(x_test):\\n predict = {elem : 0 for elem in nb_classes}\\n for key in dic:\\n predict[key[0] if dic[key].predict([value]) else key[1]] += 1\\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\\n if predicted_value == y_test[index]:\\n correct_predict += 1\\n TP += 1\\n else:\\n FP += 1\\n \\n return correct_predict, TP, FP, TN, FN\",\n \"def propagateLabel(self, l1, l2):\\n\\n if l1 != l2:\\n winner = min(l1, l2)\\n loser = max(l1, l2)\\n loserN = 0\\n superiorN = 0\\n for i,l in enumerate(self.labels):\\n if l == loser:\\n loserN += 1\\n self.labels[i] = winner\\n if l > loser:\\n superiorN += 1\\n self.labels[i] = l - 1\\n\\n # print('Loser Label is ' + str(loser) + ' . With ' + str(loserN) + ' associated cells. Winner label is ' + str(winner))\",\n \"def evaluate(labels, predictions):\\n positive_count = 0\\n positive = 0\\n negative_count = 0\\n negative = 0\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n positive_count+=1\\n if predictions[i] == 1:\\n positive +=1\\n else:\\n negative_count+=1\\n if predictions[i] == 0:\\n negative +=1\\n\\n sensitivity = positive / positive_count\\n specificity = negative / negative_count\\n\\n return (sensitivity, specificity)\",\n \"def evaluate(labels, predictions):\\n\\n truePositiveCounter = 0\\n trueNegativeCounter = 0\\n truePositiveCorrect = 0\\n trueNegativeCorrect = 0\\n \\n sensitivity = 0\\n specificity = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n truePositiveCounter += 1\\n if(labels[i] == predictions[i]):\\n truePositiveCorrect += 1\\n elif labels[i] == 0:\\n trueNegativeCounter += 1\\n if(labels[i] == predictions[i]):\\n trueNegativeCorrect += 1\\n\\n sensitivity = truePositiveCorrect / truePositiveCounter\\n specificity = trueNegativeCorrect / trueNegativeCounter\\n\\n return sensitivity, specificity\",\n \"def decision_tree_prediction(example, root, attributes):\\n # If reached a leaf node, return the label\\n if isinstance(root, str):\\n return root\\n\\n # Attribute that was split on\\n attribute = root.attribute\\n # Column of the attribute that was split on\\n i = get_index(attribute, attributes)\\n testValue = example[i]\\n # Check every child to see what path the example must take in the decision tree\\n for child in root.children:\\n if isinstance(child.branch, int):\\n if int(testValue) <= child.branch:\\n return decision_tree_prediction(example, child.nextTree, attributes)\\n elif isinstance(child.branch, float):\\n if int(testValue) > child.branch:\\n return decision_tree_prediction(example, child.nextTree, attributes)\\n# -----------------------------------------------Naive Bayes-------------------------------------------------\\n # Naive bayes\\n elif child.branch == \\\"Naive\\\":\\n yes_probability = child.histogram[0]\\n no_probability = child.histogram[2]\\n i = 0\\n for feature in example:\\n if feature == \\\"yes\\\" or feature == \\\"no\\\":\\n continue\\n if i == 0 or i == 2 or i == 4 or i == 10 or i == 11 or i == 12:\\n j = 0\\n # Its a float so check\\n for key in child.histogram[1][attribute_index[i]]:\\n if float(feature) <= float(key) and j == 0:\\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][key]\\n elif j == 1:\\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][key]\\n j += 1\\n for key in child.histogram[1][attribute_index[i]]:\\n if float(feature) <= float(key) and j == 0:\\n no_probability = no_probability * child.histogram[1][attribute_index[i]][key]\\n elif j == 1:\\n no_probability = no_probability * child.histogram[1][attribute_index[i]][key]\\n j += 1\\n else:\\n yes_probability = yes_probability * child.histogram[1][attribute_index[i]][feature]\\n no_probability = no_probability * child.histogram[3][attribute_index[i]][feature]\\n i += 1\\n if yes_probability > no_probability:\\n return \\\"yes\\\"\\n elif no_probability >= yes_probability:\\n return \\\"no\\\"\\n# -----------------------------------------------End Naive Bayes-------------------------------------------------\\n else:\\n if child.branch == testValue:\\n return decision_tree_prediction(example, child.nextTree, attributes)\",\n \"def classify(self, data):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum + self.bias[l]\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def choose_one(self,labels) :\\n # Exercise 1: Reduce k until you find a unique winner\\n counts = Counter(labels)\\n winner, winner_count = counts.most_common(1)[0]\\n num_winners = len([count for count in counts.values() if count == winner_count])\\n # replace&complete: The winning label has to be found and returned\\n if num_winners == 1:\\n return winner\\n else:\\n return self.choose_one(labels[:-1])\",\n \"def majority_vote(votes):\\n vote_counts = {}\\n for vote in votes:\\n if vote in vote_counts:\\n vote_counts[vote] += 1\\n else:\\n vote_counts[vote] = 1\\n\\n winners = []\\n max_choice = max(vote_counts.values())\\n for vote, count in vote_counts.items():\\n if count == max_choice:\\n winners.append(vote)\\n \\n import random\\n return(random.choice(winners))\",\n \"def get_best_thresholds(labels, test_y, outputs, plot=False):\\n t_max = [0] * len(labels)\\n f_max = [0] * len(labels)\\n\\n for i, label in enumerate(labels):\\n ts = []\\n fs = []\\n\\n for t in np.linspace(0.1, 0.99, num=50):\\n p, r, f, _ = precision_recall_fscore_support(test_y[:,i], np.where(outputs[:,i]>t, 1, 0), average='micro')\\n ts.append(t)\\n fs.append(f)\\n if f > f_max[i]:\\n f_max[i] = f\\n t_max[i] = t\\n\\n if plot:\\n print(f'LABEL: {label}')\\n print(f'f_max: {f_max[i]}')\\n print(f't_max: {t_max[i]}')\\n\\n plt.scatter(ts, fs)\\n plt.show()\\n \\n return t_max, f_max\",\n \"def classify(self, instance):\\n \\\"\\\"\\\"best stores the pointer to the sequence with maximum final probability from the Viterbi trellis.\\n Iterate through the corresponding row in the backtrace_pointers matrix backwards and add its labels to best_sequence list.\\n Return the reversed best_sequence list.\\n \\\"\\\"\\\"\\n backtrace_pointers = self.dynamic_programming_on_trellis(instance, False)\\n best_sequence = []\\n trellis = backtrace_pointers[0]\\n best = trellis[:,len(instance.data)-1].argmax()\\n i = best\\n best_sequence = [self.labels[best]]\\n for j in xrange(len(instance.data)-1, 0, -1):\\n i = backtrace_pointers[1][i][j]\\n best_sequence.append(self.labels[i])\\n return best_sequence[::-1]\",\n \"def ranked_accuracy(predictions, labels):\\n rank1 = 0\\n rank5 = 0\\n\\n for (pred, lbl) in zip(predictions, labels):\\n pred = np.argsort(pred)[::-1]\\n\\n if lbl in pred[:5]:\\n rank5+=1\\n\\n if lbl == pred[0]:\\n rank1+=1\\n\\n rank1 /= float(len(labels))\\n rank5 /= float(len(labels))\\n\\n return (rank1, rank5)\",\n \"def __count_errors(node, testSet, res):\\n training_results = __get_results(node) #Get a dictionary of labels and counts for the *training* data which made it to this node\\n leaf_label = None #Initialize a label for this leaf\\n majority_count = 0 #Initialize a variable to track the number of observations for the label with the most observations\\n #Note that the steps below do not handle ties of the majority count in a nice way.\\n for label, count in training_results.items(): #iterate through each pair of labels and counts from the training set\\n if count > majority_count: #find the label with the highest count\\n leaf_label = label #the label for the leaf is the label with the highest count\\n majority_count = count #keep track of the count for the leaf_label\\n \\n wrong_labels = testSet[res].unique().tolist() #initialize wrong_labels to be all labels in the testSet\\n if leaf_label in wrong_labels: #If the leaf label is in the list of labels for the part of the test set that got to this node\\n wrong_labels.remove(leaf_label) #remove the leaf_label so that all which remains are incorrect labels\\n \\n wrong_count = 0 #Initialize a count of how many testSet observations will be classified incorrectly\\n testCounts = testSet.groupby(res).size() #Get a series of the testSet labels and how many observations pertain to each label\\n for label in wrong_labels: #Iterate over all the labels not equal to the leaf_label\\n wrong_count += testCounts[label] #Sum up all of the observations with a label not equal to the leaf_label\\n return wrong_count\",\n \"def pick_largest(self, cut_off):\\r\\n for i in range(self.dimension):\\r\\n m = self.masked[int(self.rank_yx(self.rank[i])[0]) # locating the corresponding mark array\\r\\n ,int(self.rank_yx(self.rank[i])[1])]\\r\\n if m * self.image_data[i] == self.image_data[i]:\\r\\n if self.image_data[i] <= cut_off:\\r\\n print(\\\"Surveying completed\\\")\\r\\n return -1,-1 # returns -1,-1 if scan is completed\\r\\n else:\\r\\n return self.image_data[i], np.array(self.rank[i])\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def most_discriminating( features_df, labels_df, top=5):\\n \\n columns = features_df.shape[1]\\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\\n qualities = np.zeros(columns)\\n \\n _left = 0\\n _right = 1\\n\\n _c = 0\\n _h = 1\\n\\n # globals\\n cases = float(labels_df['candy_id'].count()) # total cases\\n\\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\\n p_h_A = 1.0 - p_c_A\\n\\n\\n for feature in range(columns):\\n\\n branch_cases = np.zeros(2) # total on each branch\\n pi = np.zeros(2) # proportion on each branch\\n\\n split = np.array([\\n #c, h\\n [0, 0], #left\\n [0, 0] #right\\n ])\\n\\n for index, value in features_df[feature].iteritems():\\n split[value][labels_df.loc[index][0]] += 1\\n\\n branch_cases[_left] = split[_left].sum()\\n branch_cases[_right] = split[_right].sum()\\n \\n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\\n qualities[feature] = 0\\n continue\\n \\n pi[_left] = branch_cases[_left] / cases\\n pi[_right] = branch_cases[_right] / cases\\n\\n p_c_B = split[_left][_c] / branch_cases[_left]\\n p_h_B = split[_left][_h] / branch_cases[_left]\\n\\n p_c_C = split[_right][_c] / branch_cases[_right]\\n p_h_C = split[_right][_h] / branch_cases[_right]\\n\\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\\n\\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\\n\\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\\n\\n qualities[feature] = quality\\n return list(reversed(qualities.argsort()))[:top]\",\n \"def compare_result(res, label):\\n infer_res = []\\n infer_conf = []\\n gt_conf = []\\n size = len(label)\\n for i in range(size):\\n infer_res.append(np.where(res[i] == np.max(res[i]))[3][0])\\n infer_conf.append(res[i][0][0][0][infer_res[i]])\\n gt_conf.append(res[i][0][0][0][label[i]])\\n return infer_res, infer_conf, gt_conf\",\n \"def majority_vote(votes):\\n\\n vote_counts = {} # dictionary\\n for vote in votes:\\n # known word\\n if vote in vote_counts:\\n vote_counts[vote] += 1\\n # unknown word\\n else:\\n vote_counts[vote] = 1\\n\\n print(vote_counts)\\n # but who is the winner?\\n winners = []\\n max_votes = max(vote_counts.values())\\n\\n # for (,) this is a tuple\\n for vote, count in vote_counts.items():\\n if count == max_votes:\\n winners.append(vote)\\n\\n # what is we have multiply winners? Well we select one randomly\\n\\n return random.choice(winners)\",\n \"def predict(self, input: ByteTensor) -> IntTensor:\\n clause_outputs = self.evaluate_clauses(input)\\n class_votes = self.sum_up_class_votes(clause_outputs)\\n _, index = class_votes.max(0)\\n return index\",\n \"def evaluate(labels, predictions):\\n TP = 0\\n actualP = 0\\n TN = 0\\n actualN = 0\\n for label, prediction in zip(labels, predictions):\\n if label ==1:\\n actualP +=1\\n if prediction == 1:\\n TP +=1\\n else:\\n actualN +=1\\n if prediction ==0:\\n TN +=1\\n \\n sensitivity = float(TP/actualP)\\n specificity = float(TN/actualN)\\n return (sensitivity, specificity)\",\n \"def predictClass(training_data, test_row, k):\\n\\n neighbors = getNeighbors(training_data, test_row, k)\\n output_vals = [row[-1] for row in neighbors]\\n \\n counts = dict()\\n\\n for i in output_vals:\\n counts[i] = counts.get(i, 0) + 1\\n\\n v = [value for value in counts.values()]\\n\\n #Pick a class on random if ties occur\\n prediction = choice([key for key in counts if counts[key] == max(v)])\\n\\n return prediction\",\n \"def detection(test_img):\\n # TODO: Step 2 : Your Detection code should go here.\\n no_row = len(test_img)\\n no_col = len(test_img[0])\\n thresh = 100\\n label_img = np.zeros((no_row, no_col))\\n uf = []\\n \\n #first pass\\n l = 1\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if test_img[i,j] < 255 - thresh:\\n if i == 0 and j == 0:\\n label_img[i,j] = l\\n l = l+1\\n elif i == 0 and j != 0:\\n if label_img[i,j-1] == 0:\\n label_img[i,j] = l\\n l = l+1\\n else:\\n label_img[i,j] = label_img[i,j-1]\\n elif i != 0 and j == 0:\\n if label_img[i-1,j] == 0:\\n label_img[i,j] = l\\n l = l+1\\n else:\\n label_img[i,j] = label_img[i-1,j]\\n else:\\n if label_img[i-1,j] == 0 and label_img[i,j-1] == 0:\\n label_img[i,j] = l\\n l = l+1\\n elif label_img[i-1,j] == 0 and label_img[i,j-1] != 0:\\n label_img[i,j] = label_img[i,j-1]\\n elif label_img[i-1,j] != 0 and label_img[i,j-1] == 0:\\n label_img[i,j] = label_img[i-1,j]\\n else:\\n if label_img[i,j-1] == label_img[i-1,j]:\\n label_img[i,j] = label_img[i,j-1]\\n else:\\n label_img[i,j] = min(label_img[i-1,j],label_img[i,j-1])\\n uf.append([min(label_img[i,j-1],label_img[i-1,j]),max(label_img[i,j-1],label_img[i-1,j])])\\n l = l - 1\\n \\n #2nd pass\\n def ufds(x,l):\\n b = []\\n for i in range(1,l+1):\\n b.append([i])\\n for j in x:\\n i1 = 0\\n i2 = 0\\n for k in range(0,len(b)):\\n if j[0] in b[k]:\\n i1 = k\\n if j[1] in b[k]:\\n i2 = k\\n if i1 != i2:\\n b[i1] = b[i1] + b[i2]\\n del b[i2]\\n return b\\n \\n bman = ufds(uf,l)\\n \\n #3rd pass\\n uf_arr = np.zeros(l)\\n for i in range(0,len(uf_arr)):\\n for j in bman:\\n if i+1 in j:\\n uf_arr[i] = min(j) \\n \\n fin_img = np.zeros((no_row, no_col))\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if label_img[i,j] != 0:\\n fin_img[i,j] = uf_arr[int(label_img[i,j] - 1)]\\n \\n all_label = []\\n '''\\n for i in bman:\\n all_label.append(min(i))\\n ''' \\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if fin_img[i,j] !=0 and fin_img[i,j] not in all_label:\\n all_label.append(fin_img[i,j])\\n \\n # main image\\n k_img = np.zeros((no_row, no_col))\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if fin_img[i,j] != 0:\\n k_img[i,j] = (all_label.index(fin_img[i,j]) + 1)\\n \\n k_list = []\\n for i in range(1,len(all_label)+1):\\n x = None\\n y = None\\n hx = None\\n hy = None\\n for j in range(0,no_row):\\n for k in range(0,no_col):\\n if k_img[j,k] == i:\\n if y == None and x == None:\\n y = j\\n hy = j\\n x = k\\n hx = k\\n else:\\n if y > j:\\n y = j\\n if hy < j:\\n hy = j\\n if x > k:\\n x = k\\n if hx < k:\\n hx = k\\n k_list.append({\\\"bbox\\\": [x, y, hx-x, hy-y]})\\n \\n return k_list\\n \\n #raise NotImplementedError\",\n \"def classify(self, data ):\\n\\t\\tguesses = []\\n\\t\\tfor datum in data:\\n\\t\\t\\tvectors = util.Counter()\\n\\t\\t\\tfor l in self.legalLabels:\\n\\t\\t\\t\\tvectors[l] = self.weights[l] * datum\\n\\t\\t\\tguesses.append(vectors.argMax())\\n\\t\\treturn guesses\",\n \"def classify(self, data ):\\n\\t\\tguesses = []\\n\\t\\tfor datum in data:\\n\\t\\t\\tvectors = util.Counter()\\n\\t\\t\\tfor l in self.legalLabels:\\n\\t\\t\\t\\tvectors[l] = self.weights[l] * datum\\n\\t\\t\\tguesses.append(vectors.argMax())\\n\\t\\treturn guesses\",\n \"def evaluate(y_test, pred_labels):\\n \\n # Converts one-hot code to a label (the index of 1)\\n y_test_labels = np.argmax(y_test, axis=1)\\n \\n # Compare test labels to predicted labels\\n score = accuracy_score(y_test_labels, pred_labels)\\n \\n return y_test_labels, score\",\n \"def _detection_scores(inputs, gt_boxes, gt_labels, model):\\n model = check_model('model', model, BlackModel)\\n boxes_and_confi, pred_labels = model.predict(*inputs)\\n det_scores = []\\n correct_labels_num = []\\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\\n iou_thres = 0.5\\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\\n gt_box_num = gt_box.shape[0]\\n score = 0\\n box_num = boxes.shape[0]\\n correct_label_flag = np.zeros(gt_label.shape)\\n for i in range(box_num):\\n pred_box = boxes[i]\\n max_iou_confi = 0\\n for j in range(gt_box_num):\\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\\n correct_label_flag[j] = 1\\n score += max_iou_confi\\n det_scores.append(score)\\n correct_labels_num.append(np.sum(correct_label_flag))\\n return np.array(det_scores), np.array(correct_labels_num)\",\n \"def train(self, data, labels, validationData, validationLabels): # data x training, y_training\\n # ## TODO: Your code here\\n count = util.Counter()\\n\\n #print 'Labels of the data is:', labels #printing all the labels from which the frequency has to be found\\n\\n for x in labels: # for loop\\n count[x] += 1\\n\\n #print count\\n val = count.argMax()\\n self.guess = val\\n #print val\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def nb_decision(X,p_y,p_x_given_y):\\n cases = X.shape[0]\\n dims = X.shape[1]\\n\\n bayes_prob = np.zeros((cases, 2))\\n result = np.zeros(cases)\\n\\n y_values = p_y.size\\n\\n # find the probability for each y value\\n for y_value in range(y_values):\\n # iterate through each case and calculate the probability\\n for case in range(cases):\\n prob = p_y[y_value]\\n\\n for dim in range(dims):\\n if X[case][dim] == 1:\\n prob = prob * p_x_given_y[dim][y_value]\\n elif X[case][dim] == 0:\\n prob = prob * (1 - p_x_given_y[dim][y_value])\\n\\n\\n bayes_prob[case][y_value] = prob\\n\\n # now find out which class has the biggest probability\\n for case in range(cases):\\n if bayes_prob[case][0] > bayes_prob[case][1]:\\n result[case] = 0\\n else:\\n result[case] = 1\\n\\n return result\",\n \"def greedy_learn(self,node,db,labels,ids):\\n if node.depth >= self.maxdepth or len(ids) <= self.minexamples:\\n #terminate recursion\\n node.pick_best_label(db,labels,ids)\\n err = misclassification_error([labels[id] for id in ids])\\n if err > 0:\\n print \\\"Reached a leaf and had to make some sacrifices, cost\\\",err\\n print \\\" depth\\\",node.depth\\n print \\\" labels\\\",[labels[id] for id in ids]\\n return err\\n\\n features = self.feature_subset(node,db,labels,ids)\\n cost = node.pick_best_split(db,labels,ids,features)\\n \\n #do a split\\n if node.type == 'v':\\n #base case: no misclassifications\\n \\\"\\\"\\\"\\n if cost>0:\\n print \\\"greedy_learn: Warning, pick_best_split indicates a leaf but the cost is nonzero\\\"\\n print \\\"cost=\\\",cost,\\\"misclassification=\\\",misclassification_error([labels[id] for id in ids])\\n print \\\"# of ids:\\\",len(ids)\\n for i in ids:\\n print \\\"id\\\",i,\\\",\\\",\\n for k in range(db.numFeatures()):\\n if db[k,i] != None:\\n print k,\\\"=\\\",db[k,i],\\\",\\\",\\n print \\\"label\\\",labels[i]\\n raw_input()\\n \\\"\\\"\\\"\\n return 0\\n elif node.type == 's':\\n #print \\\"Picked feature\\\",node.feature,\\\"split\\\"\\n #do a discrete split\\n node.children = dict()\\n #select sub-indices\\n Eids = defaultdict(list)\\n noneids = []\\n for id in ids:\\n v = db[node.feature,id]\\n if v is None:\\n #item doesn't exist, it's a missing value\\n noneids.append(id)\\n else:\\n Eids[v].append(id)\\n #print \\\" split sizes:\\\",[len(x) for x in Eids.values()]\\n #print \\\" None ids:\\\",len(noneids)\\n ids = None\\n errors = 0\\n for v,vids in Eids.iteritems():\\n #recurse\\n c = DecisionTreeNode(node)\\n #print \\\"Recursing on value\\\",v\\n #print \\\" ids:\\\",vids\\n errors += self.greedy_learn(c,db,labels,vids+noneids)\\n node.children[v] = c\\n if c.depth > self.deepest:\\n self.deepest = c.depth\\n print \\\"Decision tree learner: Reached node with depth\\\",self.deepest\\n return errors\\n else:\\n #do an inequality split\\n assert node.type == 'i'\\n #print \\\"Picked feature\\\",node.feature,\\\"inequality value\\\",node.value,\\\"cost\\\",cost\\n leftids = []\\n rightids = []\\n for id in ids:\\n if db[node.feature,id] is not None:\\n if db[node.feature,id] <= node.value: leftids.append(id)\\n else: rightids.append(id)\\n else:\\n leftids.append(id)\\n rightids.append(id)\\n if len(rightids) == len(ids) or len(leftids) == len(ids):\\n #due to missing values, this split is useless\\n errors = misclassification_error([labels[id] for id in ids])\\n print \\\"useless split on feature\\\",node.feature,\\\"value\\\",node.value,\\\"misclassification error\\\",errors\\n print \\\"Left size\\\",len(leftids),\\\"right size\\\",len(rightids)\\n raw_input()\\n node.pick_best_label(db,labels,ids)\\n return errors\\n #clear memory associated with ids list\\n del ids[:]\\n ids = None\\n #print \\\"Left size\\\",len(leftids),\\\"right size\\\",len(rightids)\\n c1 = DecisionTreeNode(node)\\n c2 = DecisionTreeNode(node)\\n #left side\\n errors = self.greedy_learn(c1,db,labels,leftids)\\n #right side\\n errors += self.greedy_learn(c2,db,labels,rightids)\\n #restore index\\n node.children = {0:c1,1:c2}\\n if c1.depth > self.deepest:\\n self.deepest = c1.depth\\n print \\\"Decision tree learner: Reached node with depth\\\",self.deepest\\n return errors\",\n \"def _get_max_answers(self):\\n return max([len(x) for x in self.labels])\",\n \"def optimal_neighbors(X_data,\\n y_data,\\n standardize = True,\\n pct_test=0.25,\\n seed=802,\\n response_type='reg',\\n max_neighbors=20,\\n show_viz=True): \\n \\n \\n if standardize == True:\\n # optionally standardizing X_data\\n scaler = StandardScaler()\\n scaler.fit(X_data)\\n X_scaled = scaler.transform(X_data)\\n X_scaled_df = pd.DataFrame(X_scaled)\\n X_data = X_scaled_df\\n\\n\\n\\n # train-test split\\n X_train, X_test, y_train, y_test = train_test_split(X_data,\\n y_data,\\n test_size = pct_test,\\n random_state = seed)\\n\\n\\n # creating lists for training set accuracy and test set accuracy\\n training_accuracy = []\\n test_accuracy = []\\n \\n \\n # setting neighbor range\\n neighbors_settings = range(1, max_neighbors + 1)\\n\\n\\n for n_neighbors in neighbors_settings:\\n # building the model based on response variable type\\n if response_type == 'reg':\\n clf = KNeighborsRegressor(n_neighbors = n_neighbors)\\n clf.fit(X_train, y_train)\\n \\n elif response_type == 'class':\\n clf = KNeighborsClassifier(n_neighbors = n_neighbors)\\n clf.fit(X_train, y_train) \\n \\n else:\\n print(\\\"Error: response_type must be 'reg' or 'class'\\\")\\n \\n \\n # recording the training set accuracy\\n training_accuracy.append(clf.score(X_train, y_train))\\n \\n # recording the generalization accuracy\\n test_accuracy.append(clf.score(X_test, y_test))\\n\\n\\n # optionally displaying visualization\\n if show_viz == True:\\n # plotting the visualization\\n fig, ax = plt.subplots(figsize=(12,8))\\n plt.plot(neighbors_settings, training_accuracy, label = \\\"training accuracy\\\")\\n plt.plot(neighbors_settings, test_accuracy, label = \\\"test accuracy\\\")\\n plt.ylabel(\\\"Accuracy\\\")\\n plt.xlabel(\\\"n_neighbors\\\")\\n plt.legend()\\n plt.show()\\n \\n \\n # returning optimal number of neighbors\\n print(f\\\"The optimal number of neighbors is: {test_accuracy.index(max(test_accuracy))+1}\\\")\\n return test_accuracy.index(max(test_accuracy))+1\",\n \"def add(self, detection_candidates):\\n best_cand = None\\n best_iou = 0.0\\n last_detection = self.get_last_det()\\n \\n for cand in detection_candidates: \\n if cand.label == self.label:\\n curr_iou = calculate_IOU(last_detection, cand)\\n if curr_iou > best_iou:\\n best_iou = curr_iou \\n best_cand = cand\\n print(\\\"Best IoU: {}\\\".format(best_iou))\\n if best_iou >= self.threshold:\\n self.detection_list.append(best_cand)\\n return best_cand\\n return None\",\n \"def _label_rider_by_trip_frequency(self, rider):\\n if rider['total_num_trips'] <= 5*self.duration:\\n label = 0\\n elif rider['total_num_trips'] <= 20*self.duration:\\n label = 1\\n elif rider['total_num_trips'] > 20*self.duration:\\n label = 2\\n else:\\n label = -1\\n return label\",\n \"def _majority_vote(self, claims):\\n c_df = claims[['source_id', 'object_id', 'value']].copy()\\n discovered_truths = c_df.groupby(['object_id'\\n ]).apply(lambda x: self.elect(x))\\n discovered_truths = pd.DataFrame(discovered_truths)\\n discovered_truths = discovered_truths.rename(columns={\\n 0: 'value'\\n }).reset_index()\\n return discovered_truths\",\n \"def plaque_detection_rate(labels, preds, n_classes=5, thres=0):\\n if not isinstance(labels, np.ndarray):\\n labels = labels.data.cpu().numpy()\\n preds = preds.cpu().numpy()\\n\\n pgt_cnt = [0, 0]\\n pp_cnt = [0, 0]\\n tp_cnt = [0, 0]\\n\\n # 5-class segmentation or 2-class segmentation\\n plaques = [3, 4] if n_classes == 5 else [0, 1]\\n if labels.ndim == 3: # for 2D image\\n for label, pred in zip(labels, preds):\\n for inx, plaque in enumerate(plaques):\\n if np.sum(label == plaque) != 0:\\n pgt_cnt[inx] += 1\\n if np.sum(pred == plaque) >= thres:\\n pp_cnt[inx] += 1\\n if np.sum(label == plaque) != 0 and np.sum(pred == plaque) >= thres:\\n tp_cnt[inx] += 1\\n\\n elif labels.ndim == 4:\\n for label_vol, pred_vol in zip(labels, preds):\\n for label, pred in zip(label_vol, pred_vol):\\n for inx, plaque in enumerate(plaques):\\n if np.sum(label == plaque) != 0:\\n pgt_cnt[inx] += 1\\n if np.sum(pred == plaque) >= thres:\\n pp_cnt[inx] += 1\\n if np.sum(label == plaque) != 0 and np.sum(pred == plaque) >= thres:\\n tp_cnt[inx] += 1\\n\\n return pgt_cnt[0], pp_cnt[0], tp_cnt[0], pgt_cnt[1], pp_cnt[1], tp_cnt[1]\",\n \"def result_poll(votes):\\n return sum(votes) >= 2 / 3 * len(votes)\",\n \"def predict(self, X):\\n preds = self.get_predictions(X)\\n\\n n_classifiers, n_instances = preds.shape\\n\\n local_votes = np.empty(self.n_classes, dtype=np.float32)\\n global_votes = np.empty(n_instances, dtype=np.int32)\\n\\n for i in range(n_instances):\\n local_votes[:] = 0.\\n\\n for j in range(n_classifiers):\\n local_votes[preds[j, i]] += self.voting_weights[j, preds[j, i]]\\n\\n global_votes[i] = np.argmax(local_votes)\\n\\n return global_votes\",\n \"def prob6(n_neighbors, filename=\\\"mnist_subset.npz\\\"):\\n #Extract the data\\n data = np.load(\\\"mnist_subset.npz\\\")\\n X_train = data[\\\"X_train\\\"].astype(np.float)\\n y_train = data[\\\"y_train\\\"]\\n X_test = data[\\\"X_test\\\"].astype(np.float)\\n y_test = data[\\\"y_test\\\"]\\n\\n # instantiate a KNeighborsClassifier to hold the data to make predictions\\n myClassifier = KNeighborsClassifier(n_neighbors)\\n myClassifier.fit(X_train, y_train)\\n accurate_trains = 0\\n prediction = 0\\n # test each label\\n for i in range(len(X_test)):\\n target = X_test[i]\\n #make prediction\\n prediction = myClassifier.predict(target)\\n # check accuracy\\n if prediction == y_test[i]:\\n accurate_trains += 1\\n # return the accuracy ratio\\n return accurate_trains / len(y_test)\",\n \"def evaluate1_5(self, test_data):\\r\\n test_results = [(np.argmax(self.feedforward1_5(x)), y)\\r\\n for (x, y) in test_data]\\r\\n #print(self.feedforward(test_data[0][0]))\\r\\n #print(test_data[0][1])\\r\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def ovr_test(dic, x_test, y_test, nb_classes):\\n TP = FP = TN = FN = 0\\n correct_predict = 0\\n for index, value in enumerate(x_test):\\n predict = {elem : 0 for elem in nb_classes}\\n for key in dic:\\n predict[key] = dic[key].predict_proba([value])[0][1]\\n\\n predicted_value = max(predict.items(), key=operator.itemgetter(1))[0]\\n if predicted_value == y_test[index]:\\n correct_predict += 1\\n TP += 1\\n else:\\n FP += 1\\n \\n return correct_predict, TP, FP, TN, FN\",\n \"def iterative_majority(votes):\\n half = len(votes)//2\\n counts = defaultdict(lambda: 0)\\n for vote in votes:\\n counts[vote] += 1\\n\\n sorted_counts = sorted((count for count in counts.values()), reverse=True)\\n return (Outcome.has_majority if sorted_counts[0] > half\\n else Outcome.no_majority)\",\n \"def _score_to_decision(self, score):\",\n \"def find_best_k(data, anots, neibhours_range):\\r\\n \\r\\n best_k = 0\\r\\n best_acc = 0\\r\\n for n_neighbors in neibhours_range:\\r\\n accur = iterate_over_chanels(data, anots, n_neighbors)\\r\\n mean_acc = accur.mean()\\r\\n if mean_acc > best_acc:\\r\\n best_acc = mean_acc\\r\\n best_k = n_neighbors\\r\\n return best_k\",\n \"def nearest_neighbors_metrics(all_pcs, all_labels, this_unit_id, max_spikes_for_nn, n_neighbors):\\n\\n total_spikes = all_pcs.shape[0]\\n ratio = max_spikes_for_nn / total_spikes\\n this_unit = all_labels == this_unit_id\\n\\n X = np.concatenate((all_pcs[this_unit, :], all_pcs[np.invert(this_unit), :]), 0)\\n\\n n = np.sum(this_unit)\\n\\n if ratio < 1:\\n inds = np.arange(0, X.shape[0] - 1, 1 / ratio).astype('int')\\n X = X[inds, :]\\n n = int(n * ratio)\\n\\n nbrs = NearestNeighbors(n_neighbors=n_neighbors, algorithm='ball_tree').fit(X)\\n distances, indices = nbrs.kneighbors(X)\\n\\n this_cluster_inds = np.arange(n)\\n\\n this_cluster_nearest = indices[:n, 1:].flatten()\\n other_cluster_nearest = indices[n:, 1:].flatten()\\n\\n hit_rate = np.mean(this_cluster_nearest < n)\\n miss_rate = np.mean(other_cluster_nearest < n)\\n\\n return hit_rate, miss_rate\",\n \"def variable_ranking(self):\\n self.grow_trees()\\n dist_classes = self.dist_classes\\n oob = self.forest.oob_set_generator()\\n oob_length, First, elt_vals, var_vals = len(oob), True, {}, {}\\n succ_rate, dist_succ_rate, dist_order = 0, 0, 0\\n for var in self.variables:\\n var_range = list(variable_range(self.data, var))\\n range_len = len(var_range)\\n print var\\n permution = None\\n permuted_succ, perm_dist_succ = 0, 0\\n for elts in oob:\\n if First:\\n actual = self.data[elts][self.prediction_index]\\n elt_vals[elts] = actual\\n predicted = self.forest.test_predict(self.data[elts], elts)\\n if actual in dist_classes:\\n dist_order += 1\\n if actual == predicted:\\n succ_rate += 1\\n if actual in dist_classes:\\n dist_succ_rate += 1\\n if var[1] == 'd':\\n permution = int(math.floor(uniform(0, 1)*range_len))\\n permution = var_range[permution]\\n else:\\n permution = uniform(0, 1)*(var_range[1] - var_range[0])\\n perm_tuple = self.data[elts][:var[0]] + [permution] + self.data[elts][var[0]+1:]\\n permuted_prediction = self.forest.predict(perm_tuple)\\n actual = elt_vals[elts]\\n if actual == permuted_prediction:\\n permuted_succ += 1\\n if actual in dist_classes:\\n perm_dist_succ += 1\\n if First:\\n succ_rate = float(succ_rate)/oob_length\\n dist_succ_rate = float(dist_succ_rate)/dist_order\\n First = False\\n permuted_succ = float(permuted_succ)/oob_length\\n perm_dist_succ = float(perm_dist_succ)/dist_order\\n print \\\"Originally a \\\", succ_rate, \\\" success rate, with permution to \\\", permuted_succ\\n print \\\"A difference of \\\", succ_rate - permuted_succ\\n print \\\"WRT Distinguised classes, a success rate of:\\\", dist_succ_rate, 'with permution to ', perm_dist_succ\\n print \\\"A difference of \\\", dist_succ_rate - perm_dist_succ\\n var_vals[var] = succ_rate - permuted_succ\\n var_vals[(var, 'd')] = dist_succ_rate - perm_dist_succ\\n var_vals = sorted(var_vals.items(), key=lambda x: x[1], reverse=True)\\n for x in var_vals:\\n print x[0], x[1]\",\n \"def knnForOne(x_training_data, y_training_data, single_x_test_data, n_neighbors):\\n nearest_neighbors = {}\\n length = len(x_training_data)\\n\\n for i in range(length):\\n X2 = x_training_data[i,:] # get current row of known data\\n Y2 = y_training_data[i] # get current label of known data\\n distance = getDistance(single_x_test_data, X2) # compare test to known data\\n\\n if len(nearest_neighbors) < n_neighbors: # reach capacity of nearest neighbors\\n nearest_neighbors[distance] = Y2\\n else: # kick out largest distance\\n\\n # Assumes no two distances are exactly the same, or data point will be overwritten in dictionary\\n largest_distance = max(nearest_neighbors)\\n if distance < largest_distance:\\n del nearest_neighbors[largest_distance]\\n nearest_neighbors[distance] = Y2\\n\\n # nearest_neighbors is a dictionary with the n nearest neighbors \\n # as values and their distances from single_x_test_data as keys\\n \\n counts = {}\\n for key in nearest_neighbors: # initialize counts dictionary\\n counts[nearest_neighbors[key]] = 0\\n\\n for key in nearest_neighbors: # count labels within the nearest neighbors\\n counts[nearest_neighbors[key]] += 1\\n\\n max_value = max(counts.values()) # find most frequent label within the nearest neighbors\\n for key in counts:\\n if counts[key] == max_value:\\n return key\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7076513","0.6492986","0.63586086","0.6339451","0.62436193","0.61596376","0.6038543","0.598995","0.59895474","0.5984259","0.5975959","0.5975312","0.5897305","0.58957624","0.58957624","0.58913827","0.5873205","0.5868879","0.5822922","0.5816393","0.5770653","0.5763279","0.5759779","0.5757576","0.5745748","0.5710364","0.57040066","0.5695241","0.56651795","0.5661203","0.5644886","0.56418943","0.564122","0.56069916","0.559978","0.55887264","0.55844223","0.557432","0.5572309","0.55618215","0.55448306","0.55442387","0.5542412","0.5535918","0.5533213","0.55284125","0.5518167","0.5500525","0.5494618","0.5491563","0.54867214","0.545608","0.5454237","0.54540646","0.54468316","0.5443302","0.5440781","0.54395396","0.54344714","0.5432831","0.5431688","0.5413683","0.54099727","0.5406201","0.54005253","0.53947645","0.5387844","0.5385157","0.5376944","0.5373117","0.53703344","0.53671557","0.53605586","0.53600913","0.5356589","0.5351002","0.5351002","0.5344586","0.53414863","0.53405744","0.5340528","0.533881","0.53351927","0.5333791","0.5328621","0.5323329","0.53222567","0.53196937","0.5316612","0.53157353","0.530776","0.52936524","0.52917916","0.5285141","0.52818346","0.5278541","0.5277196","0.5268175","0.5261389","0.5256208"],"string":"[\n \"0.7076513\",\n \"0.6492986\",\n \"0.63586086\",\n \"0.6339451\",\n \"0.62436193\",\n \"0.61596376\",\n \"0.6038543\",\n \"0.598995\",\n \"0.59895474\",\n \"0.5984259\",\n \"0.5975959\",\n \"0.5975312\",\n \"0.5897305\",\n \"0.58957624\",\n \"0.58957624\",\n \"0.58913827\",\n \"0.5873205\",\n \"0.5868879\",\n \"0.5822922\",\n \"0.5816393\",\n \"0.5770653\",\n \"0.5763279\",\n \"0.5759779\",\n \"0.5757576\",\n \"0.5745748\",\n \"0.5710364\",\n \"0.57040066\",\n \"0.5695241\",\n \"0.56651795\",\n \"0.5661203\",\n \"0.5644886\",\n \"0.56418943\",\n \"0.564122\",\n \"0.56069916\",\n \"0.559978\",\n \"0.55887264\",\n \"0.55844223\",\n \"0.557432\",\n \"0.5572309\",\n \"0.55618215\",\n \"0.55448306\",\n \"0.55442387\",\n \"0.5542412\",\n \"0.5535918\",\n \"0.5533213\",\n \"0.55284125\",\n \"0.5518167\",\n \"0.5500525\",\n \"0.5494618\",\n \"0.5491563\",\n \"0.54867214\",\n \"0.545608\",\n \"0.5454237\",\n \"0.54540646\",\n \"0.54468316\",\n \"0.5443302\",\n \"0.5440781\",\n \"0.54395396\",\n \"0.54344714\",\n \"0.5432831\",\n \"0.5431688\",\n \"0.5413683\",\n \"0.54099727\",\n \"0.5406201\",\n \"0.54005253\",\n \"0.53947645\",\n \"0.5387844\",\n \"0.5385157\",\n \"0.5376944\",\n \"0.5373117\",\n \"0.53703344\",\n \"0.53671557\",\n \"0.53605586\",\n \"0.53600913\",\n \"0.5356589\",\n \"0.5351002\",\n \"0.5351002\",\n \"0.5344586\",\n \"0.53414863\",\n \"0.53405744\",\n \"0.5340528\",\n \"0.533881\",\n \"0.53351927\",\n \"0.5333791\",\n \"0.5328621\",\n \"0.5323329\",\n \"0.53222567\",\n \"0.53196937\",\n \"0.5316612\",\n \"0.53157353\",\n \"0.530776\",\n \"0.52936524\",\n \"0.52917916\",\n \"0.5285141\",\n \"0.52818346\",\n \"0.5278541\",\n \"0.5277196\",\n \"0.5268175\",\n \"0.5261389\",\n \"0.5256208\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7605235"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93096,"cells":{"query":{"kind":"string","value":"Secure XMLRPC server. It it very similar to SimpleXMLRPCServer but it uses HTTPS for transporting XML data."},"document":{"kind":"string","value":"def __init__(self, server_address, HandlerClass, logRequests=True):\n self.logRequests = logRequests\n \n try:\n SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self)\n except TypeError:\n # An exception is raised in Python 2.5 as the prototype of the __init__\n # method has changed and now has 3 arguments (self, allow_none, encoding)\n #\n SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self, False, None)\n \n SocketServer.BaseServer.__init__(self, server_address, HandlerClass)\n \n self.socket = ssl.wrap_socket(socket.socket(), server_side=True, certfile=CERTFILE,\n keyfile=KEYFILE, ssl_version=ssl.PROTOCOL_SSLv23)\n \n self.server_bind()\n self.server_activate()"},"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 ServerApp(stream, certfile, keyfile):\n\n def secured():\n print 'server secured!'\n wait()\n\n def read(line):\n line = line.strip()\n print 'client said: %r.' % line\n\n if line == 'QUIT':\n write('GOODBYE')\n elif line == 'STARTTLS':\n stream.write('PROCEED\\n')\n stream.starttls(\n secured,\n server_side=True,\n certfile=certfile,\n keyfile=keyfile\n )\n else:\n write('YOU SAID: %r' % line)\n\n def write(data):\n stream.write('%s\\n' % data)\n wait()\n\n def wait():\n stream.read_until('\\n', read)\n\n ## Begin\n print 'starting server: %r' % stream.socket.fileno()\n wait()","def __init__(self, server_address, HandlerClass, logRequests=False):\n self.logRequests = logRequests\n\n SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self)\n SocketServer.BaseServer.__init__(self, server_address, HandlerClass)\n ctx = SSL.Context(SSL.SSLv23_METHOD)\n\n ctx.use_privatekey_file (XMLRPC_SERVER_KEYFILE)\n ctx.use_certificate_file(XMLRPC_SERVER_CERTFILE)\n self.socket = SSL.Connection(ctx, socket.socket(self.address_family,\n self.socket_type))\n self.server_bind()\n self.server_activate()","def __init__(self, uri, x509=None, Transport=None):\n xmlrpclib.ServerProxy.__init__(self, uri, transport=Transport)\n self.x509 = x509","def _server(self, sock):\n # Create the server side Connection. This is mostly setup boilerplate\n # - use TLSv1, use a particular certificate, etc.\n server_ctx = Context(SSLv23_METHOD)\n server_ctx.set_options(OP_NO_SSLv2 | OP_NO_SSLv3 | OP_SINGLE_DH_USE)\n server_ctx.set_verify(\n VERIFY_PEER | VERIFY_FAIL_IF_NO_PEER_CERT | VERIFY_CLIENT_ONCE,\n verify_cb,\n )\n server_store = server_ctx.get_cert_store()\n server_ctx.use_privatekey(\n load_privatekey(FILETYPE_PEM, server_key_pem)\n )\n server_ctx.use_certificate(\n load_certificate(FILETYPE_PEM, server_cert_pem)\n )\n server_ctx.check_privatekey()\n server_store.add_cert(load_certificate(FILETYPE_PEM, root_cert_pem))\n # Here the Connection is actually created. If None is passed as the\n # 2nd parameter, it indicates a memory BIO should be created.\n server_conn = Connection(server_ctx, sock)\n server_conn.set_accept_state()\n return server_conn","def createSimpleXMLRPCServer(host, ports):\n\tfor port in ports:\n\t\ttry:\n\t\t\tres = xserver.SimpleXMLRPCServer((host,port))\n\t\texcept Exception as e:\n\t\t\tprint(\"Retrying:%s\"%(e))\n\t\telse:\n\t\t\tres.logRequests = 0 # hint from newsgroup to disable the - - [13/Apr/2007 13:33:57] \"POST /RPC2 HTTP/1.0\" 200 - output with every request\n\t\t\treturn res","def GetRpcServer(options):\n\n rpc_server_class = HttpRpcServer\n\n def GetUserCredentials():\n \"\"\"Prompts the user for a username and password.\"\"\"\n email = options.email\n if email is None:\n email = GetEmail(\"Email (login for uploading to %s)\" % options.server)\n password = getpass.getpass(\"Password for %s: \" % email)\n return (email, password)\n\n # If this is the dev_appserver, use fake authentication.\n host = (options.host or options.server).lower()\n if host == \"localhost\" or host.startswith(\"localhost:\"):\n email = options.email\n if email is None:\n email = \"test@example.com\"\n logging.info(\"Using debug user %s. Override with --email\" % email)\n server = rpc_server_class(\n options.server,\n lambda: (email, \"password\"),\n host_override=options.host,\n extra_headers={\"Cookie\":\n 'dev_appserver_login=\"%s:False\"' % email},\n save_cookies=options.save_cookies)\n # Don't try to talk to ClientLogin.\n server.authenticated = True\n return server\n\n return rpc_server_class(options.server, GetUserCredentials,\n host_override=options.host,\n save_cookies=options.save_cookies)","def xs_connection(password, url, user='root'):\n \n conn = xmlrpclib.Server(url)\n connection = conn.session.login_with_password(user, password)\n \n if connection['Status'] == 'Success':\n token = connection['Value']\n sys.stderr.write (\"\\n Connection unique ref: %s\\n\" %token)\n else :\n for i in connection['ErrorDescription']:\n sys.stderr.write(i)\n try :\n sys.remove(pid_file)\n except OSError as e:\n sys.stderr.write(str(e))\n sys.exit(3)\n return conn, token","def __init__(self):\n try:\n context = ssl.create_default_context(\n purpose=ssl.Purpose.CLIENT_AUTH)\n context.options |= ssl.OP_NO_SSLv2\n context.options |= ssl.OP_NO_SSLv3\n context.options |= ssl.OP_NO_TLSv1\n context.options |= ssl.OP_NO_TLSv1_1\n context.options |= ssl.OP_NO_COMPRESSION\n context.verify_mode = ssl.CERT_REQUIRED\n # TODO do not use static configuration parameters\n context.load_verify_locations(cafile='/sbin/rpcsd/root.cert.pem')\n context.load_cert_chain(certfile='/sbin/rpcsd/gaps.pem')\n context.set_ciphers('AES128-SHA256')\n RPCS.context = context\n except FileNotFoundError:\n # If we can't set up TLS context, log error and exit\n LOG.error(\"Could not setup TLS context: certificate file(s) \"\n \"not present in the correct directory\")\n exit(1)","def main():\n parser = argparse.ArgumentParser(description=DESCRIPTION)\n parser.add_argument(\n \"--port\", type=int, default=9090, help=\"The port number to listen to.\",\n )\n parser.add_argument(\"--settings\", help=\"Full path to settings file.\", required=True)\n parser.add_argument(\n \"--ssl_context\",\n help=\"A key and certificate file pair to run the server in HTTPS mode.\",\n nargs=2,\n )\n\n args = parser.parse_args()\n\n keyfile = None\n certfile = None\n if args.ssl_context:\n keyfile, certfile = args.ssl_context\n\n run_server(\n port=args.port, settings=args.settings, keyfile=keyfile, certfile=certfile,\n )","def server(addr, port, family, use_tls=False):\n sock = _socket(addr, port, family)\n ctx = _context(use_tls=use_tls)\n return {\"sock\": sock, \"ssl\": ctx}","def gen_server():\n server = grpc.server(futures.ThreadPoolExecutor(max_workers = 10), \n options= [('grpc.max_send_message_length', 100 * 1024 * 1024),\n ('grpc.max_receive_message_length', 100 * 1024 * 1024)])\n with open('server.key', 'rb') as f:\n private_key = f.read()\n with open('server.crt', 'rb') as f:\n certificate_chain = f.read()\n server_credentials = grpc.ssl_server_credentials(((private_key, certificate_chain,),))\n server.add_secure_port('[::]:50051', server_credentials)\n return server","def is_secure(self):\n return self._is_ssl or self._is_socket","def _ServerProxy__request(self, methodname, params):\n\n paddedHandler = self._ServerProxy__handler\n\n # add on the methodName\n sep = '&'\n if '?' not in paddedHandler:\n sep = '?'\n paddedHandler = paddedHandler + \"%smethod=%s\" % (sep, methodname)\n sep = '&'\n\n # add on the auth token\n if self._authToken:\n paddedHandler = paddedHandler + \"%sauth_token=%s\" % (sep, urllib.quote_plus(self._authToken))\n\n # add on the partnerId\n if self._partnerId:\n paddedHandler = paddedHandler + \"%spartner_id=%s\" % (sep, self._partnerId)\n\n # add on the userId\n if self._userId:\n paddedHandler = paddedHandler + \"%suser_id=%s\" % (sep, self._userId)\n\n EXCLUDED_PAYLOAD_CALLS = ([\n \"auth.partnerLogin\",\n \"test.\",\n \"debug.\",\n \"testability.\"\n ])\n encryptRequest = True\n if self._requestCipher:\n for excludedMethodPattern in EXCLUDED_PAYLOAD_CALLS:\n if methodname.startswith(excludedMethodPattern):\n encryptRequest = False\n break\n else:\n encryptRequest = False\n\n # add the syncTime request\n if encryptRequest and self._sync:\n server_value, sync_time = self._sync\n params[0]['syncTime'] = server_value + int(time.time()) - sync_time\n\n request = xmlrpclib.dumps(params, methodname,\n encoding=self._ServerProxy__encoding,\n allow_none=self._ServerProxy__allow_none)\n\n #print \"------- XML REQUEST --------\"\n #print request\n\n if encryptRequest:\n request = self.encodeRequest(request)\n\n if self.x509:\n response = self._ServerProxy__transport.request(\n (self._ServerProxy__host, self.x509),\n paddedHandler,\n request,\n verbose=self._ServerProxy__verbose\n )\n else:\n response = self._ServerProxy__transport.request(\n self._ServerProxy__host,\n paddedHandler,\n request,\n verbose=self._ServerProxy__verbose\n )\n\n if len(response) == 1:\n response = response[0]\n\n #print \"------ RESPONSE ------\"\n #print response\n\n return response","def secure_sock(self):\n return self._secure_sock","def UnitTestServer(self):\n print('--server--')\n print('server pid is ' + str(os.getpid()))\n try:\n s = socket.socket()\n s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n s.bind(('', 25692))\n s.listen(1)\n c, addr = s.accept() #get client socket and address\n s.close()\n self.ExchangeServer(c)\n print(\"prime index: \" + str(self.PrimeCache.index((self.SharedPrime, self.SharedBase))))\n print('Shared secret: ' + str(self.SharedSecret))\n self.sendStr(c, 'An encrypted message')\n msg = self.recvStr(c)\n if msg == 'Thanks for sharing':\n print('Client message received OK')\n else:\n raise Exception('Failed to decrypt client message!')\n c.close()\n except Exception as e:\n traceback.print_exc(file=sys.stdout)\n c.close()\n return False\n \n return True","def Connect(server, port=common_lib.SERVER_PORT):\n addr = 'https://%s:%d' % (server, port)\n logging.debug('Connecting to RPC server at %s', addr)\n return jsonrpclib.ServerProxy(addr, allow_none=True)","def xmlrpc_methods():","def ussl.wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None):\n pass","def connect(enc_data=None, ring=1):\n if not enc_data:\n enc_data = load_default_enc_json()\n url = {0: DIRECTORY_URL_RING0,\n 1: DIRECTORY_URL_RING1}[ring]\n return xmlrpc.client.Server(url.format(enc=enc_data), allow_none=True,\n use_datetime=True)","def do_POST(self):\n \n try:\n # get arguments\n data = self.rfile.read(int(self.headers[\"content-length\"]))\n # In previous versions of SimpleXMLRPCServer, _dispatch\n # could be overridden in this class, instead of in\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\n # check to see if a subclass implements _dispatch and dispatch\n # using that method if present.\n response = self.server._marshaled_dispatch(\n data, getattr(self, '_dispatch', None)\n )\n except: # This should only happen if the module is buggy\n # internal error, report as HTTP server error\n self.send_response(500)\n self.end_headers()\n else:\n # got a valid XML RPC response\n self.send_response(200)\n self.send_header(\"Content-type\", \"text/xml\")\n self.send_header(\"Content-length\", str(len(response)))\n self.end_headers()\n self.wfile.write(response)\n \n # shut down the connection\n self.wfile.flush()\n \n #modified as of http://docs.python.org/library/ssl.html\n self.connection.shutdown(socket.SHUT_RDWR)\n self.connection.close()","async def main():\n await serve_websocket(handle_server, SERVER, PORT, ssl_context=None)","def check_secure():\n return get_config_handler().check_secure()","def start_rpc_server(user, host, port, client):\n if user not in SERVER_THREADS.keys():\n # Create server\n server = SimpleXMLRPCServer((host, port), requestHandler=RequestHandler)\n server.register_instance(QChatRPCServer(user, host, port, client))\n server_thread = RPCServerThread(server=server, target=server.serve_forever)\n SERVER_THREADS[user] = server_thread\n server_thread.start()","def run(self, handler):\n server = WSGIServer((self.host, self.port), handler)\n server.ssl_adapter = pyOpenSSLAdapter(\n certificate=CERTIFICATE,\n private_key=KEY,\n # certificate_chain=\"intermediate_cert.crt\"\n )\n\n try:\n server.start()\n logger.info(\"Started vROPs Web Service\")\n except Exception as exp:\n server.stop()\n logger.error(\"Exception: {} Stopped vROPs Web Service\".format(exp))","def ClientApp(stream):\n\n def secured():\n print 'client secured!'\n write('QUIT')\n\n def read(line):\n line = line.strip()\n print 'server said: %r.' % line\n if line == \"YOU SAID: 'hello'\":\n write('STARTTLS')\n elif line == 'PROCEED':\n stream.starttls(secured)\n elif line == 'GOODBYE':\n stream.close()\n else:\n wait()\n\n def write(data):\n stream.write('%s\\n' % data)\n wait()\n\n def wait():\n stream.read_until('\\n', read)\n\n ## Begin\n print 'starting client: %r' % stream.socket.fileno()\n write('hello')","def _server_connection(self, callback, data):\n ctx = Context(SSLv23_METHOD)\n ctx.use_privatekey(load_privatekey(FILETYPE_PEM, server_key_pem))\n ctx.use_certificate(load_certificate(FILETYPE_PEM, server_cert_pem))\n ctx.set_ocsp_server_callback(callback, data)\n server = Connection(ctx)\n server.set_accept_state()\n return server","def Server(self) -> Socket:","def launch_writeserver(self):\n # server thread interface to DB\n self.writeconn = sqlite3.connect(self.dbname, timeout = 30)\n self.write_curs = self.writeconn.cursor()\n self.log_message(self.create_readout(\"LogDB_XMLRPC_server.py\", \"Autologbook DB web interface server\", None),\n \"Starting Logger write server on \" + self.host + \":%i\"%self.writeport)\n\n # xmlrpc web interface for data updates\n class RequestHandler(SimpleXMLRPCRequestHandler):\n rpc_paths = ('/RPC2',)\n\n server = SimpleXMLRPCServer(None, bind_and_activate=False, requestHandler=RequestHandler, allow_none=True)\n server.register_function(self.create_readout, 'create_readout')\n server.register_function(self.set_ChangeFilter, 'set_ChangeFilter')\n server.register_function(self.set_DecimationFilter, 'set_DecimationFilter')\n server.register_function(self.log_readout, 'log_readout')\n server.register_function(self.log_readouts, 'log_readouts')\n server.register_function(self.log_message, 'log_message')\n server.register_function(self.writeconn.commit, 'commit')\n server.register_function(self.define_readset, 'define_readset')\n server.register_function(self.log_readset, 'log_readset')\n\n context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) #, cafile = 'https_cert.pem') # accepted certs from clients\n #context.verify_mode = ssl.CERT_REQUIRED\n #context.check_hostname = False\n context.load_cert_chain('https_cert.pem', 'https_key.pem') # my certs for clients\n\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:\n sock.bind(('', self.writeport)) # listen on all interfaces\n sock.listen(40) # 20 pending connections before dropping more\n\n with context.wrap_socket(sock, server_side=True) as ssock:\n server.socket = ssock\n print(\"Launching writeserver on\", self.host, self.writeport)\n sys.stdout.flush()\n server.serve_forever()","def server():","def server():","def GetRpcServer(server, email=None, host_override=None, save_cookies=True,\r\n account_type=AUTH_ACCOUNT_TYPE):\r\n\r\n # If this is the dev_appserver, use fake authentication.\r\n host = (host_override or server).lower()\r\n if re.match(r'(http://)?localhost([:/]|$)', host):\r\n if email is None:\r\n email = \"test@example.com\"\r\n logging.info(\"Using debug user %s. Override with --email\" % email)\r\n server = HttpRpcServer(\r\n server,\r\n lambda: (email, \"password\"),\r\n host_override=host_override,\r\n extra_headers={\"Cookie\":\r\n 'dev_appserver_login=\"%s:False\"' % email},\r\n save_cookies=save_cookies,\r\n account_type=account_type)\r\n # Don't try to talk to ClientLogin.\r\n server.authenticated = True\r\n return server\r\n\r\n return HttpRpcServer(server,\r\n KeyringCreds(server, host, email).GetUserCredentials,\r\n host_override=host_override,\r\n save_cookies=save_cookies,\r\n account_type=account_type)","def wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None):\n ...","def _httpd_serve_forever(args):\n server_address = ('', args.port)\n factory = _request_handler_factory(args)\n httpd = BaseHTTPServer.HTTPServer(server_address, factory)\n if args.sslcert:\n certpath = os.path.abspath(args.sslcert)\n print(certpath)\n httpd.socket = ssl.wrap_socket(\n httpd.socket,\n certfile=certpath,\n server_side=True)\n httpd.serve_forever()","def Connect(server, port):\n addr = 'http://%s:%d' % (server, port)\n logging.debug('Connecting to RPC server at %s', addr)\n return jsonrpclib.ServerProxy(addr, allow_none=True)","def serve(self):\n \n print (\"Starting metastore server on port %d, use ctrl-c \"\n \"to quit\" % self.port)\n \n from SimpleXMLRPCServer import SimpleXMLRPCServer\n server = SimpleXMLRPCServer((\"0.0.0.0\", self.port))\n server.register_function(self.store.get)\n server.register_function(self.store.put)\n server.register_function(self.store.multiget)\n server.serve_forever()","def start(self):\n if self._use_ssl:\n try:\n ca_file = CONF.ssl_ca_file\n cert_file = CONF.ssl_cert_file\n key_file = CONF.ssl_key_file\n\n if cert_file and not os.path.exists(cert_file):\n raise RuntimeError(\n _(\"Unable to find cert_file : %s\") % cert_file)\n\n if ca_file and not os.path.exists(ca_file):\n raise RuntimeError(\n _(\"Unable to find ca_file : %s\") % ca_file)\n\n if key_file and not os.path.exists(key_file):\n raise RuntimeError(\n _(\"Unable to find key_file : %s\") % key_file)\n\n if self._use_ssl and (not cert_file or not key_file):\n raise RuntimeError(\n _(\"When running server in SSL mode, you must \"\n \"specify both a cert_file and key_file \"\n \"option value in your configuration file\"))\n ssl_kwargs = {\n 'server_side': True,\n 'certfile': cert_file,\n 'keyfile': key_file,\n 'cert_reqs': ssl.CERT_NONE,\n }\n\n if CONF.ssl_ca_file:\n ssl_kwargs['ca_certs'] = ca_file\n ssl_kwargs['cert_reqs'] = ssl.CERT_REQUIRED\n\n self._socket = eventlet.wrap_ssl(self._socket,\n **ssl_kwargs)\n\n self._socket.setsockopt(socket.SOL_SOCKET,\n socket.SO_REUSEADDR, 1)\n # sockets can hang around forever without keepalive\n self._socket.setsockopt(socket.SOL_SOCKET,\n socket.SO_KEEPALIVE, 1)\n\n # This option isn't available in the OS X version of eventlet\n if hasattr(socket, 'TCP_KEEPIDLE'):\n self._socket.setsockopt(socket.IPPROTO_TCP,\n socket.TCP_KEEPIDLE,\n CONF.tcp_keepidle)\n\n except Exception:\n with excutils.save_and_reraise_exception():\n LOG.error(_(\"Failed to start %(name)s on %(host)s\"\n \":%(port)s with SSL support\") % self.__dict__)\n\n wsgi_kwargs = {\n 'func': eventlet.wsgi.server,\n 'sock': self._socket,\n 'site': self.app,\n 'protocol': self._protocol,\n 'custom_pool': self._pool,\n 'log': self._wsgi_logger,\n 'log_format': CONF.wsgi_log_format\n }\n\n if self._max_url_len:\n wsgi_kwargs['url_length_limit'] = self._max_url_len\n\n self._server = eventlet.spawn(**wsgi_kwargs)","def build_httpd(secure=None):\n\n httpd = http_server.HTTPServer(LOCAL_RANDOM_PORT, MockServerRequestHandler)\n httpd.req = {}\n httpd.rsp = []\n\n if secure:\n keyfile, certfile = fetch_cert_files()\n\n context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)\n context.load_cert_chain(certfile, keyfile=keyfile)\n\n httpd.socket = context.wrap_socket(httpd.socket, server_side=True)\n\n return httpd","def is_secure_context(self):\n raise exceptions.NotImplementedError()","def __handshake(sock):\n # Craft HELLO packet\n msg = \"HELLO,SecureClient\".encode('utf-8')\n \n # Send packet\n sock.sendall(msg)\n\n # Wait for server's key\n resp = sock.recv(1024).decode('utf-8')\n print(resp)\n \n # Parse response\n parsedResp = resp.split(\",\")\n\n # Check correct response\n if parsedResp[0] != \"HELLO\" and parsedResp[1] != \"SecureServer\":\n print(\"Bad response\")\n return False\n\n try:\n # Extract the key from server message\n dirtyKey = parsedResp[2]\n except IndexError:\n print(\"Bad key message\")\n return False\n\n return __clean_key(dirtyKey)","def insecure_ssl(self):\n # type: () -> bool\n return self._insecure_ssl","def registerXMLRPC(self, unique_service_name, instance, endpoint):\n # TODO only set the ClientCert Handler if configured\n handler = XMLRPCHandler(unique_service_name)\n handler.connect(self._flaskapp.app, endpoint)\n handler.register_instance(instance)","def _authenticated_server_proxy(self):\n config = self._config\n\n if self.__authenticated_server_proxy is None:\n realm = REALM\n if \"realm\" in self._config:\n realm = self._config[\"realm\"]\n server = TRAC_SERVER_URI\n if \"server\" in self._config:\n server = self._config[\"server\"]\n if server[-1] != '/': server += '/'\n\n username = self._username\n if username == \"doctest\":\n return DoctestServerProxy(self)\n else:\n transport = DigestTransport(realm, server, username, self._password)\n self.__authenticated_server_proxy = ServerProxy(server + 'login/xmlrpc', transport=transport)\n\n return self.__authenticated_server_proxy","def __init__(self,dbname,server_ip,server_port):\n self.dbname = dbname\n self.con = sqlite3.connect(dbname)\n self.cur = self.con.cursor()\n self.server_ip=server_ip\n self.server_port=server_port\n\n # The access method from server initialization\n self.server = SimpleXMLRPCServer((server_ip, int(server_port)))\n logging.info('Server started on %s %s', server_ip, server_port)","def __init__(self, host, user, password, port=443):\n self._host = host\n self._user = user\n self._password = password\n self._port = port\n self.sslContext = ssl._create_unverified_context()\n self._si = self._get_service_instance()","def create_server_certs_sign():\n global server_keystore\n\n dn_sign = \"/CN=server certificate sign RSA-PSS\"\n key_pair_rsa_sign = create_csr_pss(dn_sign)\n server_keystore[\"key-sign\"] = key_pair_rsa_sign[\"key\"]\n san = [f'URI.1 = {uuid.uuid4().urn}']\n server_keystore[\"crt-sign\"] = sign_csr(key_pair_rsa_sign[\"pub\"], dn_sign, san)","def create_server_context(domain, container_path, context_path=None, use_ssl=True):\n server_context = dict(domain=domain, container_path=container_path, context_path=context_path)\n\n if use_ssl:\n scheme = 'https'\n else:\n scheme = 'http'\n scheme += '://'\n\n if use_ssl:\n session = requests.Session()\n session.mount(scheme, SafeTLSAdapter())\n else:\n # TODO: Is there a better way? Can we have session.mount('http')?\n session = requests\n\n server_context['scheme'] = scheme\n server_context['session'] = session\n\n return server_context","def main():\n # if not enough arguments are provided, print an error and exit\n if len(sys.argv) < 3:\n print \"Required Parameters Missing\"\n sys.exit()\n\n # get arguments from console\n # if only host and neuid are provided\n elif len(sys.argv) == 3:\n port = 27993\n sflag = None\n hostname = str(sys.argv[1])\n neuid = str(sys.argv[2])\n \n # if -s flag given (or invalid arguments)\n elif len(sys.argv) == 4:\n if sys.argv[1] == '-s':\n port = 27994\n sflag = True\n else:\n print \"Error: Invalid arguments\"\n sys.exit()\n\n hostname = str(sys.argv[2])\n neuid = str(sys.argv[3])\n \n # if port or sflag are provided\n elif len(sys.argv) == 5:\n if sys.argv[1] == '-p':\n port = int(sys.argv[2])\n sflag = False\n else:\n print 'ERROR: Invalid Argument for Second Parameter'\n sys.exit()\n\n hostname = str(sys.argv[3])\n neuid = str(sys.argv[4])\n\n # if port and sflag are provided\n elif len(sys.argv) == 6:\n if sys.argv[1] == '-p' and sys.argv[3] == '-s':\n port = int(sys.argv[2])\n sflag = True\n else:\n print 'Error: Invalid Argument for port or s flags'\n sys.exit()\n\n hostname = str(sys.argv[4])\n neuid = str(sys.argv[5])\n\n # create the socket\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n # connect the socket to the host\n try:\n s.connect((hostname, port))\n except socket.error:\n print \"Failed To Connect Socket to Host\"\n sys.exit(1)\n\n # if ssl flag is there, create the ssl connection\n if sflag:\n sock = ssl.wrap_socket(s, cert_reqs=ssl.CERT_NONE)\n else:\n sock = s\n\n # send the hello message\n try:\n sock.send(\"cs3700spring2016 HELLO \" + neuid + \"\\n\")\n except socket.error:\n print \"Failed To Send Hello Message\"\n\n # continuously receive and send messages\n while 1:\n global closed_flag\n if closed_flag:\n break\n received = sock.recv(1024)\n if 'BYE' in received:\n print received.split()[2]\n parse_message(received, sock)","def runServer(self, services=[]):\n self.add_routes()\n #debug = self.general_section.get(\"debug\")\n host = self.general_section.get(\"host\")\n use_reloader = ast.literal_eval(self.general_section.get(\"use_reloader\"))\n app_port = int(self.general_section.get(\"port\"))\n cFCGI = ast.literal_eval(self.fcgi_section.get(\"enabled\"))\n fcgi_port = int(self.fcgi_section.get(\"port\"))\n must_have_client_cert = ast.literal_eval(self.certificates_flask_section.get(\"force_client_certificate\"))\n if cFCGI:\n logger.info(\"registering fcgi server at %s:%i\", host, fcgi_port)\n from flup.server.fcgi import WSGIServer\n WSGIServer(self._app, bindAddress=(host, fcgi_port)).run()\n else:\n logger.info(\"registering app server at %s:%i\", host, app_port)\n # this workaround makes sure that the client cert can be acquired later (even when running the development server)\n # copied all this stuff from the actual flask implementation, so we can intervene and adjust the ssl context\n # self._app.run(host=host, port=app_port, ssl_context='adhoc', debug=debug, request_handler=ClientCertHTTPRequestHandler)\n\n # the code from flask's `run...`\n # see https://github.com/mitsuhiko/flask/blob/master/flask/app.py\n #options = {}\n try:\n # now the code from werkzeug's `run_simple(host, app_port, self._app, **options)`\n # see https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/serving.py\n #from werkzeug.debug import DebuggedApplication\n import socket\n #application = DebuggedApplication(self._app, True)\n \n # Set up an SSL context\n context = SSL.Context(SSL.SSLv23_METHOD)\n certs_path = os.path.normpath(os.path.join(os.path.dirname(__file__), \"../../..\", \"cert\"))\n context_crt = os.path.join(certs_path, \"server.crt\")\n context_key = os.path.join(certs_path, \"server.key\")\n try:\n context.use_certificate_file(context_crt)\n context.use_privatekey_file(context_key)\n except Exception as e:\n logger.critical(\"error starting flask server. Cert or key is missing under %s\", certs_path)\n sys.exit(e)\n \n def inner():\n #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')\n server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=context)\n #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=(context_crt, context_key)) \n # The following line is the reason why I copied all that code!\n if must_have_client_cert:\n # FIXME: what works with web app does not work with cli. Check this out\n server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)\n # before enter in the loop, start the supplementary services\n for s in services:\n s.start()\n # That's it\n server.serve_forever()\n address_family = serving.select_ip_version(host, app_port)\n test_socket = socket.socket(address_family, socket.SOCK_STREAM)\n test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n test_socket.bind((host, app_port))\n test_socket.close()\n # Disable reloader only by explicit config setting\n if use_reloader == False:\n serving.run_simple(host, app_port, self._app, use_reloader=False)\n else:\n serving.run_with_reloader(inner, None, 1)\n finally:\n self._app._got_first_request = False","def getContext(self):\n ctx = SSL.Context(SSL.SSLv23_METHOD)\n ctx.use_certificate_file(Settings.BaseDir+'/server.pem')\n ctx.use_privatekey_file(Settings.BaseDir+'/privkey.pem')\n return ctx","def call_rpc(rpc_user, rpc_pwd, method):\n base_url = 'http://127.0.0.1:37128/'\n try:\n response = post(base_url,\n data=method,\n auth=(rpc_user, rpc_pwd)\n )\n except Exception as e:\n response = e\n return evaluate_response(response)","async def test_simple_get_ssl_ctx(app, aiohttp_server, ssl_context):\n server = await aiohttp_server(app, ssl=ssl_context)\n url = \"https://localhost:%d\" % server.port\n\n ssl_context = ssl.create_default_context(\n ssl.Purpose.SERVER_AUTH,\n )\n ssl_context.check_hostname = False\n ssl_context.verify_mode = ssl.CERT_NONE\n async with aiosonic.HTTPClient() as client:\n res = await client.get(url, ssl=ssl_context)\n assert res.status_code == 200\n assert await res.text() == \"Hello, world\"\n await server.close()","def soap_client(self):\n context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)\n context.verify_mode = ssl.CERT_NONE\n return pyVim.connect.SmartConnect(\n host=self.host,\n user=self.settings.username,\n pwd=self.settings.password,\n port=443,\n sslContext=context,\n )","def xmlrpc_response(data):\n xml = xmlrpc_marshal(data)\n response = webob.Response(xml)\n response.content_type = 'text/xml'\n response.content_length = len(xml)\n return response","def __init__(self, server, port, dbname, user, passwd):\n\n\n #-------------------------------------------------------------------------\n #--- WRAPPER XMLRPC OPENERP ----------------------------------------------\n #-------------------------------------------------------------------------\n\n\n self.url_template = \"http://%s:%s/xmlrpc/%s\"\n self.server = server\n self.port = port\n self.dbname = dbname\n self.user_name = user\n self.user_passwd = passwd\n self.user_id = 0\n\n\n #\n # Conectamos con OpenERP\n #\n\n login_facade = xmlrpclib.ServerProxy(self.url_template % (self.server, self.port, 'common'))\n self.user_id = login_facade.login(self.dbname, self.user_name, self.user_passwd)\n self.object_facade = xmlrpclib.ServerProxy(self.url_template % (self.server, self.port, 'object'))","def server(secure=False, idx=0):\n if secure:\n try:\n url = 'https://' + wwl.secure_wwl_servers[idx]\n except:\n url = ''\n else:\n try:\n url = 'http://' + wwl.wwl_servers[idx]\n except:\n url = ''\n return url","def protect_endpoint():\n pass","def render(self, request):\n user = None\n if request.isSecure():\n user = request.channel.transport.getPeerCertificate(\n ).get_subject().commonName\n\n request.content.seek(0, 0)\n args, procedurePath = xmlrpclib.loads(request.content.read())\n args = list(args)\n args.insert(0, user)\n try:\n function = self.lookupProcedure(procedurePath)\n except xmlrpclib.Fault, f:\n self._cbRender(f, request)\n else:\n request.setHeader(\"content-type\", \"text/xml\")\n defer.maybeDeferred(function, *args).addErrback(\n self._ebRender\n ).addCallback(\n self._cbRender, request\n )\n\n return server.NOT_DONE_YET","def handshake(self):\n\n request_line = _build_method_line(self._options.get('resource'))\n self._logger.debug('Client\\'s opening handshake Request-Line: %r',\n request_line)\n self._socket.sendall(request_line)\n\n fields = []\n fields.append(_format_host_header(\n self._options.get('server_host'),\n int(self._options.get('server_port')),\n self._options.get('use_tls')=='True'))\n fields.append(_UPGRADE_HEADER)\n fields.append(_CONNECTION_HEADER)\n if self._options.get('origin') is not None:\n if self._options.get('protocol_version') == _PROTOCOL_VERSION_HYBI08:\n fields.append(_origin_header(\n common.SEC_WEBSOCKET_ORIGIN_HEADER,\n self._options.get('origin')))\n else:\n fields.append(_origin_header(common.ORIGIN_HEADER,\n self._options.get('origin')))\n\n original_key = os.urandom(16)\n self._key = base64.b64encode(original_key)\n self._logger.debug(\n '%s: %r (%s)',\n common.SEC_WEBSOCKET_KEY_HEADER,\n self._key,\n util.hexify(original_key))\n fields.append(\n '%s: %s\\r\\n' % (common.SEC_WEBSOCKET_KEY_HEADER, self._key))\n\n if int(self._options.get('version_header')) > 0:\n fields.append('%s: %d\\r\\n' % (common.SEC_WEBSOCKET_VERSION_HEADER,\n int(self._options.get('version_header'))))\n else:\n fields.append('%s: %d\\r\\n' % (common.SEC_WEBSOCKET_VERSION_HEADER,\n common.VERSION_HYBI_LATEST))\n\n extensions_to_request = []\n\n if self._options.get('deflate_stream') == 'True':\n extensions_to_request.append(\n common.ExtensionParameter(\n common.DEFLATE_STREAM_EXTENSION))\n\n if self._options.get('deflate_frame') == 'True':\n extensions_to_request.append(\n common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION))\n\n if len(extensions_to_request) != 0:\n fields.append(\n '%s: %s\\r\\n' %\n (common.SEC_WEBSOCKET_EXTENSIONS_HEADER,\n common.format_extensions(extensions_to_request)))\n\n for field in fields:\n self._socket.sendall(field)\n\n self._socket.sendall('\\r\\n')\n\n self._logger.debug('Sent client\\'s opening handshake headers: %r',\n fields)\n self._logger.debug('Start reading Status-Line')\n\n status_line = ''\n while True:\n ch = _receive_bytes(self._socket, 1)\n status_line += ch\n if ch == '\\n':\n break\n\n m = re.match('HTTP/\\\\d+\\.\\\\d+ (\\\\d\\\\d\\\\d) .*\\r\\n', status_line)\n if m is None:\n raise ClientHandshakeError(\n 'Wrong status line format: %r' % status_line)\n status_code = m.group(1)\n if status_code != '101':\n self._logger.debug('Unexpected status code %s with following '\n 'headers: %r', status_code, self._read_fields())\n raise ClientHandshakeError(\n 'Expected HTTP status code 101 but found %r' % status_code)\n\n self._logger.debug('Received valid Status-Line')\n self._logger.debug('Start reading headers until we see an empty line')\n\n fields = self._read_fields()\n\n ch = _receive_bytes(self._socket, 1)\n if ch != '\\n': # 0x0A\n raise ClientHandshakeError(\n 'Expected LF but found %r while reading value %r for header '\n 'name %r' % (ch, \"test\", \"test\"))\n\n self._logger.debug('Received an empty line')\n self._logger.debug('Server\\'s opening handshake headers: %r', fields)\n\n _validate_mandatory_header(\n fields,\n common.UPGRADE_HEADER,\n common.WEBSOCKET_UPGRADE_TYPE,\n False)\n\n _validate_mandatory_header(\n fields,\n common.CONNECTION_HEADER,\n common.UPGRADE_CONNECTION_TYPE,\n False)\n\n accept = _get_mandatory_header(\n fields, common.SEC_WEBSOCKET_ACCEPT_HEADER)\n\n # Validate\n try:\n binary_accept = base64.b64decode(accept)\n except TypeError, e:\n raise HandshakeError(\n 'Illegal value for header %s: %r' %\n (common.SEC_WEBSOCKET_ACCEPT_HEADER, accept))\n\n if len(binary_accept) != 20:\n raise ClientHandshakeError(\n 'Decoded value of %s is not 20-byte long' %\n common.SEC_WEBSOCKET_ACCEPT_HEADER)\n\n self._logger.debug(\n 'Response for challenge : %r (%s)',\n accept, util.hexify(binary_accept))\n\n binary_expected_accept = util.sha1_hash(\n self._key + common.WEBSOCKET_ACCEPT_UUID).digest()\n expected_accept = base64.b64encode(binary_expected_accept)\n\n self._logger.debug(\n 'Expected response for challenge: %r (%s)',\n expected_accept, util.hexify(binary_expected_accept))\n\n if accept != expected_accept:\n raise ClientHandshakeError(\n 'Invalid %s header: %r (expected: %s)' %\n (common.SEC_WEBSOCKET_ACCEPT_HEADER, accept, expected_accept))\n\n deflate_stream_accepted = False\n deflate_frame_accepted = False\n\n extensions_header = fields.get(\n common.SEC_WEBSOCKET_EXTENSIONS_HEADER.lower())\n accepted_extensions = []\n if extensions_header is not None and len(extensions_header) != 0:\n accepted_extensions = common.parse_extensions(extensions_header[0])\n # TODO(bashi): Support the new style perframe compression extension.\n for extension in accepted_extensions:\n extension_name = extension.name()\n if (extension_name == common.DEFLATE_STREAM_EXTENSION and\n len(extension.get_parameter_names()) == 0 and\n self._options.get('deflate_stream')=='True'):\n deflate_stream_accepted = True\n continue\n\n if (extension_name == common.DEFLATE_FRAME_EXTENSION and\n self._options.get('deflate_frame')=='True'):\n deflate_frame_accepted = True\n processor = DeflateFrameExtensionProcessor(extension)\n unused_extension_response = processor.get_extension_response()\n self._options['deflate_frame'] = processor\n continue\n\n raise ClientHandshakeError(\n 'Unexpected extension %r' % extension_name)\n\n if (self._options.get('deflate_stream') == 'True' and not deflate_stream_accepted):\n raise ClientHandshakeError(\n 'Requested %s, but the server rejected it' %\n common.DEFLATE_STREAM_EXTENSION)\n\n if (self._options.get('deflate_frame') == 'True' and not deflate_frame_accepted):\n raise ClientHandshakeError(\n 'Requested %s, but the server rejected it' %\n common.DEFLATE_FRAME_EXTENSION)","def create_server_certs_enc():\n global server_keystore, config\n\n same_enc_sign_cert = config[\"config\"][\"same_enc_sign_cert\"]\n if same_enc_sign_cert:\n dn = \"/CN=server certificate RSA\"\n else:\n dn = \"/CN=server certificate encryption RSA\"\n key_pair_rsa = create_csr(dn)\n server_keystore[\"key\"] = key_pair_rsa[\"key\"]\n san = [f'URI.1 = {uuid.uuid4().urn}']\n server_keystore[\"crt\"] = sign_csr(key_pair_rsa[\"pub\"], dn, san)","def add_endpoint_to_sipserver(self, endpoint: str, password: str) -> None:","def __init__(self, server, ssl=True, username=None, password=None):\n self.server = server\n\n authstring = 'Basic ' + string.strip(base64.encodestring(username + ':' + password))\n self.auth = authstring if username and password else None\n\n self.connection_method = httplib.HTTPSConnection if ssl else httplib.HTTPConnection","def __init__(self, addr=(\"localhost\", 8000)):\n\n Thread.__init__(self)\n RPCBaseProxy.__init__(self)\n\n self.__instances = []\n\n self.__server = SimpleXMLRPCServer(addr=addr, logRequests=False, requestHandler=SimpleXMLRPCRequestHandler)\n self.__server.register_instance(self)","def run_server(port, settings, keyfile=None, certfile=None):\n create_server(port, settings, keyfile, certfile).serve_forever()","def start_websocket_server(self, addr, port):\n app = SLSApplication(self, default_host=addr)\n app.listen(port)\n log.info(f\"Serving SLS/Websocket on ({addr}, {port})\")\n tornado.ioloop.IOLoop.current().start()","def test_peercreds_unix_sock(peercreds_enabled_server_and_client):\n httpserver, testclient = peercreds_enabled_server_and_client\n\n unix_base_uri = 'http+unix://{}'.format(\n httpserver.bind_addr.replace('/', '%2F'),\n )\n\n expected_peercreds = os.getpid(), os.getuid(), os.getgid()\n expected_peercreds = '|'.join(map(str, expected_peercreds))\n\n with requests_unixsocket.monkeypatch():\n peercreds_resp = requests.get(unix_base_uri + PEERCRED_IDS_URI)\n peercreds_resp.raise_for_status()\n assert peercreds_resp.text == expected_peercreds\n\n peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI)\n assert peercreds_text_resp.status_code == 500","def connect(server, user=None, password=None, verify=True, netrc_file=None, debug=False,\n extension_types=True, loglevel=None, logger=None, detect_redirect=True,\n no_parse_model=False):\n\n # Generate a hash for the connection\n hasher = hashlib.md5()\n hasher.update(server.encode('utf-8'))\n hasher.update(str(time.time()).encode('utf-8'))\n connection_id = hasher.hexdigest()\n\n # Setup the logger for this connection\n if logger is None:\n logger = logging.getLogger('xnat-{}'.format(connection_id))\n handler = logging.StreamHandler()\n handler.setLevel(logging.DEBUG)\n logger.addHandler(handler)\n\n # create formatter\n if debug:\n formatter = logging.Formatter('[%(asctime)s] %(levelname)s: %(module)s:%(lineno)d >> %(message)s')\n else:\n formatter = logging.Formatter('[%(levelname)s] %(message)s')\n handler.setFormatter(formatter)\n\n if loglevel is not None:\n logger.setLevel(loglevel)\n elif debug:\n logger.setLevel('DEBUG')\n else:\n logger.setLevel('WARNING')\n\n # If verify is False, disable urllib3 warning and give a one time warning!\n if not verify:\n logger.warning('Verify is disabled, this will NOT verify the certificate of SSL connections!')\n logger.warning('Warnings about invalid certificates will be HIDDEN to avoid spam, but this')\n logger.warning('means that your connection can be potentially unsafe!')\n requests.packages.urllib3.disable_warnings()\n\n if user is None and password is None:\n user, password = query_netrc(server, netrc_file, logger)\n\n if user is not None and password is None:\n password = getpass.getpass(prompt=str(\"Please enter the password for user '{}':\".format(user)))\n\n # Create the correct requests session\n requests_session = requests.Session()\n\n if user is not None:\n requests_session.auth = (user, password)\n\n if not verify:\n requests_session.verify = False\n\n # Check for redirects\n original_uri = server\n if detect_redirect:\n server = detect_redirection(server, requests_session, logger)\n\n # If no login was found, check if the new server has a known login as a backup\n if original_uri != server and user is None and password is None:\n user, password = query_netrc(server, netrc_file, logger)\n\n # Check if login is successful\n logged_in_user = check_auth(requests_session, server=server, user=user, logger=logger)\n\n # Create the XNAT connection\n xnat_session = XNATSession(server=server, logger=logger,\n interface=requests_session, debug=debug,\n original_uri=original_uri, logged_in_user=logged_in_user)\n\n # Parse data model and create classes\n if not no_parse_model:\n build_model(xnat_session, extension_types=extension_types, connection_id=connection_id)\n\n return xnat_session","def beta_create_wxAuth_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):\n request_deserializers = {\n ('wxAuth', 'CallAutoEditor'): AuthRequest.FromString,\n ('wxAuth', 'checkClient2Version'): AuthRequest.FromString,\n ('wxAuth', 'checkClientVersion'): AuthRequest.FromString,\n ('wxAuth', 'checkServerVersion'): AuthRequest.FromString,\n ('wxAuth', 'checkWxBot'): AuthRequest.FromString,\n ('wxAuth', 'getWxBotKey'): AuthRequest.FromString,\n ('wxAuth', 'runAEScript'): AuthRequest.FromString,\n ('wxAuth', 'wxRPCAuth'): AuthRequest.FromString,\n }\n response_serializers = {\n ('wxAuth', 'CallAutoEditor'): AuthReply.SerializeToString,\n ('wxAuth', 'checkClient2Version'): AuthReply.SerializeToString,\n ('wxAuth', 'checkClientVersion'): AuthReply.SerializeToString,\n ('wxAuth', 'checkServerVersion'): AuthReply.SerializeToString,\n ('wxAuth', 'checkWxBot'): AuthReply.SerializeToString,\n ('wxAuth', 'getWxBotKey'): ByteReplay.SerializeToString,\n ('wxAuth', 'runAEScript'): AuthReply.SerializeToString,\n ('wxAuth', 'wxRPCAuth'): AuthReply.SerializeToString,\n }\n method_implementations = {\n ('wxAuth', 'CallAutoEditor'): face_utilities.unary_unary_inline(servicer.CallAutoEditor),\n ('wxAuth', 'checkClient2Version'): face_utilities.unary_unary_inline(servicer.checkClient2Version),\n ('wxAuth', 'checkClientVersion'): face_utilities.unary_unary_inline(servicer.checkClientVersion),\n ('wxAuth', 'checkServerVersion'): face_utilities.unary_unary_inline(servicer.checkServerVersion),\n ('wxAuth', 'checkWxBot'): face_utilities.unary_unary_inline(servicer.checkWxBot),\n ('wxAuth', 'getWxBotKey'): face_utilities.unary_unary_inline(servicer.getWxBotKey),\n ('wxAuth', 'runAEScript'): face_utilities.unary_unary_inline(servicer.runAEScript),\n ('wxAuth', 'wxRPCAuth'): face_utilities.unary_unary_inline(servicer.wxRPCAuth),\n }\n server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)\n return beta_implementations.server(method_implementations, options=server_options)","def set_credentials(self, username, password, url):\n # remove trailing slash off URL\n url = url.rstrip('/')\n # save variables to object\n self.url = url\n self.username = username\n self.password = password\n self.xml_rpc = '%s/server/xml.server.php' % (self.url)","def __init__(self, server, ressource):\n self.server = server\n local_url = \"http://%s:%d/xmlrpc/common\" % (\n server.server_url,\n server.server_port,\n )\n rpc = ServerProxy(local_url)\n self.uid = rpc.login(server.server_db, server.login, server.password)\n local_url = \"http://%s:%d/xmlrpc/object\" % (\n server.server_url,\n server.server_port,\n )\n self.rpc = ServerProxy(local_url)\n self.ressource = ressource","def ssl_wrap_socket(socket, ssl_options, server_hostname=..., **kwargs):\n ...","def run():\n global base_dir\n \n cert_path = os.path.join(base_dir, 'cert.pem')\n key_path = os.path.join(base_dir, 'key.pem')\n if os.path.isfile(cert_path) and os.path.isfile(key_path):\n logging.info('Found SSL certificate files cert.pem and key.pem')\n logging.info('Server will run in HTTPS mode')\n try:\n app.run(host=cfg.cfg['ADDRESS'], port=cfg.cfg['PORT'], ssl_context=(cert_path, key_path))\n except ssl.SSLError:\n logging.error('Detected problem with certificate files!')\n logging.error('Server will not start!')\n else:\n logging.warning('SSL certificate files cert.pem and key.pem not found!')\n logging.warning('Server will run in HTTP mode!')\n app.run(host=cfg.cfg['ADDRESS'], port=cfg.cfg['PORT'])","def tls_http_server(request):\n return functools.partial(make_tls_http_server, request=request)","def create_server(\n handle_event: EventCallback,\n host: str = \"0.0.0.0\",\n port: int = 0,\n ssl_context: Optional[SSLContext] = None,\n) -> Server:\n return Server(handle_event, host, port, ssl_context)","def xmlrpc_namespace():","def _anonymous_server_proxy(self):\n if self.__anonymous_server_proxy is None:\n realm = REALM\n if \"realm\" in self._config:\n realm = self._config[\"realm\"]\n server = TRAC_SERVER_URI\n if \"server\" in self._config:\n server = self._config[\"server\"]\n if server[-1] != '/': server += '/'\n\n transport = DigestTransport(realm, server)\n self.__anonymous_server_proxy = ServerProxy(server + 'xmlrpc', transport=transport)\n return self.__anonymous_server_proxy","def update_endpoint_in_sipserver(self, endpoint: str, password: str) -> None:","def websocket_proxy_server(url, key=\"\"):\n def create_on_message(conn):\n def _fsend(data):\n data = bytes(data)\n conn.write_message(data, binary=True)\n return len(data)\n on_message = rpc._CreateEventDrivenServer(_fsend, \"WebSocketProxyServer\")\n return on_message\n\n @gen.coroutine\n def _connect(key):\n conn = yield websocket.websocket_connect(url)\n on_message = create_on_message(conn)\n temp = _server_env()\n # Start connecton\n conn.write_message(struct.pack('@i', RPC_MAGIC), binary=True)\n key = \"server:\" + key\n conn.write_message(struct.pack('@i', len(key)), binary=True)\n conn.write_message(key.encode(\"utf-8\"), binary=True)\n msg = yield conn.read_message()\n assert len(msg) >= 4\n magic = struct.unpack('@i', msg[:4])[0]\n if magic == RPC_MAGIC + 1:\n raise RuntimeError(\"key: %s has already been used in proxy\" % key)\n elif magic == RPC_MAGIC + 2:\n logging.info(\"RPCProxy do not have matching client key %s\", key)\n elif magic != RPC_MAGIC:\n raise RuntimeError(\"%s is not RPC Proxy\" % url)\n logging.info(\"Connection established\")\n msg = msg[4:]\n if msg:\n on_message(bytearray(msg), 3)\n\n while True:\n try:\n msg = yield conn.read_message()\n if msg is None:\n break\n on_message(bytearray(msg), 3)\n except websocket.WebSocketClosedError as err:\n break\n logging.info(\"WebSocketProxyServer closed...\")\n temp.remove()\n ioloop.IOLoop.current().stop()\n ioloop.IOLoop.current().spawn_callback(_connect, key)\n ioloop.IOLoop.current().start()","def is_secure_transport(request: Request) -> bool:\n if request.settings.INSECURE_TRANSPORT:\n return True\n return request.url.lower().startswith(\"https://\")","def insecure(self) -> bool:\n return self._insecure","def do_server(wrapping_key_public):\n secret = os.urandom(32)\n logging.info(f'secret: {hexlify(secret)}')\n\n ref_path = 'server-secret-for-reference.bin'\n logging.debug(f'creating {ref_path}')\n with open(ref_path, 'wb') as f:\n f.write(secret)\n\n # generate IV\n iv = os.urandom(12)\n logging.debug(f'iv: {hexlify(iv)}')\n\n # generate 256-bit AES encryption key\n ephemeral_key = os.urandom(32)\n logging.debug(f'ephemeral_key: {hexlify(ephemeral_key)}')\n\n # xor_mask = os.urandom(32)\n xor_mask = b'\\x00' * 32\n logging.debug(f'xor_mask: {hexlify(xor_mask)}')\n\n # xor with mask to get transportKey\n transport_key = bytes([ephemeral_key[i] ^ xor_mask[i] for i in range(32)])\n logging.debug(f'transport_key: {hexlify(transport_key)}')\n\n logging.debug(f'wrapping the transport key with the public RSA wrapping key')\n encrypted_transport_key = wrap(wrapping_key_public, transport_key)\n\n logging.debug(f'encrypting the secure secret with the AES ephermeral key')\n encrypted_secret, tag = encrypt(ephemeral_key, iv, secret)\n\n logging.debug(f'encrypted_secret: {hexlify(encrypted_secret)}')\n logging.debug(f'tag: {hexlify(tag)}')\n\n authorizationList = AuthorizationList()\n\n key_description = KeyDescription()\n key_description['keyFormat'] = KM_KEY_FORMAT_RAW\n key_description['keyParams'] = authorizationList\n\n secure_key_wrapper = SecureKeyWrapper()\n secure_key_wrapper['version'] = 0\n secure_key_wrapper['encryptedTransportKey'] = encrypted_transport_key\n secure_key_wrapper['initializationVector'] = iv\n secure_key_wrapper['keyDescription'] = key_description\n secure_key_wrapper['encryptedKey'] = encrypted_secret\n secure_key_wrapper['tag'] = tag\n\n encoded_secure_key_wrapper = encode_secure_key_wrapper(secure_key_wrapper)\n\n return encoded_secure_key_wrapper, xor_mask","def servant():\n pass","def peercreds_enabled_server_and_client(http_server, unix_sock_file):\n httpserver = http_server.send(unix_sock_file)\n httpserver.gateway = _TestGateway\n httpserver.peercreds_enabled = True\n return httpserver, get_server_client(httpserver)","def do_POST(self):\n\n try:\n # get arguments\n data = self.rfile.read(int(self.headers[\"content-length\"]))\n # In previous versions of SimpleXMLRPCServer, _dispatch\n # could be overridden in this class, instead of in\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\n # check to see if a subclass implements _dispatch and dispatch\n # using that method if present.\n response = self.server._marshaled_dispatch(\n data, getattr(self, '_dispatch', None)\n )\n except: # This should only happen if the module is buggy\n # internal error, report as HTTP server error\n self.send_response(500)\n self.end_headers()\n else:\n # got a valid XML RPC response\n self.send_response(200)\n self.send_header(\"Content-type\", \"text/xml\")\n self.send_header(\"Content-length\", str(len(response)))\n self.end_headers()\n self.wfile.write(response)\n\n # shut down the connection\n self.wfile.flush()\n self.connection.shutdown() # Modified here!","def __init__(self):\n self.host = CONF.zvm.zvm_xcat_server\n self.port = 443\n self.conn = HTTPSClientAuthConnection(self.host, self.port,\n CONF.zvm.zvm_xcat_ca_file,\n timeout=CONF.zvm.zvm_xcat_connection_timeout)","def context():\n return Context(SSLv23_METHOD)","def __get_http2_ssl_context(self):\n # Get the basic context from the standard library.\n if self.client_side == False:\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)\n self.ctx = ssl._create_unverified_context()\n else:\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH, cafile=self.server_cert)\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)\n self.ctx = ssl._create_unverified_context()\n\n # RFC 7540 Section 9.2: Implementations of HTTP/2 MUST use TLS version 1.2\n # or higher. Disable TLS 1.1 and lower.\n self.ctx.options |= (\n ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1\n )\n\n # RFC 7540 Section 9.2.1: A deployment of HTTP/2 over TLS 1.2 MUST disable\n # compression.\n self.ctx.options |= ssl.OP_NO_COMPRESSION\n\n # RFC 7540 Section 9.2.2: \"deployments of HTTP/2 that use TLS 1.2 MUST\n # support TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256\". In practice, the\n # blacklist defined in this section allows only the AES GCM and ChaCha20\n # cipher suites with ephemeral key negotiation.\n\n\n if self.client_side == False:\n self.ctx.load_cert_chain(certfile=self.server_cert, keyfile=self.server_key)\n self.ctx.load_verify_locations(cafile=self.client_certs) \n else:\n self.ctx.load_cert_chain(certfile=self.client_certs, keyfile=self.client_key)\n self.ctx.load_verify_locations(cafile=self.client_certs) \n pass\n\n\n\n # We want to negotiate using NPN and ALPN. ALPN is mandatory, but NPN may\n # be absent, so allow that. This setup allows for negotiation of HTTP/1.1.\n self.ctx.set_alpn_protocols([\"h2\", \"http/1.1\"])\n\n try:\n self.ctx.set_npn_protocols([\"h2\", \"http/1.1\"])\n except NotImplementedError as e:\n print(\"TLS Error: NotImplementedError=%s\" % (e))\n pass\n\n #self.ctx = ctx\n\n return True","async def _create_context(self) -> ssl.SSLContext:\n context = utils.server_context_modern()\n\n await self.cloud.run_executor(\n context.load_cert_chain,\n self._acme.path_fullchain,\n self._acme.path_private_key,\n )\n\n return context","def force_communicate_tls(rest: ClusterManager) -> bool:\n settings, err = rest.get_security_settings()\n _exit_if_errors(err)\n\n # The cluster isn't using 'strict' cluster encryption, we shouldn't need to force enable TLS\n if 'clusterEncryptionLevel' not in settings or settings['clusterEncryptionLevel'] != 'strict':\n return False\n\n # The user might not have used a 'https://' scheme prefix, so communicating to other nodes via the secure ports may\n # lead to interesting/surprising errors; let them know beforehand.\n _warning(\"sub-command requires multi-node communication via TLS enabled ports, '--cacert' or \"\n \"'--no-ssl-verify' may need to be supplied\")\n\n return True","def __init__(self, use_datetime=0,\r\n username=None, password=None,\r\n certChain=None, privateKey=None,\r\n checker=None,\r\n settings=None,\r\n ignoreAbruptClose=False):\r\n\r\n # self._connection is new in python 2.7, since we're using it here,\r\n # we'll add this ourselves too, just in case we're pre-2.7\r\n self._connection = (None, None)\r\n xmlrpclib.Transport.__init__(self, use_datetime)\r\n self.ignoreAbruptClose = ignoreAbruptClose\r\n ClientHelper.__init__(self,\r\n username, password, \r\n certChain, privateKey,\r\n checker,\r\n settings)","def secure(self) -> bool:\n return self.get_state(self.args[CONF_OVERALL_SECURITY_STATUS]) == \"Secure\"","def StartServer(serve_webapp=True, serve_static_web=True, serve_admin=True):\n client = db_client.DBClient.Instance()\n\n settings = {\n 'gzip': True,\n 'login_url': '/',\n 'admin_login_url': '/admin/otp',\n 'domain': options.options.domain,\n 'server_version': options.options.server_version,\n 'cookie_secret': secrets.GetSecret('cookie_secret'),\n 'facebook_api_key': secrets.GetSecret('facebook_api_key'),\n 'facebook_secret': secrets.GetSecret('facebook_secret'),\n 'google_client_id': secrets.GetSecret('google_client_id'),\n 'google_client_secret': secrets.GetSecret('google_client_secret'),\n 'google_client_mobile_id': secrets.GetSecret('google_client_mobile_id'),\n 'google_client_mobile_secret': secrets.GetSecret('google_client_mobile_secret'),\n 'template_path': ResourcesManager.Instance().template_path,\n 'ui_modules': uimodules,\n 'xsrf_cookies' : options.options.enable_xsrf,\n 'debug': options.options.server_debug,\n 'static_path': ResourcesManager.Instance().static_path,\n }\n\n if options.options.log_file_prefix:\n settings['logs_dir'] = os.path.dirname(options.options.log_file_prefix)\n\n # Configure metrics uploading.\n if options.options.upload_metrics:\n for interval in metric.METRIC_INTERVALS:\n metric.Metric.StartMetricUpload(client, metric.DEFAULT_CLUSTER_NAME, interval)\n\n # Setup application and SSL HTTP server.\n handlers = deepcopy(COMMON_HANDLERS)\n if serve_webapp:\n # Configure web application handlers.\n webapp_handlers = deepcopy(WEBAPP_HANDLERS)\n\n # Initialize the file object store if specified.\n obj_store = ObjectStore.GetInstance(ObjectStore.PHOTO)\n settings['obj_store'] = obj_store\n if options.options.fileobjstore:\n for store_name, content_type in ((ObjectStore.PHOTO, r'image/jpeg'),\n (ObjectStore.USER_LOG, r'text/plain'),\n (ObjectStore.USER_ZIPS, r'application/zip')):\n webapp_handlers.append((r'/fileobjstore/%s/(.*)' % store_name,\n file_object_store.FileObjectStoreHandler,\n { 'storename': store_name, 'contenttype': content_type}))\n\n if ServerEnvironment.IsDevBox():\n webapp_handlers.append((r'/(link|login|register)/fakeviewfinder', auth_viewfinder.FakeAuthViewfinderHandler))\n # Set the testing directories.\n if options.options.testing_path is not None:\n webapp_handlers.append((r'/testing/hook/(.*)', test_hook.TestHookHandler))\n webapp_handlers.append((r'/testing/static/(.*)',\n web.StaticFileHandler,\n {'path': '%s' % options.options.testing_path}))\n\n handlers.extend(webapp_handlers)\n\n if serve_static_web:\n # Configure static web handlers.\n static_web_handlers = deepcopy(STATIC_WEB_HANDLERS)\n handlers.extend(static_web_handlers)\n\n if serve_admin:\n # Configure and verify admin handlers.\n admin_handlers = deepcopy(ADMIN_HANDLERS)\n for path, handler in admin_handlers:\n if not issubclass(handler, basic_auth.BasicAuthHandler):\n raise TypeError('Administration handlers must '\n 'subclass BasicAuthHandler')\n handlers.extend(admin_handlers)\n\n # Catch-all handler for 404 pages.\n handlers.extend([(r'/.*', base.PageNotFoundHandler)])\n\n # Create application and separately add handlers for the short domain and the \n # regular domain. \n # \n # Note that, although the short-domain handlers are added after the initial construction\n # of the Application, those routes will take priority over the routes in the handlers \n # array.\n application = web.Application(handlers, **settings)\n application.add_handlers(re.escape(options.options.short_domain), SHORT_DOMAIN_HANDLERS)\n\n # Start the HTTP server.\n http_server = httpserver.HTTPServer(\n application, xheaders=options.options.xheaders,\n ssl_options={\n 'certfile': secrets.GetSecretFile('%s.crt' % settings['domain']),\n 'keyfile': secrets.GetSecretFile('%s.key' % settings['domain']),\n } if options.options.ssl else None)\n with stack_context.NullContext():\n http_server.listen(options.options.port)\n\n # Setup redirect server for HTTP -> HTTPS.\n if options.options.ssl:\n http_settings = {\n 'host': ServerEnvironment.GetHost(),\n 'redirect_port': options.options.redirect_port,\n 'xheaders': options.options.xheaders,\n }\n\n redirect_handlers = [\n (r'/(.*)', index.RedirectHandler),\n ]\n redirect_server = httpserver.HTTPServer(web.Application(\n redirect_handlers, **http_settings))\n with stack_context.NullContext():\n redirect_server.listen(options.options.insecure_port)\n\n # Ensure that system users have been created if running with a local db (needs server to be running).\n if options.options.localdb:\n yield CreateSystemUsers(client)\n\n # Run the server until it hits an exception or stop signal.\n yield gen.Task(lambda callback: None)","def poodle():\n with settings(hide('everything'), warn_only=True):\n check_accept = re.compile(r'\\bCipher\\sis\\b')\n check_cypher = re.compile(r'\\bCipher\\s*:\\s0000\\b|'\n r'\\bCipher\\s*:\\s\\(NONE\\)\\b')\n try:\n result = 'Poodle '\n timeout = run('which timeout')\n ssl2test = run('%s 3 openssl s_client -ssl2 -connect localhost:443'\n % timeout)\n if check_accept.search(ssl2test):\n check_ssl2 = check_cypher.search(ssl2test)\n if check_ssl2:\n result += 'SSLv2: OK'\n else:\n result += 'SSLv2: VULNERABLE'\n else:\n result += 'SSLv2: OK'\n ssl3test = run('%s 3 openssl s_client -ssl3 -connect localhost:443'\n % timeout)\n if check_accept.search(ssl2test):\n check_ssl3 = check_cypher.search(ssl3test)\n if check_ssl3:\n result += ' / SSLv3: OK'\n else:\n result += ' / SSLv3: VULNERABLE'\n else:\n result += ' / SSLv3: OK'\n print(\"%s: %s\" % (env.host, result))\n logging.warning(\"%s: %s\" % (env.host, result))\n except Exception as e:\n logging.warning('%s: Error: %s' % (env.host, e.message))","def __init__(self, host='localhost', port=9091, path='/transmission/rpc',\n username=None, password=None, ssl=False, timeout=DEFAULT_TIMEOUT):\n if ssl:\n scheme = 'https'\n else:\n scheme = 'http'\n\n self.url = \"%s://%s:%d%s\" % (scheme, host, port, path)\n self.headers = {} # type: Dict[str, str]\n self.tag = 0\n self.timeout = timeout\n\n self.auth = None # type: Tuple[str, str]\n if username or password:\n self.auth = (username, password)","def server():\n package('apache2')\n require_started('apache2')","def server_address():\n return '127.0.0.1'","def _get_socket(self, secure=False, timeout=None):\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.settimeout(timeout or self.timeout)\n\n if secure:\n # Setting Purpose to CLIENT_AUTH might seem a bit backwards. But\n # SOS Access v4 is using SSL/TLS for encryption not authentications\n # and verification. There is no cert and no hostname to check so\n # setting the purpose to Client Auth diables that in a nifty way.\n self.context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)\n return self.context.wrap_socket(sock)\n\n else:\n return sock","def setup_server():\n cherrypy.config.update('server.conf')\n cherrypy.tree.mount(StringGeneratorWebService(), '/', 'server.conf')","def _send_xml(self, url, xml):\n http = httplib2.Http()\n headers = {\"Content-type\": \"application/x-www-form-urlencoded\",\n \"Authorization\": \"Basic %s\" % self.get_basic_auth()}\n return http.request(url, \"POST\", xml, headers=headers)","def create_server(host, port, uid, pwd):\r\n s = smtplib.SMTP(host, port)\r\n s.starttls()\r\n s.login(\r\n uid,\r\n pwd\r\n )\r\n return s","def __init__(self, host, port=10035, user=None, password=None, cainfo=None, sslcert=None, verifyhost=None, verifypeer=None, **options):\n \n if re.match('^https?://', host):\n uri = host + ':%d'\n self._client = miniserver.Client(uri % port, user, password, cainfo, sslcert, verifyhost, verifypeer)\n elif sslcert != None:\n uri = 'https://%s:%d'\n self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)\n else:\n uri = 'http://%s:%d'\n self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)\n \n #self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)"],"string":"[\n \"def ServerApp(stream, certfile, keyfile):\\n\\n def secured():\\n print 'server secured!'\\n wait()\\n\\n def read(line):\\n line = line.strip()\\n print 'client said: %r.' % line\\n\\n if line == 'QUIT':\\n write('GOODBYE')\\n elif line == 'STARTTLS':\\n stream.write('PROCEED\\\\n')\\n stream.starttls(\\n secured,\\n server_side=True,\\n certfile=certfile,\\n keyfile=keyfile\\n )\\n else:\\n write('YOU SAID: %r' % line)\\n\\n def write(data):\\n stream.write('%s\\\\n' % data)\\n wait()\\n\\n def wait():\\n stream.read_until('\\\\n', read)\\n\\n ## Begin\\n print 'starting server: %r' % stream.socket.fileno()\\n wait()\",\n \"def __init__(self, server_address, HandlerClass, logRequests=False):\\n self.logRequests = logRequests\\n\\n SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self)\\n SocketServer.BaseServer.__init__(self, server_address, HandlerClass)\\n ctx = SSL.Context(SSL.SSLv23_METHOD)\\n\\n ctx.use_privatekey_file (XMLRPC_SERVER_KEYFILE)\\n ctx.use_certificate_file(XMLRPC_SERVER_CERTFILE)\\n self.socket = SSL.Connection(ctx, socket.socket(self.address_family,\\n self.socket_type))\\n self.server_bind()\\n self.server_activate()\",\n \"def __init__(self, uri, x509=None, Transport=None):\\n xmlrpclib.ServerProxy.__init__(self, uri, transport=Transport)\\n self.x509 = x509\",\n \"def _server(self, sock):\\n # Create the server side Connection. This is mostly setup boilerplate\\n # - use TLSv1, use a particular certificate, etc.\\n server_ctx = Context(SSLv23_METHOD)\\n server_ctx.set_options(OP_NO_SSLv2 | OP_NO_SSLv3 | OP_SINGLE_DH_USE)\\n server_ctx.set_verify(\\n VERIFY_PEER | VERIFY_FAIL_IF_NO_PEER_CERT | VERIFY_CLIENT_ONCE,\\n verify_cb,\\n )\\n server_store = server_ctx.get_cert_store()\\n server_ctx.use_privatekey(\\n load_privatekey(FILETYPE_PEM, server_key_pem)\\n )\\n server_ctx.use_certificate(\\n load_certificate(FILETYPE_PEM, server_cert_pem)\\n )\\n server_ctx.check_privatekey()\\n server_store.add_cert(load_certificate(FILETYPE_PEM, root_cert_pem))\\n # Here the Connection is actually created. If None is passed as the\\n # 2nd parameter, it indicates a memory BIO should be created.\\n server_conn = Connection(server_ctx, sock)\\n server_conn.set_accept_state()\\n return server_conn\",\n \"def createSimpleXMLRPCServer(host, ports):\\n\\tfor port in ports:\\n\\t\\ttry:\\n\\t\\t\\tres = xserver.SimpleXMLRPCServer((host,port))\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint(\\\"Retrying:%s\\\"%(e))\\n\\t\\telse:\\n\\t\\t\\tres.logRequests = 0 # hint from newsgroup to disable the - - [13/Apr/2007 13:33:57] \\\"POST /RPC2 HTTP/1.0\\\" 200 - output with every request\\n\\t\\t\\treturn res\",\n \"def GetRpcServer(options):\\n\\n rpc_server_class = HttpRpcServer\\n\\n def GetUserCredentials():\\n \\\"\\\"\\\"Prompts the user for a username and password.\\\"\\\"\\\"\\n email = options.email\\n if email is None:\\n email = GetEmail(\\\"Email (login for uploading to %s)\\\" % options.server)\\n password = getpass.getpass(\\\"Password for %s: \\\" % email)\\n return (email, password)\\n\\n # If this is the dev_appserver, use fake authentication.\\n host = (options.host or options.server).lower()\\n if host == \\\"localhost\\\" or host.startswith(\\\"localhost:\\\"):\\n email = options.email\\n if email is None:\\n email = \\\"test@example.com\\\"\\n logging.info(\\\"Using debug user %s. Override with --email\\\" % email)\\n server = rpc_server_class(\\n options.server,\\n lambda: (email, \\\"password\\\"),\\n host_override=options.host,\\n extra_headers={\\\"Cookie\\\":\\n 'dev_appserver_login=\\\"%s:False\\\"' % email},\\n save_cookies=options.save_cookies)\\n # Don't try to talk to ClientLogin.\\n server.authenticated = True\\n return server\\n\\n return rpc_server_class(options.server, GetUserCredentials,\\n host_override=options.host,\\n save_cookies=options.save_cookies)\",\n \"def xs_connection(password, url, user='root'):\\n \\n conn = xmlrpclib.Server(url)\\n connection = conn.session.login_with_password(user, password)\\n \\n if connection['Status'] == 'Success':\\n token = connection['Value']\\n sys.stderr.write (\\\"\\\\n Connection unique ref: %s\\\\n\\\" %token)\\n else :\\n for i in connection['ErrorDescription']:\\n sys.stderr.write(i)\\n try :\\n sys.remove(pid_file)\\n except OSError as e:\\n sys.stderr.write(str(e))\\n sys.exit(3)\\n return conn, token\",\n \"def __init__(self):\\n try:\\n context = ssl.create_default_context(\\n purpose=ssl.Purpose.CLIENT_AUTH)\\n context.options |= ssl.OP_NO_SSLv2\\n context.options |= ssl.OP_NO_SSLv3\\n context.options |= ssl.OP_NO_TLSv1\\n context.options |= ssl.OP_NO_TLSv1_1\\n context.options |= ssl.OP_NO_COMPRESSION\\n context.verify_mode = ssl.CERT_REQUIRED\\n # TODO do not use static configuration parameters\\n context.load_verify_locations(cafile='/sbin/rpcsd/root.cert.pem')\\n context.load_cert_chain(certfile='/sbin/rpcsd/gaps.pem')\\n context.set_ciphers('AES128-SHA256')\\n RPCS.context = context\\n except FileNotFoundError:\\n # If we can't set up TLS context, log error and exit\\n LOG.error(\\\"Could not setup TLS context: certificate file(s) \\\"\\n \\\"not present in the correct directory\\\")\\n exit(1)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=DESCRIPTION)\\n parser.add_argument(\\n \\\"--port\\\", type=int, default=9090, help=\\\"The port number to listen to.\\\",\\n )\\n parser.add_argument(\\\"--settings\\\", help=\\\"Full path to settings file.\\\", required=True)\\n parser.add_argument(\\n \\\"--ssl_context\\\",\\n help=\\\"A key and certificate file pair to run the server in HTTPS mode.\\\",\\n nargs=2,\\n )\\n\\n args = parser.parse_args()\\n\\n keyfile = None\\n certfile = None\\n if args.ssl_context:\\n keyfile, certfile = args.ssl_context\\n\\n run_server(\\n port=args.port, settings=args.settings, keyfile=keyfile, certfile=certfile,\\n )\",\n \"def server(addr, port, family, use_tls=False):\\n sock = _socket(addr, port, family)\\n ctx = _context(use_tls=use_tls)\\n return {\\\"sock\\\": sock, \\\"ssl\\\": ctx}\",\n \"def gen_server():\\n server = grpc.server(futures.ThreadPoolExecutor(max_workers = 10), \\n options= [('grpc.max_send_message_length', 100 * 1024 * 1024),\\n ('grpc.max_receive_message_length', 100 * 1024 * 1024)])\\n with open('server.key', 'rb') as f:\\n private_key = f.read()\\n with open('server.crt', 'rb') as f:\\n certificate_chain = f.read()\\n server_credentials = grpc.ssl_server_credentials(((private_key, certificate_chain,),))\\n server.add_secure_port('[::]:50051', server_credentials)\\n return server\",\n \"def is_secure(self):\\n return self._is_ssl or self._is_socket\",\n \"def _ServerProxy__request(self, methodname, params):\\n\\n paddedHandler = self._ServerProxy__handler\\n\\n # add on the methodName\\n sep = '&'\\n if '?' not in paddedHandler:\\n sep = '?'\\n paddedHandler = paddedHandler + \\\"%smethod=%s\\\" % (sep, methodname)\\n sep = '&'\\n\\n # add on the auth token\\n if self._authToken:\\n paddedHandler = paddedHandler + \\\"%sauth_token=%s\\\" % (sep, urllib.quote_plus(self._authToken))\\n\\n # add on the partnerId\\n if self._partnerId:\\n paddedHandler = paddedHandler + \\\"%spartner_id=%s\\\" % (sep, self._partnerId)\\n\\n # add on the userId\\n if self._userId:\\n paddedHandler = paddedHandler + \\\"%suser_id=%s\\\" % (sep, self._userId)\\n\\n EXCLUDED_PAYLOAD_CALLS = ([\\n \\\"auth.partnerLogin\\\",\\n \\\"test.\\\",\\n \\\"debug.\\\",\\n \\\"testability.\\\"\\n ])\\n encryptRequest = True\\n if self._requestCipher:\\n for excludedMethodPattern in EXCLUDED_PAYLOAD_CALLS:\\n if methodname.startswith(excludedMethodPattern):\\n encryptRequest = False\\n break\\n else:\\n encryptRequest = False\\n\\n # add the syncTime request\\n if encryptRequest and self._sync:\\n server_value, sync_time = self._sync\\n params[0]['syncTime'] = server_value + int(time.time()) - sync_time\\n\\n request = xmlrpclib.dumps(params, methodname,\\n encoding=self._ServerProxy__encoding,\\n allow_none=self._ServerProxy__allow_none)\\n\\n #print \\\"------- XML REQUEST --------\\\"\\n #print request\\n\\n if encryptRequest:\\n request = self.encodeRequest(request)\\n\\n if self.x509:\\n response = self._ServerProxy__transport.request(\\n (self._ServerProxy__host, self.x509),\\n paddedHandler,\\n request,\\n verbose=self._ServerProxy__verbose\\n )\\n else:\\n response = self._ServerProxy__transport.request(\\n self._ServerProxy__host,\\n paddedHandler,\\n request,\\n verbose=self._ServerProxy__verbose\\n )\\n\\n if len(response) == 1:\\n response = response[0]\\n\\n #print \\\"------ RESPONSE ------\\\"\\n #print response\\n\\n return response\",\n \"def secure_sock(self):\\n return self._secure_sock\",\n \"def UnitTestServer(self):\\n print('--server--')\\n print('server pid is ' + str(os.getpid()))\\n try:\\n s = socket.socket()\\n s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n s.bind(('', 25692))\\n s.listen(1)\\n c, addr = s.accept() #get client socket and address\\n s.close()\\n self.ExchangeServer(c)\\n print(\\\"prime index: \\\" + str(self.PrimeCache.index((self.SharedPrime, self.SharedBase))))\\n print('Shared secret: ' + str(self.SharedSecret))\\n self.sendStr(c, 'An encrypted message')\\n msg = self.recvStr(c)\\n if msg == 'Thanks for sharing':\\n print('Client message received OK')\\n else:\\n raise Exception('Failed to decrypt client message!')\\n c.close()\\n except Exception as e:\\n traceback.print_exc(file=sys.stdout)\\n c.close()\\n return False\\n \\n return True\",\n \"def Connect(server, port=common_lib.SERVER_PORT):\\n addr = 'https://%s:%d' % (server, port)\\n logging.debug('Connecting to RPC server at %s', addr)\\n return jsonrpclib.ServerProxy(addr, allow_none=True)\",\n \"def xmlrpc_methods():\",\n \"def ussl.wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None):\\n pass\",\n \"def connect(enc_data=None, ring=1):\\n if not enc_data:\\n enc_data = load_default_enc_json()\\n url = {0: DIRECTORY_URL_RING0,\\n 1: DIRECTORY_URL_RING1}[ring]\\n return xmlrpc.client.Server(url.format(enc=enc_data), allow_none=True,\\n use_datetime=True)\",\n \"def do_POST(self):\\n \\n try:\\n # get arguments\\n data = self.rfile.read(int(self.headers[\\\"content-length\\\"]))\\n # In previous versions of SimpleXMLRPCServer, _dispatch\\n # could be overridden in this class, instead of in\\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\\n # check to see if a subclass implements _dispatch and dispatch\\n # using that method if present.\\n response = self.server._marshaled_dispatch(\\n data, getattr(self, '_dispatch', None)\\n )\\n except: # This should only happen if the module is buggy\\n # internal error, report as HTTP server error\\n self.send_response(500)\\n self.end_headers()\\n else:\\n # got a valid XML RPC response\\n self.send_response(200)\\n self.send_header(\\\"Content-type\\\", \\\"text/xml\\\")\\n self.send_header(\\\"Content-length\\\", str(len(response)))\\n self.end_headers()\\n self.wfile.write(response)\\n \\n # shut down the connection\\n self.wfile.flush()\\n \\n #modified as of http://docs.python.org/library/ssl.html\\n self.connection.shutdown(socket.SHUT_RDWR)\\n self.connection.close()\",\n \"async def main():\\n await serve_websocket(handle_server, SERVER, PORT, ssl_context=None)\",\n \"def check_secure():\\n return get_config_handler().check_secure()\",\n \"def start_rpc_server(user, host, port, client):\\n if user not in SERVER_THREADS.keys():\\n # Create server\\n server = SimpleXMLRPCServer((host, port), requestHandler=RequestHandler)\\n server.register_instance(QChatRPCServer(user, host, port, client))\\n server_thread = RPCServerThread(server=server, target=server.serve_forever)\\n SERVER_THREADS[user] = server_thread\\n server_thread.start()\",\n \"def run(self, handler):\\n server = WSGIServer((self.host, self.port), handler)\\n server.ssl_adapter = pyOpenSSLAdapter(\\n certificate=CERTIFICATE,\\n private_key=KEY,\\n # certificate_chain=\\\"intermediate_cert.crt\\\"\\n )\\n\\n try:\\n server.start()\\n logger.info(\\\"Started vROPs Web Service\\\")\\n except Exception as exp:\\n server.stop()\\n logger.error(\\\"Exception: {} Stopped vROPs Web Service\\\".format(exp))\",\n \"def ClientApp(stream):\\n\\n def secured():\\n print 'client secured!'\\n write('QUIT')\\n\\n def read(line):\\n line = line.strip()\\n print 'server said: %r.' % line\\n if line == \\\"YOU SAID: 'hello'\\\":\\n write('STARTTLS')\\n elif line == 'PROCEED':\\n stream.starttls(secured)\\n elif line == 'GOODBYE':\\n stream.close()\\n else:\\n wait()\\n\\n def write(data):\\n stream.write('%s\\\\n' % data)\\n wait()\\n\\n def wait():\\n stream.read_until('\\\\n', read)\\n\\n ## Begin\\n print 'starting client: %r' % stream.socket.fileno()\\n write('hello')\",\n \"def _server_connection(self, callback, data):\\n ctx = Context(SSLv23_METHOD)\\n ctx.use_privatekey(load_privatekey(FILETYPE_PEM, server_key_pem))\\n ctx.use_certificate(load_certificate(FILETYPE_PEM, server_cert_pem))\\n ctx.set_ocsp_server_callback(callback, data)\\n server = Connection(ctx)\\n server.set_accept_state()\\n return server\",\n \"def Server(self) -> Socket:\",\n \"def launch_writeserver(self):\\n # server thread interface to DB\\n self.writeconn = sqlite3.connect(self.dbname, timeout = 30)\\n self.write_curs = self.writeconn.cursor()\\n self.log_message(self.create_readout(\\\"LogDB_XMLRPC_server.py\\\", \\\"Autologbook DB web interface server\\\", None),\\n \\\"Starting Logger write server on \\\" + self.host + \\\":%i\\\"%self.writeport)\\n\\n # xmlrpc web interface for data updates\\n class RequestHandler(SimpleXMLRPCRequestHandler):\\n rpc_paths = ('/RPC2',)\\n\\n server = SimpleXMLRPCServer(None, bind_and_activate=False, requestHandler=RequestHandler, allow_none=True)\\n server.register_function(self.create_readout, 'create_readout')\\n server.register_function(self.set_ChangeFilter, 'set_ChangeFilter')\\n server.register_function(self.set_DecimationFilter, 'set_DecimationFilter')\\n server.register_function(self.log_readout, 'log_readout')\\n server.register_function(self.log_readouts, 'log_readouts')\\n server.register_function(self.log_message, 'log_message')\\n server.register_function(self.writeconn.commit, 'commit')\\n server.register_function(self.define_readset, 'define_readset')\\n server.register_function(self.log_readset, 'log_readset')\\n\\n context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) #, cafile = 'https_cert.pem') # accepted certs from clients\\n #context.verify_mode = ssl.CERT_REQUIRED\\n #context.check_hostname = False\\n context.load_cert_chain('https_cert.pem', 'https_key.pem') # my certs for clients\\n\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:\\n sock.bind(('', self.writeport)) # listen on all interfaces\\n sock.listen(40) # 20 pending connections before dropping more\\n\\n with context.wrap_socket(sock, server_side=True) as ssock:\\n server.socket = ssock\\n print(\\\"Launching writeserver on\\\", self.host, self.writeport)\\n sys.stdout.flush()\\n server.serve_forever()\",\n \"def server():\",\n \"def server():\",\n \"def GetRpcServer(server, email=None, host_override=None, save_cookies=True,\\r\\n account_type=AUTH_ACCOUNT_TYPE):\\r\\n\\r\\n # If this is the dev_appserver, use fake authentication.\\r\\n host = (host_override or server).lower()\\r\\n if re.match(r'(http://)?localhost([:/]|$)', host):\\r\\n if email is None:\\r\\n email = \\\"test@example.com\\\"\\r\\n logging.info(\\\"Using debug user %s. Override with --email\\\" % email)\\r\\n server = HttpRpcServer(\\r\\n server,\\r\\n lambda: (email, \\\"password\\\"),\\r\\n host_override=host_override,\\r\\n extra_headers={\\\"Cookie\\\":\\r\\n 'dev_appserver_login=\\\"%s:False\\\"' % email},\\r\\n save_cookies=save_cookies,\\r\\n account_type=account_type)\\r\\n # Don't try to talk to ClientLogin.\\r\\n server.authenticated = True\\r\\n return server\\r\\n\\r\\n return HttpRpcServer(server,\\r\\n KeyringCreds(server, host, email).GetUserCredentials,\\r\\n host_override=host_override,\\r\\n save_cookies=save_cookies,\\r\\n account_type=account_type)\",\n \"def wrap_socket(sock, server_side=False, keyfile=None, certfile=None, cert_reqs=CERT_NONE, ca_certs=None):\\n ...\",\n \"def _httpd_serve_forever(args):\\n server_address = ('', args.port)\\n factory = _request_handler_factory(args)\\n httpd = BaseHTTPServer.HTTPServer(server_address, factory)\\n if args.sslcert:\\n certpath = os.path.abspath(args.sslcert)\\n print(certpath)\\n httpd.socket = ssl.wrap_socket(\\n httpd.socket,\\n certfile=certpath,\\n server_side=True)\\n httpd.serve_forever()\",\n \"def Connect(server, port):\\n addr = 'http://%s:%d' % (server, port)\\n logging.debug('Connecting to RPC server at %s', addr)\\n return jsonrpclib.ServerProxy(addr, allow_none=True)\",\n \"def serve(self):\\n \\n print (\\\"Starting metastore server on port %d, use ctrl-c \\\"\\n \\\"to quit\\\" % self.port)\\n \\n from SimpleXMLRPCServer import SimpleXMLRPCServer\\n server = SimpleXMLRPCServer((\\\"0.0.0.0\\\", self.port))\\n server.register_function(self.store.get)\\n server.register_function(self.store.put)\\n server.register_function(self.store.multiget)\\n server.serve_forever()\",\n \"def start(self):\\n if self._use_ssl:\\n try:\\n ca_file = CONF.ssl_ca_file\\n cert_file = CONF.ssl_cert_file\\n key_file = CONF.ssl_key_file\\n\\n if cert_file and not os.path.exists(cert_file):\\n raise RuntimeError(\\n _(\\\"Unable to find cert_file : %s\\\") % cert_file)\\n\\n if ca_file and not os.path.exists(ca_file):\\n raise RuntimeError(\\n _(\\\"Unable to find ca_file : %s\\\") % ca_file)\\n\\n if key_file and not os.path.exists(key_file):\\n raise RuntimeError(\\n _(\\\"Unable to find key_file : %s\\\") % key_file)\\n\\n if self._use_ssl and (not cert_file or not key_file):\\n raise RuntimeError(\\n _(\\\"When running server in SSL mode, you must \\\"\\n \\\"specify both a cert_file and key_file \\\"\\n \\\"option value in your configuration file\\\"))\\n ssl_kwargs = {\\n 'server_side': True,\\n 'certfile': cert_file,\\n 'keyfile': key_file,\\n 'cert_reqs': ssl.CERT_NONE,\\n }\\n\\n if CONF.ssl_ca_file:\\n ssl_kwargs['ca_certs'] = ca_file\\n ssl_kwargs['cert_reqs'] = ssl.CERT_REQUIRED\\n\\n self._socket = eventlet.wrap_ssl(self._socket,\\n **ssl_kwargs)\\n\\n self._socket.setsockopt(socket.SOL_SOCKET,\\n socket.SO_REUSEADDR, 1)\\n # sockets can hang around forever without keepalive\\n self._socket.setsockopt(socket.SOL_SOCKET,\\n socket.SO_KEEPALIVE, 1)\\n\\n # This option isn't available in the OS X version of eventlet\\n if hasattr(socket, 'TCP_KEEPIDLE'):\\n self._socket.setsockopt(socket.IPPROTO_TCP,\\n socket.TCP_KEEPIDLE,\\n CONF.tcp_keepidle)\\n\\n except Exception:\\n with excutils.save_and_reraise_exception():\\n LOG.error(_(\\\"Failed to start %(name)s on %(host)s\\\"\\n \\\":%(port)s with SSL support\\\") % self.__dict__)\\n\\n wsgi_kwargs = {\\n 'func': eventlet.wsgi.server,\\n 'sock': self._socket,\\n 'site': self.app,\\n 'protocol': self._protocol,\\n 'custom_pool': self._pool,\\n 'log': self._wsgi_logger,\\n 'log_format': CONF.wsgi_log_format\\n }\\n\\n if self._max_url_len:\\n wsgi_kwargs['url_length_limit'] = self._max_url_len\\n\\n self._server = eventlet.spawn(**wsgi_kwargs)\",\n \"def build_httpd(secure=None):\\n\\n httpd = http_server.HTTPServer(LOCAL_RANDOM_PORT, MockServerRequestHandler)\\n httpd.req = {}\\n httpd.rsp = []\\n\\n if secure:\\n keyfile, certfile = fetch_cert_files()\\n\\n context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)\\n context.load_cert_chain(certfile, keyfile=keyfile)\\n\\n httpd.socket = context.wrap_socket(httpd.socket, server_side=True)\\n\\n return httpd\",\n \"def is_secure_context(self):\\n raise exceptions.NotImplementedError()\",\n \"def __handshake(sock):\\n # Craft HELLO packet\\n msg = \\\"HELLO,SecureClient\\\".encode('utf-8')\\n \\n # Send packet\\n sock.sendall(msg)\\n\\n # Wait for server's key\\n resp = sock.recv(1024).decode('utf-8')\\n print(resp)\\n \\n # Parse response\\n parsedResp = resp.split(\\\",\\\")\\n\\n # Check correct response\\n if parsedResp[0] != \\\"HELLO\\\" and parsedResp[1] != \\\"SecureServer\\\":\\n print(\\\"Bad response\\\")\\n return False\\n\\n try:\\n # Extract the key from server message\\n dirtyKey = parsedResp[2]\\n except IndexError:\\n print(\\\"Bad key message\\\")\\n return False\\n\\n return __clean_key(dirtyKey)\",\n \"def insecure_ssl(self):\\n # type: () -> bool\\n return self._insecure_ssl\",\n \"def registerXMLRPC(self, unique_service_name, instance, endpoint):\\n # TODO only set the ClientCert Handler if configured\\n handler = XMLRPCHandler(unique_service_name)\\n handler.connect(self._flaskapp.app, endpoint)\\n handler.register_instance(instance)\",\n \"def _authenticated_server_proxy(self):\\n config = self._config\\n\\n if self.__authenticated_server_proxy is None:\\n realm = REALM\\n if \\\"realm\\\" in self._config:\\n realm = self._config[\\\"realm\\\"]\\n server = TRAC_SERVER_URI\\n if \\\"server\\\" in self._config:\\n server = self._config[\\\"server\\\"]\\n if server[-1] != '/': server += '/'\\n\\n username = self._username\\n if username == \\\"doctest\\\":\\n return DoctestServerProxy(self)\\n else:\\n transport = DigestTransport(realm, server, username, self._password)\\n self.__authenticated_server_proxy = ServerProxy(server + 'login/xmlrpc', transport=transport)\\n\\n return self.__authenticated_server_proxy\",\n \"def __init__(self,dbname,server_ip,server_port):\\n self.dbname = dbname\\n self.con = sqlite3.connect(dbname)\\n self.cur = self.con.cursor()\\n self.server_ip=server_ip\\n self.server_port=server_port\\n\\n # The access method from server initialization\\n self.server = SimpleXMLRPCServer((server_ip, int(server_port)))\\n logging.info('Server started on %s %s', server_ip, server_port)\",\n \"def __init__(self, host, user, password, port=443):\\n self._host = host\\n self._user = user\\n self._password = password\\n self._port = port\\n self.sslContext = ssl._create_unverified_context()\\n self._si = self._get_service_instance()\",\n \"def create_server_certs_sign():\\n global server_keystore\\n\\n dn_sign = \\\"/CN=server certificate sign RSA-PSS\\\"\\n key_pair_rsa_sign = create_csr_pss(dn_sign)\\n server_keystore[\\\"key-sign\\\"] = key_pair_rsa_sign[\\\"key\\\"]\\n san = [f'URI.1 = {uuid.uuid4().urn}']\\n server_keystore[\\\"crt-sign\\\"] = sign_csr(key_pair_rsa_sign[\\\"pub\\\"], dn_sign, san)\",\n \"def create_server_context(domain, container_path, context_path=None, use_ssl=True):\\n server_context = dict(domain=domain, container_path=container_path, context_path=context_path)\\n\\n if use_ssl:\\n scheme = 'https'\\n else:\\n scheme = 'http'\\n scheme += '://'\\n\\n if use_ssl:\\n session = requests.Session()\\n session.mount(scheme, SafeTLSAdapter())\\n else:\\n # TODO: Is there a better way? Can we have session.mount('http')?\\n session = requests\\n\\n server_context['scheme'] = scheme\\n server_context['session'] = session\\n\\n return server_context\",\n \"def main():\\n # if not enough arguments are provided, print an error and exit\\n if len(sys.argv) < 3:\\n print \\\"Required Parameters Missing\\\"\\n sys.exit()\\n\\n # get arguments from console\\n # if only host and neuid are provided\\n elif len(sys.argv) == 3:\\n port = 27993\\n sflag = None\\n hostname = str(sys.argv[1])\\n neuid = str(sys.argv[2])\\n \\n # if -s flag given (or invalid arguments)\\n elif len(sys.argv) == 4:\\n if sys.argv[1] == '-s':\\n port = 27994\\n sflag = True\\n else:\\n print \\\"Error: Invalid arguments\\\"\\n sys.exit()\\n\\n hostname = str(sys.argv[2])\\n neuid = str(sys.argv[3])\\n \\n # if port or sflag are provided\\n elif len(sys.argv) == 5:\\n if sys.argv[1] == '-p':\\n port = int(sys.argv[2])\\n sflag = False\\n else:\\n print 'ERROR: Invalid Argument for Second Parameter'\\n sys.exit()\\n\\n hostname = str(sys.argv[3])\\n neuid = str(sys.argv[4])\\n\\n # if port and sflag are provided\\n elif len(sys.argv) == 6:\\n if sys.argv[1] == '-p' and sys.argv[3] == '-s':\\n port = int(sys.argv[2])\\n sflag = True\\n else:\\n print 'Error: Invalid Argument for port or s flags'\\n sys.exit()\\n\\n hostname = str(sys.argv[4])\\n neuid = str(sys.argv[5])\\n\\n # create the socket\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\n # connect the socket to the host\\n try:\\n s.connect((hostname, port))\\n except socket.error:\\n print \\\"Failed To Connect Socket to Host\\\"\\n sys.exit(1)\\n\\n # if ssl flag is there, create the ssl connection\\n if sflag:\\n sock = ssl.wrap_socket(s, cert_reqs=ssl.CERT_NONE)\\n else:\\n sock = s\\n\\n # send the hello message\\n try:\\n sock.send(\\\"cs3700spring2016 HELLO \\\" + neuid + \\\"\\\\n\\\")\\n except socket.error:\\n print \\\"Failed To Send Hello Message\\\"\\n\\n # continuously receive and send messages\\n while 1:\\n global closed_flag\\n if closed_flag:\\n break\\n received = sock.recv(1024)\\n if 'BYE' in received:\\n print received.split()[2]\\n parse_message(received, sock)\",\n \"def runServer(self, services=[]):\\n self.add_routes()\\n #debug = self.general_section.get(\\\"debug\\\")\\n host = self.general_section.get(\\\"host\\\")\\n use_reloader = ast.literal_eval(self.general_section.get(\\\"use_reloader\\\"))\\n app_port = int(self.general_section.get(\\\"port\\\"))\\n cFCGI = ast.literal_eval(self.fcgi_section.get(\\\"enabled\\\"))\\n fcgi_port = int(self.fcgi_section.get(\\\"port\\\"))\\n must_have_client_cert = ast.literal_eval(self.certificates_flask_section.get(\\\"force_client_certificate\\\"))\\n if cFCGI:\\n logger.info(\\\"registering fcgi server at %s:%i\\\", host, fcgi_port)\\n from flup.server.fcgi import WSGIServer\\n WSGIServer(self._app, bindAddress=(host, fcgi_port)).run()\\n else:\\n logger.info(\\\"registering app server at %s:%i\\\", host, app_port)\\n # this workaround makes sure that the client cert can be acquired later (even when running the development server)\\n # copied all this stuff from the actual flask implementation, so we can intervene and adjust the ssl context\\n # self._app.run(host=host, port=app_port, ssl_context='adhoc', debug=debug, request_handler=ClientCertHTTPRequestHandler)\\n\\n # the code from flask's `run...`\\n # see https://github.com/mitsuhiko/flask/blob/master/flask/app.py\\n #options = {}\\n try:\\n # now the code from werkzeug's `run_simple(host, app_port, self._app, **options)`\\n # see https://github.com/mitsuhiko/werkzeug/blob/master/werkzeug/serving.py\\n #from werkzeug.debug import DebuggedApplication\\n import socket\\n #application = DebuggedApplication(self._app, True)\\n \\n # Set up an SSL context\\n context = SSL.Context(SSL.SSLv23_METHOD)\\n certs_path = os.path.normpath(os.path.join(os.path.dirname(__file__), \\\"../../..\\\", \\\"cert\\\"))\\n context_crt = os.path.join(certs_path, \\\"server.crt\\\")\\n context_key = os.path.join(certs_path, \\\"server.key\\\")\\n try:\\n context.use_certificate_file(context_crt)\\n context.use_privatekey_file(context_key)\\n except Exception as e:\\n logger.critical(\\\"error starting flask server. Cert or key is missing under %s\\\", certs_path)\\n sys.exit(e)\\n \\n def inner():\\n #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')\\n server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=context)\\n #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=(context_crt, context_key)) \\n # The following line is the reason why I copied all that code!\\n if must_have_client_cert:\\n # FIXME: what works with web app does not work with cli. Check this out\\n server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)\\n # before enter in the loop, start the supplementary services\\n for s in services:\\n s.start()\\n # That's it\\n server.serve_forever()\\n address_family = serving.select_ip_version(host, app_port)\\n test_socket = socket.socket(address_family, socket.SOCK_STREAM)\\n test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n test_socket.bind((host, app_port))\\n test_socket.close()\\n # Disable reloader only by explicit config setting\\n if use_reloader == False:\\n serving.run_simple(host, app_port, self._app, use_reloader=False)\\n else:\\n serving.run_with_reloader(inner, None, 1)\\n finally:\\n self._app._got_first_request = False\",\n \"def getContext(self):\\n ctx = SSL.Context(SSL.SSLv23_METHOD)\\n ctx.use_certificate_file(Settings.BaseDir+'/server.pem')\\n ctx.use_privatekey_file(Settings.BaseDir+'/privkey.pem')\\n return ctx\",\n \"def call_rpc(rpc_user, rpc_pwd, method):\\n base_url = 'http://127.0.0.1:37128/'\\n try:\\n response = post(base_url,\\n data=method,\\n auth=(rpc_user, rpc_pwd)\\n )\\n except Exception as e:\\n response = e\\n return evaluate_response(response)\",\n \"async def test_simple_get_ssl_ctx(app, aiohttp_server, ssl_context):\\n server = await aiohttp_server(app, ssl=ssl_context)\\n url = \\\"https://localhost:%d\\\" % server.port\\n\\n ssl_context = ssl.create_default_context(\\n ssl.Purpose.SERVER_AUTH,\\n )\\n ssl_context.check_hostname = False\\n ssl_context.verify_mode = ssl.CERT_NONE\\n async with aiosonic.HTTPClient() as client:\\n res = await client.get(url, ssl=ssl_context)\\n assert res.status_code == 200\\n assert await res.text() == \\\"Hello, world\\\"\\n await server.close()\",\n \"def soap_client(self):\\n context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)\\n context.verify_mode = ssl.CERT_NONE\\n return pyVim.connect.SmartConnect(\\n host=self.host,\\n user=self.settings.username,\\n pwd=self.settings.password,\\n port=443,\\n sslContext=context,\\n )\",\n \"def xmlrpc_response(data):\\n xml = xmlrpc_marshal(data)\\n response = webob.Response(xml)\\n response.content_type = 'text/xml'\\n response.content_length = len(xml)\\n return response\",\n \"def __init__(self, server, port, dbname, user, passwd):\\n\\n\\n #-------------------------------------------------------------------------\\n #--- WRAPPER XMLRPC OPENERP ----------------------------------------------\\n #-------------------------------------------------------------------------\\n\\n\\n self.url_template = \\\"http://%s:%s/xmlrpc/%s\\\"\\n self.server = server\\n self.port = port\\n self.dbname = dbname\\n self.user_name = user\\n self.user_passwd = passwd\\n self.user_id = 0\\n\\n\\n #\\n # Conectamos con OpenERP\\n #\\n\\n login_facade = xmlrpclib.ServerProxy(self.url_template % (self.server, self.port, 'common'))\\n self.user_id = login_facade.login(self.dbname, self.user_name, self.user_passwd)\\n self.object_facade = xmlrpclib.ServerProxy(self.url_template % (self.server, self.port, 'object'))\",\n \"def server(secure=False, idx=0):\\n if secure:\\n try:\\n url = 'https://' + wwl.secure_wwl_servers[idx]\\n except:\\n url = ''\\n else:\\n try:\\n url = 'http://' + wwl.wwl_servers[idx]\\n except:\\n url = ''\\n return url\",\n \"def protect_endpoint():\\n pass\",\n \"def render(self, request):\\n user = None\\n if request.isSecure():\\n user = request.channel.transport.getPeerCertificate(\\n ).get_subject().commonName\\n\\n request.content.seek(0, 0)\\n args, procedurePath = xmlrpclib.loads(request.content.read())\\n args = list(args)\\n args.insert(0, user)\\n try:\\n function = self.lookupProcedure(procedurePath)\\n except xmlrpclib.Fault, f:\\n self._cbRender(f, request)\\n else:\\n request.setHeader(\\\"content-type\\\", \\\"text/xml\\\")\\n defer.maybeDeferred(function, *args).addErrback(\\n self._ebRender\\n ).addCallback(\\n self._cbRender, request\\n )\\n\\n return server.NOT_DONE_YET\",\n \"def handshake(self):\\n\\n request_line = _build_method_line(self._options.get('resource'))\\n self._logger.debug('Client\\\\'s opening handshake Request-Line: %r',\\n request_line)\\n self._socket.sendall(request_line)\\n\\n fields = []\\n fields.append(_format_host_header(\\n self._options.get('server_host'),\\n int(self._options.get('server_port')),\\n self._options.get('use_tls')=='True'))\\n fields.append(_UPGRADE_HEADER)\\n fields.append(_CONNECTION_HEADER)\\n if self._options.get('origin') is not None:\\n if self._options.get('protocol_version') == _PROTOCOL_VERSION_HYBI08:\\n fields.append(_origin_header(\\n common.SEC_WEBSOCKET_ORIGIN_HEADER,\\n self._options.get('origin')))\\n else:\\n fields.append(_origin_header(common.ORIGIN_HEADER,\\n self._options.get('origin')))\\n\\n original_key = os.urandom(16)\\n self._key = base64.b64encode(original_key)\\n self._logger.debug(\\n '%s: %r (%s)',\\n common.SEC_WEBSOCKET_KEY_HEADER,\\n self._key,\\n util.hexify(original_key))\\n fields.append(\\n '%s: %s\\\\r\\\\n' % (common.SEC_WEBSOCKET_KEY_HEADER, self._key))\\n\\n if int(self._options.get('version_header')) > 0:\\n fields.append('%s: %d\\\\r\\\\n' % (common.SEC_WEBSOCKET_VERSION_HEADER,\\n int(self._options.get('version_header'))))\\n else:\\n fields.append('%s: %d\\\\r\\\\n' % (common.SEC_WEBSOCKET_VERSION_HEADER,\\n common.VERSION_HYBI_LATEST))\\n\\n extensions_to_request = []\\n\\n if self._options.get('deflate_stream') == 'True':\\n extensions_to_request.append(\\n common.ExtensionParameter(\\n common.DEFLATE_STREAM_EXTENSION))\\n\\n if self._options.get('deflate_frame') == 'True':\\n extensions_to_request.append(\\n common.ExtensionParameter(common.DEFLATE_FRAME_EXTENSION))\\n\\n if len(extensions_to_request) != 0:\\n fields.append(\\n '%s: %s\\\\r\\\\n' %\\n (common.SEC_WEBSOCKET_EXTENSIONS_HEADER,\\n common.format_extensions(extensions_to_request)))\\n\\n for field in fields:\\n self._socket.sendall(field)\\n\\n self._socket.sendall('\\\\r\\\\n')\\n\\n self._logger.debug('Sent client\\\\'s opening handshake headers: %r',\\n fields)\\n self._logger.debug('Start reading Status-Line')\\n\\n status_line = ''\\n while True:\\n ch = _receive_bytes(self._socket, 1)\\n status_line += ch\\n if ch == '\\\\n':\\n break\\n\\n m = re.match('HTTP/\\\\\\\\d+\\\\.\\\\\\\\d+ (\\\\\\\\d\\\\\\\\d\\\\\\\\d) .*\\\\r\\\\n', status_line)\\n if m is None:\\n raise ClientHandshakeError(\\n 'Wrong status line format: %r' % status_line)\\n status_code = m.group(1)\\n if status_code != '101':\\n self._logger.debug('Unexpected status code %s with following '\\n 'headers: %r', status_code, self._read_fields())\\n raise ClientHandshakeError(\\n 'Expected HTTP status code 101 but found %r' % status_code)\\n\\n self._logger.debug('Received valid Status-Line')\\n self._logger.debug('Start reading headers until we see an empty line')\\n\\n fields = self._read_fields()\\n\\n ch = _receive_bytes(self._socket, 1)\\n if ch != '\\\\n': # 0x0A\\n raise ClientHandshakeError(\\n 'Expected LF but found %r while reading value %r for header '\\n 'name %r' % (ch, \\\"test\\\", \\\"test\\\"))\\n\\n self._logger.debug('Received an empty line')\\n self._logger.debug('Server\\\\'s opening handshake headers: %r', fields)\\n\\n _validate_mandatory_header(\\n fields,\\n common.UPGRADE_HEADER,\\n common.WEBSOCKET_UPGRADE_TYPE,\\n False)\\n\\n _validate_mandatory_header(\\n fields,\\n common.CONNECTION_HEADER,\\n common.UPGRADE_CONNECTION_TYPE,\\n False)\\n\\n accept = _get_mandatory_header(\\n fields, common.SEC_WEBSOCKET_ACCEPT_HEADER)\\n\\n # Validate\\n try:\\n binary_accept = base64.b64decode(accept)\\n except TypeError, e:\\n raise HandshakeError(\\n 'Illegal value for header %s: %r' %\\n (common.SEC_WEBSOCKET_ACCEPT_HEADER, accept))\\n\\n if len(binary_accept) != 20:\\n raise ClientHandshakeError(\\n 'Decoded value of %s is not 20-byte long' %\\n common.SEC_WEBSOCKET_ACCEPT_HEADER)\\n\\n self._logger.debug(\\n 'Response for challenge : %r (%s)',\\n accept, util.hexify(binary_accept))\\n\\n binary_expected_accept = util.sha1_hash(\\n self._key + common.WEBSOCKET_ACCEPT_UUID).digest()\\n expected_accept = base64.b64encode(binary_expected_accept)\\n\\n self._logger.debug(\\n 'Expected response for challenge: %r (%s)',\\n expected_accept, util.hexify(binary_expected_accept))\\n\\n if accept != expected_accept:\\n raise ClientHandshakeError(\\n 'Invalid %s header: %r (expected: %s)' %\\n (common.SEC_WEBSOCKET_ACCEPT_HEADER, accept, expected_accept))\\n\\n deflate_stream_accepted = False\\n deflate_frame_accepted = False\\n\\n extensions_header = fields.get(\\n common.SEC_WEBSOCKET_EXTENSIONS_HEADER.lower())\\n accepted_extensions = []\\n if extensions_header is not None and len(extensions_header) != 0:\\n accepted_extensions = common.parse_extensions(extensions_header[0])\\n # TODO(bashi): Support the new style perframe compression extension.\\n for extension in accepted_extensions:\\n extension_name = extension.name()\\n if (extension_name == common.DEFLATE_STREAM_EXTENSION and\\n len(extension.get_parameter_names()) == 0 and\\n self._options.get('deflate_stream')=='True'):\\n deflate_stream_accepted = True\\n continue\\n\\n if (extension_name == common.DEFLATE_FRAME_EXTENSION and\\n self._options.get('deflate_frame')=='True'):\\n deflate_frame_accepted = True\\n processor = DeflateFrameExtensionProcessor(extension)\\n unused_extension_response = processor.get_extension_response()\\n self._options['deflate_frame'] = processor\\n continue\\n\\n raise ClientHandshakeError(\\n 'Unexpected extension %r' % extension_name)\\n\\n if (self._options.get('deflate_stream') == 'True' and not deflate_stream_accepted):\\n raise ClientHandshakeError(\\n 'Requested %s, but the server rejected it' %\\n common.DEFLATE_STREAM_EXTENSION)\\n\\n if (self._options.get('deflate_frame') == 'True' and not deflate_frame_accepted):\\n raise ClientHandshakeError(\\n 'Requested %s, but the server rejected it' %\\n common.DEFLATE_FRAME_EXTENSION)\",\n \"def create_server_certs_enc():\\n global server_keystore, config\\n\\n same_enc_sign_cert = config[\\\"config\\\"][\\\"same_enc_sign_cert\\\"]\\n if same_enc_sign_cert:\\n dn = \\\"/CN=server certificate RSA\\\"\\n else:\\n dn = \\\"/CN=server certificate encryption RSA\\\"\\n key_pair_rsa = create_csr(dn)\\n server_keystore[\\\"key\\\"] = key_pair_rsa[\\\"key\\\"]\\n san = [f'URI.1 = {uuid.uuid4().urn}']\\n server_keystore[\\\"crt\\\"] = sign_csr(key_pair_rsa[\\\"pub\\\"], dn, san)\",\n \"def add_endpoint_to_sipserver(self, endpoint: str, password: str) -> None:\",\n \"def __init__(self, server, ssl=True, username=None, password=None):\\n self.server = server\\n\\n authstring = 'Basic ' + string.strip(base64.encodestring(username + ':' + password))\\n self.auth = authstring if username and password else None\\n\\n self.connection_method = httplib.HTTPSConnection if ssl else httplib.HTTPConnection\",\n \"def __init__(self, addr=(\\\"localhost\\\", 8000)):\\n\\n Thread.__init__(self)\\n RPCBaseProxy.__init__(self)\\n\\n self.__instances = []\\n\\n self.__server = SimpleXMLRPCServer(addr=addr, logRequests=False, requestHandler=SimpleXMLRPCRequestHandler)\\n self.__server.register_instance(self)\",\n \"def run_server(port, settings, keyfile=None, certfile=None):\\n create_server(port, settings, keyfile, certfile).serve_forever()\",\n \"def start_websocket_server(self, addr, port):\\n app = SLSApplication(self, default_host=addr)\\n app.listen(port)\\n log.info(f\\\"Serving SLS/Websocket on ({addr}, {port})\\\")\\n tornado.ioloop.IOLoop.current().start()\",\n \"def test_peercreds_unix_sock(peercreds_enabled_server_and_client):\\n httpserver, testclient = peercreds_enabled_server_and_client\\n\\n unix_base_uri = 'http+unix://{}'.format(\\n httpserver.bind_addr.replace('/', '%2F'),\\n )\\n\\n expected_peercreds = os.getpid(), os.getuid(), os.getgid()\\n expected_peercreds = '|'.join(map(str, expected_peercreds))\\n\\n with requests_unixsocket.monkeypatch():\\n peercreds_resp = requests.get(unix_base_uri + PEERCRED_IDS_URI)\\n peercreds_resp.raise_for_status()\\n assert peercreds_resp.text == expected_peercreds\\n\\n peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI)\\n assert peercreds_text_resp.status_code == 500\",\n \"def connect(server, user=None, password=None, verify=True, netrc_file=None, debug=False,\\n extension_types=True, loglevel=None, logger=None, detect_redirect=True,\\n no_parse_model=False):\\n\\n # Generate a hash for the connection\\n hasher = hashlib.md5()\\n hasher.update(server.encode('utf-8'))\\n hasher.update(str(time.time()).encode('utf-8'))\\n connection_id = hasher.hexdigest()\\n\\n # Setup the logger for this connection\\n if logger is None:\\n logger = logging.getLogger('xnat-{}'.format(connection_id))\\n handler = logging.StreamHandler()\\n handler.setLevel(logging.DEBUG)\\n logger.addHandler(handler)\\n\\n # create formatter\\n if debug:\\n formatter = logging.Formatter('[%(asctime)s] %(levelname)s: %(module)s:%(lineno)d >> %(message)s')\\n else:\\n formatter = logging.Formatter('[%(levelname)s] %(message)s')\\n handler.setFormatter(formatter)\\n\\n if loglevel is not None:\\n logger.setLevel(loglevel)\\n elif debug:\\n logger.setLevel('DEBUG')\\n else:\\n logger.setLevel('WARNING')\\n\\n # If verify is False, disable urllib3 warning and give a one time warning!\\n if not verify:\\n logger.warning('Verify is disabled, this will NOT verify the certificate of SSL connections!')\\n logger.warning('Warnings about invalid certificates will be HIDDEN to avoid spam, but this')\\n logger.warning('means that your connection can be potentially unsafe!')\\n requests.packages.urllib3.disable_warnings()\\n\\n if user is None and password is None:\\n user, password = query_netrc(server, netrc_file, logger)\\n\\n if user is not None and password is None:\\n password = getpass.getpass(prompt=str(\\\"Please enter the password for user '{}':\\\".format(user)))\\n\\n # Create the correct requests session\\n requests_session = requests.Session()\\n\\n if user is not None:\\n requests_session.auth = (user, password)\\n\\n if not verify:\\n requests_session.verify = False\\n\\n # Check for redirects\\n original_uri = server\\n if detect_redirect:\\n server = detect_redirection(server, requests_session, logger)\\n\\n # If no login was found, check if the new server has a known login as a backup\\n if original_uri != server and user is None and password is None:\\n user, password = query_netrc(server, netrc_file, logger)\\n\\n # Check if login is successful\\n logged_in_user = check_auth(requests_session, server=server, user=user, logger=logger)\\n\\n # Create the XNAT connection\\n xnat_session = XNATSession(server=server, logger=logger,\\n interface=requests_session, debug=debug,\\n original_uri=original_uri, logged_in_user=logged_in_user)\\n\\n # Parse data model and create classes\\n if not no_parse_model:\\n build_model(xnat_session, extension_types=extension_types, connection_id=connection_id)\\n\\n return xnat_session\",\n \"def beta_create_wxAuth_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):\\n request_deserializers = {\\n ('wxAuth', 'CallAutoEditor'): AuthRequest.FromString,\\n ('wxAuth', 'checkClient2Version'): AuthRequest.FromString,\\n ('wxAuth', 'checkClientVersion'): AuthRequest.FromString,\\n ('wxAuth', 'checkServerVersion'): AuthRequest.FromString,\\n ('wxAuth', 'checkWxBot'): AuthRequest.FromString,\\n ('wxAuth', 'getWxBotKey'): AuthRequest.FromString,\\n ('wxAuth', 'runAEScript'): AuthRequest.FromString,\\n ('wxAuth', 'wxRPCAuth'): AuthRequest.FromString,\\n }\\n response_serializers = {\\n ('wxAuth', 'CallAutoEditor'): AuthReply.SerializeToString,\\n ('wxAuth', 'checkClient2Version'): AuthReply.SerializeToString,\\n ('wxAuth', 'checkClientVersion'): AuthReply.SerializeToString,\\n ('wxAuth', 'checkServerVersion'): AuthReply.SerializeToString,\\n ('wxAuth', 'checkWxBot'): AuthReply.SerializeToString,\\n ('wxAuth', 'getWxBotKey'): ByteReplay.SerializeToString,\\n ('wxAuth', 'runAEScript'): AuthReply.SerializeToString,\\n ('wxAuth', 'wxRPCAuth'): AuthReply.SerializeToString,\\n }\\n method_implementations = {\\n ('wxAuth', 'CallAutoEditor'): face_utilities.unary_unary_inline(servicer.CallAutoEditor),\\n ('wxAuth', 'checkClient2Version'): face_utilities.unary_unary_inline(servicer.checkClient2Version),\\n ('wxAuth', 'checkClientVersion'): face_utilities.unary_unary_inline(servicer.checkClientVersion),\\n ('wxAuth', 'checkServerVersion'): face_utilities.unary_unary_inline(servicer.checkServerVersion),\\n ('wxAuth', 'checkWxBot'): face_utilities.unary_unary_inline(servicer.checkWxBot),\\n ('wxAuth', 'getWxBotKey'): face_utilities.unary_unary_inline(servicer.getWxBotKey),\\n ('wxAuth', 'runAEScript'): face_utilities.unary_unary_inline(servicer.runAEScript),\\n ('wxAuth', 'wxRPCAuth'): face_utilities.unary_unary_inline(servicer.wxRPCAuth),\\n }\\n server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)\\n return beta_implementations.server(method_implementations, options=server_options)\",\n \"def set_credentials(self, username, password, url):\\n # remove trailing slash off URL\\n url = url.rstrip('/')\\n # save variables to object\\n self.url = url\\n self.username = username\\n self.password = password\\n self.xml_rpc = '%s/server/xml.server.php' % (self.url)\",\n \"def __init__(self, server, ressource):\\n self.server = server\\n local_url = \\\"http://%s:%d/xmlrpc/common\\\" % (\\n server.server_url,\\n server.server_port,\\n )\\n rpc = ServerProxy(local_url)\\n self.uid = rpc.login(server.server_db, server.login, server.password)\\n local_url = \\\"http://%s:%d/xmlrpc/object\\\" % (\\n server.server_url,\\n server.server_port,\\n )\\n self.rpc = ServerProxy(local_url)\\n self.ressource = ressource\",\n \"def ssl_wrap_socket(socket, ssl_options, server_hostname=..., **kwargs):\\n ...\",\n \"def run():\\n global base_dir\\n \\n cert_path = os.path.join(base_dir, 'cert.pem')\\n key_path = os.path.join(base_dir, 'key.pem')\\n if os.path.isfile(cert_path) and os.path.isfile(key_path):\\n logging.info('Found SSL certificate files cert.pem and key.pem')\\n logging.info('Server will run in HTTPS mode')\\n try:\\n app.run(host=cfg.cfg['ADDRESS'], port=cfg.cfg['PORT'], ssl_context=(cert_path, key_path))\\n except ssl.SSLError:\\n logging.error('Detected problem with certificate files!')\\n logging.error('Server will not start!')\\n else:\\n logging.warning('SSL certificate files cert.pem and key.pem not found!')\\n logging.warning('Server will run in HTTP mode!')\\n app.run(host=cfg.cfg['ADDRESS'], port=cfg.cfg['PORT'])\",\n \"def tls_http_server(request):\\n return functools.partial(make_tls_http_server, request=request)\",\n \"def create_server(\\n handle_event: EventCallback,\\n host: str = \\\"0.0.0.0\\\",\\n port: int = 0,\\n ssl_context: Optional[SSLContext] = None,\\n) -> Server:\\n return Server(handle_event, host, port, ssl_context)\",\n \"def xmlrpc_namespace():\",\n \"def _anonymous_server_proxy(self):\\n if self.__anonymous_server_proxy is None:\\n realm = REALM\\n if \\\"realm\\\" in self._config:\\n realm = self._config[\\\"realm\\\"]\\n server = TRAC_SERVER_URI\\n if \\\"server\\\" in self._config:\\n server = self._config[\\\"server\\\"]\\n if server[-1] != '/': server += '/'\\n\\n transport = DigestTransport(realm, server)\\n self.__anonymous_server_proxy = ServerProxy(server + 'xmlrpc', transport=transport)\\n return self.__anonymous_server_proxy\",\n \"def update_endpoint_in_sipserver(self, endpoint: str, password: str) -> None:\",\n \"def websocket_proxy_server(url, key=\\\"\\\"):\\n def create_on_message(conn):\\n def _fsend(data):\\n data = bytes(data)\\n conn.write_message(data, binary=True)\\n return len(data)\\n on_message = rpc._CreateEventDrivenServer(_fsend, \\\"WebSocketProxyServer\\\")\\n return on_message\\n\\n @gen.coroutine\\n def _connect(key):\\n conn = yield websocket.websocket_connect(url)\\n on_message = create_on_message(conn)\\n temp = _server_env()\\n # Start connecton\\n conn.write_message(struct.pack('@i', RPC_MAGIC), binary=True)\\n key = \\\"server:\\\" + key\\n conn.write_message(struct.pack('@i', len(key)), binary=True)\\n conn.write_message(key.encode(\\\"utf-8\\\"), binary=True)\\n msg = yield conn.read_message()\\n assert len(msg) >= 4\\n magic = struct.unpack('@i', msg[:4])[0]\\n if magic == RPC_MAGIC + 1:\\n raise RuntimeError(\\\"key: %s has already been used in proxy\\\" % key)\\n elif magic == RPC_MAGIC + 2:\\n logging.info(\\\"RPCProxy do not have matching client key %s\\\", key)\\n elif magic != RPC_MAGIC:\\n raise RuntimeError(\\\"%s is not RPC Proxy\\\" % url)\\n logging.info(\\\"Connection established\\\")\\n msg = msg[4:]\\n if msg:\\n on_message(bytearray(msg), 3)\\n\\n while True:\\n try:\\n msg = yield conn.read_message()\\n if msg is None:\\n break\\n on_message(bytearray(msg), 3)\\n except websocket.WebSocketClosedError as err:\\n break\\n logging.info(\\\"WebSocketProxyServer closed...\\\")\\n temp.remove()\\n ioloop.IOLoop.current().stop()\\n ioloop.IOLoop.current().spawn_callback(_connect, key)\\n ioloop.IOLoop.current().start()\",\n \"def is_secure_transport(request: Request) -> bool:\\n if request.settings.INSECURE_TRANSPORT:\\n return True\\n return request.url.lower().startswith(\\\"https://\\\")\",\n \"def insecure(self) -> bool:\\n return self._insecure\",\n \"def do_server(wrapping_key_public):\\n secret = os.urandom(32)\\n logging.info(f'secret: {hexlify(secret)}')\\n\\n ref_path = 'server-secret-for-reference.bin'\\n logging.debug(f'creating {ref_path}')\\n with open(ref_path, 'wb') as f:\\n f.write(secret)\\n\\n # generate IV\\n iv = os.urandom(12)\\n logging.debug(f'iv: {hexlify(iv)}')\\n\\n # generate 256-bit AES encryption key\\n ephemeral_key = os.urandom(32)\\n logging.debug(f'ephemeral_key: {hexlify(ephemeral_key)}')\\n\\n # xor_mask = os.urandom(32)\\n xor_mask = b'\\\\x00' * 32\\n logging.debug(f'xor_mask: {hexlify(xor_mask)}')\\n\\n # xor with mask to get transportKey\\n transport_key = bytes([ephemeral_key[i] ^ xor_mask[i] for i in range(32)])\\n logging.debug(f'transport_key: {hexlify(transport_key)}')\\n\\n logging.debug(f'wrapping the transport key with the public RSA wrapping key')\\n encrypted_transport_key = wrap(wrapping_key_public, transport_key)\\n\\n logging.debug(f'encrypting the secure secret with the AES ephermeral key')\\n encrypted_secret, tag = encrypt(ephemeral_key, iv, secret)\\n\\n logging.debug(f'encrypted_secret: {hexlify(encrypted_secret)}')\\n logging.debug(f'tag: {hexlify(tag)}')\\n\\n authorizationList = AuthorizationList()\\n\\n key_description = KeyDescription()\\n key_description['keyFormat'] = KM_KEY_FORMAT_RAW\\n key_description['keyParams'] = authorizationList\\n\\n secure_key_wrapper = SecureKeyWrapper()\\n secure_key_wrapper['version'] = 0\\n secure_key_wrapper['encryptedTransportKey'] = encrypted_transport_key\\n secure_key_wrapper['initializationVector'] = iv\\n secure_key_wrapper['keyDescription'] = key_description\\n secure_key_wrapper['encryptedKey'] = encrypted_secret\\n secure_key_wrapper['tag'] = tag\\n\\n encoded_secure_key_wrapper = encode_secure_key_wrapper(secure_key_wrapper)\\n\\n return encoded_secure_key_wrapper, xor_mask\",\n \"def servant():\\n pass\",\n \"def peercreds_enabled_server_and_client(http_server, unix_sock_file):\\n httpserver = http_server.send(unix_sock_file)\\n httpserver.gateway = _TestGateway\\n httpserver.peercreds_enabled = True\\n return httpserver, get_server_client(httpserver)\",\n \"def do_POST(self):\\n\\n try:\\n # get arguments\\n data = self.rfile.read(int(self.headers[\\\"content-length\\\"]))\\n # In previous versions of SimpleXMLRPCServer, _dispatch\\n # could be overridden in this class, instead of in\\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\\n # check to see if a subclass implements _dispatch and dispatch\\n # using that method if present.\\n response = self.server._marshaled_dispatch(\\n data, getattr(self, '_dispatch', None)\\n )\\n except: # This should only happen if the module is buggy\\n # internal error, report as HTTP server error\\n self.send_response(500)\\n self.end_headers()\\n else:\\n # got a valid XML RPC response\\n self.send_response(200)\\n self.send_header(\\\"Content-type\\\", \\\"text/xml\\\")\\n self.send_header(\\\"Content-length\\\", str(len(response)))\\n self.end_headers()\\n self.wfile.write(response)\\n\\n # shut down the connection\\n self.wfile.flush()\\n self.connection.shutdown() # Modified here!\",\n \"def __init__(self):\\n self.host = CONF.zvm.zvm_xcat_server\\n self.port = 443\\n self.conn = HTTPSClientAuthConnection(self.host, self.port,\\n CONF.zvm.zvm_xcat_ca_file,\\n timeout=CONF.zvm.zvm_xcat_connection_timeout)\",\n \"def context():\\n return Context(SSLv23_METHOD)\",\n \"def __get_http2_ssl_context(self):\\n # Get the basic context from the standard library.\\n if self.client_side == False:\\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)\\n self.ctx = ssl._create_unverified_context()\\n else:\\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH, cafile=self.server_cert)\\n #self.ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)\\n self.ctx = ssl._create_unverified_context()\\n\\n # RFC 7540 Section 9.2: Implementations of HTTP/2 MUST use TLS version 1.2\\n # or higher. Disable TLS 1.1 and lower.\\n self.ctx.options |= (\\n ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1\\n )\\n\\n # RFC 7540 Section 9.2.1: A deployment of HTTP/2 over TLS 1.2 MUST disable\\n # compression.\\n self.ctx.options |= ssl.OP_NO_COMPRESSION\\n\\n # RFC 7540 Section 9.2.2: \\\"deployments of HTTP/2 that use TLS 1.2 MUST\\n # support TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256\\\". In practice, the\\n # blacklist defined in this section allows only the AES GCM and ChaCha20\\n # cipher suites with ephemeral key negotiation.\\n\\n\\n if self.client_side == False:\\n self.ctx.load_cert_chain(certfile=self.server_cert, keyfile=self.server_key)\\n self.ctx.load_verify_locations(cafile=self.client_certs) \\n else:\\n self.ctx.load_cert_chain(certfile=self.client_certs, keyfile=self.client_key)\\n self.ctx.load_verify_locations(cafile=self.client_certs) \\n pass\\n\\n\\n\\n # We want to negotiate using NPN and ALPN. ALPN is mandatory, but NPN may\\n # be absent, so allow that. This setup allows for negotiation of HTTP/1.1.\\n self.ctx.set_alpn_protocols([\\\"h2\\\", \\\"http/1.1\\\"])\\n\\n try:\\n self.ctx.set_npn_protocols([\\\"h2\\\", \\\"http/1.1\\\"])\\n except NotImplementedError as e:\\n print(\\\"TLS Error: NotImplementedError=%s\\\" % (e))\\n pass\\n\\n #self.ctx = ctx\\n\\n return True\",\n \"async def _create_context(self) -> ssl.SSLContext:\\n context = utils.server_context_modern()\\n\\n await self.cloud.run_executor(\\n context.load_cert_chain,\\n self._acme.path_fullchain,\\n self._acme.path_private_key,\\n )\\n\\n return context\",\n \"def force_communicate_tls(rest: ClusterManager) -> bool:\\n settings, err = rest.get_security_settings()\\n _exit_if_errors(err)\\n\\n # The cluster isn't using 'strict' cluster encryption, we shouldn't need to force enable TLS\\n if 'clusterEncryptionLevel' not in settings or settings['clusterEncryptionLevel'] != 'strict':\\n return False\\n\\n # The user might not have used a 'https://' scheme prefix, so communicating to other nodes via the secure ports may\\n # lead to interesting/surprising errors; let them know beforehand.\\n _warning(\\\"sub-command requires multi-node communication via TLS enabled ports, '--cacert' or \\\"\\n \\\"'--no-ssl-verify' may need to be supplied\\\")\\n\\n return True\",\n \"def __init__(self, use_datetime=0,\\r\\n username=None, password=None,\\r\\n certChain=None, privateKey=None,\\r\\n checker=None,\\r\\n settings=None,\\r\\n ignoreAbruptClose=False):\\r\\n\\r\\n # self._connection is new in python 2.7, since we're using it here,\\r\\n # we'll add this ourselves too, just in case we're pre-2.7\\r\\n self._connection = (None, None)\\r\\n xmlrpclib.Transport.__init__(self, use_datetime)\\r\\n self.ignoreAbruptClose = ignoreAbruptClose\\r\\n ClientHelper.__init__(self,\\r\\n username, password, \\r\\n certChain, privateKey,\\r\\n checker,\\r\\n settings)\",\n \"def secure(self) -> bool:\\n return self.get_state(self.args[CONF_OVERALL_SECURITY_STATUS]) == \\\"Secure\\\"\",\n \"def StartServer(serve_webapp=True, serve_static_web=True, serve_admin=True):\\n client = db_client.DBClient.Instance()\\n\\n settings = {\\n 'gzip': True,\\n 'login_url': '/',\\n 'admin_login_url': '/admin/otp',\\n 'domain': options.options.domain,\\n 'server_version': options.options.server_version,\\n 'cookie_secret': secrets.GetSecret('cookie_secret'),\\n 'facebook_api_key': secrets.GetSecret('facebook_api_key'),\\n 'facebook_secret': secrets.GetSecret('facebook_secret'),\\n 'google_client_id': secrets.GetSecret('google_client_id'),\\n 'google_client_secret': secrets.GetSecret('google_client_secret'),\\n 'google_client_mobile_id': secrets.GetSecret('google_client_mobile_id'),\\n 'google_client_mobile_secret': secrets.GetSecret('google_client_mobile_secret'),\\n 'template_path': ResourcesManager.Instance().template_path,\\n 'ui_modules': uimodules,\\n 'xsrf_cookies' : options.options.enable_xsrf,\\n 'debug': options.options.server_debug,\\n 'static_path': ResourcesManager.Instance().static_path,\\n }\\n\\n if options.options.log_file_prefix:\\n settings['logs_dir'] = os.path.dirname(options.options.log_file_prefix)\\n\\n # Configure metrics uploading.\\n if options.options.upload_metrics:\\n for interval in metric.METRIC_INTERVALS:\\n metric.Metric.StartMetricUpload(client, metric.DEFAULT_CLUSTER_NAME, interval)\\n\\n # Setup application and SSL HTTP server.\\n handlers = deepcopy(COMMON_HANDLERS)\\n if serve_webapp:\\n # Configure web application handlers.\\n webapp_handlers = deepcopy(WEBAPP_HANDLERS)\\n\\n # Initialize the file object store if specified.\\n obj_store = ObjectStore.GetInstance(ObjectStore.PHOTO)\\n settings['obj_store'] = obj_store\\n if options.options.fileobjstore:\\n for store_name, content_type in ((ObjectStore.PHOTO, r'image/jpeg'),\\n (ObjectStore.USER_LOG, r'text/plain'),\\n (ObjectStore.USER_ZIPS, r'application/zip')):\\n webapp_handlers.append((r'/fileobjstore/%s/(.*)' % store_name,\\n file_object_store.FileObjectStoreHandler,\\n { 'storename': store_name, 'contenttype': content_type}))\\n\\n if ServerEnvironment.IsDevBox():\\n webapp_handlers.append((r'/(link|login|register)/fakeviewfinder', auth_viewfinder.FakeAuthViewfinderHandler))\\n # Set the testing directories.\\n if options.options.testing_path is not None:\\n webapp_handlers.append((r'/testing/hook/(.*)', test_hook.TestHookHandler))\\n webapp_handlers.append((r'/testing/static/(.*)',\\n web.StaticFileHandler,\\n {'path': '%s' % options.options.testing_path}))\\n\\n handlers.extend(webapp_handlers)\\n\\n if serve_static_web:\\n # Configure static web handlers.\\n static_web_handlers = deepcopy(STATIC_WEB_HANDLERS)\\n handlers.extend(static_web_handlers)\\n\\n if serve_admin:\\n # Configure and verify admin handlers.\\n admin_handlers = deepcopy(ADMIN_HANDLERS)\\n for path, handler in admin_handlers:\\n if not issubclass(handler, basic_auth.BasicAuthHandler):\\n raise TypeError('Administration handlers must '\\n 'subclass BasicAuthHandler')\\n handlers.extend(admin_handlers)\\n\\n # Catch-all handler for 404 pages.\\n handlers.extend([(r'/.*', base.PageNotFoundHandler)])\\n\\n # Create application and separately add handlers for the short domain and the \\n # regular domain. \\n # \\n # Note that, although the short-domain handlers are added after the initial construction\\n # of the Application, those routes will take priority over the routes in the handlers \\n # array.\\n application = web.Application(handlers, **settings)\\n application.add_handlers(re.escape(options.options.short_domain), SHORT_DOMAIN_HANDLERS)\\n\\n # Start the HTTP server.\\n http_server = httpserver.HTTPServer(\\n application, xheaders=options.options.xheaders,\\n ssl_options={\\n 'certfile': secrets.GetSecretFile('%s.crt' % settings['domain']),\\n 'keyfile': secrets.GetSecretFile('%s.key' % settings['domain']),\\n } if options.options.ssl else None)\\n with stack_context.NullContext():\\n http_server.listen(options.options.port)\\n\\n # Setup redirect server for HTTP -> HTTPS.\\n if options.options.ssl:\\n http_settings = {\\n 'host': ServerEnvironment.GetHost(),\\n 'redirect_port': options.options.redirect_port,\\n 'xheaders': options.options.xheaders,\\n }\\n\\n redirect_handlers = [\\n (r'/(.*)', index.RedirectHandler),\\n ]\\n redirect_server = httpserver.HTTPServer(web.Application(\\n redirect_handlers, **http_settings))\\n with stack_context.NullContext():\\n redirect_server.listen(options.options.insecure_port)\\n\\n # Ensure that system users have been created if running with a local db (needs server to be running).\\n if options.options.localdb:\\n yield CreateSystemUsers(client)\\n\\n # Run the server until it hits an exception or stop signal.\\n yield gen.Task(lambda callback: None)\",\n \"def poodle():\\n with settings(hide('everything'), warn_only=True):\\n check_accept = re.compile(r'\\\\bCipher\\\\sis\\\\b')\\n check_cypher = re.compile(r'\\\\bCipher\\\\s*:\\\\s0000\\\\b|'\\n r'\\\\bCipher\\\\s*:\\\\s\\\\(NONE\\\\)\\\\b')\\n try:\\n result = 'Poodle '\\n timeout = run('which timeout')\\n ssl2test = run('%s 3 openssl s_client -ssl2 -connect localhost:443'\\n % timeout)\\n if check_accept.search(ssl2test):\\n check_ssl2 = check_cypher.search(ssl2test)\\n if check_ssl2:\\n result += 'SSLv2: OK'\\n else:\\n result += 'SSLv2: VULNERABLE'\\n else:\\n result += 'SSLv2: OK'\\n ssl3test = run('%s 3 openssl s_client -ssl3 -connect localhost:443'\\n % timeout)\\n if check_accept.search(ssl2test):\\n check_ssl3 = check_cypher.search(ssl3test)\\n if check_ssl3:\\n result += ' / SSLv3: OK'\\n else:\\n result += ' / SSLv3: VULNERABLE'\\n else:\\n result += ' / SSLv3: OK'\\n print(\\\"%s: %s\\\" % (env.host, result))\\n logging.warning(\\\"%s: %s\\\" % (env.host, result))\\n except Exception as e:\\n logging.warning('%s: Error: %s' % (env.host, e.message))\",\n \"def __init__(self, host='localhost', port=9091, path='/transmission/rpc',\\n username=None, password=None, ssl=False, timeout=DEFAULT_TIMEOUT):\\n if ssl:\\n scheme = 'https'\\n else:\\n scheme = 'http'\\n\\n self.url = \\\"%s://%s:%d%s\\\" % (scheme, host, port, path)\\n self.headers = {} # type: Dict[str, str]\\n self.tag = 0\\n self.timeout = timeout\\n\\n self.auth = None # type: Tuple[str, str]\\n if username or password:\\n self.auth = (username, password)\",\n \"def server():\\n package('apache2')\\n require_started('apache2')\",\n \"def server_address():\\n return '127.0.0.1'\",\n \"def _get_socket(self, secure=False, timeout=None):\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.settimeout(timeout or self.timeout)\\n\\n if secure:\\n # Setting Purpose to CLIENT_AUTH might seem a bit backwards. But\\n # SOS Access v4 is using SSL/TLS for encryption not authentications\\n # and verification. There is no cert and no hostname to check so\\n # setting the purpose to Client Auth diables that in a nifty way.\\n self.context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)\\n return self.context.wrap_socket(sock)\\n\\n else:\\n return sock\",\n \"def setup_server():\\n cherrypy.config.update('server.conf')\\n cherrypy.tree.mount(StringGeneratorWebService(), '/', 'server.conf')\",\n \"def _send_xml(self, url, xml):\\n http = httplib2.Http()\\n headers = {\\\"Content-type\\\": \\\"application/x-www-form-urlencoded\\\",\\n \\\"Authorization\\\": \\\"Basic %s\\\" % self.get_basic_auth()}\\n return http.request(url, \\\"POST\\\", xml, headers=headers)\",\n \"def create_server(host, port, uid, pwd):\\r\\n s = smtplib.SMTP(host, port)\\r\\n s.starttls()\\r\\n s.login(\\r\\n uid,\\r\\n pwd\\r\\n )\\r\\n return s\",\n \"def __init__(self, host, port=10035, user=None, password=None, cainfo=None, sslcert=None, verifyhost=None, verifypeer=None, **options):\\n \\n if re.match('^https?://', host):\\n uri = host + ':%d'\\n self._client = miniserver.Client(uri % port, user, password, cainfo, sslcert, verifyhost, verifypeer)\\n elif sslcert != None:\\n uri = 'https://%s:%d'\\n self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)\\n else:\\n uri = 'http://%s:%d'\\n self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)\\n \\n #self._client = miniserver.Client(uri % (host, port), user, password, cainfo, sslcert, verifyhost, verifypeer)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5892171","0.5800856","0.57675576","0.55861664","0.557848","0.5535654","0.5511048","0.54085445","0.5328043","0.52619624","0.52469873","0.5210757","0.5188847","0.5187752","0.51839226","0.51787466","0.51674885","0.5163018","0.5136565","0.51175344","0.5110345","0.51076716","0.50996053","0.5085922","0.5073166","0.5057006","0.5040666","0.5021844","0.501608","0.501608","0.49870396","0.4962736","0.49589658","0.4947145","0.494116","0.49160063","0.49039194","0.48728716","0.4869094","0.48679247","0.48433226","0.48311308","0.48180833","0.4813759","0.4802861","0.4802621","0.47962737","0.47558638","0.4748919","0.4734647","0.4731283","0.4719917","0.47197473","0.47171363","0.47142506","0.4714213","0.47057167","0.46940356","0.46870857","0.46826786","0.46739075","0.46644908","0.46624947","0.46560454","0.4654022","0.4653079","0.4652747","0.4621119","0.46208107","0.4613166","0.46094525","0.46031475","0.45959216","0.45900714","0.45864564","0.4585143","0.45836243","0.458163","0.45751342","0.45726538","0.45659542","0.45652208","0.45622346","0.45516917","0.45493594","0.45484567","0.45445052","0.45441258","0.45405504","0.45352042","0.4529326","0.45252204","0.45239648","0.45218796","0.4521051","0.45173952","0.45096925","0.4500682","0.44722393","0.4467513"],"string":"[\n \"0.5892171\",\n \"0.5800856\",\n \"0.57675576\",\n \"0.55861664\",\n \"0.557848\",\n \"0.5535654\",\n \"0.5511048\",\n \"0.54085445\",\n \"0.5328043\",\n \"0.52619624\",\n \"0.52469873\",\n \"0.5210757\",\n \"0.5188847\",\n \"0.5187752\",\n \"0.51839226\",\n \"0.51787466\",\n \"0.51674885\",\n \"0.5163018\",\n \"0.5136565\",\n \"0.51175344\",\n \"0.5110345\",\n \"0.51076716\",\n \"0.50996053\",\n \"0.5085922\",\n \"0.5073166\",\n \"0.5057006\",\n \"0.5040666\",\n \"0.5021844\",\n \"0.501608\",\n \"0.501608\",\n \"0.49870396\",\n \"0.4962736\",\n \"0.49589658\",\n \"0.4947145\",\n \"0.494116\",\n \"0.49160063\",\n \"0.49039194\",\n \"0.48728716\",\n \"0.4869094\",\n \"0.48679247\",\n \"0.48433226\",\n \"0.48311308\",\n \"0.48180833\",\n \"0.4813759\",\n \"0.4802861\",\n \"0.4802621\",\n \"0.47962737\",\n \"0.47558638\",\n \"0.4748919\",\n \"0.4734647\",\n \"0.4731283\",\n \"0.4719917\",\n \"0.47197473\",\n \"0.47171363\",\n \"0.47142506\",\n \"0.4714213\",\n \"0.47057167\",\n \"0.46940356\",\n \"0.46870857\",\n \"0.46826786\",\n \"0.46739075\",\n \"0.46644908\",\n \"0.46624947\",\n \"0.46560454\",\n \"0.4654022\",\n \"0.4653079\",\n \"0.4652747\",\n \"0.4621119\",\n \"0.46208107\",\n \"0.4613166\",\n \"0.46094525\",\n \"0.46031475\",\n \"0.45959216\",\n \"0.45900714\",\n \"0.45864564\",\n \"0.4585143\",\n \"0.45836243\",\n \"0.458163\",\n \"0.45751342\",\n \"0.45726538\",\n \"0.45659542\",\n \"0.45652208\",\n \"0.45622346\",\n \"0.45516917\",\n \"0.45493594\",\n \"0.45484567\",\n \"0.45445052\",\n \"0.45441258\",\n \"0.45405504\",\n \"0.45352042\",\n \"0.4529326\",\n \"0.45252204\",\n \"0.45239648\",\n \"0.45218796\",\n \"0.4521051\",\n \"0.45173952\",\n \"0.45096925\",\n \"0.4500682\",\n \"0.44722393\",\n \"0.4467513\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5573137"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":93097,"cells":{"query":{"kind":"string","value":"Handles the HTTPS POST request. It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly."},"document":{"kind":"string","value":"def do_POST(self):\n \n try:\n # get arguments\n data = self.rfile.read(int(self.headers[\"content-length\"]))\n # In previous versions of SimpleXMLRPCServer, _dispatch\n # could be overridden in this class, instead of in\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\n # check to see if a subclass implements _dispatch and dispatch\n # using that method if present.\n response = self.server._marshaled_dispatch(\n data, getattr(self, '_dispatch', None)\n )\n except: # This should only happen if the module is buggy\n # internal error, report as HTTP server error\n self.send_response(500)\n self.end_headers()\n else:\n # got a valid XML RPC response\n self.send_response(200)\n self.send_header(\"Content-type\", \"text/xml\")\n self.send_header(\"Content-length\", str(len(response)))\n self.end_headers()\n self.wfile.write(response)\n \n # shut down the connection\n self.wfile.flush()\n \n #modified as of http://docs.python.org/library/ssl.html\n self.connection.shutdown(socket.SHUT_RDWR)\n self.connection.close()"},"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 do_POST(self):\r\n SimpleXMLRPCRequestHandler.do_POST(self)\r\n try:\r\n # shut down the connection\r\n self.connection.shutdown()\r\n except:\r\n pass","def do_POST(self):\n\n try:\n # get arguments\n data = self.rfile.read(int(self.headers[\"content-length\"]))\n # In previous versions of SimpleXMLRPCServer, _dispatch\n # could be overridden in this class, instead of in\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\n # check to see if a subclass implements _dispatch and dispatch\n # using that method if present.\n response = self.server._marshaled_dispatch(\n data, getattr(self, '_dispatch', None)\n )\n except: # This should only happen if the module is buggy\n # internal error, report as HTTP server error\n self.send_response(500)\n self.end_headers()\n else:\n # got a valid XML RPC response\n self.send_response(200)\n self.send_header(\"Content-type\", \"text/xml\")\n self.send_header(\"Content-length\", str(len(response)))\n self.end_headers()\n self.wfile.write(response)\n\n # shut down the connection\n self.wfile.flush()\n self.connection.shutdown() # Modified here!","def do_POST(self):\n orig_request = ssl_proxy_log.Request(self.path, 'POST', self.headers,\n self.log, self.http_redirect_table, self.ssl_redirect_table)\n self.log.debug('do_POST called: %s' % self.path)\n request_log = self.fetch2(orig_request, self.wfile, self.rfile)\n\n# if not request_log:\n# return\n\n# if self.display_filter:\n# if not self.display_filter.search(self.path):\n# return\n\n if self.interactive:\n self.Log(request_log)","def do_POST(self): # pylint: disable=invalid-name\n self.handle_request()","def PostRequest(self):\n if self.__Payload: \n self.__Answer = requests.post(self.__URL, data = self.__Payload, headers = self.__Headers)\n Logs.WriteToLog(\"Data transited to web server\")\n else:\n Logs.WriteToLog(\"No payload in HTTP request\")\n raise Exception(\"Payload must be setted\")","def do_POST(self):\r\n content_length = int(self.headers['Content-Length'])\r\n body = self.rfile.read(content_length)\r\n\r\n response = BytesIO()\r\n try:\r\n res = webServer.handle_post_msg(body)\r\n print(res)\r\n self.send_response(200)\r\n except Exception as e:\r\n print(e)\r\n res = str(e)\r\n self.send_response(500)\r\n self.end_headers()\r\n response.write(res.encode())\r\n self.wfile.write(response.getvalue())","def do_POST(self):\n self._try_to_process_request(self._handle_post_request)","def post(self):\n code, status = run_handlers.handle_data_post(self.request.headers, self.request.body)\n self.set_status(code)\n self.write(status)\n self.finish()","def do_POST(self):\r\n self._send_handler_response('POST')","def do_POST(self):\n if self.client_address[0] != self.server.authorized_address:\n logging.error('Received unauthorized RPC request from %s',\n self.task_address[0])\n self.send_response(403)\n response = 'Forbidden'\n self.send_header('Content-type', 'text/plain')\n self.send_header('Content-length', str(len(response)))\n self.end_headers()\n self.wfile.write(response)\n else:\n return SimpleJSONRPCServer.SimpleJSONRPCRequestHandler.do_POST(self)","def do_POST(self):\n self.send_response(httplib.OK)\n self.send_header('Content-Type', 'application/octet-stream')\n self.end_headers()\n\n response = remote_api_pb.Response()\n try:\n request = remote_api_pb.Request()\n\n\n\n request.ParseFromString(\n self.rfile.read(int(self.headers['content-length'])))\n api_response = _ExecuteRequest(request).Encode()\n response.set_response(api_response)\n except Exception, e:\n logging.debug('Exception while handling %s\\n%s',\n request,\n traceback.format_exc())\n response.set_exception(pickle.dumps(e))\n if isinstance(e, apiproxy_errors.ApplicationError):\n application_error = response.mutable_application_error()\n application_error.set_code(e.application_error)\n application_error.set_detail(e.error_detail)\n self.wfile.write(response.Encode())","def HandlePost(self): # pylint: disable=R0201\n return BaseHandler.CreateError('Not implemented yet!', 501)","def do_POST(self):\n try:\n self._validate_http_request()\n except ValueError:\n return\n\n content_length = int(self.headers.get('Content-Length', '0'))\n request_bytes = self.rfile.read(content_length)\n while len(request_bytes) < content_length:\n request_bytes += self.rfile.read(content_length - len(request_bytes))\n\n request_raw = request_bytes.decode('utf-8')\n try:\n request = json.loads(request_raw)\n except ValueError as err:\n error = self._build_rpc_error(None, RpcErrors.PARSE_ERROR, err, keep_null_id=True)\n self._send_json(error)\n return\n\n if isinstance(request, list):\n responses = [self._process_request(single) for single in request]\n response = [r for r in responses if r is not None]\n elif isinstance(request, dict):\n response = self._process_request(request)\n else:\n try:\n raise ValueError\n except ValueError as err:\n error = self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err)\n self._send_json(error)\n return\n\n if response is not None:\n self._send_json(response)\n else:\n self.send_response(200, 'OK')\n self.end_headers()","def do_POST(self):\n logger.info(\"Received a POST request: {}\".format(self.path))\n path = self.strip_path()\n if path == SET_OP:\n self.send_response(self.process_set_request())\n elif path == COMMIT_OP:\n self.send_response(self.process_commit_request())\n else:\n logger.error(\"Invalid POST operation {} was received.\".format(path))\n self.send_response(404)","def do_POST(self,):\n self.http_method = 'POST'\n self.response()","def _create_https_connecetion(self,cr, uid, UPS_SERVER,Request_string,UPS_url=\"/ups.app/xml/XAV\", default_port=443, context={}):\n conn=httplib.HTTPSConnection(UPS_SERVER,default_port) #creating http connection\n\n if not conn:\n response_data='Connection failed'\n else:\n try:\n conn.request(\"POST\",UPS_url,Request_string) #requst being sent to ups\n response = conn.getresponse()\n except Exception:\n response_data='Connection failed'\n else:\n response_data = response.read()\n return response_data","def handle(self):\n data = self.request.recv(1024)\n self.request.send(data)","def post(self, *args, **kwargs):\n return self.handle_post_request()","def sendSslEnd(self, req):\n self._sendTcpMessage(self.SONY_MSG_Tcp_ProxyEnd, req, self.ThreeValueMsg.pack(a=1, b=1, c=0))","def submitPost(self):\n headers, params, proxy = self.getHeaderParamProxyInfo()\n try:\n resp = requests.post(self.FullURL, data=self.PostData, headers=headers, params=params, proxies=proxy, verify=False)\n return str(resp.content)\n except ConnectionError as ce:\n try:\n self.postErrorMessage('[-] Cannot connect to {url}. Server response is {resp} Server error code is {code}'.\n format(url=self.FullURL, resp=ce.message[0], code=ce.message[1][0]))\n except:\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\n except:\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)","async def post(self):\n\n # decrypt the request\n payload = decrypt_message(self.request.body, self.fernet_secret)\n if not payload:\n raise tornado.web.HTTPError(status_code=401)\n\n # ignore all requests for echo to this handler\n if payload[\"request\"] == \"echo\":\n LOGGER.error(\"This handler can't echo things.\")\n raise tornado.web.HTTPError(status_code=400)\n\n # get the request ID\n reqid = payload.get(\"reqid\")\n if reqid is None:\n raise ValueError(\n \"No request ID provided. \" \"Ignoring this request.\"\n )\n\n # rate limit the request if this is turned on\n if self.ratelimits:\n # get the frontend client IP addr\n frontend_client_ipaddr = payload.get(\"client_ipaddr\")\n\n if not frontend_client_ipaddr:\n LOGGER.error(\n \"[%s] request: '%s' is missing a payload \"\n \"value: 'client_ipaddr' \"\n \"needed to calculate rate, dropping this request.\"\n % (reqid, payload[\"request\"])\n )\n raise tornado.web.HTTPError(status_code=400)\n\n self.ratelimit_request(\n reqid,\n payload[\"request\"],\n frontend_client_ipaddr,\n request_body=payload[\"body\"],\n )\n\n # if we successfully got past host, decryption, rate-limit validation,\n # then process the request\n try:\n\n #\n # dispatch the action handler function\n #\n\n # inject the request ID into the body of the request so the backend\n # function can report on it\n payload[\"body\"][\"reqid\"] = reqid\n\n # inject the PII salt into the body of the request as well\n payload[\"body\"][\"pii_salt\"] = self.pii_salt\n\n #\n # validate the request and choose the function to dispatch\n #\n handler_func, problems, validate_msgs = validate_and_get_function(\n payload[\"request\"], payload[\"body\"]\n )\n\n if handler_func is None:\n problems[\"failure_reason\"] = \"invalid request parameters\"\n response = {\n \"success\": False,\n \"response\": problems,\n \"messages\": [validate_msgs],\n }\n else:\n # inject the config object into the backend function call\n # this passes along any secrets or settings from environ\n # directly to those functions\n backend_func = partial(\n handler_func, payload[\"body\"], config=self.config\n )\n # run the function associated with the request type\n loop = tornado.ioloop.IOLoop.current()\n response = await loop.run_in_executor(\n self.executor,\n backend_func,\n )\n\n #\n # see if the request was one that requires an email and password. in\n # this case, we'll apply backoff to slow down repeated failed\n # passwords\n #\n passcheck_requests = {\"user-login\", \"user-passcheck-nosession\"}\n\n if (\n payload[\"request\"] in passcheck_requests\n and response[\"success\"] is False\n ):\n\n (\n failure_status,\n failure_count,\n failure_wait,\n ) = await self.handle_failed_logins(payload)\n\n # if the user is locked for repeated login failures, handle that\n if failure_status == \"locked\":\n response = await self.lockuser_repeated_login_failures(\n payload, unlock_after_seconds=self.config.userlocktime\n )\n elif failure_status == \"wait\":\n LOGGER.warning(\n \"[%s] User with email: %s is being rate-limited \"\n \"after %s failed login attempts. \"\n \"Current wait time: %.1f seconds.\"\n % (\n reqid,\n pii_hash(payload[\"body\"][\"email\"], self.pii_salt),\n failure_count,\n failure_wait,\n )\n )\n\n # reset the failed counter to zero for each successful attempt\n elif (\n payload[\"request\"] in passcheck_requests\n and response[\"success\"] is True\n ):\n\n self.failed_passchecks.pop(payload[\"body\"][\"email\"], None)\n\n #\n # trim the failed_passchecks dict\n #\n if len(self.failed_passchecks) > 1000:\n self.failed_passchecks.pop(self.failed_passchecks.keys()[0])\n\n #\n # form and send the response\n #\n await self.send_response(response, reqid)\n\n except Exception:\n\n LOGGER.exception(\"Failed to understand request.\")\n raise tornado.web.HTTPError(status_code=400)","def _post_request(self):\n # check if input file size was not exceeded\n maxsize = configuration.get_config_value('server', 'maxrequestsize')\n maxsize = configuration.get_size_mb(maxsize) * 1024 * 1024\n if self.http_request.content_length > maxsize:\n raise FileSizeExceeded('File size for input exceeded.'\n ' Maximum request size allowed: %i megabytes' % maxsize / 1024 / 1024)\n\n try:\n doc = lxml.etree.fromstring(self.http_request.get_data())\n except Exception as e:\n if PY2:\n raise NoApplicableCode(e.message)\n else:\n raise NoApplicableCode(e.msg)\n\n operation = doc.tag\n request_parser = self._post_request_parser(operation)\n request_parser(doc)","def do_POST(self):\n ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))\n self.body = cgi.FieldStorage(fp=self.rfile,\n headers=self.headers, environ = {'REQUEST_METHOD':'POST'},\n keep_blank_values = 1, strict_parsing = 1)\n # throw away additional data [see bug #427345]\n while select.select([self.rfile._sock], [], [], 0)[0]:\n if not self.rfile._sock.recv(1):\n break\n self.handle_data()","def handle_request(self):\n try:\n content_type = self.headers.get('content-type')\n\n if content_type != 'application/json':\n self.write_empty_response(400)\n return\n\n content_len = int(self.headers.get('content-length', 0))\n\n # If content was provided, then parse it\n if content_len > 0:\n message = json.loads(self.rfile.read(content_len))\n else:\n self.write_empty_response(400)\n return\n\n helper.log_info(f'Incoming POST from {self.client_address[0]}: {message}')\n\n aspect_type = message['aspect_type']\n object_id = message['object_id']\n object_type = message['object_type']\n # make owner_id a str to avoid issues with athlete_checkpoint dict\n owner_id = str(message['owner_id'])\n\n athlete_checkpoint = helper.get_check_point(\"webhook_updates\") or {}\n\n # We only care about activity updates. New activities are pulled in automatically as strava_api input restarts.\n if aspect_type == 'update' and object_type == 'activity':\n if owner_id not in athlete_checkpoint:\n athlete_checkpoint[owner_id] = []\n athlete_checkpoint[owner_id].append(object_id)\n helper.save_check_point(\"webhook_updates\", athlete_checkpoint)\n else:\n athlete_checkpoint[owner_id].append(object_id)\n helper.save_check_point(\"webhook_updates\", athlete_checkpoint)\n helper.log_debug(f'webhooks_updates checkpoint: {helper.get_check_point(\"webhook_updates\")}')\n\n # Send data to Splunk\n data = json.dumps(message)\n event = helper.new_event(source=helper.get_input_type(), index=helper.get_output_index(), sourcetype=helper.get_sourcetype(), data=data)\n ew.write_event(event)\n\n # Strava API expects a 200 response\n self.write_empty_response(200)\n\n # Restart strava_api inputs to pull in the data unless it's a delete, as the input doesn't do anything with that anyway.\n if aspect_type != 'delete':\n self.restart_input('strava_api', self.SESSION_KEY)\n helper.log_info(f'Reloading Strava API input to retrieve updated activity {object_id} for athlete {owner_id}.')\n\n except Exception as ex:\n helper.log_error(f'Something went wrong in handle request: {ex}')","async def post_to_microservice(self, url, prompt_serialized):\n # this is the only way that DOES not block django channels, whereas everything else did?!\n pool.apply_async(\n requests.post,\n args=[url, prompt_serialized],\n callback=on_post_success_to_microservice,\n error_callback=on_error_to_microservice,\n )","def post(self, request, *args, **kwargs):\n verify_secure(request)\n return super().post(request, args, kwargs)","def post(self, request, *args, **kwargs):\n verify_secure(request)\n return super().post(request, args, kwargs)","def do_POST(self): # pylint:disable=invalid-name\n if not self.is_log_path_valid():\n self.report_404()\n return\n\n try:\n # Get arguments by reading body of request.\n # We read this in chunks to avoid straining\n # socket.read(); around the 10 or 15Mb mark, some platforms\n # begin to have problems (bug #792570).\n max_chunk_size = 10 * 1024 * 1024\n size_remaining = int(self.headers[\"content-length\"])\n chunk_list = []\n while size_remaining:\n chunk_size = min(size_remaining, max_chunk_size)\n chunk = self.rfile.read(chunk_size)\n if not chunk:\n break\n chunk_list.append(chunk)\n size_remaining -= len(chunk_list[-1])\n data = ''.join(chunk_list)\n\n data = self.decode_request_content(StringIO(data))\n if data is None:\n return # response has been sent\n\n if 'data' in data.keys() and 'method' in data['data'].keys():\n response = self.server.dispatch(data['data']['method'], data)\n else:\n response = None\n\n except Exception: # This should only happen if the module is buggy\n # internal error, report as HTTP server error\n self.send_response(500)\n raise\n else:\n # got a valid LOG response\n self.send_200_resp(response, \"text/plain\")","def _doPOST(POST_DATA=LOGIN_POST_DATA, extra_headers=META_HEADERS, args=None, url=LOGIN_URL, cookies=None):\n body = ''\n if POST_DATA:\n body = '&'.join([k+'='+v for k,v in POST_DATA.items()]) % args\n \n headers={\n 'Accept-Encoding' : 'deflate',\n 'Content-Length' : len(body),\n }\n if extra_headers:\n headers.update(extra_headers)\n \n request = urllib2.Request(url, body, headers)\n try:\n response = urllib2.urlopen(request)\n if not cookies:\n cookies = CookieJar()\n cookies.extract_cookies(response, request)\n cookie_handler= urllib2.HTTPCookieProcessor(cookies)\n redirect_handler= urllib2.HTTPRedirectHandler()\n opener = urllib2.build_opener(redirect_handler, cookie_handler)\n resp = opener.open(request)\n return cookies, resp.read()\n except urllib2.HTTPError, e:\n print >> sys.stderr, \"Sky servers having some trouble - \", e\n raise e\n except urllib2.URLError, e:\n print >> sys.stderr, \"Sky servers having some trouble - \", e\n raise e","def do_POST(self):\r\n if 'grade' in self.path and self._send_graded_result().status_code == 200:\r\n status_message = 'LTI consumer (edX) responded with XML content:<br>' + self.server.grade_data['TC answer']\r\n content = self._create_content(status_message)\r\n self.send_response(200, content)\r\n elif 'lti2_outcome' in self.path and self._send_lti2_outcome().status_code == 200:\r\n status_message = 'LTI consumer (edX) responded with HTTP {}<br>'.format(\r\n self.server.grade_data['status_code'])\r\n content = self._create_content(status_message)\r\n self.send_response(200, content)\r\n elif 'lti2_delete' in self.path and self._send_lti2_delete().status_code == 200:\r\n status_message = 'LTI consumer (edX) responded with HTTP {}<br>'.format(\r\n self.server.grade_data['status_code'])\r\n content = self._create_content(status_message)\r\n self.send_response(200, content)\r\n # Respond to request with correct lti endpoint\r\n elif self._is_correct_lti_request():\r\n params = {k: v for k, v in self.post_dict.items() if k != 'oauth_signature'}\r\n\r\n if self._check_oauth_signature(params, self.post_dict.get('oauth_signature', \"\")):\r\n status_message = \"This is LTI tool. Success.\"\r\n\r\n # Set data for grades what need to be stored as server data\r\n if 'lis_outcome_service_url' in self.post_dict:\r\n self.server.grade_data = {\r\n 'callback_url': self.post_dict.get('lis_outcome_service_url').replace('https', 'http'),\r\n 'sourcedId': self.post_dict.get('lis_result_sourcedid')\r\n }\r\n\r\n submit_url = '//{}:{}'.format(*self.server.server_address)\r\n content = self._create_content(status_message, submit_url)\r\n self.send_response(200, content)\r\n\r\n else:\r\n content = self._create_content(\"Wrong LTI signature\")\r\n self.send_response(200, content)\r\n else:\r\n content = self._create_content(\"Invalid request URL\")\r\n self.send_response(500, content)","def _PostRequest(self, data=None):\n # requests will use about 3 times of data size's memory.\n req = requests.Request(\n 'POST',\n url=self._target_url,\n headers={'Multi-Event': 'True',\n 'Node-ID': str(self.GetNodeID())},\n files=data).prepare()\n clen = int(req.headers.get('Content-Length'))\n # Checks the size of request, and doesn't send if bigger than maximum size.\n if clen > self._max_bytes:\n return (413, 'Request Entity Too Large: The request is bigger '\n 'than %d bytes' % self._max_bytes, clen)\n resp = requests.Session().send(req, timeout=http_common.HTTP_TIMEOUT)\n if resp.headers['Maximum-Bytes']:\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\n return resp.status_code, resp.reason, clen","def do_POST(self):\n global st_point, cur_request\n if time.time() - st_point < 1 and cur_request > args.MAX_REQ:\n self.send_response(429)\n self.send_header(\"Content-type\",\"text/html\")\n self.end_headers()\n time.sleep(0.2)\n return\n elif time.time() - st_point > 1:\n st_point = time.time()\n cur_request = 1\n self.func_PARSE()\n if self.parsed_url[2] in [\"/cat\"]:\n self.func_DO()\n else:\n self.send_response(400)\n text=\"<h1 align=center>Bad request</h1>\"\n self.func_PRINT(text)","def _handle_post_request(self):\n form = cgi.FieldStorage(\n fp=self.rfile,\n headers=self.headers,\n environ={'REQUEST_METHOD': 'POST'})\n\n if self.path == '/URLRequest':\n # First we check, whether the formular has been filled by\n # something behaving like a bot\n if form.has_key('URL'):\n self._send_homepage('<p class=\"warning\">Please check your input</p>')\n return\n else:\n url = form['real_URL'].value if form.has_key('real_URL') else None\n tmp = self._insert_url_to_db(url)\n if tmp:\n try:\n blocked = self._db.is_hash_blocked(tmp)\n if tmp < 0:\n self._send_database_problem()\n return\n elif blocked:\n self._send_blocked_page(blocked[3])\n return\n else:\n self._send_return_page(tmp)\n return\n except YuDatabaseError:\n self._send_database_problem()\n return\n else:\n # There was a general issue with URL\n self._send_homepage('''<p class=\"warning\">Please check your input.</p>''')\n return\n elif self.path == '/ContactUs':\n if form.has_key('URL'):\n # Here we might have a bot who likes to send the webmaster some spam\n # who most likely will be not amused about.\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail NOT sent',\n msg='There was an issue with your request. Are you a bot? '\n '<a href=\"/ContactUs\">Please try again</a>.')\n else:\n try:\n email = form['email'].value\n subj = form['subject'].value\n descr = form['request'].value\n if self._send_mail(subj, descr, email):\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail sent',\n msg=\"Your request has been sent. You will receive an answer soon.\")\n else:\n self._send_internal_server_error()\n return\n except KeyError:\n template_filename = self._get_config_template('contactUsResult')\n text = read_template(\n template_filename,\n title='',\n header='Mail NOT sent',\n msg='It appers you did not fill out all needed fields.\\\n <a href=\"/ContactUs\">Please try again</a>.')\n\n elif self.path == '/Show':\n short_url = form['ShortURL'].value if form.has_key('ShortURL') else None\n if short_url != None and short_url.find(\"yaturl.net\") > -1:\n tmp = short_url.rfind(\"/\")\n if tmp > -1 and short_url != \"\":\n tmp = tmp + 1\n short_url = short_url[tmp:]\n if short_url != None and short_url.isalnum():\n try:\n result = self._db.get_link_from_db(short_url)\n except YuDatabaseError:\n self._send_database_problem()\n return\n template_filename = self._get_config_template('showpage')\n if result:\n new_url = '<p><a href=\"%(result)s\">%(result)s</a></p>' % \\\n {'result': result}\n else:\n new_url = '<p class=\"warning\">No URL found for this string. Please double check your\\\n <a href=\"/ShowURL\">input and try again</a></p>'\n\n stats = self._db.get_statistics_for_hash(short_url)\n\n text = read_template(\n template_filename,\n title=SERVER_NAME,\n header=SERVER_NAME,\n msg=new_url,\n stat=stats,\n statspage=\"/stats/\" + short_url)\n else:\n self._send_404()\n return\n\n else:\n self._send_404()\n return\n\n self._send_response(text, 200)","def requestReceivedPOST(self, path, version):\n import cgi\n \n self.content.seek(0,0)\n self.args = {}\n self.extended_args = {}\n self.stack = []\n\n self.method = 'POST'\n self.uri = path\n self.clientproto = version\n x = self.uri.split('?')\n\n argstring = \"\"\n if len(x) == 1:\n self.path = self.uri\n else:\n if len(x) != 2:\n from twisted.python import log\n log.msg(\"May ignore parts of this invalid URI: %s\"\n % repr(self.uri))\n self.path, argstring = x[0], x[1]\n\n # cache the client and server information, we'll need this later to be\n # serialized and sent with the request so CGIs will work remotely\n self.client = self.channel.transport.getPeer()\n self.host = self.channel.transport.getHost()\n\n # create dummy env for cgi.FieldStorage\n env = {\n 'REQUEST_METHOD': self.method,\n 'QUERY_STRING': argstring,\n }\n form = cgi.FieldStorage(fp=self.content,\n environ=env,\n headers=self.received_headers)\n\n # Argument processing\n\n args = self.args\n try:\n keys = form.keys()\n except TypeError:\n pass\n else:\n for key in keys:\n values = form[key]\n if not isinstance(values, list):\n values = [values]\n fixedResult = []\n for i in values:\n if isinstance(i, cgi.MiniFieldStorage):\n fixedResult.append(i.value)\n elif isinstance(i, cgi.FieldStorage):\n fixedResult.append(i.value)\n # multiple uploads to same form field are stupid!\n if i.filename:\n args[key + '__filename__'] = i.filename\n args[key] = fixedResult\n \n self.process()","def registerHTTPPostCallbacks():\n libxml2mod.xmlRegisterHTTPPostCallbacks()","def post(self):\n policies = json.loads(self.request.get('policies'))\n request = json.loads(self.request.get('request_json'))\n response = json.loads(self.request.get('response_json'))\n\n maybe_notify_backend('LEASED', response['hostname'], policies)\n maybe_notify_lessee(request, response)","def __httpsRequest(self, method, _uri, body='', files=None, headers={}, stream=False):\n\n #-------------------- \n # Make the request arguments\n #--------------------\n url = Xnat.path.makeXnatUrl(self.host, _uri)\n print(f\"{method} XNAT URL: {url}\")\n if (body):\n print(body)\n\n #-------------------- \n # Conduct REST call\n #-------------------- \n # self.__requests_worker(method, url, body, files, headers, stream)\n t = threading.Thread(\n target=self.__requests_worker, \n args=(method, url, body, files, headers, stream,))\n t.start()\n t.join()\n \n return self.response","def do_POST(self):\r\n self.do_GET()","def post(self, *args, **kwargs):\n return self._requests_call(util.requests_post, *args, **kwargs)","def do_POST(self):\n bugsnag = self.server.bugsnag\n body = self.rfile.read(int(self.headers['Content-Length']))\n bugsnag.enqueue(body)\n\n response = (\"OK %s:%s -> %s (%s/%s)\\n\" % (bugsnag.listen, bugsnag.port, bugsnag.endpoint, bugsnag.queue.qsize(), bugsnag.queue.maxsize))\n\n try:\n self.send_response(200)\n self.send_header('Content-Length', len(response))\n self.end_headers()\n self.wfile.write(response)\n except:\n print \"Client disconnected before waiting for response\"\n print_exception(*sys.exc_info())\n print \"continuing...\"","def _req_post(self, url: str, data, raw_res: bool = False):\n self._get_cookies()\n if not self._cookies:\n return\n r = reqtry.post(url, cookies=self._cookies, data=data, allow_redirects=False, timeout=(3, 3), tries=3, delay=1,\n backoff=1.5, jitter=(1, 1.5))\n if raw_res:\n return r\n assert r.status_code == 200, f\"Post request: Invalid http status code: {r.status_code}\"\n assert '\"errCode\":0' in r.text, f'Post response with error from server. Response: {r.text}'\n return r.text","def _postproc(self, request):\n if request.status_code != 200: raise Exception('wrong error code: {0}'.format(request.status_code))\n data = request.json()\n self.data = self._finalize_data(data)","def post(self):","def _process_request(self):\n if not self._requests:\n if self._stream:\n self._stream.close()\n self._stream = None\n if self._processing:\n self._processing = False\n Engine.instance().stop()\n return\n\n request = self._requests[0]\n\n request.append(\n Engine.instance().defer(request[5], self._request_timeout, request))\n\n port = request[2].port\n if not port:\n if request[2].scheme.lower() == 'https':\n port = 443\n else:\n port = 80\n\n host = \"%s:%d\" % (request[2].hostname, port)\n\n if self._stream:\n if not self._server == host.lower() or not \\\n self._is_secure == (request[2].scheme.lower() == 'https'):\n self._stream.end()\n return\n\n if not self._stream:\n # Store the current server.\n self._server = host.lower()\n\n # Create a Stream, hook into it, and connect.\n self._stream = Stream()\n\n self._stream.on_close = self._on_close\n self._stream.on_connect = self._on_connect\n\n self._is_secure = request[2].scheme.lower() == 'https'\n if self._is_secure:\n raise Exception(\"SSL has not yet been implemented in this version of Pants.\")\n self._stream.startTLS()\n\n self._stream.connect((request[2].hostname, port))\n return\n\n # If we got here, we're connected, and to the right server. Do stuff.\n self._stream.write('%s %s HTTP/1.1%s' % (request[0], request[8], CRLF))\n for k, v in request[3].iteritems():\n self._stream.write('%s: %s%s' % (k, v, CRLF))\n\n if request[4]:\n self._stream.write('%s%s' % (CRLF, request[4]))\n else:\n self._stream.write(CRLF)\n\n # Now, wait for a response.\n self._stream.on_read = self._read_headers\n self._stream.read_delimiter = DOUBLE_CRLF","def postTo(self,conn,data):\n #log(\"postTo: \"+str(conn))\n conn.request(self.command,self.path,data,self.headers)\n resp = conn.getresponse()\n log(\"postTo: \"+str(resp.status)+\", \"+str(resp.reason)+\", \"+str(resp.version))\n return resp","def post():\n pass","def http_method_post():\n return 'POST'","def server_do(self,input, connstream):\r\n pass","def _handle_error(error):\n try:\n #Abandon any active timeout triggers\n if timeoutCall.active():\n timeoutCall.cancel()\n #Unexpected error on HTTPS POST, we may want to move to the next node.\n self.log.error(\"Error on HTTPS POST : {cls!r} : {err!r}. {node!r}\",cls=error.type.__name__,err=error.getErrorMessage(),node = self.nodes[self.node_index])\n self._next_node()\n except Exception as ex:\n self.log.failure(\"Error in _handle_error {err!r}. {node!r}\",err=str(ex),node = self.nodes[self.node_index])\n #Add the failed sub-queue back to the command queue, we shall try again soon.\n self.queue = subqueue + self.queue\n ##If something went wrong, the HTTPS POST isn't active anymore.\n self.active_call_count = self.active_call_count - 1\n #Invoke self, possibly sending new queues RPC calls to the current node\n self()","def request(self, host, handler, request_body, verbose):\n headers = {'User-Agent': self.user_agent,\n 'Content-Type': 'text/xml',\n }\n url = self._build_url(host, handler)\n kwargs = {}\n if StrictVersion(requests.__version__) >= StrictVersion('0.8.8'):\n kwargs['verify'] = True\n else:\n if self.use_https:\n warnings.warn(\n 'using https transport but no certificate '\n 'verification. (Hint: upgrade requests package.)')\n try:\n resp = requests.post(url, data=request_body, headers=headers,\n **kwargs)\n except ValueError:\n raise\n except Exception:\n raise # something went wrong\n else:\n try:\n resp.raise_for_status()\n except requests.RequestException as e:\n raise xmlrpc.ProtocolError(\n url, resp.status_code, str(e), resp.headers)\n else:\n return self.parse_response(resp)","def _post(self, request_obj):\n return self._execute_action(request_obj, 'POST')","def post(self):\n text = 'HELLO from socnet API Server!'\n return push_to_mattermost(text)","def on_post(self, req, resp):\n helping.parseReqBody(req)\n survey_data = req.body\n\n # documentation says remote_addr is a string,\n # but in some cases it's a tuple.\n ip_address = req.remote_addr\n key = str(uuid.uuid4())\n\n if type(ip_address) is tuple:\n ip_address = ip_address[0]\n\n body = {\n \"survey_data\": survey_data,\n \"metadata\": {\n \"ip_address\": ip_address,\n \"received\": str(arrow.utcnow())\n }\n }\n\n # We don't want to lose survey data, so if an ip address\n # cannot be found log it and save the data.\n if type(ip_address) is not str:\n log_data = {\n \"title\": \"Unknown IP Address Format\",\n \"description\": \"Could not access requester's IP Address. {}\".format(req.remote_addr),\n \"request_body\": body,\n \"remote_addr\": req.remote_addr,\n \"ip_address\": ip_address\n }\n dbing.logDB.save(key, log_data)\n\n dbing.surveyDB.save(key, body)\n\n resp.body = json.dumps({key: body}, ensure_ascii=False)\n resp.status = falcon.HTTP_201","def HandlePingRequest(self, request, response):\n self._publish_helper.HandlePingRequest(request, response)","def get_WebInterfaceHandlerLocal(destination_addr, destination_port):\n\n class WebInterfaceHandlerLocal(BaseHTTPRequestHandler):\n\n def do_GET(self):\n # gather client's request\n host = str(destination_addr)\n port = str(destination_port)\n path = str(self.path)\n headers = self.headers\n\n # resend the client's request to the server\n # gather server's response\n api = 'https://{}:{}{}'.format(host, port, path)\n myssl = create_ssl_context()\n response, headers, code = fetch_get(api, myssl, headers=headers)\n\n # send server's response to the client\n self.send_response(code)\n for header in headers:\n print(repr(header))\n k, v = header.split(\":\", 1)\n self.send_header(k.strip(), v.strip())\n self.end_headers()\n try:\n self.wfile.write(response)\n except ssl.SSLEOFError:\n # TODO - why is suppress_ragged_eofs ignored?\n print(\"ssl.SSLEOFError (#TODO in the code)\")\n\n def do_POST(self):\n # gather client's request\n host = str(destination_addr)\n port = str(destination_port)\n path = str(self.path)\n headers = self.headers\n data = self.rfile.read(int(self.headers['Content-Length']))\n\n # resend the client's request to the server\n # gather server's response\n api = 'https://{}:{}{}'.format(host, port, path)\n myssl = create_ssl_context()\n response, headers, code = fetch_post(api, myssl, data, headers=headers)\n\n # send server's response to the client\n self.send_response(code)\n for header in headers:\n print(repr(header))\n k, v = header.split(\":\", 1)\n self.send_header(k.strip(), v.strip())\n self.end_headers()\n try:\n self.wfile.write(response)\n except ssl.SSLEOFError:\n # TODO - why is suppress_ragged_eofs ignored?\n print(\"ssl.SSLEOFError (#TODO in the code)\")\n\n def do_HEAD(self):\n # gather client's request\n host = str(destination_addr)\n port = str(destination_port)\n path = str(self.path)\n headers = self.headers\n\n # resend the client's request to the server\n # gather server's response\n api = 'https://{}:{}{}'.format(host, port, path)\n myssl = create_ssl_context()\n headers, code = fetch_head(api, myssl, headers=headers)\n\n # send server's response to the client\n self.send_response(code)\n for header in headers:\n print(repr(header))\n k, v = header.split(\":\", 1)\n self.send_header(k.strip(), v.strip())\n self.end_headers()\n\n return WebInterfaceHandlerLocal","def do_POST(self):\n is_valid = False\n\n agent = self.headers.getheader(\"User-Agent\")\n\n # print User-Agent, helps to diagnose, bitbucket should be\n # \"Bitbucket-Webhooks/2.0\"\n if not self.quiet:\n LOGGER.info(\"User Agent is: %s\", agent)\n\n if agent == \"Bitbucket-Webhooks/2.0\":\n is_valid = self.processBitBucketRequest()\n else:\n is_valid = self.processGithubRequest()\n\n if is_valid:\n LOGGER.info('git hook request processed')\n else:\n LOGGER.error('could not process git hook request')\n\n for url in self.urls:\n paths = self.getMatchingPaths(url)\n for path in paths:\n fetch(path)\n self.deploy(path)","def handleRequest(self, s, request):\n client = self.connections[s]\n\n try:\n logging.info(\"HANDLING message from %s: %r\", client, repr(request))\n\n try:\n req = json.loads(request)\n req = dic_b64_and_pickle_loads(req)\n except:\n return\n\n if not isinstance(req, dict):\n return\n\n if 'type' not in req:\n return\n\n if req['type'] == 'ack':\n return # Ignore for now\n\n client.send({'type': 'ack'})\n\n if req['type'] == 'connect':\n self.processConnect(client, req)\n elif req['type'] == 'secure':\n self.processSecure(client, req)\n\n except Exception:\n logging.exception(\"Could not handle request\")","def _post(self, *args, **kwargs):\n return self._request('post', *args, **kwargs)","def do_POST(self):\n response_body = get_response_body(\"index.html\")\n\n self.send_response(200)\n self.send_header('Content-type', 'text/xml; charset=UTF-8')\n self.send_header('Content-length', len(response_body))\n self.end_headers()\n self.wfile.write(response_body)\n logging.info('[Request method] POST')\n logging.info(\"[Request headers]\\n%s\", str(self.headers))\n\n content_len = int(self.headers.getheader('content-length', 0))\n post_body = self.rfile.read(content_len)\n logging.info('[Request doby]\\n%s', post_body)","def send_post(data, serial_object, host, url):\n datalen = len(data) + 4\n \n if _open_serv(host, serial_object):\n try:\n serial_object.write(('AT+CIPSEND=0,\\r\\n').encode())\n time.sleep(0.5)\n serial_object.write(('POST {} HTTP/1.1\\r\\n').format(url).encode())\n serial_object.write(('Host: {}\\r\\n').format(host).encode())\n serial_object.write(('Content-Type: application/json\\r\\n').encode()) \n serial_object.write(('Accept: */*\\r\\n').encode())\n serial_object.write(('Content-Length: {}\\r\\n').format(datalen).encode())\n serial_object.write(('\\r\\n').encode())\n serial_object.write(('\\r\\n').encode())\n serial_object.write(('{}\\r\\n').format(data).encode())\n serial_object.write(('\\r\\n').encode())\n serial_object.write(('\\r\\n').encode())\n serial_object.write(chr(26).encode())\n pat = re.compile('\\+IPCLOSE: 0,1')\n if _valid_send(serial_object, pat):\n print ('Data Send')\n else:\n print ('Cannot send data')\n except serial.SerialException:\n print ('Something goes wrong')","def _on_close(self):\n self._stream = None\n self._is_secure = False\n self._process_request()","def do_POST(self):\n\n # do this before sending any response as we may raise an exception\n content = self.__get_content(self.__get_post_body())\n\n # send the response back to the client\n self.send_response(200)\n self.send_header(\"Content-type\", \"text/json\")\n self.end_headers()\n self.wfile.write(content)","def exec_handler(self, body = None):\n h = self.MyTestHandler()\n h.request = Request.blank('/test_rpc/')\n h.response = Response()\n h.request.body = body\n h.post()\n return (h.response._Response__status[0], h.response.out.getvalue())","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def post(self):\n pass","def handle_request(self, t):\n\n # respect ur elders\n super(StoreServer,self).handle_request(t)\n\n # convert out tuple to a request\n request = StoreRequest(t)\n\n # come up w/ a response for them\n response = StoreResponse(key=request.key,\n url=self.get_url(),\n port=self.get_port())\n\n # now spin up a handler for that port\n handler = StoreHandler(self,(response.url,response.port))\n\n # send back our response\n self.bb_client.put(response)","def do_POST(self):\n self.send_response(200)\n self.send_header('Content-type','text/html')\n self.send_header('Access-Control-Allow-Origin','*')\n self.end_headers()\n # Send the html message\n self.wfile.write(\"Aivis Panovs, 161REB125\")\n return","def handle_post(cls, **kwargs):\n raise NotImplementedError","def _HandleShutdown(self):\n self.send_response(httplib.OK)\n self.send_header('Content-Type', 'text/plain')\n self.end_headers()\n self.wfile.write('API Server Quitting')\n self.server.shutdown()","def do_POST(self):\r\n msg = \"XQueue received POST request {0} to path {1}\".format(self.post_dict, self.path)\r\n self.log_message(msg)\r\n\r\n # Respond only to grading requests\r\n if self._is_grade_request():\r\n\r\n # If configured, send the grader payload to other services.\r\n self._register_submission(self.post_dict['xqueue_body'])\r\n\r\n try:\r\n xqueue_header = json.loads(self.post_dict['xqueue_header'])\r\n callback_url = xqueue_header['lms_callback_url']\r\n\r\n except KeyError:\r\n # If the message doesn't have a header or body,\r\n # then it's malformed. Respond with failure\r\n error_msg = \"XQueue received invalid grade request\"\r\n self._send_immediate_response(False, message=error_msg)\r\n\r\n except ValueError:\r\n # If we could not decode the body or header,\r\n # respond with failure\r\n error_msg = \"XQueue could not decode grade request\"\r\n self._send_immediate_response(False, message=error_msg)\r\n\r\n else:\r\n # Send an immediate response of success\r\n # The grade request is formed correctly\r\n self._send_immediate_response(True)\r\n\r\n # Wait a bit before POSTing back to the callback url with the\r\n # grade result configured by the server\r\n # Otherwise, the problem will not realize it's\r\n # queued and it will keep waiting for a response indefinitely\r\n delayed_grade_func = lambda: self._send_grade_response(\r\n callback_url, xqueue_header, self.post_dict['xqueue_body']\r\n )\r\n\r\n delay = self.server.config.get('response_delay', self.DEFAULT_RESPONSE_DELAY)\r\n Timer(delay, delayed_grade_func).start()\r\n\r\n # If we get a request that's not to the grading submission\r\n # URL, return an error\r\n else:\r\n self._send_immediate_response(False, message=\"Invalid request URL\")","def handle_request(self, data, peer):\n\n req = Request.parse(data)\n if req:\n handler = self.get_hanlder(\n req, (self.host, self.port), peer, \n self._retries, self._timeout\n )\n handler.run()","def handle_ssl_shutdown(self):\n\t\t\tself.log_info('unhandled handle_ssl_shutdown event', 'warning')","def _send_to_endpoint(self, events):\n if not self.endpoint.startswith('https://'):\n logging.error(\"Received invalid https endpoint: %s\", self.endpoint)\n return False\n\n logging.debug('event_mon: POSTing events to %s', self.endpoint)\n\n attempt = 0 # silencing pylint\n for attempt in xrange(self.try_num): # pragma: no branch\n # (re)set this time at the very last moment\n events.request_time_ms = time_ms()\n response = None\n try:\n if self._dry_run:\n logging.info('Http requests disabled. Not sending anything')\n else: # pragma: no cover\n response, _ = self._http.request(\n uri=self.endpoint,\n method='POST',\n headers={'Content-Type': 'application/octet-stream'},\n body=events.SerializeToString()\n )\n\n if self._dry_run or response.status == 200:\n logging.debug('Succeeded POSTing data after %d attempts', attempt + 1)\n return True\n\n except Exception:\n logging.exception('exception when POSTing data')\n\n if response:\n logging.error('failed to POST data to %s Status: %d (attempt %d)',\n self.endpoint, response.status, attempt)\n\n if attempt == 0:\n logging.error('data: %s', str(events)[:2000])\n\n self._sleep_fn(backoff_time(attempt, retry_backoff=self.retry_backoff))\n\n logging.error('failed to POST data after %d attempts, giving up.',\n attempt+1)\n return False","def do_post_request(self, uri, headers, payload, timeout_ms, stats_config):\n return self._do_request('POST', uri, headers, payload, timeout_ms,\n stats_config)","def handle_request(self):\n\t\ttry:\n\t\t\trequest, client_address = self.get_request()\n\t\texcept socket.error:\n\t\t\treturn\n\t\tif self.verify_request(request, client_address):\n\t\t\ttry:\n\t\t\t\tself.process_request(request, client_address)\n\t\t\texcept:\n\t\t\t\tself.handle_error(request, client_address)\n\t\t\t\tself.close_request(request)","def _http_post(self, path, data):\n # Prepare the request path\n if path[0] == '/':\n path = path[1:]\n path = urljoin(self.servlet_path, path)\n\n # Request the end points\n conn = httplib.HTTPConnection(\"localhost\", self.port)\n conn.request(\"POST\", path, data, {\"Content-Type\": \"application/json\"})\n result = conn.getresponse()\n data = result.read()\n conn.close()\n\n # Convert the response to a string\n return result.status, to_str(data)","def do_POST(self):\n global pages, devices, settings\n try:\n ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))\n if ctype == 'application/x-www-form-urlencoded':\n length = int(self.headers.getheader('content-length'))\n postvars = cgi.parse_qs(self.rfile.read(length), keep_blank_values=1)\n #if(self.path != '/simple/updateGPSCoordinates'):\n #print postvars\n #print self.path\n #now call the function that is meant to process this request\n if(self.path == '/simple/selectedHousehold'):\n #print 'need to get all cows in household #%s ' % postvars['household'][0]\n output = pages[postvars['page'][0]].selectedHousehold(postvars['household'][0], devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/selectedSite'):\n #print 'need to get all the households from the site #%s ' % postvars['sites'][0]\n output = pages[postvars['page'][0]].selectedSite(postvars['sites'][0], devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/nextAnimal'):\n #print 'we have finalized saving samples for one animal, now we need to go to the next animal'\n output = pages[postvars['page'][0]].nextAnimal(postvars, devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/sampleCow'):\n #print 'we sampling the cow'\n #we have the cow that we want to sample...now proceed with the sampling\n output = pages[postvars['page'][0]].collectSample(postvars, devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/saveSample'):\n #print 'we saving a new sample'\n #the user have entered a sample for an animal\n output = pages[postvars['page'][0]].saveSample(postvars, devices['gps'], settings['barcode_use'])\n self.wfile.write(output)\n elif(self.path == '/simple/updateGPSCoordinates'):\n #we want to get the current GPS position\n output = pages[postvars['page'][0]].curPosition(devices['gps']) #for the sake of consistence, we just using the passed 'page' variable\n self.wfile.write(output)\n elif(self.path == '/simple/deleteSample'):\n #print 'we need to delete the sample %s ' % postvars['sample'][0]\n #the user have entered a sample for an animal\n output = pages[postvars['page'][0]].deleteSample(postvars['sample'][0], devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/deleteAnimal'):\n #print postvars\n #print 'we need to delete the anial %s ' % postvars['curAnimalRead'][0]\n #the user have entered a sample for an animal\n output = pages[postvars['page'][0]].deleteAnimal(postvars['curAnimalRead'][0], devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/showAllSites'):\n #print postvars\n #print 'we either to show all sites or just the households within a certain radius'\n #the user have entered a sample for an animal\n output = pages[postvars['page'][0]].showSites(postvars, devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/refreshSampler'):\n #print 'I really dont know what to do here, so we shall evaluate it a case on case basis'\n output = pages[postvars['page'][0]].refreshSampler(postvars, devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/simple/updateHouseholds'):\n #print 'The radius of interest has changed...lets update the households'\n output = pages[postvars['page'][0]].updateSites(postvars, devices['gps'])\n self.wfile.write(output)\n elif(self.path == '/admin'):\n #print 'admin page'\n \n if ctype == 'multipart/form-data':\n self.send_response(301)\n form = cgi.parse_multipart(self.rfile, pdict)\n #print form\n pages[form['page'][0]].parse_form(form, info, devices)\n self.send_header('Location', 'http://localhost:%s/%s' % (settings['port'], form['page'][0]))\n self.end_headers()\n except IOError:\n self.send_error(501, 'Unsupported Method')","def do_POST(self, request, response):\n # Store data\n self.data = to_str(request.read_data())\n\n # Respond\n if self.error:\n response.send_content(404, 'Not active', 'text/plain')\n\n else:\n response.send_content(200, 'OK', 'text/plain')","def handle(self):\n try:\n # First, send a response to allow the server to continue.\n rsp = \"220 dictserver <xnooptions> <msgid@msgid>\\n\"\n self.request.sendall(rsp.encode(\"utf-8\"))\n\n # Receive the request.\n data = self.request.recv(1024).strip()\n log.debug(\"[DICT] Incoming data: %r\", data)\n\n if VERIFIED_REQ in data:\n log.debug(\"[DICT] Received verification request from test \"\n \"framework\")\n response_data = VERIFIED_RSP.format(pid=os.getpid())\n else:\n log.debug(\"[DICT] Received normal request\")\n response_data = \"No matches\"\n\n # Send back a failure to find.\n response = \"552 {0}\\n\".format(response_data)\n log.debug(\"[DICT] Responding with %r\", response)\n self.request.sendall(response.encode(\"utf-8\"))\n\n except IOError:\n log.exception(\"[DICT] IOError hit during request\")","def postProcess(self, message):\n self.conn.close()","def handle(self):\n try:\n # Wait for data\n data = json.loads(self.request.recv(1024).decode('UTF-8').strip())\n\n # Process data\n self.process_data(data)\n\n except Exception as e:\n print(\"Exception wile receiving message: \", e)\n self.request.sendall(\n bytes(json.dumps({'return': 'error'}), 'UTF-8'))","def HandleDynamicUpdater(request):\n print \"[*] %s Got Static C&C Updater request: %s\" % (time.ctime(), request.uri)\n print \"\\t[+] Host: %s\" % request.host\n\n message = getUpdaterResponse(CNC_IP, CNC_PORT)\n request.write(\"HTTP/1.1 200 OK\\r\\nContent-Length: %d\\r\\n\\r\\n%s\" % (len(message), message))","def PostInputs(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def render_POST(self, request):\n log.msg(\"Paypal callback:\")\n log.msg(request.args)\n\n d = self.verify(request)\n d.addCallback(lambda ign: self._process(request.args))\n d.addErrback(log.err)\n return ''","def handler(self):\r\n\t\tif (self.state != self.INIT):\r\n\t\t\tself.sendRtspRequest(self.TEARDOWN)\r\n\t\t\treply = self.recvRtspReply()\r\n\t\t\t\r\n\t\t\treplyEle = self.parseRtspReply(reply)\r\n\t\t\ttotalSendPacketCount = int(replyEle[3][1])\r\n\r\n\t\t\tif (reply.split('\\n')[0] == \"RTSP/1.0 200 OK\"):\r\n\t\t\t\tself.networkStat.computeLoss(totalSendPacketCount, self.networkStat.receivedPacketCount)\r\n\t\t\t\tself.networkStat.computeADR()\r\n\t\t\t\tself.networkStat.exportLogFile(self.sessionId, self.rtspSeq)\r\n\t\t\t\r\n\t\t\tif os.path.exists(self.cacheFile):\r\n\t\t\t\tos.remove(self.cacheFile)\r\n\t\ttry:\r\n\t\t\tself.rtpSocket_client.close()\r\n\t\t\tself.rtspSocket_client.close()\r\n\t\texcept:\r\n\t\t\tNone\r\n\t\tself.master.destroy()\r\n\t\tsys.exit()","def do_post(self, *args):\n raise NotImplementedError()","def post(self) -> WerkzeugResponse:\n\n _dict = self.unpack_post()\n return self.perform_logout(_dict, BINDING_HTTP_POST)","def communicate_to_server(url, postdata, prefix):\n try:\n f = urllib2.urlopen(url, postdata)\n except urllib2.URLError as url_e:\n error(prefix, \"can't communicate to server (%s)\" % url_e.reason)\n msg = f.read()\n f.close()\n return msg"],"string":"[\n \"def do_POST(self):\\r\\n SimpleXMLRPCRequestHandler.do_POST(self)\\r\\n try:\\r\\n # shut down the connection\\r\\n self.connection.shutdown()\\r\\n except:\\r\\n pass\",\n \"def do_POST(self):\\n\\n try:\\n # get arguments\\n data = self.rfile.read(int(self.headers[\\\"content-length\\\"]))\\n # In previous versions of SimpleXMLRPCServer, _dispatch\\n # could be overridden in this class, instead of in\\n # SimpleXMLRPCDispatcher. To maintain backwards compatibility,\\n # check to see if a subclass implements _dispatch and dispatch\\n # using that method if present.\\n response = self.server._marshaled_dispatch(\\n data, getattr(self, '_dispatch', None)\\n )\\n except: # This should only happen if the module is buggy\\n # internal error, report as HTTP server error\\n self.send_response(500)\\n self.end_headers()\\n else:\\n # got a valid XML RPC response\\n self.send_response(200)\\n self.send_header(\\\"Content-type\\\", \\\"text/xml\\\")\\n self.send_header(\\\"Content-length\\\", str(len(response)))\\n self.end_headers()\\n self.wfile.write(response)\\n\\n # shut down the connection\\n self.wfile.flush()\\n self.connection.shutdown() # Modified here!\",\n \"def do_POST(self):\\n orig_request = ssl_proxy_log.Request(self.path, 'POST', self.headers,\\n self.log, self.http_redirect_table, self.ssl_redirect_table)\\n self.log.debug('do_POST called: %s' % self.path)\\n request_log = self.fetch2(orig_request, self.wfile, self.rfile)\\n\\n# if not request_log:\\n# return\\n\\n# if self.display_filter:\\n# if not self.display_filter.search(self.path):\\n# return\\n\\n if self.interactive:\\n self.Log(request_log)\",\n \"def do_POST(self): # pylint: disable=invalid-name\\n self.handle_request()\",\n \"def PostRequest(self):\\n if self.__Payload: \\n self.__Answer = requests.post(self.__URL, data = self.__Payload, headers = self.__Headers)\\n Logs.WriteToLog(\\\"Data transited to web server\\\")\\n else:\\n Logs.WriteToLog(\\\"No payload in HTTP request\\\")\\n raise Exception(\\\"Payload must be setted\\\")\",\n \"def do_POST(self):\\r\\n content_length = int(self.headers['Content-Length'])\\r\\n body = self.rfile.read(content_length)\\r\\n\\r\\n response = BytesIO()\\r\\n try:\\r\\n res = webServer.handle_post_msg(body)\\r\\n print(res)\\r\\n self.send_response(200)\\r\\n except Exception as e:\\r\\n print(e)\\r\\n res = str(e)\\r\\n self.send_response(500)\\r\\n self.end_headers()\\r\\n response.write(res.encode())\\r\\n self.wfile.write(response.getvalue())\",\n \"def do_POST(self):\\n self._try_to_process_request(self._handle_post_request)\",\n \"def post(self):\\n code, status = run_handlers.handle_data_post(self.request.headers, self.request.body)\\n self.set_status(code)\\n self.write(status)\\n self.finish()\",\n \"def do_POST(self):\\r\\n self._send_handler_response('POST')\",\n \"def do_POST(self):\\n if self.client_address[0] != self.server.authorized_address:\\n logging.error('Received unauthorized RPC request from %s',\\n self.task_address[0])\\n self.send_response(403)\\n response = 'Forbidden'\\n self.send_header('Content-type', 'text/plain')\\n self.send_header('Content-length', str(len(response)))\\n self.end_headers()\\n self.wfile.write(response)\\n else:\\n return SimpleJSONRPCServer.SimpleJSONRPCRequestHandler.do_POST(self)\",\n \"def do_POST(self):\\n self.send_response(httplib.OK)\\n self.send_header('Content-Type', 'application/octet-stream')\\n self.end_headers()\\n\\n response = remote_api_pb.Response()\\n try:\\n request = remote_api_pb.Request()\\n\\n\\n\\n request.ParseFromString(\\n self.rfile.read(int(self.headers['content-length'])))\\n api_response = _ExecuteRequest(request).Encode()\\n response.set_response(api_response)\\n except Exception, e:\\n logging.debug('Exception while handling %s\\\\n%s',\\n request,\\n traceback.format_exc())\\n response.set_exception(pickle.dumps(e))\\n if isinstance(e, apiproxy_errors.ApplicationError):\\n application_error = response.mutable_application_error()\\n application_error.set_code(e.application_error)\\n application_error.set_detail(e.error_detail)\\n self.wfile.write(response.Encode())\",\n \"def HandlePost(self): # pylint: disable=R0201\\n return BaseHandler.CreateError('Not implemented yet!', 501)\",\n \"def do_POST(self):\\n try:\\n self._validate_http_request()\\n except ValueError:\\n return\\n\\n content_length = int(self.headers.get('Content-Length', '0'))\\n request_bytes = self.rfile.read(content_length)\\n while len(request_bytes) < content_length:\\n request_bytes += self.rfile.read(content_length - len(request_bytes))\\n\\n request_raw = request_bytes.decode('utf-8')\\n try:\\n request = json.loads(request_raw)\\n except ValueError as err:\\n error = self._build_rpc_error(None, RpcErrors.PARSE_ERROR, err, keep_null_id=True)\\n self._send_json(error)\\n return\\n\\n if isinstance(request, list):\\n responses = [self._process_request(single) for single in request]\\n response = [r for r in responses if r is not None]\\n elif isinstance(request, dict):\\n response = self._process_request(request)\\n else:\\n try:\\n raise ValueError\\n except ValueError as err:\\n error = self._build_rpc_error(None, RpcErrors.INVALID_REQUEST, err)\\n self._send_json(error)\\n return\\n\\n if response is not None:\\n self._send_json(response)\\n else:\\n self.send_response(200, 'OK')\\n self.end_headers()\",\n \"def do_POST(self):\\n logger.info(\\\"Received a POST request: {}\\\".format(self.path))\\n path = self.strip_path()\\n if path == SET_OP:\\n self.send_response(self.process_set_request())\\n elif path == COMMIT_OP:\\n self.send_response(self.process_commit_request())\\n else:\\n logger.error(\\\"Invalid POST operation {} was received.\\\".format(path))\\n self.send_response(404)\",\n \"def do_POST(self,):\\n self.http_method = 'POST'\\n self.response()\",\n \"def _create_https_connecetion(self,cr, uid, UPS_SERVER,Request_string,UPS_url=\\\"/ups.app/xml/XAV\\\", default_port=443, context={}):\\n conn=httplib.HTTPSConnection(UPS_SERVER,default_port) #creating http connection\\n\\n if not conn:\\n response_data='Connection failed'\\n else:\\n try:\\n conn.request(\\\"POST\\\",UPS_url,Request_string) #requst being sent to ups\\n response = conn.getresponse()\\n except Exception:\\n response_data='Connection failed'\\n else:\\n response_data = response.read()\\n return response_data\",\n \"def handle(self):\\n data = self.request.recv(1024)\\n self.request.send(data)\",\n \"def post(self, *args, **kwargs):\\n return self.handle_post_request()\",\n \"def sendSslEnd(self, req):\\n self._sendTcpMessage(self.SONY_MSG_Tcp_ProxyEnd, req, self.ThreeValueMsg.pack(a=1, b=1, c=0))\",\n \"def submitPost(self):\\n headers, params, proxy = self.getHeaderParamProxyInfo()\\n try:\\n resp = requests.post(self.FullURL, data=self.PostData, headers=headers, params=params, proxies=proxy, verify=False)\\n return str(resp.content)\\n except ConnectionError as ce:\\n try:\\n self.postErrorMessage('[-] Cannot connect to {url}. Server response is {resp} Server error code is {code}'.\\n format(url=self.FullURL, resp=ce.message[0], code=ce.message[1][0]))\\n except:\\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\\n except:\\n self.postErrorMessage('[-] Cannot connect to ' + self.FullURL)\",\n \"async def post(self):\\n\\n # decrypt the request\\n payload = decrypt_message(self.request.body, self.fernet_secret)\\n if not payload:\\n raise tornado.web.HTTPError(status_code=401)\\n\\n # ignore all requests for echo to this handler\\n if payload[\\\"request\\\"] == \\\"echo\\\":\\n LOGGER.error(\\\"This handler can't echo things.\\\")\\n raise tornado.web.HTTPError(status_code=400)\\n\\n # get the request ID\\n reqid = payload.get(\\\"reqid\\\")\\n if reqid is None:\\n raise ValueError(\\n \\\"No request ID provided. \\\" \\\"Ignoring this request.\\\"\\n )\\n\\n # rate limit the request if this is turned on\\n if self.ratelimits:\\n # get the frontend client IP addr\\n frontend_client_ipaddr = payload.get(\\\"client_ipaddr\\\")\\n\\n if not frontend_client_ipaddr:\\n LOGGER.error(\\n \\\"[%s] request: '%s' is missing a payload \\\"\\n \\\"value: 'client_ipaddr' \\\"\\n \\\"needed to calculate rate, dropping this request.\\\"\\n % (reqid, payload[\\\"request\\\"])\\n )\\n raise tornado.web.HTTPError(status_code=400)\\n\\n self.ratelimit_request(\\n reqid,\\n payload[\\\"request\\\"],\\n frontend_client_ipaddr,\\n request_body=payload[\\\"body\\\"],\\n )\\n\\n # if we successfully got past host, decryption, rate-limit validation,\\n # then process the request\\n try:\\n\\n #\\n # dispatch the action handler function\\n #\\n\\n # inject the request ID into the body of the request so the backend\\n # function can report on it\\n payload[\\\"body\\\"][\\\"reqid\\\"] = reqid\\n\\n # inject the PII salt into the body of the request as well\\n payload[\\\"body\\\"][\\\"pii_salt\\\"] = self.pii_salt\\n\\n #\\n # validate the request and choose the function to dispatch\\n #\\n handler_func, problems, validate_msgs = validate_and_get_function(\\n payload[\\\"request\\\"], payload[\\\"body\\\"]\\n )\\n\\n if handler_func is None:\\n problems[\\\"failure_reason\\\"] = \\\"invalid request parameters\\\"\\n response = {\\n \\\"success\\\": False,\\n \\\"response\\\": problems,\\n \\\"messages\\\": [validate_msgs],\\n }\\n else:\\n # inject the config object into the backend function call\\n # this passes along any secrets or settings from environ\\n # directly to those functions\\n backend_func = partial(\\n handler_func, payload[\\\"body\\\"], config=self.config\\n )\\n # run the function associated with the request type\\n loop = tornado.ioloop.IOLoop.current()\\n response = await loop.run_in_executor(\\n self.executor,\\n backend_func,\\n )\\n\\n #\\n # see if the request was one that requires an email and password. in\\n # this case, we'll apply backoff to slow down repeated failed\\n # passwords\\n #\\n passcheck_requests = {\\\"user-login\\\", \\\"user-passcheck-nosession\\\"}\\n\\n if (\\n payload[\\\"request\\\"] in passcheck_requests\\n and response[\\\"success\\\"] is False\\n ):\\n\\n (\\n failure_status,\\n failure_count,\\n failure_wait,\\n ) = await self.handle_failed_logins(payload)\\n\\n # if the user is locked for repeated login failures, handle that\\n if failure_status == \\\"locked\\\":\\n response = await self.lockuser_repeated_login_failures(\\n payload, unlock_after_seconds=self.config.userlocktime\\n )\\n elif failure_status == \\\"wait\\\":\\n LOGGER.warning(\\n \\\"[%s] User with email: %s is being rate-limited \\\"\\n \\\"after %s failed login attempts. \\\"\\n \\\"Current wait time: %.1f seconds.\\\"\\n % (\\n reqid,\\n pii_hash(payload[\\\"body\\\"][\\\"email\\\"], self.pii_salt),\\n failure_count,\\n failure_wait,\\n )\\n )\\n\\n # reset the failed counter to zero for each successful attempt\\n elif (\\n payload[\\\"request\\\"] in passcheck_requests\\n and response[\\\"success\\\"] is True\\n ):\\n\\n self.failed_passchecks.pop(payload[\\\"body\\\"][\\\"email\\\"], None)\\n\\n #\\n # trim the failed_passchecks dict\\n #\\n if len(self.failed_passchecks) > 1000:\\n self.failed_passchecks.pop(self.failed_passchecks.keys()[0])\\n\\n #\\n # form and send the response\\n #\\n await self.send_response(response, reqid)\\n\\n except Exception:\\n\\n LOGGER.exception(\\\"Failed to understand request.\\\")\\n raise tornado.web.HTTPError(status_code=400)\",\n \"def _post_request(self):\\n # check if input file size was not exceeded\\n maxsize = configuration.get_config_value('server', 'maxrequestsize')\\n maxsize = configuration.get_size_mb(maxsize) * 1024 * 1024\\n if self.http_request.content_length > maxsize:\\n raise FileSizeExceeded('File size for input exceeded.'\\n ' Maximum request size allowed: %i megabytes' % maxsize / 1024 / 1024)\\n\\n try:\\n doc = lxml.etree.fromstring(self.http_request.get_data())\\n except Exception as e:\\n if PY2:\\n raise NoApplicableCode(e.message)\\n else:\\n raise NoApplicableCode(e.msg)\\n\\n operation = doc.tag\\n request_parser = self._post_request_parser(operation)\\n request_parser(doc)\",\n \"def do_POST(self):\\n ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))\\n self.body = cgi.FieldStorage(fp=self.rfile,\\n headers=self.headers, environ = {'REQUEST_METHOD':'POST'},\\n keep_blank_values = 1, strict_parsing = 1)\\n # throw away additional data [see bug #427345]\\n while select.select([self.rfile._sock], [], [], 0)[0]:\\n if not self.rfile._sock.recv(1):\\n break\\n self.handle_data()\",\n \"def handle_request(self):\\n try:\\n content_type = self.headers.get('content-type')\\n\\n if content_type != 'application/json':\\n self.write_empty_response(400)\\n return\\n\\n content_len = int(self.headers.get('content-length', 0))\\n\\n # If content was provided, then parse it\\n if content_len > 0:\\n message = json.loads(self.rfile.read(content_len))\\n else:\\n self.write_empty_response(400)\\n return\\n\\n helper.log_info(f'Incoming POST from {self.client_address[0]}: {message}')\\n\\n aspect_type = message['aspect_type']\\n object_id = message['object_id']\\n object_type = message['object_type']\\n # make owner_id a str to avoid issues with athlete_checkpoint dict\\n owner_id = str(message['owner_id'])\\n\\n athlete_checkpoint = helper.get_check_point(\\\"webhook_updates\\\") or {}\\n\\n # We only care about activity updates. New activities are pulled in automatically as strava_api input restarts.\\n if aspect_type == 'update' and object_type == 'activity':\\n if owner_id not in athlete_checkpoint:\\n athlete_checkpoint[owner_id] = []\\n athlete_checkpoint[owner_id].append(object_id)\\n helper.save_check_point(\\\"webhook_updates\\\", athlete_checkpoint)\\n else:\\n athlete_checkpoint[owner_id].append(object_id)\\n helper.save_check_point(\\\"webhook_updates\\\", athlete_checkpoint)\\n helper.log_debug(f'webhooks_updates checkpoint: {helper.get_check_point(\\\"webhook_updates\\\")}')\\n\\n # Send data to Splunk\\n data = json.dumps(message)\\n event = helper.new_event(source=helper.get_input_type(), index=helper.get_output_index(), sourcetype=helper.get_sourcetype(), data=data)\\n ew.write_event(event)\\n\\n # Strava API expects a 200 response\\n self.write_empty_response(200)\\n\\n # Restart strava_api inputs to pull in the data unless it's a delete, as the input doesn't do anything with that anyway.\\n if aspect_type != 'delete':\\n self.restart_input('strava_api', self.SESSION_KEY)\\n helper.log_info(f'Reloading Strava API input to retrieve updated activity {object_id} for athlete {owner_id}.')\\n\\n except Exception as ex:\\n helper.log_error(f'Something went wrong in handle request: {ex}')\",\n \"async def post_to_microservice(self, url, prompt_serialized):\\n # this is the only way that DOES not block django channels, whereas everything else did?!\\n pool.apply_async(\\n requests.post,\\n args=[url, prompt_serialized],\\n callback=on_post_success_to_microservice,\\n error_callback=on_error_to_microservice,\\n )\",\n \"def post(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().post(request, args, kwargs)\",\n \"def post(self, request, *args, **kwargs):\\n verify_secure(request)\\n return super().post(request, args, kwargs)\",\n \"def do_POST(self): # pylint:disable=invalid-name\\n if not self.is_log_path_valid():\\n self.report_404()\\n return\\n\\n try:\\n # Get arguments by reading body of request.\\n # We read this in chunks to avoid straining\\n # socket.read(); around the 10 or 15Mb mark, some platforms\\n # begin to have problems (bug #792570).\\n max_chunk_size = 10 * 1024 * 1024\\n size_remaining = int(self.headers[\\\"content-length\\\"])\\n chunk_list = []\\n while size_remaining:\\n chunk_size = min(size_remaining, max_chunk_size)\\n chunk = self.rfile.read(chunk_size)\\n if not chunk:\\n break\\n chunk_list.append(chunk)\\n size_remaining -= len(chunk_list[-1])\\n data = ''.join(chunk_list)\\n\\n data = self.decode_request_content(StringIO(data))\\n if data is None:\\n return # response has been sent\\n\\n if 'data' in data.keys() and 'method' in data['data'].keys():\\n response = self.server.dispatch(data['data']['method'], data)\\n else:\\n response = None\\n\\n except Exception: # This should only happen if the module is buggy\\n # internal error, report as HTTP server error\\n self.send_response(500)\\n raise\\n else:\\n # got a valid LOG response\\n self.send_200_resp(response, \\\"text/plain\\\")\",\n \"def _doPOST(POST_DATA=LOGIN_POST_DATA, extra_headers=META_HEADERS, args=None, url=LOGIN_URL, cookies=None):\\n body = ''\\n if POST_DATA:\\n body = '&'.join([k+'='+v for k,v in POST_DATA.items()]) % args\\n \\n headers={\\n 'Accept-Encoding' : 'deflate',\\n 'Content-Length' : len(body),\\n }\\n if extra_headers:\\n headers.update(extra_headers)\\n \\n request = urllib2.Request(url, body, headers)\\n try:\\n response = urllib2.urlopen(request)\\n if not cookies:\\n cookies = CookieJar()\\n cookies.extract_cookies(response, request)\\n cookie_handler= urllib2.HTTPCookieProcessor(cookies)\\n redirect_handler= urllib2.HTTPRedirectHandler()\\n opener = urllib2.build_opener(redirect_handler, cookie_handler)\\n resp = opener.open(request)\\n return cookies, resp.read()\\n except urllib2.HTTPError, e:\\n print >> sys.stderr, \\\"Sky servers having some trouble - \\\", e\\n raise e\\n except urllib2.URLError, e:\\n print >> sys.stderr, \\\"Sky servers having some trouble - \\\", e\\n raise e\",\n \"def do_POST(self):\\r\\n if 'grade' in self.path and self._send_graded_result().status_code == 200:\\r\\n status_message = 'LTI consumer (edX) responded with XML content:<br>' + self.server.grade_data['TC answer']\\r\\n content = self._create_content(status_message)\\r\\n self.send_response(200, content)\\r\\n elif 'lti2_outcome' in self.path and self._send_lti2_outcome().status_code == 200:\\r\\n status_message = 'LTI consumer (edX) responded with HTTP {}<br>'.format(\\r\\n self.server.grade_data['status_code'])\\r\\n content = self._create_content(status_message)\\r\\n self.send_response(200, content)\\r\\n elif 'lti2_delete' in self.path and self._send_lti2_delete().status_code == 200:\\r\\n status_message = 'LTI consumer (edX) responded with HTTP {}<br>'.format(\\r\\n self.server.grade_data['status_code'])\\r\\n content = self._create_content(status_message)\\r\\n self.send_response(200, content)\\r\\n # Respond to request with correct lti endpoint\\r\\n elif self._is_correct_lti_request():\\r\\n params = {k: v for k, v in self.post_dict.items() if k != 'oauth_signature'}\\r\\n\\r\\n if self._check_oauth_signature(params, self.post_dict.get('oauth_signature', \\\"\\\")):\\r\\n status_message = \\\"This is LTI tool. Success.\\\"\\r\\n\\r\\n # Set data for grades what need to be stored as server data\\r\\n if 'lis_outcome_service_url' in self.post_dict:\\r\\n self.server.grade_data = {\\r\\n 'callback_url': self.post_dict.get('lis_outcome_service_url').replace('https', 'http'),\\r\\n 'sourcedId': self.post_dict.get('lis_result_sourcedid')\\r\\n }\\r\\n\\r\\n submit_url = '//{}:{}'.format(*self.server.server_address)\\r\\n content = self._create_content(status_message, submit_url)\\r\\n self.send_response(200, content)\\r\\n\\r\\n else:\\r\\n content = self._create_content(\\\"Wrong LTI signature\\\")\\r\\n self.send_response(200, content)\\r\\n else:\\r\\n content = self._create_content(\\\"Invalid request URL\\\")\\r\\n self.send_response(500, content)\",\n \"def _PostRequest(self, data=None):\\n # requests will use about 3 times of data size's memory.\\n req = requests.Request(\\n 'POST',\\n url=self._target_url,\\n headers={'Multi-Event': 'True',\\n 'Node-ID': str(self.GetNodeID())},\\n files=data).prepare()\\n clen = int(req.headers.get('Content-Length'))\\n # Checks the size of request, and doesn't send if bigger than maximum size.\\n if clen > self._max_bytes:\\n return (413, 'Request Entity Too Large: The request is bigger '\\n 'than %d bytes' % self._max_bytes, clen)\\n resp = requests.Session().send(req, timeout=http_common.HTTP_TIMEOUT)\\n if resp.headers['Maximum-Bytes']:\\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\\n return resp.status_code, resp.reason, clen\",\n \"def do_POST(self):\\n global st_point, cur_request\\n if time.time() - st_point < 1 and cur_request > args.MAX_REQ:\\n self.send_response(429)\\n self.send_header(\\\"Content-type\\\",\\\"text/html\\\")\\n self.end_headers()\\n time.sleep(0.2)\\n return\\n elif time.time() - st_point > 1:\\n st_point = time.time()\\n cur_request = 1\\n self.func_PARSE()\\n if self.parsed_url[2] in [\\\"/cat\\\"]:\\n self.func_DO()\\n else:\\n self.send_response(400)\\n text=\\\"<h1 align=center>Bad request</h1>\\\"\\n self.func_PRINT(text)\",\n \"def _handle_post_request(self):\\n form = cgi.FieldStorage(\\n fp=self.rfile,\\n headers=self.headers,\\n environ={'REQUEST_METHOD': 'POST'})\\n\\n if self.path == '/URLRequest':\\n # First we check, whether the formular has been filled by\\n # something behaving like a bot\\n if form.has_key('URL'):\\n self._send_homepage('<p class=\\\"warning\\\">Please check your input</p>')\\n return\\n else:\\n url = form['real_URL'].value if form.has_key('real_URL') else None\\n tmp = self._insert_url_to_db(url)\\n if tmp:\\n try:\\n blocked = self._db.is_hash_blocked(tmp)\\n if tmp < 0:\\n self._send_database_problem()\\n return\\n elif blocked:\\n self._send_blocked_page(blocked[3])\\n return\\n else:\\n self._send_return_page(tmp)\\n return\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n else:\\n # There was a general issue with URL\\n self._send_homepage('''<p class=\\\"warning\\\">Please check your input.</p>''')\\n return\\n elif self.path == '/ContactUs':\\n if form.has_key('URL'):\\n # Here we might have a bot who likes to send the webmaster some spam\\n # who most likely will be not amused about.\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail NOT sent',\\n msg='There was an issue with your request. Are you a bot? '\\n '<a href=\\\"/ContactUs\\\">Please try again</a>.')\\n else:\\n try:\\n email = form['email'].value\\n subj = form['subject'].value\\n descr = form['request'].value\\n if self._send_mail(subj, descr, email):\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail sent',\\n msg=\\\"Your request has been sent. You will receive an answer soon.\\\")\\n else:\\n self._send_internal_server_error()\\n return\\n except KeyError:\\n template_filename = self._get_config_template('contactUsResult')\\n text = read_template(\\n template_filename,\\n title='',\\n header='Mail NOT sent',\\n msg='It appers you did not fill out all needed fields.\\\\\\n <a href=\\\"/ContactUs\\\">Please try again</a>.')\\n\\n elif self.path == '/Show':\\n short_url = form['ShortURL'].value if form.has_key('ShortURL') else None\\n if short_url != None and short_url.find(\\\"yaturl.net\\\") > -1:\\n tmp = short_url.rfind(\\\"/\\\")\\n if tmp > -1 and short_url != \\\"\\\":\\n tmp = tmp + 1\\n short_url = short_url[tmp:]\\n if short_url != None and short_url.isalnum():\\n try:\\n result = self._db.get_link_from_db(short_url)\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n template_filename = self._get_config_template('showpage')\\n if result:\\n new_url = '<p><a href=\\\"%(result)s\\\">%(result)s</a></p>' % \\\\\\n {'result': result}\\n else:\\n new_url = '<p class=\\\"warning\\\">No URL found for this string. Please double check your\\\\\\n <a href=\\\"/ShowURL\\\">input and try again</a></p>'\\n\\n stats = self._db.get_statistics_for_hash(short_url)\\n\\n text = read_template(\\n template_filename,\\n title=SERVER_NAME,\\n header=SERVER_NAME,\\n msg=new_url,\\n stat=stats,\\n statspage=\\\"/stats/\\\" + short_url)\\n else:\\n self._send_404()\\n return\\n\\n else:\\n self._send_404()\\n return\\n\\n self._send_response(text, 200)\",\n \"def requestReceivedPOST(self, path, version):\\n import cgi\\n \\n self.content.seek(0,0)\\n self.args = {}\\n self.extended_args = {}\\n self.stack = []\\n\\n self.method = 'POST'\\n self.uri = path\\n self.clientproto = version\\n x = self.uri.split('?')\\n\\n argstring = \\\"\\\"\\n if len(x) == 1:\\n self.path = self.uri\\n else:\\n if len(x) != 2:\\n from twisted.python import log\\n log.msg(\\\"May ignore parts of this invalid URI: %s\\\"\\n % repr(self.uri))\\n self.path, argstring = x[0], x[1]\\n\\n # cache the client and server information, we'll need this later to be\\n # serialized and sent with the request so CGIs will work remotely\\n self.client = self.channel.transport.getPeer()\\n self.host = self.channel.transport.getHost()\\n\\n # create dummy env for cgi.FieldStorage\\n env = {\\n 'REQUEST_METHOD': self.method,\\n 'QUERY_STRING': argstring,\\n }\\n form = cgi.FieldStorage(fp=self.content,\\n environ=env,\\n headers=self.received_headers)\\n\\n # Argument processing\\n\\n args = self.args\\n try:\\n keys = form.keys()\\n except TypeError:\\n pass\\n else:\\n for key in keys:\\n values = form[key]\\n if not isinstance(values, list):\\n values = [values]\\n fixedResult = []\\n for i in values:\\n if isinstance(i, cgi.MiniFieldStorage):\\n fixedResult.append(i.value)\\n elif isinstance(i, cgi.FieldStorage):\\n fixedResult.append(i.value)\\n # multiple uploads to same form field are stupid!\\n if i.filename:\\n args[key + '__filename__'] = i.filename\\n args[key] = fixedResult\\n \\n self.process()\",\n \"def registerHTTPPostCallbacks():\\n libxml2mod.xmlRegisterHTTPPostCallbacks()\",\n \"def post(self):\\n policies = json.loads(self.request.get('policies'))\\n request = json.loads(self.request.get('request_json'))\\n response = json.loads(self.request.get('response_json'))\\n\\n maybe_notify_backend('LEASED', response['hostname'], policies)\\n maybe_notify_lessee(request, response)\",\n \"def __httpsRequest(self, method, _uri, body='', files=None, headers={}, stream=False):\\n\\n #-------------------- \\n # Make the request arguments\\n #--------------------\\n url = Xnat.path.makeXnatUrl(self.host, _uri)\\n print(f\\\"{method} XNAT URL: {url}\\\")\\n if (body):\\n print(body)\\n\\n #-------------------- \\n # Conduct REST call\\n #-------------------- \\n # self.__requests_worker(method, url, body, files, headers, stream)\\n t = threading.Thread(\\n target=self.__requests_worker, \\n args=(method, url, body, files, headers, stream,))\\n t.start()\\n t.join()\\n \\n return self.response\",\n \"def do_POST(self):\\r\\n self.do_GET()\",\n \"def post(self, *args, **kwargs):\\n return self._requests_call(util.requests_post, *args, **kwargs)\",\n \"def do_POST(self):\\n bugsnag = self.server.bugsnag\\n body = self.rfile.read(int(self.headers['Content-Length']))\\n bugsnag.enqueue(body)\\n\\n response = (\\\"OK %s:%s -> %s (%s/%s)\\\\n\\\" % (bugsnag.listen, bugsnag.port, bugsnag.endpoint, bugsnag.queue.qsize(), bugsnag.queue.maxsize))\\n\\n try:\\n self.send_response(200)\\n self.send_header('Content-Length', len(response))\\n self.end_headers()\\n self.wfile.write(response)\\n except:\\n print \\\"Client disconnected before waiting for response\\\"\\n print_exception(*sys.exc_info())\\n print \\\"continuing...\\\"\",\n \"def _req_post(self, url: str, data, raw_res: bool = False):\\n self._get_cookies()\\n if not self._cookies:\\n return\\n r = reqtry.post(url, cookies=self._cookies, data=data, allow_redirects=False, timeout=(3, 3), tries=3, delay=1,\\n backoff=1.5, jitter=(1, 1.5))\\n if raw_res:\\n return r\\n assert r.status_code == 200, f\\\"Post request: Invalid http status code: {r.status_code}\\\"\\n assert '\\\"errCode\\\":0' in r.text, f'Post response with error from server. Response: {r.text}'\\n return r.text\",\n \"def _postproc(self, request):\\n if request.status_code != 200: raise Exception('wrong error code: {0}'.format(request.status_code))\\n data = request.json()\\n self.data = self._finalize_data(data)\",\n \"def post(self):\",\n \"def _process_request(self):\\n if not self._requests:\\n if self._stream:\\n self._stream.close()\\n self._stream = None\\n if self._processing:\\n self._processing = False\\n Engine.instance().stop()\\n return\\n\\n request = self._requests[0]\\n\\n request.append(\\n Engine.instance().defer(request[5], self._request_timeout, request))\\n\\n port = request[2].port\\n if not port:\\n if request[2].scheme.lower() == 'https':\\n port = 443\\n else:\\n port = 80\\n\\n host = \\\"%s:%d\\\" % (request[2].hostname, port)\\n\\n if self._stream:\\n if not self._server == host.lower() or not \\\\\\n self._is_secure == (request[2].scheme.lower() == 'https'):\\n self._stream.end()\\n return\\n\\n if not self._stream:\\n # Store the current server.\\n self._server = host.lower()\\n\\n # Create a Stream, hook into it, and connect.\\n self._stream = Stream()\\n\\n self._stream.on_close = self._on_close\\n self._stream.on_connect = self._on_connect\\n\\n self._is_secure = request[2].scheme.lower() == 'https'\\n if self._is_secure:\\n raise Exception(\\\"SSL has not yet been implemented in this version of Pants.\\\")\\n self._stream.startTLS()\\n\\n self._stream.connect((request[2].hostname, port))\\n return\\n\\n # If we got here, we're connected, and to the right server. Do stuff.\\n self._stream.write('%s %s HTTP/1.1%s' % (request[0], request[8], CRLF))\\n for k, v in request[3].iteritems():\\n self._stream.write('%s: %s%s' % (k, v, CRLF))\\n\\n if request[4]:\\n self._stream.write('%s%s' % (CRLF, request[4]))\\n else:\\n self._stream.write(CRLF)\\n\\n # Now, wait for a response.\\n self._stream.on_read = self._read_headers\\n self._stream.read_delimiter = DOUBLE_CRLF\",\n \"def postTo(self,conn,data):\\n #log(\\\"postTo: \\\"+str(conn))\\n conn.request(self.command,self.path,data,self.headers)\\n resp = conn.getresponse()\\n log(\\\"postTo: \\\"+str(resp.status)+\\\", \\\"+str(resp.reason)+\\\", \\\"+str(resp.version))\\n return resp\",\n \"def post():\\n pass\",\n \"def http_method_post():\\n return 'POST'\",\n \"def server_do(self,input, connstream):\\r\\n pass\",\n \"def _handle_error(error):\\n try:\\n #Abandon any active timeout triggers\\n if timeoutCall.active():\\n timeoutCall.cancel()\\n #Unexpected error on HTTPS POST, we may want to move to the next node.\\n self.log.error(\\\"Error on HTTPS POST : {cls!r} : {err!r}. {node!r}\\\",cls=error.type.__name__,err=error.getErrorMessage(),node = self.nodes[self.node_index])\\n self._next_node()\\n except Exception as ex:\\n self.log.failure(\\\"Error in _handle_error {err!r}. {node!r}\\\",err=str(ex),node = self.nodes[self.node_index])\\n #Add the failed sub-queue back to the command queue, we shall try again soon.\\n self.queue = subqueue + self.queue\\n ##If something went wrong, the HTTPS POST isn't active anymore.\\n self.active_call_count = self.active_call_count - 1\\n #Invoke self, possibly sending new queues RPC calls to the current node\\n self()\",\n \"def request(self, host, handler, request_body, verbose):\\n headers = {'User-Agent': self.user_agent,\\n 'Content-Type': 'text/xml',\\n }\\n url = self._build_url(host, handler)\\n kwargs = {}\\n if StrictVersion(requests.__version__) >= StrictVersion('0.8.8'):\\n kwargs['verify'] = True\\n else:\\n if self.use_https:\\n warnings.warn(\\n 'using https transport but no certificate '\\n 'verification. (Hint: upgrade requests package.)')\\n try:\\n resp = requests.post(url, data=request_body, headers=headers,\\n **kwargs)\\n except ValueError:\\n raise\\n except Exception:\\n raise # something went wrong\\n else:\\n try:\\n resp.raise_for_status()\\n except requests.RequestException as e:\\n raise xmlrpc.ProtocolError(\\n url, resp.status_code, str(e), resp.headers)\\n else:\\n return self.parse_response(resp)\",\n \"def _post(self, request_obj):\\n return self._execute_action(request_obj, 'POST')\",\n \"def post(self):\\n text = 'HELLO from socnet API Server!'\\n return push_to_mattermost(text)\",\n \"def on_post(self, req, resp):\\n helping.parseReqBody(req)\\n survey_data = req.body\\n\\n # documentation says remote_addr is a string,\\n # but in some cases it's a tuple.\\n ip_address = req.remote_addr\\n key = str(uuid.uuid4())\\n\\n if type(ip_address) is tuple:\\n ip_address = ip_address[0]\\n\\n body = {\\n \\\"survey_data\\\": survey_data,\\n \\\"metadata\\\": {\\n \\\"ip_address\\\": ip_address,\\n \\\"received\\\": str(arrow.utcnow())\\n }\\n }\\n\\n # We don't want to lose survey data, so if an ip address\\n # cannot be found log it and save the data.\\n if type(ip_address) is not str:\\n log_data = {\\n \\\"title\\\": \\\"Unknown IP Address Format\\\",\\n \\\"description\\\": \\\"Could not access requester's IP Address. {}\\\".format(req.remote_addr),\\n \\\"request_body\\\": body,\\n \\\"remote_addr\\\": req.remote_addr,\\n \\\"ip_address\\\": ip_address\\n }\\n dbing.logDB.save(key, log_data)\\n\\n dbing.surveyDB.save(key, body)\\n\\n resp.body = json.dumps({key: body}, ensure_ascii=False)\\n resp.status = falcon.HTTP_201\",\n \"def HandlePingRequest(self, request, response):\\n self._publish_helper.HandlePingRequest(request, response)\",\n \"def get_WebInterfaceHandlerLocal(destination_addr, destination_port):\\n\\n class WebInterfaceHandlerLocal(BaseHTTPRequestHandler):\\n\\n def do_GET(self):\\n # gather client's request\\n host = str(destination_addr)\\n port = str(destination_port)\\n path = str(self.path)\\n headers = self.headers\\n\\n # resend the client's request to the server\\n # gather server's response\\n api = 'https://{}:{}{}'.format(host, port, path)\\n myssl = create_ssl_context()\\n response, headers, code = fetch_get(api, myssl, headers=headers)\\n\\n # send server's response to the client\\n self.send_response(code)\\n for header in headers:\\n print(repr(header))\\n k, v = header.split(\\\":\\\", 1)\\n self.send_header(k.strip(), v.strip())\\n self.end_headers()\\n try:\\n self.wfile.write(response)\\n except ssl.SSLEOFError:\\n # TODO - why is suppress_ragged_eofs ignored?\\n print(\\\"ssl.SSLEOFError (#TODO in the code)\\\")\\n\\n def do_POST(self):\\n # gather client's request\\n host = str(destination_addr)\\n port = str(destination_port)\\n path = str(self.path)\\n headers = self.headers\\n data = self.rfile.read(int(self.headers['Content-Length']))\\n\\n # resend the client's request to the server\\n # gather server's response\\n api = 'https://{}:{}{}'.format(host, port, path)\\n myssl = create_ssl_context()\\n response, headers, code = fetch_post(api, myssl, data, headers=headers)\\n\\n # send server's response to the client\\n self.send_response(code)\\n for header in headers:\\n print(repr(header))\\n k, v = header.split(\\\":\\\", 1)\\n self.send_header(k.strip(), v.strip())\\n self.end_headers()\\n try:\\n self.wfile.write(response)\\n except ssl.SSLEOFError:\\n # TODO - why is suppress_ragged_eofs ignored?\\n print(\\\"ssl.SSLEOFError (#TODO in the code)\\\")\\n\\n def do_HEAD(self):\\n # gather client's request\\n host = str(destination_addr)\\n port = str(destination_port)\\n path = str(self.path)\\n headers = self.headers\\n\\n # resend the client's request to the server\\n # gather server's response\\n api = 'https://{}:{}{}'.format(host, port, path)\\n myssl = create_ssl_context()\\n headers, code = fetch_head(api, myssl, headers=headers)\\n\\n # send server's response to the client\\n self.send_response(code)\\n for header in headers:\\n print(repr(header))\\n k, v = header.split(\\\":\\\", 1)\\n self.send_header(k.strip(), v.strip())\\n self.end_headers()\\n\\n return WebInterfaceHandlerLocal\",\n \"def do_POST(self):\\n is_valid = False\\n\\n agent = self.headers.getheader(\\\"User-Agent\\\")\\n\\n # print User-Agent, helps to diagnose, bitbucket should be\\n # \\\"Bitbucket-Webhooks/2.0\\\"\\n if not self.quiet:\\n LOGGER.info(\\\"User Agent is: %s\\\", agent)\\n\\n if agent == \\\"Bitbucket-Webhooks/2.0\\\":\\n is_valid = self.processBitBucketRequest()\\n else:\\n is_valid = self.processGithubRequest()\\n\\n if is_valid:\\n LOGGER.info('git hook request processed')\\n else:\\n LOGGER.error('could not process git hook request')\\n\\n for url in self.urls:\\n paths = self.getMatchingPaths(url)\\n for path in paths:\\n fetch(path)\\n self.deploy(path)\",\n \"def handleRequest(self, s, request):\\n client = self.connections[s]\\n\\n try:\\n logging.info(\\\"HANDLING message from %s: %r\\\", client, repr(request))\\n\\n try:\\n req = json.loads(request)\\n req = dic_b64_and_pickle_loads(req)\\n except:\\n return\\n\\n if not isinstance(req, dict):\\n return\\n\\n if 'type' not in req:\\n return\\n\\n if req['type'] == 'ack':\\n return # Ignore for now\\n\\n client.send({'type': 'ack'})\\n\\n if req['type'] == 'connect':\\n self.processConnect(client, req)\\n elif req['type'] == 'secure':\\n self.processSecure(client, req)\\n\\n except Exception:\\n logging.exception(\\\"Could not handle request\\\")\",\n \"def _post(self, *args, **kwargs):\\n return self._request('post', *args, **kwargs)\",\n \"def do_POST(self):\\n response_body = get_response_body(\\\"index.html\\\")\\n\\n self.send_response(200)\\n self.send_header('Content-type', 'text/xml; charset=UTF-8')\\n self.send_header('Content-length', len(response_body))\\n self.end_headers()\\n self.wfile.write(response_body)\\n logging.info('[Request method] POST')\\n logging.info(\\\"[Request headers]\\\\n%s\\\", str(self.headers))\\n\\n content_len = int(self.headers.getheader('content-length', 0))\\n post_body = self.rfile.read(content_len)\\n logging.info('[Request doby]\\\\n%s', post_body)\",\n \"def send_post(data, serial_object, host, url):\\n datalen = len(data) + 4\\n \\n if _open_serv(host, serial_object):\\n try:\\n serial_object.write(('AT+CIPSEND=0,\\\\r\\\\n').encode())\\n time.sleep(0.5)\\n serial_object.write(('POST {} HTTP/1.1\\\\r\\\\n').format(url).encode())\\n serial_object.write(('Host: {}\\\\r\\\\n').format(host).encode())\\n serial_object.write(('Content-Type: application/json\\\\r\\\\n').encode()) \\n serial_object.write(('Accept: */*\\\\r\\\\n').encode())\\n serial_object.write(('Content-Length: {}\\\\r\\\\n').format(datalen).encode())\\n serial_object.write(('\\\\r\\\\n').encode())\\n serial_object.write(('\\\\r\\\\n').encode())\\n serial_object.write(('{}\\\\r\\\\n').format(data).encode())\\n serial_object.write(('\\\\r\\\\n').encode())\\n serial_object.write(('\\\\r\\\\n').encode())\\n serial_object.write(chr(26).encode())\\n pat = re.compile('\\\\+IPCLOSE: 0,1')\\n if _valid_send(serial_object, pat):\\n print ('Data Send')\\n else:\\n print ('Cannot send data')\\n except serial.SerialException:\\n print ('Something goes wrong')\",\n \"def _on_close(self):\\n self._stream = None\\n self._is_secure = False\\n self._process_request()\",\n \"def do_POST(self):\\n\\n # do this before sending any response as we may raise an exception\\n content = self.__get_content(self.__get_post_body())\\n\\n # send the response back to the client\\n self.send_response(200)\\n self.send_header(\\\"Content-type\\\", \\\"text/json\\\")\\n self.end_headers()\\n self.wfile.write(content)\",\n \"def exec_handler(self, body = None):\\n h = self.MyTestHandler()\\n h.request = Request.blank('/test_rpc/')\\n h.response = Response()\\n h.request.body = body\\n h.post()\\n return (h.response._Response__status[0], h.response.out.getvalue())\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def post(self):\\n pass\",\n \"def handle_request(self, t):\\n\\n # respect ur elders\\n super(StoreServer,self).handle_request(t)\\n\\n # convert out tuple to a request\\n request = StoreRequest(t)\\n\\n # come up w/ a response for them\\n response = StoreResponse(key=request.key,\\n url=self.get_url(),\\n port=self.get_port())\\n\\n # now spin up a handler for that port\\n handler = StoreHandler(self,(response.url,response.port))\\n\\n # send back our response\\n self.bb_client.put(response)\",\n \"def do_POST(self):\\n self.send_response(200)\\n self.send_header('Content-type','text/html')\\n self.send_header('Access-Control-Allow-Origin','*')\\n self.end_headers()\\n # Send the html message\\n self.wfile.write(\\\"Aivis Panovs, 161REB125\\\")\\n return\",\n \"def handle_post(cls, **kwargs):\\n raise NotImplementedError\",\n \"def _HandleShutdown(self):\\n self.send_response(httplib.OK)\\n self.send_header('Content-Type', 'text/plain')\\n self.end_headers()\\n self.wfile.write('API Server Quitting')\\n self.server.shutdown()\",\n \"def do_POST(self):\\r\\n msg = \\\"XQueue received POST request {0} to path {1}\\\".format(self.post_dict, self.path)\\r\\n self.log_message(msg)\\r\\n\\r\\n # Respond only to grading requests\\r\\n if self._is_grade_request():\\r\\n\\r\\n # If configured, send the grader payload to other services.\\r\\n self._register_submission(self.post_dict['xqueue_body'])\\r\\n\\r\\n try:\\r\\n xqueue_header = json.loads(self.post_dict['xqueue_header'])\\r\\n callback_url = xqueue_header['lms_callback_url']\\r\\n\\r\\n except KeyError:\\r\\n # If the message doesn't have a header or body,\\r\\n # then it's malformed. Respond with failure\\r\\n error_msg = \\\"XQueue received invalid grade request\\\"\\r\\n self._send_immediate_response(False, message=error_msg)\\r\\n\\r\\n except ValueError:\\r\\n # If we could not decode the body or header,\\r\\n # respond with failure\\r\\n error_msg = \\\"XQueue could not decode grade request\\\"\\r\\n self._send_immediate_response(False, message=error_msg)\\r\\n\\r\\n else:\\r\\n # Send an immediate response of success\\r\\n # The grade request is formed correctly\\r\\n self._send_immediate_response(True)\\r\\n\\r\\n # Wait a bit before POSTing back to the callback url with the\\r\\n # grade result configured by the server\\r\\n # Otherwise, the problem will not realize it's\\r\\n # queued and it will keep waiting for a response indefinitely\\r\\n delayed_grade_func = lambda: self._send_grade_response(\\r\\n callback_url, xqueue_header, self.post_dict['xqueue_body']\\r\\n )\\r\\n\\r\\n delay = self.server.config.get('response_delay', self.DEFAULT_RESPONSE_DELAY)\\r\\n Timer(delay, delayed_grade_func).start()\\r\\n\\r\\n # If we get a request that's not to the grading submission\\r\\n # URL, return an error\\r\\n else:\\r\\n self._send_immediate_response(False, message=\\\"Invalid request URL\\\")\",\n \"def handle_request(self, data, peer):\\n\\n req = Request.parse(data)\\n if req:\\n handler = self.get_hanlder(\\n req, (self.host, self.port), peer, \\n self._retries, self._timeout\\n )\\n handler.run()\",\n \"def handle_ssl_shutdown(self):\\n\\t\\t\\tself.log_info('unhandled handle_ssl_shutdown event', 'warning')\",\n \"def _send_to_endpoint(self, events):\\n if not self.endpoint.startswith('https://'):\\n logging.error(\\\"Received invalid https endpoint: %s\\\", self.endpoint)\\n return False\\n\\n logging.debug('event_mon: POSTing events to %s', self.endpoint)\\n\\n attempt = 0 # silencing pylint\\n for attempt in xrange(self.try_num): # pragma: no branch\\n # (re)set this time at the very last moment\\n events.request_time_ms = time_ms()\\n response = None\\n try:\\n if self._dry_run:\\n logging.info('Http requests disabled. Not sending anything')\\n else: # pragma: no cover\\n response, _ = self._http.request(\\n uri=self.endpoint,\\n method='POST',\\n headers={'Content-Type': 'application/octet-stream'},\\n body=events.SerializeToString()\\n )\\n\\n if self._dry_run or response.status == 200:\\n logging.debug('Succeeded POSTing data after %d attempts', attempt + 1)\\n return True\\n\\n except Exception:\\n logging.exception('exception when POSTing data')\\n\\n if response:\\n logging.error('failed to POST data to %s Status: %d (attempt %d)',\\n self.endpoint, response.status, attempt)\\n\\n if attempt == 0:\\n logging.error('data: %s', str(events)[:2000])\\n\\n self._sleep_fn(backoff_time(attempt, retry_backoff=self.retry_backoff))\\n\\n logging.error('failed to POST data after %d attempts, giving up.',\\n attempt+1)\\n return False\",\n \"def do_post_request(self, uri, headers, payload, timeout_ms, stats_config):\\n return self._do_request('POST', uri, headers, payload, timeout_ms,\\n stats_config)\",\n \"def handle_request(self):\\n\\t\\ttry:\\n\\t\\t\\trequest, client_address = self.get_request()\\n\\t\\texcept socket.error:\\n\\t\\t\\treturn\\n\\t\\tif self.verify_request(request, client_address):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tself.process_request(request, client_address)\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tself.handle_error(request, client_address)\\n\\t\\t\\t\\tself.close_request(request)\",\n \"def _http_post(self, path, data):\\n # Prepare the request path\\n if path[0] == '/':\\n path = path[1:]\\n path = urljoin(self.servlet_path, path)\\n\\n # Request the end points\\n conn = httplib.HTTPConnection(\\\"localhost\\\", self.port)\\n conn.request(\\\"POST\\\", path, data, {\\\"Content-Type\\\": \\\"application/json\\\"})\\n result = conn.getresponse()\\n data = result.read()\\n conn.close()\\n\\n # Convert the response to a string\\n return result.status, to_str(data)\",\n \"def do_POST(self):\\n global pages, devices, settings\\n try:\\n ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))\\n if ctype == 'application/x-www-form-urlencoded':\\n length = int(self.headers.getheader('content-length'))\\n postvars = cgi.parse_qs(self.rfile.read(length), keep_blank_values=1)\\n #if(self.path != '/simple/updateGPSCoordinates'):\\n #print postvars\\n #print self.path\\n #now call the function that is meant to process this request\\n if(self.path == '/simple/selectedHousehold'):\\n #print 'need to get all cows in household #%s ' % postvars['household'][0]\\n output = pages[postvars['page'][0]].selectedHousehold(postvars['household'][0], devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/selectedSite'):\\n #print 'need to get all the households from the site #%s ' % postvars['sites'][0]\\n output = pages[postvars['page'][0]].selectedSite(postvars['sites'][0], devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/nextAnimal'):\\n #print 'we have finalized saving samples for one animal, now we need to go to the next animal'\\n output = pages[postvars['page'][0]].nextAnimal(postvars, devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/sampleCow'):\\n #print 'we sampling the cow'\\n #we have the cow that we want to sample...now proceed with the sampling\\n output = pages[postvars['page'][0]].collectSample(postvars, devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/saveSample'):\\n #print 'we saving a new sample'\\n #the user have entered a sample for an animal\\n output = pages[postvars['page'][0]].saveSample(postvars, devices['gps'], settings['barcode_use'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/updateGPSCoordinates'):\\n #we want to get the current GPS position\\n output = pages[postvars['page'][0]].curPosition(devices['gps']) #for the sake of consistence, we just using the passed 'page' variable\\n self.wfile.write(output)\\n elif(self.path == '/simple/deleteSample'):\\n #print 'we need to delete the sample %s ' % postvars['sample'][0]\\n #the user have entered a sample for an animal\\n output = pages[postvars['page'][0]].deleteSample(postvars['sample'][0], devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/deleteAnimal'):\\n #print postvars\\n #print 'we need to delete the anial %s ' % postvars['curAnimalRead'][0]\\n #the user have entered a sample for an animal\\n output = pages[postvars['page'][0]].deleteAnimal(postvars['curAnimalRead'][0], devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/showAllSites'):\\n #print postvars\\n #print 'we either to show all sites or just the households within a certain radius'\\n #the user have entered a sample for an animal\\n output = pages[postvars['page'][0]].showSites(postvars, devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/refreshSampler'):\\n #print 'I really dont know what to do here, so we shall evaluate it a case on case basis'\\n output = pages[postvars['page'][0]].refreshSampler(postvars, devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/simple/updateHouseholds'):\\n #print 'The radius of interest has changed...lets update the households'\\n output = pages[postvars['page'][0]].updateSites(postvars, devices['gps'])\\n self.wfile.write(output)\\n elif(self.path == '/admin'):\\n #print 'admin page'\\n \\n if ctype == 'multipart/form-data':\\n self.send_response(301)\\n form = cgi.parse_multipart(self.rfile, pdict)\\n #print form\\n pages[form['page'][0]].parse_form(form, info, devices)\\n self.send_header('Location', 'http://localhost:%s/%s' % (settings['port'], form['page'][0]))\\n self.end_headers()\\n except IOError:\\n self.send_error(501, 'Unsupported Method')\",\n \"def do_POST(self, request, response):\\n # Store data\\n self.data = to_str(request.read_data())\\n\\n # Respond\\n if self.error:\\n response.send_content(404, 'Not active', 'text/plain')\\n\\n else:\\n response.send_content(200, 'OK', 'text/plain')\",\n \"def handle(self):\\n try:\\n # First, send a response to allow the server to continue.\\n rsp = \\\"220 dictserver <xnooptions> <msgid@msgid>\\\\n\\\"\\n self.request.sendall(rsp.encode(\\\"utf-8\\\"))\\n\\n # Receive the request.\\n data = self.request.recv(1024).strip()\\n log.debug(\\\"[DICT] Incoming data: %r\\\", data)\\n\\n if VERIFIED_REQ in data:\\n log.debug(\\\"[DICT] Received verification request from test \\\"\\n \\\"framework\\\")\\n response_data = VERIFIED_RSP.format(pid=os.getpid())\\n else:\\n log.debug(\\\"[DICT] Received normal request\\\")\\n response_data = \\\"No matches\\\"\\n\\n # Send back a failure to find.\\n response = \\\"552 {0}\\\\n\\\".format(response_data)\\n log.debug(\\\"[DICT] Responding with %r\\\", response)\\n self.request.sendall(response.encode(\\\"utf-8\\\"))\\n\\n except IOError:\\n log.exception(\\\"[DICT] IOError hit during request\\\")\",\n \"def postProcess(self, message):\\n self.conn.close()\",\n \"def handle(self):\\n try:\\n # Wait for data\\n data = json.loads(self.request.recv(1024).decode('UTF-8').strip())\\n\\n # Process data\\n self.process_data(data)\\n\\n except Exception as e:\\n print(\\\"Exception wile receiving message: \\\", e)\\n self.request.sendall(\\n bytes(json.dumps({'return': 'error'}), 'UTF-8'))\",\n \"def HandleDynamicUpdater(request):\\n print \\\"[*] %s Got Static C&C Updater request: %s\\\" % (time.ctime(), request.uri)\\n print \\\"\\\\t[+] Host: %s\\\" % request.host\\n\\n message = getUpdaterResponse(CNC_IP, CNC_PORT)\\n request.write(\\\"HTTP/1.1 200 OK\\\\r\\\\nContent-Length: %d\\\\r\\\\n\\\\r\\\\n%s\\\" % (len(message), message))\",\n \"def PostInputs(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def render_POST(self, request):\\n log.msg(\\\"Paypal callback:\\\")\\n log.msg(request.args)\\n\\n d = self.verify(request)\\n d.addCallback(lambda ign: self._process(request.args))\\n d.addErrback(log.err)\\n return ''\",\n \"def handler(self):\\r\\n\\t\\tif (self.state != self.INIT):\\r\\n\\t\\t\\tself.sendRtspRequest(self.TEARDOWN)\\r\\n\\t\\t\\treply = self.recvRtspReply()\\r\\n\\t\\t\\t\\r\\n\\t\\t\\treplyEle = self.parseRtspReply(reply)\\r\\n\\t\\t\\ttotalSendPacketCount = int(replyEle[3][1])\\r\\n\\r\\n\\t\\t\\tif (reply.split('\\\\n')[0] == \\\"RTSP/1.0 200 OK\\\"):\\r\\n\\t\\t\\t\\tself.networkStat.computeLoss(totalSendPacketCount, self.networkStat.receivedPacketCount)\\r\\n\\t\\t\\t\\tself.networkStat.computeADR()\\r\\n\\t\\t\\t\\tself.networkStat.exportLogFile(self.sessionId, self.rtspSeq)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tif os.path.exists(self.cacheFile):\\r\\n\\t\\t\\t\\tos.remove(self.cacheFile)\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tself.rtpSocket_client.close()\\r\\n\\t\\t\\tself.rtspSocket_client.close()\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tNone\\r\\n\\t\\tself.master.destroy()\\r\\n\\t\\tsys.exit()\",\n \"def do_post(self, *args):\\n raise NotImplementedError()\",\n \"def post(self) -> WerkzeugResponse:\\n\\n _dict = self.unpack_post()\\n return self.perform_logout(_dict, BINDING_HTTP_POST)\",\n \"def communicate_to_server(url, postdata, prefix):\\n try:\\n f = urllib2.urlopen(url, postdata)\\n except urllib2.URLError as url_e:\\n error(prefix, \\\"can't communicate to server (%s)\\\" % url_e.reason)\\n msg = f.read()\\n f.close()\\n return msg\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7406314","0.67461973","0.64566195","0.63029206","0.6072018","0.6066601","0.6046328","0.5997497","0.59290093","0.58769035","0.58373576","0.57971627","0.573956","0.57225776","0.5698153","0.5666174","0.563702","0.56157655","0.5584676","0.55648243","0.5531771","0.55178905","0.55112934","0.55077416","0.5483814","0.5475518","0.5475518","0.54642576","0.54522586","0.5391004","0.5371632","0.5366631","0.5356074","0.53501916","0.5333915","0.5302751","0.52866787","0.5267091","0.52559817","0.52518046","0.5225157","0.5210243","0.5209915","0.52086496","0.51883125","0.5183544","0.51740015","0.5169344","0.5165466","0.5152902","0.51465595","0.5138813","0.5133628","0.5133039","0.5122633","0.5122183","0.51206","0.511853","0.5091088","0.50717956","0.50711864","0.5066973","0.50655454","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50433767","0.50361174","0.5019715","0.50183743","0.49957776","0.49879682","0.49872747","0.49800935","0.4979986","0.49763694","0.4968329","0.49505043","0.49467158","0.49465472","0.4938591","0.49197835","0.4896437","0.4894658","0.4889678","0.4889614","0.48865166","0.48862815","0.48819914","0.4878222"],"string":"[\n \"0.7406314\",\n \"0.67461973\",\n \"0.64566195\",\n \"0.63029206\",\n \"0.6072018\",\n \"0.6066601\",\n \"0.6046328\",\n \"0.5997497\",\n \"0.59290093\",\n \"0.58769035\",\n \"0.58373576\",\n \"0.57971627\",\n \"0.573956\",\n \"0.57225776\",\n \"0.5698153\",\n \"0.5666174\",\n \"0.563702\",\n \"0.56157655\",\n \"0.5584676\",\n \"0.55648243\",\n \"0.5531771\",\n \"0.55178905\",\n \"0.55112934\",\n \"0.55077416\",\n \"0.5483814\",\n \"0.5475518\",\n \"0.5475518\",\n \"0.54642576\",\n \"0.54522586\",\n \"0.5391004\",\n \"0.5371632\",\n \"0.5366631\",\n \"0.5356074\",\n \"0.53501916\",\n \"0.5333915\",\n \"0.5302751\",\n \"0.52866787\",\n \"0.5267091\",\n \"0.52559817\",\n \"0.52518046\",\n \"0.5225157\",\n \"0.5210243\",\n \"0.5209915\",\n \"0.52086496\",\n \"0.51883125\",\n \"0.5183544\",\n \"0.51740015\",\n \"0.5169344\",\n \"0.5165466\",\n \"0.5152902\",\n \"0.51465595\",\n \"0.5138813\",\n \"0.5133628\",\n \"0.5133039\",\n \"0.5122633\",\n \"0.5122183\",\n \"0.51206\",\n \"0.511853\",\n \"0.5091088\",\n \"0.50717956\",\n \"0.50711864\",\n \"0.5066973\",\n \"0.50655454\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50433767\",\n \"0.50361174\",\n \"0.5019715\",\n \"0.50183743\",\n \"0.49957776\",\n \"0.49879682\",\n \"0.49872747\",\n \"0.49800935\",\n \"0.4979986\",\n \"0.49763694\",\n \"0.4968329\",\n \"0.49505043\",\n \"0.49467158\",\n \"0.49465472\",\n \"0.4938591\",\n \"0.49197835\",\n \"0.4896437\",\n \"0.4894658\",\n \"0.4889678\",\n \"0.4889614\",\n \"0.48865166\",\n \"0.48862815\",\n \"0.48819914\",\n \"0.4878222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72129786"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":93098,"cells":{"query":{"kind":"string","value":"Return object data in easily serializeable format"},"document":{"kind":"string","value":"def serialize(self):\n return {\n 'id' : self.id,\n 'name': self.name,\n 'address1' : self.address1,\n 'address2': self.address2,\n 'phone' : self.phone,\n 'lat': self.lat,\n 'lng' : self.lng,\n 'cost': self.cost,\n 'menu_type' : self.menu_type,\n 'rate': self.rate,\n 'imgurl': self.image_url,\n 'imgname': self.image_filename,\n 'offer' : self.offer,\n 'has_delivery': self.has_delivery,\n 'has_bar':self.has_bar,\n 'has_cards': self.has_cards,\n 'has_terrace': self.has_terrace,\n 'has_wifi': self.has_wifi,\n 'has_parking': self.has_parking,\n 'has_reservation': self.has_reservation\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 serialize(self, obj):\n return obj","def GetDataAsObject(self):","def serialize(self, obj):\n pass","def serialize(self, data):\n return data","def SerializeObject(self, data):\n\n if isinstance(data,dict):\n serializad_data = json.dumps(data)\n else:\n serializad_data = json.dumps(data.__dict__)\n\n return serializad_data","def serialize(self):","def serialize(self, data):","def serialize(obj):\n return serialization_manager.serialize(obj)","def _serialise(self):\n # TODO (M Foley)\n pass","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'date' : str(self.date),\n 'owner_id' : self.owner_id,\n }","def serialize(self):\n pass","def serialize_forstorage(cls, obj):\n return misc.serialize_forstorage(obj)","def data(self):\n retval = copy.deepcopy(self.__dict__)\n retval[\"_Serializable_classname\"] = type(self).__name__\n retval[\"_Serializable_version\"] = \"1.0\"\n return retval","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'owner' : self.user.name,\n 'room' : self.room.name,\n 'description' : self.description,\n 'price' : self.price,\n }","def serialize(self):\n return {\n\n\n }","def serialize(self, obj):\n return json.dumps(obj)","def to_data(self):\n return self.data","def serialize(self, obj, for_read=False):\n\n serializer = self.get_serializer()\n return serializer.serialize(obj.to_python(for_read=for_read))","def serialize(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n \"detail\": self.detail,\n \"date_on\": self.date_on,\n }","def get_data(self):\n return self.data.to_json()","def serialize(self, data):\r\n if data is None:\r\n return None\r\n elif type(data) is dict:\r\n return serializer.Serializer(\r\n self.get_attr_metadata()).serialize(data, self.content_type())\r\n else:\r\n raise Exception(_(\"Unable to serialize object of type = '%s'\") %\r\n type(data))","def serialize(self, data):\n raise NotImplementedError","def serialize(self, data, format='application/json'):\r\n return self.serializer.serialize(data, format=format)","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'date_time' : str(self.date_time),\n 'duration' : self.duration,\n 'highlights' : self.highlights,\n 'conference_id' : self.conference_id,\n 'type_of_session_id' : self.type_of_session_id,\n 'speaker_id' : self.speaker_id,\n 'location_id' : self.location_id,\n 'documents' : self.documents \n }","def serialize(self):\n return {\n 'name' :self.name,\n 'points' :self.pts,\n 'id' :self.id,\n 'league_id':self.league_id,\n 'userID':self.user_id\n }","def serialize(self):\n return {\n 'name' : self.name,\n 'description' : self.description,\n 'id' : self.id,\n 'picture' : self.picture,\n 'catalog_id' : self.catalog_id,\n 'user_id' : self.user_id,\n 'last_edit' : self.time_str,\n }","def serialize(self):\n return {\n 'lapyname': self.lapyname,\n 'speciality': self.speciality,\n 'ram': self.ram,\n 'storage': self.storage,\n 'warrenty': self.warrenty,\n 'price': self.price,\n 'rating': self.rating,\n 'date': self.date,\n 'id': self. id\n }","def serialize(obj):\n return pickle.dumps(obj)","def serialize(self):\n return {\n 'id' : self.id,\n 'description': self.description,\n 'longitude' : self.longitude,\n 'latitude' : self.latitude,\n 'created_on' : self.created_on,\n 'created_by' : self.created_by,\n 'likes' : self.likes\n }","def serialize(self):\n\t\treturn { 'type': self.type, 'parameters' : self.parameters}","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'userID': self.userID,\n }","def serialize(self):\n return{\n 'name':self.name,\n 'id' :self.id,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'price': self.price,\n }","def serialized_data(self):\n return {\n 'id': self.id,\n 'start_time': str(self.start_time),\n 'venue_id': self.venue_id,\n 'venue_name': self.venue.name,\n 'venue_image_link': self.venue.image_link,\n 'artist_id': self.artist_id,\n 'artist_name': self.artist.name,\n 'artist_image_link': self.artist.image_link\n }","def dumps(self, data):\n return dumps(data)","def toJSON(self):\n raise NotImplementedError()","def serialize(obj):\n\n # if isinstance(obj, date):\n # serial = obj.isoformat()\n # return serial\n #\n # if isinstance(obj, time):\n # serial = obj.isoformat()\n # return serial\n\n return obj.to_json()","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'description' : self.description,\n 'is_private' : self.is_private,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'id': self.id,\n 'price': self.price,\n }","def serialize(self) -> typing.Any:\n return self._serialize(self.__dict__)","def serialize(self):\n\t\treturn {\n\t\t\t\"id\": self.id,\n\t\t\t\"name\": self.name\n\t\t}","def serialize(self):\n\t\treturn {\n\t\t\t\"id\": self.id,\n\t\t\t\"name\": self.name\n\t\t}","def data(self):\n return self.__dict__","def serialize(self):\n return {\n 'name': self.name,\n 'year_of_birth': self.year_of_birth,\n 'location': self.location,\n 'telephone': self.telephone,\n 'primary_publisher': self.primary_publisher,\n }","def dump(self):\n return json.dumps(self.__data)","def serialize(self):\n return {\n 'name' : self.name,\n 'id' : self.id,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'phone' : self.phone,\n 'email' : self.email,\n 'address' : self.address,\n 'picture' : self.picture,\n }","def serialize(self, obj):\n return dill.dumps(obj, 0).decode('latin-1')","def serialize(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n \"currency\": self.currency,\n \"old_price\": self.old_price,\n \"price\": self.price,\n \"availability\": self.availability,\n \"url\": self.url,\n \"img_url\": self.img_url\n }","def serialize(self):\n return {\n 'name' : self.name,\n 'id' : self.id,\n 'user_id' : self.user_id,\n 'last_edit' : self.time_str, \n }","def serialize(self):\n return {\n 'id' : self.id,\n 'created' : self.created.isoformat(),\n 'newCar' : self.newCar,\n 'type' : self.type,\n 'make' : self.make,\n 'model' : self.model,\n 'trim' : self.trim,\n 'year' : self.year,\n 'mileage' : self.mileage,\n 'price' : self.price,\n 'description' : self.description,\n 'dealer_id' : self.dealer_id,\n }","def dump(self):\n return {\"data\": self.data, \"encoding\": self.encoding,\n \"type\": self.type_name}","def data(self):\n if self._data is None:\n if self.many:\n self._data = [self.to_native(item) for item in self.object]\n else:\n self._data = self.to_native(self.object)\n return self._data","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'description': self.description,\n 'date_added': self.date_added,\n }","def dumps(self):\n return dumps(self)","def serialize(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n }","def serialize(self):\n return{\n # 'date': self.date,\n 'date': self.date,\n 'id': self.id,\n }","def serialize(self):\n data = {}\n\n for k, v in self.__dict__.items():\n if not k.startswith('__'):\n data[k] = v\n\n return data","def pack(self, obj):\n # TODO: use a JSON encoder that handles more types?\n if obj is not None:\n return json.dumps(obj)","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'id': self.id,\n 'price': self.price,\n 'catch_phrase': self.catch_phrase,\n }","def to_representation(self, data): # lint-amnesty, pylint: disable=arguments-differ\n return str(data)","def to_representation(self, data): # lint-amnesty, pylint: disable=arguments-differ\n return str(data)","def serialize(self):\n\t\treturn {\n\t\t\t'id': self.id,\n\t\t\t'title': self.title,\n\t\t\t'year': self.year,\n\t\t\t'artist': self.artist_id,\n\t\t\t'user': self.user_id\n\t\t}","def serialize(self):\r\n return (self.name, self.values)","def serialize(self):\n return {\n \"grade\": self.grade,\n \"student\": {\n \"id\": self.student_id,\n \"fname\": self.student.fname,\n \"lname\": self.student.lname,\n \"dob\": self.student.dob,\n \"grad_year\": self.student.grad_year,\n \"gpa\": self.student.gpa,\n \"occupation\": self.student.occupation.serialize\n },\n \"course\": {\n \"id\": self.course_id,\n \"course_name\": self.course.course_name,\n \"field\": self.course.field.serialize,\n \"faculty\": self.course.faculty.serialize,\n \"semester\": self.course.semester.serialize\n }\n }","def to_json_string(self) -> None:\n return json.dumps(dataclasses.asdict(self)) + \"\\n\"","def serialize(self):\n return{\n 'name': self.name,\n 'id': self.id,\n }","def __marshallable__(self):\n return dict(self.__dict__)['_data']","def serialized_data(self):\n return {\n 'id': self.id,\n 'city': self.name,\n 'state': self.state_name\n }","def toJSON(self) -> str:\r\n try:\r\n _ = json.dumps(self.value)\r\n value = self.value\r\n except (TypeError, OverflowError):\r\n value = {}\r\n value['object_type'] = self.value.__class__.__name__\r\n if isinstance(self.value, RawData):\r\n type_str = '_{}__'.format(value['object_type'])\r\n for key, data in self.value.__dict__.items():\r\n value[key.replace(type_str, '')] = data\r\n else:\r\n type_str = '_{}'.format(value['object_type'])\r\n for key, data in self.value.__dict__.items():\r\n value[key.replace(type_str, '')] = data\r\n\r\n return json.dumps({'object_type' : 'RawData', 'version' : self.version,\r\n 'timestamp' : self.timestamp, 'label' : self.label,\r\n 'value' : value})","def serialize(self):\n return {\n 'uuid': self.uuid,\n 'image': self.image,\n 'name': self.name,\n 'description': self.description,\n 'price': self.price,\n 'available': self.available,\n 'type_': self.type_.serialize,\n 'salesman': self.get_user,\n 'game': self.game,\n 'server': self.server,\n \"created_at\": self.created_at,\n \"updated_at\": self.updated_at\n }","def serialize(self):\n\n\t\treturn str(self)","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'owner' : self.user.name,\n }","def json_serial(obj):\n if isinstance(obj, LegipyModel):\n return obj.to_json()\n elif isinstance(obj, (datetime.date, datetime.datetime)):\n return obj.isoformat()\n raise TypeError(\"Type {0} not serializable\".format(repr(type(obj))))","def serialize(self):\n return {\n 'name' :self.name,\n 'position':self.position,\n 'id' :self.id,\n 'team_id':self.team_id,\n 'league_id':self.league_id,\n }","def serialize(self):\n\t\treturn {\n\t\t\t'id': self.id,\n\t\t\t'name': self.name,\n\t\t\t'user': self.user_id\n\t\t}","def serialize(self):\n\t\treturn {\n\t\t\t'name' : self.name,\n\t\t\t'id' : self.id,\n\t\t\t'description' : self.description,\n\t\t\t'kind_of_thing' : self.kind_of_thing,\n\t\t}","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n 'price': self.price,\n 'course': self.course,\n 'restaurant_id': self.restaurant_id\n }","def serialize(obj):\n\n if isinstance(obj, datetime.datetime):\n serial = obj.replace(microsecond=0).replace(tzinfo=None).isoformat() + \"Z\"\n return serial\n\n if isinstance(obj, bytes):\n return obj.decode('utf-8')\n\n return obj.__dict__","def serialize(obj):\n\n if isinstance(obj, datetime.datetime):\n serial = obj.replace(microsecond=0).replace(tzinfo=None).isoformat() + \"Z\"\n return serial\n\n if isinstance(obj, bytes):\n return obj.decode('utf-8')\n\n return obj.__dict__","def serialize(self):\n return {\n 'oid' : self.oid,\n 'title' : self.title,\n 'pickupaddr' : self.pickupaddr,\n 'pickuptime' : self.pickuptime.strftime(DATETIME_FORMAT) if self.pickuptime else '',\n 'did' : self.did,\n 'totalcargosize' : self.totalcargosize,\n 'trucksize' : self.trucksize,\n 'initialfee' : self.initialfee,\n 'perstopfee' : self.perstopfee,\n 'status' : self.status,\n 'drivername' : self.drivername,\n 'driverphone' : self.driverphone,\n 'deliverdate' : self.deliverdate.strftime(DATETIME_FORMAT) if self.deliverdate else '',\n 'finishedtime' : self.finishedtime.strftime(DATETIME_FORMAT) if self.finishedtime else '',\n 'pickupaddr_lat': self.pickupaddr_lat,\n 'pickupaddr_lng': self.pickupaddr_lng,\n 'participants': self.participants\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'latitude': self.latitude,\n 'longitude': self.longitude\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\r\n return json.dumps({\r\n 'display_name': self.display_name,\r\n 'data': self.data,\r\n 'metadata': self.metadata,\r\n 'graderType': self.grader_type,\r\n 'publish': self.publish\r\n })","def serialize(self):\n return self.record","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'id': self.id,\n }","def get_data(self, **context):\n # Note: This is *EXTREMELY* naive; in reality, you'll need\n # to do much more complex handling to ensure that arbitrary\n # objects -- such as Django model instances or querysets\n # -- can be serialized as JSON.\n return context","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'description': self.description,\n }","def to_json_string(self):\n\t\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \"\\n\"","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name\n }","def to_string(self):\n return json.dumps(self.to_json(), cls=ObjectEncoder)","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'address': self.address,\n 'tel': self.tel\n }","def json_serial(obj):\r\n\r\n\t\tif isinstance(obj,(datetime, date)):\r\n\t\t\treturn obj.isoformat()\r\n\t\traise TypeError (\"Type %s not serializable\" % type(obj))"],"string":"[\n \"def serialize(self, obj):\\n return obj\",\n \"def GetDataAsObject(self):\",\n \"def serialize(self, obj):\\n pass\",\n \"def serialize(self, data):\\n return data\",\n \"def SerializeObject(self, data):\\n\\n if isinstance(data,dict):\\n serializad_data = json.dumps(data)\\n else:\\n serializad_data = json.dumps(data.__dict__)\\n\\n return serializad_data\",\n \"def serialize(self):\",\n \"def serialize(self, data):\",\n \"def serialize(obj):\\n return serialization_manager.serialize(obj)\",\n \"def _serialise(self):\\n # TODO (M Foley)\\n pass\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'date' : str(self.date),\\n 'owner_id' : self.owner_id,\\n }\",\n \"def serialize(self):\\n pass\",\n \"def serialize_forstorage(cls, obj):\\n return misc.serialize_forstorage(obj)\",\n \"def data(self):\\n retval = copy.deepcopy(self.__dict__)\\n retval[\\\"_Serializable_classname\\\"] = type(self).__name__\\n retval[\\\"_Serializable_version\\\"] = \\\"1.0\\\"\\n return retval\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'owner' : self.user.name,\\n 'room' : self.room.name,\\n 'description' : self.description,\\n 'price' : self.price,\\n }\",\n \"def serialize(self):\\n return {\\n\\n\\n }\",\n \"def serialize(self, obj):\\n return json.dumps(obj)\",\n \"def to_data(self):\\n return self.data\",\n \"def serialize(self, obj, for_read=False):\\n\\n serializer = self.get_serializer()\\n return serializer.serialize(obj.to_python(for_read=for_read))\",\n \"def serialize(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n \\\"detail\\\": self.detail,\\n \\\"date_on\\\": self.date_on,\\n }\",\n \"def get_data(self):\\n return self.data.to_json()\",\n \"def serialize(self, data):\\r\\n if data is None:\\r\\n return None\\r\\n elif type(data) is dict:\\r\\n return serializer.Serializer(\\r\\n self.get_attr_metadata()).serialize(data, self.content_type())\\r\\n else:\\r\\n raise Exception(_(\\\"Unable to serialize object of type = '%s'\\\") %\\r\\n type(data))\",\n \"def serialize(self, data):\\n raise NotImplementedError\",\n \"def serialize(self, data, format='application/json'):\\r\\n return self.serializer.serialize(data, format=format)\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'date_time' : str(self.date_time),\\n 'duration' : self.duration,\\n 'highlights' : self.highlights,\\n 'conference_id' : self.conference_id,\\n 'type_of_session_id' : self.type_of_session_id,\\n 'speaker_id' : self.speaker_id,\\n 'location_id' : self.location_id,\\n 'documents' : self.documents \\n }\",\n \"def serialize(self):\\n return {\\n 'name' :self.name,\\n 'points' :self.pts,\\n 'id' :self.id,\\n 'league_id':self.league_id,\\n 'userID':self.user_id\\n }\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'description' : self.description,\\n 'id' : self.id,\\n 'picture' : self.picture,\\n 'catalog_id' : self.catalog_id,\\n 'user_id' : self.user_id,\\n 'last_edit' : self.time_str,\\n }\",\n \"def serialize(self):\\n return {\\n 'lapyname': self.lapyname,\\n 'speciality': self.speciality,\\n 'ram': self.ram,\\n 'storage': self.storage,\\n 'warrenty': self.warrenty,\\n 'price': self.price,\\n 'rating': self.rating,\\n 'date': self.date,\\n 'id': self. id\\n }\",\n \"def serialize(obj):\\n return pickle.dumps(obj)\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'description': self.description,\\n 'longitude' : self.longitude,\\n 'latitude' : self.latitude,\\n 'created_on' : self.created_on,\\n 'created_by' : self.created_by,\\n 'likes' : self.likes\\n }\",\n \"def serialize(self):\\n\\t\\treturn { 'type': self.type, 'parameters' : self.parameters}\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'userID': self.userID,\\n }\",\n \"def serialize(self):\\n return{\\n 'name':self.name,\\n 'id' :self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'price': self.price,\\n }\",\n \"def serialized_data(self):\\n return {\\n 'id': self.id,\\n 'start_time': str(self.start_time),\\n 'venue_id': self.venue_id,\\n 'venue_name': self.venue.name,\\n 'venue_image_link': self.venue.image_link,\\n 'artist_id': self.artist_id,\\n 'artist_name': self.artist.name,\\n 'artist_image_link': self.artist.image_link\\n }\",\n \"def dumps(self, data):\\n return dumps(data)\",\n \"def toJSON(self):\\n raise NotImplementedError()\",\n \"def serialize(obj):\\n\\n # if isinstance(obj, date):\\n # serial = obj.isoformat()\\n # return serial\\n #\\n # if isinstance(obj, time):\\n # serial = obj.isoformat()\\n # return serial\\n\\n return obj.to_json()\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'description' : self.description,\\n 'is_private' : self.is_private,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'id': self.id,\\n 'price': self.price,\\n }\",\n \"def serialize(self) -> typing.Any:\\n return self._serialize(self.__dict__)\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t\\\"id\\\": self.id,\\n\\t\\t\\t\\\"name\\\": self.name\\n\\t\\t}\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t\\\"id\\\": self.id,\\n\\t\\t\\t\\\"name\\\": self.name\\n\\t\\t}\",\n \"def data(self):\\n return self.__dict__\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'year_of_birth': self.year_of_birth,\\n 'location': self.location,\\n 'telephone': self.telephone,\\n 'primary_publisher': self.primary_publisher,\\n }\",\n \"def dump(self):\\n return json.dumps(self.__data)\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'id' : self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'phone' : self.phone,\\n 'email' : self.email,\\n 'address' : self.address,\\n 'picture' : self.picture,\\n }\",\n \"def serialize(self, obj):\\n return dill.dumps(obj, 0).decode('latin-1')\",\n \"def serialize(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n \\\"currency\\\": self.currency,\\n \\\"old_price\\\": self.old_price,\\n \\\"price\\\": self.price,\\n \\\"availability\\\": self.availability,\\n \\\"url\\\": self.url,\\n \\\"img_url\\\": self.img_url\\n }\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'id' : self.id,\\n 'user_id' : self.user_id,\\n 'last_edit' : self.time_str, \\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'created' : self.created.isoformat(),\\n 'newCar' : self.newCar,\\n 'type' : self.type,\\n 'make' : self.make,\\n 'model' : self.model,\\n 'trim' : self.trim,\\n 'year' : self.year,\\n 'mileage' : self.mileage,\\n 'price' : self.price,\\n 'description' : self.description,\\n 'dealer_id' : self.dealer_id,\\n }\",\n \"def dump(self):\\n return {\\\"data\\\": self.data, \\\"encoding\\\": self.encoding,\\n \\\"type\\\": self.type_name}\",\n \"def data(self):\\n if self._data is None:\\n if self.many:\\n self._data = [self.to_native(item) for item in self.object]\\n else:\\n self._data = self.to_native(self.object)\\n return self._data\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'description': self.description,\\n 'date_added': self.date_added,\\n }\",\n \"def dumps(self):\\n return dumps(self)\",\n \"def serialize(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n }\",\n \"def serialize(self):\\n return{\\n # 'date': self.date,\\n 'date': self.date,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n data = {}\\n\\n for k, v in self.__dict__.items():\\n if not k.startswith('__'):\\n data[k] = v\\n\\n return data\",\n \"def pack(self, obj):\\n # TODO: use a JSON encoder that handles more types?\\n if obj is not None:\\n return json.dumps(obj)\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'id': self.id,\\n 'price': self.price,\\n 'catch_phrase': self.catch_phrase,\\n }\",\n \"def to_representation(self, data): # lint-amnesty, pylint: disable=arguments-differ\\n return str(data)\",\n \"def to_representation(self, data): # lint-amnesty, pylint: disable=arguments-differ\\n return str(data)\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'id': self.id,\\n\\t\\t\\t'title': self.title,\\n\\t\\t\\t'year': self.year,\\n\\t\\t\\t'artist': self.artist_id,\\n\\t\\t\\t'user': self.user_id\\n\\t\\t}\",\n \"def serialize(self):\\r\\n return (self.name, self.values)\",\n \"def serialize(self):\\n return {\\n \\\"grade\\\": self.grade,\\n \\\"student\\\": {\\n \\\"id\\\": self.student_id,\\n \\\"fname\\\": self.student.fname,\\n \\\"lname\\\": self.student.lname,\\n \\\"dob\\\": self.student.dob,\\n \\\"grad_year\\\": self.student.grad_year,\\n \\\"gpa\\\": self.student.gpa,\\n \\\"occupation\\\": self.student.occupation.serialize\\n },\\n \\\"course\\\": {\\n \\\"id\\\": self.course_id,\\n \\\"course_name\\\": self.course.course_name,\\n \\\"field\\\": self.course.field.serialize,\\n \\\"faculty\\\": self.course.faculty.serialize,\\n \\\"semester\\\": self.course.semester.serialize\\n }\\n }\",\n \"def to_json_string(self) -> None:\\n return json.dumps(dataclasses.asdict(self)) + \\\"\\\\n\\\"\",\n \"def serialize(self):\\n return{\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def __marshallable__(self):\\n return dict(self.__dict__)['_data']\",\n \"def serialized_data(self):\\n return {\\n 'id': self.id,\\n 'city': self.name,\\n 'state': self.state_name\\n }\",\n \"def toJSON(self) -> str:\\r\\n try:\\r\\n _ = json.dumps(self.value)\\r\\n value = self.value\\r\\n except (TypeError, OverflowError):\\r\\n value = {}\\r\\n value['object_type'] = self.value.__class__.__name__\\r\\n if isinstance(self.value, RawData):\\r\\n type_str = '_{}__'.format(value['object_type'])\\r\\n for key, data in self.value.__dict__.items():\\r\\n value[key.replace(type_str, '')] = data\\r\\n else:\\r\\n type_str = '_{}'.format(value['object_type'])\\r\\n for key, data in self.value.__dict__.items():\\r\\n value[key.replace(type_str, '')] = data\\r\\n\\r\\n return json.dumps({'object_type' : 'RawData', 'version' : self.version,\\r\\n 'timestamp' : self.timestamp, 'label' : self.label,\\r\\n 'value' : value})\",\n \"def serialize(self):\\n return {\\n 'uuid': self.uuid,\\n 'image': self.image,\\n 'name': self.name,\\n 'description': self.description,\\n 'price': self.price,\\n 'available': self.available,\\n 'type_': self.type_.serialize,\\n 'salesman': self.get_user,\\n 'game': self.game,\\n 'server': self.server,\\n \\\"created_at\\\": self.created_at,\\n \\\"updated_at\\\": self.updated_at\\n }\",\n \"def serialize(self):\\n\\n\\t\\treturn str(self)\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'owner' : self.user.name,\\n }\",\n \"def json_serial(obj):\\n if isinstance(obj, LegipyModel):\\n return obj.to_json()\\n elif isinstance(obj, (datetime.date, datetime.datetime)):\\n return obj.isoformat()\\n raise TypeError(\\\"Type {0} not serializable\\\".format(repr(type(obj))))\",\n \"def serialize(self):\\n return {\\n 'name' :self.name,\\n 'position':self.position,\\n 'id' :self.id,\\n 'team_id':self.team_id,\\n 'league_id':self.league_id,\\n }\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'id': self.id,\\n\\t\\t\\t'name': self.name,\\n\\t\\t\\t'user': self.user_id\\n\\t\\t}\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'name' : self.name,\\n\\t\\t\\t'id' : self.id,\\n\\t\\t\\t'description' : self.description,\\n\\t\\t\\t'kind_of_thing' : self.kind_of_thing,\\n\\t\\t}\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n 'price': self.price,\\n 'course': self.course,\\n 'restaurant_id': self.restaurant_id\\n }\",\n \"def serialize(obj):\\n\\n if isinstance(obj, datetime.datetime):\\n serial = obj.replace(microsecond=0).replace(tzinfo=None).isoformat() + \\\"Z\\\"\\n return serial\\n\\n if isinstance(obj, bytes):\\n return obj.decode('utf-8')\\n\\n return obj.__dict__\",\n \"def serialize(obj):\\n\\n if isinstance(obj, datetime.datetime):\\n serial = obj.replace(microsecond=0).replace(tzinfo=None).isoformat() + \\\"Z\\\"\\n return serial\\n\\n if isinstance(obj, bytes):\\n return obj.decode('utf-8')\\n\\n return obj.__dict__\",\n \"def serialize(self):\\n return {\\n 'oid' : self.oid,\\n 'title' : self.title,\\n 'pickupaddr' : self.pickupaddr,\\n 'pickuptime' : self.pickuptime.strftime(DATETIME_FORMAT) if self.pickuptime else '',\\n 'did' : self.did,\\n 'totalcargosize' : self.totalcargosize,\\n 'trucksize' : self.trucksize,\\n 'initialfee' : self.initialfee,\\n 'perstopfee' : self.perstopfee,\\n 'status' : self.status,\\n 'drivername' : self.drivername,\\n 'driverphone' : self.driverphone,\\n 'deliverdate' : self.deliverdate.strftime(DATETIME_FORMAT) if self.deliverdate else '',\\n 'finishedtime' : self.finishedtime.strftime(DATETIME_FORMAT) if self.finishedtime else '',\\n 'pickupaddr_lat': self.pickupaddr_lat,\\n 'pickupaddr_lng': self.pickupaddr_lng,\\n 'participants': self.participants\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'latitude': self.latitude,\\n 'longitude': self.longitude\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\r\\n return json.dumps({\\r\\n 'display_name': self.display_name,\\r\\n 'data': self.data,\\r\\n 'metadata': self.metadata,\\r\\n 'graderType': self.grader_type,\\r\\n 'publish': self.publish\\r\\n })\",\n \"def serialize(self):\\n return self.record\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'id': self.id,\\n }\",\n \"def get_data(self, **context):\\n # Note: This is *EXTREMELY* naive; in reality, you'll need\\n # to do much more complex handling to ensure that arbitrary\\n # objects -- such as Django model instances or querysets\\n # -- can be serialized as JSON.\\n return context\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'description': self.description,\\n }\",\n \"def to_json_string(self):\\n\\t\\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name\\n }\",\n \"def to_string(self):\\n return json.dumps(self.to_json(), cls=ObjectEncoder)\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'address': self.address,\\n 'tel': self.tel\\n }\",\n \"def json_serial(obj):\\r\\n\\r\\n\\t\\tif isinstance(obj,(datetime, date)):\\r\\n\\t\\t\\treturn obj.isoformat()\\r\\n\\t\\traise TypeError (\\\"Type %s not serializable\\\" % type(obj))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.777154","0.7626386","0.7566185","0.7525398","0.74336725","0.7321529","0.7315361","0.7281728","0.7163479","0.7155347","0.7148642","0.7124317","0.7099167","0.70400804","0.70074207","0.6971844","0.6960608","0.6955735","0.6948549","0.69371045","0.69215906","0.6904719","0.6894361","0.6892801","0.6885364","0.6884662","0.6882248","0.68677026","0.68663764","0.68601173","0.68462056","0.68420213","0.6836476","0.6836476","0.6824409","0.6805304","0.6803351","0.68019974","0.6798591","0.6797797","0.6791108","0.67891395","0.67842597","0.67842597","0.6769639","0.6768915","0.6761451","0.6747949","0.67459536","0.6739507","0.6738927","0.6734372","0.6728447","0.67239696","0.6723241","0.6701543","0.6698341","0.668867","0.66877466","0.66870683","0.66790104","0.6678815","0.6678716","0.6678716","0.6668779","0.6660429","0.66525406","0.66473454","0.66410494","0.663914","0.6638119","0.6633034","0.66318154","0.6631165","0.6631057","0.6630644","0.6626509","0.66224736","0.66197145","0.66132355","0.6608844","0.6608844","0.6604335","0.6597765","0.6597765","0.6597765","0.6595677","0.65946966","0.65946966","0.65946966","0.6592818","0.6588092","0.65863025","0.6583545","0.65815365","0.6580507","0.6580195","0.65763754","0.65754956","0.6572844"],"string":"[\n \"0.777154\",\n \"0.7626386\",\n \"0.7566185\",\n \"0.7525398\",\n \"0.74336725\",\n \"0.7321529\",\n \"0.7315361\",\n \"0.7281728\",\n \"0.7163479\",\n \"0.7155347\",\n \"0.7148642\",\n \"0.7124317\",\n \"0.7099167\",\n \"0.70400804\",\n \"0.70074207\",\n \"0.6971844\",\n \"0.6960608\",\n \"0.6955735\",\n \"0.6948549\",\n \"0.69371045\",\n \"0.69215906\",\n \"0.6904719\",\n \"0.6894361\",\n \"0.6892801\",\n \"0.6885364\",\n \"0.6884662\",\n \"0.6882248\",\n \"0.68677026\",\n \"0.68663764\",\n \"0.68601173\",\n \"0.68462056\",\n \"0.68420213\",\n \"0.6836476\",\n \"0.6836476\",\n \"0.6824409\",\n \"0.6805304\",\n \"0.6803351\",\n \"0.68019974\",\n \"0.6798591\",\n \"0.6797797\",\n \"0.6791108\",\n \"0.67891395\",\n \"0.67842597\",\n \"0.67842597\",\n \"0.6769639\",\n \"0.6768915\",\n \"0.6761451\",\n \"0.6747949\",\n \"0.67459536\",\n \"0.6739507\",\n \"0.6738927\",\n \"0.6734372\",\n \"0.6728447\",\n \"0.67239696\",\n \"0.6723241\",\n \"0.6701543\",\n \"0.6698341\",\n \"0.668867\",\n \"0.66877466\",\n \"0.66870683\",\n \"0.66790104\",\n \"0.6678815\",\n \"0.6678716\",\n \"0.6678716\",\n \"0.6668779\",\n \"0.6660429\",\n \"0.66525406\",\n \"0.66473454\",\n \"0.66410494\",\n \"0.663914\",\n \"0.6638119\",\n \"0.6633034\",\n \"0.66318154\",\n \"0.6631165\",\n \"0.6631057\",\n \"0.6630644\",\n \"0.6626509\",\n \"0.66224736\",\n \"0.66197145\",\n \"0.66132355\",\n \"0.6608844\",\n \"0.6608844\",\n \"0.6604335\",\n \"0.6597765\",\n \"0.6597765\",\n \"0.6597765\",\n \"0.6595677\",\n \"0.65946966\",\n \"0.65946966\",\n \"0.65946966\",\n \"0.6592818\",\n \"0.6588092\",\n \"0.65863025\",\n \"0.6583545\",\n \"0.65815365\",\n \"0.6580507\",\n \"0.6580195\",\n \"0.65763754\",\n \"0.65754956\",\n \"0.6572844\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67694086"},"document_rank":{"kind":"string","value":"45"}}},{"rowIdx":93099,"cells":{"query":{"kind":"string","value":"u {l1} and r {l} new should be of equal sizes to be concatenated"},"document":{"kind":"string","value":"def __init__(self,\r\n in_channels_r, out_channels_r, in_channels_u, out_channels,\r\n kernel_size_in, kernel_size_out,\r\n up_stride_in, stride_out,\r\n up_padding_in, padding_out, output_padding=0,\r\n activation_in='lrelu', activation_out='lrelu',\r\n norm_in='bn', norm_out='none'):\r\n super(RecovecyBlock, self).__init__()\r\n\r\n self.in_upconv = upconv_block(\r\n in_channels=in_channels_r,\r\n out_channels=out_channels_r,\r\n kernel_size=kernel_size_in,\r\n stride=up_stride_in,\r\n padding=up_padding_in,\r\n output_padding=output_padding,\r\n norm=norm_in,\r\n activation=activation_in\r\n )\r\n\r\n self.out_conv = conv_block(\r\n in_channels=out_channels_r + in_channels_u,\r\n out_channels=out_channels,\r\n kernel_size=kernel_size_out,\r\n stride=stride_out,\r\n padding=padding_out,\r\n norm=norm_out,\r\n activation=activation_out\r\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 concatenate_data():","def rejoin(l0,l1=None):\r\n while len(l0) != 0:\r\n if l1 is None:\r\n l1 = []\r\n if l0[0] == '<':\r\n if len(l0) >= 3:\r\n if l0[2] == '>':\r\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\r\n else:\r\n l1 += [l0.pop(0)]\r\n return l1","def assemble_row(r1, r2):\n r1.extend(r2)\n return r1","def pattern2(l, r) :\n if (len(r) == 0) :\n return (l, r)\n \n le = len(l) - 1\n if (len(l[le]) > 0) and starts(l[le][0]) and (not starts(r) ) :\n l[le].append(r) \n return (l,\"\")\n return (l,r)","def add_vectors(v, u):\n return (v[0] + u[0], v[1] + u[1])","def make_same_length(l1, l2):\n ln = max(len(l1), len(l2))\n l1.extend([None] * (ln - len(l1)))\n l2.extend([None] * (ln - len(l2)))","def brcadd(*args):\n\n #Find the list use a mask list.\n bargs=[isinstance(i,list) for i in args]\n\n #If all the elements are strings, just connect them.\n if not any(bargs):\n return ''.join(args)\n\n #Collect the lengths of the lists and check.\n lists=[len(args[i]) for i in range(len(args)) if bargs[i]]\n\n# assert(all_equal(lists))\n if (not all_equal(lists)):\n raise ValueError('All args must have the same length!')\n\n length=lists[0]\n\n #Expand strings to list with the same strings such that all the lists have\n #the same length.\n lis_args=[args[i] if bargs[i] else [args[i]]*length for i in range(len(args))]\n\n #Join the strings of the same positions and get the result.\n res=[''.join([item[i] for item in lis_args]) for i in range(length)]\n\n return res","def pattern3(l, r) :\n if (len(r) == 0) :\n return (l, r)\n\n le = len(l) - 1\n if (len(l[le]) > 1) and starts(l[le][0]) and starts(r) :\n l.append([r]) \n return (l,\"\")\n return (l,r)","def brcadd(*args):\n \n #Find the list use a mask list.\n bargs=[isinstance(i,list) for i in args]\n \n #If all the elements are strings, just connect them.\n if not any(bargs):\n return ''.join(args)\n \n #Collect the lengths of the lists and check.\n lists=[len(args[i]) for i in range(len(args)) if bargs[i]]\n assert(all_same(lists))\n length=lists[0]\n \n #Expand strings to list with the same strings such that all the lists have\n #the same length.\n lis_args=[args[i] if bargs[i] else [args[i]]*length for i in range(len(args))]\n \n #Join the strings of the same positions and get the result.\n res=[''.join([item[i] for item in lis_args]) for i in range(length)]\n \n return res","def test_merge_list_same(short_ll, small_ll):\n assert ml(short_ll, small_ll) == 8\n assert len(small_ll) == 8","def concretize(self, lw: torch.Tensor, uw: torch.Tensor):\n if self.args.attack_type == \"synonym\":\n # lw: (input/output len, output dim, len * input dim)\n # lw = lw.transpose(0, 1) # (output dim, input/output len, len * input dim)\n # uw = uw.transpose(0, 1) # (output dim, input/output len, len * input dim)\n\n dim = lw.size(2) // self.perturbed_words\n concretized_l = torch.zeros(lw.size(0), lw.size(1), device=lw.device)\n concretized_u = torch.zeros(uw.size(0), uw.size(1), device=uw.device)\n for i in range(self.perturbed_words):\n concretized_l -= torch.norm(lw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\n concretized_u += torch.norm(uw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\n\n return concretized_l, concretized_u\n elif self.perturbed_words == 2:\n assert (len(lw.shape) == 3), \"Lw does not have 3 dimensions! It has %d dimensions\" % len(lw.shape)\n half = lw.shape[-1] // 2\n concretized_l = self.concretize_l(lw[:, :, :half]) + self.concretize_l(lw[:, :, half:])\n concretized_u = self.concretize_u(uw[:, :, :half]) + self.concretize_u(uw[:, :, half:])\n return concretized_l, concretized_u\n elif self.perturbed_words == 1:\n return self.concretize_l(lw), self.concretize_u(uw)\n else:\n raise NotImplementedError","def pattern1(l, r) :\n if (len(r) == 0) :\n return (l, r)\n \n le = len(l) - 1\n if (len(l[le]) == 1) and starts(l[le][0]) and starts(r) :\n l[le].append(True) \n l.append([r])\n return (l,\"\")\n return (l,r)","def __radd__(self, left_arr):\n concat_arr = left_arr.copy() # Create new instance to return\n concat_arr.extend(self)\n return concat_arr","def merge(l, r):\n print(\"merge [l={}, r={}]\".format(l, r))\n t = [None] * (len(l) + len(r))\n ti = 0\n \n i, j = 0, 0\n\n while i < len(l) and j < len(r):\n if l[i] <= r[j]:\n t[ti] = l[i]\n i += 1\n else:\n t[ti] = r[j]\n j += 1\n ti += 1\n\n # copy remaining items from one of either l or r...\n if i < len(l):\n while i < len(l):\n t[ti] = l[i]\n i += 1\n ti += 1\n else:\n while j < len(r):\n t[ti] = r[j]\n j+= 1\n ti += 1\n\n return t","def concatMatrix(self, a, l, cols):\n l_i = l * np.identity(cols)\n concat = np.concatenate((a, l_i))\n\n return concat","def l_up(self, filters, l_in, l_c):\n l = tf.keras.layers.UpSampling2D(self.pooling_size)(l_in)\n l = tf.keras.layers.Conv2D(filters, 2, activation='relu', padding='same', kernel_initializer='he_normal')(l)\n l = tf.keras.layers.concatenate([l_c, l], axis=3)\n l = tf.keras.layers.Conv2D(filters, 3, activation='relu', padding='same', kernel_initializer='he_normal')(l)\n l = tf.keras.layers.Conv2D(filters, 3, activation='relu', padding='same', kernel_initializer='he_normal')(l)\n\n return l","def test_merge_list_two(long_ll, short_ll):\n assert ml(long_ll, short_ll) == 16\n assert len(long_ll) == 10","def concat(a, b):\n return torch.cat((a, b), 1)","def concatv(*seqs):\n return concat(seqs)","def test_merge_list(short_ll, long_ll):\n assert ml(short_ll, long_ll) == 8\n assert len(long_ll) == 10","def _union(\n lows: np.array, ups: np.array, new_lows: np.array, new_ups: np.array\n) -> Union[np.array, np.array]:\n out_lows = []\n out_ups = []\n\n for i in range(0, lows.shape[1]):\n low, up = _union_one_dim( # pylint:disable=invalid-name\n lows[:, i], ups[:, i], new_lows[:, i], new_ups[:, i]\n )\n out_lows.append(low.reshape(-1, 1))\n out_ups.append(up.reshape(-1, 1))\n\n out_lows_array, out_ups_array = np.hstack(out_lows), np.hstack(out_ups)\n\n return out_lows_array, out_ups_array","def new(self, u, k1, k2, k3, k4):\n\n v = self.combine(k1, k2, k3, k4)\n\n return u + (self._delta_t / 6.0) * v","def joint_dataset(l1, l2):\n N = np.max(l1) + 1\n return l2 * N + l1","def merge_two(l, r):\n new = []\n i1, i2 = 0, 0\n while i1 != len(l) and i2 != len(r):\n if l[i1] < r[i2]:\n new.append(l[i1])\n i1 += 1\n else:\n new.append(r[i2])\n i2 += 1\n\n new.extend(l[i1:])\n new.extend(r[i2:])\n return new","def add_uniform(x,y,n_u):\n n = x.shape[0]\n print(x.shape)\n print(y.shape)\n d = x.shape[1]\n new_shape = (n_u+n,d)\n resx = np.zeros(new_shape, dtype = np.float32)\n #x_norm = normalisation_l_inf(x)\n _,_,x_norm = normalisation_l2(x)\n resx[:n] = x_norm\n resx[n:] = normalisation_l2(np.random.uniform(low = 0, high = 1.0,size = (n_u,d)))[2]\n resy = np.zeros((n_u+n,y.shape[1]+1))\n resy[:n,0:y.shape[1]] = y\n resy[n:,y.shape[1]] = 1\n print(\"added uniform\")\n print(\"new shape\"+ str(resx.shape))\n return(resx,resy)","def mergeLumis(inputdata, lumimask):\n mergedlumis = LumiList()\n doublelumis = LumiList()\n for report in inputdata:\n doublelumis = mergedlumis & LumiList(runsAndLumis=report)\n mergedlumis = mergedlumis | LumiList(runsAndLumis=report)\n return mergedlumis.getCompactList(), (LumiList(compactList=lumimask) - mergedlumis).getCompactList(), doublelumis.getCompactList()","def join(\n self, store: \"FlattenedStorage\", lsuffix: str = \"\", rsuffix: str = \"\"\n ) -> \"FlattenedStorage\":\n if len(self) != len(store):\n raise ValueError(\n \"FlattenedStorages to be joined have to be of the same length!\"\n )\n if (self[\"length\"] != store[\"length\"]).any():\n raise ValueError(\n \"FlattenedStorages to be joined have to have same length chunks everywhere!\"\n )\n if lsuffix == rsuffix != \"\":\n raise ValueError(\"lsuffix and rsuffix may not be equal!\")\n rename = lsuffix != \"\" or rsuffix != \"\"\n if not rename:\n shared_elements = set(self._per_element_arrays).intersection(\n store._per_element_arrays\n )\n shared_chunks = set(self._per_chunk_arrays).intersection(\n store._per_chunk_arrays\n )\n shared_chunks.remove(\"start_index\")\n shared_chunks.remove(\"length\")\n shared_chunks.remove(\"identifier\")\n if len(shared_elements) > 0 or len(shared_chunks) > 0:\n raise ValueError(\n \"FlattenedStorages to be joined may have common arrays only if lsuffix or rsuffix are given!\"\n )\n\n for k, a in store._per_element_arrays.items():\n if k in self._per_element_arrays and rename:\n self._per_element_arrays[k + lsuffix] = self._per_element_arrays[k]\n k += rsuffix\n self._per_element_arrays[k] = a\n\n for k, a in store._per_chunk_arrays.items():\n if k not in (\"start_index\", \"length\", \"identifier\"):\n if k in self._per_chunk_arrays and rename:\n self._per_chunk_arrays[k + lsuffix] = self._per_chunk_arrays[k]\n k += rsuffix\n self._per_chunk_arrays[k] = a\n\n self._resize_elements(self._num_elements_alloc)\n self._resize_chunks(self._num_chunks_alloc)\n return self","def _gu_linear(self, h, r):\n mu1h = torch.matmul(self.mu1.weight, h.T) # [k, b]\n mu2r = torch.matmul(self.mu2.weight, r.T) # [k, b]\n return (mu1h + mu2r + self.bu.weight).T # [b, k]","def laceStrings(s1, s2):\n # Your Code Here\n minLen = min(len(s1), len(s2))\n s3 = \"\".join(y for x in zip(s1, s2) for y in x) + s1[minLen:] + s2[minLen:]\n return s3","def merge(l, s1, l1, s2, l2):\n nonlocal c, r, w\n\n # Create temporary list to store sorted value\n tempList = l.copy() \n\n # Compare pairs of values of two list, start from the first element\n i = s1 # Beginning of the left list\n j = s2 # Beginning of the right list\n k = 0\n\n # Compare and add to temporary list\n c += 2\n while i <= l1 and j <= l2: \n c += 3\n r += 2 \n w += 1 \n if l[i] < l[j]:\n tempList[k] = l[i]\n i = i + 1\n k = k + 1 \n else:\n tempList[k] = l[j]\n j = j + 1\n k = k + 1\n\n # Copy remaining elements of the first list\n c += 1\n while i <= l1:\n tempList[k] = l[i]\n i = i + 1\n k = k + 1\n c += 1\n r += 1\n w += 1\n\n # Copy remaining elements of the second list \n c += 1\n while j <= l2:\n tempList[k] = l[j]\n j = j + 1\n k = k + 1\n c += 1\n r += 1\n w += 1\n\n # Copy elements from tempList to list l\n i = s1\n j = 0 \n c += 1\n while i <= l2:\n l[i] = tempList[j]\n i = i + 1\n j = j + 1\n c += 1\n w += 1 \n r += 1","def combineData(self, dataLOLA, dataLOLB):\r\n map(lambda x: x[0].append(x[1][1]), zip(dataLOLA, dataLOLB))\r\n return dataLOLA","def lcombine( v1, v2, k1, k2 ):\n return [ x*k1 + y*k2 for (x,y) in izip(v1,v2) ]","def add_vectors(u, v): #11.22.5\r\n new_vector = []\r\n \"\"\"Because they have same length so we\r\n should take advantage from this one\"\"\"\r\n for i in range(len(u)):\r\n m = u[i] + v[i] # Get their value of i index at the same time!\r\n new_vector.append(m)\r\n return new_vector","def concatena(*args):\n linea = ''\n for l in args:\n linea += str(l if l else '')\n return linea","def test_merge_list_same_values(short_ll, small_ll):\n ml(short_ll, small_ll)\n assert small_ll.head.val == 8\n assert small_ll.head._next.val == 4\n assert small_ll.head._next._next._next._next._next._next._next.val == 1","def test_merge_list_values(short_ll, long_ll):\n ml(short_ll, long_ll)\n assert long_ll.head.val == 8\n assert long_ll.head._next.val == 16","def prepare_r_uls_r_lus(\n number_of_levels,\n number_of_shells,\n j_blues,\n excitation_species,\n nlte_data,\n ):\n # number_of_levels = atomic_data_levels.energy.loc[\n # excitation_species\n # ].count() do this in the solver\n lnl = nlte_data.lines_level_number_lower[excitation_species]\n lnu = nlte_data.lines_level_number_upper[excitation_species]\n (lines_index,) = nlte_data.lines_idx[excitation_species]\n\n try:\n j_blues_filtered = j_blues.iloc[lines_index]\n except AttributeError:\n j_blues_filtered = j_blues\n A_uls = nlte_data.A_uls[excitation_species]\n B_uls = nlte_data.B_uls[excitation_species]\n B_lus = nlte_data.B_lus[excitation_species]\n r_lu_index = lnu * number_of_levels + lnl\n r_ul_index = lnl * number_of_levels + lnu\n r_ul_matrix = np.zeros(\n (number_of_levels, number_of_levels, number_of_shells),\n dtype=np.float64,\n )\n r_ul_matrix_reshaped = r_ul_matrix.reshape(\n (number_of_levels**2, number_of_shells)\n )\n r_ul_matrix_reshaped[r_ul_index] = (\n A_uls[np.newaxis].T + B_uls[np.newaxis].T * j_blues_filtered\n )\n r_lu_matrix = np.zeros_like(r_ul_matrix)\n r_lu_matrix_reshaped = r_lu_matrix.reshape(\n (number_of_levels**2, number_of_shells)\n )\n r_lu_matrix_reshaped[r_lu_index] = (\n B_lus[np.newaxis].T * j_blues_filtered\n )\n return (\n lines_index,\n r_ul_index,\n r_ul_matrix,\n r_lu_index,\n r_lu_matrix,\n )\n # TODO: beta sobolev needs to be recalculated for each iteration, because it depends on number density","def combine(a, b):\n assert len(a) == len(b)\n out = \"\"\n for i in range(len(a)):\n out += a[i]\n out += b[i]\n return out","def mergeWith(self, others):","def _union_one_dim(\n lows: Sequence, ups: Sequence, new_lows: Sequence, new_ups: Sequence\n) -> Tuple[np.array, np.array]:\n out_lows = []\n out_ups = []\n\n for i, low in enumerate(lows):\n # In one dimension we can imagine the following cases where there\n # is zero intersection\n # 1) |--old range--| |--new range--|,\n # i.e., lower new limit above old upper limit\n # 2) |--new range--| |--old range--|,\n # i.e., upper new limit below lower old limit\n if (new_lows[i] >= ups[i]) or (new_ups[i] <= low):\n out_lows.append(new_lows[i])\n out_ups.append(new_ups[i])\n\n # In other cases, we want to intersect the ranges, i.e.\n # |---old range-|-|--new-range--| --> |-|\n # i.e. we take the max of the lower limits and the min of the upper limits\n else:\n out_lows.append(max(low, new_lows[i]))\n out_ups.append(min(ups[i], new_ups[i]))\n\n return np.array(out_lows), np.array(out_ups)","def _rconcat(self, other: Any) -> ColumnOperators:\n return self.reverse_operate(concat_op, other)","def add_eggs(eggs, l):\n\n return '\\n'.join(uniq(eggs + l))","def padding(old, l):\n new = deepcopy(old)\n for i, j in enumerate(new):\n new[i] += [0] * (l - len(j))\n new[i] = j[:l]\n return new","def __listunion(self, c1, c2):\n s1 = {}\n for delta in c1:\n s1[delta] = 1\n\n\tc = c1[:]\n\tfor delta in c2:\n if not s1.has_key(delta):\n\t\tc.append(delta)\n\n\treturn c","def concat_same(context, number):\n buffer = context\n for i in range(0, number - 1):\n buffer = np.concatenate((buffer, context), axis=0) \n return buffer","def __add__(self, right_arr):\n concat_arr = self.copy() # Create new instance to return\n concat_arr.extend(right_arr)\n return concat_arr","def assemble_col(c1, c2):\n c1.extend(c2)\n return c1","def concat_strings(l_strings):\n if l_strings == []:\n return \"\"\n else: \n return l_strings[0] + \" \" + concat_strings(l_strings[1:])","def clRelu(self, size):","def toeplitz_multiplication(u, c, r=None):\n n = len(u)\n if r is None:\n r = c\n u1 = zeros((2*n))\n u1[0:n] = u\n \n c = np.concatenate((c, [0], r[-1:0:-1])) \n \n y1 = circulant_multiplication(u1, c)\n \n return y1[0:n]","def _algorithm(self, rut):\n suma = 0\n multi = 2\n for r in rut[::-1]:\n suma += int(r) * multi\n multi += 1\n if multi == 8:\n multi = 2\n return u'0123456789K0'[11 - suma % 11]","def test_merge_list_two_values(long_ll, short_ll):\n ml(long_ll, short_ll)\n assert long_ll.head.val == 16\n assert long_ll.head._next.val == 8","def _extend(cls, li1, li2):\n return li1 + li2","def test_merge_list_empty(short_ll, empty_ll):\n assert ml(short_ll, empty_ll) == 8\n assert len(short_ll) == 4","def __iadd__(self, other):\n\n if not isinstance(other, Ulog):\n raise UlogError('Ulog.__iadd__: can' +\n ' only add another Ulog to an Ulog.')\n\n nccd = set(self.utc.keys())\n if set(other.utc.keys()) != nccd:\n raise UlogError('Ulog.__iadd__: CCD numbers of inputs do not match')\n\n for nc in nccd:\n if len(self.x[nc]) != len(other.x[nc]):\n raise UlogError('Ulog.__iadd__: incompatible' +\n ' aperture numbers for CCD ' + nc)\n\n # OK, tests passed, add new arrays onto the end of the old ones\n for nc in nccd:\n\n self.utc[nc] = np.concatenate((self.utc[nc], other.utc[nc]))\n self.tflag[nc] = np.concatenate((self.tflag[nc], other.tflag[nc]))\n self.expose[nc] = np.concatenate((self.expose[nc],other.expose[nc]))\n self.fwhm[nc] = np.concatenate((self.fwhm[nc],other.fwhm[nc]))\n self.beta[nc] = np.concatenate((self.beta[nc],other.beta[nc]))\n\n for nap in range(len(self.x[nc])):\n self.x[nc][nap] = np.concatenate(\n (self.x[nc][nap],other.x[nc][nap]))\n self.y[nc][nap] = np.concatenate(\n (self.y[nc][nap],other.y[nc][nap]))\n self.xm[nc][nap] = np.concatenate(\n (self.xm[nc][nap],other.xm[nc][nap]))\n self.ym[nc][nap] = np.concatenate(\n (self.ym[nc][nap],other.ym[nc][nap]))\n self.exm[nc][nap] = np.concatenate(\n (self.exm[nc][nap],other.exm[nc][nap]))\n self.eym[nc][nap] = np.concatenate(\n (self.eym[nc][nap],other.eym[nc][nap]))\n self.counts[nc][nap] = np.concatenate(\n (self.counts[nc][nap],other.counts[nc][nap]))\n self.sigma[nc][nap] = np.concatenate(\n (self.sigma[nc][nap],other.sigma[nc][nap]))\n self.sky[nc][nap] = np.concatenate(\n (self.sky[nc][nap],other.sky[nc][nap]))\n self.nsky[nc][nap] = np.concatenate(\n (self.nsky[nc][nap],other.nsky[nc][nap]))\n self.nrej[nc][nap] = np.concatenate(\n (self.nrej[nc][nap],other.nrej[nc][nap]))\n self.worst[nc][nap] = np.concatenate(\n (self.worst[nc][nap],other.worst[nc][nap]))\n self.eflag[nc][nap] = np.concatenate(\n (self.eflag[nc][nap],other.eflag[nc][nap]))\n return self","def shorten_ends(s1, s2, s1_ang, s1_crd, s1_raw_seq, s1_ismodified):\n aligner = init_aligner(allow_target_gaps=True)\n a = aligner.align(s1, s2)\n mask = get_padded_second_seq_from_alignment(a[0])\n i = len(mask) - 1\n while mask[i] == \"-\":\n s1 = s1[:-1]\n s1_ang = s1_ang[:-1]\n s1_crd = s1_crd[:-NUM_COORDS_PER_RES]\n s1_raw_seq = s1_raw_seq[:-1]\n s1_ismodified = s1_ismodified[:-1]\n mask = mask[:-1]\n i -= 1\n while mask[0] == \"-\":\n s1 = s1[1:]\n s1_ang = s1_ang[1:]\n s1_crd = s1_crd[NUM_COORDS_PER_RES:]\n s1_raw_seq = s1_raw_seq[1:]\n s1_ismodified = s1_ismodified[1:]\n mask = mask[1:]\n return s1, s1_ang, s1_crd, s1_raw_seq, s1_ismodified","def add_lists(a,b):\r\n\r\n for i in range(len(a)):\r\n a[i] += b[i]\r\n return a","def regular_collate_fn(data):\n\timg, box, q, a = list(zip(*data))\n\tq = torch.nn.utils.rnn.pad_sequence(q, batch_first=True)\n\treturn torch.stack(img), torch.stack(box), q, torch.stack(a).long()","def newPassword(a, b):\n if len(a) > len(b):\n return combine(a[:len(b)], b) + a[len(b):]\n elif len(a) < len(b):\n return combine(a, b[:len(a)]) + b[len(a):]\n else:\n return combine(a, b)","def __add__(self,l):\r\n\t\t\r\n\t\t# add\r\n\t\ta = self.add(l)\r\n\t\t\r\n\t\treturn a","def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n nums1[:]=sorted((nums1[:m]+nums2[:n]))","def __iadd__(self,l):\r\n\t\t\r\n\t\treturn self.add(l)","def concat(V, s):\n\n X = []\n for k in range(s):\n x = []\n for j in V:\n x.append(j[k])\n X.append(vertcat(*x))\n return X","def merge_roidb(roidbs):\n roidb = roidbs[0]\n for r in roidbs[1:]:\n roidb.extend(r)\n return roidb","def merge_roidb(roidbs):\n roidb = roidbs[0]\n for r in roidbs[1:]:\n roidb.extend(r)\n return roidb","def merge(ul, ur, bl, br, isOdd):\n\n # Adjust the indicies of the boards for when they're merged together.\n # upper left board has no offset\n bl = adjust_offset((len(ul), 0), bl)\n ur = adjust_offset((0, len(ul[0])), ur)\n br = adjust_offset((len(ul), len(ul[0])), br)\n\n if isOdd:\n # Upper Left\n ul_edge, ul_row_e, ul_col_e = replace_corner(offset=(0, 0),\n dimensions=(len(ul), len(ul[0])),\n constant=_ULedge)\n ul_corn, ul_row_c, ul_col_c = replace_corner(offset=(0, 0),\n dimensions=(len(ul), len(ul[0])),\n constant=_ULcorn)\n # Upper Right\n ur_edge, ur_row_e, ur_col_e = replace_corner(offset=(0, len(ul[0])),\n dimensions=(len(ur), len(ur[0])),\n constant=_URedge)\n ur_corn, ur_row_c, ur_col_c = replace_corner(offset=(0, len(ul[0])),\n dimensions=(len(ur), len(ur[0])),\n constant=_URcorn)\n # Bottom Left\n bl_edge, bl_row_e, bl_col_e = replace_corner(offset=(len(ul), 0),\n dimensions=(len(bl), len(bl[0])),\n constant=_BLedge)\n bl_corn, bl_row_c, bl_col_c = replace_corner(offset=(len(ul), 0),\n dimensions=(len(bl), len(bl[0])),\n constant=_BLcorn)\n # Bottom Right\n br_edge, br_row_e, br_col_e = replace_corner(offset=(len(ur), len(bl[0])),\n dimensions=(len(ur), len(ur[0])),\n constant=_BRedge)\n br_corn, br_row_c, br_col_c = replace_corner(offset=(len(ur), len(bl[0])),\n dimensions=(len(ur), len(ur[0])),\n constant=_BRcorn)\n else:\n # UL\n ul_edge, ul_r, ul_c = replace_corner(offset=(0, 0),\n dimensions=(len(ul),len(ul[0])),\n constant=_sA)\n # UR\n ur_edge, ur_r, ur_c = replace_corner(offset=(0, len(ul[0])),\n dimensions=(len(ur),len(ur[0])),\n constant=_sB)\n # BL\n bl_edge, bl_r, bl_c = replace_corner(offset=(len(ul), 0),\n dimensions=(len(bl),len(bl[0])),\n constant=_sD)\n # BR\n br_edge, br_r, br_c = replace_corner(offset=(len(ur), len(bl[0])),\n dimensions=(len(br),len(br[0])),\n constant=_sC)\n\n\n # Join the boards together\n board = []\n # top half\n for row in range(len(ul)):\n board.append(ul[row]+ur[row])\n # bottom half\n for row in range(len(bl)):\n board.append(bl[row]+br[row])\n\n # Do the actual edge replacement to join the quadrants together\n if isOdd:\n board[ul_row_e][ul_col_e] = ul_edge\n board[ur_row_c][ur_col_c] = ur_corn\n board[bl_row_e][bl_col_e] = bl_edge\n board[ul_row_c][ul_col_c] = ul_corn\n board[br_row_e][br_col_e] = br_edge\n board[bl_row_c][bl_col_c] = bl_corn\n board[ur_row_e][ur_col_e] = ur_edge\n board[br_row_c][br_col_c] = br_corn\n else:\n board[ul_r][ul_c] = ul_edge\n board[ur_r][ur_c] = ur_edge\n board[br_r][br_c] = br_edge\n board[bl_r][bl_c] = bl_edge\n\n return board","def merge_up(lsts):\r\n lsts1 = transpose(lsts)\r\n lsts2 = merge_AllLeft(lsts1)\r\n lsts3 = shift(lsts2)\r\n lsts4 = transpose(lsts3)\r\n lsts = lsts4\r\n\r\n return lsts","def merge(a, b):\r\n # your code here\r\n \r\n m = []\r\n i, j = 0, 0\r\n \r\n while i < len(a) and j < len(b):\r\n if a[i] < b[j]:\r\n m.append(a[i])\r\n i += 1\r\n else:\r\n m.append(b[j])\r\n j += 1\r\n \r\n m += a[i:] + b[j:]\r\n \r\n return m","def merge(self, nums1, m, nums2, n):\n\t\tnum1_pointer = 0\n\t\tif len(nums2) ==0:\n\t\t\treturn\n\t\tt = nums2.pop(0)\n\t\tboundry = m\n\t\twhile nums2:\n\t\t\t# print(nums2)\n\t\t\tif num1_pointer == boundry:\n\t\t\t\tbreak\n\t\t\tif nums1[num1_pointer] < t:\n\t\t\t\tnum1_pointer += 1\n\t\t\telse:\n\t\t\t\ttemp = nums1[num1_pointer]\n\t\t\t\tnums1[num1_pointer:] = [0] + nums1[num1_pointer:-1]\n\t\t\t\tnums1[num1_pointer] = t\n\t\t\t\tt = nums2.pop(0)\n\t\t\t\tboundry += 1\n\t\t\t\tnum1_pointer += 1\n\t\tif nums2:\n\t\t\tnums1[num1_pointer:] = [t] + nums2\n\t\telse:\n\t\t\tprint(\"test\")\n\t\t\ttemp = nums1[num1_pointer]\n\t\t\tnums1[num1_pointer:] = [0] + nums1[num1_pointer:-1]\n\t\t\tnums1[num1_pointer] = t","def add4(a,b):\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],a[3]+b[3]]","def clevr_collate_fn(data):\n\tdata = sorted(data, key=lambda x: len(x[1]), reverse=True)\n\timg, q, len_q, a, f, idx = list(zip(*data))\n\tq = torch.nn.utils.rnn.pad_sequence(q, batch_first=True)\n\treturn torch.stack(img), q, list(len_q), torch.stack(a), list(f), list(idx)","def concatenate(arrays, **kwargs):\n unit = unit_of(arrays[0])\n result = np.concatenate([to_unitless(arr, unit) for arr in arrays], **kwargs)\n return result * unit","def join_vars(self, xs):\n return tf.concat(1, xs)","def laceStrings(s1, s2):\n # Your Code Here\n i = 0\n result = \"\"\n \n while i < len(s1) and i < len(s2):\n result += s1[i] + s2[i]\n i += 1\n \n result += s1[i:]\n result += s2[i:]\n \n return result","def _to_add_and_update(self):\n primitive_list=[]\n group_list=[]\n location_list = []\n #primitives\n for item in self.candidate_config:\n item_groupdef=group(item['name'], item['type'], item['ips'])\n if item['name'] in names(self.live_config):\n live_item=[x for x in self.live_config if x['name']==item['name']][0]\n added_ips=[x for x in item['ips'] if x not in live_item['ips']]\n primitive_list += ip_primitives(item['name'], added_ips)\n if item['type'] != live_item['type']:\n if item['type'] == 'ldirectord':\n primitive_list += ld_primitives(item['name'], item['loadbalancers'])\n if set(item_groupdef[0].split()) != set(group2(live_item)[0].split()):\n group_list += item_groupdef\n if item['loadbalancers'] != live_item['loadbalancers']:\n location_list += lborder(item['name'], item['loadbalancers'])\n else:\n primitive_list += primitives(item['name'], item['type'], item['ips'])\n group_list += item_groupdef\n location_list += lborder(item['name'], item['loadbalancers'])\n return '\\n'.join(primitive_list + group_list + location_list)","def concat(strokes):\n\n long_stroke = Stroke()\n for stroke in strokes:\n long_stroke.x += stroke.x\n long_stroke.y += stroke.y\n long_stroke.len += stroke.len\n return long_stroke","def data_unification(self, data1, data2):\r\n data = data1 + data2\r\n return data","def MergeLogic(self) -> str:","def addVectors(r1, r2):\n \"\"\" [0] = angle, [1] = lenght \"\"\"\n x = (math.sin(r1[0]) * r1[1]) + (math.sin(r2[0]) * r2[1])\n y = (math.cos(r1[0]) * r1[1]) + (math.cos(r2[0]) * r2[1])\n \n angle = 0.5 * math.pi - math.atan2(y, x)\n length = math.hypot(x, y)\n\n return (angle, length)","def joins((u,v,o)):\r\n return { W : ((u,v), (u-1,v)),\r\n S : ((u,v), (u,v-1)) }[o]","def concat(seq1, seq2):\n if type_tag(seq1) == type_tag(seq2):\n return seq1 + seq2\n else:\n types = (type_tag(seq1), type_tag(seq2))\n if types in concat.adders:\n return concat.adders[types](seq1, seq2)","def testRegisterConcatenation(self):\n reg_one = ShiftRegister(2)\n reg_one.shift(\"a\")\n reg_one.shift(\"b\")\n reg_two = ShiftRegister(3)\n reg_two.shift(\"c\")\n reg_two.shift(\"d\")\n reg_two.shift(\"e\")\n reg_cat = reg_one.concatenate(reg_two)\n self.assertEqual(''.join(reg_cat), \"abcde\")","def test_align_lst_shapes_equal():\n test_file = os.path.join(DATA_PATH, \"paper_test_file.uvh5\")\n test_uv = UVData()\n test_uv.read(test_file)\n\n test_uv_2 = copy.deepcopy(test_uv)\n ra_range = [0, 12]\n\n test_uv_out, test_uv_2_out = utils.lst_align(\n test_uv,\n test_uv_2,\n ra_range=ra_range,\n inplace=False,\n )\n\n assert test_uv_out.time_array.shape == test_uv_out.time_array.shape","def merge_ranges():","def __array_append(self, in_a,in_b):\n in_b = np.array([in_b]) if isinstance(in_b,(int,float,long,complex)) else in_b\n return np.concatenate((in_a,in_b))","def add_string(l, base):\n\n match_length = len(l) - 1\n left_end = base[:match_length]\n right_end = base[-match_length:]\n if l[1:] == left_end:\n return [l[0]] + base\n elif l[:-1] == right_end:\n return base + [l[-1]]\n else:\n raise AppendException","def concat(x: list[int], y: list[int]) -> list[int]:\n con = list()\n i: int = 0\n count: int = 0\n while len(y) > i: \n con.append(y[i])\n i += 1\n while len(x) > count: \n con.append(x[count])\n count += 1 \n return con","def __add__(self,other):\n if self.h != other.h or self.w != other.w:\n raise(ValueError, \"Matrices can only be added if the dimensions are the same\") \n # \n # TODO - your code here\n #\n result = [];\n for i in range(self.h):\n result.append([a+b for a,b in zip(self.g[i],other.g[i])]);\n \n return Matrix(result);","def bytearray_join(glue, list_of_barrays):\n res = list_of_barrays[0]\n for i in range(1,len(list_of_barrays)):\n res += glue + list_of_barrays[i]\n return res","def mergeNodes(new, t1, t2):\n \n if t1 and t2:\n new.val = t1.val + t2.val\n elif not t1:\n new.val = t2.val\n elif not t2:\n new.val = t1.val","def __add__(self, other):\n return self.concatenate(other)","def __add__(self, other):\n return self.concatenate(other)","def _umap_concat(data, **umap_kwargs):\n data_tiles = []\n for i in range(5):\n data_i = slice_vec_bands(data, start=i, end=i + 1)\n data_tiles.append(umap.UMAP(**umap_kwargs).fit_transform(data_i))\n\n data_concat = numpy.empty((\n data_tiles[0].shape[0],\n sum(dt.shape[1] for dt in data_tiles)\n ))\n\n start_col = 0\n for dt in data_tiles:\n end_col = start_col + dt.shape[1]\n data[:, start_col:end_col] = dt\n start_col = end_col\n\n return data_concat","def combinations( l1, l2 ):\n for i in range(len(l1)):\n yield zip( l1,l2)\n l1.insert(0,l1.pop())","def concat_all(self):\n return self.merge(1)","def recombine(self, s1, s2):\n PICK_OP_PROB = 0.9\n\n rep1, cpi1 = self.pick_random_rep(s1, PICK_OP_PROB)\n rep2, cpi2 = self.pick_random_rep(s2, PICK_OP_PROB)\n\n off1 = s1[:rep1] + s2[rep2:cpi2 + 1] + s1[cpi1 + 1:]\n off2 = s2[:rep2] + s1[rep1:cpi1 + 1] + s2[cpi2 + 1:]\n\n return off1, off2","def lform(self):\n a, c, d, b = self.to_ccw()\n if b < c:\n a += b\n b -= b\n c -= b\n d += b\n else:\n a += c\n b -= c\n c -= c\n d += c\n return self.__class__.from_ccw(a, c, d, b)","def laceStrings(s1, s2):\n s3= \"\"\n x=0\n \n while x < len(s1):\n s3 += s1[x]\n s3 += s2[x]\n x += 1\n if x >= len(s2):\n s3 += s1[len(s2):]\n return s3\n \n s3 += s2[len(s1):]\n return s3","def _batchify(self, data, align_right=False, include_lengths=False):\n lengths = [x.size(0) for x in data]\n max_length = max(lengths)\n out = data[0].new(len(data), max_length).fill_(neusum.Constants.PAD)\n for i in range(len(data)):\n data_length = data[i].size(0)\n offset = max_length - data_length if align_right else 0\n out[i].narrow(0, offset, data_length).copy_(data[i])\n\n if include_lengths:\n return out, lengths\n else:\n return out","def brepalgo_ConcatenateWire(*args):\n return _BRepAlgo.brepalgo_ConcatenateWire(*args)","def join (xl,xr,y=1):\n\n X = (xl,xr)\n Y = split(y)\n while not seq(X,Y):\n y *= 2\n if sle(Y,X): y += 1\n Y = split(y)\n return y"],"string":"[\n \"def concatenate_data():\",\n \"def rejoin(l0,l1=None):\\r\\n while len(l0) != 0:\\r\\n if l1 is None:\\r\\n l1 = []\\r\\n if l0[0] == '<':\\r\\n if len(l0) >= 3:\\r\\n if l0[2] == '>':\\r\\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\\r\\n else:\\r\\n l1 += [l0.pop(0)]\\r\\n return l1\",\n \"def assemble_row(r1, r2):\\n r1.extend(r2)\\n return r1\",\n \"def pattern2(l, r) :\\n if (len(r) == 0) :\\n return (l, r)\\n \\n le = len(l) - 1\\n if (len(l[le]) > 0) and starts(l[le][0]) and (not starts(r) ) :\\n l[le].append(r) \\n return (l,\\\"\\\")\\n return (l,r)\",\n \"def add_vectors(v, u):\\n return (v[0] + u[0], v[1] + u[1])\",\n \"def make_same_length(l1, l2):\\n ln = max(len(l1), len(l2))\\n l1.extend([None] * (ln - len(l1)))\\n l2.extend([None] * (ln - len(l2)))\",\n \"def brcadd(*args):\\n\\n #Find the list use a mask list.\\n bargs=[isinstance(i,list) for i in args]\\n\\n #If all the elements are strings, just connect them.\\n if not any(bargs):\\n return ''.join(args)\\n\\n #Collect the lengths of the lists and check.\\n lists=[len(args[i]) for i in range(len(args)) if bargs[i]]\\n\\n# assert(all_equal(lists))\\n if (not all_equal(lists)):\\n raise ValueError('All args must have the same length!')\\n\\n length=lists[0]\\n\\n #Expand strings to list with the same strings such that all the lists have\\n #the same length.\\n lis_args=[args[i] if bargs[i] else [args[i]]*length for i in range(len(args))]\\n\\n #Join the strings of the same positions and get the result.\\n res=[''.join([item[i] for item in lis_args]) for i in range(length)]\\n\\n return res\",\n \"def pattern3(l, r) :\\n if (len(r) == 0) :\\n return (l, r)\\n\\n le = len(l) - 1\\n if (len(l[le]) > 1) and starts(l[le][0]) and starts(r) :\\n l.append([r]) \\n return (l,\\\"\\\")\\n return (l,r)\",\n \"def brcadd(*args):\\n \\n #Find the list use a mask list.\\n bargs=[isinstance(i,list) for i in args]\\n \\n #If all the elements are strings, just connect them.\\n if not any(bargs):\\n return ''.join(args)\\n \\n #Collect the lengths of the lists and check.\\n lists=[len(args[i]) for i in range(len(args)) if bargs[i]]\\n assert(all_same(lists))\\n length=lists[0]\\n \\n #Expand strings to list with the same strings such that all the lists have\\n #the same length.\\n lis_args=[args[i] if bargs[i] else [args[i]]*length for i in range(len(args))]\\n \\n #Join the strings of the same positions and get the result.\\n res=[''.join([item[i] for item in lis_args]) for i in range(length)]\\n \\n return res\",\n \"def test_merge_list_same(short_ll, small_ll):\\n assert ml(short_ll, small_ll) == 8\\n assert len(small_ll) == 8\",\n \"def concretize(self, lw: torch.Tensor, uw: torch.Tensor):\\n if self.args.attack_type == \\\"synonym\\\":\\n # lw: (input/output len, output dim, len * input dim)\\n # lw = lw.transpose(0, 1) # (output dim, input/output len, len * input dim)\\n # uw = uw.transpose(0, 1) # (output dim, input/output len, len * input dim)\\n\\n dim = lw.size(2) // self.perturbed_words\\n concretized_l = torch.zeros(lw.size(0), lw.size(1), device=lw.device)\\n concretized_u = torch.zeros(uw.size(0), uw.size(1), device=uw.device)\\n for i in range(self.perturbed_words):\\n concretized_l -= torch.norm(lw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\\n concretized_u += torch.norm(uw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\\n\\n return concretized_l, concretized_u\\n elif self.perturbed_words == 2:\\n assert (len(lw.shape) == 3), \\\"Lw does not have 3 dimensions! It has %d dimensions\\\" % len(lw.shape)\\n half = lw.shape[-1] // 2\\n concretized_l = self.concretize_l(lw[:, :, :half]) + self.concretize_l(lw[:, :, half:])\\n concretized_u = self.concretize_u(uw[:, :, :half]) + self.concretize_u(uw[:, :, half:])\\n return concretized_l, concretized_u\\n elif self.perturbed_words == 1:\\n return self.concretize_l(lw), self.concretize_u(uw)\\n else:\\n raise NotImplementedError\",\n \"def pattern1(l, r) :\\n if (len(r) == 0) :\\n return (l, r)\\n \\n le = len(l) - 1\\n if (len(l[le]) == 1) and starts(l[le][0]) and starts(r) :\\n l[le].append(True) \\n l.append([r])\\n return (l,\\\"\\\")\\n return (l,r)\",\n \"def __radd__(self, left_arr):\\n concat_arr = left_arr.copy() # Create new instance to return\\n concat_arr.extend(self)\\n return concat_arr\",\n \"def merge(l, r):\\n print(\\\"merge [l={}, r={}]\\\".format(l, r))\\n t = [None] * (len(l) + len(r))\\n ti = 0\\n \\n i, j = 0, 0\\n\\n while i < len(l) and j < len(r):\\n if l[i] <= r[j]:\\n t[ti] = l[i]\\n i += 1\\n else:\\n t[ti] = r[j]\\n j += 1\\n ti += 1\\n\\n # copy remaining items from one of either l or r...\\n if i < len(l):\\n while i < len(l):\\n t[ti] = l[i]\\n i += 1\\n ti += 1\\n else:\\n while j < len(r):\\n t[ti] = r[j]\\n j+= 1\\n ti += 1\\n\\n return t\",\n \"def concatMatrix(self, a, l, cols):\\n l_i = l * np.identity(cols)\\n concat = np.concatenate((a, l_i))\\n\\n return concat\",\n \"def l_up(self, filters, l_in, l_c):\\n l = tf.keras.layers.UpSampling2D(self.pooling_size)(l_in)\\n l = tf.keras.layers.Conv2D(filters, 2, activation='relu', padding='same', kernel_initializer='he_normal')(l)\\n l = tf.keras.layers.concatenate([l_c, l], axis=3)\\n l = tf.keras.layers.Conv2D(filters, 3, activation='relu', padding='same', kernel_initializer='he_normal')(l)\\n l = tf.keras.layers.Conv2D(filters, 3, activation='relu', padding='same', kernel_initializer='he_normal')(l)\\n\\n return l\",\n \"def test_merge_list_two(long_ll, short_ll):\\n assert ml(long_ll, short_ll) == 16\\n assert len(long_ll) == 10\",\n \"def concat(a, b):\\n return torch.cat((a, b), 1)\",\n \"def concatv(*seqs):\\n return concat(seqs)\",\n \"def test_merge_list(short_ll, long_ll):\\n assert ml(short_ll, long_ll) == 8\\n assert len(long_ll) == 10\",\n \"def _union(\\n lows: np.array, ups: np.array, new_lows: np.array, new_ups: np.array\\n) -> Union[np.array, np.array]:\\n out_lows = []\\n out_ups = []\\n\\n for i in range(0, lows.shape[1]):\\n low, up = _union_one_dim( # pylint:disable=invalid-name\\n lows[:, i], ups[:, i], new_lows[:, i], new_ups[:, i]\\n )\\n out_lows.append(low.reshape(-1, 1))\\n out_ups.append(up.reshape(-1, 1))\\n\\n out_lows_array, out_ups_array = np.hstack(out_lows), np.hstack(out_ups)\\n\\n return out_lows_array, out_ups_array\",\n \"def new(self, u, k1, k2, k3, k4):\\n\\n v = self.combine(k1, k2, k3, k4)\\n\\n return u + (self._delta_t / 6.0) * v\",\n \"def joint_dataset(l1, l2):\\n N = np.max(l1) + 1\\n return l2 * N + l1\",\n \"def merge_two(l, r):\\n new = []\\n i1, i2 = 0, 0\\n while i1 != len(l) and i2 != len(r):\\n if l[i1] < r[i2]:\\n new.append(l[i1])\\n i1 += 1\\n else:\\n new.append(r[i2])\\n i2 += 1\\n\\n new.extend(l[i1:])\\n new.extend(r[i2:])\\n return new\",\n \"def add_uniform(x,y,n_u):\\n n = x.shape[0]\\n print(x.shape)\\n print(y.shape)\\n d = x.shape[1]\\n new_shape = (n_u+n,d)\\n resx = np.zeros(new_shape, dtype = np.float32)\\n #x_norm = normalisation_l_inf(x)\\n _,_,x_norm = normalisation_l2(x)\\n resx[:n] = x_norm\\n resx[n:] = normalisation_l2(np.random.uniform(low = 0, high = 1.0,size = (n_u,d)))[2]\\n resy = np.zeros((n_u+n,y.shape[1]+1))\\n resy[:n,0:y.shape[1]] = y\\n resy[n:,y.shape[1]] = 1\\n print(\\\"added uniform\\\")\\n print(\\\"new shape\\\"+ str(resx.shape))\\n return(resx,resy)\",\n \"def mergeLumis(inputdata, lumimask):\\n mergedlumis = LumiList()\\n doublelumis = LumiList()\\n for report in inputdata:\\n doublelumis = mergedlumis & LumiList(runsAndLumis=report)\\n mergedlumis = mergedlumis | LumiList(runsAndLumis=report)\\n return mergedlumis.getCompactList(), (LumiList(compactList=lumimask) - mergedlumis).getCompactList(), doublelumis.getCompactList()\",\n \"def join(\\n self, store: \\\"FlattenedStorage\\\", lsuffix: str = \\\"\\\", rsuffix: str = \\\"\\\"\\n ) -> \\\"FlattenedStorage\\\":\\n if len(self) != len(store):\\n raise ValueError(\\n \\\"FlattenedStorages to be joined have to be of the same length!\\\"\\n )\\n if (self[\\\"length\\\"] != store[\\\"length\\\"]).any():\\n raise ValueError(\\n \\\"FlattenedStorages to be joined have to have same length chunks everywhere!\\\"\\n )\\n if lsuffix == rsuffix != \\\"\\\":\\n raise ValueError(\\\"lsuffix and rsuffix may not be equal!\\\")\\n rename = lsuffix != \\\"\\\" or rsuffix != \\\"\\\"\\n if not rename:\\n shared_elements = set(self._per_element_arrays).intersection(\\n store._per_element_arrays\\n )\\n shared_chunks = set(self._per_chunk_arrays).intersection(\\n store._per_chunk_arrays\\n )\\n shared_chunks.remove(\\\"start_index\\\")\\n shared_chunks.remove(\\\"length\\\")\\n shared_chunks.remove(\\\"identifier\\\")\\n if len(shared_elements) > 0 or len(shared_chunks) > 0:\\n raise ValueError(\\n \\\"FlattenedStorages to be joined may have common arrays only if lsuffix or rsuffix are given!\\\"\\n )\\n\\n for k, a in store._per_element_arrays.items():\\n if k in self._per_element_arrays and rename:\\n self._per_element_arrays[k + lsuffix] = self._per_element_arrays[k]\\n k += rsuffix\\n self._per_element_arrays[k] = a\\n\\n for k, a in store._per_chunk_arrays.items():\\n if k not in (\\\"start_index\\\", \\\"length\\\", \\\"identifier\\\"):\\n if k in self._per_chunk_arrays and rename:\\n self._per_chunk_arrays[k + lsuffix] = self._per_chunk_arrays[k]\\n k += rsuffix\\n self._per_chunk_arrays[k] = a\\n\\n self._resize_elements(self._num_elements_alloc)\\n self._resize_chunks(self._num_chunks_alloc)\\n return self\",\n \"def _gu_linear(self, h, r):\\n mu1h = torch.matmul(self.mu1.weight, h.T) # [k, b]\\n mu2r = torch.matmul(self.mu2.weight, r.T) # [k, b]\\n return (mu1h + mu2r + self.bu.weight).T # [b, k]\",\n \"def laceStrings(s1, s2):\\n # Your Code Here\\n minLen = min(len(s1), len(s2))\\n s3 = \\\"\\\".join(y for x in zip(s1, s2) for y in x) + s1[minLen:] + s2[minLen:]\\n return s3\",\n \"def merge(l, s1, l1, s2, l2):\\n nonlocal c, r, w\\n\\n # Create temporary list to store sorted value\\n tempList = l.copy() \\n\\n # Compare pairs of values of two list, start from the first element\\n i = s1 # Beginning of the left list\\n j = s2 # Beginning of the right list\\n k = 0\\n\\n # Compare and add to temporary list\\n c += 2\\n while i <= l1 and j <= l2: \\n c += 3\\n r += 2 \\n w += 1 \\n if l[i] < l[j]:\\n tempList[k] = l[i]\\n i = i + 1\\n k = k + 1 \\n else:\\n tempList[k] = l[j]\\n j = j + 1\\n k = k + 1\\n\\n # Copy remaining elements of the first list\\n c += 1\\n while i <= l1:\\n tempList[k] = l[i]\\n i = i + 1\\n k = k + 1\\n c += 1\\n r += 1\\n w += 1\\n\\n # Copy remaining elements of the second list \\n c += 1\\n while j <= l2:\\n tempList[k] = l[j]\\n j = j + 1\\n k = k + 1\\n c += 1\\n r += 1\\n w += 1\\n\\n # Copy elements from tempList to list l\\n i = s1\\n j = 0 \\n c += 1\\n while i <= l2:\\n l[i] = tempList[j]\\n i = i + 1\\n j = j + 1\\n c += 1\\n w += 1 \\n r += 1\",\n \"def combineData(self, dataLOLA, dataLOLB):\\r\\n map(lambda x: x[0].append(x[1][1]), zip(dataLOLA, dataLOLB))\\r\\n return dataLOLA\",\n \"def lcombine( v1, v2, k1, k2 ):\\n return [ x*k1 + y*k2 for (x,y) in izip(v1,v2) ]\",\n \"def add_vectors(u, v): #11.22.5\\r\\n new_vector = []\\r\\n \\\"\\\"\\\"Because they have same length so we\\r\\n should take advantage from this one\\\"\\\"\\\"\\r\\n for i in range(len(u)):\\r\\n m = u[i] + v[i] # Get their value of i index at the same time!\\r\\n new_vector.append(m)\\r\\n return new_vector\",\n \"def concatena(*args):\\n linea = ''\\n for l in args:\\n linea += str(l if l else '')\\n return linea\",\n \"def test_merge_list_same_values(short_ll, small_ll):\\n ml(short_ll, small_ll)\\n assert small_ll.head.val == 8\\n assert small_ll.head._next.val == 4\\n assert small_ll.head._next._next._next._next._next._next._next.val == 1\",\n \"def test_merge_list_values(short_ll, long_ll):\\n ml(short_ll, long_ll)\\n assert long_ll.head.val == 8\\n assert long_ll.head._next.val == 16\",\n \"def prepare_r_uls_r_lus(\\n number_of_levels,\\n number_of_shells,\\n j_blues,\\n excitation_species,\\n nlte_data,\\n ):\\n # number_of_levels = atomic_data_levels.energy.loc[\\n # excitation_species\\n # ].count() do this in the solver\\n lnl = nlte_data.lines_level_number_lower[excitation_species]\\n lnu = nlte_data.lines_level_number_upper[excitation_species]\\n (lines_index,) = nlte_data.lines_idx[excitation_species]\\n\\n try:\\n j_blues_filtered = j_blues.iloc[lines_index]\\n except AttributeError:\\n j_blues_filtered = j_blues\\n A_uls = nlte_data.A_uls[excitation_species]\\n B_uls = nlte_data.B_uls[excitation_species]\\n B_lus = nlte_data.B_lus[excitation_species]\\n r_lu_index = lnu * number_of_levels + lnl\\n r_ul_index = lnl * number_of_levels + lnu\\n r_ul_matrix = np.zeros(\\n (number_of_levels, number_of_levels, number_of_shells),\\n dtype=np.float64,\\n )\\n r_ul_matrix_reshaped = r_ul_matrix.reshape(\\n (number_of_levels**2, number_of_shells)\\n )\\n r_ul_matrix_reshaped[r_ul_index] = (\\n A_uls[np.newaxis].T + B_uls[np.newaxis].T * j_blues_filtered\\n )\\n r_lu_matrix = np.zeros_like(r_ul_matrix)\\n r_lu_matrix_reshaped = r_lu_matrix.reshape(\\n (number_of_levels**2, number_of_shells)\\n )\\n r_lu_matrix_reshaped[r_lu_index] = (\\n B_lus[np.newaxis].T * j_blues_filtered\\n )\\n return (\\n lines_index,\\n r_ul_index,\\n r_ul_matrix,\\n r_lu_index,\\n r_lu_matrix,\\n )\\n # TODO: beta sobolev needs to be recalculated for each iteration, because it depends on number density\",\n \"def combine(a, b):\\n assert len(a) == len(b)\\n out = \\\"\\\"\\n for i in range(len(a)):\\n out += a[i]\\n out += b[i]\\n return out\",\n \"def mergeWith(self, others):\",\n \"def _union_one_dim(\\n lows: Sequence, ups: Sequence, new_lows: Sequence, new_ups: Sequence\\n) -> Tuple[np.array, np.array]:\\n out_lows = []\\n out_ups = []\\n\\n for i, low in enumerate(lows):\\n # In one dimension we can imagine the following cases where there\\n # is zero intersection\\n # 1) |--old range--| |--new range--|,\\n # i.e., lower new limit above old upper limit\\n # 2) |--new range--| |--old range--|,\\n # i.e., upper new limit below lower old limit\\n if (new_lows[i] >= ups[i]) or (new_ups[i] <= low):\\n out_lows.append(new_lows[i])\\n out_ups.append(new_ups[i])\\n\\n # In other cases, we want to intersect the ranges, i.e.\\n # |---old range-|-|--new-range--| --> |-|\\n # i.e. we take the max of the lower limits and the min of the upper limits\\n else:\\n out_lows.append(max(low, new_lows[i]))\\n out_ups.append(min(ups[i], new_ups[i]))\\n\\n return np.array(out_lows), np.array(out_ups)\",\n \"def _rconcat(self, other: Any) -> ColumnOperators:\\n return self.reverse_operate(concat_op, other)\",\n \"def add_eggs(eggs, l):\\n\\n return '\\\\n'.join(uniq(eggs + l))\",\n \"def padding(old, l):\\n new = deepcopy(old)\\n for i, j in enumerate(new):\\n new[i] += [0] * (l - len(j))\\n new[i] = j[:l]\\n return new\",\n \"def __listunion(self, c1, c2):\\n s1 = {}\\n for delta in c1:\\n s1[delta] = 1\\n\\n\\tc = c1[:]\\n\\tfor delta in c2:\\n if not s1.has_key(delta):\\n\\t\\tc.append(delta)\\n\\n\\treturn c\",\n \"def concat_same(context, number):\\n buffer = context\\n for i in range(0, number - 1):\\n buffer = np.concatenate((buffer, context), axis=0) \\n return buffer\",\n \"def __add__(self, right_arr):\\n concat_arr = self.copy() # Create new instance to return\\n concat_arr.extend(right_arr)\\n return concat_arr\",\n \"def assemble_col(c1, c2):\\n c1.extend(c2)\\n return c1\",\n \"def concat_strings(l_strings):\\n if l_strings == []:\\n return \\\"\\\"\\n else: \\n return l_strings[0] + \\\" \\\" + concat_strings(l_strings[1:])\",\n \"def clRelu(self, size):\",\n \"def toeplitz_multiplication(u, c, r=None):\\n n = len(u)\\n if r is None:\\n r = c\\n u1 = zeros((2*n))\\n u1[0:n] = u\\n \\n c = np.concatenate((c, [0], r[-1:0:-1])) \\n \\n y1 = circulant_multiplication(u1, c)\\n \\n return y1[0:n]\",\n \"def _algorithm(self, rut):\\n suma = 0\\n multi = 2\\n for r in rut[::-1]:\\n suma += int(r) * multi\\n multi += 1\\n if multi == 8:\\n multi = 2\\n return u'0123456789K0'[11 - suma % 11]\",\n \"def test_merge_list_two_values(long_ll, short_ll):\\n ml(long_ll, short_ll)\\n assert long_ll.head.val == 16\\n assert long_ll.head._next.val == 8\",\n \"def _extend(cls, li1, li2):\\n return li1 + li2\",\n \"def test_merge_list_empty(short_ll, empty_ll):\\n assert ml(short_ll, empty_ll) == 8\\n assert len(short_ll) == 4\",\n \"def __iadd__(self, other):\\n\\n if not isinstance(other, Ulog):\\n raise UlogError('Ulog.__iadd__: can' +\\n ' only add another Ulog to an Ulog.')\\n\\n nccd = set(self.utc.keys())\\n if set(other.utc.keys()) != nccd:\\n raise UlogError('Ulog.__iadd__: CCD numbers of inputs do not match')\\n\\n for nc in nccd:\\n if len(self.x[nc]) != len(other.x[nc]):\\n raise UlogError('Ulog.__iadd__: incompatible' +\\n ' aperture numbers for CCD ' + nc)\\n\\n # OK, tests passed, add new arrays onto the end of the old ones\\n for nc in nccd:\\n\\n self.utc[nc] = np.concatenate((self.utc[nc], other.utc[nc]))\\n self.tflag[nc] = np.concatenate((self.tflag[nc], other.tflag[nc]))\\n self.expose[nc] = np.concatenate((self.expose[nc],other.expose[nc]))\\n self.fwhm[nc] = np.concatenate((self.fwhm[nc],other.fwhm[nc]))\\n self.beta[nc] = np.concatenate((self.beta[nc],other.beta[nc]))\\n\\n for nap in range(len(self.x[nc])):\\n self.x[nc][nap] = np.concatenate(\\n (self.x[nc][nap],other.x[nc][nap]))\\n self.y[nc][nap] = np.concatenate(\\n (self.y[nc][nap],other.y[nc][nap]))\\n self.xm[nc][nap] = np.concatenate(\\n (self.xm[nc][nap],other.xm[nc][nap]))\\n self.ym[nc][nap] = np.concatenate(\\n (self.ym[nc][nap],other.ym[nc][nap]))\\n self.exm[nc][nap] = np.concatenate(\\n (self.exm[nc][nap],other.exm[nc][nap]))\\n self.eym[nc][nap] = np.concatenate(\\n (self.eym[nc][nap],other.eym[nc][nap]))\\n self.counts[nc][nap] = np.concatenate(\\n (self.counts[nc][nap],other.counts[nc][nap]))\\n self.sigma[nc][nap] = np.concatenate(\\n (self.sigma[nc][nap],other.sigma[nc][nap]))\\n self.sky[nc][nap] = np.concatenate(\\n (self.sky[nc][nap],other.sky[nc][nap]))\\n self.nsky[nc][nap] = np.concatenate(\\n (self.nsky[nc][nap],other.nsky[nc][nap]))\\n self.nrej[nc][nap] = np.concatenate(\\n (self.nrej[nc][nap],other.nrej[nc][nap]))\\n self.worst[nc][nap] = np.concatenate(\\n (self.worst[nc][nap],other.worst[nc][nap]))\\n self.eflag[nc][nap] = np.concatenate(\\n (self.eflag[nc][nap],other.eflag[nc][nap]))\\n return self\",\n \"def shorten_ends(s1, s2, s1_ang, s1_crd, s1_raw_seq, s1_ismodified):\\n aligner = init_aligner(allow_target_gaps=True)\\n a = aligner.align(s1, s2)\\n mask = get_padded_second_seq_from_alignment(a[0])\\n i = len(mask) - 1\\n while mask[i] == \\\"-\\\":\\n s1 = s1[:-1]\\n s1_ang = s1_ang[:-1]\\n s1_crd = s1_crd[:-NUM_COORDS_PER_RES]\\n s1_raw_seq = s1_raw_seq[:-1]\\n s1_ismodified = s1_ismodified[:-1]\\n mask = mask[:-1]\\n i -= 1\\n while mask[0] == \\\"-\\\":\\n s1 = s1[1:]\\n s1_ang = s1_ang[1:]\\n s1_crd = s1_crd[NUM_COORDS_PER_RES:]\\n s1_raw_seq = s1_raw_seq[1:]\\n s1_ismodified = s1_ismodified[1:]\\n mask = mask[1:]\\n return s1, s1_ang, s1_crd, s1_raw_seq, s1_ismodified\",\n \"def add_lists(a,b):\\r\\n\\r\\n for i in range(len(a)):\\r\\n a[i] += b[i]\\r\\n return a\",\n \"def regular_collate_fn(data):\\n\\timg, box, q, a = list(zip(*data))\\n\\tq = torch.nn.utils.rnn.pad_sequence(q, batch_first=True)\\n\\treturn torch.stack(img), torch.stack(box), q, torch.stack(a).long()\",\n \"def newPassword(a, b):\\n if len(a) > len(b):\\n return combine(a[:len(b)], b) + a[len(b):]\\n elif len(a) < len(b):\\n return combine(a, b[:len(a)]) + b[len(a):]\\n else:\\n return combine(a, b)\",\n \"def __add__(self,l):\\r\\n\\t\\t\\r\\n\\t\\t# add\\r\\n\\t\\ta = self.add(l)\\r\\n\\t\\t\\r\\n\\t\\treturn a\",\n \"def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\\n nums1[:]=sorted((nums1[:m]+nums2[:n]))\",\n \"def __iadd__(self,l):\\r\\n\\t\\t\\r\\n\\t\\treturn self.add(l)\",\n \"def concat(V, s):\\n\\n X = []\\n for k in range(s):\\n x = []\\n for j in V:\\n x.append(j[k])\\n X.append(vertcat(*x))\\n return X\",\n \"def merge_roidb(roidbs):\\n roidb = roidbs[0]\\n for r in roidbs[1:]:\\n roidb.extend(r)\\n return roidb\",\n \"def merge_roidb(roidbs):\\n roidb = roidbs[0]\\n for r in roidbs[1:]:\\n roidb.extend(r)\\n return roidb\",\n \"def merge(ul, ur, bl, br, isOdd):\\n\\n # Adjust the indicies of the boards for when they're merged together.\\n # upper left board has no offset\\n bl = adjust_offset((len(ul), 0), bl)\\n ur = adjust_offset((0, len(ul[0])), ur)\\n br = adjust_offset((len(ul), len(ul[0])), br)\\n\\n if isOdd:\\n # Upper Left\\n ul_edge, ul_row_e, ul_col_e = replace_corner(offset=(0, 0),\\n dimensions=(len(ul), len(ul[0])),\\n constant=_ULedge)\\n ul_corn, ul_row_c, ul_col_c = replace_corner(offset=(0, 0),\\n dimensions=(len(ul), len(ul[0])),\\n constant=_ULcorn)\\n # Upper Right\\n ur_edge, ur_row_e, ur_col_e = replace_corner(offset=(0, len(ul[0])),\\n dimensions=(len(ur), len(ur[0])),\\n constant=_URedge)\\n ur_corn, ur_row_c, ur_col_c = replace_corner(offset=(0, len(ul[0])),\\n dimensions=(len(ur), len(ur[0])),\\n constant=_URcorn)\\n # Bottom Left\\n bl_edge, bl_row_e, bl_col_e = replace_corner(offset=(len(ul), 0),\\n dimensions=(len(bl), len(bl[0])),\\n constant=_BLedge)\\n bl_corn, bl_row_c, bl_col_c = replace_corner(offset=(len(ul), 0),\\n dimensions=(len(bl), len(bl[0])),\\n constant=_BLcorn)\\n # Bottom Right\\n br_edge, br_row_e, br_col_e = replace_corner(offset=(len(ur), len(bl[0])),\\n dimensions=(len(ur), len(ur[0])),\\n constant=_BRedge)\\n br_corn, br_row_c, br_col_c = replace_corner(offset=(len(ur), len(bl[0])),\\n dimensions=(len(ur), len(ur[0])),\\n constant=_BRcorn)\\n else:\\n # UL\\n ul_edge, ul_r, ul_c = replace_corner(offset=(0, 0),\\n dimensions=(len(ul),len(ul[0])),\\n constant=_sA)\\n # UR\\n ur_edge, ur_r, ur_c = replace_corner(offset=(0, len(ul[0])),\\n dimensions=(len(ur),len(ur[0])),\\n constant=_sB)\\n # BL\\n bl_edge, bl_r, bl_c = replace_corner(offset=(len(ul), 0),\\n dimensions=(len(bl),len(bl[0])),\\n constant=_sD)\\n # BR\\n br_edge, br_r, br_c = replace_corner(offset=(len(ur), len(bl[0])),\\n dimensions=(len(br),len(br[0])),\\n constant=_sC)\\n\\n\\n # Join the boards together\\n board = []\\n # top half\\n for row in range(len(ul)):\\n board.append(ul[row]+ur[row])\\n # bottom half\\n for row in range(len(bl)):\\n board.append(bl[row]+br[row])\\n\\n # Do the actual edge replacement to join the quadrants together\\n if isOdd:\\n board[ul_row_e][ul_col_e] = ul_edge\\n board[ur_row_c][ur_col_c] = ur_corn\\n board[bl_row_e][bl_col_e] = bl_edge\\n board[ul_row_c][ul_col_c] = ul_corn\\n board[br_row_e][br_col_e] = br_edge\\n board[bl_row_c][bl_col_c] = bl_corn\\n board[ur_row_e][ur_col_e] = ur_edge\\n board[br_row_c][br_col_c] = br_corn\\n else:\\n board[ul_r][ul_c] = ul_edge\\n board[ur_r][ur_c] = ur_edge\\n board[br_r][br_c] = br_edge\\n board[bl_r][bl_c] = bl_edge\\n\\n return board\",\n \"def merge_up(lsts):\\r\\n lsts1 = transpose(lsts)\\r\\n lsts2 = merge_AllLeft(lsts1)\\r\\n lsts3 = shift(lsts2)\\r\\n lsts4 = transpose(lsts3)\\r\\n lsts = lsts4\\r\\n\\r\\n return lsts\",\n \"def merge(a, b):\\r\\n # your code here\\r\\n \\r\\n m = []\\r\\n i, j = 0, 0\\r\\n \\r\\n while i < len(a) and j < len(b):\\r\\n if a[i] < b[j]:\\r\\n m.append(a[i])\\r\\n i += 1\\r\\n else:\\r\\n m.append(b[j])\\r\\n j += 1\\r\\n \\r\\n m += a[i:] + b[j:]\\r\\n \\r\\n return m\",\n \"def merge(self, nums1, m, nums2, n):\\n\\t\\tnum1_pointer = 0\\n\\t\\tif len(nums2) ==0:\\n\\t\\t\\treturn\\n\\t\\tt = nums2.pop(0)\\n\\t\\tboundry = m\\n\\t\\twhile nums2:\\n\\t\\t\\t# print(nums2)\\n\\t\\t\\tif num1_pointer == boundry:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tif nums1[num1_pointer] < t:\\n\\t\\t\\t\\tnum1_pointer += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttemp = nums1[num1_pointer]\\n\\t\\t\\t\\tnums1[num1_pointer:] = [0] + nums1[num1_pointer:-1]\\n\\t\\t\\t\\tnums1[num1_pointer] = t\\n\\t\\t\\t\\tt = nums2.pop(0)\\n\\t\\t\\t\\tboundry += 1\\n\\t\\t\\t\\tnum1_pointer += 1\\n\\t\\tif nums2:\\n\\t\\t\\tnums1[num1_pointer:] = [t] + nums2\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"test\\\")\\n\\t\\t\\ttemp = nums1[num1_pointer]\\n\\t\\t\\tnums1[num1_pointer:] = [0] + nums1[num1_pointer:-1]\\n\\t\\t\\tnums1[num1_pointer] = t\",\n \"def add4(a,b):\\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],a[3]+b[3]]\",\n \"def clevr_collate_fn(data):\\n\\tdata = sorted(data, key=lambda x: len(x[1]), reverse=True)\\n\\timg, q, len_q, a, f, idx = list(zip(*data))\\n\\tq = torch.nn.utils.rnn.pad_sequence(q, batch_first=True)\\n\\treturn torch.stack(img), q, list(len_q), torch.stack(a), list(f), list(idx)\",\n \"def concatenate(arrays, **kwargs):\\n unit = unit_of(arrays[0])\\n result = np.concatenate([to_unitless(arr, unit) for arr in arrays], **kwargs)\\n return result * unit\",\n \"def join_vars(self, xs):\\n return tf.concat(1, xs)\",\n \"def laceStrings(s1, s2):\\n # Your Code Here\\n i = 0\\n result = \\\"\\\"\\n \\n while i < len(s1) and i < len(s2):\\n result += s1[i] + s2[i]\\n i += 1\\n \\n result += s1[i:]\\n result += s2[i:]\\n \\n return result\",\n \"def _to_add_and_update(self):\\n primitive_list=[]\\n group_list=[]\\n location_list = []\\n #primitives\\n for item in self.candidate_config:\\n item_groupdef=group(item['name'], item['type'], item['ips'])\\n if item['name'] in names(self.live_config):\\n live_item=[x for x in self.live_config if x['name']==item['name']][0]\\n added_ips=[x for x in item['ips'] if x not in live_item['ips']]\\n primitive_list += ip_primitives(item['name'], added_ips)\\n if item['type'] != live_item['type']:\\n if item['type'] == 'ldirectord':\\n primitive_list += ld_primitives(item['name'], item['loadbalancers'])\\n if set(item_groupdef[0].split()) != set(group2(live_item)[0].split()):\\n group_list += item_groupdef\\n if item['loadbalancers'] != live_item['loadbalancers']:\\n location_list += lborder(item['name'], item['loadbalancers'])\\n else:\\n primitive_list += primitives(item['name'], item['type'], item['ips'])\\n group_list += item_groupdef\\n location_list += lborder(item['name'], item['loadbalancers'])\\n return '\\\\n'.join(primitive_list + group_list + location_list)\",\n \"def concat(strokes):\\n\\n long_stroke = Stroke()\\n for stroke in strokes:\\n long_stroke.x += stroke.x\\n long_stroke.y += stroke.y\\n long_stroke.len += stroke.len\\n return long_stroke\",\n \"def data_unification(self, data1, data2):\\r\\n data = data1 + data2\\r\\n return data\",\n \"def MergeLogic(self) -> str:\",\n \"def addVectors(r1, r2):\\n \\\"\\\"\\\" [0] = angle, [1] = lenght \\\"\\\"\\\"\\n x = (math.sin(r1[0]) * r1[1]) + (math.sin(r2[0]) * r2[1])\\n y = (math.cos(r1[0]) * r1[1]) + (math.cos(r2[0]) * r2[1])\\n \\n angle = 0.5 * math.pi - math.atan2(y, x)\\n length = math.hypot(x, y)\\n\\n return (angle, length)\",\n \"def joins((u,v,o)):\\r\\n return { W : ((u,v), (u-1,v)),\\r\\n S : ((u,v), (u,v-1)) }[o]\",\n \"def concat(seq1, seq2):\\n if type_tag(seq1) == type_tag(seq2):\\n return seq1 + seq2\\n else:\\n types = (type_tag(seq1), type_tag(seq2))\\n if types in concat.adders:\\n return concat.adders[types](seq1, seq2)\",\n \"def testRegisterConcatenation(self):\\n reg_one = ShiftRegister(2)\\n reg_one.shift(\\\"a\\\")\\n reg_one.shift(\\\"b\\\")\\n reg_two = ShiftRegister(3)\\n reg_two.shift(\\\"c\\\")\\n reg_two.shift(\\\"d\\\")\\n reg_two.shift(\\\"e\\\")\\n reg_cat = reg_one.concatenate(reg_two)\\n self.assertEqual(''.join(reg_cat), \\\"abcde\\\")\",\n \"def test_align_lst_shapes_equal():\\n test_file = os.path.join(DATA_PATH, \\\"paper_test_file.uvh5\\\")\\n test_uv = UVData()\\n test_uv.read(test_file)\\n\\n test_uv_2 = copy.deepcopy(test_uv)\\n ra_range = [0, 12]\\n\\n test_uv_out, test_uv_2_out = utils.lst_align(\\n test_uv,\\n test_uv_2,\\n ra_range=ra_range,\\n inplace=False,\\n )\\n\\n assert test_uv_out.time_array.shape == test_uv_out.time_array.shape\",\n \"def merge_ranges():\",\n \"def __array_append(self, in_a,in_b):\\n in_b = np.array([in_b]) if isinstance(in_b,(int,float,long,complex)) else in_b\\n return np.concatenate((in_a,in_b))\",\n \"def add_string(l, base):\\n\\n match_length = len(l) - 1\\n left_end = base[:match_length]\\n right_end = base[-match_length:]\\n if l[1:] == left_end:\\n return [l[0]] + base\\n elif l[:-1] == right_end:\\n return base + [l[-1]]\\n else:\\n raise AppendException\",\n \"def concat(x: list[int], y: list[int]) -> list[int]:\\n con = list()\\n i: int = 0\\n count: int = 0\\n while len(y) > i: \\n con.append(y[i])\\n i += 1\\n while len(x) > count: \\n con.append(x[count])\\n count += 1 \\n return con\",\n \"def __add__(self,other):\\n if self.h != other.h or self.w != other.w:\\n raise(ValueError, \\\"Matrices can only be added if the dimensions are the same\\\") \\n # \\n # TODO - your code here\\n #\\n result = [];\\n for i in range(self.h):\\n result.append([a+b for a,b in zip(self.g[i],other.g[i])]);\\n \\n return Matrix(result);\",\n \"def bytearray_join(glue, list_of_barrays):\\n res = list_of_barrays[0]\\n for i in range(1,len(list_of_barrays)):\\n res += glue + list_of_barrays[i]\\n return res\",\n \"def mergeNodes(new, t1, t2):\\n \\n if t1 and t2:\\n new.val = t1.val + t2.val\\n elif not t1:\\n new.val = t2.val\\n elif not t2:\\n new.val = t1.val\",\n \"def __add__(self, other):\\n return self.concatenate(other)\",\n \"def __add__(self, other):\\n return self.concatenate(other)\",\n \"def _umap_concat(data, **umap_kwargs):\\n data_tiles = []\\n for i in range(5):\\n data_i = slice_vec_bands(data, start=i, end=i + 1)\\n data_tiles.append(umap.UMAP(**umap_kwargs).fit_transform(data_i))\\n\\n data_concat = numpy.empty((\\n data_tiles[0].shape[0],\\n sum(dt.shape[1] for dt in data_tiles)\\n ))\\n\\n start_col = 0\\n for dt in data_tiles:\\n end_col = start_col + dt.shape[1]\\n data[:, start_col:end_col] = dt\\n start_col = end_col\\n\\n return data_concat\",\n \"def combinations( l1, l2 ):\\n for i in range(len(l1)):\\n yield zip( l1,l2)\\n l1.insert(0,l1.pop())\",\n \"def concat_all(self):\\n return self.merge(1)\",\n \"def recombine(self, s1, s2):\\n PICK_OP_PROB = 0.9\\n\\n rep1, cpi1 = self.pick_random_rep(s1, PICK_OP_PROB)\\n rep2, cpi2 = self.pick_random_rep(s2, PICK_OP_PROB)\\n\\n off1 = s1[:rep1] + s2[rep2:cpi2 + 1] + s1[cpi1 + 1:]\\n off2 = s2[:rep2] + s1[rep1:cpi1 + 1] + s2[cpi2 + 1:]\\n\\n return off1, off2\",\n \"def lform(self):\\n a, c, d, b = self.to_ccw()\\n if b < c:\\n a += b\\n b -= b\\n c -= b\\n d += b\\n else:\\n a += c\\n b -= c\\n c -= c\\n d += c\\n return self.__class__.from_ccw(a, c, d, b)\",\n \"def laceStrings(s1, s2):\\n s3= \\\"\\\"\\n x=0\\n \\n while x < len(s1):\\n s3 += s1[x]\\n s3 += s2[x]\\n x += 1\\n if x >= len(s2):\\n s3 += s1[len(s2):]\\n return s3\\n \\n s3 += s2[len(s1):]\\n return s3\",\n \"def _batchify(self, data, align_right=False, include_lengths=False):\\n lengths = [x.size(0) for x in data]\\n max_length = max(lengths)\\n out = data[0].new(len(data), max_length).fill_(neusum.Constants.PAD)\\n for i in range(len(data)):\\n data_length = data[i].size(0)\\n offset = max_length - data_length if align_right else 0\\n out[i].narrow(0, offset, data_length).copy_(data[i])\\n\\n if include_lengths:\\n return out, lengths\\n else:\\n return out\",\n \"def brepalgo_ConcatenateWire(*args):\\n return _BRepAlgo.brepalgo_ConcatenateWire(*args)\",\n \"def join (xl,xr,y=1):\\n\\n X = (xl,xr)\\n Y = split(y)\\n while not seq(X,Y):\\n y *= 2\\n if sle(Y,X): y += 1\\n Y = split(y)\\n return y\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6007597","0.5953543","0.58370024","0.57667744","0.56314075","0.5579645","0.5569091","0.5529879","0.55260503","0.5507611","0.5504095","0.5491118","0.5489259","0.5442784","0.5399009","0.5395347","0.5387921","0.5385343","0.5382747","0.5379792","0.5364914","0.5332827","0.5300339","0.5297065","0.52909315","0.5243205","0.52382445","0.5230071","0.52251196","0.51968414","0.5192649","0.51874375","0.5163518","0.515311","0.5149403","0.5139839","0.513417","0.51296085","0.5128968","0.51149535","0.51073015","0.5105312","0.510507","0.5084403","0.507948","0.5072386","0.5069113","0.50616676","0.5061393","0.5058619","0.5028354","0.50256735","0.50189143","0.5011338","0.50089896","0.5004658","0.5004189","0.49966702","0.49929348","0.49898776","0.49795017","0.49709746","0.49707913","0.49653813","0.49653813","0.49552336","0.49465582","0.49431425","0.4941305","0.4930504","0.4919485","0.4916578","0.49132213","0.4911916","0.49062094","0.49061638","0.49056542","0.49052316","0.49045032","0.4899931","0.48920557","0.48868868","0.4886725","0.48860466","0.48852408","0.48767453","0.48763856","0.4871632","0.48654008","0.48620534","0.48579147","0.48579147","0.4857093","0.48542073","0.48540947","0.48530895","0.4851375","0.48374707","0.48363408","0.4832488","0.48323068"],"string":"[\n \"0.6007597\",\n \"0.5953543\",\n \"0.58370024\",\n \"0.57667744\",\n \"0.56314075\",\n \"0.5579645\",\n \"0.5569091\",\n \"0.5529879\",\n \"0.55260503\",\n \"0.5507611\",\n \"0.5504095\",\n \"0.5491118\",\n \"0.5489259\",\n \"0.5442784\",\n \"0.5399009\",\n \"0.5395347\",\n \"0.5387921\",\n \"0.5385343\",\n \"0.5382747\",\n \"0.5379792\",\n \"0.5364914\",\n \"0.5332827\",\n \"0.5300339\",\n \"0.5297065\",\n \"0.52909315\",\n \"0.5243205\",\n \"0.52382445\",\n \"0.5230071\",\n \"0.52251196\",\n \"0.51968414\",\n \"0.5192649\",\n \"0.51874375\",\n \"0.5163518\",\n \"0.515311\",\n \"0.5149403\",\n \"0.5139839\",\n \"0.513417\",\n \"0.51296085\",\n \"0.5128968\",\n \"0.51149535\",\n \"0.51073015\",\n \"0.5105312\",\n \"0.510507\",\n \"0.5084403\",\n \"0.507948\",\n \"0.5072386\",\n \"0.5069113\",\n \"0.50616676\",\n \"0.5061393\",\n \"0.5058619\",\n \"0.5028354\",\n \"0.50256735\",\n \"0.50189143\",\n \"0.5011338\",\n \"0.50089896\",\n \"0.5004658\",\n \"0.5004189\",\n \"0.49966702\",\n \"0.49929348\",\n \"0.49898776\",\n \"0.49795017\",\n \"0.49709746\",\n \"0.49707913\",\n \"0.49653813\",\n \"0.49653813\",\n \"0.49552336\",\n \"0.49465582\",\n \"0.49431425\",\n \"0.4941305\",\n \"0.4930504\",\n \"0.4919485\",\n \"0.4916578\",\n \"0.49132213\",\n \"0.4911916\",\n \"0.49062094\",\n \"0.49061638\",\n \"0.49056542\",\n \"0.49052316\",\n \"0.49045032\",\n \"0.4899931\",\n \"0.48920557\",\n \"0.48868868\",\n \"0.4886725\",\n \"0.48860466\",\n \"0.48852408\",\n \"0.48767453\",\n \"0.48763856\",\n \"0.4871632\",\n \"0.48654008\",\n \"0.48620534\",\n \"0.48579147\",\n \"0.48579147\",\n \"0.4857093\",\n \"0.48542073\",\n \"0.48540947\",\n \"0.48530895\",\n \"0.4851375\",\n \"0.48374707\",\n \"0.48363408\",\n \"0.4832488\",\n \"0.48323068\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":930,"numItemsPerPage":100,"numTotalItems":95772,"offset":93000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTU1MzMwNSwianRpIjoiNDNmMGZiODctZGY3Mi00NmYxLTkwOTItNTJiZjI1OWU5MzkzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1NTY5MDUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.XsOqagfGeE78d5wOtgqcqe4miyG8inS4SKD8wXU0vl4xsYWYCr1H0s1NRRSBMD-jCQH2SJIP91rsEpRrI_1MBQ","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 |
|---|---|---|---|---|---|---|
Finds all nonnested open reading frames in the given DNA sequence on both strands. | def find_all_ORFs_both_strands(dna):
return find_all_ORFs(dna) + find_all_ORFs(get_reverse_complement(dna)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_all_ORFs_oneframe(dna):",
"def find_all_ORFs(dna):\n first_frame = find_all_ORFs_oneframe(dna[0:])\n second_frame = find_all_ORFs_oneframe(dna[1:])\n third_frame = find_all_ORFs_oneframe(dna[2:])\n list_of_frames = first_frame + second_frame + third_frame\n return list_of_frames",
"def ... | [
"0.63436097",
"0.6218921",
"0.6172527",
"0.60850155",
"0.60356677",
"0.59685004",
"0.5943129",
"0.5929876",
"0.59213984",
"0.592066",
"0.59185624",
"0.5876451",
"0.5841582",
"0.58351207",
"0.5815624",
"0.5804441",
"0.5793256",
"0.5780236",
"0.5777369",
"0.5773576",
"0.5764555... | 0.5699599 | 25 |
Unit tests for the find_all_ORFs_both_strands function | def find_all_ORFs_both_strands_unit_tests():
data_list = [
["ATGCGAATGTAGCATCAAA", ["ATGCGAATG", "ATGCTACATTCGCAT"]],
["ATG", ["ATG"]],
["CAT", ["ATG"]],
["CATCAT", ["ATGATG"]],
["CATGGGCAT", ["ATGGGCAT", "ATGCCCATG"]],
["CATGCAGTGCACGGATGGCAT", ["ATGCAGTGCACGGATGGCAT... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_all_ORFs_both_strands_unit_tests():\n\n # YOUR IMPLEMENTATION HERE",
"def find_all_ORFs_both_strands_unit_tests():\n print ''\n print 'Begin Unit test Find_all_ORFs both tests'\n input_a='ATGCGAGGGTAGATGGATTAG'\n expected_output='[ATGCGAGGG, ATGGAT]'\n actual_output=find_all_ORFs_both_... | [
"0.8720261",
"0.8006601",
"0.78446746",
"0.7341566",
"0.7335677",
"0.71598625",
"0.6980529",
"0.695957",
"0.6887582",
"0.68275267",
"0.68138146",
"0.68044704",
"0.6797018",
"0.6769603",
"0.67119783",
"0.6693318",
"0.6661346",
"0.6647071",
"0.6629509",
"0.6596347",
"0.65733176... | 0.77680993 | 3 |
Finds the longest ORF on both strands of the specified DNA and returns it as a string | def longest_ORF(dna):
l = find_all_ORFs_both_strands(dna)
max_len = 0
r = ""
# [???] what if there are ORFs with same length?
# this function just get the first one.
if len(l) == 0:
return ""
for o in l:
if len(o) > max_len:
r = o
max_len = len(o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_ORF(dna):\n l = find_all_ORFs_both_strands(dna)\n longest=''\n if len(l)>=1:\n\t longest =max(l,key=len)\n return longest",
"def longest_ORF(dna):\n both_strings=find_all_ORFs_both_strands(dna)\n L=max(both_strings,key=len)\n Q=len(L)\n return Q\n\n #save out put of ... | [
"0.87619084",
"0.8655862",
"0.86459744",
"0.86390924",
"0.86111736",
"0.8554702",
"0.8422834",
"0.8375487",
"0.83478934",
"0.80594677",
"0.8031292",
"0.7990923",
"0.7948157",
"0.7885518",
"0.76717263",
"0.76625794",
"0.7617656",
"0.75137126",
"0.75038695",
"0.7478359",
"0.742... | 0.8745673 | 1 |
Unit tests for the longest_ORF function | def longest_ORF_unit_tests():
data_list = [
["ATGCGAATGTAGCATCAAA", "ATGCTACATTCGCAT"],
["ATG", "ATG"],
["CAT", "ATG"],
["CATCAT", "ATGATG"],
["CATGGGCAT", "ATGCCCATG"],
["CATGCAGTGCACGGATGGCAT", "ATGCCATCCGTGCACTGCATG"],
# CATGCAGTGCACGGATGGCAT
# CAT GCA GTG CAC GGA ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_ORF_unit_tests():\n\n # YOUR IMPLEMENTATION HERE",
"def longest_ORF_unit_tests():\n\n # YOUR IMPLEMENTATION HERE",
"def longest_ORF_unit_tests():\n\n input_a=\"ATGCGAATGTAGCATCAAA\"\n expected_output=''\n actual_output=longest_ORF(input_a)\n print 'Expected Output is ' + expected_... | [
"0.87596375",
"0.87596375",
"0.87375337",
"0.81525123",
"0.80336714",
"0.7930263",
"0.78946465",
"0.7806731",
"0.774229",
"0.77294636",
"0.76995844",
"0.7675174",
"0.76290596",
"0.76229846",
"0.7548526",
"0.74611413",
"0.74381006",
"0.74002784",
"0.7334834",
"0.73214704",
"0.... | 0.85157883 | 3 |
Computes the maximum length of the longest ORF over num_trials shuffles of the specfied DNA sequence | def longest_ORF_noncoding(dna, num_trials):
org = list(dna)
max_len = 0
r = ""
for i in range(num_trials):
l = org
shuffle(l)
orf = longest_ORF(collapse(l))
if len(orf) > max_len:
r = orf
max_len = len(orf)
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_ORF_noncoding(dna, num_trials):\n i = 0\n longest_each_trial = []\n while i < num_trials:\n shuffled_dna = shuffle_string(dna)\n longest_each_trial.append(longest_ORF(shuffled_dna))\n i += 1\n\n longest_longest = max(longest_each_trial, key=len)\n return len(longest_... | [
"0.87796474",
"0.87454444",
"0.85417074",
"0.8508988",
"0.8500134",
"0.84909016",
"0.8478915",
"0.8408802",
"0.8328015",
"0.8135475",
"0.806552",
"0.80442095",
"0.74661",
"0.7383516",
"0.7355161",
"0.7231103",
"0.7160716",
"0.7150049",
"0.7064139",
"0.70563704",
"0.7049209",
... | 0.8279816 | 9 |
Returns the amino acid sequences coded by all genes that have an ORF larger than the specified threshold. | def gene_finder(dna, threshold):
l = find_all_ORFs_both_strands(dna)
r = []
if len(l) > 0:
for item in l:
if len(item) > threshold:
r.append(item)
for i in range(len(r)):
r[i] = coding_strand_to_AA(r[i])
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gene_finder(dna, threshold):\n orfs = find_all_ORFs_both_strands(dna)\n orfs = [i for i in orfs if len(i)>threshold]\n orfs = [coding_strand_to_AA(i) for i in orfs]\n return orfs",
"def gene_finder(dna):\n orfs = find_all_ORFs_both_strands(dna)\n print(orfs)\n threshold = longest_ORF_non... | [
"0.74298954",
"0.71481067",
"0.6994018",
"0.68657947",
"0.6788955",
"0.67642456",
"0.59709907",
"0.58188194",
"0.5695765",
"0.557573",
"0.55652696",
"0.55194056",
"0.5454421",
"0.5452923",
"0.54236233",
"0.5409136",
"0.53492814",
"0.5158032",
"0.5150435",
"0.51174647",
"0.506... | 0.71809494 | 1 |
This is the helper function & rob a noncircular list of houses as House Robber I | def robSingle_2(self, nums, start, end):
# print((start, end))
# print(nums[start: end + 1])
curMax = 0
preMax = 0
for num in nums[start:end + 1]:
preMax, curMax = curMax, max(curMax, preMax + num)
# print(curMax)
# print("#############################... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_own_house(self, house): # Filling a list of houses are owned by Person\n self.own_home.append(house)",
"def link_houses(self):\n # order the batteries for each house\n for house in list(self.houses.values()):\n dist = house.dist\n ord_dist = sorted(dist.items(... | [
"0.5806222",
"0.5710233",
"0.570435",
"0.5521284",
"0.551165",
"0.550744",
"0.5492642",
"0.5478569",
"0.5465875",
"0.54462147",
"0.54407626",
"0.54252803",
"0.54103124",
"0.53790945",
"0.53709656",
"0.5357785",
"0.53563446",
"0.5340862",
"0.53357506",
"0.5317696",
"0.53055185... | 0.0 | -1 |
This is the helper function & rob a noncircular list of houses as House Robber I | def robSingle(self, nums, start, end):
# print((start, end))
# print(nums[start: end])
curMax = 0
preMax = 0
for num in nums[start:end]:
preMax, curMax = curMax, max(curMax, preMax + num)
# print(curMax)
# print("####################################")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_own_house(self, house): # Filling a list of houses are owned by Person\n self.own_home.append(house)",
"def link_houses(self):\n # order the batteries for each house\n for house in list(self.houses.values()):\n dist = house.dist\n ord_dist = sorted(dist.items(... | [
"0.58063686",
"0.5711454",
"0.57048863",
"0.55215704",
"0.5511004",
"0.55080914",
"0.5494405",
"0.5479343",
"0.5466541",
"0.5447755",
"0.54425746",
"0.54249513",
"0.5409817",
"0.5380757",
"0.537144",
"0.53576016",
"0.53571963",
"0.53413516",
"0.5336846",
"0.53189075",
"0.5307... | 0.0 | -1 |
r""" Initialize a collision with two wavefunctions, presumably a nucleus and a proton. One must implement the wilson line, though the order of the arguments does not matter. In the case that both wavefunctions implement the wilson line, the first (wavefunction1) will be used as such. In the case that neither implement ... | def __init__(self, wavefunction1: Wavefunction, wavefunction2: Wavefunction):
# Make sure that at least one has a wilson line
wilsonLineExists1 = callable(getattr(wavefunction1, "wilsonLine", None))
wilsonLineExists2 = callable(getattr(wavefunction2, "wilsonLine", None))
if not wilsonL... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_library_charges_to_two_waters(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n get_data_file_path(\"test_forcefields/tip3p.offxml\"),\n )\n mol = Molecule.from_file(\n get_data_file_path(os.path.join(\"syst... | [
"0.5363549",
"0.53437185",
"0.5282484",
"0.4975989",
"0.49336395",
"0.49139965",
"0.4913422",
"0.4866941",
"0.485196",
"0.4840935",
"0.4831913",
"0.48300686",
"0.48231012",
"0.48094025",
"0.47987574",
"0.47694734",
"0.47500825",
"0.47249275",
"0.47237548",
"0.4697747",
"0.467... | 0.781818 | 0 |
r""" Calculate the field omega at each point on the lattice. If the field already exists, it is simply returned and no calculation is done. | def omega(self, forceCalculate=False, verbose=0):
if self._omegaExists and not forceCalculate:
return self._omega
self.incidentWavefunction.gaugeField(verbose=verbose)
self.targetWavefunction.adjointWilsonLine(verbose=verbose)
if verbose > 0:
print(f'Calculatin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculateOmegaOpt(N, gluonDOF, delta, incidentGaugeField, targetAdjointWilsonLine):\n\n # 2,2 is for the 2 dimensions, x and y\n omega = np.zeros((N, N, 2, 2, gluonDOF), dtype='complex') # 2 is for two dimensions, x and y\n\n derivs = [_x_deriv, _y_deriv]\n\n for i in range(N):\n for j in r... | [
"0.61966604",
"0.61015",
"0.6020752",
"0.5965969",
"0.5809604",
"0.5785809",
"0.5762362",
"0.56903183",
"0.5675721",
"0.566216",
"0.562489",
"0.5606232",
"0.5581973",
"0.5539443",
"0.5505453",
"0.5466363",
"0.5453032",
"0.5429813",
"0.5425745",
"0.5405547",
"0.53965545",
"0... | 0.6339087 | 0 |
r""" Compute the fourier transform of the field omega on the lattice. If the fft of the field already exists, it is simply returned and no calculation is done. | def omegaFFT(self, forceCalculate=False, verbose=0):
if self._omegaFFTExists and not forceCalculate:
return self._omegaFFT
# Make sure omega exists
self.omega(verbose=verbose)
if verbose > 0:
print(f'Calculating {type(self).__name__} omega fourier transform' + '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fourier_transform(hamiltonian, grid, spinless):\n return _fourier_transform_helper(hamiltonian=hamiltonian,\n grid=grid,\n spinless=spinless,\n phase_factor=+1,\n v... | [
"0.63342255",
"0.63339674",
"0.6287672",
"0.62734646",
"0.62432265",
"0.61635166",
"0.61274135",
"0.60326177",
"0.60305816",
"0.5935891",
"0.59015477",
"0.5884128",
"0.58474153",
"0.58341295",
"0.58334965",
"0.57607025",
"0.57455075",
"0.5744383",
"0.57404006",
"0.5733641",
"... | 0.64539677 | 0 |
r""" Compute the range of momenta at which particles will be created based on the dimensions of the lattice. | def momentaBins(self, forceCalculate=False, verbose=0):
if self._momentaBinsExists and not forceCalculate:
return self._momentaBins
if verbose > 0:
print(f'Calculating {type(self).__name__} momentum bins' + '.'*10, end='')
self._momentaBins = [i*self.binSize for i in r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)",
"def _calc_range(self) -> np.ndarray:\n if self._is_ct25k():\n range_resolution = 30\n n_gates = 256\n else:\n n_gates = int(self.metadata[\"number_of_gates\"])\n range_... | [
"0.62849957",
"0.6180772",
"0.6029936",
"0.57914567",
"0.5738106",
"0.5718626",
"0.57101995",
"0.5694598",
"0.5662082",
"0.5660439",
"0.56356585",
"0.5627411",
"0.56166595",
"0.56106514",
"0.5584325",
"0.55651206",
"0.55525315",
"0.55234414",
"0.55138046",
"0.5500878",
"0.548... | 0.0 | -1 |
r""" Compute the derivative of particles produced (\( \frac{d^2 N}{d^2 k} \)) at each point on the lattice If the calculation has already been done, the result is simply returned and is not repeated. | def particlesProducedDeriv(self, forceCalculate=False, verbose=0):
if self._particlesProducedDerivExists and not forceCalculate:
return self._particlesProducedDeriv
# Make sure these quantities exist
self.omegaFFT(verbose=verbose)
self.momentaMagnitudeSquared(verbose=verbose... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_derivative(self, model, params, n):\n params1 = np.array(params)\n params2 = np.array(params)\n\n params1[n] += self.eps\n params2[n] -= self.eps\n\n res1 = model.run(params1)\n res2 = model.run(params2)\n\n d = (res1 - res2) / (2 * self.eps)\n\n return d.ravel()",
"def nth_deriva... | [
"0.64778066",
"0.64777637",
"0.6454873",
"0.6416733",
"0.6385484",
"0.6365195",
"0.63649744",
"0.6353335",
"0.6346613",
"0.63342845",
"0.63319826",
"0.6290726",
"0.62458384",
"0.61796194",
"0.6177636",
"0.6173804",
"0.612152",
"0.6115887",
"0.6109102",
"0.61023456",
"0.608113... | 0.5847744 | 40 |
r""" Compute the number of particles produced \(N(|k|)\) as a function of momentum. Note that this is technically the zeroth fourier harmonic, so this actually just calls the cgc.Collision.fourierHarmonic() function. The particles are binned according to cgc.Collision.momentaBins(). Most likely will be plotted against ... | def particlesProduced(self, forceCalculate=False, verbose=0):
# This one is strictly real, so we should make sure that is updated
self._fourierHarmonics[0] = np.real(self.fourierHarmonic(0, forceCalculate, verbose))
return self._fourierHarmonics[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cdf(self, k):\n\n if k < 0 or k > self.n:\n return 0\n\n k = int(k)\n ans = 0\n for i in range(0, k + 1):\n ans += self.pmf(i)\n return ans",
"def frequency(self, mass: float) -> float:\n return self.omega(mass) / u.twopi",
"def get_k(self, mo... | [
"0.6223754",
"0.58447295",
"0.5835107",
"0.58238643",
"0.5793296",
"0.57711184",
"0.57160884",
"0.57103884",
"0.57061857",
"0.57055527",
"0.56863546",
"0.5672576",
"0.5646059",
"0.56414986",
"0.5624835",
"0.5577681",
"0.5571035",
"0.5556223",
"0.55299175",
"0.5514452",
"0.549... | 0.0 | -1 |
Calculate the field omega at each point on the lattice. If the field already exists, it is simply returned and no calculation is done. Returns | def _calculateOmegaOpt(N, gluonDOF, delta, incidentGaugeField, targetAdjointWilsonLine):
# 2,2 is for the 2 dimensions, x and y
omega = np.zeros((N, N, 2, 2, gluonDOF), dtype='complex') # 2 is for two dimensions, x and y
derivs = [_x_deriv, _y_deriv]
for i in range(N):
for j in range(N):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def omega(self, forceCalculate=False, verbose=0):\n\n if self._omegaExists and not forceCalculate:\n return self._omega\n\n self.incidentWavefunction.gaugeField(verbose=verbose)\n self.targetWavefunction.adjointWilsonLine(verbose=verbose)\n\n if verbose > 0:\n prin... | [
"0.65611875",
"0.6319371",
"0.5993952",
"0.59877014",
"0.5888921",
"0.58748895",
"0.58195966",
"0.5772964",
"0.5772052",
"0.56714135",
"0.56430805",
"0.5615205",
"0.5599253",
"0.5576051",
"0.5548847",
"0.55219823",
"0.55002594",
"0.5486295",
"0.5471869",
"0.54689527",
"0.5463... | 0.62411505 | 2 |
Optimized (via numba) function to calculated the position (momentum) in Fourier space of each point | def _calculateMomentaOpt(N, delta):
momentaComponents = np.zeros((N, N, 2))
theta = np.zeros((N, N))
for i in range(N):
for j in range(N):
# Note that these components are of the form:
# k_x = 2/a sin(k_x' a / 2)
# Though the argument of the sin is simplified a b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position_to_Fourier(self):\n #TODO Try to do it with FFT \n U = self.alphas @ self.positions\n \n return U",
"def PointMilieu(x,f):\n\tNx = f.shape[0]\n\tS=0.0\n\tfor i in range(0,Nx-1):\n\t\tS=S+f[i]*(x[i+1]-x[i]) \n\treturn S",
"def f(x):\n return np.tan(x) - np.sin(x)... | [
"0.6262863",
"0.58647877",
"0.5800414",
"0.57622546",
"0.5669494",
"0.566121",
"0.56350255",
"0.56235635",
"0.56235635",
"0.5615969",
"0.5564165",
"0.55272233",
"0.55245006",
"0.5508289",
"0.54817075",
"0.5475856",
"0.5470814",
"0.54582995",
"0.54064107",
"0.540339",
"0.53952... | 0.0 | -1 |
Optimized (via numba) function to calculate dN/d^2k | def _calculateParticlesProducedDerivOpt(N, gluonDOF, momentaMagSquared, omegaFFT):
# Where we will calculate dN/d^2k
particleProduction = np.zeros((N,N))
# # 2D Levi-Cevita symbol
LCS = np.array([[0,1],[-1,0]])
# # 2D Delta function
KDF = np.array([[1,0],[0,1]])
# Note that unlike in the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(k, i, j):\n if not (0 <= i < N and 0 <= j < N): return 0\n if k == 0: return 1 \n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))",
"def get_pij_numba(d, scale, i):\n \n d_scaled = -d/scale\n ... | [
"0.6455723",
"0.6416024",
"0.6281938",
"0.622644",
"0.60808295",
"0.6065724",
"0.6049456",
"0.5998111",
"0.5918952",
"0.5913631",
"0.5879115",
"0.58402175",
"0.58285564",
"0.5814981",
"0.5798404",
"0.57793164",
"0.57776886",
"0.575968",
"0.57358",
"0.5716769",
"0.5710634",
... | 0.0 | -1 |
Evaluate the systematic uncertainty of the fit model. Each signal shape in fitting.lambdac_mass.shapes_sig is fitted with each background shape in fitting.lambdac_mass.shapes_bkg. The systematic uncertainty is taken as the largest fractional deviation from the nominal yield, which is the yield obtained from the nominal... | def fit_systematics(mode, polarity, year):
n = ntuples.get_ntuple(mode, polarity, year)
sel_path = "{0}/selected-{1}.root".format(config.output_dir, n)
sel_n = n.__class__("DecayTree", n.polarity, n.year)
sel_n.add(sel_path)
w_name = "{0}-{1}-{2}-workspace"
# Nominal shapes
# Nom nom nom
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_power_law_MMEN_per_system_observed_and_physical(sssp_per_sys, sssp, n_mult_min=2, max_core_mass=10., prescription='CL2013', n=10., a0=1., p0=1., p1=-1.5, scale_up=False):\n fit_per_sys_dict = {'n_pl_true':[], 'n_pl_obs':[], 'Mp_tot_true':[], 'Mp_tot_obs':[], 'sigma0_true':[], 'sigma0_obs':[], 'scale_fac... | [
"0.54107773",
"0.53992355",
"0.5390711",
"0.5299261",
"0.5136206",
"0.5134165",
"0.5129948",
"0.5105046",
"0.5085043",
"0.5083824",
"0.50725913",
"0.5069007",
"0.504954",
"0.50494796",
"0.50400126",
"0.50268537",
"0.49904805",
"0.49638087",
"0.49399418",
"0.49384803",
"0.4933... | 0.54793423 | 0 |
We won't initialize values in the board in here. This allows us to set the board by various methods later. | def __init__(self):
self.rows = None
self.columns = None
self.squares = None
# max is useful as a way to track range for iteration, and also as a way
# to track the maximum number in any spot.
self.max = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initBoard(self):\n pass",
"def set_board(board):",
"def initialize_board(self):\n self.board = np.zeros(shape=(BOARD_SIZE, BOARD_SIZE), dtype=np.int) # another way of defining board: [[for x in range(cm.BOARD_SIZE)] for x in range(cm.BOARD_SIZE)]\n center = int(BOARD_SIZE / 2)\n ... | [
"0.84042627",
"0.81255907",
"0.7827382",
"0.77757037",
"0.76603794",
"0.7593099",
"0.7526167",
"0.7517234",
"0.7514194",
"0.7464708",
"0.74549705",
"0.74544424",
"0.7384845",
"0.73820364",
"0.73545396",
"0.7345615",
"0.732285",
"0.7308128",
"0.7305453",
"0.73042303",
"0.72986... | 0.0 | -1 |
Calculates the Euclidean distance of multivariate time series of the same length. | def ED(X,Y): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def euclidean_distance(x1: np.ndarray, x2: np.ndarray) -> float:\n return np.sqrt(np.square(x1 - x2).sum())",
"def euclidean_distance(s1,s2): \n tmpsum = 0\n \n for index,value in enumerate(s1):\n tmpsum += (s1[index]-s2[index])**2\n \n return math.sqrt(tmpsum)",
"def dist_euclidean... | [
"0.6681572",
"0.65386665",
"0.6445761",
"0.6442041",
"0.63351816",
"0.6331959",
"0.6330316",
"0.6316178",
"0.6282366",
"0.62821025",
"0.62731445",
"0.62528145",
"0.62418395",
"0.62296194",
"0.62112737",
"0.61803675",
"0.6160056",
"0.6159171",
"0.6150553",
"0.61495095",
"0.614... | 0.0 | -1 |
Get current date and time with the format= . | def getTime(form=Constants.record_name_format):
# Get the date and time from the system
now = datetime.now()
# Format and return
return now.strftime(form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_now():\r\n now = dt.datetime.now()\r\n now_str = now.strftime(\"%d/%m %H:%M\")\r\n return now_str",
"def get_current_datetime_string ( ) :\n return get_current_datetime( ).strftime( \"%Y%m%d-%H%M%S\" )",
"def current_time():\n now = datetime.datetime.now()\n time = now.strftime(\"%Y-%m... | [
"0.8194152",
"0.7987566",
"0.7932862",
"0.79326594",
"0.79113275",
"0.7893641",
"0.78934723",
"0.78358227",
"0.7831609",
"0.7829139",
"0.7818449",
"0.78158355",
"0.7813814",
"0.78097653",
"0.775849",
"0.77103084",
"0.76516235",
"0.764516",
"0.76419735",
"0.7633488",
"0.762019... | 0.7465342 | 35 |
Check if is number. | def isNumber(number):
try:
# Try to cast the string
int(number)
# The cast was successful
return True
# The cast was unsuccessful, the string is not a number
except ValueError as err:
# Write the exception in logging
logging.exception(str(err))
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_number(self) -> bool:\n return False",
"def is_number(value):\n\n return isinstance(value, (int, long, float))",
"def ISNUMBER(value):\n return isinstance(value, numbers.Number)",
"def is_number(self,val):\n try:\n float(val)\n return True\n except ValueE... | [
"0.83748645",
"0.8357549",
"0.83331686",
"0.8269055",
"0.8266388",
"0.8216462",
"0.8212759",
"0.81497115",
"0.8141254",
"0.8037783",
"0.80337286",
"0.80125856",
"0.7990518",
"0.7987615",
"0.79799354",
"0.7952793",
"0.7945219",
"0.7936261",
"0.79353315",
"0.7902707",
"0.789953... | 0.7382923 | 62 |
Check record name. The record name must be the same as getTime() function return. | def isRecordNameValid(record):
# Split the string with the record separator ':'
splitted = record.split(':')
# There must be 5 values - year:month:day:hour:minute
if len(splitted) != 5:
# Not valid - more or less than 5 values
return False
# There are 5 values - check each one if is ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_record_name(self):\n zone = Zone('test.example.com')\n record = Record(zone, 'test-record', {'type': 'A', 'ttl': 300})\n self.assertEqual(record.name, 'test-record')",
"def check_base_filename(self, record):\n time_tuple = time.localtime()\n\n if self.file_name_format:... | [
"0.71127087",
"0.6416714",
"0.62757695",
"0.6255716",
"0.5947194",
"0.5886621",
"0.58701205",
"0.58524096",
"0.5753524",
"0.56767505",
"0.56354964",
"0.5626901",
"0.5602901",
"0.55897135",
"0.55889857",
"0.54834104",
"0.547835",
"0.54688334",
"0.54676193",
"0.54560345",
"0.54... | 0.64312017 | 1 |
Check if a record is older than value. | def olderThan(record, value=Constants.older_than):
# Check first if the record is valid
if isRecordNameValid(record):
# Get the record values and split them - year:month:day:hour:minute
splitted_record = record.split(':')
# Get the current date and time from the system and split them
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def older(self, timestamp):\r\n return self._added < timestamp",
"def match_Older(self, object, options) :\n\t\tif options.has_key(\"older\") :\n\t\t\tobjolder = self.toObject(self.__context, options[\"older\"])\n\t\t\tif objolder is not None :\n\t\t\t\tif object.bobobase_modification_time() >= objolder.b... | [
"0.71754",
"0.6400666",
"0.6392453",
"0.6271246",
"0.62259823",
"0.6223402",
"0.6223402",
"0.62114763",
"0.6195353",
"0.61886394",
"0.5976829",
"0.5961276",
"0.5923364",
"0.59210014",
"0.59175354",
"0.5868831",
"0.58493334",
"0.5846879",
"0.5807692",
"0.5804501",
"0.5777203",... | 0.79310864 | 0 |
Take the dictionary from database and return it as two lists of and . The will be a list of lists. Each region in list will have a list of records in list. | def getDataBaseLists(data, db):
# The list of regions - ex: "46 60 26 23" for region of coordinates 46.60 26.23
regions = []
# The list of lists of records - each region can have multiple records
records = []
try:
# Loop through all data in database dictionary
for reg, rec in data:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def common_blocks_records(self):\n if self.records is None:\n raise ValueError(\"\")\n records = []\n for block_name, data in self.common_blocks.items():\n cst, (start, end, strand) = data[\"locations\"][0]\n record = self.records[cst][start:end]\n i... | [
"0.5845994",
"0.5654632",
"0.55073863",
"0.5502603",
"0.5475942",
"0.54431844",
"0.54248035",
"0.5393792",
"0.53916633",
"0.52849215",
"0.52630603",
"0.52412134",
"0.5224337",
"0.5203017",
"0.51666725",
"0.5165008",
"0.5107521",
"0.50934386",
"0.506704",
"0.5066681",
"0.50605... | 0.70710075 | 0 |
Get the average weather condition from all records of a region. A region is a string (its name) representing the coordinates of it. | def calculateWeatherForEachRegion(regions, records):
if not bool(regions) or not bool(records):
return None, None
try:
weather_list = []
danger_list = []
for index in range(len(regions)):
weather, mean_weather_code = Machine_learning.getWeatherForRegion(records[index]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def region_stats(ds, mask, region_name):\n agg = ds.where(mask == arctic_mask_region[region_name]).mean(dim=['x','y'])\n if 'latitude' in agg:\n agg = agg.drop('latitude')\n if 'longitude' in agg:\n agg = agg.drop('longitude')\n return agg",
"def avg_based_on_forecast(city):\n wparam... | [
"0.6348331",
"0.6154541",
"0.6068361",
"0.59449464",
"0.5889889",
"0.5856748",
"0.5781751",
"0.5741478",
"0.56861424",
"0.5669117",
"0.56116873",
"0.55883586",
"0.55631655",
"0.5545508",
"0.53814787",
"0.5365397",
"0.5356737",
"0.5309372",
"0.5306273",
"0.5302752",
"0.5234683... | 0.618818 | 1 |
Get the index of the weather using the weather code. Weather code can be from 100 to 499. | def getWeatherIndex(code, return_if_none=Constants.return_value_index_of_weather_not_found):
# Start the index with 0
index = 0
for i in [100, 200, 300, 400]:
for j in [0, 33, 66]:
if inWeatherCodeRange(code, i + j, i + j + 33):
return index
index += 1
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_index(weather_data: dict, date: datetime) -> int:\n weather_list = weather_data['list']\n for index, weather in enumerate(weather_list):\n if weather['dt_txt'] == date.strftime('%Y-%m-%d %H:%M:%S'):\n return index\n return 0",
"def get_index(identify):\n\n ... | [
"0.66678154",
"0.62248325",
"0.61293477",
"0.59989315",
"0.5930833",
"0.58119816",
"0.57981074",
"0.57821745",
"0.5711183",
"0.5681351",
"0.5678698",
"0.5635346",
"0.56227213",
"0.5618192",
"0.561285",
"0.5601398",
"0.55593145",
"0.5548384",
"0.55290467",
"0.55117786",
"0.550... | 0.8678492 | 0 |
Check if the code is in range. | def inWeatherCodeRange(code, _min, _max):
# Example: code = 120
# _min = 0 _max = 133
# return 0 <= 120 <= 133 => true
return _min <= code <= _max | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def icd9_in_code_range(val, code_ranges):\n return any(val <= code_range[1] and val >= code_range[0] for code_range in code_ranges)",
"def isRangeValid(self) -> bool:\n ...",
"def IsInRange(self, id, start, isStartInclusive, end, isEndInclusive):\r\n if isStartInclusive == False:\r\n ... | [
"0.7484409",
"0.7367147",
"0.7140791",
"0.70511144",
"0.70411056",
"0.6920733",
"0.68506825",
"0.6842587",
"0.6837561",
"0.68176687",
"0.6816321",
"0.68019915",
"0.676852",
"0.6762765",
"0.6742773",
"0.6739405",
"0.67343843",
"0.66643924",
"0.6628126",
"0.6624612",
"0.6607039... | 0.7409259 | 1 |
Called every to check the database data. Remove invalid data. Write the calculated data. Update new data. | def checkDataBaseData(db, records, regions, data):
# Loop through all list of list of records - every region has a list of records
# The <records> list has list for each region (list of lists)
for i in range(len(regions)):
# Get the current region object from loop
region = regions.__getitem_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self):\n\t\tif self.update_check() or self.force_update:\n\t\t\tself.district_check() #pull all local data and regions\n\t\t\tself.fix() #fix data anomalies - e.g add in Bucks.\n\t\t\tself.save_all() #store a copy of the data\n\t\t\tself.ingest() #add data to models\n\t\t\tself.update_totals() #calcula... | [
"0.69099915",
"0.647808",
"0.6443949",
"0.63570875",
"0.6231783",
"0.6180875",
"0.6078408",
"0.60474265",
"0.6018188",
"0.60085803",
"0.5980333",
"0.59342647",
"0.59322685",
"0.5918742",
"0.59032136",
"0.58859277",
"0.5876542",
"0.58433986",
"0.58387524",
"0.58320487",
"0.583... | 0.55986655 | 44 |
Write the new records in the main dataframe (from Machine_learning file). The records with the same values that exists in dataframe will be ignored (no duplications). | def writeRecordsInDataframe(records):
# The list is not defined -- something was wrong
if records is None:
return
# Loop through the main list, containing the list of Record objects
for region_recs in records:
# Loop through all Record objects of each list
for record in region_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_model_output(self):\n warnings.warn(\"Please ensure that the column names of the new file accurately corresponds to the relevant column names in the exisitng file\")\n column_names_new = self.new_data.head()\n column_names_old = self.existing_data.head()\n for column_name in ... | [
"0.6713008",
"0.6275531",
"0.6157596",
"0.5832331",
"0.5825501",
"0.58015543",
"0.5790889",
"0.57429373",
"0.5720146",
"0.56158197",
"0.56148225",
"0.56103545",
"0.55689096",
"0.55660117",
"0.5495955",
"0.5441212",
"0.5425738",
"0.5421349",
"0.5405427",
"0.54010093",
"0.53962... | 0.61618674 | 2 |
Get the seconds of the string. | def getSecondsFromStringDateTime(date_time):
split_date_time = date_time.split(Constants.record_name_sep)
if len(split_date_time) == 5:
for value in split_date_time:
if not isNumber(value):
return Constants.return_value_invalid_datetime_value
result = int(split_date_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSeconds(self, s):\n duration = 0\n \n for i in s.split('-'):\n if 'h' in i: duration = duration + int(i.split('h')[0])*3600\n if 'm' in i: duration = duration + int(i.split('m')[0])*60\n if 's' in i: duration = duration + int(i.split('s')[0])\n ... | [
"0.7766101",
"0.7115368",
"0.71104825",
"0.7041365",
"0.70393634",
"0.70393634",
"0.6951356",
"0.69008636",
"0.6872411",
"0.6872411",
"0.68332404",
"0.68117046",
"0.66860545",
"0.6683153",
"0.6572782",
"0.65385103",
"0.65095",
"0.65092576",
"0.6505078",
"0.6484745",
"0.642686... | 0.58662844 | 53 |
Returns the weather string (name) from the file using the index of the weather. The weather titles are wrote in a dictionary, where the keys are the index. | def getWeatherString(index):
return Texts.weather_titles[index] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_index(index_file):\n index_dict = {}\n with open(index_file) as f:\n for line in f:\n title, path = line.strip().split()\n index_dict[title] = path\n return index_dict",
"def read_weatherstationnames(path_to_data):\n\n nr, name = np.loadtxt(os.path.join(path_to_d... | [
"0.58560216",
"0.57427657",
"0.5587316",
"0.54862076",
"0.5465274",
"0.53827",
"0.53461164",
"0.53260946",
"0.5280319",
"0.5268441",
"0.5262383",
"0.5219673",
"0.521099",
"0.51767963",
"0.51703185",
"0.51631576",
"0.5161624",
"0.51347274",
"0.5134441",
"0.5131381",
"0.5129603... | 0.7401113 | 0 |
Convert a dictionary to a list. | def convertToList(data):
try:
# Try to create a list from dictionary
result = list(data.items())
# Successfully created
# Return the list
return result
except Exception as err:
# Couldn't convert the dictionary to a list
print(err)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dictToLst(dictionary):\n keys = []\n values = []\n for key, value in dictionary.iteritems():\n keys.append(key)\n values.append(value)\n return [keys, values]",
"def dict_to_list(dict: Dict, name_key: str = \"name\", value_key: str = \"value\"):\n ... | [
"0.82195216",
"0.80905014",
"0.80083996",
"0.7971248",
"0.7794634",
"0.7763368",
"0.7755257",
"0.7734761",
"0.741443",
"0.741443",
"0.73810256",
"0.73580605",
"0.71780914",
"0.7127262",
"0.71178746",
"0.7070168",
"0.70463735",
"0.7015465",
"0.6966923",
"0.6900855",
"0.6895519... | 0.7301802 | 12 |
Randomly crops image and then scales to target size. | def _decode_and_random_crop(image_buffer, bbox, image_size):
with tf.name_scope('distorted_bounding_box_crop',
values=[image_buffer, bbox]):
sample_distorted_bounding_box = tf.image.sample_distorted_bounding_box(
tf.image.extract_jpeg_shape(image_buffer),
bounding_boxes=bbox,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def img_agu_crop(img_):\n\tscale_ = 5\n\txmin = max(0, random.randint(0, scale_))\n\tymin = max(0, random.randint(0, scale_))\n\txmax = min(img_.shape[1]-1, img_.shape[1]-random.randint(0, scale_))\n\tymax = min(img_.shape[0]-1, img_.shape[0]-random.randint(0, scale_))\n\treturn img_[ymin : ymax, xmin : xmax , : ]... | [
"0.69238734",
"0.688668",
"0.67406136",
"0.6653446",
"0.6611991",
"0.65635043",
"0.65129",
"0.64813966",
"0.6446414",
"0.6439087",
"0.6420242",
"0.64065105",
"0.6373644",
"0.63549376",
"0.6237832",
"0.6220096",
"0.61792403",
"0.61725205",
"0.6107943",
"0.6069131",
"0.6034094"... | 0.5382218 | 87 |
Crops to center of image with padding then scales to target size. | def _decode_and_center_crop(image_buffer, image_size):
shape = tf.image.extract_jpeg_shape(image_buffer)
image_height = shape[0]
image_width = shape[1]
padded_center_crop_size = tf.cast(
0.875 * tf.cast(tf.minimum(image_height, image_width), tf.float32),
tf.int32)
offset_height = ((image_height ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center_crop(image, source=(218, 178, 3), target=128):\n height, width, channel = source\n\n off_h = np.ceil((height - target) / 2).astype(int)\n off_w = np.ceil((width - target) / 2).astype(int)\n return image[off_h: off_h+target, off_w: off_w+target, :]",
"def _crop_image_and_paste(self, image, ... | [
"0.7128099",
"0.70488757",
"0.68803775",
"0.6781932",
"0.6731713",
"0.67305714",
"0.6663504",
"0.664844",
"0.6613311",
"0.6602656",
"0.6566218",
"0.65391105",
"0.65155274",
"0.64812684",
"0.6468684",
"0.6438739",
"0.6353911",
"0.632617",
"0.6314719",
"0.6305832",
"0.63000154"... | 0.58932555 | 50 |
Rescale image to [1, 1] range. | def _normalize(image):
return tf.multiply(tf.subtract(image, 0.5), 2.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rescale_image_01(image):\n # scale image to from [0, 255] to [0.0, 1.0]\n image = image.astype(np.float32)\n return image / 255",
"def rescale(self, img):\n\n if self.scale != 1:\n return imutils.resize(img, width=int(img.shape[1] * self.scale))\n else:\n return i... | [
"0.78326875",
"0.76999515",
"0.7549549",
"0.7467479",
"0.74480367",
"0.7409863",
"0.7364775",
"0.7286831",
"0.7183715",
"0.71511316",
"0.70305556",
"0.7026632",
"0.6979429",
"0.6891725",
"0.6880963",
"0.6845083",
"0.6800742",
"0.67787117",
"0.6744161",
"0.67401654",
"0.669306... | 0.0 | -1 |
Does image decoding and preprocessing. | def image_preprocessing(image_buffer, bbox, image_size, is_training):
if is_training:
image = _decode_and_random_crop(image_buffer, bbox, image_size)
image = _normalize(image)
image = tf.image.random_flip_left_right(image)
else:
image = _decode_and_center_crop(image_buffer, image_size)
image = _... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(self):\n pass",
"def process(self, image):",
"def compute_img(self):\r\n self.load_img()\r\n self.check_shape()\r\n self.convert_img()\r\n self.img_computed = True",
"def process(image):\n pass",
"def process_images(self):\n self.processed_cont... | [
"0.7315352",
"0.7302317",
"0.7068986",
"0.6870666",
"0.6806362",
"0.6737336",
"0.66996175",
"0.6657503",
"0.65969765",
"0.65701276",
"0.65510494",
"0.65479803",
"0.6521088",
"0.65128094",
"0.64939",
"0.6452522",
"0.64515615",
"0.6416641",
"0.6404622",
"0.6380717",
"0.63793856... | 0.0 | -1 |
Parse an ImageNet record from a serialized string Tensor. | def imagenet_parser(value, image_size, is_training):
keys_to_features = {
'image/encoded':
tf.FixedLenFeature((), tf.string, ''),
'image/format':
tf.FixedLenFeature((), tf.string, 'jpeg'),
'image/class/label':
tf.FixedLenFeature([], tf.int64, -1),
'image/class/tex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_record(raw_record, is_training):\n keys_to_features = {\n 'image/encoded':\n tf.FixedLenFeature((), tf.string, default_value=''),\n 'image/format':\n tf.FixedLenFeature((), tf.string, default_value='jpeg'),\n 'image/class/label':\n tf.FixedLenFeatu... | [
"0.7003186",
"0.69466406",
"0.6868156",
"0.6796544",
"0.67705315",
"0.6690875",
"0.6612416",
"0.652146",
"0.64584464",
"0.64071184",
"0.6387107",
"0.6385398",
"0.6299073",
"0.6298604",
"0.62885815",
"0.6247955",
"0.61994916",
"0.6195895",
"0.6139263",
"0.6138774",
"0.6130966"... | 0.6313274 | 12 |
Statically set the batch_size dimension. | def set_shapes(images, labels):
images.set_shape(images.get_shape().merge_with(
tf.TensorShape([batch_size, None, None, None])))
labels.set_shape(labels.get_shape().merge_with(
tf.TensorShape([batch_size])))
return images, labels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_batch_size(self, batch_size):\n self.batch_size = batch_size\n self.n_batch = math.ceil(self.n_samples / batch_size)",
"def set_batch_size(self, batch_size):\n final_sz = self.full_dataset_size % batch_size\n if not self.final_batch:\n self.dataset_size = self.full_dataset_size -... | [
"0.79235494",
"0.7797408",
"0.77408826",
"0.7675693",
"0.73949724",
"0.7355096",
"0.72564864",
"0.69373244",
"0.6932983",
"0.6832364",
"0.6790107",
"0.67524546",
"0.6734956",
"0.67191464",
"0.66851157",
"0.66851157",
"0.66851157",
"0.66851157",
"0.66447586",
"0.66447586",
"0.... | 0.0 | -1 |
Returns the number of examples in the data set. | def num_examples_per_epoch(split):
if split.lower().startswith('train'):
return 1281167
elif split.lower().startswith('validation'):
return 50000
else:
raise ValueError('Invalid split: %s' % split) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNumExamples(self):\n return self.__numExamples",
"def num_examples(self):\r\n raise NotImplementedError",
"def getSampleCount(self):\r\n return len(self._data)",
"def count_elements_in_dataset(dataset):\n return dataset.count()",
"def _number_of_samples(self):\n return len... | [
"0.7674337",
"0.7648816",
"0.75274837",
"0.7515767",
"0.7486572",
"0.7340652",
"0.7263475",
"0.72145987",
"0.7210284",
"0.71721756",
"0.7159244",
"0.71544725",
"0.714173",
"0.7136569",
"0.7095468",
"0.70904535",
"0.70807683",
"0.706733",
"0.704017",
"0.703757",
"0.703757",
... | 0.0 | -1 |
Get box regression transformation deltas (dx, dy, dw, dh) that can be used to transform the `src_boxes` into the `target_boxes`. That is, the relation ``target_boxes == self.apply_deltas(deltas, src_boxes)`` is true (unless any delta is too large and is clamped). | def get_deltas(self, src_boxes, target_boxes):
assert isinstance(src_boxes, torch.Tensor), type(src_boxes)
assert isinstance(target_boxes, torch.Tensor), type(target_boxes)
TO_REMOVE = 1 # TODO remove
src_widths = src_boxes[:, 2] - src_boxes[:, 0] + TO_REMOVE
src_heights ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_deltas(self, deltas, boxes):\r\n assert torch.isfinite(deltas).all().item(), \"Box regression deltas become infinite or NaN!\"\r\n boxes = boxes.to(deltas.dtype)\r\n\r\n TO_REMOVE = 1 # TODO remove\r\n widths = boxes[:, 2] - boxes[:, 0] + TO_REMOVE\r\n heights = boxes[... | [
"0.699108",
"0.6511962",
"0.645136",
"0.6319423",
"0.6214895",
"0.6214895",
"0.61235464",
"0.60987717",
"0.56899726",
"0.55584025",
"0.55373454",
"0.54795",
"0.54542905",
"0.54477835",
"0.5432317",
"0.54260546",
"0.537766",
"0.5244466",
"0.523219",
"0.5218577",
"0.51628095",
... | 0.84701025 | 0 |
Apply transformation `deltas` (dx, dy, dw, dh) to `boxes`. | def apply_deltas(self, deltas, boxes):
assert torch.isfinite(deltas).all().item(), "Box regression deltas become infinite or NaN!"
boxes = boxes.to(deltas.dtype)
TO_REMOVE = 1 # TODO remove
widths = boxes[:, 2] - boxes[:, 0] + TO_REMOVE
heights = boxes[:, 3] - boxes[:, 1]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_box_deltas(boxes, deltas):\n boxes = boxes.astype(np.float32)\n # Convert to y, x, h, w\n height = boxes[:, 2] - boxes[:, 0]\n width = boxes[:, 3] - boxes[:, 1]\n center_y = boxes[:, 0] + 0.5 * height\n center_x = boxes[:, 1] + 0.5 * width\n # Apply deltas\n center_y += deltas[:, ... | [
"0.7690878",
"0.7311821",
"0.7311821",
"0.6538352",
"0.6171323",
"0.59190184",
"0.5770745",
"0.5738584",
"0.57102823",
"0.5680742",
"0.56772006",
"0.56652987",
"0.56527686",
"0.562585",
"0.5600068",
"0.5577344",
"0.5559888",
"0.5343118",
"0.52774864",
"0.5238505",
"0.5183296"... | 0.6933272 | 3 |
Convert a JSON stream to a tabseparated "CSV" of concepttoconcept associations. | def convert_to_assoc(input_filename, output_filename):
out_stream = codecs.open(output_filename, 'w', encoding='utf-8')
for info in read_json_stream(input_filename):
startc = reduce_concept(info['start'])
endc = reduce_concept(info['end'])
rel = info['rel']
weight = info['we... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def people_json_to_csv(self, outfilename, fname):\n subkeys = set()\n with open(fname, 'rb') as r:\n with open(outfilename, 'wb') as w:\n # Get all properties (will use this to create the header)\n for line in r:\n try:\n ... | [
"0.6206316",
"0.6075651",
"0.5827159",
"0.57352823",
"0.56285065",
"0.55078745",
"0.54613775",
"0.5433535",
"0.5431025",
"0.5420267",
"0.53780305",
"0.5356324",
"0.5320781",
"0.5217893",
"0.5152822",
"0.5130858",
"0.51101536",
"0.5109959",
"0.505014",
"0.5041207",
"0.5038131"... | 0.5013517 | 21 |
Create model hyperparameters. Parse nondefault from given string. | def create_hparams(hparams_string=None, verbose=False):
hparams = tf.contrib.training.HParams(
################################
# Experiment Parameters #
################################
epochs=1000,
iters_per_checkpoint=1000,
iters_per_validation=1000,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_hyper_parameters(self, hp_string):\n\n hp_dict = {}\n for params in hp_string.split(','):\n hp_name = params.split(':')[0]\n hp_value =params.split(':')[1]\n try: hp_value = int(hp_value)\n except ValueError: hp_value = float(hp_value)\n ... | [
"0.62610024",
"0.597264",
"0.5869631",
"0.55946445",
"0.5581092",
"0.5527914",
"0.5526985",
"0.53285867",
"0.53260046",
"0.5311576",
"0.52976143",
"0.52973396",
"0.52916193",
"0.5237482",
"0.5237394",
"0.52253926",
"0.51872045",
"0.5182307",
"0.51735324",
"0.51575536",
"0.514... | 0.49683392 | 41 |
Load all test cases and return a unittest.TestSuite object. | def load_tests(loader, filter):
suite = unittest.TestSuite()
for r, d, f in os.walk(test_path):
module_path = os.path.relpath(r, os.path.dirname(test_path)).replace(os.path.sep, ".")
for file in f:
filename, ext = os.path.splitext(file)
if ext == ".py" and not file.starts... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def suite():\n\tts = unittest.TestSuite()\n\tfor test_module in __all__:\n\t\tm = importlib.import_module(\"pyroclast.test.\" + test_module)\n\t\tfor n in dir(m):\n\t\t\tc = getattr(m, n)\n\t\t\tif is_test_case(c):\n\t\t\t\ts = unittest.TestLoader().loadTestsFromTestCase(c)\n\t\t\t\tts.addTests(s)\n\treturn ts",
... | [
"0.8478419",
"0.8108045",
"0.80656457",
"0.80470455",
"0.8037982",
"0.8037982",
"0.79625636",
"0.7948463",
"0.7787993",
"0.774353",
"0.77031124",
"0.768088",
"0.7679084",
"0.76632",
"0.7583168",
"0.75241446",
"0.7513062",
"0.75110626",
"0.7492876",
"0.7442735",
"0.7425314",
... | 0.6891633 | 56 |
Convert value and error to string in LateX. | def val2str(s, serr):
vals = []
for v, verr in zip(s, serr):
if np.isnan(v) or np.isnan(verr):
vals.append(r"--")
elif np.log10(verr) < 1:
sigfig = -int(np.floor(np.log10(verr)))
newerr = np.around(verr, sigfig)
if newerr == np.power(10., -sigfig)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error_string(value: float, error: float, units: str = None, normalise: bool = True):#TODO: sort normalisation for value\n if normalise:#TODO: this dosn't normalise the value it just does the error\n error = sig_fig(error, 1)\n\n if units is None:\n return \"{} \\u00B1 {}\".format(value, flo... | [
"0.7160076",
"0.70478255",
"0.6800622",
"0.6579564",
"0.65621626",
"0.64962274",
"0.6461397",
"0.6456456",
"0.64154863",
"0.6332837",
"0.6320989",
"0.6313117",
"0.63117963",
"0.63026834",
"0.6295734",
"0.6252095",
"0.6219286",
"0.61679935",
"0.61673594",
"0.61670315",
"0.6156... | 0.588954 | 60 |
return parsed xml tag | def listup_all_programs(self):
with urllib.request.urlopen(self._request) as response:
XmlData = response.read()
root = ET.fromstring(XmlData)
for child in root:
for title in child.iter("title"):
yield title.text.replace("\u3000","")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tag_name(self, xml):\r\n tag = etree.fromstring(xml).tag\r\n return tag",
"def parsexml(self):\n raise NotImplementedError",
"def parse(k):\r\n return xml_object.xpath(k)[0]",
"def parse(k):\r\n return xml_object.xpath(k)[0]",
"def parseXML(self, xml):\n ... | [
"0.68485546",
"0.6773583",
"0.67726684",
"0.67726684",
"0.6668718",
"0.66462964",
"0.6591409",
"0.6402723",
"0.63820267",
"0.63488346",
"0.63284",
"0.6302398",
"0.6082791",
"0.6082791",
"0.60371417",
"0.6022387",
"0.60149926",
"0.5995002",
"0.59925175",
"0.59566605",
"0.59175... | 0.0 | -1 |
Reconstruct file sequence of objects from index, sorted by absolute position | def inspect(filename):
bfile = open(filename, 'rb')
bdata = bfile.read()
bfile.close()
doc = loads(bdata)
file_seq = []
second = None
for ver, snapshot in enumerate(doc.index):
nb_obj = len(snapshot)
cache = nb_obj * [None]
mini_index = nb_obj * [None]
for i i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indexed(filename):\n\n with tempfile.NamedTemporaryFile() as tmp:\n with gzip.open(filename, \"r\") as raw:\n SeqIO.write(corrected_records(raw), tmp, \"fasta\")\n\n tmp.flush()\n yield SeqIO.index(tmp.name, \"fasta\")",
"def sort_index(self):\n def s(t):\n ... | [
"0.5764997",
"0.572877",
"0.56066453",
"0.5589324",
"0.55742806",
"0.54208404",
"0.54207265",
"0.5403319",
"0.53931236",
"0.5381334",
"0.5358659",
"0.53422064",
"0.5331138",
"0.5320528",
"0.528979",
"0.52894425",
"0.52819306",
"0.5266695",
"0.5228879",
"0.5205095",
"0.5189061... | 0.60294557 | 0 |
Given a list of items with name, value and weight. Return the optimal value with total weight <= allowed weight and list of picked items. | def knapsack(W, items):
n = len(items)
k = [[0 for x in range(W+1)] for x in range(n+1)]
for i in range(n+1):
for w in range(W+1):
if i == 0 or w == 0:
k[i][w] = 0
elif items[i-1][2] <= w:
k[i][w] = max(items[i-1][1] + k[i-1][w-items[i-1][2]]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weighted_choice(items):\n weight_total = sum((item[1] for item in items))\n n = random.uniform(0, weight_total)\n for item, weight in items:\n if n < weight:\n return item\n n = n - weight\n return item",
"def weighted_choice(items: List[Tuple[str, float]]) -> str:\r\n total_weight = sum(it... | [
"0.7539636",
"0.7514603",
"0.74942696",
"0.7100174",
"0.7095652",
"0.70954",
"0.6999063",
"0.69927824",
"0.6953054",
"0.6947716",
"0.69220656",
"0.6871103",
"0.68582654",
"0.68159413",
"0.68074834",
"0.67640036",
"0.67107743",
"0.6702032",
"0.6597879",
"0.6596981",
"0.6595855... | 0.6240748 | 36 |
Add element e to the back of the queue | def enqueue(self,e): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push_back(self, e):\n if(self.size_ >= self.capacity_):#If our Deque is full we need to resize it first\n self.resize_back()\n self.back_+=1\n self.data_[self.back_]= e\n self.size_+=1\n #print(\"case 1\")\n elif (self.front_ == -1 and self.s... | [
"0.78046787",
"0.7583146",
"0.7390687",
"0.72610795",
"0.7176424",
"0.7175298",
"0.7008927",
"0.69792056",
"0.68699765",
"0.68680924",
"0.68505114",
"0.68476194",
"0.6812599",
"0.6803687",
"0.6799105",
"0.6699544",
"0.66798687",
"0.6613747",
"0.6572156",
"0.65694535",
"0.6523... | 0.7152605 | 6 |
Remove and return the element at the end of the queue Raise Empty exception if the queue is empty | def dequeue(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop(self):\n if self._size > 0:\n elem = self.first.data\n self.first = self.first.next\n self._size = self._size - 1\n return elem\n \n raise IndexError('The queue is empty! ')",
"def remove(self) -> T:\n if not self.is_empty():\n ... | [
"0.8022507",
"0.7990784",
"0.79863566",
"0.7874401",
"0.78543675",
"0.7854198",
"0.7853462",
"0.7846237",
"0.7837136",
"0.78317785",
"0.78260535",
"0.78231287",
"0.779543",
"0.77750546",
"0.7771193",
"0.77538985",
"0.7703734",
"0.76770043",
"0.76745313",
"0.7670734",
"0.76650... | 0.0 | -1 |
Return(but do not remove) the first element of the queue Raise Empty exception if the queue is empty | def first(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first(self):\r\n if self.is_empty():\r\n raise Empty(\"Queue is empty\")\r\n return self._head._element",
"def first(self):\n\t\tif self.is_empty():\n\t\t\traise Empty('Queue is empty')\n\t\treturn self._head._element",
"def first(self):\n if self.is_empty():\n ra... | [
"0.81999797",
"0.81825745",
"0.79937387",
"0.7902844",
"0.790266",
"0.7881833",
"0.7812879",
"0.77918804",
"0.7773757",
"0.7751808",
"0.75177455",
"0.75161946",
"0.7513576",
"0.75060105",
"0.7501084",
"0.74900395",
"0.748522",
"0.74548346",
"0.7403902",
"0.73623663",
"0.73067... | 0.0 | -1 |
Return the total number of elements in the stack. | def __len__(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size(self): #returns the size or number of items in the stack\n if self.is_empty():\n return 0\n else:\n return self.num_items",
"def size(self):\n return self.N # Number of items in the stack",
"def size(self):\n return len(self.stack)",
"... | [
"0.8385018",
"0.8324536",
"0.82126945",
"0.81617856",
"0.8129431",
"0.8096499",
"0.8096499",
"0.77489895",
"0.7717348",
"0.7416412",
"0.74085087",
"0.72057086",
"0.70385385",
"0.69653875",
"0.6932348",
"0.6904429",
"0.68893206",
"0.68893206",
"0.6885125",
"0.68705064",
"0.686... | 0.0 | -1 |
Return True if the tree is empty. | def is_empty(self):
return len(self) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_empty(self):\n if self.root == None:\n return True\n return False",
"def empty(self) -> bool:\n return True if self.root is None else False",
"def is_empty(self):\n return self.__root == None",
"def is_empty(self):\n return self.root is None",
"def is_em... | [
"0.8936684",
"0.87890667",
"0.8788178",
"0.8782837",
"0.8782837",
"0.83093023",
"0.82048905",
"0.8137257",
"0.81060463",
"0.7952423",
"0.7952423",
"0.7916874",
"0.7916541",
"0.7911159",
"0.79048574",
"0.79016674",
"0.78991055",
"0.7893206",
"0.7882776",
"0.7882776",
"0.787793... | 0.77148354 | 94 |
Makes PyTorch DataLoaders for extraction. | def get_extract_dataloaders(data_path, image_shape=None, batch_size=1, num_workers=0):
if image_shape is None and batch_size != 1:
import warnings
batch_size = 1
warnings.warn('Since you wish to use variable image sizes, setting batch_size=1.'
'\nDealing with variable inputs is not trivial.', RuntimeWarni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)",
"def dataloaders():\n # train data path\n data_train = '../dataset/train/'\n # set transformations\n train_transforms = transforms.Compose([\n ... | [
"0.7184117",
"0.7172089",
"0.7103049",
"0.70585805",
"0.7023571",
"0.69776785",
"0.6923268",
"0.6862011",
"0.6858555",
"0.6841408",
"0.6834583",
"0.68124217",
"0.6796105",
"0.6769847",
"0.6736129",
"0.6662132",
"0.664149",
"0.6600465",
"0.65924054",
"0.65893775",
"0.65822655"... | 0.0 | -1 |
The images go through this pipeline before extraction. | def get_transform(image_shape=None):
from torchvision import transforms
normalization = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
transform = [transforms.ToTensor(), transforms.Normalize(**normalization)]
if image_shape is not None:
if isinstance(image_shape, int): image_shape = (image_shape,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def extractimages(self, ctx):\n if self.extract_images_running:\n await ctx.send(inline('Extract images already running'))\n return\n\n event_loop = asyncio.get_event_loop()\n running_load = event_loop.run_in_executor(self.executor, self.do_extract_images)\n\n ... | [
"0.7110638",
"0.6889193",
"0.67962146",
"0.67683077",
"0.6659005",
"0.6605889",
"0.65992206",
"0.64040875",
"0.63980496",
"0.6391139",
"0.6390637",
"0.6346538",
"0.62487423",
"0.6236488",
"0.62193924",
"0.6202339",
"0.619318",
"0.6191987",
"0.61843616",
"0.6183965",
"0.614803... | 0.0 | -1 |
Makes PyTorch DataLoaders for training. | def get_training_dataloaders(data_path, caption_idx, shuffle):
return {mode: _get_training_dataloader(data_path / mode, caption_idx, shuffle) for mode in ('train', 'val')} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_train, **self.dl_kwargs)",
"def _init_train_loader(self):\n # Choose the right dataset type\n if self.config_args[\"num_members\"] > 1:\n class_dataset_wrapper = d... | [
"0.7816402",
"0.76506495",
"0.7545887",
"0.7512149",
"0.7501321",
"0.7258058",
"0.7178917",
"0.7167783",
"0.71297485",
"0.71099246",
"0.7090041",
"0.7088098",
"0.70586234",
"0.70514125",
"0.7021508",
"0.70021164",
"0.698864",
"0.6976145",
"0.696673",
"0.69660807",
"0.6953139"... | 0.0 | -1 |
The COCO Dataset that has the extracted features and the corresponding captions. The fundamental difference between this and the CocoCaptions class in torchvision.datasets | def __init__(self, root, annFile, feature_file, caption_idx):
import torch
super().__init__(root, annFile)
self.features = torch.load(feature_file, map_location='cpu')
self.caption_idx = caption_idx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_coco_dataset():\n ds = AttrDict()\n classes = [\n '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\n 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\n 'sheep', ... | [
"0.7193297",
"0.684184",
"0.62688726",
"0.62399566",
"0.62046766",
"0.6088953",
"0.5980426",
"0.597014",
"0.5891977",
"0.58210665",
"0.5746802",
"0.5740212",
"0.57296383",
"0.56720185",
"0.56706953",
"0.5666726",
"0.562342",
"0.55948806",
"0.5585627",
"0.5570578",
"0.55512846... | 0.0 | -1 |
Set up babybuddy select entities for feeding and diaper change. | async def async_setup_entry(
hass: HomeAssistant,
entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
async_add_entities([BabyBuddySelect(entity) for entity in SELECTOR_TYPES]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pick_up(self):",
"def __init__(self, entity_description: BabyBuddySelectDescription) -> None:\n self._attr_unique_id = entity_description.key\n self._attr_options = entity_description.options\n self.entity_description = entity_description\n self._attr_current_option = None",
"de... | [
"0.5553327",
"0.5431278",
"0.533167",
"0.532243",
"0.5231893",
"0.51908284",
"0.51467603",
"0.5063082",
"0.5009682",
"0.49979505",
"0.49765864",
"0.49712533",
"0.49513426",
"0.49345365",
"0.49092245",
"0.48547655",
"0.48247764",
"0.48069692",
"0.47705767",
"0.47544596",
"0.47... | 0.65842026 | 0 |
Initialize the Babybuddy select entity. | def __init__(self, entity_description: BabyBuddySelectDescription) -> None:
self._attr_unique_id = entity_description.key
self._attr_options = entity_description.options
self.entity_description = entity_description
self._attr_current_option = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n super(ChoiceFieldType, self).__init__(*args, **kwargs)\n\n self.choices = self.get_field_info_key('choices')",
"def init(self):\n # IMPORTANT: create a new gob database model entry for this object\n self.gobify()",
"def initialize(self):\n\n ... | [
"0.6092637",
"0.60616356",
"0.58840305",
"0.5762157",
"0.57082224",
"0.56701213",
"0.5660541",
"0.5595342",
"0.55679876",
"0.55628157",
"0.5492031",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54903996",
"0.54722273",
"... | 0.7361549 | 0 |
Restore last state when added. | async def async_added_to_hass(self) -> None:
last_state = await self.async_get_last_state()
if last_state:
self._attr_current_option = last_state.state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restore(self):\n raise NotImplementedError",
"def restore_last_undo_point(self):\n self.unload()",
"def restore(self):\n self.igate.restore()\n self.fgate.restore()\n self.ogate.restore()\n super(LSTM, self).restore()",
"def revert_state(self):\n if self.p... | [
"0.7342478",
"0.7273116",
"0.70957226",
"0.7068361",
"0.7049309",
"0.69999045",
"0.69320804",
"0.6918523",
"0.6859195",
"0.6853133",
"0.6844502",
"0.68230796",
"0.67886513",
"0.67182875",
"0.67166734",
"0.6713994",
"0.6663462",
"0.6641381",
"0.6621431",
"0.65914077",
"0.65838... | 0.0 | -1 |
Update the current selected option. | async def async_select_option(self, option: str) -> None:
if option not in self.options:
raise ValueError(f"Invalid option for {self.entity_id}: {option}")
self._attr_current_option = option
self.async_write_ha_state() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_selection(self):\n raise NotImplementedError",
"def update_view(self, selected):\n pass",
"def changeCurrentValue(self):\n if(self.dropDown.currentIndex() >= 0):\n self.__currentValue = self.dropDown.currentIndex()\n\n if(self.__functionToInvoke != None):\n... | [
"0.72777873",
"0.6968837",
"0.66772693",
"0.6658478",
"0.6596658",
"0.6303981",
"0.62901753",
"0.6194861",
"0.61828315",
"0.6148036",
"0.6134859",
"0.6079361",
"0.6030761",
"0.602593",
"0.601563",
"0.60150194",
"0.60019153",
"0.5996462",
"0.5994246",
"0.5967078",
"0.59609795"... | 0.0 | -1 |
You do not need to change this method, but you're welcome to. getAction chooses among the best options according to the evaluation function. Just like in the previous project, getAction takes a GameState and returns some Directions.X for some X in the set {North, South, West, East, Stop} | def getAction(self, gameState):
# Collect legal moves and successor states
legalMoves = gameState.getLegalActions()
# Choose one of the best actions
scores = [self.evaluationFunction(gameState, action) for action in legalMoves]
bestScore = max(scores)
bestIndices = [index for index in range(len... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n \n # The best_move is basically a pair with the evaluation value and action name\n best_move = self.minimax(gameState, 0 , 0)\n \n # Returning best action move\n return best_move[1]\n \n # ... | [
"0.73985434",
"0.73298985",
"0.73247117",
"0.7301311",
"0.72974575",
"0.7279284",
"0.7243445",
"0.72334325",
"0.722034",
"0.72193974",
"0.7208082",
"0.7161462",
"0.716105",
"0.71267086",
"0.71228415",
"0.7121531",
"0.7100198",
"0.7100198",
"0.7088234",
"0.7043927",
"0.7043721... | 0.7037261 | 25 |
Design a better evaluation function here. The evaluation function takes in the current and proposed successor GameStates (pacman.py) and returns a number, where higher numbers are better. The code below extracts some useful information from the state, like the remaining food (newFood) and Pacman position after moving (... | def evaluationFunction(self, currentGameState, action):
# Useful information you can extract from a GameState (pacman.py)
successorGameState = currentGameState.generatePacmanSuccessor(action)
newPos = successorGameState.getPacmanPosition()
newFood = successorGameState.getFood()
newGhostStates = succ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n oldFood = currentGameState.getFood()\n newGhostState... | [
"0.85765415",
"0.8431476",
"0.837736",
"0.8358476",
"0.83099616",
"0.83093965",
"0.8276818",
"0.82762575",
"0.82379407",
"0.82248855",
"0.81835407",
"0.81680053",
"0.81561214",
"0.8144599",
"0.8134267",
"0.8133093",
"0.813167",
"0.8119687",
"0.8119089",
"0.8108717",
"0.809037... | 0.8116712 | 19 |
This default evaluation function just returns the score of the state. The score is the same one displayed in the Pacman GUI. This evaluation function is meant for use with adversarial search agents (not reflex agents). | def scoreEvaluationFunction(currentGameState):
return currentGameState.getScore() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scoreEvaluationFunction(gameState):\n return gameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\r\n return currentGameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\n ... | [
"0.8054703",
"0.75815105",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
"0.7554428",
... | 0.7593981 | 5 |
Returns the minimax action from the current gameState using self.depth and self.evaluationFunction. Here are some method calls that might be useful when implementing minimax. | def getAction(self, gameState):
"*** YOUR CODE HERE ***"
legalActions = gameState.getLegalActions(0)
legalActions.remove('Stop')
besctaction = Directions.STOP
score = float("-inf")
for action in legalActions:
child = gameState.generateSuccessor(0, action)
newscore = max(score, m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAction(self, gameState: GameState):\n _max = float(\"-inf\")\n action = None\n for move in gameState.getLegalActions(0):\n util = minimax(self.evaluationFunction, 1, 0,\n gameState.generateSuccessor(0, move), self.depth)\n if util > _max o... | [
"0.7805281",
"0.7533675",
"0.75330496",
"0.75187063",
"0.74377435",
"0.74094397",
"0.740521",
"0.7399833",
"0.7341552",
"0.7264349",
"0.7261286",
"0.7251706",
"0.71673775",
"0.71428883",
"0.70934355",
"0.70878756",
"0.70714605",
"0.70707184",
"0.7041809",
"0.70143723",
"0.699... | 0.6830117 | 39 |
Returns the minimax action using self.depth and self.evaluationFunction | def getAction(self, gameState):
"*** YOUR CODE HERE ***"
legalActions = gameState.getLegalActions(0)
legalActions.remove('Stop')
alpha = float("-inf")
beta = float("inf")
besctaction = Directions.STOP
score = float("-inf")
for action in legalActions:
child = gameState.generate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAction(self, gameState: GameState):\n _max = float(\"-inf\")\n action = None\n for move in gameState.getLegalActions(0):\n util = minimax(self.evaluationFunction, 1, 0,\n gameState.generateSuccessor(0, move), self.depth)\n if util > _max o... | [
"0.7482665",
"0.7383559",
"0.71806973",
"0.7110041",
"0.70884514",
"0.70694935",
"0.70683014",
"0.7048308",
"0.70055133",
"0.69651455",
"0.69642085",
"0.69604385",
"0.6945924",
"0.68998593",
"0.6895832",
"0.688605",
"0.6826282",
"0.6767276",
"0.6758028",
"0.6751636",
"0.67054... | 0.0 | -1 |
Returns the expectimax action using self.depth and self.evaluationFunction All ghosts should be modeled as choosing uniformly at random from their legal moves. | def getAction(self, gameState):
"*** YOUR CODE HERE ***"
legalActions = gameState.getLegalActions(0)
legalActions.remove('Stop')
besctaction = Directions.STOP
score = float("-inf")
for action in legalActions:
child = gameState.generateSuccessor(0, action)
newscore = max(score, e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAction(self, gameState):\n def Minimaxer(sucGameState, depth, curAgent, numGhosts):\n if sucGameState.isWin() or sucGameState.isLose():\n return self.evaluationFunction(sucGameState)\n if depth == 0:\n return self.evaluationFunction(sucGameState)\n ... | [
"0.7490743",
"0.7464548",
"0.7464233",
"0.74424946",
"0.74306947",
"0.74106455",
"0.7387545",
"0.73767996",
"0.73012114",
"0.7255859",
"0.72178525",
"0.7213856",
"0.72098166",
"0.7205306",
"0.7187404",
"0.7172729",
"0.716867",
"0.7158275",
"0.7151114",
"0.7147327",
"0.7108024... | 0.6561642 | 83 |
Your extreme ghosthunting, pelletnabbing, foodgobbling, unstoppable evaluation function (question 5). | def betterEvaluationFunction(currentGameState):
"*** YOUR CODE HERE ***"
pos = currentGameState.getPacmanPosition()
score1 = currentGameState.getScore()
Food = currentGameState.getFood()
foodlist = list(Food.asList())
dist = []
score2 = 0
if len(foodlist) != 0:
for food in foodlist:
dist.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def betterEvaluationFunction(currentGameState):\n \"*** YOUR CODE HERE ***\"\n next_pacman_position = currentGameState.getPacmanPosition()\n next_food = [food for food in currentGameState.getFood().asList() if food]\n next_ghosts_states = currentGameState.getGhostStates()\n next_ghosts_scared_timers... | [
"0.73445916",
"0.7206647",
"0.7201176",
"0.7178031",
"0.71601456",
"0.71585554",
"0.7139828",
"0.71391654",
"0.71090144",
"0.7050158",
"0.70279783",
"0.7020684",
"0.70147085",
"0.69905776",
"0.69860834",
"0.6977059",
"0.6974314",
"0.69628817",
"0.6937865",
"0.6931714",
"0.692... | 0.72288746 | 1 |
Returns an action. You can use any method you want and search to any depth you want. Just remember that the minicontest is timed, so you have to trade off speed and computation. Ghosts don't behave randomly anymore, but they aren't perfect either they'll usually just make a beeline straight towards Pacman (or away from... | def getAction(self, gameState):
"*** YOUR CODE HERE ***"
util.raiseNotDefined() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAction(self, gameState):\n return self.minimax(gameState, self.depth, 0)",
"def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n def minMaxHelper(gameState, deepness, agent):\n if agent >= gameState.getNumAgents():\n agent = 0\n deepness ... | [
"0.6819004",
"0.6791531",
"0.67102724",
"0.6693187",
"0.6638914",
"0.6618938",
"0.6614788",
"0.66092956",
"0.6582351",
"0.6573214",
"0.6567215",
"0.65612036",
"0.65345424",
"0.6523664",
"0.65080947",
"0.6482032",
"0.64712214",
"0.64578146",
"0.64441186",
"0.6432857",
"0.64244... | 0.0 | -1 |
Returns the timezone as an hour/minute offset in the form "+HHMM" or "HHMM". | def _format_timezone_offset(converted_time):
# Windows treats %z in the format string as %Z, so we compute the hour/minute offset
# manually.
if converted_time.tm_isdst == 1 and time.daylight:
utc_offset_secs = time.altzone
else:
utc_offset_secs = time.timezone
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_timezone_offset():\n timezone = get_localzone()\n offset_minutes = timezone.utcoffset(datetime.datetime.now()).total_seconds() // SECONDS_IN_MINUTE\n return parse_int(offset_minutes)",
"def get_fixed_timezone(offset):\n if isinstance(offset, timedelta):\n offset = offset.total_seconds(... | [
"0.7235955",
"0.67034847",
"0.6700693",
"0.66685057",
"0.6638393",
"0.66248596",
"0.6586953",
"0.6572008",
"0.65655357",
"0.64952195",
"0.64378357",
"0.6383715",
"0.6347221",
"0.63229084",
"0.6319341",
"0.62767327",
"0.62652457",
"0.6222787",
"0.62033075",
"0.61946964",
"0.61... | 0.71226084 | 1 |
Returns the executable path of a py_binary. This returns the executable path of a py_binary that is in another Bazel target's data dependencies. On Linux/macOS, the path and __file__ has the same root directory. On Windows, bazel builds an .exe file and we need to use the MANIFEST file the location the actual binary. | def get_executable_path(py_binary_name):
if os.name == 'nt':
py_binary_name += '.exe'
manifest_file = os.path.join(FLAGS.test_srcdir, 'MANIFEST')
workspace_name = os.environ['TEST_WORKSPACE']
manifest_entry = '{}/{}'.format(workspace_name, py_binary_name)
with open(manifest_file, 'r') as manifest... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_exec_path(self):\n bin_name = 'test_hint_time'\n # Look for in place build\n script_dir = os.path.dirname(os.path.realpath(__file__))\n bin_path = os.path.join(script_dir, '.libs', bin_name)\n if not os.path.exists(bin_path):\n # Look for out of place build fro... | [
"0.70611286",
"0.69784385",
"0.67366946",
"0.6704762",
"0.6694283",
"0.6644212",
"0.66146284",
"0.65615684",
"0.6532665",
"0.6474591",
"0.6446678",
"0.6406514",
"0.6392812",
"0.6340146",
"0.632116",
"0.6318753",
"0.6304325",
"0.6299277",
"0.62937576",
"0.62814784",
"0.628113"... | 0.80735695 | 0 |
Enumerates videos from the original dataset. | def get_seq(data_dir, dname):
# Get list of video files
data_dir = os.path.join(data_dir, 'softmotion30_44k', dname)
filenames = gfile.Glob(os.path.join(data_dir, '*'))
if not filenames:
raise RuntimeError('No data files found.')
# Enumerates videos (filename, index of file, list of images)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ordinarilyGenerateFrames(self):\n for name, video in self._videos.items():\n print(f'Reading:{name}...')\n success, frame = video.read()\n while self.alive and success:\n yield frame\n success, frame = video.read()\n print('Reading Co... | [
"0.62048256",
"0.6199403",
"0.6159387",
"0.6045818",
"0.60281456",
"0.600516",
"0.5924626",
"0.59033257",
"0.5884817",
"0.587601",
"0.5873562",
"0.5806949",
"0.57932585",
"0.57638246",
"0.57544434",
"0.57515126",
"0.5748793",
"0.5737944",
"0.57259256",
"0.5701706",
"0.5696077... | 0.57019675 | 19 |
Preprocesses videos from the BAIR dataset in the input directory. Processed videos are saved in separate directories; each video frame is extracted in a .png file. | def convert_data(data_dir, dname):
# Get videos from the original dataset
seq_generator = get_seq(data_dir, dname)
# Process videos
for n, (f, k, seq) in enumerate(seq_generator):
# Create a directory for the video
f = os.path.splitext(os.path.basename(f))[0]
dirname = os.path.jo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precompute_numpy_video_files(self):\n videos = self.get_videos(self.not_collisions, 1) \\\n | chain_with(self.get_videos(self.collisions, 0)) \\\n | where(lambda f: not isfile(self.get_numpy_filename(f[1])))\n\n for v in videos:\n path = self.get_numpy... | [
"0.69390935",
"0.6890178",
"0.66392815",
"0.66133606",
"0.66133606",
"0.65581614",
"0.6554764",
"0.651356",
"0.64366",
"0.6430591",
"0.6429932",
"0.6412027",
"0.6364831",
"0.63648057",
"0.6340141",
"0.63109636",
"0.6306809",
"0.62747556",
"0.62535834",
"0.6226402",
"0.6222001... | 0.6655314 | 2 |
start threads and idle handler (update_ui) for callback dispatching | def start_thread():
global gIt, gOt, gRunning
gRunning = True
gIt = Thread(target = input_thread)
gIt.start()
gOt = Thread(target = output_thread)
gOt.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polling( self, ):\r\n \"\"\"\r\n queue protocol, data = ( action, function, function_args )\r\n action = a string\r\n function = a function\r\n function_args = arguments to function which will be called function( function_args ) This should be a tuple... | [
"0.64265764",
"0.64098173",
"0.6402181",
"0.6346647",
"0.6325017",
"0.62540954",
"0.6195212",
"0.6173926",
"0.61703956",
"0.6163969",
"0.6110663",
"0.6080352",
"0.6075288",
"0.6012084",
"0.6007064",
"0.6005521",
"0.5975944",
"0.59583676",
"0.5932319",
"0.59218866",
"0.5921886... | 0.0 | -1 |
output thread function for getting inference results from Movidius NCS running graph specific post processing of inference result queuing the results for main thread callbacks | def output_thread():
global gRunning
try:
while gRunning:
try:
inference_result, user_data = gGraph.GetResult()
print (postprocess(inference_result))
#print(user_data)
# gUpdateq.put((postprocess(inference_result), user_data))
except KeyError:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inference(self):\n for i in range(len(self.nodes)):\n for j in range(len(self.nodes[i])):\n self.pipes[i][j].send(\"inference\")\n \n ## wait for the finalization to be completed\n for i in range(len(self.nodes)):\n for j in range(len(sel... | [
"0.7058547",
"0.6675076",
"0.63437945",
"0.61934835",
"0.60070735",
"0.59801656",
"0.59527904",
"0.59318507",
"0.59288776",
"0.5920665",
"0.5890297",
"0.5875667",
"0.58533645",
"0.58358604",
"0.5832103",
"0.5815753",
"0.58027357",
"0.5774473",
"0.5759439",
"0.57552284",
"0.57... | 0.75303006 | 0 |
get a preprocessed frame to be pushed to the graph | def get_sample():
global counter
counter = counter + 1
# capture frames from the camera;
frame=picamera.array.PiRGBArray(camera)
camera.capture(frame, 'bgr', use_video_port=True)
# grab the raw NumPy array representing the image, then initialize the timestamp
# and occupied/unoccupied tex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_frame(self, frame):\n\t\treturn frame",
"def preprocess_frame(self, frame):\n state = torch.Tensor(frame)\n return gpuify(state, self.gpu_id)",
"def frame_pre_process(self, frame):\n assert len(frame.shape) == 3, \\\n \"Expected input frame in (H, W, C) format propos... | [
"0.7119568",
"0.6751297",
"0.67064327",
"0.6306198",
"0.6134869",
"0.6000026",
"0.5978636",
"0.59715766",
"0.59634686",
"0.5920147",
"0.5843046",
"0.58087265",
"0.57635844",
"0.5748316",
"0.5747666",
"0.57154405",
"0.5696114",
"0.56948686",
"0.5672049",
"0.56586546",
"0.56557... | 0.5511134 | 29 |
preprocess a video frame input in the format specified by rawinputformat() method output in the format required by the graph | def preprocess(img):
dim=(227,227)
resize_width = 224
resize_height = 224
img=cv2.resize(img,dim)
#img=cv2.normalize(img,None,alpha=0,beta=1,norm_type=cv2.NORM_MINMAX,dtype=cv2.CV_32F)
img = img.astype(numpy.float32)
#Preprocess image changing the RGB pixel values to the value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_video(input_file, output_file):\n # video = VideoFileClip(input_file).subclip(40,44) # from 38s to 46s\n video = VideoFileClip(input_file)\n annotated_video = video.fl_image(process_pipeline)\n annotated_video.write_videofile(output_file, audio=False)",
"def process_video(input_file, outp... | [
"0.660406",
"0.660406",
"0.6251925",
"0.62162185",
"0.61449426",
"0.6016263",
"0.59658784",
"0.59191173",
"0.5898252",
"0.58571494",
"0.58359957",
"0.58204484",
"0.5807554",
"0.57724744",
"0.5767315",
"0.57514405",
"0.5736507",
"0.57330585",
"0.5650401",
"0.5630842",
"0.56126... | 0.5234842 | 60 |
postprocess an inference result input in the format produced by the graph output in a human readable format | def postprocess(output):
text=''
order = output.argsort()[::-1][:6]
# print('\n------- predictions --------')
for i in range(1):
# print ('prediction ' + str(i) + ' (probability ' + str(output[order[i]]*100) + '%) is ' + gNetworkCategories[order[i]] + ' label index is: ' + str(order[i]) )
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def postprocess(self, inference_output):\n logger.info(inference_output)\n return inference_output",
"def inference():\n if request.method == \"POST\":\n data = request.json #\n src_img = np.array(data[\"src\"]).astype(np.uint8) # Pars... | [
"0.74513173",
"0.63642395",
"0.63103646",
"0.6209664",
"0.6149981",
"0.61384505",
"0.61171323",
"0.6045562",
"0.6036395",
"0.59836096",
"0.5979635",
"0.58721167",
"0.5831833",
"0.58255285",
"0.5821647",
"0.58004344",
"0.5789193",
"0.5777875",
"0.5736013",
"0.572711",
"0.57234... | 0.6112819 | 7 |
Newton's Method. f(y) = y2 x = 0 f(y1) = f(y0) + dy f'(y0) = y0 y0 x + (y1 y0) 2 y0 = 0 y1 = (y0 + x / y0) / 2 | def mySqrt(self, x: int) -> int:
if x == 0:
return 0
d = 0.1
y = x / 2
z = (y + x/y) / 2
e = abs(z-y)
while e > d:
y = z
z = (y + x/y) / 2
e = abs(z - y)
return int(z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def newton(f, x0, Df, tol=1e-5, maxiter=15, alpha=1.):\n raise NotImplementedError(\"Problem 1 Incomplete\")",
"def test_newton():\n\n f = lambda x: x**2 + np.sin(5*x)\n df = lambda x: 2*x + 5*np.cos(5*x)\n ddf = lambda x: 2 + 0,-25*np.sin(5*x)\n\n\n print newtonsMethod(f,df,ddf, 0, niter = 100)",... | [
"0.7441877",
"0.7211542",
"0.71977335",
"0.719035",
"0.7187115",
"0.71342146",
"0.71297497",
"0.7069365",
"0.7065893",
"0.70429343",
"0.69355184",
"0.68557405",
"0.6837517",
"0.68288064",
"0.68169826",
"0.6779649",
"0.6760478",
"0.6721544",
"0.6686242",
"0.6662009",
"0.666122... | 0.0 | -1 |
Return the pending number of messages in the queue by doing a passive Queue declare. | def __len__(self):
response = self._rpc(self._declare(True))
return response.message_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_pending(status=\"pending\", username=\"garrett.wilson\"):\n cmd = [\n \"squeue\",\n \"-u\", username,\n \"-t\", status,\n \"-h\"\n ]\n\n output = subprocess.check_output(cmd)\n output = output.decode(\"utf-8\").strip()\n\n if output == \"\":\n return 0\n\n ... | [
"0.6994661",
"0.69166964",
"0.6806728",
"0.6793772",
"0.674106",
"0.653735",
"0.65129846",
"0.64847827",
"0.64818645",
"0.6461492",
"0.63980144",
"0.63980144",
"0.6334779",
"0.6294051",
"0.62864494",
"0.6266857",
"0.6237147",
"0.620611",
"0.6205403",
"0.6193056",
"0.6183044",... | 0.56386495 | 53 |
Bind the queue to the specified exchange or routing key. | def bind(self, source, routing_key=None, arguments=None):
if hasattr(source, 'name'):
source = source.name
frame = specification.Queue.Bind(queue=self.name,
exchange=source,
routing_key=routing_key or '',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bind_queue_to_exchange(self, channel, exchange, queue_name, routing_key):\n logger.info('Binding %s to %s with %s',\n exchange, queue_name, routing_key)\n channel.queue_bind(queue=queue_name,\n exchange=exchange,\n routing_key=routing_key)",
"async def b... | [
"0.8586502",
"0.84070414",
"0.8285592",
"0.6888623",
"0.6881881",
"0.65968955",
"0.63757175",
"0.63733155",
"0.6050453",
"0.59048396",
"0.5763697",
"0.57079154",
"0.57029057",
"0.56764746",
"0.5662288",
"0.5568562",
"0.5544528",
"0.5477283",
"0.54671043",
"0.5458153",
"0.5446... | 0.73164797 | 3 |
Consumer message context manager, returns a consumer message generator. | def consumer(self, no_ack=False, prefetch=100, priority=None):
if prefetch is not None:
self.channel.prefetch_count(prefetch)
self.channel._consume(self, no_ack, priority)
self.consuming = True
yield Consumer(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n # Trigger the consumer procs to start off.\n # We will iterate till there are no more messages available\n self.size.value = 0\n self.pause.set()\n\n while True:\n self.start.set()\n try:\n # We will block for a small whi... | [
"0.6520486",
"0.64304805",
"0.6348474",
"0.6260189",
"0.6066062",
"0.59972835",
"0.5906607",
"0.5790026",
"0.57867485",
"0.57645184",
"0.5661963",
"0.5636426",
"0.5610837",
"0.5610837",
"0.56106585",
"0.55232435",
"0.5515625",
"0.54985094",
"0.5481432",
"0.5471095",
"0.546918... | 0.60765916 | 4 |
Declare the queue on the RabbitMQ channel passed into the constructor, returning the current message count for the queue and its consumer count as a tuple. | def declare(self, passive=False):
response = self._rpc(self._declare(passive))
return response.message_count, response.consumer_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_queue_msg_count1(self):\n self.queue.direct_declare(TEST_QUEUE)\n self.queue.publish(TEST_QUEUE, 'this is a test msg')\n\n msg_count = self.queue.get_queue_msg_count(TEST_QUEUE)\n assert isinstance(msg_count, int)",
"def get_pending_messages():\n global logger\n try... | [
"0.6695004",
"0.65361464",
"0.6433904",
"0.6380009",
"0.63566524",
"0.6303155",
"0.6188639",
"0.6182734",
"0.61554193",
"0.6077462",
"0.6067161",
"0.60579026",
"0.60351235",
"0.6034361",
"0.60192823",
"0.5917088",
"0.58340645",
"0.58212996",
"0.5819722",
"0.58159286",
"0.5790... | 0.6078519 | 9 |
Request a single message from RabbitMQ using the Basic.Get AMQP command. | def get(self, acknowledge=True):
self._write_frame(specification.Basic.Get(queue=self.name,
no_ack=not acknowledge))
return self.channel._get_message() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, msg):\n\n # print(\"get\")\n self.q.put(msg)",
"def rabbit_request(self, path):\n uri = self._base_uri + path\n response = requests.get(uri, auth=self._auth)\n\n if response.status_code != 200:\n raise Exception(self.error_message(response))\n re... | [
"0.6866893",
"0.68570006",
"0.63802916",
"0.6348834",
"0.6341484",
"0.61993957",
"0.61341304",
"0.6129399",
"0.61021316",
"0.5994536",
"0.5983703",
"0.59462357",
"0.5938115",
"0.59198",
"0.59198",
"0.59195334",
"0.59125274",
"0.5909593",
"0.5882313",
"0.58796036",
"0.5872847"... | 0.6481924 | 2 |
Declare a the queue as highly available, passing in a list of nodes the queue should live on. If no nodes are passed, the queue will be declared across all nodes in the cluster. | def ha_declare(self, nodes=None):
if nodes:
self._arguments['x-ha-policy'] = 'nodes'
self._arguments['x-ha-nodes'] = nodes
else:
self._arguments['x-ha-policy'] = 'all'
if 'x-ha-nodes' in self._arguments:
del self._arguments['x-ha-nodes']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def declare_queue(self):\n\n self._channel.queue_declare(queue=self._queue_name, durable=True)\n print(\"Queue declared....\")",
"def _create_queue(self):\n # Instantiate\n queue = pbs.queue(verbose=not self.quiet)\n\n if self.q == 'ember':\n # Submitting to Utah emb... | [
"0.62286747",
"0.60477805",
"0.58977777",
"0.5751411",
"0.5699497",
"0.5601299",
"0.5536529",
"0.5517704",
"0.55171967",
"0.54711384",
"0.54707986",
"0.5445398",
"0.5411856",
"0.54114914",
"0.5409894",
"0.53511775",
"0.5346529",
"0.5311034",
"0.52988267",
"0.5228136",
"0.5223... | 0.57938516 | 3 |
Purge the queue of all of its messages. | def purge(self):
self._rpc(specification.Queue.Purge()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clearQueueAll():",
"def clear_queue(self):\n while not self.queue.empty():\n self.queue.get()",
"def clear_queue(self):\n\t\t\tself.message_queue.clear()\n\t\t\treturn self.message_queue",
"def clear_messages(self):\n self.redis_client.delete(self.message_list)",
"def flush_msg... | [
"0.7505619",
"0.72489685",
"0.7197505",
"0.7081021",
"0.70500505",
"0.7026544",
"0.6947277",
"0.692343",
"0.69218075",
"0.68953866",
"0.6863806",
"0.6734934",
"0.66792786",
"0.66656256",
"0.6581635",
"0.6553705",
"0.65511155",
"0.6539296",
"0.65362954",
"0.65359545",
"0.65193... | 0.8184247 | 0 |
Unbind queue from the specified exchange where it is bound the routing key. If routing key is None, use the queue name. | def unbind(self, source, routing_key=None):
if hasattr(source, 'name'):
source = source.name
self._rpc(specification.Queue.Bind(queue=self.name,
exchange=source,
routing_key=routing_key or
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def bind(\n self,\n exchange: ExchangeParamType,\n routing_key: Optional[str] = None,\n *,\n arguments: Arguments = None,\n timeout: TimeoutType = None,\n ) -> aiormq.spec.Queue.BindOk:\n\n if routing_key is None:\n routing_key = self.name\n\n ... | [
"0.5841196",
"0.5779545",
"0.5448614",
"0.5320331",
"0.52993155",
"0.5290274",
"0.51541996",
"0.51409155",
"0.5094225",
"0.4963937",
"0.49457547",
"0.4868611",
"0.48207507",
"0.48195007",
"0.48154044",
"0.48097736",
"0.4786163",
"0.47184947",
"0.47171628",
"0.47167245",
"0.46... | 0.77533823 | 0 |
Return a specification.Queue.Declare class precomposed for the rpc method since this can be called multiple times. | def _declare(self, passive=False):
arguments = dict(self._arguments)
if self._expires:
arguments['x-expires'] = self._expires
if self._message_ttl:
arguments['x-message-ttl'] = self._message_ttl
if self._max_length:
arguments['x-max-length'] = self._ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def declare(self) -> 'Queue':\n # we are relying to this in other functions\n self._channel = await self._backend.channel()\n self.log.debug(\"Channel acquired CHANNEL%i\",\n self._channel.channel_number)\n\n if self.exchange:\n await self.declare_... | [
"0.67236507",
"0.66197556",
"0.64929247",
"0.6260047",
"0.6201118",
"0.5973525",
"0.59200746",
"0.5897509",
"0.5897299",
"0.5760605",
"0.5723684",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.57159436",
"0.... | 0.6956101 | 0 |
Called when exiting the consumer iterator | def __exit__(self, exc_type, exc_val, exc_tb):
self.queue.channel.rpc(self._basic_cancel)
self.queue.consuming = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_iter(self):\n raise NotImplementedError",
"def __exit__(self, *_) -> None:\n self.__cursor.top.pop()",
"def end(self) -> None:",
"def end(self):\n ...",
"def _finish(self):\n if self.consumer:\n self.consumer.unregisterProducer()\n self.consumer = N... | [
"0.71276844",
"0.64325505",
"0.6416023",
"0.63907677",
"0.6312287",
"0.6300143",
"0.6271744",
"0.6212424",
"0.6212424",
"0.6212424",
"0.6162212",
"0.61339283",
"0.6100264",
"0.6042454",
"0.6037785",
"0.6007991",
"0.6005878",
"0.6001117",
"0.5998288",
"0.59981495",
"0.5981218"... | 0.6188529 | 10 |
Retrieve the nest message from the queue as an iterator, blocking until the next message is available. | def next_message(self):
while self.queue.consuming:
yield self.queue.channel._consume_message() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next(self): # wait for 5 minutes after sending message\n if self.queue:\n messages = self.queue.get_messages(1,visibility_timeout=self.visibility_timeout)\n if messages:\n for m in messages:\n return m\n raise StopIteration",
"def read(sel... | [
"0.7556442",
"0.7009815",
"0.6816463",
"0.674572",
"0.6724379",
"0.66346157",
"0.660066",
"0.64881974",
"0.63246495",
"0.63130015",
"0.62896055",
"0.6209126",
"0.6189926",
"0.61867803",
"0.60752857",
"0.60651827",
"0.6057777",
"0.6036472",
"0.5981971",
"0.59722316",
"0.596316... | 0.7156374 | 1 |
This is initialization method of the algorithm's class. | def __init__(self, filename='', limit=0.80, members=3, delimiter=','):
self.count = 0 # counter for correct predictions
self.results = self.load_data(filename=filename, limit=limit, delim=delimiter) # load data and receive response
self.test_data = self.results[1]
self.training_data = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_algorithm(self):\n pass",
"def initialize(self):\n\t\tpass",
"def init(self) -> None:",
"def initialize(self):\r\n pass",
"def initialize(self):\r\n pass",
"def initialize(self):\n pass",
"def initialize(self):\n pass",
"def initialize(self):\n pass"... | [
"0.8788583",
"0.78260493",
"0.7767065",
"0.77532625",
"0.77532625",
"0.77265584",
"0.77265584",
"0.77265584",
"0.77265584",
"0.77265584",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7675273",
"0.7666846",
"0.7661625",
"0.76616... | 0.0 | -1 |
This method loads data from the file. A ny number of columns is accepted but provided the labels are on the last columns to the right. | def load_data(self, filename='', limit=0.75, delim=','):
with open(filename) as data:
reader = csv.reader(data, delimiter=delim)
f = list(reader)
for x in range(len(f)):
for y in range(len(f[0]) - 1):
f[x][y] = float(f[x][y]) # convert elements of eac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_column_labels(self):\n\n # read the label line (should be at row 15 of the file at this point)\n label_list = self._stream_handle.readline().strip().split()\n self.num_columns = len(label_list)\n self._header_dict['labels'] = label_list\n\n # the m_present_time label is... | [
"0.74831015",
"0.7439754",
"0.69201815",
"0.68371534",
"0.68163675",
"0.6701311",
"0.665933",
"0.65913653",
"0.65871",
"0.6568758",
"0.6536346",
"0.653422",
"0.65012157",
"0.648894",
"0.6411348",
"0.63984174",
"0.63932616",
"0.63891995",
"0.63853955",
"0.63792837",
"0.6369172... | 0.0 | -1 |
This method receives the whole training data set, the data instance being predicted and the cluster member size. | def get_neighbours(self, training_data=(), instance=(), k=3):
data = []
neighbours = []
# calculate the query distance
for x in range(len(training_data)):
distance = self.query_distance(instance1=training_data[x][:-1], instance2=instance[:-1])
data.append([trainin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_train_instances(self):\n raise NotImplementedError()",
"def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n ... | [
"0.64410335",
"0.6329403",
"0.6253084",
"0.6185533",
"0.6177989",
"0.61298734",
"0.6108489",
"0.61044306",
"0.61016464",
"0.606673",
"0.6049881",
"0.6038121",
"0.60097194",
"0.60030633",
"0.59279317",
"0.59199035",
"0.5886591",
"0.5773972",
"0.5772074",
"0.57601804",
"0.57601... | 0.0 | -1 |
This method calculates the query distance between the current data in the training set and the test data in question | def query_distance(self, instance1=(), instance2=()):
distance = sum([pow((a - b), 2) for a, b in zip(instance1, instance2)])
return distance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDistanceM(self, test, train):\n p = 2 # TUNE currently euclidian distance\n distanceM = pd.DataFrame(index=test.index.values, columns=train.index.values)\n for testrow, testing in test.iterrows():\n for trainrow, training in train.iterrows():\n tot = 0\n ... | [
"0.7019203",
"0.6988815",
"0.68354094",
"0.66117215",
"0.64914435",
"0.6445621",
"0.6380863",
"0.6360921",
"0.6360921",
"0.6267546",
"0.619195",
"0.6135691",
"0.60662866",
"0.6063706",
"0.60594213",
"0.60494125",
"0.5988632",
"0.5947215",
"0.59445816",
"0.594229",
"0.5941032"... | 0.56466407 | 48 |
This method receives the neighbours of the test data and takes a tally of the votes and makes a decision. The decision is based on the label with the highest count. | def count_votes(self, neighbours=()):
labels = []
data = neighbours
# create the list made up of labels.
for x in range(len(data)):
labels.append(data[x][-1])
# count the appearance of labels.
count = [[x, labels.count(x)] for x in set(labels)]
# Sort... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _vote(self, neighbor_labels):\n counts= torch.bincount(neighbor_labels.int())\n return torch.argmax(counts)",
"def _tally_votes(self, labels, distances):\n votes = collections.defaultdict(int)\n for i, index in enumerate(distances.order(ascending=True).index):\n if i < ... | [
"0.7076513",
"0.6492986",
"0.63586086",
"0.6339451",
"0.62436193",
"0.61596376",
"0.6038543",
"0.598995",
"0.59895474",
"0.5984259",
"0.5975959",
"0.5975312",
"0.5897305",
"0.58957624",
"0.58957624",
"0.58913827",
"0.5873205",
"0.5868879",
"0.5822922",
"0.5816393",
"0.5770653... | 0.7605235 | 0 |
Secure XMLRPC server. It it very similar to SimpleXMLRPCServer but it uses HTTPS for transporting XML data. | def __init__(self, server_address, HandlerClass, logRequests=True):
self.logRequests = logRequests
try:
SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self)
except TypeError:
# An exception is raised in Python 2.5 as the prototype of the __init__
# metho... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ServerApp(stream, certfile, keyfile):\n\n def secured():\n print 'server secured!'\n wait()\n\n def read(line):\n line = line.strip()\n print 'client said: %r.' % line\n\n if line == 'QUIT':\n write('GOODBYE')\n elif line == 'STARTTLS':\n st... | [
"0.5892171",
"0.5800856",
"0.57675576",
"0.55861664",
"0.557848",
"0.5535654",
"0.5511048",
"0.54085445",
"0.5328043",
"0.52619624",
"0.52469873",
"0.5210757",
"0.5188847",
"0.5187752",
"0.51839226",
"0.51787466",
"0.51674885",
"0.5163018",
"0.5136565",
"0.51175344",
"0.51103... | 0.5573137 | 5 |
Handles the HTTPS POST request. It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly. | def do_POST(self):
try:
# get arguments
data = self.rfile.read(int(self.headers["content-length"]))
# In previous versions of SimpleXMLRPCServer, _dispatch
# could be overridden in this class, instead of in
# SimpleXMLRPCDispatcher. To maintain backw... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_POST(self):\r\n SimpleXMLRPCRequestHandler.do_POST(self)\r\n try:\r\n # shut down the connection\r\n self.connection.shutdown()\r\n except:\r\n pass",
"def do_POST(self):\n\n try:\n # get arguments\n data = self.rfile.read(... | [
"0.7406314",
"0.67461973",
"0.64566195",
"0.63029206",
"0.6072018",
"0.6066601",
"0.6046328",
"0.5997497",
"0.59290093",
"0.58769035",
"0.58373576",
"0.57971627",
"0.573956",
"0.57225776",
"0.5698153",
"0.5666174",
"0.563702",
"0.56157655",
"0.5584676",
"0.55648243",
"0.55317... | 0.72129786 | 1 |
Return object data in easily serializeable format | def serialize(self):
return {
'id' : self.id,
'name': self.name,
'address1' : self.address1,
'address2': self.address2,
'phone' : self.phone,
'lat': self.lat,
'lng' : self.lng,
'cost': self.cost,
'menu_type' :... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self, obj):\n return obj",
"def GetDataAsObject(self):",
"def serialize(self, obj):\n pass",
"def serialize(self, data):\n return data",
"def SerializeObject(self, data):\n\n if isinstance(data,dict):\n serializad_data = json.dumps(data)\n else:\n... | [
"0.777154",
"0.7626386",
"0.7566185",
"0.7525398",
"0.74336725",
"0.7321529",
"0.7315361",
"0.7281728",
"0.7163479",
"0.7155347",
"0.7148642",
"0.7124317",
"0.7099167",
"0.70400804",
"0.70074207",
"0.6971844",
"0.6960608",
"0.6955735",
"0.6948549",
"0.69371045",
"0.69215906",... | 0.67694086 | 45 |
u {l1} and r {l} new should be of equal sizes to be concatenated | def __init__(self,
in_channels_r, out_channels_r, in_channels_u, out_channels,
kernel_size_in, kernel_size_out,
up_stride_in, stride_out,
up_padding_in, padding_out, output_padding=0,
activation_in='lrelu', activation_out='lrelu',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def concatenate_data():",
"def rejoin(l0,l1=None):\r\n while len(l0) != 0:\r\n if l1 is None:\r\n l1 = []\r\n if l0[0] == '<':\r\n if len(l0) >= 3:\r\n if l0[2] == '>':\r\n l1 += [l0.pop(0) + l0.pop(0) + l0.pop(0)]\r\n else:\r\n ... | [
"0.6007597",
"0.5953543",
"0.58370024",
"0.57667744",
"0.56314075",
"0.5579645",
"0.5569091",
"0.5529879",
"0.55260503",
"0.5507611",
"0.5504095",
"0.5491118",
"0.5489259",
"0.5442784",
"0.5399009",
"0.5395347",
"0.5387921",
"0.5385343",
"0.5382747",
"0.5379792",
"0.5364914",... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.