= self.object_threshold)\\n #box_confidence = box_confidence[first_filter[:-1]]\\n #box_class_probs = box_class_probs[first_filter[:-1]]\\n #boxes = boxes[first_filter[:-1]]\\n\\n box_scores = box_confidence[first_filter[:-1]] * box_class_probs[first_filter[:-1]]\\n box_class_scores = torch.max(box_scores, axis=-1)\\n box_classes = box_class_scores.indices\\n box_class_scores = box_class_scores.values\\n pos = torch.where(box_class_scores >= self.object_threshold)\\n# print(self.batch_inds[scale_factor].shape, boxes.shape)\\n# print(self.batch_inds[scale_factor][first_filter[0]][pos[0]])\\n# print(first_filter)\\n# MAYBE BATCH_INDS SHOULD BE IN CPU????\\n# print(pos)\\n out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], self.batch_inds[scale_factor][first_filter[0]][pos[0]]\\n #out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], first_filter[0][pos[0]]\\n #out = boxes[pos], box_classes[pos], box_class_scores[pos], pos[0]\\n# whole_proc.stop()\\n\\n# https://github.com/opencv/opencv/issues/17148\\n# scale_x_y \\n return out\",\n \"def demosaic(bayerImage, mask_red, mask_green, mask_blue):\\n mosaicImage = bayerImage\\n # create the three RGB Layers\\n red1 = mosaicImage * mask_red\\n blue1 = mosaicImage * mask_blue\\n green1 = mosaicImage * mask_green\\n #\\n # Converting from 12-bit to 8-bit by dividing by 2^4\\n red = (red1).astype('float32')\\n # Converting from 12-bit to 8-bit by dividing by 2^4\\n blue = (blue1).astype('float32')\\n # Converting from 12-bit to 8-bit by dividing by 2^4\\n green = (green1).astype('float32')\\n blue = numpy.multiply(blue, 4)\\n red = numpy.multiply(red, 4)\\n green = numpy.multiply(green, 2)\\n\\n # downsampling then upsampling by Bilinear Interpolation Demosaicing'''\\n down_r = cv2.resize(\\n red,\\n None,\\n fx=0.5,\\n fy=0.5,\\n interpolation=cv2.INTER_LINEAR) # Downsampling the red pixels by half\\n # Downsampling the blue pixels by half\\n down_b = cv2.resize(blue, None, fx=0.5, fy=0.5,\\n interpolation=cv2.INTER_LINEAR)\\n # Downsampling the green pixels by half\\n down_g = cv2.resize(green, None, fx=0.5, fy=0.5,\\n interpolation=cv2.INTER_LINEAR)\\n\\n # Creating a zero matrix where each of the channels will be stacked at\\n # different dimensions\\n rgbArray = numpy.zeros((608, 968, 3), 'uint8')\\n rgbArray[..., 0] = down_r # Red channel in dimension 1\\n rgbArray[..., 1] = down_g # Green channel in dimension 2\\n rgbArray[..., 2] = down_b # Blue channel in dimension 3\\n # Upsampling the newly formed matrix by 2 times to get the original image\\n up_BL = cv2.resize(rgbArray, None, fx=2, fy=2,\\n interpolation=cv2.INTER_LINEAR)\\n\\n return up_BL\",\n \"def rescaleBox(box_pred, box_true, img, imageOrig, transformPredicted = False):\\n # Transform the predicted Box\\n if transformPredicted:\\n sx, sy, ex, ey = box_pred\\n x, y, z = img.shape\\n x1, y1, z1 = imageOrig.shape\\n scaleX = x1/x\\n scaleY = y1/y\\n # Transform the true Box\\n else:\\n sx, sy, ex, ey = box_true\\n x, y, z = img.shape\\n x1, y1, z1 = imageOrig.shape\\n scaleX = x/x1\\n scaleY = y/y1\\n\\n sx = sx * scaleY\\n sy = sy * scaleX\\n ex = ex * scaleY\\n ey = ey * scaleX\\n\\n return torch.tensor([sx, sy, ex, ey])\",\n \"def zoom_augmentation():\\n # Get the width and the height of the zoomed version\\n x_len, y_len = np.random.randint(250, 350, size=2)\\n # Get left upper ,right and lower bound of the pixels in the original image\\n left = np.random.randint(x_size-x_len)\\n upper = np.random.randint(y_size-y_len)\\n right, lower = left + x_len, upper+y_len\\n # Crops the box and resizes it to the original image size\\n box = (left, upper, right, lower)\\n return lambda image: image.transform(image.size, Image.EXTENT, box)\",\n \"def test_default_box_simple() :\\n kwargs = {\\n 'image_size' : 160,\\n 'steps' : [8, 16, 32],\\n 'aspect_ratios' : [1],\\n 'variance' : [0.1, 0.2],\\n 'clip' : 1,\\n }\\n default_box = DefaultBox(**kwargs)\\n boxes = default_box()\\n assert torch.all(eq(\\n default_box.feature_maps,\\n tensor([20, 10, 5])\\n ))\\n assert default_box.anchors.dim() == 3\\n \\\"\\\"\\\"\\n 3 -> number of feature maps\\n 2 -> n aspect ratio (+1)\\n 2 -> width and height value\\n \\\"\\\"\\\"\\n assert default_box.anchors.size() == Size([3,2,2])\\n assert boxes.dim() == 2\\n \\\"\\\"\\\"\\n (20*20+10*10+5*5)*2 -> number of feature maps (grids) * number of aspect ratios\\n 2+2 -> cxywh\\n \\\"\\\"\\\"\\n assert boxes.size() == Size([(20*20+10*10+5*5)*2,2+2])\\n kwargs = {\\n 'image_size' : 160,\\n 'steps' : [8, 16, 32],\\n 'aspect_ratios' : [2, 3],\\n 'variance' : [0.1, 0.2],\\n 'clip' : 1,\\n }\\n default_box = DefaultBox(**kwargs)\\n boxes = default_box()\\n assert torch.all(eq(\\n default_box.feature_maps,\\n tensor([20, 10, 5])\\n ))\\n assert default_box.anchors.dim() == 3\\n \\\"\\\"\\\"\\n 3 -> number of feature maps\\n 4 -> n aspect ratio * 2 (for 1/2 and 1/3)\\n 2 -> width and height value\\n \\\"\\\"\\\"\\n assert default_box.anchors.size() == Size([3,4,2])\\n assert boxes.dim() == 2\\n \\\"\\\"\\\"\\n (20*20+10*10+5*5)*4 -> number of feature maps (grids) * number of aspect ratios\\n 2+2 -> cxywh\\n \\\"\\\"\\\"\\n assert boxes.size() == Size([(20*20+10*10+5*5)*4,2+2])\",\n \"def modified(self):\\n if self._allow_rescale:\\n return super(ImageScaling, self).modified()\\n else:\\n return 1\",\n \"def im_detect_mask(model, im_scales, boxes):\\n assert len(im_scales) == 1, \\\\\\n 'Only single-image / single-scale batch implemented'\\n\\n M_HEIGHT = cfg.MRCNN.RESOLUTION_H\\n M_WIDTH = cfg.MRCNN.RESOLUTION_W\\n if boxes.shape[0] == 0:\\n pred_masks = np.zeros((0, M, M), np.float32)\\n return pred_masks\\n\\n inputs = {'mask_rois': _get_rois_blob(boxes, im_scales)}\\n # Add multi-level rois for FPN\\n if cfg.FPN.MULTILEVEL_ROIS:\\n _add_multilevel_rois_for_test(inputs, 'mask_rois')\\n\\n for k, v in inputs.items():\\n workspace.FeedBlob(core.ScopedName(k), v)\\n workspace.RunNet(model.mask_net.Proto().name)\\n\\n # Fetch masks\\n pred_global_masks = workspace.FetchBlob(\\n core.ScopedName('mask_fcn_global_probs')\\n ).squeeze()\\n pred_char_masks = workspace.FetchBlob(\\n core.ScopedName('mask_fcn_char_probs')\\n ).squeeze()\\n # pred_char_boxes = workspace.FetchBlob(\\n # core.ScopedName('mask_fcn_charbox_pred')\\n # ).squeeze()\\n pred_global_masks = pred_global_masks.reshape([-1, 1, M_HEIGHT, M_WIDTH])\\n pred_char_masks = pred_char_masks.reshape([-1, M_HEIGHT, M_WIDTH, 37])\\n pred_char_masks = pred_char_masks.transpose([0,3,1,2])\\n # pred_char_boxes = pred_char_boxes.reshape([-1, 4, M_HEIGHT, M_WIDTH])\\n\\n return pred_global_masks, pred_char_masks, None\",\n \"def rescale_boxes(boxes, current_dim, original_shape):\\n orig_h, orig_w = original_shape\\n\\n # The amount of padding that was added\\n pad_x = max(orig_h - orig_w, 0) * (current_dim / max(original_shape))\\n pad_y = max(orig_w - orig_h, 0) * (current_dim / max(original_shape))\\n\\n # Image height and width after padding is removed\\n unpad_h = current_dim - pad_y\\n unpad_w = current_dim - pad_x\\n\\n # Rescale bounding boxes to dimension of original image\\n boxes[:, 0] = ((boxes[:, 0] - pad_x // 2) / unpad_w) * orig_w\\n boxes[:, 1] = ((boxes[:, 1] - pad_y // 2) / unpad_h) * orig_h\\n boxes[:, 2] = ((boxes[:, 2] - pad_x // 2) / unpad_w) * orig_w\\n boxes[:, 3] = ((boxes[:, 3] - pad_y // 2) / unpad_h) * orig_h\\n return boxes\",\n \"def hook(images, augmenter, parents, default):\\n return augmenter.__class__.__name__ in MASK_AUGMENTERS\",\n \"def __getitem__(self, index):\\n\\n totensor = transforms.Compose(\\n [transforms.Resize((224, 224)),\\n transforms.ToTensor()\\n ])\\n\\n assert (index < len(self.data))\\n assert (index < self.len)\\n images = self.data[index]\\n # print(images)\\n img = cv2.imread(os.path.join(self.dataset.directory, images))\\n\\n target = self.bbox[index]\\n\\n scale = np.array(img.shape) / 224\\n\\n # img = cv2.rectangle(img, (target[0]-10, target[1]-10), (target[2]+10, target[3]+10),\\n # color=(255, 255, 0), thickness=10)\\n\\n # cv2.imwrite(os.path.join(\\\"res\\\", str(index)+\\\".jpg\\\"), draw)\\n\\n # print(img.shape, scale)\\n img = cv2.resize(img, (224, 224))\\n\\n # print(target)\\n\\n target[0] = int(target[0] / scale[1] - 5)\\n target[1] = int(target[1] / scale[0] - 5)\\n target[2] = int(target[2] / scale[1] + 5)\\n target[3] = int(target[3] / scale[0] + 5)\\n\\n # print(target)\\n t = target\\n if self.transform is not None:\\n seq_det = self.transform.to_deterministic() # call this for each batch again, NOT only once at the start\\n\\n keypoints_on_images = []\\n keypoints = []\\n keypoints.append(ia.Keypoint(x=target[0], y=target[1]))\\n keypoints.append(ia.Keypoint(x=target[2], y=target[3]))\\n\\n keypoints_on_images.append(ia.KeypointsOnImage(keypoints, shape=np.asarray(img).shape[:-1]))\\n\\n # augment keypoints and images\\n img = seq_det.augment_image(np.asarray(img))\\n after_aug = []\\n\\n target = seq_det.augment_keypoints(keypoints_on_images)\\n for point in target[0].keypoints:\\n # print(point)\\n x_new, y_new = point.x, point.y\\n after_aug.append(point.x)\\n after_aug.append(point.y)\\n target = after_aug\\n # print(after_aug)\\n newImg = Image.fromarray(img)\\n reg_targets = np.float32(np.array(target))\\n\\n b=self.labels[index]\\n\\n #a = np.array(self.labels[index])\\n #b = np.zeros((a.size, 2))\\n #b[np.arange(a.size), a] = 1\\n\\n #print(\\\"B=\\\",b,self.labels[index])\\n\\n #print(targets)\\n ##draw = cv2.rectangle(cv2.resize(np.array(newImg), (224, 224)), (t[1], t[0]), (t[3], t[2]), color=(0, 0, 0),\\n # thickness=6)\\n\\n #draw = cv2.rectangle(cv2.resize(np.array(draw), (224, 224)), (targets[0], targets[1]), (targets[2], targets[3]),\\n # color=(0, 255, 0), thickness=3)\\n\\n #cv2.imwrite(os.path.join(\\\"res\\\", str(index) + \\\".jpg\\\"), draw)\\n #print(reg_targets)\\n\\n return totensor(newImg), reg_targets,b ,index\",\n \"def prepare_test_img(self, idx):\\n img_info = self.img_infos[idx]\\n img_path = osp.join(self.img_prefix, img_info['filename'])\\n\\n if self.proposals is not None:\\n proposal = self.proposals[idx][:self.num_max_proposals]\\n if not proposal.shape[1] == 4 or proposal.shape[1] == 5:\\n raise AssertionError(\\n 'proposals should have shapes (n, 4) or (n, 5), '\\n 'but found {}'.format(proposal.shape))\\n else:\\n proposal = None\\n\\n if self.with_background_erasing:\\n ann = self.get_ann_info(idx)\\n gt_bboxes = ann['bboxes']\\n else:\\n gt_bboxes = None\\n\\n def prepare_single_scale(img_path, expected_size, flip_ratio=0,\\n proposal=None, bbox=None):\\n _img, img_shape, pad_shape, scale_factor, \\\\\\n flipped_flag, flipped_direction = self.img_transforms(\\n img_path, expected_size, flip_ratio=flip_ratio)\\n if bbox is not None:\\n if not len(bbox) == 0:\\n _gt_bboxes = self.bbox_transforms(bbox,\\n img_shape,\\n scale_factor,\\n flipped_flag,\\n flipped_direction)\\n else:\\n _gt_bboxes = bbox\\n _img = self.background_erasing(\\n _img, img_shape, _gt_bboxes,\\n cell_size=self.be_cell_size,\\n random_ratio=self.be_random_ratio)\\n _img = to_tensor(_img)\\n _img_meta = dict(\\n filename=img_info['filename'],\\n ori_shape=(img_info['height'], img_info['width'], 3),\\n img_shape=img_shape,\\n pad_shape=pad_shape,\\n scale_factor=scale_factor,\\n flipped_flag=flipped_flag,\\n flipped_direction=flipped_direction\\n )\\n if proposal is not None:\\n if proposal.shape[1] == 5:\\n score = proposal[:, 4, None]\\n proposal = proposal[:, :4]\\n else:\\n score = None\\n _proposal = self.bbox_transforms(proposal,\\n img_shape,\\n scale_factor,\\n flipped_flag,\\n flipped_direction)\\n _proposal = np.hstack([_proposal, score]) \\\\\\n if score is not None else _proposal\\n _proposal = to_tensor(_proposal)\\n else:\\n _proposal = None\\n return _img, _img_meta, _proposal\\n\\n imgs = []\\n img_metas = []\\n proposals = []\\n for expected_size in self.img_expected_sizes:\\n # at first, we do not flip the image\\n _img, _img_meta, _proposal = prepare_single_scale(\\n img_path, expected_size, flip_ratio=0,\\n proposal=proposal, bbox=gt_bboxes)\\n imgs.append(_img)\\n img_metas.append(DataContainer(_img_meta, cpu_only=True))\\n proposals.append(_proposal)\\n if self.flip_ratio > 0:\\n _img, _img_meta, _proposal = prepare_single_scale(\\n img_path, expected_size, flip_ratio=1,\\n proposal=proposal, bbox=gt_bboxes)\\n imgs.append(_img)\\n img_metas.append(DataContainer(_img_meta, cpu_only=True))\\n proposals.append(_proposal)\\n data = dict(img=imgs, img_meta=img_metas)\\n if self.proposals is not None:\\n data['proposals'] = proposals\\n return data\",\n \"def rescale_bbs(img, bbs):\\n width = img.shape[1]\\n height = img.shape[0]\\n for box in bbs:\\n box[0] = int(box[0] * width)\\n box[1] = int(box[1] * height)\\n box[2] = int(box[2] * width)\\n box[3] = int(box[3] * height)\\n return bbs\",\n \"def resize_bboxes(ratios, bboxes):\\r\\n ymin = bboxes[..., 0] * ratios[0]\\r\\n xmin = bboxes[..., 1] * ratios[1]\\r\\n ymax = bboxes[..., 2] * ratios[0]\\r\\n xmax = bboxes[..., 3] * ratios[1]\\r\\n bboxes = np.stack([ymin, xmin, ymax, xmax], axis=-1)\\r\\n return bboxes\",\n \"def get_seg_masks(self, rgba_pred, det_bboxes, det_labels, rcnn_test_cfg,\\n ori_shape, scale_factor, rescale):\\n if isinstance(rgba_pred, torch.Tensor):\\n rgba_pred = rgba_pred.tanh().cpu().numpy()\\n assert isinstance(rgba_pred, np.ndarray)\\n # when enabling mixed precision training, rgba pred may be float16 numpy array\\n rgba_pred = rgba_pred.astype(np.float32)\\n cls_segms = [[] for _ in range(self.num_classes - 1)]\\n bboxes = det_bboxes.cpu().numpy()[:, :4]\\n labels = det_labels.cpu().numpy() + 1\\n\\n if rescale:\\n img_h, img_w = ori_shape[:2]\\n else:\\n img_h = np.round(ori_shape[0] * scale_factor).astype(np.int32)\\n img_w = np.round(ori_shape[1] * scale_factor).astype(np.int32)\\n scale_factor = 1.0\\n\\n for i in range(bboxes.shape[0]):\\n if not isinstance(scale_factor, (float, np.ndarray)):\\n scale_factor = scale_factor.cpu().numpy()\\n bbox = (bboxes[i, :] / scale_factor).astype(np.int32)\\n label = labels[i]\\n w = max(bbox[2] - bbox[0] + 1, 1)\\n h = max(bbox[3] - bbox[1] + 1, 1)\\n\\n if self.out_channels is None and not self.class_agnostic:\\n mask_pred = rgba_pred[i, label, :, :]\\n else:\\n mask_pred = rgba_pred[i, 0, :, :]\\n im_mask = np.zeros((img_h, img_w), dtype=np.uint8)\\n\\n bbox_mask = mmcv.imresize(mask_pred, (w, h))\\n bbox_mask = (bbox_mask > rcnn_test_cfg.mask_thr_binary).astype(np.uint8)\\n im_mask[bbox[1]:bbox[1] + h, bbox[0]:bbox[0] + w] = bbox_mask\\n rle = mask_util.encode(np.array(im_mask[:, :, np.newaxis], order='F'))[0]\\n cls_segms[label - 1].append(rle)\\n\\n return cls_segms\",\n \"def validate(net, val_data, val_items, val_shapes, ctx, size, classes):\\n clipper = gcv.nn.bbox.BBoxClipToImage()\\n net.hybridize(static_alloc=True)\\n print(\\\"---Detect Total {:d} Image Start.---\\\".format(len(val_items))) \\n\\n result_dict = {}\\n for ib, (batch, item) in enumerate(zip(val_data, val_items)):\\n batch = split_and_load(batch, ctx_list=ctx)\\n for x, y, im_scale in zip(*batch):\\n ids, scores, bboxes = net(x)\\n bboxes = clipper(bboxes, x)\\n im_scale = im_scale.reshape((-1)).asscalar()\\n bboxes *= im_scale\\n inds = nd.argsort(nd.squeeze(ids, axis=(0, 2)), is_ascend=False)\\n ids = nd.squeeze(ids, axis=(0, 2)).asnumpy().astype(np.int8).tolist()\\n valid_ids = [id for id in ids if id is not -1]\\n valid_len = len(valid_ids)\\n if valid_len > 0: # valid_len must > 0\\n inds = nd.slice_axis(inds, begin=0, end=valid_len, axis=0)\\n scores = nd.take(scores, inds, axis=1)\\n bboxes = nd.take(bboxes, inds, axis=1)\\n scores = scores.asnumpy()\\n bboxes = bboxes.asnumpy()\\n for i, id in enumerate(valid_ids):\\n score = scores[:, i, 0][0]\\n xmin, ymin, xmax, ymax = bboxes[:, i, 0][0], bboxes[:, i, 1][0], bboxes[:, i, 2][0], bboxes[:, i, 3][0] \\n result_dict[id] = result_dict.get(id, []) + [[item, score, xmin, ymin, xmax, ymax]]\\n print(\\\"Detect Image {:s} Done.\\\".format(item))\\n print(\\\"---Detect Total {:d} Image Done.---\\\".format(len(val_items)))\\n return result_dict\",\n \"def __call__(self, results):\\n\\n if 'img_fields' in results:\\n assert results['img_fields'] == ['img'], \\\\\\n 'Only single img_fields is allowed'\\n img = results['img']\\n assert 'bbox_fields' in results\\n boxes = [results[key] for key in results['bbox_fields']]\\n boxes = np.concatenate(boxes, 0)\\n h, w, c = img.shape\\n while True:\\n mode = random.choice(self.sample_mode)\\n self.mode = mode\\n if mode == 1:\\n return results\\n\\n min_iou = mode\\n for i in range(50):\\n new_w = random.uniform(self.min_crop_size * w, w)\\n new_h = random.uniform(self.min_crop_size * h, h)\\n\\n # h / w in [0.5, 2]\\n if new_h / new_w < 0.5 or new_h / new_w > 2:\\n continue\\n\\n left = random.uniform(w - new_w)\\n top = random.uniform(h - new_h)\\n\\n patch = np.array(\\n (int(left), int(top), int(left + new_w), int(top + new_h)))\\n # Line or point crop is not allowed\\n if patch[2] == patch[0] or patch[3] == patch[1]:\\n continue\\n overlaps = bbox_overlaps(\\n patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)\\n if len(overlaps) > 0 and overlaps.min() < min_iou:\\n continue\\n\\n # center of boxes should inside the crop img\\n # only adjust boxes and instance masks when the gt is not empty\\n if len(overlaps) > 0:\\n # adjust boxes\\n def is_center_of_bboxes_in_patch(boxes, patch):\\n center = (boxes[:, :2] + boxes[:, 2:]) / 2\\n mask = ((center[:, 0] > patch[0]) *\\n (center[:, 1] > patch[1]) *\\n (center[:, 0] < patch[2]) *\\n (center[:, 1] < patch[3]))\\n return mask\\n\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n if not mask.any():\\n continue\\n for key in results.get('bbox_fields', []):\\n boxes = results[key].copy()\\n mask = is_center_of_bboxes_in_patch(boxes, patch)\\n boxes = boxes[mask]\\n if self.bbox_clip_border:\\n boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])\\n boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])\\n boxes -= np.tile(patch[:2], 2)\\n\\n results[key] = boxes\\n # labels\\n label_key = self.bbox2label.get(key)\\n if label_key in results:\\n results[label_key] = results[label_key][mask]\\n\\n # mask fields\\n mask_key = self.bbox2mask.get(key)\\n if mask_key in results:\\n results[mask_key] = results[mask_key][\\n mask.nonzero()[0]].crop(patch)\\n # adjust the img no matter whether the gt is empty before crop\\n img = img[patch[1]:patch[3], patch[0]:patch[2]]\\n results['img'] = img\\n results['img_shape'] = img.shape\\n\\n # seg fields\\n for key in results.get('seg_fields', []):\\n results[key] = results[key][patch[1]:patch[3],\\n patch[0]:patch[2]]\\n return results\",\n \"def get_validation_augmentation():\\r\\n test_transform = [\\r\\n albu.RandomCrop(height=256, width=256, always_apply=True),\\r\\n ]\\r\\n return albu.Compose(test_transform)\",\n \"def imcrop(img,bboxes,scale=1.0,pad_fill=None):\\n channel = 1 if img.ndim == 2 else img.shape[2]\\n if pad_fill is not None:\\n if isinstance(pad_fill,(int,float)):\\n pad_fill = [pad_fill for _ in range(channel)]\\n assert len(pad_fill) == channel\\n # bboxes.ndim == 1 if there is only one box.\\n _bboxes = bboxes[None,...] if bboxes.ndim == 1 else bboxes\\n scaled_bboxes = bbox_scaling(_bboxes,scale).astype(np.int32)\\n clipped_bboxes = bbox_clip(scaled_bboxes,img.shape)\\n \\n patches = []\\n for i in range(clipped_bbox.shape[0]):\\n x1,y1,x2,y2 = tuple(clipped_bbox[i,:])\\n if pad_fill is None:\\n patch = img[y1:y2+1,x1:x2+1,...]\\n else:\\n _x1,_y1,_x2,_y2 = tuple(scaled_bboxes[i,:])\\n if channel == 2:\\n patch_shape = (_y2 - _y1 + 1,_x2 - _x1 + 1)\\n else:\\n patch_shape = (_y2 - _y1 + 1,_x2 - _x1 + 1,chn)\\n patch = np.array(pad_fill,dtype=img.dtype) * np.ones(patch_shape,dtype=img.dtype)\\n x_start = 0 if _x1 >= 0 else -_x1\\n y_start = 0 if _y1 >= 0 else -_y1\\n w = x2 - x1 + 1\\n h = y2 - y1 + 1\\n patch[y_start:y_start + h,x_start:x_start + w,...] = img[y1:y1+h,x1:x1+w,...]\\n patches.append(patch)\\n \\n if bboxes.ndim == 1:\\n return patches[0]\\n else:\\n return patches\",\n \"def bboxes_resize(bbox_ref, bboxes):\\n bboxes = np.copy(bboxes)\\n # Translate.\\n bboxes[:, 0] -= bbox_ref[0]\\n bboxes[:, 1] -= bbox_ref[1]\\n bboxes[:, 2] -= bbox_ref[0]\\n bboxes[:, 3] -= bbox_ref[1]\\n # Resize.\\n resize = [bbox_ref[2] - bbox_ref[0], bbox_ref[3] - bbox_ref[1]]\\n bboxes[:, 0] /= resize[0]\\n bboxes[:, 1] /= resize[1]\\n bboxes[:, 2] /= resize[0]\\n bboxes[:, 3] /= resize[1]\\n return bboxes\",\n \"def bboxes_resize(bbox_ref, bboxes):\\n bboxes = np.copy(bboxes)\\n # Translate.\\n bboxes[:, 0] -= bbox_ref[0]\\n bboxes[:, 1] -= bbox_ref[1]\\n bboxes[:, 2] -= bbox_ref[0]\\n bboxes[:, 3] -= bbox_ref[1]\\n # Resize.\\n resize = [bbox_ref[2] - bbox_ref[0], bbox_ref[3] - bbox_ref[1]]\\n bboxes[:, 0] /= resize[0]\\n bboxes[:, 1] /= resize[1]\\n bboxes[:, 2] /= resize[0]\\n bboxes[:, 3] /= resize[1]\\n return bboxes\",\n \"def draw_bboxes(images, # type: thelper.typedefs.InputType\\n preds=None, # type: Optional[thelper.typedefs.AnyPredictionType]\\n bboxes=None, # type: Optional[thelper.typedefs.AnyTargetType]\\n color_map=None, # type: Optional[thelper.typedefs.ClassColorMap]\\n redraw=None, # type: Optional[thelper.typedefs.DrawingType]\\n block=False, # type: Optional[bool]\\n min_confidence=0.5, # type: thelper.typedefs.Number\\n class_map=None, # type: Optional[thelper.typedefs.ClassIdType, AnyStr]\\n **kwargs # type: Any\\n ):\\n def get_class_name(_bbox):\\n if isinstance(class_map, dict):\\n return class_map[_bbox.class_id]\\n elif bbox.task is not None:\\n return _bbox.task.class_names[_bbox.class_id]\\n else:\\n raise RuntimeError(\\\"could not find class name from either class mapping or bbox task definition\\\")\\n\\n image_list = [get_displayable_image(images[batch_idx, ...]) for batch_idx in range(images.shape[0])]\\n if color_map is not None and isinstance(color_map, dict):\\n assert len(color_map) <= 256, \\\"too many indices for uint8 map\\\"\\n color_map_new = np.zeros((256, 3), dtype=np.uint8)\\n for idx, val in color_map.items():\\n color_map_new[idx, ...] = val\\n color_map = color_map_new.tolist()\\n nb_imgs = len(image_list)\\n grid_size_x, grid_size_y = nb_imgs, 1 # all images on one row, by default (add gt and preds as extra rows)\\n box_thickness = thelper.utils.get_key_def(\\\"box_thickness\\\", kwargs, default=2, delete=True)\\n font_thickness = thelper.utils.get_key_def(\\\"font_thickness\\\", kwargs, default=1, delete=True)\\n font_scale = thelper.utils.get_key_def(\\\"font_scale\\\", kwargs, default=0.4, delete=True)\\n if preds is not None:\\n assert len(image_list) == len(preds)\\n for preds_list, image in zip(preds, image_list):\\n for bbox_idx, bbox in enumerate(preds_list):\\n assert isinstance(bbox, thelper.data.BoundingBox), \\\"unrecognized bbox type\\\"\\n if bbox.confidence is not None and bbox.confidence < min_confidence:\\n continue\\n color = get_bgr_from_hsl(bbox_idx / len(preds_list) * 360, 1.0, 0.5) \\\\\\n if color_map is None else color_map[bbox.class_id]\\n conf = \\\"\\\"\\n if thelper.utils.is_scalar(bbox.confidence):\\n conf = f\\\" ({bbox.confidence:.3f})\\\"\\n elif isinstance(bbox.confidence, (list, tuple, np.ndarray)):\\n conf = f\\\" ({bbox.confidence[bbox.class_id]:.3f})\\\"\\n draw_bbox(image, bbox.top_left, bbox.bottom_right, f\\\"{get_class_name(bbox)} {conf}\\\",\\n color, box_thickness=box_thickness, font_thickness=font_thickness, font_scale=font_scale)\\n if bboxes is not None:\\n assert len(image_list) == len(bboxes), \\\"mismatched bboxes list and image list sizes\\\"\\n clean_image_list = [get_displayable_image(images[batch_idx, ...]) for batch_idx in range(images.shape[0])]\\n for bboxes_list, image in zip(bboxes, clean_image_list):\\n for bbox_idx, bbox in enumerate(bboxes_list):\\n assert isinstance(bbox, thelper.data.BoundingBox), \\\"unrecognized bbox type\\\"\\n color = get_bgr_from_hsl(bbox_idx / len(bboxes_list) * 360, 1.0, 0.5) \\\\\\n if color_map is None else color_map[bbox.class_id]\\n draw_bbox(image, bbox.top_left, bbox.bottom_right, f\\\"GT: {get_class_name(bbox)}\\\",\\n color, box_thickness=box_thickness, font_thickness=font_thickness, font_scale=font_scale)\\n grid_size_y += 1\\n image_list += clean_image_list\\n return draw_images(image_list, redraw=redraw, window_name=\\\"detections\\\", block=block,\\n grid_size_x=grid_size_x, grid_size_y=grid_size_y, **kwargs)\",\n \"def ssd_bboxes_decode(feat_localizations,\\n anchor_bboxes,\\n prior_scaling=[0.1, 0.1, 0.2, 0.2]):\\n # Reshape for easier broadcasting.\\n l_shape = feat_localizations.shape\\n feat_localizations = np.reshape(feat_localizations,\\n (-1, l_shape[-2], l_shape[-1]))\\n yref, xref, href, wref = anchor_bboxes\\n xref = np.reshape(xref, [-1, 1])\\n yref = np.reshape(yref, [-1, 1])\\n\\n # Compute center, height and width\\n cx = feat_localizations[:, :, 0] * wref * prior_scaling[0] + xref\\n cy = feat_localizations[:, :, 1] * href * prior_scaling[1] + yref\\n w = wref * np.exp(feat_localizations[:, :, 2] * prior_scaling[2])\\n h = href * np.exp(feat_localizations[:, :, 3] * prior_scaling[3])\\n # bboxes: ymin, xmin, xmax, ymax.\\n bboxes = np.zeros_like(feat_localizations)\\n bboxes[:, :, 0] = cy - h / 2.\\n bboxes[:, :, 1] = cx - w / 2.\\n bboxes[:, :, 2] = cy + h / 2.\\n bboxes[:, :, 3] = cx + w / 2.\\n # Back to original shape.\\n bboxes = np.reshape(bboxes, l_shape)\\n return bboxes\",\n \"def get_validation_augmentation():\\r\\n test_transform = [\\r\\n albu.Resize(192, 192)\\r\\n ]\\r\\n return albu.Compose(test_transform)\",\n \"def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):\\n img_ids = rois[:, 0].long().unique(sorted=True)\\n assert img_ids.numel() <= len(img_metas)\\n\\n bboxes_list = []\\n for i in range(len(img_metas)):\\n inds = torch.nonzero(\\n rois[:, 0] == i, as_tuple=False).squeeze(dim=1)\\n num_rois = inds.numel()\\n\\n bboxes_ = rois[inds, 1:]\\n label_ = labels[inds]\\n bbox_pred_ = bbox_preds[inds]\\n img_meta_ = img_metas[i]\\n pos_is_gts_ = pos_is_gts[i]\\n\\n bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_,\\n img_meta_)\\n\\n # filter gt bboxes\\n pos_keep = 1 - pos_is_gts_\\n keep_inds = pos_is_gts_.new_ones(num_rois)\\n keep_inds[:len(pos_is_gts_)] = pos_keep\\n\\n bboxes_list.append(bboxes[keep_inds.type(torch.bool)])\\n\\n return bboxes_list\",\n \"def _get_image_blob(roidb, scale_inds):\\n num_images = len(roidb)\\n processed_ims = []\\n im_scales = []\\n # gt boxes: (x1, y1, x2, y2, theta, cls) 5->6,4->5\\n im = cv2.imread(roidb[0]['image'])\\n if im is None:\\n print \\\"Read image failed:\\\", roidb[0]['image']\\n\\n if roidb[0]['flipped']:\\n im = im[:, ::-1, :]\\n\\n gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]\\n im, new_gt_boxes = _augment_data(im, roidb[0]['boxes'][gt_inds, 0:8])\\n\\n gt_boxes = np.empty((len(new_gt_boxes), 9), dtype=np.float32)\\n gt_boxes[:, 0:8] = new_gt_boxes\\n\\n target_size = cfg.TRAIN.SCALES[scale_inds[0]]\\n im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, target_size,\\n cfg.TRAIN.MAX_SIZE)\\n im_scales.append(im_scale)\\n processed_ims.append(im)\\n\\n # Create a blob to hold the input images\\n blob = im_list_to_blob(processed_ims)\\n gt_boxes[:, 0:8] *= im_scales\\n gt_boxes[:, 8] = roidb[0]['gt_classes'][gt_inds[:len(new_gt_boxes)]]\\n return blob, im_scales, gt_boxes\",\n \"def preprocess_bounding_boxes(self, bounding_boxes, scale):\\n\\n h_scale, w_scale = scale\\n \\n if bounding_boxes == []:\\n return None\\n\\n bounding_boxes[:, [0, 2]] = bounding_boxes[:, [0, 2]] * w_scale\\n bounding_boxes[:, [1, 3]] = bounding_boxes[:, [1, 3]] * h_scale\\n\\n return bounding_boxes\",\n \"def infer(self, img, threshold=0.2, keep_size=False, custom_nms: NMSCustom=None,\\r\\n nms_thresh=0.45, nms_topk=400, post_nms=100):\\r\\n\\r\\n assert self._model is not None, \\\"Model has not been loaded, call load(path) first\\\"\\r\\n\\r\\n if custom_nms:\\r\\n self._model.set_nms(nms_thresh=0.85, nms_topk=5000, post_nms=1000)\\r\\n else:\\r\\n self._model.set_nms(nms_thresh=nms_thresh, nms_topk=nms_topk, post_nms=post_nms)\\r\\n if not isinstance(img, Image):\\r\\n img = Image(img)\\r\\n _img = img.convert(\\\"channels_last\\\", \\\"rgb\\\")\\r\\n\\r\\n height, width, _ = _img.shape\\r\\n img_mx = mx.image.image.nd.from_numpy(np.float32(_img))\\r\\n\\r\\n if keep_size:\\r\\n x, img_mx = transform_test(img_mx)\\r\\n else:\\r\\n x, img_mx = presets.ssd.transform_test(img_mx, short=self.img_size)\\r\\n h_mx, w_mx, _ = img_mx.shape\\r\\n x = pad_test(x, min_size=self.img_size)\\r\\n x = x.as_in_context(self.ctx)\\r\\n class_IDs, scores, boxes = self._model(x)\\r\\n\\r\\n class_IDs = class_IDs[0, :, 0].asnumpy()\\r\\n scores = scores[0, :, 0].asnumpy()\\r\\n mask = np.where(class_IDs >= 0)[0]\\r\\n if custom_nms is None:\\r\\n mask = np.intersect1d(mask, np.where(scores > threshold)[0])\\r\\n if mask.size == 0:\\r\\n return BoundingBoxList([])\\r\\n\\r\\n scores = scores[mask, np.newaxis]\\r\\n class_IDs = class_IDs[mask, np.newaxis]\\r\\n boxes = boxes[0, mask, :].asnumpy()\\r\\n if x.shape[2] > h_mx:\\r\\n boxes[:, [1, 3]] -= (x.shape[2] - h_mx)\\r\\n elif x.shape[3] > w_mx:\\r\\n boxes[:, [0, 2]] -= (x.shape[3] - w_mx)\\r\\n boxes[:, [0, 2]] /= w_mx\\r\\n boxes[:, [1, 3]] /= h_mx\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n\\r\\n if custom_nms is not None:\\r\\n bounding_boxes, _ = custom_nms.run_nms(boxes=boxes, scores=scores, threshold=threshold, img=_img)\\r\\n else:\\r\\n bounding_boxes = BoundingBoxList([])\\r\\n for idx, box in enumerate(boxes):\\r\\n bbox = BoundingBox(left=box[0], top=box[1],\\r\\n width=box[2] - box[0],\\r\\n height=box[3] - box[1],\\r\\n name=class_IDs[idx, :],\\r\\n score=scores[idx, :])\\r\\n bounding_boxes.data.append(bbox)\\r\\n\\r\\n return bounding_boxes\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def imgBC(img, mask=None, scale=1.0, numBins=64, returnBias=False):\\n spacing = np.array(img.GetSpacing())/scale\\n img_ds = imgResample(img, spacing=spacing)\\n\\n # Calculate bias\\n if mask is None:\\n mask_ds = sitk.Image(img_ds.GetSize(), sitk.sitkUInt8)+1\\n mask_ds.CopyInformation(img_ds)\\n else:\\n mask_ds = imgResample(mask, spacing=spacing, useNearest=True)\\n mask_ds = mask_ds > 0\\n\\n splineOrder = 2\\n img_ds_bc = sitk.N4BiasFieldCorrection(sitk.Cast(img_ds, sitk.sitkFloat32), mask_ds, numberOfHistogramBins=numBins, splineOrder=splineOrder, numberOfControlPoints=[splineOrder+1]*4)\\n #bias_ds = img_ds_bc - sitk.Cast(img_ds,img_ds_bc.GetPixelID())\\n\\n bias_ds = imgFinite(img_ds_bc / img_ds)\\n bias_ds = sitk.Mask(bias_ds, mask_ds) + sitk.Cast(1-mask_ds, sitk.sitkFloat32) # Fill background with 1s\\n\\n # Upsample bias \\n bias = imgResample(bias_ds, spacing=img.GetSpacing(), size=img.GetSize())\\n bias = sitk.Cast(bias, img.GetPixelID())\\n\\n # Apply bias to original image and threshold to eliminate negitive values\\n try:\\n upper = np.iinfo(sitkToNpDataTypes[img.GetPixelID()]).max\\n except:\\n upper = np.finfo(sitkToNpDataTypes[img.GetPixelID()]).max *0.99\\n\\n #img_bc = sitk.Threshold(img + sitk.Cast(bias, img.GetPixelID()),\\n # lower=0,\\n # upper=upper)\\n\\n img_bc = sitk.Threshold(img * bias, lower=0, upper=upper)\\n\\n if returnBias:\\n return (img_bc, bias)\\n else:\\n return img_bc\",\n \"def im_detect_keypoints_aug(model, im, boxes):\\n\\n # Collect heatmaps predicted under different transformations\\n heatmaps_ts = []\\n # Tag predictions computed under downscaling and upscaling transformations\\n ds_ts = []\\n us_ts = []\\n\\n def add_heatmaps_t(heatmaps_t, ds_t=False, us_t=False):\\n heatmaps_ts.append(heatmaps_t)\\n ds_ts.append(ds_t)\\n us_ts.append(us_t)\\n\\n # Compute the heatmaps for the original image (identity transform)\\n im_scales = im_conv_body_only(model, im)\\n heatmaps_i = im_detect_keypoints(model, im_scales, boxes)\\n add_heatmaps_t(heatmaps_i)\\n\\n # Perform keypoints detection on the horizontally flipped image\\n if cfg.TEST.KPS_AUG.H_FLIP:\\n heatmaps_hf = im_detect_keypoints_hflip(model, im, boxes)\\n add_heatmaps_t(heatmaps_hf)\\n\\n # Compute detections at different scales\\n for scale in cfg.TEST.KPS_AUG.SCALES:\\n ds_scl = scale < cfg.TEST.SCALES[0]\\n us_scl = scale > cfg.TEST.SCALES[0]\\n heatmaps_scl = im_detect_keypoints_scale(\\n model, im, scale, cfg.TEST.KPS_AUG.MAX_SIZE, boxes\\n )\\n add_heatmaps_t(heatmaps_scl, ds_scl, us_scl)\\n\\n if cfg.TEST.KPS_AUG.SCALE_H_FLIP:\\n heatmaps_scl_hf = im_detect_keypoints_scale(\\n model, im, scale, cfg.TEST.KPS_AUG.MAX_SIZE, boxes, hflip=True\\n )\\n add_heatmaps_t(heatmaps_scl_hf, ds_scl, us_scl)\\n\\n # Compute keypoints at different aspect ratios\\n for aspect_ratio in cfg.TEST.KPS_AUG.ASPECT_RATIOS:\\n heatmaps_ar = im_detect_keypoints_aspect_ratio(\\n model, im, aspect_ratio, boxes\\n )\\n add_heatmaps_t(heatmaps_ar)\\n\\n if cfg.TEST.KPS_AUG.ASPECT_RATIO_H_FLIP:\\n heatmaps_ar_hf = im_detect_keypoints_aspect_ratio(\\n model, im, aspect_ratio, boxes, hflip=True\\n )\\n add_heatmaps_t(heatmaps_ar_hf)\\n\\n # Select the heuristic function for combining the heatmaps\\n if cfg.TEST.KPS_AUG.HEUR == 'HM_AVG':\\n np_f = np.mean\\n elif cfg.TEST.KPS_AUG.HEUR == 'HM_MAX':\\n np_f = np.amax\\n else:\\n raise NotImplementedError(\\n 'Heuristic {} not supported'.format(cfg.TEST.KPS_AUG.HEUR)\\n )\\n\\n def heur_f(hms_ts):\\n return np_f(hms_ts, axis=0)\\n\\n # Combine the heatmaps\\n if cfg.TEST.KPS_AUG.SCALE_SIZE_DEP:\\n heatmaps_c = combine_heatmaps_size_dep(\\n heatmaps_ts, ds_ts, us_ts, boxes, heur_f\\n )\\n else:\\n heatmaps_c = heur_f(heatmaps_ts)\\n\\n return heatmaps_c\",\n \"def simple_test_pts(self, x, img_metas, rescale=False):\\n outs = self.pts_bbox_head(x)\\n bbox_list = self.pts_bbox_head.get_bboxes(\\n *outs, img_metas, rescale=rescale)\\n bbox_results = [\\n bbox3d2result(bboxes, scores, labels)\\n for bboxes, scores, labels in bbox_list\\n ]\\n return bbox_results\",\n \"def test_scale_image_rgb(self):\\n larger = scale_image(self.rgb_image, 1.5)\\n self.assertEqual((150, 300, 3), larger.shape)\\n\\n smaller = scale_image(self.rgb_image, 0.2)\\n self.assertEqual((20, 40, 3), smaller.shape)\",\n \"def blending_example1():\\n pic_desert = read_image(relpath(\\\"./externals/pic_desert.jpg\\\"), 2)\\n pic_pool = read_image(relpath(\\\"./externals/pic_swim.jpg\\\"), 2)\\n mask = read_image(relpath(\\\"./externals/mask_desert.jpg\\\"), 1)\\n # making the mask binary (normalizing 2 original values)\\n mask = strech_helper(mask).astype(np.bool)\\n print(pic_desert.shape[2])\\n [R1, G1, B1] = np.dsplit(pic_desert, pic_desert.shape[2])\\n [R2, G2, B2] = np.dsplit(pic_pool, pic_pool.shape[2])\\n R1 = np.reshape(R1, (512,1024))\\n R2 = np.reshape(R2, (512,1024))\\n G1 = np.reshape(G1, (512,1024))\\n G2 = np.reshape(G2, (512,1024))\\n B1 = np.reshape(B1, (512,1024))\\n B2 = np.reshape(B2, (512,1024))\\n\\n blend1 = pyramid_blending(R2, R1, mask, 3, 3, 3)\\n blend2 = pyramid_blending(G2, G1, mask, 3, 3, 3)\\n blend3 = pyramid_blending(B2, B1, mask, 3, 3, 3)\\n\\n blend1 = np.reshape(blend1, (blend1.shape[0], blend1.shape[1], 1))\\n blend2 = np.reshape(blend2, (blend2.shape[0], blend3.shape[1], 1))\\n blend3 = np.reshape(blend3, (blend3.shape[0], blend3.shape[1], 1))\\n\\n new_pic = np.concatenate((blend1, blend2, blend3), axis=2)\\n # plotting the images\\n fig = plt.figure()\\n ax1 = fig.add_subplot(221)\\n ax2 = fig.add_subplot(222)\\n ax3 = fig.add_subplot(223)\\n ax4 = fig.add_subplot(224)\\n ax1.imshow(pic_desert)\\n ax2.imshow(pic_pool)\\n ax3.imshow(mask, cmap='gray')\\n ax4.imshow(new_pic)\\n plt.show()\\n\\n return pic_desert, pic_pool, mask, new_pic\",\n \"def test_scale_image_gray(self):\\n larger = scale_image(self.gray_image, 1.5)\\n self.assertEqual((150, 300), larger.shape)\\n\\n smaller = scale_image(self.gray_image, 0.2)\\n self.assertEqual((20, 40), smaller.shape)\",\n \"def rescale_images(images, rescale='basic', rng=(0,255), dtype='uint8'):\\n # Error check\\n if rescale not in [None, False, 'basic', 'all', 'average']:\\n raise TypeError(\\\"rescale must be None, 'basic', 'all', or 'average'\\\")\\n\\n # Rescale / clip if requested\\n if rescale:\\n # Apply preliminary rescaling if necessary\\n if rescale in ['all', 'average']:\\n trg_min, trg_max = rng\\n\\n # rescale min\\n if rescale == 'all':\\n _min = np.min(images)\\n else: # 'average'\\n _min = np.mean([im.min() for im in images])\\n\\n # Temporarily rescale min to zero\\n for im in images:\\n im -= _min\\n\\n # rescale max\\n if rescale == 'all':\\n _max = np.max(images)\\n else: # 'average'\\n _max = np.mean([np.max(im) for im in images])\\n\\n # Rescale max, accounting for target min\\n for im in images:\\n im *= (trg_max - trg_min) / _max\\n im += trg_min\\n\\n # Clip images to range, cast to requested datatype\\n images = [np.clip(im, *rng).astype(dtype) for im in images]\\n\\n # If rescale is None, cast images to requested datatype without clipping\\n else:\\n images = [im.astype(dtype) for im in images]\\n\\n # Return\\n return images\",\n \"def boxes_postprocess(boxes, image_meta):\\n if 'scales' in image_meta:\\n boxes[:, [0, 2]] /= image_meta['scales'][1]\\n boxes[:, [1, 3]] /= image_meta['scales'][0]\\n\\n if 'padding' in image_meta:\\n boxes[:, [0, 2]] -= image_meta['padding'][2]\\n boxes[:, [1, 3]] -= image_meta['padding'][0]\\n\\n if 'crops' in image_meta:\\n boxes[:, [0, 2]] += image_meta['crops'][2]\\n boxes[:, [1, 3]] += image_meta['crops'][0]\\n\\n if 'flipped' in image_meta and image_meta['flipped']:\\n image_width = image_meta['drifted_size'][1] if 'drifted_size' in image_meta else \\\\\\n image_meta['orig_size'][1]\\n boxes_widths = boxes[:, 2] - boxes[:, 0] + 1.\\n boxes[:, 0] = image_width - 1 - boxes[:, 2]\\n boxes[:, 2] = boxes[:, 0] + boxes_widths - 1.\\n\\n if 'drifts' in image_meta:\\n boxes[:, [0, 2]] += image_meta['drifts'][1]\\n boxes[:, [1, 3]] += image_meta['drifts'][0]\\n\\n return boxes\",\n \"def im_detections(model, im, anchors):\\n k_max, k_min = cfg.FPN.RPN_MAX_LEVEL, cfg.FPN.RPN_MIN_LEVEL\\n A = cfg.RETINANET.SCALES_PER_OCTAVE * len(cfg.RETINANET.ASPECT_RATIOS)\\n inputs = {}\\n inputs['data'], inputs['im_info'] = _get_image_blob(im)\\n cls_probs, box_preds = [], []\\n for lvl in range(k_min, k_max + 1):\\n suffix = 'fpn{}'.format(lvl)\\n cls_probs.append(core.ScopedName('retnet_cls_prob_{}'.format(suffix)))\\n box_preds.append(core.ScopedName('retnet_bbox_pred_{}'.format(suffix)))\\n for k, v in inputs.items():\\n workspace.FeedBlob(core.ScopedName(k), v.astype(np.float32, copy=False))\\n\\n workspace.RunNet(model.net.Proto().name)\\n scale = inputs['im_info'][0, 2]\\n cls_probs = workspace.FetchBlobs(cls_probs)\\n box_preds = workspace.FetchBlobs(box_preds)\\n\\n # here the boxes_all are [x0, y0, x1, y1, score]\\n boxes_all = defaultdict(list)\\n\\n cnt = 0\\n for lvl in range(k_min, k_max + 1):\\n # create cell anchors array\\n stride = 2. ** lvl\\n cell_anchors = anchors[lvl]\\n\\n # fetch per level probability\\n cls_prob = cls_probs[cnt]\\n box_pred = box_preds[cnt]\\n cls_prob = cls_prob.reshape((\\n cls_prob.shape[0], A, int(cls_prob.shape[1] / A),\\n cls_prob.shape[2], cls_prob.shape[3]))\\n box_pred = box_pred.reshape((\\n box_pred.shape[0], A, 4, box_pred.shape[2], box_pred.shape[3]))\\n cnt += 1\\n\\n if cfg.RETINANET.SOFTMAX:\\n cls_prob = cls_prob[:, :, 1::, :, :]\\n\\n cls_prob_ravel = cls_prob.ravel()\\n # In some cases [especially for very small img sizes], it's possible that\\n # candidate_ind is empty if we impose threshold 0.05 at all levels. This\\n # will lead to errors since no detections are found for this image. Hence,\\n # for lvl 7 which has small spatial resolution, we take the threshold 0.0\\n th = cfg.RETINANET.INFERENCE_TH if lvl < k_max else 0.0\\n candidate_inds = np.where(cls_prob_ravel > th)[0]\\n if (len(candidate_inds) == 0):\\n continue\\n\\n pre_nms_topn = min(cfg.RETINANET.PRE_NMS_TOP_N, len(candidate_inds))\\n inds = np.argpartition(\\n cls_prob_ravel[candidate_inds], -pre_nms_topn)[-pre_nms_topn:]\\n inds = candidate_inds[inds]\\n\\n inds_5d = np.array(np.unravel_index(inds, cls_prob.shape)).transpose()\\n classes = inds_5d[:, 2]\\n anchor_ids, y, x = inds_5d[:, 1], inds_5d[:, 3], inds_5d[:, 4]\\n scores = cls_prob[:, anchor_ids, classes, y, x]\\n\\n boxes = np.column_stack((x, y, x, y)).astype(dtype=np.float32)\\n boxes *= stride\\n boxes += cell_anchors[anchor_ids, :]\\n\\n if not cfg.RETINANET.CLASS_SPECIFIC_BBOX:\\n box_deltas = box_pred[0, anchor_ids, :, y, x]\\n else:\\n box_cls_inds = classes * 4\\n box_deltas = np.vstack(\\n [box_pred[0, ind:ind + 4, yi, xi]\\n for ind, yi, xi in zip(box_cls_inds, y, x)]\\n )\\n pred_boxes = (\\n box_utils.bbox_transform(boxes, box_deltas)\\n if cfg.TEST.BBOX_REG else boxes)\\n pred_boxes /= scale\\n pred_boxes = box_utils.clip_tiled_boxes(pred_boxes, im.shape)\\n box_scores = np.zeros((pred_boxes.shape[0], 5))\\n box_scores[:, 0:4] = pred_boxes\\n box_scores[:, 4] = scores\\n\\n for cls in range(1, cfg.MODEL.NUM_CLASSES):\\n inds = np.where(classes == cls - 1)[0]\\n if len(inds) > 0:\\n boxes_all[cls].extend(box_scores[inds, :])\\n\\n # Combine predictions across all levels and retain the top scoring by class\\n detections = []\\n for cls, boxes in boxes_all.items():\\n cls_dets = np.vstack(boxes).astype(dtype=np.float32)\\n # do class specific nms here\\n keep = box_utils.nms(cls_dets, cfg.TEST.NMS)\\n cls_dets = cls_dets[keep, :]\\n out = np.zeros((len(keep), 6))\\n out[:, 0:5] = cls_dets\\n out[:, 5].fill(cls)\\n detections.append(out)\\n\\n detections = np.vstack(detections)\\n # sort all again\\n inds = np.argsort(-detections[:, 4])\\n detections = detections[inds[0:cfg.TEST.DETECTIONS_PER_IM], :]\\n boxes = detections[:, 0:4]\\n scores = detections[:, 4]\\n classes = detections[:, 5]\\n return boxes, scores, classes\",\n \"def refine_rbboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):\\n img_ids = rois[:, 0].long().unique(sorted=True)\\n assert img_ids.numel() == len(img_metas)\\n\\n bboxes_list = []\\n for i in range(len(img_metas)):\\n inds = torch.nonzero(rois[:, 0] == i).squeeze()\\n num_rois = inds.numel()\\n\\n bboxes_ = rois[inds, 1:]\\n label_ = labels[inds]\\n bbox_pred_ = bbox_preds[inds]\\n img_meta_ = img_metas[i]\\n pos_is_gts_ = pos_is_gts[i]\\n\\n bboxes = self.regress_by_class_rbbox(bboxes_, label_, bbox_pred_,\\n img_meta_)\\n # filter gt bboxes\\n pos_keep = 1 - pos_is_gts_\\n keep_inds = pos_is_gts_.new_ones(num_rois)\\n keep_inds[:len(pos_is_gts_)] = pos_keep\\n\\n bboxes_list.append(bboxes[keep_inds])\\n\\n return bboxes_list\",\n \"def _sync_transform(self, epoch_data: Dict[str, Union[Image.Image, List]]) -> None:\\n scale_func = lambda x: int(self.scale_factor * x / 32.0) * 32\\n output_shape = [scale_func(x) for x in self.output_size]\\n\\n # random mirror\\n if self.augmentations.get('rand_flip', False) and random.random() < 0.5:\\n for key, data in epoch_data.items():\\n if key not in ['labels', 'bboxes']:\\n epoch_data[key] = torchvision.transforms.functional.hflip(data)\\n elif key == 'bboxes':\\n epoch_data[key] = self._mirror_bbox(data, CityScapesDataset.base_size)\\n\\n if 'rand_brightness' in self.augmentations:\\n brightness_scale = random.uniform(\\n 1-self.augmentations['rand_brightness']/100,\\n 1+self.augmentations['rand_brightness']/100)\\n for key, data in epoch_data.items():\\n if key in [\\\"l_img\\\", \\\"r_img\\\", \\\"l_seq\\\", \\\"r_seq\\\"]:\\n epoch_data[key] = torchvision.transforms.functional.adjust_brightness(\\n data, brightness_scale)\\n\\n if 'rand_rot' in self.augmentations:\\n # TODO Add mask for bboxes which is required for attention head\\n angle = random.uniform(0, self.augmentations['rand_rot'])\\n for key, data in epoch_data.items():\\n if key in [\\\"l_img\\\", \\\"r_img\\\", \\\"l_seq\\\", \\\"r_seq\\\"]:\\n epoch_data[key] = torchvision.transforms.functional.rotate(\\n data, angle, resample=Image.BILINEAR)\\n elif key in ['disparity', 'seg']:\\n epoch_data[key] = torchvision.transforms.functional.rotate(\\n data, angle, resample=Image.NEAREST, fill=-1)\\n elif key == 'bboxes':\\n self._rotate_bbox(epoch_data, angle)\\n\\n for key, data in epoch_data.items():\\n if key in [\\\"l_img\\\", \\\"r_img\\\", \\\"l_seq\\\", \\\"r_seq\\\", 'center', 'offset']:\\n epoch_data[key] = torchvision.transforms.functional.resize(\\n data, tuple(output_shape[::-1]), Image.BILINEAR)\\n elif key in ['disparity', 'seg', 'foreground'] or key.endswith('mask'):\\n epoch_data[key] = torchvision.transforms.functional.resize(\\n data, tuple(output_shape[::-1]), Image.NEAREST)\\n elif key == \\\"center_points\\\":\\n new_points = []\\n rescale_func = lambda x: [tgt * new / old for (tgt, new, old) \\\\\\n in zip(x, output_shape, CityScapesDataset.base_size)]\\n for points in data:\\n new_points.append(rescale_func(points))\\n epoch_data[key] = new_points\\n elif key == \\\"bboxes\\\":\\n epoch_data[key] = self._scale_bbox(data, output_shape)\\n\\n for key in [\\\"l_img\\\", \\\"r_img\\\", \\\"l_seq\\\", \\\"r_seq\\\"]:\\n if key in epoch_data:\\n epoch_data[key] = self._img_transform(epoch_data[key])\\n\\n if 'disparity' in epoch_data:\\n epoch_data['disparity'] = self._depth_transform(epoch_data['disparity'])\\n\\n if 'seg' in epoch_data:\\n epoch_data['seg'] = self._seg_transform(epoch_data['seg'])\\n\\n if 'offset' in epoch_data:\\n epoch_data['offset'][:,0,:,:] *= output_shape[0] / CityScapesDataset.base_size[0]\\n epoch_data['offset'][:,1,:,:] *= output_shape[1] / CityScapesDataset.base_size[1]\\n\\n if 'crop_fraction' in self.augmentations:\\n # random crop\\n crop_fraction = self.augmentations['crop_fraction']\\n crop_h = int(epoch_data[\\\"l_img\\\"].shape[1] / crop_fraction / 32.0) * 32\\n crop_w = int(epoch_data[\\\"l_img\\\"].shape[2] / crop_fraction / 32.0) * 32\\n crop_x = random.randint(0, epoch_data[\\\"l_img\\\"].shape[2] - crop_w)\\n crop_y = random.randint(0, epoch_data[\\\"l_img\\\"].shape[1] - crop_h)\\n\\n for key, data in epoch_data.items():\\n if key in [\\\"l_img\\\", \\\"r_img\\\", \\\"l_seq\\\", \\\"r_seq\\\"]:\\n epoch_data[key] = data[:, crop_y:crop_y+crop_h, crop_x:crop_x+crop_w]\\n elif key in [\\\"seg\\\", \\\"disparity\\\"]:\\n epoch_data[key] = data[crop_y:crop_y+crop_h, crop_x:crop_x+crop_w]\\n elif key == 'bboxes':\\n self._crop_bbox(data, (crop_x, crop_y, crop_w, crop_h))\",\n \"def nms(bboxes, iou_threshold, sigma = 0.3, method = 'nms'):\\n \\\"\\\"\\\" takes bboxes with the shape of (num_of_box, 6), where 6 => (xmin, ymin, xmax, ymax, score, class) \\\"\\\"\\\"\\n \\n # remove duplicates in classes\\n classes_in_img = list(set(bboxes[:, 5]))\\n \\n # initialise list to store best bboxes\\n best_bboxes = []\\n \\n # iterate over each class\\n for cls in classes_in_img:\\n \\n # get mask for bboxes with the same class and apply on bboxes to obtain array of bboxes with same class\\n cls_mask = (bboxes[:, 5] == cls)\\n cls_bboxes = bboxes[cls_mask]\\n \\n # iterate while there are still bboxes in cls_bboxes\\n while len(cls_bboxes) > 0:\\n \\n # select index of the bbox with the highest score \\n max_ind = np.argmax(cls_bboxes[:, 4])\\n \\n # select bbox with highest score \\n best_bbox = cls_bboxes[max_ind]\\n \\n # append to best _bbox list \\n best_bboxes.append(best_bbox)\\n \\n # obtain cls_bboxes without best bbox\\n cls_bboxes = np.concatenate([cls_bboxes[: max_ind], cls_bboxes[max_ind + 1:]])\\n \\n # calculate iou of remaining bboxes with best bbox \\n iou = bbox_iou(best_bbox[np.newaxis, :4], cls_bboxes[:, :4])\\n \\n weight = np.ones((len(iou), ), dtype = np.float32)\\n \\n # assert method to be either 'nms' or 'soft_nms'\\n assert method in ['nms', 'soft_nms']\\n \\n if method == 'nms':\\n \\n # obtain nms iou mask based on threshold\\n iou_mask = iou > iou_threshold\\n \\n # apply mask on weights\\n weight[iou_mask.numpy()] = 0.0\\n \\n if method == 'soft_nms':\\n \\n # obtain soft_nms weights\\n weight = np.exp(-(1.0 * iou ** 2 / sigma))\\n \\n # apply weights on cls_bboxes\\n cls_bboxes[:, 4] = cls_bboxes[:, 4] * weight\\n \\n # obtain score mask of scores greater than zero\\n score_mask = cls_bboxes[:, 4] > 0.\\n \\n # apply mask on cls_bboxes \\n cls_bboxes = cls_bboxes[score_mask]\\n\\n return best_bboxes\",\n \"def nextBatch(self, TRAIN=True, d=False):\\n while True:\\n if TRAIN==True:\\n idx=np.random.randint(self.split*self.total)\\n else:\\n idx=np.random.randint(self.split*self.total,high=self.total)\\n \\n if len(self.roidb[idx])!=0:\\n break\\n \\n data=self.imdb[idx][np.newaxis,:]\\n gt_boxes=np.array(self.roidb[idx])\\n \\n maskdb=self.maskdb[idx]\\n mask_max_x=0\\n mask_max_y=0\\n for ins in maskdb:\\n if ins.shape[0]>mask_max_y:\\n mask_max_y=ins.shape[0]\\n if ins.shape[1]>mask_max_x:\\n mask_max_x=ins.shape[1]\\n\\n gt_masks=np.zeros((len(maskdb),mask_max_y,mask_max_x))\\n mask_info=np.zeros((len(maskdb),2))\\n for j in range(len(maskdb)):\\n mask=maskdb[j]\\n mask_x=mask.shape[1]\\n mask_y=mask.shape[0]\\n gt_masks[j,0:mask_y,0:mask_x]=mask\\n mask_info[j,0]=mask_y\\n mask_info[j,1]=mask_x\\n\\n blobs={\\n 'data': data,\\n 'gt_boxes': gt_boxes,\\n 'im_info': np.array([[data.shape[2],data.shape[3],1]], dtype=np.float32),\\n 'gt_masks':gt_masks,\\n 'mask_info':mask_info\\n }\\n if d: \\n # i is always 1, in ultrasound case\\n for i in range(blobs['data'].shape[0]):\\n print blobs['im_info']\\n print blobs['mask_info']\\n print blobs['gt_boxes']\\n img=blobs['data'][0,0]\\n print img.shape\\n fig=plt.figure()\\n ax=fig.add_subplot(111)\\n plt.imshow(img)\\n for j,bbox in enumerate(gt_boxes):\\n blank=np.zeros_like(img)\\n print blank.shape,maskdb[j].shape,bbox\\n blank[bbox[1]:maskdb[j].shape[0]+bbox[1],bbox[0]:maskdb[j].shape[1]+bbox[0]]=maskdb[j]\\n blank[blank>0]=1\\n plt.imshow(blank,alpha=.9)\\n ax.add_patch(patches.Rectangle((bbox[0],bbox[1]),bbox[2]-bbox[0],bbox[3]-bbox[1],fill=False))\\n plt.text(bbox[0],bbox[1],bbox[-1],bbox=dict(facecolor='blue',alpha=0.5),fontsize=14, color='white')\\n plt.show()\\n for i in blobs:\\n print i,blobs[i].shape\\n print ''\\n return blobs\",\n \"def get_validation_augmentation():\\n test_transform = [\\n albu.Resize(HEIGHT_TRAIN, WIDTH_TRAIN)\\n ]\\n return albu.Compose(test_transform)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68419516","0.6574216","0.6549093","0.6481572","0.6396106","0.63814837","0.63660586","0.63358074","0.63159716","0.6262087","0.6254781","0.62417847","0.61867654","0.6185712","0.6176265","0.61736345","0.61701804","0.61697906","0.6157004","0.61568195","0.61282754","0.6095269","0.6095269","0.6087811","0.6072449","0.60506654","0.60347396","0.6026667","0.6022652","0.6017986","0.5991483","0.59311974","0.5921985","0.5835662","0.58259195","0.58213055","0.5817027","0.5809459","0.57998186","0.5776526","0.57330585","0.57284844","0.5715683","0.5698396","0.56941414","0.56799066","0.5655047","0.5649579","0.5634023","0.5616983","0.56104666","0.5605733","0.55978256","0.55974764","0.55859566","0.55809903","0.5554419","0.5549628","0.5544453","0.5534523","0.5523009","0.5521507","0.5518123","0.55067164","0.54998237","0.5492552","0.5483006","0.54796576","0.5459956","0.5458098","0.54542726","0.545352","0.54497486","0.5427204","0.54247785","0.5417366","0.5417366","0.54145783","0.5407554","0.5400677","0.53960115","0.53955454","0.53895456","0.53811747","0.53514683","0.53514683","0.5346415","0.53428","0.53385943","0.5337649","0.5335116","0.53334904","0.53300387","0.53274345","0.53216755","0.53216213","0.5319154","0.5308606","0.5302655","0.53002393"],"string":"[\n \"0.68419516\",\n \"0.6574216\",\n \"0.6549093\",\n \"0.6481572\",\n \"0.6396106\",\n \"0.63814837\",\n \"0.63660586\",\n \"0.63358074\",\n \"0.63159716\",\n \"0.6262087\",\n \"0.6254781\",\n \"0.62417847\",\n \"0.61867654\",\n \"0.6185712\",\n \"0.6176265\",\n \"0.61736345\",\n \"0.61701804\",\n \"0.61697906\",\n \"0.6157004\",\n \"0.61568195\",\n \"0.61282754\",\n \"0.6095269\",\n \"0.6095269\",\n \"0.6087811\",\n \"0.6072449\",\n \"0.60506654\",\n \"0.60347396\",\n \"0.6026667\",\n \"0.6022652\",\n \"0.6017986\",\n \"0.5991483\",\n \"0.59311974\",\n \"0.5921985\",\n \"0.5835662\",\n \"0.58259195\",\n \"0.58213055\",\n \"0.5817027\",\n \"0.5809459\",\n \"0.57998186\",\n \"0.5776526\",\n \"0.57330585\",\n \"0.57284844\",\n \"0.5715683\",\n \"0.5698396\",\n \"0.56941414\",\n \"0.56799066\",\n \"0.5655047\",\n \"0.5649579\",\n \"0.5634023\",\n \"0.5616983\",\n \"0.56104666\",\n \"0.5605733\",\n \"0.55978256\",\n \"0.55974764\",\n \"0.55859566\",\n \"0.55809903\",\n \"0.5554419\",\n \"0.5549628\",\n \"0.5544453\",\n \"0.5534523\",\n \"0.5523009\",\n \"0.5521507\",\n \"0.5518123\",\n \"0.55067164\",\n \"0.54998237\",\n \"0.5492552\",\n \"0.5483006\",\n \"0.54796576\",\n \"0.5459956\",\n \"0.5458098\",\n \"0.54542726\",\n \"0.545352\",\n \"0.54497486\",\n \"0.5427204\",\n \"0.54247785\",\n \"0.5417366\",\n \"0.5417366\",\n \"0.54145783\",\n \"0.5407554\",\n \"0.5400677\",\n \"0.53960115\",\n \"0.53955454\",\n \"0.53895456\",\n \"0.53811747\",\n \"0.53514683\",\n \"0.53514683\",\n \"0.5346415\",\n \"0.53428\",\n \"0.53385943\",\n \"0.5337649\",\n \"0.5335116\",\n \"0.53334904\",\n \"0.53300387\",\n \"0.53274345\",\n \"0.53216755\",\n \"0.53216213\",\n \"0.5319154\",\n \"0.5308606\",\n \"0.5302655\",\n \"0.53002393\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6817737"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":89197,"cells":{"query":{"kind":"string","value":"Read data Size of returned data expected to be in range [1..size], otherwise BrokenPipeError must be raised. Reading scope must be entered for duration of reading."},"document":{"kind":"string","value":"def read(self, size):\n with self.reading:\n raise NotImplementedError()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def read(self, size: int = -1) -> bytes:\n if self.size_read >= self.chunksize:\n return b''\n if size < 0:\n size = self.chunksize - self.size_read\n if size > self.chunksize - self.size_read:\n size = self.chunksize - self.size_read\n data = self.file.read(size)\n self.size_read = self.size_read + len(data)\n if self.size_read == self.chunksize and (self.chunksize & 1):\n dummy = self.file.read(1)\n self.size_read = self.size_read + len(dummy)\n return data","def _get_data(self, read_size):\n return self._pipe.recv_bytes()","def read_until_size(self, size):\n if not size:\n do_return(b'')\n with self.reading:\n while len(self.read_buffer) < size:\n self.read_buffer.enqueue((yield self.base.read(self.bufsize)))\n do_return(self.read_buffer.dequeue(size))","async def read_chunk(self, size: int = ...) -> bytes:\n ...","def read(self, size=1):\n assert self.count < len(self.data)\n data = self.data[self.count]\n self.count += 1\n return data","def read(self, size=-1):\n buf = self._fd.read(size)\n self._progress.update(len(buf))\n return buf","def _readData(self):\n # Debug. This fn should be called only after checking canRead()\n if not self._canRead():\n raise Exception(\"Trying to read more data than there is.\")\n\n data = self.buffer[:self._expectedByteCount]\n self.buffer = self.buffer[self._expectedByteCount:]\n\n return data","def read(self, *args, **kwargs):\n return self.limitedstream.read(*args, **kwargs)","def read(self, size, timeout=None):\n assert self._locked\n\n if timeout is None:\n timeout = self.timeout\n return self.ep_data_in.read(size, timeout)","def read(self, size=-1):\n self._check_not_closed()\n raise io.UnsupportedOperation(\"Read not supported\")","def _read(self, length: int) -> bytes:\n if length + self.total_bytes_read > PNG_MAX_FILE_SIZE:\n raise exceptions.PNGTooLarge(\n \"Attempted to read past file size limit: {size} bytes\".format(\n size=PNG_MAX_FILE_SIZE,\n )\n )\n data = self._stream.read(length)\n actual = len(data)\n self.total_bytes_read += actual\n assert length >= actual, \"Read more bytes than requested\"\n if length > actual:\n fmt = \"Expected to read {length}, got {actual}, total read {total}\"\n raise exceptions.UnexpectedEOF(fmt.format(\n length=length,\n actual=actual,\n total=self.total_bytes_read\n ))\n return data","def __read_block(self, size):\n buf = b\"\"\n if len(self.__read_buffer):\n limit = (\n size if size <= len(self.__read_buffer) else\n len(self.__read_buffer)\n )\n buf = self.__read_buffer[:limit]\n self.__read_buffer = self.__read_buffer[limit:]\n size -= limit\n if not size:\n return buf\n try:\n buf += self.sock.recv(size)\n except (socket.timeout, ssl.SSLError):\n raise Error(\"Failed to read %d bytes from the server\" % size)\n self.__dprint(buf)\n return buf","def checked_read(in_stream, length, allow_eof=False):\n\n bytes = in_stream.read(length)\n if allow_eof and bytes == '':\n return bytes\n if len(bytes) != length:\n raise IOError(MSG_INCOMPLETE_READ)\n return bytes","def SafeReadBytes(self, length):\n data = self.ReadBytes(length)\n if len(data) < length:\n raise ValueError(\"Not enough data available\")\n else:\n return data","def read(self, size=-1):\n ...","async def async_readchunks(self, size: int):\n while True:\n data = await self.read(size)\n if data:\n await yield_(data)\n else:\n return","def waitforAndRead(self, size):\n while self.device.inWaiting() < size:\n pass\n else:\n return self.device.read(size)","def read_until_eof(self):\n with self.reading:\n try:\n while True:\n self.read_buffer.enqueue((yield self.base.read(self.bufsize)))\n except BrokenPipeError:\n pass\n do_return(self.read_buffer.dequeue())","def read_data(self, size, attempts = 1):\n data = Array('B')\n # do we have all of the data in the read buffer?\n if size <= len(self.rdbuf) - self.rdofs:\n data = self.rdbuf[self.rdofs : self.rdofs + size]\n self.rdofs += size\n return data\n # do we have some of the data in the read buffer?\n if len(self.rdbuf) - self.rdofs > 0:\n data = self.rdbuf[self.rdofs:]\n # do a usb read to get the rest...\n # read from the usb device\n try:\n bytes_to_rd = size - len(data)\n while bytes_to_rd > 0:\n # read from the usb device\n while True:\n self.rdbuf = self._read()\n self.rdofs = 0\n if len(self.rdbuf) > 0:\n break\n else:\n # no data received\n attempts -= 1\n if attempts > 0:\n # try again\n continue\n # return what we have\n return data\n # copy the read buffer into the returned data\n n = len(self.rdbuf)\n if n >= bytes_to_rd:\n # copy a partial read buffer\n data += self.rdbuf[:bytes_to_rd]\n self.rdofs = bytes_to_rd\n return data\n else:\n # copy all of the read buffer\n data += self.rdbuf\n bytes_to_rd -= n\n # read more data...\n except usb.core.USBError as e:\n raise usbdev_error(str(e))\n # never reached\n raise usbdev_error(\"internal error\")","def read(self, size: int = None) -> bytes:\n if size is None:\n buffer = io.BytesIO()\n copy_stream(self, buffer)\n return buffer.getvalue()\n else:\n return self._read_chunked(size)","def read(self, size: int=-1) -> bytes:\n ...","def read(self, size: int=-1) -> bytes:\n ...","def read(self, size=1):\n \n data = self.fp.read(1)\n if data == '':\n self.fp.seek(0)\n data = self.fp.read(1)\n \n return data","def read(self, size=-1):\n\n if size < 0:\n raise NotImplementedError(\"Don't be greedy, that could be massive!\")\n elif size == 0:\n if self._text:\n return \"\"\n else:\n return b\"\"\n elif self._within_block_offset + size <= len(self._buffer):\n # This may leave us right at the end of a block\n # (lazy loading, don't load the next block unless we have too)\n data = self._buffer[self._within_block_offset:self._within_block_offset + size]\n self._within_block_offset += size\n assert data # Must be at least 1 byte\n return data\n else:\n # if read data overflows to next block\n # pull in rest of data in current block\n data = self._buffer[self._within_block_offset:]\n\n # decrement size so that we only pull the rest of the data\n # from next block\n size -= len(data)\n self._load_block() # will reset offsets\n\n if not self._buffer:\n return data # EOF\n\n # if there is still more to read\n elif size:\n # pull rest of data from next block\n return data + self.read(size)\n else:\n # Only needed the end of the last block\n return data","def _buffered_func(dataset, size):\n\n class _EndSignal(object):\n pass\n\n end = _EndSignal()\n\n def _read_worker(r, q):\n for d in r:\n q.put(d)\n q.put(end)\n\n def _data_reader():\n r = dataset()\n q = multiprocessing.Queue(maxsize=size)\n t = multiprocessing.Process(\n target=_read_worker, args=(\n r,\n q, ))\n t.daemon = True\n t.start()\n e = q.get()\n while e != end:\n yield e\n e = q.get()\n\n return _data_reader","def read(self, num_bytes_to_read):\n pass","def read(self, n=-1):\n\n if self._exception is not None:\n raise self._exception\n\n if n == 0:\n return b''\n\n if n < 0:\n # This used to just loop creating a new waiter hoping to\n # collect everything in self._buffer, but that would\n # deadlock if the subprocess sends more than self.limit\n # bytes. So just call self.read(self._limit) until EOF.\n blocks = []\n while True:\n block = yield from self.read(self._limit)\n if not block:\n break\n blocks.append(block)\n return b''.join(blocks)\n\n if not self._buffer and not self._eof:\n yield from self._wait_for_data('read')\n\n # This will work right even if buffer is less than n bytes\n data = bytes(self._buffer[:n])\n del self._buffer[:n]\n\n self._maybe_resume_transport()\n return data","def buffered(reader, size):\n\n class EndSignal():\n pass\n\n end = EndSignal()\n\n def read_worker(r, q):\n for d in r:\n q.put(d)\n q.put(end)\n\n def data_reader():\n r = reader()\n q = Queue(maxsize=size)\n t = Thread(\n target=read_worker, args=(\n r,\n q, ))\n t.daemon = True\n t.start()\n e = q.get()\n while e != end:\n yield e\n e = q.get()\n\n return data_reader","async def _read(self, n):\n return await self._reader.readexactly(n)","def _serial_read(self, size):\n self.write([self.SERIAL_IO])\n resp = self.read(size)\n data = self.decode(resp)\n return data","def read(self, size=None):\n if size is None or size < 0:\n return \"\".join(list(self))\n else:\n data_chunks = []\n data_readed = 0\n try:\n while data_readed < size:\n chunk = self.next_chunk()\n data_chunks.append(chunk)\n data_readed += len(chunk)\n except StopIteration:\n pass\n\n if data_readed > size:\n last_chunk = data_chunks.pop()\n extra_length = data_readed - size\n last_chunk, extra_data = last_chunk[:-extra_length], last_chunk[-extra_length:]\n self.unshift(extra_data)\n data_chunks.append(last_chunk)\n return \"\".join(data_chunks)","def read(self, size: int) -> bytes:\n\n return self.r.read(size)","def read(self, size=None):\n if not size:\n rlen = self.end - self.pos\n else:\n rlen = size\n if rlen == 0:\n return '' # Fake EOF\n # Clamp rlen to window end\n if self.pos + rlen > self.end:\n rlen = self.end - self.pos\n data = self.file.read(rlen)\n self.pos += len(data)\n return data","def read(self, size=-1):\n _complain_ifclosed(self._closed)\n buf = self._buf\n while size < 0 or len(buf) < size:\n try:\n buf = buf + next(self._generator)\n except StopIteration:\n break\n\n returned = b\"\"\n if size >= 1:\n self._buf = buf[size:]\n returned = buf[:size]\n else:\n self._buf = b\"\"\n returned = buf\n\n self._position = self._position + len(returned)\n return returned","def _read_fixed(buf, length):\n result = buf.read(length)\n actual = len(result)\n if actual != length:\n raise EndOfMessage(False if actual == 0 else True)\n return result","def read(self, addr: int, size: int, **kwargs) -> bytes:\n ret = bytearray()\n\n if not kwargs.get('suppress_setup', False):\n self._setup(addr, size)\n\n desc = self._describe_op(addr, size)\n show = kwargs.get('show_progress', True)\n progress = self._ctx.create_progress_indicator(self, size, desc, unit='B', show=show)\n\n def _update_progress(data: bytes):\n ret.extend(data)\n progress.update(len(data))\n\n try:\n self._read(addr, size, _update_progress)\n except KeyboardInterrupt:\n msg = 'Read operation interrupted. {:d} / {:d} bytes read.'\n log.warning(msg.format(len(ret), size))\n finally:\n self._ctx.close_progress_indicator(progress)\n\n if not kwargs.get('suppress_teardown', False):\n self._teardown()\n\n return bytes(ret)","def _read_length(self):\n msg_length = struct.unpack('!I', self.received_data[0])[0]\n self.l.debug('msg_length = %d', msg_length)\n self.set_terminator(msg_length)\n self.process_data = self._read_message\n self.received_data = []","def read_until(self, expected=serial.LF, size=None) -> bytes:\n logger.debug(f\"read_until(expected={expected}, size={size})\")\n return self._con.read_until(expected=expected, size=size)","def Read_Bytes(self, size = 0):\r\n if size == 0: size = self.Port.inWaiting()\r\n data = self.Port.read(size)\r\n return data","def read(self, batch_size=1):\n cur_q_size = len(self._queue)\n while cur_q_size < batch_size:\n if self._thread.get_exception() is not None:\n break\n time.sleep(0.1)\n cur_q_size = len(self._queue)\n\n exception = self._thread.get_exception()\n if isinstance(exception, EndOfVideoError):\n if cur_q_size == 0:\n raise EndOfVideoError()\n elif cur_q_size <= batch_size:\n data = self._read_all()\n else:\n data = self._read(batch_size)\n elif isinstance(exception, ConnectionBrokenError):\n raise ConnectionBrokenError()\n else:\n # XXX: In this case we are assuming that everything is fine,\n # and current queue size should greater than the batch\n # size.\n data = self._read(batch_size)\n return data","def safe_read_chunk(self, name, offset=0, length=1024):\n full_path = self.path(name)\n byte_buffer = None\n l = 0\n if self.exists(name):\n with caches['default'].lock('{}_{}'.format(full_path, 'reader')):\n fd = self.__volume.fopen(full_path, 'r')\n try:\n fsize = self.__volume.getsize(full_path)\n if offset < fsize:\n rlength = fsize - offset\n l = length\n if rlength < length:\n l = rlength\n fd.lseek(offset)\n byte_buffer = fd.read(l)\n finally:\n fd.close()\n return (byte_buffer, l)","def recv_size(self, size, timeout=_UNSET):\n with self._recv_lock:\n if timeout is _UNSET:\n timeout = self.timeout\n chunks = []\n total_bytes = 0\n try:\n start = time.time()\n self.sock.settimeout(timeout)\n nxt = self.rbuf or self.sock.recv(self._recvsize)\n while nxt:\n total_bytes += len(nxt)\n if total_bytes >= size:\n break\n chunks.append(nxt)\n if timeout:\n cur_timeout = timeout - (time.time() - start)\n if cur_timeout <= 0.0:\n raise socket.timeout()\n self.sock.settimeout(cur_timeout)\n nxt = self.sock.recv(self._recvsize)\n else:\n msg = ('connection closed after reading %s of %s requested'\n ' bytes' % (total_bytes, size))\n raise ConnectionClosed(msg) # check recv buffer\n except socket.timeout:\n self.rbuf = b''.join(chunks)\n msg = 'read %s of %s bytes' % (total_bytes, size)\n raise Timeout(timeout, msg) # check recv buffer\n except Exception:\n # received data is still buffered in the case of errors\n self.rbuf = b''.join(chunks)\n raise\n extra_bytes = total_bytes - size\n if extra_bytes:\n last, self.rbuf = nxt[:-extra_bytes], nxt[-extra_bytes:]\n else:\n last, self.rbuf = nxt, b''\n chunks.append(last)\n return b''.join(chunks)","def _get_data(self, read_size):\n if NIX:\n return super(Mouse, self)._get_data(read_size)\n return self._pipe.recv_bytes()","def __ReadBytes(self, size, block=True):\n need_more_data = True\n result = b''\n while need_more_data:\n read_bytes = self.__input_stream.read(size)\n if read_bytes:\n result += read_bytes\n elif read_bytes is not None:\n return (result, False)\n elif not block:\n return (result, True)\n need_more_data = (len(result) < size)\n\n return (result, True)","def read(self, address, size, progress_update=None):\n size_remain = size\n data = bytearray()\n\n while size_remain > 0:\n if progress_update is not None:\n progress_update(int(100 * (size - size_remain) / size))\n\n part_size = self.__RW_MAX_SIZE \\\n if size_remain > self.__RW_MAX_SIZE else size_remain\n offset = address + size - size_remain\n\n for retry in range(0, self.__RETRY_MAX_NUM):\n self._send_command(self.__COMMAND['read memory'])\n self._set_address(offset)\n\n self._port_handle.write(\n [part_size - 1, self._checksum(part_size - 1)])\n if self._is_acknowledged():\n break\n else:\n raise DfuException('Read memory at {} failed after {} '\n 'retries.'.format(offset, retry + 1))\n\n chunk = self._port_handle.read(part_size)\n if len(chunk) != part_size:\n raise DfuException('Read {} bytes istead of '\n '{}.'.format(len(chunk), part_size))\n data.extend(bytearray(chunk))\n\n size_remain -= part_size\n\n if progress_update is not None:\n progress_update(100)\n\n return data","def read(self, len, timeout = 0):\n if timeout < 0:\n timeout = 0\n else:\n timeout += _timeout\n\n try:\n return self._snc.read(len, timeout)\n except Exception as e:\n log.error(\"failed to read [len={0}]:\\n{1!r}\" .\n format(len, e))\n raise Error","def _read_raw_bytes_direct(self, size):\n with(self.visa_handle.ignore_warning(pyvisa.constants.VI_SUCCESS_MAX_CNT)):\n data, statuscode = self.visa_handle.visalib.read(\n self.visa_handle.session, size)\n\n return data","def _readBytes(self, len):\n return self.stream.read(len)","def _read_raw_bytes_multiple(self, size, maxread=512, verbose=0):\n ret = []\n instr = self.visa_handle\n with self.visa_handle.ignore_warning(pyvisa.constants.VI_SUCCESS_MAX_CNT):\n nread = 0\n while nread < size:\n nn = min(maxread, size - nread)\n chunk, status = instr.visalib.read(instr.session, nn)\n ret += [chunk]\n nread += len(chunk)\n if verbose:\n print('_read_raw: %d/%d bytes' % (len(chunk), nread))\n ret = b''.join(ret)\n return ret","def read(self, size=-1):\n if not self._buf:\n self._buf.append(next(self._iter, b''))\n if len(self._buf[0]) < size or size < 0:\n return self._buf.pop(0)\n block = self._buf.pop(0)\n self._buf.insert(0, block[size:])\n return block[:size]","async def read(self, wait_closed=True):\n content = b''\n # wait until the pipe is opened by a writer\n await wait_readable(self.fd)\n while True:\n try:\n item = os.read(self.fd, self.blocksize)\n except BlockingIOError:\n # pipe is blocked\n if wait_closed:\n await wait_readable(self.fd)\n else:\n break\n else:\n if not item:\n # pipe is closed\n break\n else:\n content += item\n if self.encoding is not None:\n content = content.decode(self.encoding)\n return content","def getData(self, src, chunk_size=1024):\n d = src.read(chunk_size)\n while d:\n yield d\n d = src.read(chunk_size)","def _get_data(self, read_size):\n if NIX:\n return super(Keyboard, self)._get_data(read_size)\n return self._pipe.recv_bytes()","def read(self, *args, **kwargs):\r\n buf = io.BufferedReader.read(self, *args, **kwargs)\r\n self.increment(len(buf))\r\n return buf","def read(self, endpoint, size):\n return self.device.read(endpoint, size)","def read(self, size=None, timeout_ms=None, **kwargs):\n raise NotImplementedError(\"implement in derived transport class\")","def read(self):\n while True:\n size_bytes = self.connection.read(Frame.SIZE_WIDTH)\n # Read will return zero bytes when the other side of the connection\n # closes.\n if not size_bytes:\n break\n\n message_length = read_number_string(size_bytes, Frame.SIZE_WIDTH)\n\n chunk = self.connection.read(message_length - Frame.SIZE_WIDTH)\n if not chunk:\n raise ProtocolException(\n 'Expected %d bytes available, got none' % message_length\n )\n\n if len(chunk) != message_length - Frame.SIZE_WIDTH:\n raise ProtocolException(\n 'Expected %d bytes, got %d' %\n (len(chunk), message_length - Frame.SIZE_WIDTH)\n )\n\n yield Frame.decode(BytesIO(chunk), message_length)","def _read_blocks(input_data, size=2**20):\n\n if isinstance(input_data, (BufferedReader, BytesIO)):\n f = input_data\n opened = False\n elif input_data == '-':\n f = sys.stdin.buffer # read binary instead of unicode\n opened = False\n else:\n f = open(input_data, 'rb')\n opened = True\n\n try:\n\n data = f.read(size)\n while len(data) > 0:\n yield data\n data = f.read(size)\n finally:\n if opened:\n f.close()","def read(self, size=-1):\n chunk_index, prefix_size = self._index_pos(self._pos)\n prefixed_buffer = []\n try:\n if size < 0:\n while True:\n prefixed_buffer.append(self._readchunk(chunk_index))\n chunk_index += 1\n else:\n need = prefix_size + size\n while need > 0:\n chunk_data = self._readchunk(chunk_index)\n prefixed_buffer.append(chunk_data[:need])\n need -= len(chunk_data)\n chunk_index += 1\n\n except EOFError:\n # PR#16/18 - support identifying EOF\n # use a read() as a sync from desired position to actual position\n # read(0) can be used as a synchronization call\n dec_eof_position = self._members[-1].start_pos + self._members[-1].isize\n self._pos = dec_eof_position\n if prefixed_buffer:\n # subtracting the data in the EOF Case so the normal path will add it back\n # before the function return to avoid changing the path\n # adding up lengths rather than concatenating here to avoid creating new buffers\n self._pos -= sum([len(x) for x in prefixed_buffer]) - prefix_size\n prefixed_buffer = b\"\".join(prefixed_buffer)\n result = prefixed_buffer[prefix_size:]\n self._pos += len(result)\n return result","def _get_data(self):\n while not (self.closed or self.ended):\n block = self.stream.read(8192)\n with self.lock:\n if len(block) == 0:\n self.ended = True\n else:\n self.data.append(block)\n self.available.set()","def read_full(fileobj, size):\n\n if size < 0:\n raise ValueError(\"size must not be negative\")\n\n data = fileobj.read(size)\n if len(data) != size:\n raise IOError\n return data","def read_raw(self, chunk_size=512):\n\n log.debug('Reading from device \"{0}\".'.format(self.name))\n\n buf = ''\n\n if self.driver in [drivers.pyvisa, drivers.pyvisa_usb]:\n try:\n buf = self.device.read_raw()\n except pyvisa.VisaIOError as e:\n raise\n\n elif self.driver == drivers.telnet:\n try:\n buf = self.device.read_until('\\r\\n')\n except Exception as e:\n if e is socket.timeout:\n raise DeviceTimeout(e)\n else:\n raise\n elif self.driver == drivers.requests:\n buf = requests.get(self.request_address)\n\n elif self.driver == drivers.lgpib:\n status = 0\n while status == 0:\n try:\n buf += self.device.read(len=chunk_size)\n except gpib.GpibError as e:\n if 'timeout' in e.message:\n raise DeviceTimeout(e)\n else:\n raise\n\n status = self.device.ibsta() & IbstaBits.END\n\n log.debug('Read from device \"{0}\": {1!r}'.format(self.name, buf))\n\n return buf","def read_chunks(self):\n buf = []\n chunks = []\n delays = []\n if not self.chunked:\n chunks.append(self.read())\n delays.append(0)\n else:\n start = TIMER()\n try:\n while True:\n line = self.fp.readline()\n chunk_size = self._read_chunk_size(line)\n if chunk_size is None:\n raise httplib.IncompleteRead(''.join(chunks))\n if chunk_size == 0:\n break\n delays.append(TIMER() - start)\n chunks.append(self._safe_read(chunk_size))\n self._safe_read(2) # skip the CRLF at the end of the chunk\n start = TIMER()\n\n # Ignore any trailers.\n while True:\n line = self.fp.readline()\n if not line or line == '\\r\\n':\n break\n finally:\n self.close()\n return chunks, delays","async def _read_content(\n self, length: int, max_parts=1000, max_empties=200\n ) -> Optional[bytes]:\n raw = None\n raw_parts: List[bytes] = []\n received_size = 0\n while received_size < length and len(raw_parts) < max_parts and max_empties > 0:\n part = None\n try:\n part = self.stream.read(length - received_size)\n except OSError: # pragma: no cover\n pass\n if part is None:\n max_empties -= 1\n await self.sleep()\n continue\n received_size += len(part)\n raw_parts.append(part)\n\n if raw_parts:\n raw = b\"\".join(raw_parts)\n if len(raw) != length: # pragma: no cover\n self.log.warning(\n f\"Readout and content-length mismatch: {len(raw)} vs {length};\"\n f\"remaining empties: {max_empties}; remaining parts: {max_parts}\"\n )\n\n return raw","def readline(self, size=-1):\n ...","def read(self, nbytes: int, /) -> Optional[bytes]:","def read(self, nbytes: Optional[int] = None) -> Optional[bytes]:\n ...","def _read(self):\n if not self.connected:\n raise IOError(\"Not connected.\")\n\n try:\n with self._read_lock:\n if not self.connected:\n raise IOError(\"Not connected.\")\n data = self._reader.readline(self.MAX_MESSAGE_SIZE)\n # If there weren't a \"\\r\\n\" between the last message\n # and the EOF we would have a false positive here.\n # Luckily there is one.\n if len(data) > 0 and not data.endswith(b\"\\r\\n\"):\n logger.error(\n \"The client sent a message larger than %d bytes (that \"\n \"is MAX_MESSAGE_SIZE). Consider raising that value if \"\n \"the message seemed legit.\", self.MAX_MESSAGE_SIZE)\n self.finalize(\"Client misbehaving.\")\n raise IOError(\"Message too long.\")\n except socket.error as error:\n if self.connected:\n logger.warning(\"Failed reading from socket: %s.\", error)\n self.finalize(\"Read failed.\")\n raise error\n else:\n # The client was terminated willingly; its correct termination\n # is handled in disconnect(), so here we can just return.\n return b\"\"\n\n return data","def get_block(self):\n # Read in data in blocks so as to not tie up the CPU.\n BLOCK_SIZE = 1024\n eof = False\n data = ''\n while not eof:\n next_block = self._stream_handle.read(BLOCK_SIZE)\n if next_block:\n data = data + next_block\n gevent.sleep(0)\n else:\n eof = True\n\n if data != '':\n self._chunker.add_chunk(data, self._timestamp)\n self.file_complete = True\n return len(data)\n else: # EOF\n self.file_complete = True\n raise EOFError","def _receive(self, length, timeout=None, skip_len_check=False):\n data = self._receive_internal(length, timeout)\n if not skip_len_check and len(data) < length:\n raise ButtshockIOError(\"Received unexpected length {}, expected {}!\".format(len(data), length))\n if len(data) > 0:\n self._debug_print('received data: %s' % data)\n return data","def recv_data(self):\n data = \"\"\n size = 0\n\n try:\n size = self.sockObj.recv(4) #Get metadata\n except:\n raise Exception(\"Error while receiving data. Probably broken pipe\")\n\n if len(size) == 0:\n raise Exception(\"No data recivied. Probably broken pipe\")\n\n size = struct.unpack('>I',size)[0]\n\n data = self.sockObj.recv(size)\n\n if len(data) != size:\n raise Exception(\"Partiala data recivied\")\n\n return self.decode(data)","async def readchunk(self) -> Tuple[bytes, bool]:\n ...","def _get_data(self, read_size):\n return self._character_device.read(read_size)","def recv(self, bufsize):\r\n return self.read(bufsize)","def read(self, address, size):\n raise NotImplementedError","def read_until(\n self,\n min_num_bytes: int,\n ending: bytes,\n timeout: float = 10.0,\n data_consumer=None,\n ):\n\n data = b''\n\n # If a miniumum number of bytes is given, wait till at least\n # that number of bytes are received. If the value is 0, then\n # continue, and rely on the terminator and timeout values.\n if min_num_bytes:\n data = self.con.read(min_num_bytes)\n # debug(f'read {data=}')\n if data_consumer:\n data_consumer(data)\n\n timeout_count = 0\n while True:\n if ending and data.endswith(ending):\n break\n else:\n # debug(f\"{ending=} was not found\")\n pass\n\n if self.con.inWaiting() > 0:\n new_data = self.con.read(1)\n # debug(f'read {new_data=}')\n data = data + new_data\n # if len(data) > 80:\n # debug(f'data: len={len(data)} {data[-80:]=}')\n # else:\n # debug(f'data: len={len(data)} {data=}')\n if data_consumer:\n data_consumer(new_data)\n # timeout_count = 0\n else:\n timeout_count += 1\n # debug(f'{timeout_count=}')\n if timeout is not None and timeout_count >= 100 * timeout:\n if not data:\n debug(f\"TIMEOUT - No data received within {timeout} seconds\")\n else:\n debug(f\"TIMEOUT - data {data} did not end with {ending}\")\n break\n time.sleep(0.01)\n debug(f\"read_until returns {data=}\")\n return data","def read(self, length=None):\r\n try:\r\n if length is not None:\r\n return self._fp.read(length)\r\n return self._fp.readline()\r\n except socket.error, e:\r\n self.disconnect()\r\n if e.args and e.args[0] == errno.EAGAIN:\r\n raise ConnectionError(\"Error while reading from socket: %s\" % \\\r\n e.args[1])\r\n return ''","def readBuffer(self, start, buffer_size):\r\n\r\n start, stop = self.getReadParameters(start, buffer_size)\r\n try:\r\n # data_source is a tables.Table or a tables.XArray\r\n # but data is a numpy array\r\n # Warning: in a EArray with shape (2,3,3) and extdim attribute\r\n # being 1, the read method will have 3 rows. However, the numpy\r\n # array returned by EArray.read() will have only 2 rows\r\n data = self.data_source.read(start, stop)\r\n except tables.HDF5ExtError:\r\n print(translate('Buffer',\r\n \"\"\"\\nError: problems reading records. The dataset maybe \"\"\"\r\n \"\"\"corrupted.\"\"\",\r\n 'A dataset readability error'))\r\n except:\r\n vitables.utils.formatExceptionInfo()\r\n else:\r\n # Update the buffer contents and its start position\r\n self.chunk = data\r\n self.start = start","def read(self, nbytes: int, /) -> bytes | None:","def _read_nowait(self, n: int) -> bytes:\n ...","def peek(self, size, timeout=_UNSET):\n with self._recv_lock:\n if len(self.rbuf) >= size:\n return self.rbuf[:size]\n data = self.recv_size(size, timeout=timeout)\n self.rbuf = data + self.rbuf\n return data","def read(self, length = 1024):\n\n return self.socket.recv(length)","def read(self, length = 1024):\n\n return self.socket.recv(length)","def _filesync_read_buffered(self, size, adb_info, filesync_info):\n # Ensure recv buffer has enough data.\n while len(filesync_info.recv_buffer) < size:\n _, data = self._read_until([constants.WRTE], adb_info)\n filesync_info.recv_buffer += data\n\n result = filesync_info.recv_buffer[:size]\n filesync_info.recv_buffer = filesync_info.recv_buffer[size:]\n return result","def read_bytes(self, size):\n return self.read('bytes:'+str(size))","def read(self, size):\n if size % self.recordsize != 0:\n raise ValueError(\"Cannot read a non-integer number of records\")\n\n # ensure we do not read beyond end\n size = min(size, len(self.files) * self.filesize - self.offset)\n if size <= 0:\n raise EOFError('At end of file!')\n\n # allocate buffer.\n z = np.empty(size, dtype=np.int8)\n\n # read one or more pieces\n iz = 0\n while(iz < size):\n self._seek(self.offset)\n block, already_read = divmod(self.offset, self.filesize)\n fh_size = min(size - iz, self.filesize - already_read)\n z[iz:iz+fh_size] = np.fromstring(self.fh_raw.read(fh_size),\n dtype=z.dtype)\n iz += fh_size\n self.offset += fh_size\n\n return z","def read(self, nbytes, /) -> bytes | None:","def read_pipe(pipe_out):\n out = b''\n while more_data(pipe_out):\n out += os.read(pipe_out, 1024)\n\n return out.decode('utf-8')","def Read(buf: IO[bytes]) -> Optional[bytes]:\n count_bytes = buf.read(_UINT64.size)\n if not count_bytes:\n return None\n\n try:\n (count,) = _UINT64.unpack(count_bytes)\n except struct.error as error:\n raise ValueError(f\"Incorrect size tag {count_bytes}: {error}\")\n\n # It might happen that we are given file with incorrect format. If the size\n # tag is interpreted as a huge number, reading the buffer will lead to raising\n # an exception, because Python will try to allocate a buffer to read into. If\n # possible, we try to check guard against such situations and provide more\n # informative exception message.\n\n def Error(left: int) -> ValueError:\n message = f\"Malformed input (reading {count} bytes out of {left} available)\"\n return ValueError(message)\n\n if buf.seekable():\n position = buf.tell()\n\n buf.seek(0, os.SEEK_END)\n size = buf.tell()\n\n if count > size - position:\n raise Error(size - position)\n\n buf.seek(position, os.SEEK_SET)\n\n chunk = buf.read(count)\n if len(chunk) != count:\n raise Error(len(chunk))\n\n return chunk","def _read_no_check(self):\n on_data_fut = _async.Future(self._loop)\n def on_data():\n on_data_fut.set_result(None)\n self._loop.add_reader(self._channel.fileno(), on_data)\n\n try:\n yield From(on_data_fut)\n finally:\n self._loop.remove_reader(self._channel.fileno())\n\n d = self._channel.recv(_MAX_READ_AMOUNT).decode()\n if d == '':\n logger.debug(\"{}: Read returned {!r}\".format(self, d))\n raise TransportNotConnected\n\n logger.debug(\"{}: Read {!r}\".format(self, d))\n if d.endswith(\"\\r\\n\"):\n d = d[:-2] + \"\\n\"\n d = d.encode('ascii')\n\n raise Return(d)","def read(self, length=1024):\n\n return self.socket.recv(length)","def _handle_read(self):\n try:\n data = self.recv (self.ac_in_buffer_size)\n except socket.error, why:\n self.handle_error()\n return\n\n if hasattr(self.socket, 'ssl_version'):\n # Fix for SSL wrapped sockets, checks if there is any data pending in\n # the SSL Socket's internal buffer and recv's it before contining.\n ssl_data_remainder = ''\n amount_of_data_left_over = self.socket.pending()\n while amount_of_data_left_over > 0:\n # while the ssl socket still has some data pending\n try:\n # get the remaining data\n ssl_data_remainder += self.recv(amount_of_data_left_over)\n except socket.error, why:\n self.handle_error()\n return\n # check if there is anymore remaining\n amount_of_data_left_over = self.socket.pending()\n data += ssl_data_remainder # add the remainder to the data\n self.ac_in_buffer = self.ac_in_buffer + data\n\n # Continue to search for self.terminator in self.ac_in_buffer,\n # while calling self.collect_incoming_data. The while loop\n # is necessary because we might read several data+terminator\n # combos with a single recv(4096).\n\n while self.ac_in_buffer:\n lb = len(self.ac_in_buffer)\n terminator = self.get_terminator()\n if not terminator:\n # no terminator, collect it all\n self.collect_incoming_data (self.ac_in_buffer)\n self.ac_in_buffer = ''\n elif isinstance(terminator, int) or isinstance(terminator, long):\n # numeric terminator\n n = terminator\n if lb < n:\n self.collect_incoming_data (self.ac_in_buffer)\n self.ac_in_buffer = ''\n self.terminator = self.terminator - lb\n else:\n self.collect_incoming_data (self.ac_in_buffer[:n])\n self.ac_in_buffer = self.ac_in_buffer[n:]\n self.terminator = 0\n self.found_terminator()\n else:\n # 3 cases:\n # 1) end of buffer matches terminator exactly:\n # collect data, transition\n # 2) end of buffer matches some prefix:\n # collect data to the prefix\n # 3) end of buffer does not match any prefix:\n # collect data\n terminator_len = len(terminator)\n index = self.ac_in_buffer.find(terminator)\n if index != -1:\n # we found the terminator\n if index > 0:\n # don't bother reporting the empty string\n # (source of subtle bugs)\n self.collect_incoming_data (self.ac_in_buffer[:index])\n self.ac_in_buffer = self.ac_in_buffer[index+terminator_len:]\n # This does the Right Thing if the terminator\n # is changed here.\n self.found_terminator()\n else:\n # check for a prefix of the terminator\n index = asynchat.find_prefix_at_end (self.ac_in_buffer, terminator)\n if index:\n if index != lb:\n # we found a prefix, collect up to the prefix\n self.collect_incoming_data (self.ac_in_buffer[:-index])\n self.ac_in_buffer = self.ac_in_buffer[-index:]\n break\n else:\n # no prefix, collect it all\n self.collect_incoming_data (self.ac_in_buffer)\n self.ac_in_buffer = ''","async def read(self, n: int = -1) -> AnyStr:\n\n # load file\n if len(self._buffer) == 0 and \"r\" in self.mode:\n await self._download()\n\n # check size\n if n == -1:\n data = self._buffer\n self._pos = len(self._buffer) - 1\n else:\n # extract data to read\n data = self._buffer[self._pos : self._pos + n]\n self._pos += n\n\n # return data\n return data","async def read(self, num_bytes=0) -> bytes:\n if num_bytes < 1:\n num_bytes = self.in_waiting or 1\n\n return await self._read(num_bytes)","def buffered_read(file_object, chunk_size=1024):\n while True:\n data = file_object.read(chunk_size)\n if not data:\n break\n yield data","def Read(self, data, address=None, size=None):\n if not address:\n address = self.mem_address\n if hasattr(address, 'value'):\n address = address.value\n\n if size:\n nSize = win32structures.ULONG_PTR(size)\n else:\n nSize = win32structures.ULONG_PTR(sizeof(data))\n\n if self.size < nSize.value:\n raise Exception(('Read: RemoteMemoryBlock is too small ({0} bytes),' +\n ' {1} is required.').format(self.size, nSize.value))\n\n if hex(address).lower().startswith('0xffffff'):\n raise Exception('Read: RemoteMemoryBlock has incorrect address =' + hex(address))\n\n lpNumberOfBytesRead = c_size_t(0)\n\n ret = win32functions.ReadProcessMemory(\n c_void_p(self.process),\n c_void_p(address),\n byref(data),\n nSize,\n byref(lpNumberOfBytesRead)\n )\n\n # disabled as it often returns an error - but\n # seems to work fine anyway!!\n if ret == 0:\n # try again\n ret = win32functions.ReadProcessMemory(\n c_void_p(self.process),\n c_void_p(address),\n byref(data),\n nSize,\n byref(lpNumberOfBytesRead)\n )\n if ret == 0:\n last_error = win32api.GetLastError()\n if last_error != win32defines.ERROR_PARTIAL_COPY:\n ActionLogger().log('Read: WARNING! self.mem_address =' +\n hex(self.mem_address) + ' data address =' + str(byref(data)))\n ActionLogger().log('LastError = ' + str(last_error) +\n ': ' + win32api.FormatMessage(last_error).rstrip())\n else:\n ActionLogger().log('Error: ERROR_PARTIAL_COPY')\n ActionLogger().log('\\nRead: WARNING! self.mem_address =' +\n hex(self.mem_address) + ' data address =' + str(byref(data)))\n\n ActionLogger().log('lpNumberOfBytesRead =' +\n str(lpNumberOfBytesRead) + ' nSize =' + str(nSize))\n raise WinError()\n else:\n ActionLogger().log('Warning! Read OK: 2nd attempt!')\n #else:\n # print 'Read OK: lpNumberOfBytesRead =', lpNumberOfBytesRead, ' nSize =', nSize\n\n self.CheckGuardSignature()\n return data","def _read(self, location, width):\n return self._connector.read(location=location, width=width)","async def read(self,\n n: int = -1\n ) -> bytes:\n if n == 0:\n return b''\n\n future = asyncio.Future()\n try:\n self._read_queue.put_nowait((future, False, n))\n return await future\n\n except aio.QueueClosedError:\n raise ConnectionError()","def recv(self, size, flags=0, timeout=_UNSET):\n with self._recv_lock:\n if timeout is _UNSET:\n timeout = self.timeout\n if flags:\n raise ValueError(\"non-zero flags not supported: %r\" % flags)\n if len(self.rbuf) >= size:\n data, self.rbuf = self.rbuf[:size], self.rbuf[size:]\n return data\n if self.rbuf:\n ret, self.rbuf = self.rbuf, b''\n return ret\n self.sock.settimeout(timeout)\n try:\n data = self.sock.recv(self._recvsize)\n except socket.timeout:\n raise Timeout(timeout) # check the rbuf attr for more\n if len(data) > size:\n data, self.rbuf = data[:size], data[size:]\n return data","def readinto(self, b):\n if not self._readable:\n raise UnsupportedOperation(\"read\")\n elif not self._seekable:\n return self._raw.readinto(b)\n\n with self._seek_lock:\n seek = self._seek\n queue = self._read_queue\n\n if seek == 0:\n self._preload_range()\n\n size = len(b)\n if size:\n # Pre-allocated buffer: Use memory view to avoid copies\n b_view = memoryview(b)\n size_left = size\n else:\n # Dynamic buffer: Can't avoid copy, read until EOF\n b_view = b\n size_left = -1\n b_end = 0\n\n buffer_size = self._buffer_size\n while size_left > 0 or size_left == -1:\n start = seek % buffer_size\n queue_index = seek - start\n try:\n buffer = queue[queue_index]\n except KeyError:\n # EOF\n break\n\n with handle_os_exceptions():\n try:\n queue[queue_index] = buffer = buffer.result()\n\n except AttributeError:\n # Already evaluated\n pass\n buffer_view = memoryview(buffer)\n data_size = len(buffer)\n\n if not data_size:\n break\n\n if size_left != -1:\n end = start + size_left\n else:\n end = data_size - start\n\n if end >= data_size:\n end = data_size\n\n del queue[queue_index]\n\n index = queue_index + buffer_size * self._max_buffers\n if index < self._size:\n queue[index] = self._workers.submit(\n self._read_range, index, index + buffer_size\n )\n\n read_size = end - start\n if size_left != -1:\n size_left -= read_size\n seek += read_size\n\n b_start = b_end\n b_end = b_start + read_size\n\n b_view[b_start:b_end] = buffer_view[start:end]\n\n self._seek = seek\n self._raw.seek(seek)\n\n return b_end"],"string":"[\n \"def read(self, size: int = -1) -> bytes:\\n if self.size_read >= self.chunksize:\\n return b''\\n if size < 0:\\n size = self.chunksize - self.size_read\\n if size > self.chunksize - self.size_read:\\n size = self.chunksize - self.size_read\\n data = self.file.read(size)\\n self.size_read = self.size_read + len(data)\\n if self.size_read == self.chunksize and (self.chunksize & 1):\\n dummy = self.file.read(1)\\n self.size_read = self.size_read + len(dummy)\\n return data\",\n \"def _get_data(self, read_size):\\n return self._pipe.recv_bytes()\",\n \"def read_until_size(self, size):\\n if not size:\\n do_return(b'')\\n with self.reading:\\n while len(self.read_buffer) < size:\\n self.read_buffer.enqueue((yield self.base.read(self.bufsize)))\\n do_return(self.read_buffer.dequeue(size))\",\n \"async def read_chunk(self, size: int = ...) -> bytes:\\n ...\",\n \"def read(self, size=1):\\n assert self.count < len(self.data)\\n data = self.data[self.count]\\n self.count += 1\\n return data\",\n \"def read(self, size=-1):\\n buf = self._fd.read(size)\\n self._progress.update(len(buf))\\n return buf\",\n \"def _readData(self):\\n # Debug. This fn should be called only after checking canRead()\\n if not self._canRead():\\n raise Exception(\\\"Trying to read more data than there is.\\\")\\n\\n data = self.buffer[:self._expectedByteCount]\\n self.buffer = self.buffer[self._expectedByteCount:]\\n\\n return data\",\n \"def read(self, *args, **kwargs):\\n return self.limitedstream.read(*args, **kwargs)\",\n \"def read(self, size, timeout=None):\\n assert self._locked\\n\\n if timeout is None:\\n timeout = self.timeout\\n return self.ep_data_in.read(size, timeout)\",\n \"def read(self, size=-1):\\n self._check_not_closed()\\n raise io.UnsupportedOperation(\\\"Read not supported\\\")\",\n \"def _read(self, length: int) -> bytes:\\n if length + self.total_bytes_read > PNG_MAX_FILE_SIZE:\\n raise exceptions.PNGTooLarge(\\n \\\"Attempted to read past file size limit: {size} bytes\\\".format(\\n size=PNG_MAX_FILE_SIZE,\\n )\\n )\\n data = self._stream.read(length)\\n actual = len(data)\\n self.total_bytes_read += actual\\n assert length >= actual, \\\"Read more bytes than requested\\\"\\n if length > actual:\\n fmt = \\\"Expected to read {length}, got {actual}, total read {total}\\\"\\n raise exceptions.UnexpectedEOF(fmt.format(\\n length=length,\\n actual=actual,\\n total=self.total_bytes_read\\n ))\\n return data\",\n \"def __read_block(self, size):\\n buf = b\\\"\\\"\\n if len(self.__read_buffer):\\n limit = (\\n size if size <= len(self.__read_buffer) else\\n len(self.__read_buffer)\\n )\\n buf = self.__read_buffer[:limit]\\n self.__read_buffer = self.__read_buffer[limit:]\\n size -= limit\\n if not size:\\n return buf\\n try:\\n buf += self.sock.recv(size)\\n except (socket.timeout, ssl.SSLError):\\n raise Error(\\\"Failed to read %d bytes from the server\\\" % size)\\n self.__dprint(buf)\\n return buf\",\n \"def checked_read(in_stream, length, allow_eof=False):\\n\\n bytes = in_stream.read(length)\\n if allow_eof and bytes == '':\\n return bytes\\n if len(bytes) != length:\\n raise IOError(MSG_INCOMPLETE_READ)\\n return bytes\",\n \"def SafeReadBytes(self, length):\\n data = self.ReadBytes(length)\\n if len(data) < length:\\n raise ValueError(\\\"Not enough data available\\\")\\n else:\\n return data\",\n \"def read(self, size=-1):\\n ...\",\n \"async def async_readchunks(self, size: int):\\n while True:\\n data = await self.read(size)\\n if data:\\n await yield_(data)\\n else:\\n return\",\n \"def waitforAndRead(self, size):\\n while self.device.inWaiting() < size:\\n pass\\n else:\\n return self.device.read(size)\",\n \"def read_until_eof(self):\\n with self.reading:\\n try:\\n while True:\\n self.read_buffer.enqueue((yield self.base.read(self.bufsize)))\\n except BrokenPipeError:\\n pass\\n do_return(self.read_buffer.dequeue())\",\n \"def read_data(self, size, attempts = 1):\\n data = Array('B')\\n # do we have all of the data in the read buffer?\\n if size <= len(self.rdbuf) - self.rdofs:\\n data = self.rdbuf[self.rdofs : self.rdofs + size]\\n self.rdofs += size\\n return data\\n # do we have some of the data in the read buffer?\\n if len(self.rdbuf) - self.rdofs > 0:\\n data = self.rdbuf[self.rdofs:]\\n # do a usb read to get the rest...\\n # read from the usb device\\n try:\\n bytes_to_rd = size - len(data)\\n while bytes_to_rd > 0:\\n # read from the usb device\\n while True:\\n self.rdbuf = self._read()\\n self.rdofs = 0\\n if len(self.rdbuf) > 0:\\n break\\n else:\\n # no data received\\n attempts -= 1\\n if attempts > 0:\\n # try again\\n continue\\n # return what we have\\n return data\\n # copy the read buffer into the returned data\\n n = len(self.rdbuf)\\n if n >= bytes_to_rd:\\n # copy a partial read buffer\\n data += self.rdbuf[:bytes_to_rd]\\n self.rdofs = bytes_to_rd\\n return data\\n else:\\n # copy all of the read buffer\\n data += self.rdbuf\\n bytes_to_rd -= n\\n # read more data...\\n except usb.core.USBError as e:\\n raise usbdev_error(str(e))\\n # never reached\\n raise usbdev_error(\\\"internal error\\\")\",\n \"def read(self, size: int = None) -> bytes:\\n if size is None:\\n buffer = io.BytesIO()\\n copy_stream(self, buffer)\\n return buffer.getvalue()\\n else:\\n return self._read_chunked(size)\",\n \"def read(self, size: int=-1) -> bytes:\\n ...\",\n \"def read(self, size: int=-1) -> bytes:\\n ...\",\n \"def read(self, size=1):\\n \\n data = self.fp.read(1)\\n if data == '':\\n self.fp.seek(0)\\n data = self.fp.read(1)\\n \\n return data\",\n \"def read(self, size=-1):\\n\\n if size < 0:\\n raise NotImplementedError(\\\"Don't be greedy, that could be massive!\\\")\\n elif size == 0:\\n if self._text:\\n return \\\"\\\"\\n else:\\n return b\\\"\\\"\\n elif self._within_block_offset + size <= len(self._buffer):\\n # This may leave us right at the end of a block\\n # (lazy loading, don't load the next block unless we have too)\\n data = self._buffer[self._within_block_offset:self._within_block_offset + size]\\n self._within_block_offset += size\\n assert data # Must be at least 1 byte\\n return data\\n else:\\n # if read data overflows to next block\\n # pull in rest of data in current block\\n data = self._buffer[self._within_block_offset:]\\n\\n # decrement size so that we only pull the rest of the data\\n # from next block\\n size -= len(data)\\n self._load_block() # will reset offsets\\n\\n if not self._buffer:\\n return data # EOF\\n\\n # if there is still more to read\\n elif size:\\n # pull rest of data from next block\\n return data + self.read(size)\\n else:\\n # Only needed the end of the last block\\n return data\",\n \"def _buffered_func(dataset, size):\\n\\n class _EndSignal(object):\\n pass\\n\\n end = _EndSignal()\\n\\n def _read_worker(r, q):\\n for d in r:\\n q.put(d)\\n q.put(end)\\n\\n def _data_reader():\\n r = dataset()\\n q = multiprocessing.Queue(maxsize=size)\\n t = multiprocessing.Process(\\n target=_read_worker, args=(\\n r,\\n q, ))\\n t.daemon = True\\n t.start()\\n e = q.get()\\n while e != end:\\n yield e\\n e = q.get()\\n\\n return _data_reader\",\n \"def read(self, num_bytes_to_read):\\n pass\",\n \"def read(self, n=-1):\\n\\n if self._exception is not None:\\n raise self._exception\\n\\n if n == 0:\\n return b''\\n\\n if n < 0:\\n # This used to just loop creating a new waiter hoping to\\n # collect everything in self._buffer, but that would\\n # deadlock if the subprocess sends more than self.limit\\n # bytes. So just call self.read(self._limit) until EOF.\\n blocks = []\\n while True:\\n block = yield from self.read(self._limit)\\n if not block:\\n break\\n blocks.append(block)\\n return b''.join(blocks)\\n\\n if not self._buffer and not self._eof:\\n yield from self._wait_for_data('read')\\n\\n # This will work right even if buffer is less than n bytes\\n data = bytes(self._buffer[:n])\\n del self._buffer[:n]\\n\\n self._maybe_resume_transport()\\n return data\",\n \"def buffered(reader, size):\\n\\n class EndSignal():\\n pass\\n\\n end = EndSignal()\\n\\n def read_worker(r, q):\\n for d in r:\\n q.put(d)\\n q.put(end)\\n\\n def data_reader():\\n r = reader()\\n q = Queue(maxsize=size)\\n t = Thread(\\n target=read_worker, args=(\\n r,\\n q, ))\\n t.daemon = True\\n t.start()\\n e = q.get()\\n while e != end:\\n yield e\\n e = q.get()\\n\\n return data_reader\",\n \"async def _read(self, n):\\n return await self._reader.readexactly(n)\",\n \"def _serial_read(self, size):\\n self.write([self.SERIAL_IO])\\n resp = self.read(size)\\n data = self.decode(resp)\\n return data\",\n \"def read(self, size=None):\\n if size is None or size < 0:\\n return \\\"\\\".join(list(self))\\n else:\\n data_chunks = []\\n data_readed = 0\\n try:\\n while data_readed < size:\\n chunk = self.next_chunk()\\n data_chunks.append(chunk)\\n data_readed += len(chunk)\\n except StopIteration:\\n pass\\n\\n if data_readed > size:\\n last_chunk = data_chunks.pop()\\n extra_length = data_readed - size\\n last_chunk, extra_data = last_chunk[:-extra_length], last_chunk[-extra_length:]\\n self.unshift(extra_data)\\n data_chunks.append(last_chunk)\\n return \\\"\\\".join(data_chunks)\",\n \"def read(self, size: int) -> bytes:\\n\\n return self.r.read(size)\",\n \"def read(self, size=None):\\n if not size:\\n rlen = self.end - self.pos\\n else:\\n rlen = size\\n if rlen == 0:\\n return '' # Fake EOF\\n # Clamp rlen to window end\\n if self.pos + rlen > self.end:\\n rlen = self.end - self.pos\\n data = self.file.read(rlen)\\n self.pos += len(data)\\n return data\",\n \"def read(self, size=-1):\\n _complain_ifclosed(self._closed)\\n buf = self._buf\\n while size < 0 or len(buf) < size:\\n try:\\n buf = buf + next(self._generator)\\n except StopIteration:\\n break\\n\\n returned = b\\\"\\\"\\n if size >= 1:\\n self._buf = buf[size:]\\n returned = buf[:size]\\n else:\\n self._buf = b\\\"\\\"\\n returned = buf\\n\\n self._position = self._position + len(returned)\\n return returned\",\n \"def _read_fixed(buf, length):\\n result = buf.read(length)\\n actual = len(result)\\n if actual != length:\\n raise EndOfMessage(False if actual == 0 else True)\\n return result\",\n \"def read(self, addr: int, size: int, **kwargs) -> bytes:\\n ret = bytearray()\\n\\n if not kwargs.get('suppress_setup', False):\\n self._setup(addr, size)\\n\\n desc = self._describe_op(addr, size)\\n show = kwargs.get('show_progress', True)\\n progress = self._ctx.create_progress_indicator(self, size, desc, unit='B', show=show)\\n\\n def _update_progress(data: bytes):\\n ret.extend(data)\\n progress.update(len(data))\\n\\n try:\\n self._read(addr, size, _update_progress)\\n except KeyboardInterrupt:\\n msg = 'Read operation interrupted. {:d} / {:d} bytes read.'\\n log.warning(msg.format(len(ret), size))\\n finally:\\n self._ctx.close_progress_indicator(progress)\\n\\n if not kwargs.get('suppress_teardown', False):\\n self._teardown()\\n\\n return bytes(ret)\",\n \"def _read_length(self):\\n msg_length = struct.unpack('!I', self.received_data[0])[0]\\n self.l.debug('msg_length = %d', msg_length)\\n self.set_terminator(msg_length)\\n self.process_data = self._read_message\\n self.received_data = []\",\n \"def read_until(self, expected=serial.LF, size=None) -> bytes:\\n logger.debug(f\\\"read_until(expected={expected}, size={size})\\\")\\n return self._con.read_until(expected=expected, size=size)\",\n \"def Read_Bytes(self, size = 0):\\r\\n if size == 0: size = self.Port.inWaiting()\\r\\n data = self.Port.read(size)\\r\\n return data\",\n \"def read(self, batch_size=1):\\n cur_q_size = len(self._queue)\\n while cur_q_size < batch_size:\\n if self._thread.get_exception() is not None:\\n break\\n time.sleep(0.1)\\n cur_q_size = len(self._queue)\\n\\n exception = self._thread.get_exception()\\n if isinstance(exception, EndOfVideoError):\\n if cur_q_size == 0:\\n raise EndOfVideoError()\\n elif cur_q_size <= batch_size:\\n data = self._read_all()\\n else:\\n data = self._read(batch_size)\\n elif isinstance(exception, ConnectionBrokenError):\\n raise ConnectionBrokenError()\\n else:\\n # XXX: In this case we are assuming that everything is fine,\\n # and current queue size should greater than the batch\\n # size.\\n data = self._read(batch_size)\\n return data\",\n \"def safe_read_chunk(self, name, offset=0, length=1024):\\n full_path = self.path(name)\\n byte_buffer = None\\n l = 0\\n if self.exists(name):\\n with caches['default'].lock('{}_{}'.format(full_path, 'reader')):\\n fd = self.__volume.fopen(full_path, 'r')\\n try:\\n fsize = self.__volume.getsize(full_path)\\n if offset < fsize:\\n rlength = fsize - offset\\n l = length\\n if rlength < length:\\n l = rlength\\n fd.lseek(offset)\\n byte_buffer = fd.read(l)\\n finally:\\n fd.close()\\n return (byte_buffer, l)\",\n \"def recv_size(self, size, timeout=_UNSET):\\n with self._recv_lock:\\n if timeout is _UNSET:\\n timeout = self.timeout\\n chunks = []\\n total_bytes = 0\\n try:\\n start = time.time()\\n self.sock.settimeout(timeout)\\n nxt = self.rbuf or self.sock.recv(self._recvsize)\\n while nxt:\\n total_bytes += len(nxt)\\n if total_bytes >= size:\\n break\\n chunks.append(nxt)\\n if timeout:\\n cur_timeout = timeout - (time.time() - start)\\n if cur_timeout <= 0.0:\\n raise socket.timeout()\\n self.sock.settimeout(cur_timeout)\\n nxt = self.sock.recv(self._recvsize)\\n else:\\n msg = ('connection closed after reading %s of %s requested'\\n ' bytes' % (total_bytes, size))\\n raise ConnectionClosed(msg) # check recv buffer\\n except socket.timeout:\\n self.rbuf = b''.join(chunks)\\n msg = 'read %s of %s bytes' % (total_bytes, size)\\n raise Timeout(timeout, msg) # check recv buffer\\n except Exception:\\n # received data is still buffered in the case of errors\\n self.rbuf = b''.join(chunks)\\n raise\\n extra_bytes = total_bytes - size\\n if extra_bytes:\\n last, self.rbuf = nxt[:-extra_bytes], nxt[-extra_bytes:]\\n else:\\n last, self.rbuf = nxt, b''\\n chunks.append(last)\\n return b''.join(chunks)\",\n \"def _get_data(self, read_size):\\n if NIX:\\n return super(Mouse, self)._get_data(read_size)\\n return self._pipe.recv_bytes()\",\n \"def __ReadBytes(self, size, block=True):\\n need_more_data = True\\n result = b''\\n while need_more_data:\\n read_bytes = self.__input_stream.read(size)\\n if read_bytes:\\n result += read_bytes\\n elif read_bytes is not None:\\n return (result, False)\\n elif not block:\\n return (result, True)\\n need_more_data = (len(result) < size)\\n\\n return (result, True)\",\n \"def read(self, address, size, progress_update=None):\\n size_remain = size\\n data = bytearray()\\n\\n while size_remain > 0:\\n if progress_update is not None:\\n progress_update(int(100 * (size - size_remain) / size))\\n\\n part_size = self.__RW_MAX_SIZE \\\\\\n if size_remain > self.__RW_MAX_SIZE else size_remain\\n offset = address + size - size_remain\\n\\n for retry in range(0, self.__RETRY_MAX_NUM):\\n self._send_command(self.__COMMAND['read memory'])\\n self._set_address(offset)\\n\\n self._port_handle.write(\\n [part_size - 1, self._checksum(part_size - 1)])\\n if self._is_acknowledged():\\n break\\n else:\\n raise DfuException('Read memory at {} failed after {} '\\n 'retries.'.format(offset, retry + 1))\\n\\n chunk = self._port_handle.read(part_size)\\n if len(chunk) != part_size:\\n raise DfuException('Read {} bytes istead of '\\n '{}.'.format(len(chunk), part_size))\\n data.extend(bytearray(chunk))\\n\\n size_remain -= part_size\\n\\n if progress_update is not None:\\n progress_update(100)\\n\\n return data\",\n \"def read(self, len, timeout = 0):\\n if timeout < 0:\\n timeout = 0\\n else:\\n timeout += _timeout\\n\\n try:\\n return self._snc.read(len, timeout)\\n except Exception as e:\\n log.error(\\\"failed to read [len={0}]:\\\\n{1!r}\\\" .\\n format(len, e))\\n raise Error\",\n \"def _read_raw_bytes_direct(self, size):\\n with(self.visa_handle.ignore_warning(pyvisa.constants.VI_SUCCESS_MAX_CNT)):\\n data, statuscode = self.visa_handle.visalib.read(\\n self.visa_handle.session, size)\\n\\n return data\",\n \"def _readBytes(self, len):\\n return self.stream.read(len)\",\n \"def _read_raw_bytes_multiple(self, size, maxread=512, verbose=0):\\n ret = []\\n instr = self.visa_handle\\n with self.visa_handle.ignore_warning(pyvisa.constants.VI_SUCCESS_MAX_CNT):\\n nread = 0\\n while nread < size:\\n nn = min(maxread, size - nread)\\n chunk, status = instr.visalib.read(instr.session, nn)\\n ret += [chunk]\\n nread += len(chunk)\\n if verbose:\\n print('_read_raw: %d/%d bytes' % (len(chunk), nread))\\n ret = b''.join(ret)\\n return ret\",\n \"def read(self, size=-1):\\n if not self._buf:\\n self._buf.append(next(self._iter, b''))\\n if len(self._buf[0]) < size or size < 0:\\n return self._buf.pop(0)\\n block = self._buf.pop(0)\\n self._buf.insert(0, block[size:])\\n return block[:size]\",\n \"async def read(self, wait_closed=True):\\n content = b''\\n # wait until the pipe is opened by a writer\\n await wait_readable(self.fd)\\n while True:\\n try:\\n item = os.read(self.fd, self.blocksize)\\n except BlockingIOError:\\n # pipe is blocked\\n if wait_closed:\\n await wait_readable(self.fd)\\n else:\\n break\\n else:\\n if not item:\\n # pipe is closed\\n break\\n else:\\n content += item\\n if self.encoding is not None:\\n content = content.decode(self.encoding)\\n return content\",\n \"def getData(self, src, chunk_size=1024):\\n d = src.read(chunk_size)\\n while d:\\n yield d\\n d = src.read(chunk_size)\",\n \"def _get_data(self, read_size):\\n if NIX:\\n return super(Keyboard, self)._get_data(read_size)\\n return self._pipe.recv_bytes()\",\n \"def read(self, *args, **kwargs):\\r\\n buf = io.BufferedReader.read(self, *args, **kwargs)\\r\\n self.increment(len(buf))\\r\\n return buf\",\n \"def read(self, endpoint, size):\\n return self.device.read(endpoint, size)\",\n \"def read(self, size=None, timeout_ms=None, **kwargs):\\n raise NotImplementedError(\\\"implement in derived transport class\\\")\",\n \"def read(self):\\n while True:\\n size_bytes = self.connection.read(Frame.SIZE_WIDTH)\\n # Read will return zero bytes when the other side of the connection\\n # closes.\\n if not size_bytes:\\n break\\n\\n message_length = read_number_string(size_bytes, Frame.SIZE_WIDTH)\\n\\n chunk = self.connection.read(message_length - Frame.SIZE_WIDTH)\\n if not chunk:\\n raise ProtocolException(\\n 'Expected %d bytes available, got none' % message_length\\n )\\n\\n if len(chunk) != message_length - Frame.SIZE_WIDTH:\\n raise ProtocolException(\\n 'Expected %d bytes, got %d' %\\n (len(chunk), message_length - Frame.SIZE_WIDTH)\\n )\\n\\n yield Frame.decode(BytesIO(chunk), message_length)\",\n \"def _read_blocks(input_data, size=2**20):\\n\\n if isinstance(input_data, (BufferedReader, BytesIO)):\\n f = input_data\\n opened = False\\n elif input_data == '-':\\n f = sys.stdin.buffer # read binary instead of unicode\\n opened = False\\n else:\\n f = open(input_data, 'rb')\\n opened = True\\n\\n try:\\n\\n data = f.read(size)\\n while len(data) > 0:\\n yield data\\n data = f.read(size)\\n finally:\\n if opened:\\n f.close()\",\n \"def read(self, size=-1):\\n chunk_index, prefix_size = self._index_pos(self._pos)\\n prefixed_buffer = []\\n try:\\n if size < 0:\\n while True:\\n prefixed_buffer.append(self._readchunk(chunk_index))\\n chunk_index += 1\\n else:\\n need = prefix_size + size\\n while need > 0:\\n chunk_data = self._readchunk(chunk_index)\\n prefixed_buffer.append(chunk_data[:need])\\n need -= len(chunk_data)\\n chunk_index += 1\\n\\n except EOFError:\\n # PR#16/18 - support identifying EOF\\n # use a read() as a sync from desired position to actual position\\n # read(0) can be used as a synchronization call\\n dec_eof_position = self._members[-1].start_pos + self._members[-1].isize\\n self._pos = dec_eof_position\\n if prefixed_buffer:\\n # subtracting the data in the EOF Case so the normal path will add it back\\n # before the function return to avoid changing the path\\n # adding up lengths rather than concatenating here to avoid creating new buffers\\n self._pos -= sum([len(x) for x in prefixed_buffer]) - prefix_size\\n prefixed_buffer = b\\\"\\\".join(prefixed_buffer)\\n result = prefixed_buffer[prefix_size:]\\n self._pos += len(result)\\n return result\",\n \"def _get_data(self):\\n while not (self.closed or self.ended):\\n block = self.stream.read(8192)\\n with self.lock:\\n if len(block) == 0:\\n self.ended = True\\n else:\\n self.data.append(block)\\n self.available.set()\",\n \"def read_full(fileobj, size):\\n\\n if size < 0:\\n raise ValueError(\\\"size must not be negative\\\")\\n\\n data = fileobj.read(size)\\n if len(data) != size:\\n raise IOError\\n return data\",\n \"def read_raw(self, chunk_size=512):\\n\\n log.debug('Reading from device \\\"{0}\\\".'.format(self.name))\\n\\n buf = ''\\n\\n if self.driver in [drivers.pyvisa, drivers.pyvisa_usb]:\\n try:\\n buf = self.device.read_raw()\\n except pyvisa.VisaIOError as e:\\n raise\\n\\n elif self.driver == drivers.telnet:\\n try:\\n buf = self.device.read_until('\\\\r\\\\n')\\n except Exception as e:\\n if e is socket.timeout:\\n raise DeviceTimeout(e)\\n else:\\n raise\\n elif self.driver == drivers.requests:\\n buf = requests.get(self.request_address)\\n\\n elif self.driver == drivers.lgpib:\\n status = 0\\n while status == 0:\\n try:\\n buf += self.device.read(len=chunk_size)\\n except gpib.GpibError as e:\\n if 'timeout' in e.message:\\n raise DeviceTimeout(e)\\n else:\\n raise\\n\\n status = self.device.ibsta() & IbstaBits.END\\n\\n log.debug('Read from device \\\"{0}\\\": {1!r}'.format(self.name, buf))\\n\\n return buf\",\n \"def read_chunks(self):\\n buf = []\\n chunks = []\\n delays = []\\n if not self.chunked:\\n chunks.append(self.read())\\n delays.append(0)\\n else:\\n start = TIMER()\\n try:\\n while True:\\n line = self.fp.readline()\\n chunk_size = self._read_chunk_size(line)\\n if chunk_size is None:\\n raise httplib.IncompleteRead(''.join(chunks))\\n if chunk_size == 0:\\n break\\n delays.append(TIMER() - start)\\n chunks.append(self._safe_read(chunk_size))\\n self._safe_read(2) # skip the CRLF at the end of the chunk\\n start = TIMER()\\n\\n # Ignore any trailers.\\n while True:\\n line = self.fp.readline()\\n if not line or line == '\\\\r\\\\n':\\n break\\n finally:\\n self.close()\\n return chunks, delays\",\n \"async def _read_content(\\n self, length: int, max_parts=1000, max_empties=200\\n ) -> Optional[bytes]:\\n raw = None\\n raw_parts: List[bytes] = []\\n received_size = 0\\n while received_size < length and len(raw_parts) < max_parts and max_empties > 0:\\n part = None\\n try:\\n part = self.stream.read(length - received_size)\\n except OSError: # pragma: no cover\\n pass\\n if part is None:\\n max_empties -= 1\\n await self.sleep()\\n continue\\n received_size += len(part)\\n raw_parts.append(part)\\n\\n if raw_parts:\\n raw = b\\\"\\\".join(raw_parts)\\n if len(raw) != length: # pragma: no cover\\n self.log.warning(\\n f\\\"Readout and content-length mismatch: {len(raw)} vs {length};\\\"\\n f\\\"remaining empties: {max_empties}; remaining parts: {max_parts}\\\"\\n )\\n\\n return raw\",\n \"def readline(self, size=-1):\\n ...\",\n \"def read(self, nbytes: int, /) -> Optional[bytes]:\",\n \"def read(self, nbytes: Optional[int] = None) -> Optional[bytes]:\\n ...\",\n \"def _read(self):\\n if not self.connected:\\n raise IOError(\\\"Not connected.\\\")\\n\\n try:\\n with self._read_lock:\\n if not self.connected:\\n raise IOError(\\\"Not connected.\\\")\\n data = self._reader.readline(self.MAX_MESSAGE_SIZE)\\n # If there weren't a \\\"\\\\r\\\\n\\\" between the last message\\n # and the EOF we would have a false positive here.\\n # Luckily there is one.\\n if len(data) > 0 and not data.endswith(b\\\"\\\\r\\\\n\\\"):\\n logger.error(\\n \\\"The client sent a message larger than %d bytes (that \\\"\\n \\\"is MAX_MESSAGE_SIZE). Consider raising that value if \\\"\\n \\\"the message seemed legit.\\\", self.MAX_MESSAGE_SIZE)\\n self.finalize(\\\"Client misbehaving.\\\")\\n raise IOError(\\\"Message too long.\\\")\\n except socket.error as error:\\n if self.connected:\\n logger.warning(\\\"Failed reading from socket: %s.\\\", error)\\n self.finalize(\\\"Read failed.\\\")\\n raise error\\n else:\\n # The client was terminated willingly; its correct termination\\n # is handled in disconnect(), so here we can just return.\\n return b\\\"\\\"\\n\\n return data\",\n \"def get_block(self):\\n # Read in data in blocks so as to not tie up the CPU.\\n BLOCK_SIZE = 1024\\n eof = False\\n data = ''\\n while not eof:\\n next_block = self._stream_handle.read(BLOCK_SIZE)\\n if next_block:\\n data = data + next_block\\n gevent.sleep(0)\\n else:\\n eof = True\\n\\n if data != '':\\n self._chunker.add_chunk(data, self._timestamp)\\n self.file_complete = True\\n return len(data)\\n else: # EOF\\n self.file_complete = True\\n raise EOFError\",\n \"def _receive(self, length, timeout=None, skip_len_check=False):\\n data = self._receive_internal(length, timeout)\\n if not skip_len_check and len(data) < length:\\n raise ButtshockIOError(\\\"Received unexpected length {}, expected {}!\\\".format(len(data), length))\\n if len(data) > 0:\\n self._debug_print('received data: %s' % data)\\n return data\",\n \"def recv_data(self):\\n data = \\\"\\\"\\n size = 0\\n\\n try:\\n size = self.sockObj.recv(4) #Get metadata\\n except:\\n raise Exception(\\\"Error while receiving data. Probably broken pipe\\\")\\n\\n if len(size) == 0:\\n raise Exception(\\\"No data recivied. Probably broken pipe\\\")\\n\\n size = struct.unpack('>I',size)[0]\\n\\n data = self.sockObj.recv(size)\\n\\n if len(data) != size:\\n raise Exception(\\\"Partiala data recivied\\\")\\n\\n return self.decode(data)\",\n \"async def readchunk(self) -> Tuple[bytes, bool]:\\n ...\",\n \"def _get_data(self, read_size):\\n return self._character_device.read(read_size)\",\n \"def recv(self, bufsize):\\r\\n return self.read(bufsize)\",\n \"def read(self, address, size):\\n raise NotImplementedError\",\n \"def read_until(\\n self,\\n min_num_bytes: int,\\n ending: bytes,\\n timeout: float = 10.0,\\n data_consumer=None,\\n ):\\n\\n data = b''\\n\\n # If a miniumum number of bytes is given, wait till at least\\n # that number of bytes are received. If the value is 0, then\\n # continue, and rely on the terminator and timeout values.\\n if min_num_bytes:\\n data = self.con.read(min_num_bytes)\\n # debug(f'read {data=}')\\n if data_consumer:\\n data_consumer(data)\\n\\n timeout_count = 0\\n while True:\\n if ending and data.endswith(ending):\\n break\\n else:\\n # debug(f\\\"{ending=} was not found\\\")\\n pass\\n\\n if self.con.inWaiting() > 0:\\n new_data = self.con.read(1)\\n # debug(f'read {new_data=}')\\n data = data + new_data\\n # if len(data) > 80:\\n # debug(f'data: len={len(data)} {data[-80:]=}')\\n # else:\\n # debug(f'data: len={len(data)} {data=}')\\n if data_consumer:\\n data_consumer(new_data)\\n # timeout_count = 0\\n else:\\n timeout_count += 1\\n # debug(f'{timeout_count=}')\\n if timeout is not None and timeout_count >= 100 * timeout:\\n if not data:\\n debug(f\\\"TIMEOUT - No data received within {timeout} seconds\\\")\\n else:\\n debug(f\\\"TIMEOUT - data {data} did not end with {ending}\\\")\\n break\\n time.sleep(0.01)\\n debug(f\\\"read_until returns {data=}\\\")\\n return data\",\n \"def read(self, length=None):\\r\\n try:\\r\\n if length is not None:\\r\\n return self._fp.read(length)\\r\\n return self._fp.readline()\\r\\n except socket.error, e:\\r\\n self.disconnect()\\r\\n if e.args and e.args[0] == errno.EAGAIN:\\r\\n raise ConnectionError(\\\"Error while reading from socket: %s\\\" % \\\\\\r\\n e.args[1])\\r\\n return ''\",\n \"def readBuffer(self, start, buffer_size):\\r\\n\\r\\n start, stop = self.getReadParameters(start, buffer_size)\\r\\n try:\\r\\n # data_source is a tables.Table or a tables.XArray\\r\\n # but data is a numpy array\\r\\n # Warning: in a EArray with shape (2,3,3) and extdim attribute\\r\\n # being 1, the read method will have 3 rows. However, the numpy\\r\\n # array returned by EArray.read() will have only 2 rows\\r\\n data = self.data_source.read(start, stop)\\r\\n except tables.HDF5ExtError:\\r\\n print(translate('Buffer',\\r\\n \\\"\\\"\\\"\\\\nError: problems reading records. The dataset maybe \\\"\\\"\\\"\\r\\n \\\"\\\"\\\"corrupted.\\\"\\\"\\\",\\r\\n 'A dataset readability error'))\\r\\n except:\\r\\n vitables.utils.formatExceptionInfo()\\r\\n else:\\r\\n # Update the buffer contents and its start position\\r\\n self.chunk = data\\r\\n self.start = start\",\n \"def read(self, nbytes: int, /) -> bytes | None:\",\n \"def _read_nowait(self, n: int) -> bytes:\\n ...\",\n \"def peek(self, size, timeout=_UNSET):\\n with self._recv_lock:\\n if len(self.rbuf) >= size:\\n return self.rbuf[:size]\\n data = self.recv_size(size, timeout=timeout)\\n self.rbuf = data + self.rbuf\\n return data\",\n \"def read(self, length = 1024):\\n\\n return self.socket.recv(length)\",\n \"def read(self, length = 1024):\\n\\n return self.socket.recv(length)\",\n \"def _filesync_read_buffered(self, size, adb_info, filesync_info):\\n # Ensure recv buffer has enough data.\\n while len(filesync_info.recv_buffer) < size:\\n _, data = self._read_until([constants.WRTE], adb_info)\\n filesync_info.recv_buffer += data\\n\\n result = filesync_info.recv_buffer[:size]\\n filesync_info.recv_buffer = filesync_info.recv_buffer[size:]\\n return result\",\n \"def read_bytes(self, size):\\n return self.read('bytes:'+str(size))\",\n \"def read(self, size):\\n if size % self.recordsize != 0:\\n raise ValueError(\\\"Cannot read a non-integer number of records\\\")\\n\\n # ensure we do not read beyond end\\n size = min(size, len(self.files) * self.filesize - self.offset)\\n if size <= 0:\\n raise EOFError('At end of file!')\\n\\n # allocate buffer.\\n z = np.empty(size, dtype=np.int8)\\n\\n # read one or more pieces\\n iz = 0\\n while(iz < size):\\n self._seek(self.offset)\\n block, already_read = divmod(self.offset, self.filesize)\\n fh_size = min(size - iz, self.filesize - already_read)\\n z[iz:iz+fh_size] = np.fromstring(self.fh_raw.read(fh_size),\\n dtype=z.dtype)\\n iz += fh_size\\n self.offset += fh_size\\n\\n return z\",\n \"def read(self, nbytes, /) -> bytes | None:\",\n \"def read_pipe(pipe_out):\\n out = b''\\n while more_data(pipe_out):\\n out += os.read(pipe_out, 1024)\\n\\n return out.decode('utf-8')\",\n \"def Read(buf: IO[bytes]) -> Optional[bytes]:\\n count_bytes = buf.read(_UINT64.size)\\n if not count_bytes:\\n return None\\n\\n try:\\n (count,) = _UINT64.unpack(count_bytes)\\n except struct.error as error:\\n raise ValueError(f\\\"Incorrect size tag {count_bytes}: {error}\\\")\\n\\n # It might happen that we are given file with incorrect format. If the size\\n # tag is interpreted as a huge number, reading the buffer will lead to raising\\n # an exception, because Python will try to allocate a buffer to read into. If\\n # possible, we try to check guard against such situations and provide more\\n # informative exception message.\\n\\n def Error(left: int) -> ValueError:\\n message = f\\\"Malformed input (reading {count} bytes out of {left} available)\\\"\\n return ValueError(message)\\n\\n if buf.seekable():\\n position = buf.tell()\\n\\n buf.seek(0, os.SEEK_END)\\n size = buf.tell()\\n\\n if count > size - position:\\n raise Error(size - position)\\n\\n buf.seek(position, os.SEEK_SET)\\n\\n chunk = buf.read(count)\\n if len(chunk) != count:\\n raise Error(len(chunk))\\n\\n return chunk\",\n \"def _read_no_check(self):\\n on_data_fut = _async.Future(self._loop)\\n def on_data():\\n on_data_fut.set_result(None)\\n self._loop.add_reader(self._channel.fileno(), on_data)\\n\\n try:\\n yield From(on_data_fut)\\n finally:\\n self._loop.remove_reader(self._channel.fileno())\\n\\n d = self._channel.recv(_MAX_READ_AMOUNT).decode()\\n if d == '':\\n logger.debug(\\\"{}: Read returned {!r}\\\".format(self, d))\\n raise TransportNotConnected\\n\\n logger.debug(\\\"{}: Read {!r}\\\".format(self, d))\\n if d.endswith(\\\"\\\\r\\\\n\\\"):\\n d = d[:-2] + \\\"\\\\n\\\"\\n d = d.encode('ascii')\\n\\n raise Return(d)\",\n \"def read(self, length=1024):\\n\\n return self.socket.recv(length)\",\n \"def _handle_read(self):\\n try:\\n data = self.recv (self.ac_in_buffer_size)\\n except socket.error, why:\\n self.handle_error()\\n return\\n\\n if hasattr(self.socket, 'ssl_version'):\\n # Fix for SSL wrapped sockets, checks if there is any data pending in\\n # the SSL Socket's internal buffer and recv's it before contining.\\n ssl_data_remainder = ''\\n amount_of_data_left_over = self.socket.pending()\\n while amount_of_data_left_over > 0:\\n # while the ssl socket still has some data pending\\n try:\\n # get the remaining data\\n ssl_data_remainder += self.recv(amount_of_data_left_over)\\n except socket.error, why:\\n self.handle_error()\\n return\\n # check if there is anymore remaining\\n amount_of_data_left_over = self.socket.pending()\\n data += ssl_data_remainder # add the remainder to the data\\n self.ac_in_buffer = self.ac_in_buffer + data\\n\\n # Continue to search for self.terminator in self.ac_in_buffer,\\n # while calling self.collect_incoming_data. The while loop\\n # is necessary because we might read several data+terminator\\n # combos with a single recv(4096).\\n\\n while self.ac_in_buffer:\\n lb = len(self.ac_in_buffer)\\n terminator = self.get_terminator()\\n if not terminator:\\n # no terminator, collect it all\\n self.collect_incoming_data (self.ac_in_buffer)\\n self.ac_in_buffer = ''\\n elif isinstance(terminator, int) or isinstance(terminator, long):\\n # numeric terminator\\n n = terminator\\n if lb < n:\\n self.collect_incoming_data (self.ac_in_buffer)\\n self.ac_in_buffer = ''\\n self.terminator = self.terminator - lb\\n else:\\n self.collect_incoming_data (self.ac_in_buffer[:n])\\n self.ac_in_buffer = self.ac_in_buffer[n:]\\n self.terminator = 0\\n self.found_terminator()\\n else:\\n # 3 cases:\\n # 1) end of buffer matches terminator exactly:\\n # collect data, transition\\n # 2) end of buffer matches some prefix:\\n # collect data to the prefix\\n # 3) end of buffer does not match any prefix:\\n # collect data\\n terminator_len = len(terminator)\\n index = self.ac_in_buffer.find(terminator)\\n if index != -1:\\n # we found the terminator\\n if index > 0:\\n # don't bother reporting the empty string\\n # (source of subtle bugs)\\n self.collect_incoming_data (self.ac_in_buffer[:index])\\n self.ac_in_buffer = self.ac_in_buffer[index+terminator_len:]\\n # This does the Right Thing if the terminator\\n # is changed here.\\n self.found_terminator()\\n else:\\n # check for a prefix of the terminator\\n index = asynchat.find_prefix_at_end (self.ac_in_buffer, terminator)\\n if index:\\n if index != lb:\\n # we found a prefix, collect up to the prefix\\n self.collect_incoming_data (self.ac_in_buffer[:-index])\\n self.ac_in_buffer = self.ac_in_buffer[-index:]\\n break\\n else:\\n # no prefix, collect it all\\n self.collect_incoming_data (self.ac_in_buffer)\\n self.ac_in_buffer = ''\",\n \"async def read(self, n: int = -1) -> AnyStr:\\n\\n # load file\\n if len(self._buffer) == 0 and \\\"r\\\" in self.mode:\\n await self._download()\\n\\n # check size\\n if n == -1:\\n data = self._buffer\\n self._pos = len(self._buffer) - 1\\n else:\\n # extract data to read\\n data = self._buffer[self._pos : self._pos + n]\\n self._pos += n\\n\\n # return data\\n return data\",\n \"async def read(self, num_bytes=0) -> bytes:\\n if num_bytes < 1:\\n num_bytes = self.in_waiting or 1\\n\\n return await self._read(num_bytes)\",\n \"def buffered_read(file_object, chunk_size=1024):\\n while True:\\n data = file_object.read(chunk_size)\\n if not data:\\n break\\n yield data\",\n \"def Read(self, data, address=None, size=None):\\n if not address:\\n address = self.mem_address\\n if hasattr(address, 'value'):\\n address = address.value\\n\\n if size:\\n nSize = win32structures.ULONG_PTR(size)\\n else:\\n nSize = win32structures.ULONG_PTR(sizeof(data))\\n\\n if self.size < nSize.value:\\n raise Exception(('Read: RemoteMemoryBlock is too small ({0} bytes),' +\\n ' {1} is required.').format(self.size, nSize.value))\\n\\n if hex(address).lower().startswith('0xffffff'):\\n raise Exception('Read: RemoteMemoryBlock has incorrect address =' + hex(address))\\n\\n lpNumberOfBytesRead = c_size_t(0)\\n\\n ret = win32functions.ReadProcessMemory(\\n c_void_p(self.process),\\n c_void_p(address),\\n byref(data),\\n nSize,\\n byref(lpNumberOfBytesRead)\\n )\\n\\n # disabled as it often returns an error - but\\n # seems to work fine anyway!!\\n if ret == 0:\\n # try again\\n ret = win32functions.ReadProcessMemory(\\n c_void_p(self.process),\\n c_void_p(address),\\n byref(data),\\n nSize,\\n byref(lpNumberOfBytesRead)\\n )\\n if ret == 0:\\n last_error = win32api.GetLastError()\\n if last_error != win32defines.ERROR_PARTIAL_COPY:\\n ActionLogger().log('Read: WARNING! self.mem_address =' +\\n hex(self.mem_address) + ' data address =' + str(byref(data)))\\n ActionLogger().log('LastError = ' + str(last_error) +\\n ': ' + win32api.FormatMessage(last_error).rstrip())\\n else:\\n ActionLogger().log('Error: ERROR_PARTIAL_COPY')\\n ActionLogger().log('\\\\nRead: WARNING! self.mem_address =' +\\n hex(self.mem_address) + ' data address =' + str(byref(data)))\\n\\n ActionLogger().log('lpNumberOfBytesRead =' +\\n str(lpNumberOfBytesRead) + ' nSize =' + str(nSize))\\n raise WinError()\\n else:\\n ActionLogger().log('Warning! Read OK: 2nd attempt!')\\n #else:\\n # print 'Read OK: lpNumberOfBytesRead =', lpNumberOfBytesRead, ' nSize =', nSize\\n\\n self.CheckGuardSignature()\\n return data\",\n \"def _read(self, location, width):\\n return self._connector.read(location=location, width=width)\",\n \"async def read(self,\\n n: int = -1\\n ) -> bytes:\\n if n == 0:\\n return b''\\n\\n future = asyncio.Future()\\n try:\\n self._read_queue.put_nowait((future, False, n))\\n return await future\\n\\n except aio.QueueClosedError:\\n raise ConnectionError()\",\n \"def recv(self, size, flags=0, timeout=_UNSET):\\n with self._recv_lock:\\n if timeout is _UNSET:\\n timeout = self.timeout\\n if flags:\\n raise ValueError(\\\"non-zero flags not supported: %r\\\" % flags)\\n if len(self.rbuf) >= size:\\n data, self.rbuf = self.rbuf[:size], self.rbuf[size:]\\n return data\\n if self.rbuf:\\n ret, self.rbuf = self.rbuf, b''\\n return ret\\n self.sock.settimeout(timeout)\\n try:\\n data = self.sock.recv(self._recvsize)\\n except socket.timeout:\\n raise Timeout(timeout) # check the rbuf attr for more\\n if len(data) > size:\\n data, self.rbuf = data[:size], data[size:]\\n return data\",\n \"def readinto(self, b):\\n if not self._readable:\\n raise UnsupportedOperation(\\\"read\\\")\\n elif not self._seekable:\\n return self._raw.readinto(b)\\n\\n with self._seek_lock:\\n seek = self._seek\\n queue = self._read_queue\\n\\n if seek == 0:\\n self._preload_range()\\n\\n size = len(b)\\n if size:\\n # Pre-allocated buffer: Use memory view to avoid copies\\n b_view = memoryview(b)\\n size_left = size\\n else:\\n # Dynamic buffer: Can't avoid copy, read until EOF\\n b_view = b\\n size_left = -1\\n b_end = 0\\n\\n buffer_size = self._buffer_size\\n while size_left > 0 or size_left == -1:\\n start = seek % buffer_size\\n queue_index = seek - start\\n try:\\n buffer = queue[queue_index]\\n except KeyError:\\n # EOF\\n break\\n\\n with handle_os_exceptions():\\n try:\\n queue[queue_index] = buffer = buffer.result()\\n\\n except AttributeError:\\n # Already evaluated\\n pass\\n buffer_view = memoryview(buffer)\\n data_size = len(buffer)\\n\\n if not data_size:\\n break\\n\\n if size_left != -1:\\n end = start + size_left\\n else:\\n end = data_size - start\\n\\n if end >= data_size:\\n end = data_size\\n\\n del queue[queue_index]\\n\\n index = queue_index + buffer_size * self._max_buffers\\n if index < self._size:\\n queue[index] = self._workers.submit(\\n self._read_range, index, index + buffer_size\\n )\\n\\n read_size = end - start\\n if size_left != -1:\\n size_left -= read_size\\n seek += read_size\\n\\n b_start = b_end\\n b_end = b_start + read_size\\n\\n b_view[b_start:b_end] = buffer_view[start:end]\\n\\n self._seek = seek\\n self._raw.seek(seek)\\n\\n return b_end\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7203594","0.71555114","0.68909967","0.68868846","0.6877114","0.68765837","0.678092","0.6759065","0.67104393","0.6689464","0.6680275","0.66459846","0.66349393","0.66163135","0.6571038","0.65568054","0.6509626","0.6477556","0.6435627","0.64335006","0.6431096","0.6431096","0.64066434","0.63738585","0.6372316","0.6366867","0.63579285","0.6322119","0.6311123","0.62782305","0.62568325","0.62461334","0.62312716","0.6220141","0.6211176","0.61757183","0.61691296","0.6155341","0.6143655","0.6125992","0.6103692","0.6094508","0.6090789","0.60817665","0.60767007","0.60724187","0.60722154","0.60699564","0.60647184","0.60620666","0.604334","0.60418665","0.60237396","0.6017266","0.6011182","0.6010873","0.60009843","0.5980541","0.5959087","0.59539574","0.59501475","0.59369624","0.59362215","0.59319574","0.59254724","0.5924686","0.5921891","0.5915936","0.59053034","0.59037286","0.59003544","0.5890404","0.58896977","0.5882369","0.58783686","0.5873461","0.5872241","0.58707577","0.58677286","0.5865518","0.5845755","0.58404034","0.58404034","0.5833682","0.5829998","0.5825664","0.58253664","0.58247024","0.5815765","0.5814046","0.5804121","0.57897305","0.57849294","0.5784462","0.5782985","0.57676923","0.57540286","0.57448304","0.5738915","0.5737706"],"string":"[\n \"0.7203594\",\n \"0.71555114\",\n \"0.68909967\",\n \"0.68868846\",\n \"0.6877114\",\n \"0.68765837\",\n \"0.678092\",\n \"0.6759065\",\n \"0.67104393\",\n \"0.6689464\",\n \"0.6680275\",\n \"0.66459846\",\n \"0.66349393\",\n \"0.66163135\",\n \"0.6571038\",\n \"0.65568054\",\n \"0.6509626\",\n \"0.6477556\",\n \"0.6435627\",\n \"0.64335006\",\n \"0.6431096\",\n \"0.6431096\",\n \"0.64066434\",\n \"0.63738585\",\n \"0.6372316\",\n \"0.6366867\",\n \"0.63579285\",\n \"0.6322119\",\n \"0.6311123\",\n \"0.62782305\",\n \"0.62568325\",\n \"0.62461334\",\n \"0.62312716\",\n \"0.6220141\",\n \"0.6211176\",\n \"0.61757183\",\n \"0.61691296\",\n \"0.6155341\",\n \"0.6143655\",\n \"0.6125992\",\n \"0.6103692\",\n \"0.6094508\",\n \"0.6090789\",\n \"0.60817665\",\n \"0.60767007\",\n \"0.60724187\",\n \"0.60722154\",\n \"0.60699564\",\n \"0.60647184\",\n \"0.60620666\",\n \"0.604334\",\n \"0.60418665\",\n \"0.60237396\",\n \"0.6017266\",\n \"0.6011182\",\n \"0.6010873\",\n \"0.60009843\",\n \"0.5980541\",\n \"0.5959087\",\n \"0.59539574\",\n \"0.59501475\",\n \"0.59369624\",\n \"0.59362215\",\n \"0.59319574\",\n \"0.59254724\",\n \"0.5924686\",\n \"0.5921891\",\n \"0.5915936\",\n \"0.59053034\",\n \"0.59037286\",\n \"0.59003544\",\n \"0.5890404\",\n \"0.58896977\",\n \"0.5882369\",\n \"0.58783686\",\n \"0.5873461\",\n \"0.5872241\",\n \"0.58707577\",\n \"0.58677286\",\n \"0.5865518\",\n \"0.5845755\",\n \"0.58404034\",\n \"0.58404034\",\n \"0.5833682\",\n \"0.5829998\",\n \"0.5825664\",\n \"0.58253664\",\n \"0.58247024\",\n \"0.5815765\",\n \"0.5814046\",\n \"0.5804121\",\n \"0.57897305\",\n \"0.57849294\",\n \"0.5784462\",\n \"0.5782985\",\n \"0.57676923\",\n \"0.57540286\",\n \"0.57448304\",\n \"0.5738915\",\n \"0.5737706\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.686824"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":89198,"cells":{"query":{"kind":"string","value":"Write data Returns length of written data. Writing scope must be entered for duration of writing."},"document":{"kind":"string","value":"def write(self, data):\n with self.writing:\n raise NotImplementedError()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def write_data(self, data):\n print('Wrote %d bytes' % (len(data)))","def _writeSomeData(self, data):\n if self.consumer is None:\n return 0\n self.consumer.write(data)\n return len(data)","def write(self, data):\n return 0","def write(self, data):\n with self.writing: # state check\n self.write_buffer.enqueue(data)\n if len(self.write_buffer) > 2 * self.bufsize:\n yield self.flush()\n elif len(self.write_buffer) > self.bufsize:\n self.flush()()\n do_return(len(data))","def write(self, data):\r\n try:\r\n char_handle = self._stdinout_characteristic.getHandle()\r\n bytes_sent = 0\r\n while bytes_sent < len(data):\r\n # Computing data to send.\r\n bytes_to_send = min(\r\n self._MAXIMUM_MESSAGE_SIZE_BYTES,\r\n len(data) - bytes_sent\r\n )\r\n data_to_send = data[bytes_sent:bytes_sent + bytes_to_send]\r\n\r\n # Writing data.\r\n self._node.writeCharacteristic(\r\n char_handle,\r\n data_to_send,\r\n True)\r\n bytes_sent += bytes_to_send\r\n\r\n # Calling on-write callback for a debug characteristic.\r\n self.on_write_characteristic(\r\n self._stdinout_characteristic, data_to_send, True)\r\n\r\n return bytes_sent\r\n\r\n except BTLEException as e:\r\n self._node._unexpected_disconnect()","def write_data(self, data):\n ofs = 0\n size = len(data)\n try:\n while ofs < size:\n # how many bytes should we write?\n wr_size = self.wrbuf_chunksize\n if wr_size > size - ofs:\n # reduce the write size\n wr_size = size - ofs\n # write the bytes\n n = self._write(data[ofs : ofs + wr_size])\n if n <= 0:\n raise usbdev_error(\"USB bulk write error\")\n ofs += n\n # return the number of bytes written\n return ofs\n except usb.core.USBError as e:\n raise usbdev_error(str(e))","def write(self, data):\n self.buffer.write(data)\n self.offset += len(data)","def write_data():","def put(self,data):\n\n\t\tself.fd.write(str(data))\n\t\treturn 1","def write( data ):","def __write(self, data):\n return self.__descriptor.write(data.encode(\"utf-8\") + b'\\n')","def write(self, data):\n self._check_not_closed()\n raise io.UnsupportedOperation(\"Write not supported\")","def write(data):","def write_schedule(self, data):\n self.write_buffer.enqueue(data)\n return len(data)","def _write_at(self, data, offset):\n n_data = len(data)\n bytes_written = 0\n while bytes_written < n_data:\n available = min(\n n_data - bytes_written,\n self.channel.connection.credits * smb2.BYTES_PER_CREDIT,\n self.channel.connection.negotiate_response.max_write_size,\n )\n chunk = data[bytes_written : bytes_written + available]\n count = self.channel.write(self, offset + bytes_written, chunk)\n bytes_written += count\n if bytes_written:\n self._offset += bytes_written\n # update the EOF marker if we write past it\n self._end_of_file = max(self.end_of_file, self._offset)\n return bytes_written","def _write(self, data, length, error, move_start=True):\n idxs = self.get_indexes(self._end, length, self.maxsize)\n self.move_end(length, error, move_start)\n self._data[idxs] = data","def write(self, data):\n raise NotImplementedError()","def getSize(self):\n if not self.changed: return self.size\n #--StringIO Object\n out = Tes3Writer(cStringIO.StringIO())\n self.dumpData(out)\n #--Done\n self.data = out.getvalue()\n data.close()\n self.size = len(self.data)\n self.setChanged(False)\n return self.size","def write(self, data):\n return self._write(self.wfile, data)","def Length(data):\n return len(data)","def length(self):\n return len(self._data) if self._data else 0","def write(self, data):\n if self.closed:\n raise ConnectionResetError(\n 'Transport closed - cannot write on %s' % self\n )\n else:\n t = self.transport\n if self._paused or self._buffer:\n self._buffer.appendleft(data)\n self._buffer_size += len(data)\n self._write_from_buffer()\n if self._buffer_size > 2 * self._b_limit:\n if self._waiter and not self._waiter.cancelled():\n self.logger.warning(\n '%s buffer size is %d: limit is %d ',\n self._buffer_size, self._b_limit\n )\n else:\n t.pause_reading()\n self._waiter = self._loop.create_future()\n else:\n t.write(data)\n self.changed()\n return self._waiter","def len (self):\n\t\treturn len (self.data)","def write(self, data):\n self.__CheckOpen('write')\n self.__data += data\n encrypt_buffer_size = self.__key._NoPadBufferSize(len(self.__data))\n\n if len(self.__data) >= encrypt_buffer_size:\n self.__WriteEncrypted(self.__data[:encrypt_buffer_size])\n else:\n encrypt_buffer_size = 0\n\n self.__data = self.__data[encrypt_buffer_size:]","def length(self) -> int:\n return len(self.data)","def length(self):\n return len(self.data)","def length(self):\n return len(self.data)","def length(self):\n return len(self.data)","def WriteEntry(self, data):\n if not self._file_object:\n raise IOError('Unable to write to closed serialized data stream.')\n\n data_size = len(data)\n # TODO: Fix maximum size limit handling to create new stream.\n # data_end_offset = (\n # self._file_object.tell() + self._DATA_ENTRY_SIZE + data_size)\n # if data_end_offset > self._maximum_data_size:\n # raise IOError('Unable to write data entry size value out of bounds.')\n\n data_size = construct.ULInt32('size').build(data_size)\n self._file_object.write(data_size)\n self._file_object.write(data)\n\n return self._file_object.tell()","def __len__(self):\n return(self.data_len)","def write(self, data: bytes) -> None:\n pass","def write(self, data):\n\n # TODO - Check bytes vs unicode\n data = _as_bytes(data)\n # block_size = 2**16 = 65536\n data_len = len(data)\n if len(self._buffer) + data_len < 65536:\n # print(\"Cached %r\" % data)\n self._buffer += data\n return\n else:\n # print(\"Got %r, writing out some data...\" % data)\n self._buffer += data\n while len(self._buffer) >= 65536:\n self._write_block(self._buffer[:65536])\n self._buffer = self._buffer[65536:]","def writeData(self, data):\n for i in range(0, len(data), 4):\n self.checksum = (self.checksum + int.from_bytes(data[i:i+4], byteorder='little')) & 0xFFFFFFFF\n return self._writeMessage(data=data, messageStr='writeData')","def __len__(self):\n len(self.data)","def on_write_needed(self, nbytes, underflow):","def write(self, data, timeout_ms=0):\n if not self.is_valid():\n return 0\n if isinstance(self.__usb_dev, MpUsbApi):\n num = self.__usb_dev.MPUSBWrite(self.__handle_write, data, timeout_ms)\n else:\n num = self.__usb_dev.write(1, data, timeout_ms)\n return num\n #end write()","def getLen(self):\n return len(self.data)","def write(self, data):\n _check_init()\n self._check_open()\n\n self._output.Write(data)","def __len__(self) -> int:\n if self.data is None:\n return 0\n return len(self.data)","def write(self, data, handle=None):\n if not isinstance(data, (bytes, bytearray, memoryview)):\n raise TypeError(\"data: expecting a bytes-like instance, got {!r}\"\n .format(type(data).__name__))\n if handle is not None and not isinstance(self._handle, pyuv.Pipe):\n raise ValueError('handle: can only be sent over pyuv.Pipe')\n self._check_status()\n if not self._writable:\n raise TransportError('transport is not writable')\n if self._closing:\n raise TransportError('transport is closing')\n try:\n if handle:\n self._handle.write(data, self._on_write_complete, handle)\n else:\n self._handle.write(data, self._on_write_complete)\n except pyuv.error.UVError as e:\n self._error = TransportError.from_errno(e.args[0])\n self.abort()\n raise compat.saved_exc(self._error)\n # We only keep track of the number of outstanding write requests\n # outselves. See note in get_write_buffer_size().\n self._write_buffer_size += 1\n self._maybe_pause_protocol()","def getSize(self):\n if not self.changed: return self.size\n #--Pack data and return size.\n out = Tes3Writer(cStringIO.StringIO())\n self.dumpData(out)\n self.data = out.getvalue()\n out.close()\n self.size = len(self.data)\n self.setChanged(False)\n return self.size","def __len__(self):\n # type: () -> int\n return len(self.data)","def winhttp_WinHttpWriteData(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hRequest\", \"lpBuffer\", \"dwNumberOfBytesToWrite\", \"lpdwNumberOfBytesWritten\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self._data)","def __len__(self) -> int:\n return len(self._data)","def extend_data(self, data):\r\n\r\n self._data_l += len(data)\r\n if not self.store: return\r\n self._data_b.write(data)","def _write_data(self, data):\n Compressor = zlib.compressobj(\n self.comp_str, zlib.DEFLATED, -zlib.MAX_WBITS, zlib.DEF_MEM_LEVEL, 0\n )\n # compress data and flush (includes writing crc32 and isize)\n if isinstance(data, bytes) is False:\n data = bytes(data, \"latin-1\")\n self.crc32 = zlib.crc32(data)\n self.isize = len(data) % 2**32\n comp_data = Compressor.compress(data) + Compressor.flush()\n self.file_out.write(comp_data)\n self.file_out.write(struct.pack(\"<L\", self.crc32))\n self.file_out.write(struct.pack(\"<L\", self.isize))\n return","def send(self, s):\r\n self.write(s)\r\n return len(s)","def write(self, address, data, progress_update=None):\n size_remain = len(data)\n\n while size_remain > 0:\n if progress_update is not None:\n progress_update(\n int(100 * (len(data) - size_remain) / len(data)))\n\n part_size = self.__RW_MAX_SIZE \\\n if size_remain > self.__RW_MAX_SIZE else size_remain\n offset = address + len(data) - size_remain\n\n for retry in range(0, self.__RETRY_MAX_NUM):\n self._send_command(self.__COMMAND['write memory'])\n self._set_address(offset)\n\n chunk = data[offset - address:offset - address + part_size]\n checksum = 0xff & ((part_size - 1) ^ self._checksum(chunk))\n\n bytes_sent = self._port_handle.write(bytearray([part_size - 1]))\n if bytes_sent != len(bytearray([part_size - 1])):\n raise DfuException('Tried to send {} bytes, {} was '\n 'sent.'.format(\n len(bytearray([part_size - 1])),\n bytes_sent))\n\n bytes_sent = self._port_handle.write(chunk)\n if bytes_sent != len(chunk):\n raise DfuException('Tried to send {} bytes, {} was '\n 'sent.'.format(len(chunk), bytes_sent))\n\n bytes_sent = self._port_handle.write(bytearray([checksum]))\n if bytes_sent != len(bytearray([checksum])):\n raise DfuException('Tried to send {} bytes, {} was '\n 'sent.'.format(\n len(bytearray([checksum])),\n bytes_sent))\n\n if self._is_acknowledged():\n break\n else:\n raise DfuException('Write memory at {} failed after {} '\n 'retries.'.format(offset, retry + 1))\n\n size_remain -= part_size\n\n if progress_update is not None:\n progress_update(100)","def growing_write(self, data):\n data, shape = format_write_data(data, self.dtype)\n\n length = shape[0]\n available = self.get_available_space()\n if shape[1:] != self.shape[1:]:\n msg = \"could not broadcast input array from shape {:s} into shape {:s}\".format(str(shape), str(self.shape))\n raise ValueError(msg)\n elif length > available:\n # Keep the old data and reshape\n old_data = self.get_data()\n self.shape = (self.maxsize + (length - available),) + self.shape[1:]\n if len(old_data) > 0:\n self._write(old_data, len(old_data), False)\n\n self._write(data, length, error=True)","def _write(self, data):\n self._writer.write(data)","def write(self, data):\n with self._write_lock:\n self.socket.send(data)","def data_count(self):\n return(len(self.data))","def write(self, data):\n self.check_connection()\n self._write(struct.pack(\"I\", len(data)))\n self._write(data)\n self._write_hmac.update(data)\n self._write(self._write_hmac.digest())","def write(self, stream: BinaryIO, data: Any) -> int:\n return self._write(stream, data)","def writer(data):\n if len(data) == 0:\n return\n try:\n # Call user write function:\n if write_function != None:\n write_function(data)\n except Exception as e:\n # Propagate error if the user function caused an error:\n presented_output_store[\"user_write_error\"] = str(e)\n try:\n process.kill()\n except Exception:\n pass\n presented_output_store[\"data\"] += data","def async_write(self, data) -> None:\n if data and self.__is_active:\n # logging.info('async_write: ' + str(data))\n self.__client_socket.async_write_all(data, self.__async_write_callback)\n\n # logging.info('async_write done')","def __len__(self) -> int:\n return len(self.buffer)","def _lowLevelSend(self,data):\n import socket\n \n try: size = self.socket_reference.send(data)\n except socket.error as error: raise CommClientException(str(error)) \n \n return size","def get_write_buffer_size(self):\n return self._write_buffer_size","def write(self, data):\n\t\tself.outputbuffer.write(data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def __len__(self):\n return len(self.data)","def write(self, data: Union[str, bytes]) -> None:\n ...","def write(self, data):\n line = pkt_line(data)\n line_len = len(line)\n over = self._buflen + line_len - self._bufsize\n if over >= 0:\n start = line_len - over\n self._wbuf.write(line[:start])\n self.flush()\n else:\n start = 0\n saved = line[start:]\n self._wbuf.write(saved)\n self._buflen += len(saved)","def __len__(self):\r\n return len(self._data)","def writeMuchData(self, len, start, delta, context):\n print(\"start: {}\".format(start))\n print(\"len: {}\".format(len))\n print(\"delta: {}\".format(delta))\n\n for i in range(start, start + len):\n key = \"key_{}\".format(i)\n address = _make_benchcontract_address(key)\n print(\"address: {}\".format(address))\n value = i + delta\n print(\"value: {}\".format(value))\n value = \"{}\".format(value)\n print(\"value: {}\".format(value))\n value_encoded = value.encode()\n print(\"encoded value: {}\".format(value_encoded))\n context.set_state({address: value_encoded}, timeout=self.timeout)\n print(\"writeMuchData stored {} --> {} to state\".format(key, value))\n return 0","def write(self, data):\n try:\n self._conn.send(data)\n except OSError as exc:\n raise TS3ConnectionClosedException(OSError) from exc","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n return len(self._data)","def __len__(self):\n\n return len(self.data)","def __len__(self):\n\n return len(self.data)","def __len__(self):\n return len(self.buffer)","def __len__(self):\n return len(self.buffer)","def __len__(self) -> int:\n if self.serialize_data:\n return len(self.data_address)\n else:\n return len(self.data_infos)","def write(self, data):\n self.buffer.append(data)\n while self.push():\n pass","def __len__(self) -> int:\n return len(self.getvalue())","def _write(self, data):\n if not self.connected:\n raise IOError(\"Not connected.\")\n\n if len(data + b'\\r\\n') > self.MAX_MESSAGE_SIZE:\n logger.error(\n \"A message wasn't sent to %r because it was larger than %d \"\n \"bytes (that is MAX_MESSAGE_SIZE). Consider raising that \"\n \"value if the message seemed legit.\", self._repr_remote(),\n self.MAX_MESSAGE_SIZE)\n # No need to call finalize.\n raise IOError(\"Message too long.\")\n\n try:\n with self._write_lock:\n if not self.connected:\n raise IOError(\"Not connected.\")\n # Does the same as self._socket.sendall.\n self._writer.write(data + b'\\r\\n')\n self._writer.flush()\n except socket.error as error:\n self.finalize(\"Write failed.\")\n logger.warning(\"Failed writing to socket: %s.\", error)\n raise error","def __len__(self):\r\n return len(self. data)","def write(self, data, meta):\n raise NotImplementedError","def size(self):\n return len(self.data)","def size(self):\n return len(self.data)"],"string":"[\n \"def write_data(self, data):\\n print('Wrote %d bytes' % (len(data)))\",\n \"def _writeSomeData(self, data):\\n if self.consumer is None:\\n return 0\\n self.consumer.write(data)\\n return len(data)\",\n \"def write(self, data):\\n return 0\",\n \"def write(self, data):\\n with self.writing: # state check\\n self.write_buffer.enqueue(data)\\n if len(self.write_buffer) > 2 * self.bufsize:\\n yield self.flush()\\n elif len(self.write_buffer) > self.bufsize:\\n self.flush()()\\n do_return(len(data))\",\n \"def write(self, data):\\r\\n try:\\r\\n char_handle = self._stdinout_characteristic.getHandle()\\r\\n bytes_sent = 0\\r\\n while bytes_sent < len(data):\\r\\n # Computing data to send.\\r\\n bytes_to_send = min(\\r\\n self._MAXIMUM_MESSAGE_SIZE_BYTES,\\r\\n len(data) - bytes_sent\\r\\n )\\r\\n data_to_send = data[bytes_sent:bytes_sent + bytes_to_send]\\r\\n\\r\\n # Writing data.\\r\\n self._node.writeCharacteristic(\\r\\n char_handle,\\r\\n data_to_send,\\r\\n True)\\r\\n bytes_sent += bytes_to_send\\r\\n\\r\\n # Calling on-write callback for a debug characteristic.\\r\\n self.on_write_characteristic(\\r\\n self._stdinout_characteristic, data_to_send, True)\\r\\n\\r\\n return bytes_sent\\r\\n\\r\\n except BTLEException as e:\\r\\n self._node._unexpected_disconnect()\",\n \"def write_data(self, data):\\n ofs = 0\\n size = len(data)\\n try:\\n while ofs < size:\\n # how many bytes should we write?\\n wr_size = self.wrbuf_chunksize\\n if wr_size > size - ofs:\\n # reduce the write size\\n wr_size = size - ofs\\n # write the bytes\\n n = self._write(data[ofs : ofs + wr_size])\\n if n <= 0:\\n raise usbdev_error(\\\"USB bulk write error\\\")\\n ofs += n\\n # return the number of bytes written\\n return ofs\\n except usb.core.USBError as e:\\n raise usbdev_error(str(e))\",\n \"def write(self, data):\\n self.buffer.write(data)\\n self.offset += len(data)\",\n \"def write_data():\",\n \"def put(self,data):\\n\\n\\t\\tself.fd.write(str(data))\\n\\t\\treturn 1\",\n \"def write( data ):\",\n \"def __write(self, data):\\n return self.__descriptor.write(data.encode(\\\"utf-8\\\") + b'\\\\n')\",\n \"def write(self, data):\\n self._check_not_closed()\\n raise io.UnsupportedOperation(\\\"Write not supported\\\")\",\n \"def write(data):\",\n \"def write_schedule(self, data):\\n self.write_buffer.enqueue(data)\\n return len(data)\",\n \"def _write_at(self, data, offset):\\n n_data = len(data)\\n bytes_written = 0\\n while bytes_written < n_data:\\n available = min(\\n n_data - bytes_written,\\n self.channel.connection.credits * smb2.BYTES_PER_CREDIT,\\n self.channel.connection.negotiate_response.max_write_size,\\n )\\n chunk = data[bytes_written : bytes_written + available]\\n count = self.channel.write(self, offset + bytes_written, chunk)\\n bytes_written += count\\n if bytes_written:\\n self._offset += bytes_written\\n # update the EOF marker if we write past it\\n self._end_of_file = max(self.end_of_file, self._offset)\\n return bytes_written\",\n \"def _write(self, data, length, error, move_start=True):\\n idxs = self.get_indexes(self._end, length, self.maxsize)\\n self.move_end(length, error, move_start)\\n self._data[idxs] = data\",\n \"def write(self, data):\\n raise NotImplementedError()\",\n \"def getSize(self):\\n if not self.changed: return self.size\\n #--StringIO Object\\n out = Tes3Writer(cStringIO.StringIO())\\n self.dumpData(out)\\n #--Done\\n self.data = out.getvalue()\\n data.close()\\n self.size = len(self.data)\\n self.setChanged(False)\\n return self.size\",\n \"def write(self, data):\\n return self._write(self.wfile, data)\",\n \"def Length(data):\\n return len(data)\",\n \"def length(self):\\n return len(self._data) if self._data else 0\",\n \"def write(self, data):\\n if self.closed:\\n raise ConnectionResetError(\\n 'Transport closed - cannot write on %s' % self\\n )\\n else:\\n t = self.transport\\n if self._paused or self._buffer:\\n self._buffer.appendleft(data)\\n self._buffer_size += len(data)\\n self._write_from_buffer()\\n if self._buffer_size > 2 * self._b_limit:\\n if self._waiter and not self._waiter.cancelled():\\n self.logger.warning(\\n '%s buffer size is %d: limit is %d ',\\n self._buffer_size, self._b_limit\\n )\\n else:\\n t.pause_reading()\\n self._waiter = self._loop.create_future()\\n else:\\n t.write(data)\\n self.changed()\\n return self._waiter\",\n \"def len (self):\\n\\t\\treturn len (self.data)\",\n \"def write(self, data):\\n self.__CheckOpen('write')\\n self.__data += data\\n encrypt_buffer_size = self.__key._NoPadBufferSize(len(self.__data))\\n\\n if len(self.__data) >= encrypt_buffer_size:\\n self.__WriteEncrypted(self.__data[:encrypt_buffer_size])\\n else:\\n encrypt_buffer_size = 0\\n\\n self.__data = self.__data[encrypt_buffer_size:]\",\n \"def length(self) -> int:\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\",\n \"def WriteEntry(self, data):\\n if not self._file_object:\\n raise IOError('Unable to write to closed serialized data stream.')\\n\\n data_size = len(data)\\n # TODO: Fix maximum size limit handling to create new stream.\\n # data_end_offset = (\\n # self._file_object.tell() + self._DATA_ENTRY_SIZE + data_size)\\n # if data_end_offset > self._maximum_data_size:\\n # raise IOError('Unable to write data entry size value out of bounds.')\\n\\n data_size = construct.ULInt32('size').build(data_size)\\n self._file_object.write(data_size)\\n self._file_object.write(data)\\n\\n return self._file_object.tell()\",\n \"def __len__(self):\\n return(self.data_len)\",\n \"def write(self, data: bytes) -> None:\\n pass\",\n \"def write(self, data):\\n\\n # TODO - Check bytes vs unicode\\n data = _as_bytes(data)\\n # block_size = 2**16 = 65536\\n data_len = len(data)\\n if len(self._buffer) + data_len < 65536:\\n # print(\\\"Cached %r\\\" % data)\\n self._buffer += data\\n return\\n else:\\n # print(\\\"Got %r, writing out some data...\\\" % data)\\n self._buffer += data\\n while len(self._buffer) >= 65536:\\n self._write_block(self._buffer[:65536])\\n self._buffer = self._buffer[65536:]\",\n \"def writeData(self, data):\\n for i in range(0, len(data), 4):\\n self.checksum = (self.checksum + int.from_bytes(data[i:i+4], byteorder='little')) & 0xFFFFFFFF\\n return self._writeMessage(data=data, messageStr='writeData')\",\n \"def __len__(self):\\n len(self.data)\",\n \"def on_write_needed(self, nbytes, underflow):\",\n \"def write(self, data, timeout_ms=0):\\n if not self.is_valid():\\n return 0\\n if isinstance(self.__usb_dev, MpUsbApi):\\n num = self.__usb_dev.MPUSBWrite(self.__handle_write, data, timeout_ms)\\n else:\\n num = self.__usb_dev.write(1, data, timeout_ms)\\n return num\\n #end write()\",\n \"def getLen(self):\\n return len(self.data)\",\n \"def write(self, data):\\n _check_init()\\n self._check_open()\\n\\n self._output.Write(data)\",\n \"def __len__(self) -> int:\\n if self.data is None:\\n return 0\\n return len(self.data)\",\n \"def write(self, data, handle=None):\\n if not isinstance(data, (bytes, bytearray, memoryview)):\\n raise TypeError(\\\"data: expecting a bytes-like instance, got {!r}\\\"\\n .format(type(data).__name__))\\n if handle is not None and not isinstance(self._handle, pyuv.Pipe):\\n raise ValueError('handle: can only be sent over pyuv.Pipe')\\n self._check_status()\\n if not self._writable:\\n raise TransportError('transport is not writable')\\n if self._closing:\\n raise TransportError('transport is closing')\\n try:\\n if handle:\\n self._handle.write(data, self._on_write_complete, handle)\\n else:\\n self._handle.write(data, self._on_write_complete)\\n except pyuv.error.UVError as e:\\n self._error = TransportError.from_errno(e.args[0])\\n self.abort()\\n raise compat.saved_exc(self._error)\\n # We only keep track of the number of outstanding write requests\\n # outselves. See note in get_write_buffer_size().\\n self._write_buffer_size += 1\\n self._maybe_pause_protocol()\",\n \"def getSize(self):\\n if not self.changed: return self.size\\n #--Pack data and return size.\\n out = Tes3Writer(cStringIO.StringIO())\\n self.dumpData(out)\\n self.data = out.getvalue()\\n out.close()\\n self.size = len(self.data)\\n self.setChanged(False)\\n return self.size\",\n \"def __len__(self):\\n # type: () -> int\\n return len(self.data)\",\n \"def winhttp_WinHttpWriteData(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hRequest\\\", \\\"lpBuffer\\\", \\\"dwNumberOfBytesToWrite\\\", \\\"lpdwNumberOfBytesWritten\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self._data)\",\n \"def __len__(self) -> int:\\n return len(self._data)\",\n \"def extend_data(self, data):\\r\\n\\r\\n self._data_l += len(data)\\r\\n if not self.store: return\\r\\n self._data_b.write(data)\",\n \"def _write_data(self, data):\\n Compressor = zlib.compressobj(\\n self.comp_str, zlib.DEFLATED, -zlib.MAX_WBITS, zlib.DEF_MEM_LEVEL, 0\\n )\\n # compress data and flush (includes writing crc32 and isize)\\n if isinstance(data, bytes) is False:\\n data = bytes(data, \\\"latin-1\\\")\\n self.crc32 = zlib.crc32(data)\\n self.isize = len(data) % 2**32\\n comp_data = Compressor.compress(data) + Compressor.flush()\\n self.file_out.write(comp_data)\\n self.file_out.write(struct.pack(\\\"<L\\\", self.crc32))\\n self.file_out.write(struct.pack(\\\"<L\\\", self.isize))\\n return\",\n \"def send(self, s):\\r\\n self.write(s)\\r\\n return len(s)\",\n \"def write(self, address, data, progress_update=None):\\n size_remain = len(data)\\n\\n while size_remain > 0:\\n if progress_update is not None:\\n progress_update(\\n int(100 * (len(data) - size_remain) / len(data)))\\n\\n part_size = self.__RW_MAX_SIZE \\\\\\n if size_remain > self.__RW_MAX_SIZE else size_remain\\n offset = address + len(data) - size_remain\\n\\n for retry in range(0, self.__RETRY_MAX_NUM):\\n self._send_command(self.__COMMAND['write memory'])\\n self._set_address(offset)\\n\\n chunk = data[offset - address:offset - address + part_size]\\n checksum = 0xff & ((part_size - 1) ^ self._checksum(chunk))\\n\\n bytes_sent = self._port_handle.write(bytearray([part_size - 1]))\\n if bytes_sent != len(bytearray([part_size - 1])):\\n raise DfuException('Tried to send {} bytes, {} was '\\n 'sent.'.format(\\n len(bytearray([part_size - 1])),\\n bytes_sent))\\n\\n bytes_sent = self._port_handle.write(chunk)\\n if bytes_sent != len(chunk):\\n raise DfuException('Tried to send {} bytes, {} was '\\n 'sent.'.format(len(chunk), bytes_sent))\\n\\n bytes_sent = self._port_handle.write(bytearray([checksum]))\\n if bytes_sent != len(bytearray([checksum])):\\n raise DfuException('Tried to send {} bytes, {} was '\\n 'sent.'.format(\\n len(bytearray([checksum])),\\n bytes_sent))\\n\\n if self._is_acknowledged():\\n break\\n else:\\n raise DfuException('Write memory at {} failed after {} '\\n 'retries.'.format(offset, retry + 1))\\n\\n size_remain -= part_size\\n\\n if progress_update is not None:\\n progress_update(100)\",\n \"def growing_write(self, data):\\n data, shape = format_write_data(data, self.dtype)\\n\\n length = shape[0]\\n available = self.get_available_space()\\n if shape[1:] != self.shape[1:]:\\n msg = \\\"could not broadcast input array from shape {:s} into shape {:s}\\\".format(str(shape), str(self.shape))\\n raise ValueError(msg)\\n elif length > available:\\n # Keep the old data and reshape\\n old_data = self.get_data()\\n self.shape = (self.maxsize + (length - available),) + self.shape[1:]\\n if len(old_data) > 0:\\n self._write(old_data, len(old_data), False)\\n\\n self._write(data, length, error=True)\",\n \"def _write(self, data):\\n self._writer.write(data)\",\n \"def write(self, data):\\n with self._write_lock:\\n self.socket.send(data)\",\n \"def data_count(self):\\n return(len(self.data))\",\n \"def write(self, data):\\n self.check_connection()\\n self._write(struct.pack(\\\"I\\\", len(data)))\\n self._write(data)\\n self._write_hmac.update(data)\\n self._write(self._write_hmac.digest())\",\n \"def write(self, stream: BinaryIO, data: Any) -> int:\\n return self._write(stream, data)\",\n \"def writer(data):\\n if len(data) == 0:\\n return\\n try:\\n # Call user write function:\\n if write_function != None:\\n write_function(data)\\n except Exception as e:\\n # Propagate error if the user function caused an error:\\n presented_output_store[\\\"user_write_error\\\"] = str(e)\\n try:\\n process.kill()\\n except Exception:\\n pass\\n presented_output_store[\\\"data\\\"] += data\",\n \"def async_write(self, data) -> None:\\n if data and self.__is_active:\\n # logging.info('async_write: ' + str(data))\\n self.__client_socket.async_write_all(data, self.__async_write_callback)\\n\\n # logging.info('async_write done')\",\n \"def __len__(self) -> int:\\n return len(self.buffer)\",\n \"def _lowLevelSend(self,data):\\n import socket\\n \\n try: size = self.socket_reference.send(data)\\n except socket.error as error: raise CommClientException(str(error)) \\n \\n return size\",\n \"def get_write_buffer_size(self):\\n return self._write_buffer_size\",\n \"def write(self, data):\\n\\t\\tself.outputbuffer.write(data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.data)\",\n \"def write(self, data: Union[str, bytes]) -> None:\\n ...\",\n \"def write(self, data):\\n line = pkt_line(data)\\n line_len = len(line)\\n over = self._buflen + line_len - self._bufsize\\n if over >= 0:\\n start = line_len - over\\n self._wbuf.write(line[:start])\\n self.flush()\\n else:\\n start = 0\\n saved = line[start:]\\n self._wbuf.write(saved)\\n self._buflen += len(saved)\",\n \"def __len__(self):\\r\\n return len(self._data)\",\n \"def writeMuchData(self, len, start, delta, context):\\n print(\\\"start: {}\\\".format(start))\\n print(\\\"len: {}\\\".format(len))\\n print(\\\"delta: {}\\\".format(delta))\\n\\n for i in range(start, start + len):\\n key = \\\"key_{}\\\".format(i)\\n address = _make_benchcontract_address(key)\\n print(\\\"address: {}\\\".format(address))\\n value = i + delta\\n print(\\\"value: {}\\\".format(value))\\n value = \\\"{}\\\".format(value)\\n print(\\\"value: {}\\\".format(value))\\n value_encoded = value.encode()\\n print(\\\"encoded value: {}\\\".format(value_encoded))\\n context.set_state({address: value_encoded}, timeout=self.timeout)\\n print(\\\"writeMuchData stored {} --> {} to state\\\".format(key, value))\\n return 0\",\n \"def write(self, data):\\n try:\\n self._conn.send(data)\\n except OSError as exc:\\n raise TS3ConnectionClosedException(OSError) from exc\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n return len(self._data)\",\n \"def __len__(self):\\n\\n return len(self.data)\",\n \"def __len__(self):\\n\\n return len(self.data)\",\n \"def __len__(self):\\n return len(self.buffer)\",\n \"def __len__(self):\\n return len(self.buffer)\",\n \"def __len__(self) -> int:\\n if self.serialize_data:\\n return len(self.data_address)\\n else:\\n return len(self.data_infos)\",\n \"def write(self, data):\\n self.buffer.append(data)\\n while self.push():\\n pass\",\n \"def __len__(self) -> int:\\n return len(self.getvalue())\",\n \"def _write(self, data):\\n if not self.connected:\\n raise IOError(\\\"Not connected.\\\")\\n\\n if len(data + b'\\\\r\\\\n') > self.MAX_MESSAGE_SIZE:\\n logger.error(\\n \\\"A message wasn't sent to %r because it was larger than %d \\\"\\n \\\"bytes (that is MAX_MESSAGE_SIZE). Consider raising that \\\"\\n \\\"value if the message seemed legit.\\\", self._repr_remote(),\\n self.MAX_MESSAGE_SIZE)\\n # No need to call finalize.\\n raise IOError(\\\"Message too long.\\\")\\n\\n try:\\n with self._write_lock:\\n if not self.connected:\\n raise IOError(\\\"Not connected.\\\")\\n # Does the same as self._socket.sendall.\\n self._writer.write(data + b'\\\\r\\\\n')\\n self._writer.flush()\\n except socket.error as error:\\n self.finalize(\\\"Write failed.\\\")\\n logger.warning(\\\"Failed writing to socket: %s.\\\", error)\\n raise error\",\n \"def __len__(self):\\r\\n return len(self. data)\",\n \"def write(self, data, meta):\\n raise NotImplementedError\",\n \"def size(self):\\n return len(self.data)\",\n \"def size(self):\\n return len(self.data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72757506","0.72544014","0.71922183","0.6731189","0.6619201","0.6602798","0.6471862","0.64083594","0.6364985","0.63516694","0.6344728","0.63193315","0.63137215","0.63096243","0.6309239","0.6277473","0.6271191","0.62258345","0.6195639","0.61901796","0.61405164","0.6133724","0.6118433","0.60738057","0.6051292","0.6047078","0.6047078","0.6047078","0.6018892","0.60049963","0.6003876","0.59998614","0.59873486","0.5984664","0.59831303","0.5981018","0.5977146","0.5944097","0.59050024","0.5895748","0.58788604","0.5870059","0.586584","0.5854048","0.5854048","0.5854048","0.5850835","0.5850835","0.58304036","0.58295524","0.5809324","0.5809321","0.5793146","0.57781166","0.5759673","0.575022","0.57461053","0.57386416","0.5732145","0.5717809","0.5715083","0.5713574","0.5708686","0.56948453","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5691348","0.5678622","0.5677812","0.56752914","0.56678116","0.5652575","0.5649003","0.5649003","0.5649003","0.5649003","0.5649003","0.5649003","0.5649003","0.5649003","0.5649003","0.5647048","0.5647048","0.5633979","0.5633979","0.56257755","0.5598417","0.5569782","0.5567157","0.55634207","0.556048","0.5559076","0.5559076"],"string":"[\n \"0.72757506\",\n \"0.72544014\",\n \"0.71922183\",\n \"0.6731189\",\n \"0.6619201\",\n \"0.6602798\",\n \"0.6471862\",\n \"0.64083594\",\n \"0.6364985\",\n \"0.63516694\",\n \"0.6344728\",\n \"0.63193315\",\n \"0.63137215\",\n \"0.63096243\",\n \"0.6309239\",\n \"0.6277473\",\n \"0.6271191\",\n \"0.62258345\",\n \"0.6195639\",\n \"0.61901796\",\n \"0.61405164\",\n \"0.6133724\",\n \"0.6118433\",\n \"0.60738057\",\n \"0.6051292\",\n \"0.6047078\",\n \"0.6047078\",\n \"0.6047078\",\n \"0.6018892\",\n \"0.60049963\",\n \"0.6003876\",\n \"0.59998614\",\n \"0.59873486\",\n \"0.5984664\",\n \"0.59831303\",\n \"0.5981018\",\n \"0.5977146\",\n \"0.5944097\",\n \"0.59050024\",\n \"0.5895748\",\n \"0.58788604\",\n \"0.5870059\",\n \"0.586584\",\n \"0.5854048\",\n \"0.5854048\",\n \"0.5854048\",\n \"0.5850835\",\n \"0.5850835\",\n \"0.58304036\",\n \"0.58295524\",\n \"0.5809324\",\n \"0.5809321\",\n \"0.5793146\",\n \"0.57781166\",\n \"0.5759673\",\n \"0.575022\",\n \"0.57461053\",\n \"0.57386416\",\n \"0.5732145\",\n \"0.5717809\",\n \"0.5715083\",\n \"0.5713574\",\n \"0.5708686\",\n \"0.56948453\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5691348\",\n \"0.5678622\",\n \"0.5677812\",\n \"0.56752914\",\n \"0.56678116\",\n \"0.5652575\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5649003\",\n \"0.5647048\",\n \"0.5647048\",\n \"0.5633979\",\n \"0.5633979\",\n \"0.56257755\",\n \"0.5598417\",\n \"0.5569782\",\n \"0.5567157\",\n \"0.55634207\",\n \"0.556048\",\n \"0.5559076\",\n \"0.5559076\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6268723"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":89199,"cells":{"query":{"kind":"string","value":"Flush write buffers Must hook continuation to the current flush if any or start new one."},"document":{"kind":"string","value":"def flush(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 flush( finishing=False, callback=None ):","def flush(self):\n if self.index < self.bufsize:\n self.writer(\n self.linesep.join(self.read1_batch[0:self.index]),\n self.linesep.join(self.read2_batch[0:self.index]))\n else:\n self.writer(\n self.linesep.join(self.read1_batch),\n self.linesep.join(self.read2_batch))\n self.writer(self.linesep, self.linesep)\n self.index = 0","def flushBuffer():\n\tif settings.dry_run or settings.force_sync == True:\n\t\treturn\n\tif settings.debug:\n\t\tsettings._counters['flush'] += 1\n\t\n\tsendData('NOOP', read=True, flush=True)","def __flush(self) -> None:\n assert not self.__closed\n assert self.__batch is not None, \"cannot flush without active batch\"\n\n logger.info(\n \"Flushing %s items (from %r)\",\n len(self.__batch.results),\n self.__batch.offsets,\n )\n\n self.__metrics.timing(\n \"process_message.normalized\",\n self.__batch.processing_time_ms / self.__batch.messages_processed_count,\n )\n\n batch_results_length = len(self.__batch.results)\n if batch_results_length > 0:\n logger.debug(\"Flushing batch via worker\")\n flush_start = time.time()\n self.__worker.flush_batch(self.__batch.results)\n flush_duration = (time.time() - flush_start) * 1000\n logger.info(\"Worker flush took %dms\", flush_duration)\n self.__metrics.timing(\"batch.flush\", flush_duration)\n self.__metrics.timing(\n \"batch.flush.normalized\", flush_duration / batch_results_length\n )\n\n logger.debug(\"Committing offsets for batch\")\n commit_start = time.time()\n offsets = {\n partition: offsets.hi for partition, offsets in self.__batch.offsets.items()\n }\n self.__commit(offsets)\n logger.debug(\"Committed offsets: %s\", offsets)\n commit_duration = (time.time() - commit_start) * 1000\n logger.debug(\"Offset commit took %dms\", commit_duration)\n\n self.__batch = None","def _flush_buffer(self):\n pass","def _flush_batch(self) -> None:\n batch_len = len(self._current_batch)\n if batch_len == 0:\n self.logger.debug('Nothing to flush.')\n return\n\n self.logger.debug(f'Flushing batch size {batch_len}')\n\n with self.LOCK:\n to_process_batch = list(self._current_batch)\n self._current_batch = list()\n\n log_event = EventFactory.create_log_event(to_process_batch, self.logger)\n\n self.notification_center.send_notifications(enums.NotificationTypes.LOG_EVENT, log_event)\n\n if log_event is None:\n self.logger.exception('Error dispatching event: Cannot dispatch None event.')\n return\n\n try:\n self.event_dispatcher.dispatch_event(log_event)\n except Exception as e:\n self.logger.error(f'Error dispatching event: {log_event} {e}')","def flushWrites(self):\n #log.debug(\"flushWrites(): Acquiring update lock.\")\n self.__update_lock.acquire()\n #log.debug(\"flushWrites() has update lock.\")\n if self.__writes_since_flush > 0:\n #log.debug(\"flushWrites(): Acquiring file locks.\")\n for fileLock in self.__node_locks.values():\n fileLock.acquire()\n log.debug(\"flushWrites(): Flushing write buffers\")\n for nodeid in self.__node_fds.keys():\n nodefd = self.__node_fds[nodeid]\n while len(self.__write_buf[nodeid]) > 0:\n writeStr = self.__write_buf[nodeid].pop(0)\n os.write(nodefd, writeStr)\n self.__writes_since_flush = 0\n #log.debug(\"flushWrites(): Releasing file locks.\")\n for fileLock in self.__node_locks.values():\n fileLock.release()\n #log.debug(\"flushWrites(): Releasing update lock.\")\n self.__update_lock.release()\n #log.debug(\"flushWrites() releases update lock.\") ","def flush(self):\n if not self.is_flushing:\n self.is_flushing = True\n self.flush_impl()\n self.is_flushing = False","def _flush(self):\n pass","def flush():\n None","def _flush(self):","def _buffer_flush(self, event):\n self._out_buffer_lock.acquire()\n _out_buffer = self._out_buffer\n self._out_buffer = []\n self._out_buffer_lock.release()\n self.write(''.join(_out_buffer), refresh=False)","def flush(self):\n if self._writable:\n with self._seek_lock:\n self._flush_raw_or_buffered()\n self._write_buffer = bytearray(self._buffer_size)\n self._buffer_seek = 0","def flush_buffers(self):\n\n for file_dictionary in [self.infiles, self.outfiles]:\n for name, fi in file_dictionary.items():\n fi.flush_buffers()","def flush_buffer(self):\n if self._pipeline:\n self._pipeline.execute()","def flush(self):\n data = self._wbuf.getvalue()\n if data:\n self._write(data)\n self._len = 0\n self._wbuf = BytesIO()","def flush(self):\n self._write()","def flush_tx_buffer(self):\n pass","def flush(self, data):","def _flush_queue():\n try:\n # Multiple queue flushes may be scheduled simultaneously on different threads\n # (e.g., if the queue is at its flush threshold and several more items\n # are added before a flush occurs). For correctness and efficiency, only one such\n # flush operation should proceed; all others are redundant and should be dropped\n acquired_lock = _metric_queue_lock.acquire(blocking=False)\n if acquired_lock:\n client = mlflow.tracking.MlflowClient()\n # For thread safety and to avoid modifying a list while iterating over it, we record a\n # separate list of the items being flushed and remove each one from the metric queue,\n # rather than clearing the metric queue or reassigning it (clearing / reassigning is\n # dangerous because we don't block threads from adding to the queue while a flush is\n # in progress)\n snapshot = _metric_queue[:]\n for item in snapshot:\n _metric_queue.remove(item)\n\n metrics_by_run = _assoc_list_to_map(snapshot)\n for run_id, metrics in metrics_by_run.items():\n client.log_batch(run_id, metrics=metrics, params=[], tags=[])\n finally:\n if acquired_lock:\n _metric_queue_lock.release()","def flush(self):\n pass","def flush(self):\n pass","def flush(self):\n pass","def flush(self):\n pass","def flush_batch(self, batch: Sequence[TResult]) -> None:\n pass","def _flush(self):\n for x in xrange(0,10):\n self._eng.iterate()","def flush(self):\n pass","def flush(self):\n raise NotImplementedError","def flush(self):\n self.acquire()\n try:\n if self.buffer:\n self.client.insertall(self.mapLogRecord(k) for k in self.buffer)\n self.buffer = []\n except Exception as e:\n pass\n finally:\n self.release()","def _filesync_flush(self, adb_info, filesync_info):\n # Send the buffer\n msg = AdbMessage(constants.WRTE, adb_info.local_id, adb_info.remote_id, filesync_info.send_buffer[:filesync_info.send_idx])\n self._io_manager.send(msg, adb_info)\n\n # Expect an 'OKAY' in response\n self._read_until([constants.OKAY], adb_info)\n\n # Reset the send index\n filesync_info.send_idx = 0","def flush_impl(self):\n pass","def flush(self) -> None:\n pass","def flush(self):\n for row in range(self.height):\n self.send_row(row)\n self.nframes += 1","def flush(self, mode=None):\r\n pass","def flush_buffer(output_fp, unique_align_buffer):\n \n\n return None","def _flush(self):\n tempbuf = self.databuffer\n self.databuffer = []\n self.database.runInteraction(self._executemany, tempbuf)","def _flush_write_buffer(self):\n if self._buffer_file_size:\n self._write_counter += 1\n self.file.seek(0)\n self._multipart.upload_part_from_file(\n self.file,\n self._write_counter,\n headers=self._storage.headers\n )\n self.file.close()\n self.file = None","def flush(self) -> None:\n raise NotImplementedError","def flush(self):\n for key in self.grouping_info.keys():\n if self._should_flush(key):\n self._write_current_buffer_for_group_key(key)","def flush(self):\n return","def flush_record(self):\n self.__mux.acquire()\n try:\n if self.datatype == 'csv':\n self.__csv_flush_record()\n elif self.datatype == 'json':\n self.__json_flush_record()\n elif self.datatype == 'all':\n self.__csv_flush_record(all=True)\n self.__json_flush_record(all=True)\n except Exception as e:\n log.debug(\"data_writer: Failed to flush queue: {0}: {1}\".format(str(e), [traceback.format_exc()]))\n finally:\n try:\n if sys.version_info[0] < 3:\n del self.__queue[:]\n else:\n self.__queue.clear()\n except Exception as e:\n log.error(\"data_writer: Failed to clear datawriter queue: {0}\".format(str(e)))\n self.__mux.release()","def flush(self):\n self._send()","def _flush_raw_or_buffered(self):\n # Flush only if bytes written\n # This avoids no required process/thread creation and network call.\n # This step is performed by raw stream.\n if self._buffer_seek and self._seek:\n self._seek += 1\n with handle_os_exceptions():\n self._flush()\n\n # If data lower than buffer size, flush data with raw stream to reduce IO calls\n elif self._buffer_seek:\n self._raw._write_buffer = self._get_buffer()\n self._raw._seek = self._buffer_seek\n self._raw.flush()","def sync(self):\n LOG.debug('Flushing file system buffers')\n try:\n utils.execute('sync')\n except processutils.ProcessExecutionError as e:\n error_msg = 'Flushing file system buffers failed. Error: %s' % e\n LOG.error(error_msg)\n raise errors.CommandExecutionError(error_msg)","def flush(*z: Any) -> None:\n for zi in z:\n if hasattr(zi, \"flush\"):\n zi.flush()","def _Flush(self):\n self._ignore_width = False\n if self._fill:\n self._out.write('\\n')\n self._blank = False\n self._fill = 0","def _flush(self):\r\n\r\n fh = open(self.filename, \"a\")\r\n fh.write(\"\".join(self.buffer))\r\n fh.close()\r\n\r\n self.buffer = []","def flush_buffers(self):\n if self.format == 'ENVI':\n if self.write:\n for row, frame in self.frames.items():\n valid = s.logical_not(s.isnan(frame[:, 0]))\n if self.file.metadata['interleave'] == 'bil':\n self.memmap[row, :, valid] = frame[valid, :].T\n else:\n self.memmap[row, valid, :] = frame[valid, :]\n self.frames = OrderedDict()\n del self.file\n self.file = envi.open(self.fname+'.hdr', self.fname)\n self.open_map_with_retries()","def flush():\n for (i, f) in enumerate(flushers):\n try:\n f()\n except Exception, e:\n log.exception('Uncaught exception in flusher #%s (%s):', i, f)","def flush(self):\n self._scalar_request_sender.flush()\n self._tensor_request_sender.flush()\n self._blob_request_sender.flush()","def flush_and_dispose(self):\n yield self.flush()\n self.dispose()","def flush(self):\n # Flushing a closed EventFileWriterV2 raises an exception. It is,\n # however, a noop for EventFileWriter.\n self._warn_if_event_writer_is_closed()\n self.event_writer.flush()","def _write_and_flush(self, data):\n try:\n self.stdout.write(data)\n self.stdout.flush()\n except IOError as e:\n if e.args and e.args[0] == errno.EINTR:\n # Interrupted system call. Can happpen in case of a window\n # resize signal. (Just ignore. The resize handler will render\n # again anyway.)\n pass\n else:\n raise","def _write(self, chunk):\n if self.consumer and not self.stop_event.is_set():\n self.consumer.write(chunk)","def trace_flush(self):\n cmd = enums.JLinkTraceCommand.FLUSH\n res = self._dll.JLINKARM_TRACE_Control(cmd, 0)\n if (res == 1):\n raise errors.JLinkException('Failed to flush the trace buffer.')\n return None","def flush(self, write=True): \n \n for filePath, (_strLen,fileBuffer) in self.filePathDict.items(): \n if write: \n self.__writeToFile(filePath, fileBuffer) \n del fileBuffer[:]","def flush(self):\n for stream in self.streams:\n stream.flush()","async def flush(self):\n\t\tpass","def flush_stores(self, flush_op):\n for st in self._ops_list:\n if flush_op.is_in_flush(st):\n st.flushed = True","def _write_terminator(self,):\n #It is critical that this function blocks and write the outstanding\n #records to the disc, as without that the whole protocol comes unstuck\n\n self.fd.write(b\"\\0\")\n self.fd.flush()\n self.fd.seek(-1,1)\n fdatasync(self.fd.fileno())","def flush(self):\n self._pending_flush = False\n\n if self.handler is None or not self.handler.active or not self.send_queue:\n return\n\n self.handler.send_pack('a[%s]' % self.send_queue)\n self.send_queue = ''","def flush(self):\n for fp in self.files:\n fp.flush()\n if isinstance(fp, int) or hasattr(fp, \"fileno\"):\n try:\n os.fsync(fp)\n except OSError:\n pass","def flush(self):\n self._stream.flush()","def flush(self, mask: BufferOperation) -> StatusCode:\n if mask & BufferOperation.discard_read_buffer:\n self.interface.reset_input_buffer()\n if (\n mask & BufferOperation.flush_write_buffer\n or mask & BufferOperation.flush_transmit_buffer\n ):\n self.interface.flush()\n if (\n mask & BufferOperation.discard_write_buffer\n or mask & BufferOperation.discard_transmit_buffer\n ):\n self.interface.reset_output_buffer()\n\n return StatusCode.success","def flush(self):\n \n # Buffer management\n # If data buffer not empty, send a set of values\n if self._data_buffer != []:\n time, data = self._data_buffer[0]\n self._log.debug(\"Server \" + \n self._settings['domain'] + self._settings['path'] + \n \" -> send data: \" + str(data) + \n \", timestamp: \" + str(time))\n if self._send_data(data, time):\n # In case of success, delete sample set from buffer\n del self._data_buffer[0]\n # If buffer size reaches maximum, trash oldest values\n # TODO: optionnal write to file instead of losing data\n size = len(self._data_buffer)\n if size > 1000:\n self._data_buffer = self._data_buffer[size - 1000:]","def write_batch(self, batch):\n for item in batch:\n self.write_buffer.buffer(item)\n key = self.write_buffer.get_key_from_item(item)\n if self.write_buffer.should_write_buffer(key):\n self._write_current_buffer_for_group_key(key)\n self.increment_written_items()\n self._check_items_limit()","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\n with self:\n _gl.glFlush()","def flush(self):\n if self.access != AccessMode.WRITE:\n raise ValueError(\"Flush attempted on dataset opened in READ mode.\")\n\n # TODO futures and performance stats\n self.client.flush()","def flush(self):\n self.f.flush()","def flush(self):\n \n # Check buffer is active\n if self._settings['active'] == 'False':\n return\n \n # Check sending period\n if (time.time() - self._last_send < int(self._settings['period'])):\n return\n \n # If data buffer not empty, send data\n if self._data_buffer != []:\n self._log.debug(\"Server \" + self._settings['domain'] + \n self._settings['path'] + \" -> flush buffer\")\n \n self._send_data()\n \n # Update time of last data sending\n self._last_send = time.time()\n \n # If buffer size reaches maximum, trash oldest values\n # TODO: optionnal write to file instead of losing data\n MAX_DATA_SETS_IN_BUFFER = 1000\n size = len(self._data_buffer)\n if size > MAX_DATA_SETS_IN_BUFFER:\n self._data_buffer = \\\n self._data_buffer[size - MAX_DATA_SETS_IN_BUFFER:]","def __flush(self):\n self.session.buffer=''\n self.session.before=''","def write(self, batch):\n time.sleep(self.WRITE_DELAY)","def flushMsgs(self):\n\n self.queue = self.pre_queue[:]\n self.pre_queue = []","def flush(self):\r\n # this flush method is needed for python 3 compatibility.\r\n # this handles the flush command by doing nothing.\r\n pass","def finalize(self):\r\n\r\n self._flush()\r\n self.context.close()","def flush(self):\n for card in self.cards:\n card.connection.waveformFlush()\n for chan in range(card.channels):\n card.connection.AWGflush(chan)\n card.connection.AWGstop(chan)\n card.connection.channelWaveShape(chan+1, sd1.SD_Waveshapes.AOU_AWG)","def flush(self) -> None:\n\n self.event_queue.put(self._FLUSH_SIGNAL)","def flush(*args):\n return _libsbml.flush(*args)","def flush(self, objects: Optional[Sequence[Any]] = None) -> None:\n\n if self._flushing:\n raise sa_exc.InvalidRequestError(\"Session is already flushing\")\n\n if self._is_clean():\n return\n try:\n self._flushing = True\n self._flush(objects)\n finally:\n self._flushing = False","def set_flush(self, val):\n self.flushing.value = val","def tlbflush(self, tlbflush):\n\n self._tlbflush = tlbflush","def kafka_commit(self):\n self.kf_producer.flush()","def on_process_exit(self):\n if self.flush_thread:\n self.flush_thread.cancel()\n self.flush_buffer()","def _export(self, flush_request: typing.Optional[_FlushRequest]):\n if not flush_request:\n self._export_batch()\n return\n\n num_spans = flush_request.num_spans\n while self.queue:\n num_exported = self._export_batch()\n num_spans -= num_exported\n\n if num_spans <= 0:\n break","def _flush():\n libtcod.console_flush()","def flush(self):\n if self.serial:\n self.serial.flush()","def flush(self):\n self.old_stdout.flush()","def Flush(self, writer=None):\n if not writer:\n writer = _WriteFile\n for file in sorted(self._filename_to_emitter.keys()):\n emitter = self._filename_to_emitter[file]\n writer(file, emitter.Fragments())","def flush(self):\n\n for handler in self.handlers:\n handler.flush()","def flush(self):\n\n self.nclauses = self.nclauses - len(self.aux_clauses)\n self.aux_clauses = []","def redis_flush(self):\n def func(server):\n return server.server.flushall()\n self.__run_redis_cmd(func)","def flush(self) -> None:\n if self.producer is not None:\n self.producer.flush()","def flush(self) -> None:\n super().put(self.buffer)\n self.buffer = np.ndarray((0, 1), dtype=np.int16)","def _flush(self):\n self._d = {}"],"string":"[\n \"def flush( finishing=False, callback=None ):\",\n \"def flush(self):\\n if self.index < self.bufsize:\\n self.writer(\\n self.linesep.join(self.read1_batch[0:self.index]),\\n self.linesep.join(self.read2_batch[0:self.index]))\\n else:\\n self.writer(\\n self.linesep.join(self.read1_batch),\\n self.linesep.join(self.read2_batch))\\n self.writer(self.linesep, self.linesep)\\n self.index = 0\",\n \"def flushBuffer():\\n\\tif settings.dry_run or settings.force_sync == True:\\n\\t\\treturn\\n\\tif settings.debug:\\n\\t\\tsettings._counters['flush'] += 1\\n\\t\\n\\tsendData('NOOP', read=True, flush=True)\",\n \"def __flush(self) -> None:\\n assert not self.__closed\\n assert self.__batch is not None, \\\"cannot flush without active batch\\\"\\n\\n logger.info(\\n \\\"Flushing %s items (from %r)\\\",\\n len(self.__batch.results),\\n self.__batch.offsets,\\n )\\n\\n self.__metrics.timing(\\n \\\"process_message.normalized\\\",\\n self.__batch.processing_time_ms / self.__batch.messages_processed_count,\\n )\\n\\n batch_results_length = len(self.__batch.results)\\n if batch_results_length > 0:\\n logger.debug(\\\"Flushing batch via worker\\\")\\n flush_start = time.time()\\n self.__worker.flush_batch(self.__batch.results)\\n flush_duration = (time.time() - flush_start) * 1000\\n logger.info(\\\"Worker flush took %dms\\\", flush_duration)\\n self.__metrics.timing(\\\"batch.flush\\\", flush_duration)\\n self.__metrics.timing(\\n \\\"batch.flush.normalized\\\", flush_duration / batch_results_length\\n )\\n\\n logger.debug(\\\"Committing offsets for batch\\\")\\n commit_start = time.time()\\n offsets = {\\n partition: offsets.hi for partition, offsets in self.__batch.offsets.items()\\n }\\n self.__commit(offsets)\\n logger.debug(\\\"Committed offsets: %s\\\", offsets)\\n commit_duration = (time.time() - commit_start) * 1000\\n logger.debug(\\\"Offset commit took %dms\\\", commit_duration)\\n\\n self.__batch = None\",\n \"def _flush_buffer(self):\\n pass\",\n \"def _flush_batch(self) -> None:\\n batch_len = len(self._current_batch)\\n if batch_len == 0:\\n self.logger.debug('Nothing to flush.')\\n return\\n\\n self.logger.debug(f'Flushing batch size {batch_len}')\\n\\n with self.LOCK:\\n to_process_batch = list(self._current_batch)\\n self._current_batch = list()\\n\\n log_event = EventFactory.create_log_event(to_process_batch, self.logger)\\n\\n self.notification_center.send_notifications(enums.NotificationTypes.LOG_EVENT, log_event)\\n\\n if log_event is None:\\n self.logger.exception('Error dispatching event: Cannot dispatch None event.')\\n return\\n\\n try:\\n self.event_dispatcher.dispatch_event(log_event)\\n except Exception as e:\\n self.logger.error(f'Error dispatching event: {log_event} {e}')\",\n \"def flushWrites(self):\\n #log.debug(\\\"flushWrites(): Acquiring update lock.\\\")\\n self.__update_lock.acquire()\\n #log.debug(\\\"flushWrites() has update lock.\\\")\\n if self.__writes_since_flush > 0:\\n #log.debug(\\\"flushWrites(): Acquiring file locks.\\\")\\n for fileLock in self.__node_locks.values():\\n fileLock.acquire()\\n log.debug(\\\"flushWrites(): Flushing write buffers\\\")\\n for nodeid in self.__node_fds.keys():\\n nodefd = self.__node_fds[nodeid]\\n while len(self.__write_buf[nodeid]) > 0:\\n writeStr = self.__write_buf[nodeid].pop(0)\\n os.write(nodefd, writeStr)\\n self.__writes_since_flush = 0\\n #log.debug(\\\"flushWrites(): Releasing file locks.\\\")\\n for fileLock in self.__node_locks.values():\\n fileLock.release()\\n #log.debug(\\\"flushWrites(): Releasing update lock.\\\")\\n self.__update_lock.release()\\n #log.debug(\\\"flushWrites() releases update lock.\\\") \",\n \"def flush(self):\\n if not self.is_flushing:\\n self.is_flushing = True\\n self.flush_impl()\\n self.is_flushing = False\",\n \"def _flush(self):\\n pass\",\n \"def flush():\\n None\",\n \"def _flush(self):\",\n \"def _buffer_flush(self, event):\\n self._out_buffer_lock.acquire()\\n _out_buffer = self._out_buffer\\n self._out_buffer = []\\n self._out_buffer_lock.release()\\n self.write(''.join(_out_buffer), refresh=False)\",\n \"def flush(self):\\n if self._writable:\\n with self._seek_lock:\\n self._flush_raw_or_buffered()\\n self._write_buffer = bytearray(self._buffer_size)\\n self._buffer_seek = 0\",\n \"def flush_buffers(self):\\n\\n for file_dictionary in [self.infiles, self.outfiles]:\\n for name, fi in file_dictionary.items():\\n fi.flush_buffers()\",\n \"def flush_buffer(self):\\n if self._pipeline:\\n self._pipeline.execute()\",\n \"def flush(self):\\n data = self._wbuf.getvalue()\\n if data:\\n self._write(data)\\n self._len = 0\\n self._wbuf = BytesIO()\",\n \"def flush(self):\\n self._write()\",\n \"def flush_tx_buffer(self):\\n pass\",\n \"def flush(self, data):\",\n \"def _flush_queue():\\n try:\\n # Multiple queue flushes may be scheduled simultaneously on different threads\\n # (e.g., if the queue is at its flush threshold and several more items\\n # are added before a flush occurs). For correctness and efficiency, only one such\\n # flush operation should proceed; all others are redundant and should be dropped\\n acquired_lock = _metric_queue_lock.acquire(blocking=False)\\n if acquired_lock:\\n client = mlflow.tracking.MlflowClient()\\n # For thread safety and to avoid modifying a list while iterating over it, we record a\\n # separate list of the items being flushed and remove each one from the metric queue,\\n # rather than clearing the metric queue or reassigning it (clearing / reassigning is\\n # dangerous because we don't block threads from adding to the queue while a flush is\\n # in progress)\\n snapshot = _metric_queue[:]\\n for item in snapshot:\\n _metric_queue.remove(item)\\n\\n metrics_by_run = _assoc_list_to_map(snapshot)\\n for run_id, metrics in metrics_by_run.items():\\n client.log_batch(run_id, metrics=metrics, params=[], tags=[])\\n finally:\\n if acquired_lock:\\n _metric_queue_lock.release()\",\n \"def flush(self):\\n pass\",\n \"def flush(self):\\n pass\",\n \"def flush(self):\\n pass\",\n \"def flush(self):\\n pass\",\n \"def flush_batch(self, batch: Sequence[TResult]) -> None:\\n pass\",\n \"def _flush(self):\\n for x in xrange(0,10):\\n self._eng.iterate()\",\n \"def flush(self):\\n pass\",\n \"def flush(self):\\n raise NotImplementedError\",\n \"def flush(self):\\n self.acquire()\\n try:\\n if self.buffer:\\n self.client.insertall(self.mapLogRecord(k) for k in self.buffer)\\n self.buffer = []\\n except Exception as e:\\n pass\\n finally:\\n self.release()\",\n \"def _filesync_flush(self, adb_info, filesync_info):\\n # Send the buffer\\n msg = AdbMessage(constants.WRTE, adb_info.local_id, adb_info.remote_id, filesync_info.send_buffer[:filesync_info.send_idx])\\n self._io_manager.send(msg, adb_info)\\n\\n # Expect an 'OKAY' in response\\n self._read_until([constants.OKAY], adb_info)\\n\\n # Reset the send index\\n filesync_info.send_idx = 0\",\n \"def flush_impl(self):\\n pass\",\n \"def flush(self) -> None:\\n pass\",\n \"def flush(self):\\n for row in range(self.height):\\n self.send_row(row)\\n self.nframes += 1\",\n \"def flush(self, mode=None):\\r\\n pass\",\n \"def flush_buffer(output_fp, unique_align_buffer):\\n \\n\\n return None\",\n \"def _flush(self):\\n tempbuf = self.databuffer\\n self.databuffer = []\\n self.database.runInteraction(self._executemany, tempbuf)\",\n \"def _flush_write_buffer(self):\\n if self._buffer_file_size:\\n self._write_counter += 1\\n self.file.seek(0)\\n self._multipart.upload_part_from_file(\\n self.file,\\n self._write_counter,\\n headers=self._storage.headers\\n )\\n self.file.close()\\n self.file = None\",\n \"def flush(self) -> None:\\n raise NotImplementedError\",\n \"def flush(self):\\n for key in self.grouping_info.keys():\\n if self._should_flush(key):\\n self._write_current_buffer_for_group_key(key)\",\n \"def flush(self):\\n return\",\n \"def flush_record(self):\\n self.__mux.acquire()\\n try:\\n if self.datatype == 'csv':\\n self.__csv_flush_record()\\n elif self.datatype == 'json':\\n self.__json_flush_record()\\n elif self.datatype == 'all':\\n self.__csv_flush_record(all=True)\\n self.__json_flush_record(all=True)\\n except Exception as e:\\n log.debug(\\\"data_writer: Failed to flush queue: {0}: {1}\\\".format(str(e), [traceback.format_exc()]))\\n finally:\\n try:\\n if sys.version_info[0] < 3:\\n del self.__queue[:]\\n else:\\n self.__queue.clear()\\n except Exception as e:\\n log.error(\\\"data_writer: Failed to clear datawriter queue: {0}\\\".format(str(e)))\\n self.__mux.release()\",\n \"def flush(self):\\n self._send()\",\n \"def _flush_raw_or_buffered(self):\\n # Flush only if bytes written\\n # This avoids no required process/thread creation and network call.\\n # This step is performed by raw stream.\\n if self._buffer_seek and self._seek:\\n self._seek += 1\\n with handle_os_exceptions():\\n self._flush()\\n\\n # If data lower than buffer size, flush data with raw stream to reduce IO calls\\n elif self._buffer_seek:\\n self._raw._write_buffer = self._get_buffer()\\n self._raw._seek = self._buffer_seek\\n self._raw.flush()\",\n \"def sync(self):\\n LOG.debug('Flushing file system buffers')\\n try:\\n utils.execute('sync')\\n except processutils.ProcessExecutionError as e:\\n error_msg = 'Flushing file system buffers failed. Error: %s' % e\\n LOG.error(error_msg)\\n raise errors.CommandExecutionError(error_msg)\",\n \"def flush(*z: Any) -> None:\\n for zi in z:\\n if hasattr(zi, \\\"flush\\\"):\\n zi.flush()\",\n \"def _Flush(self):\\n self._ignore_width = False\\n if self._fill:\\n self._out.write('\\\\n')\\n self._blank = False\\n self._fill = 0\",\n \"def _flush(self):\\r\\n\\r\\n fh = open(self.filename, \\\"a\\\")\\r\\n fh.write(\\\"\\\".join(self.buffer))\\r\\n fh.close()\\r\\n\\r\\n self.buffer = []\",\n \"def flush_buffers(self):\\n if self.format == 'ENVI':\\n if self.write:\\n for row, frame in self.frames.items():\\n valid = s.logical_not(s.isnan(frame[:, 0]))\\n if self.file.metadata['interleave'] == 'bil':\\n self.memmap[row, :, valid] = frame[valid, :].T\\n else:\\n self.memmap[row, valid, :] = frame[valid, :]\\n self.frames = OrderedDict()\\n del self.file\\n self.file = envi.open(self.fname+'.hdr', self.fname)\\n self.open_map_with_retries()\",\n \"def flush():\\n for (i, f) in enumerate(flushers):\\n try:\\n f()\\n except Exception, e:\\n log.exception('Uncaught exception in flusher #%s (%s):', i, f)\",\n \"def flush(self):\\n self._scalar_request_sender.flush()\\n self._tensor_request_sender.flush()\\n self._blob_request_sender.flush()\",\n \"def flush_and_dispose(self):\\n yield self.flush()\\n self.dispose()\",\n \"def flush(self):\\n # Flushing a closed EventFileWriterV2 raises an exception. It is,\\n # however, a noop for EventFileWriter.\\n self._warn_if_event_writer_is_closed()\\n self.event_writer.flush()\",\n \"def _write_and_flush(self, data):\\n try:\\n self.stdout.write(data)\\n self.stdout.flush()\\n except IOError as e:\\n if e.args and e.args[0] == errno.EINTR:\\n # Interrupted system call. Can happpen in case of a window\\n # resize signal. (Just ignore. The resize handler will render\\n # again anyway.)\\n pass\\n else:\\n raise\",\n \"def _write(self, chunk):\\n if self.consumer and not self.stop_event.is_set():\\n self.consumer.write(chunk)\",\n \"def trace_flush(self):\\n cmd = enums.JLinkTraceCommand.FLUSH\\n res = self._dll.JLINKARM_TRACE_Control(cmd, 0)\\n if (res == 1):\\n raise errors.JLinkException('Failed to flush the trace buffer.')\\n return None\",\n \"def flush(self, write=True): \\n \\n for filePath, (_strLen,fileBuffer) in self.filePathDict.items(): \\n if write: \\n self.__writeToFile(filePath, fileBuffer) \\n del fileBuffer[:]\",\n \"def flush(self):\\n for stream in self.streams:\\n stream.flush()\",\n \"async def flush(self):\\n\\t\\tpass\",\n \"def flush_stores(self, flush_op):\\n for st in self._ops_list:\\n if flush_op.is_in_flush(st):\\n st.flushed = True\",\n \"def _write_terminator(self,):\\n #It is critical that this function blocks and write the outstanding\\n #records to the disc, as without that the whole protocol comes unstuck\\n\\n self.fd.write(b\\\"\\\\0\\\")\\n self.fd.flush()\\n self.fd.seek(-1,1)\\n fdatasync(self.fd.fileno())\",\n \"def flush(self):\\n self._pending_flush = False\\n\\n if self.handler is None or not self.handler.active or not self.send_queue:\\n return\\n\\n self.handler.send_pack('a[%s]' % self.send_queue)\\n self.send_queue = ''\",\n \"def flush(self):\\n for fp in self.files:\\n fp.flush()\\n if isinstance(fp, int) or hasattr(fp, \\\"fileno\\\"):\\n try:\\n os.fsync(fp)\\n except OSError:\\n pass\",\n \"def flush(self):\\n self._stream.flush()\",\n \"def flush(self, mask: BufferOperation) -> StatusCode:\\n if mask & BufferOperation.discard_read_buffer:\\n self.interface.reset_input_buffer()\\n if (\\n mask & BufferOperation.flush_write_buffer\\n or mask & BufferOperation.flush_transmit_buffer\\n ):\\n self.interface.flush()\\n if (\\n mask & BufferOperation.discard_write_buffer\\n or mask & BufferOperation.discard_transmit_buffer\\n ):\\n self.interface.reset_output_buffer()\\n\\n return StatusCode.success\",\n \"def flush(self):\\n \\n # Buffer management\\n # If data buffer not empty, send a set of values\\n if self._data_buffer != []:\\n time, data = self._data_buffer[0]\\n self._log.debug(\\\"Server \\\" + \\n self._settings['domain'] + self._settings['path'] + \\n \\\" -> send data: \\\" + str(data) + \\n \\\", timestamp: \\\" + str(time))\\n if self._send_data(data, time):\\n # In case of success, delete sample set from buffer\\n del self._data_buffer[0]\\n # If buffer size reaches maximum, trash oldest values\\n # TODO: optionnal write to file instead of losing data\\n size = len(self._data_buffer)\\n if size > 1000:\\n self._data_buffer = self._data_buffer[size - 1000:]\",\n \"def write_batch(self, batch):\\n for item in batch:\\n self.write_buffer.buffer(item)\\n key = self.write_buffer.get_key_from_item(item)\\n if self.write_buffer.should_write_buffer(key):\\n self._write_current_buffer_for_group_key(key)\\n self.increment_written_items()\\n self._check_items_limit()\",\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\\n with self:\\n _gl.glFlush()\",\n \"def flush(self):\\n if self.access != AccessMode.WRITE:\\n raise ValueError(\\\"Flush attempted on dataset opened in READ mode.\\\")\\n\\n # TODO futures and performance stats\\n self.client.flush()\",\n \"def flush(self):\\n self.f.flush()\",\n \"def flush(self):\\n \\n # Check buffer is active\\n if self._settings['active'] == 'False':\\n return\\n \\n # Check sending period\\n if (time.time() - self._last_send < int(self._settings['period'])):\\n return\\n \\n # If data buffer not empty, send data\\n if self._data_buffer != []:\\n self._log.debug(\\\"Server \\\" + self._settings['domain'] + \\n self._settings['path'] + \\\" -> flush buffer\\\")\\n \\n self._send_data()\\n \\n # Update time of last data sending\\n self._last_send = time.time()\\n \\n # If buffer size reaches maximum, trash oldest values\\n # TODO: optionnal write to file instead of losing data\\n MAX_DATA_SETS_IN_BUFFER = 1000\\n size = len(self._data_buffer)\\n if size > MAX_DATA_SETS_IN_BUFFER:\\n self._data_buffer = \\\\\\n self._data_buffer[size - MAX_DATA_SETS_IN_BUFFER:]\",\n \"def __flush(self):\\n self.session.buffer=''\\n self.session.before=''\",\n \"def write(self, batch):\\n time.sleep(self.WRITE_DELAY)\",\n \"def flushMsgs(self):\\n\\n self.queue = self.pre_queue[:]\\n self.pre_queue = []\",\n \"def flush(self):\\r\\n # this flush method is needed for python 3 compatibility.\\r\\n # this handles the flush command by doing nothing.\\r\\n pass\",\n \"def finalize(self):\\r\\n\\r\\n self._flush()\\r\\n self.context.close()\",\n \"def flush(self):\\n for card in self.cards:\\n card.connection.waveformFlush()\\n for chan in range(card.channels):\\n card.connection.AWGflush(chan)\\n card.connection.AWGstop(chan)\\n card.connection.channelWaveShape(chan+1, sd1.SD_Waveshapes.AOU_AWG)\",\n \"def flush(self) -> None:\\n\\n self.event_queue.put(self._FLUSH_SIGNAL)\",\n \"def flush(*args):\\n return _libsbml.flush(*args)\",\n \"def flush(self, objects: Optional[Sequence[Any]] = None) -> None:\\n\\n if self._flushing:\\n raise sa_exc.InvalidRequestError(\\\"Session is already flushing\\\")\\n\\n if self._is_clean():\\n return\\n try:\\n self._flushing = True\\n self._flush(objects)\\n finally:\\n self._flushing = False\",\n \"def set_flush(self, val):\\n self.flushing.value = val\",\n \"def tlbflush(self, tlbflush):\\n\\n self._tlbflush = tlbflush\",\n \"def kafka_commit(self):\\n self.kf_producer.flush()\",\n \"def on_process_exit(self):\\n if self.flush_thread:\\n self.flush_thread.cancel()\\n self.flush_buffer()\",\n \"def _export(self, flush_request: typing.Optional[_FlushRequest]):\\n if not flush_request:\\n self._export_batch()\\n return\\n\\n num_spans = flush_request.num_spans\\n while self.queue:\\n num_exported = self._export_batch()\\n num_spans -= num_exported\\n\\n if num_spans <= 0:\\n break\",\n \"def _flush():\\n libtcod.console_flush()\",\n \"def flush(self):\\n if self.serial:\\n self.serial.flush()\",\n \"def flush(self):\\n self.old_stdout.flush()\",\n \"def Flush(self, writer=None):\\n if not writer:\\n writer = _WriteFile\\n for file in sorted(self._filename_to_emitter.keys()):\\n emitter = self._filename_to_emitter[file]\\n writer(file, emitter.Fragments())\",\n \"def flush(self):\\n\\n for handler in self.handlers:\\n handler.flush()\",\n \"def flush(self):\\n\\n self.nclauses = self.nclauses - len(self.aux_clauses)\\n self.aux_clauses = []\",\n \"def redis_flush(self):\\n def func(server):\\n return server.server.flushall()\\n self.__run_redis_cmd(func)\",\n \"def flush(self) -> None:\\n if self.producer is not None:\\n self.producer.flush()\",\n \"def flush(self) -> None:\\n super().put(self.buffer)\\n self.buffer = np.ndarray((0, 1), dtype=np.int16)\",\n \"def _flush(self):\\n self._d = {}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72197866","0.6825687","0.6762548","0.67556584","0.6626207","0.65444833","0.6481918","0.6443816","0.6437833","0.6389314","0.638791","0.6369492","0.6365876","0.63625133","0.6264878","0.6097336","0.60739243","0.60723567","0.6068778","0.60441273","0.60136825","0.60136825","0.60136825","0.60136825","0.6007551","0.5991972","0.5988481","0.5966298","0.59270686","0.59230685","0.5919391","0.5914971","0.590006","0.58657086","0.5865569","0.5865095","0.5849045","0.58289075","0.5820188","0.5802696","0.57880324","0.57825387","0.5775416","0.5774656","0.57710236","0.57576954","0.57487845","0.5736154","0.57234883","0.569261","0.5688591","0.5678867","0.5666986","0.56580454","0.5647687","0.5633066","0.56321716","0.56310296","0.56274647","0.56215227","0.56186926","0.5598681","0.5582454","0.5578835","0.5578539","0.5567882","0.5564705","0.556022","0.5558524","0.5552055","0.5550957","0.5533298","0.5526595","0.55223596","0.5512523","0.5507843","0.5506548","0.54987836","0.5474738","0.546555","0.5446732","0.5444919","0.5440368","0.5439885","0.5434725","0.5412615","0.5407788","0.5402859","0.5387046","0.5376582","0.53729683","0.5358957","0.534407","0.5334708","0.53266525"],"string":"[\n \"0.72197866\",\n \"0.6825687\",\n \"0.6762548\",\n \"0.67556584\",\n \"0.6626207\",\n \"0.65444833\",\n \"0.6481918\",\n \"0.6443816\",\n \"0.6437833\",\n \"0.6389314\",\n \"0.638791\",\n \"0.6369492\",\n \"0.6365876\",\n \"0.63625133\",\n \"0.6264878\",\n \"0.6097336\",\n \"0.60739243\",\n \"0.60723567\",\n \"0.6068778\",\n \"0.60441273\",\n \"0.60136825\",\n \"0.60136825\",\n \"0.60136825\",\n \"0.60136825\",\n \"0.6007551\",\n \"0.5991972\",\n \"0.5988481\",\n \"0.5966298\",\n \"0.59270686\",\n \"0.59230685\",\n \"0.5919391\",\n \"0.5914971\",\n \"0.590006\",\n \"0.58657086\",\n \"0.5865569\",\n \"0.5865095\",\n \"0.5849045\",\n \"0.58289075\",\n \"0.5820188\",\n \"0.5802696\",\n \"0.57880324\",\n \"0.57825387\",\n \"0.5775416\",\n \"0.5774656\",\n \"0.57710236\",\n \"0.57576954\",\n \"0.57487845\",\n \"0.5736154\",\n \"0.57234883\",\n \"0.569261\",\n \"0.5688591\",\n \"0.5678867\",\n \"0.5666986\",\n \"0.56580454\",\n \"0.5647687\",\n \"0.5633066\",\n \"0.56321716\",\n \"0.56310296\",\n \"0.56274647\",\n \"0.56215227\",\n \"0.56186926\",\n \"0.5598681\",\n \"0.5582454\",\n \"0.5578835\",\n \"0.5578539\",\n \"0.5567882\",\n \"0.5564705\",\n \"0.556022\",\n \"0.5558524\",\n \"0.5552055\",\n \"0.5550957\",\n \"0.5533298\",\n \"0.5526595\",\n \"0.55223596\",\n \"0.5512523\",\n \"0.5507843\",\n \"0.5506548\",\n \"0.54987836\",\n \"0.5474738\",\n \"0.546555\",\n \"0.5446732\",\n \"0.5444919\",\n \"0.5440368\",\n \"0.5439885\",\n \"0.5434725\",\n \"0.5412615\",\n \"0.5407788\",\n \"0.5402859\",\n \"0.5387046\",\n \"0.5376582\",\n \"0.53729683\",\n \"0.5358957\",\n \"0.534407\",\n \"0.5334708\",\n \"0.53266525\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5962441"},"document_rank":{"kind":"string","value":"32"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":891,"numItemsPerPage":100,"numTotalItems":95772,"offset":89100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTc5NzIxOCwianRpIjoiOGZlZmVlNTgtYzUyNy00OGMwLWEyZWMtYWY1YmUyNWUyYTdiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4MDA4MTgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.d7X19IoaWk_u0iRTWLX7j58kr_c0t6lZ9dTeWygAZ0v-_VIlfmT5BE0i1TH_Wsyx_pg3xx6BnHg-7_ZrSfXtAw","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 |
|---|---|---|---|---|---|---|
Quickly plot multiple images at once. each arr has to be a list of 2D or 3D images Example ======= x = np.ones((200,200)) plot_some([x],[x]) x = np.ones((5,200,200)) plot_some(x,x,x) | def plot_some(*arr, **kwargs):
title_list = kwargs.pop('title_list',None)
pmin = kwargs.pop('pmin',0)
pmax = kwargs.pop('pmax',100)
cmap = kwargs.pop('cmap','magma')
imshow_kwargs = kwargs
return _plot_some(arr=arr, title_list=title_list, pmin=pmin, pmax=pmax, cmap=cmap, **imshow_kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PlotImages(x):\r\n # 5.1 Create figure-window and axes\r\n _, ax = plt.subplots(nrows = 2, ncols= 3)\r\n # 5.2\r\n ax[0,0].imshow(x[0, :].reshape(75,75))\r\n ax[0,1].imshow(x[1, :].reshape(75,75))\r\n ax[0,2].imshow(x[2, :].reshape(75,75))\r\n ax[1,0].imshow(x[3, :].reshape(75,75))\r\n ... | [
"0.70711166",
"0.7066877",
"0.701081",
"0.6905507",
"0.68050313",
"0.6788474",
"0.6689471",
"0.6664214",
"0.6644253",
"0.66416115",
"0.6564791",
"0.6560931",
"0.6557468",
"0.65556717",
"0.6523524",
"0.6523524",
"0.6523524",
"0.6478707",
"0.6459929",
"0.6411923",
"0.64117026",... | 0.7205167 | 0 |
plots a matrix of images arr = [ X_1, X_2, ..., X_n] where each X_i is a list of images | def _plot_some(arr, title_list=None, pmin=0, pmax=100, cmap='magma', **imshow_kwargs):
import matplotlib.pyplot as plt
imshow_kwargs['cmap'] = cmap
def make_acceptable(a):
return np.asarray(a)
def color_image(a):
return np.stack(map(to_color,a)) if 1 < a.shape[-1] <= 3 else a
def ma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_n_image(X, n):\n pic_size = int(np.sqrt(X.shape[1]))\n grid_size = int(np.sqrt(n))\n\n first_n_images = X[:n, :]\n\n fig, ax_array = plt.subplots(nrows=grid_size, ncols=grid_size,sharey=True, sharex=True, figsize=(8, 8))\n\n for r in range(grid_size):\n for c in range(grid_size):\n ... | [
"0.7608688",
"0.7593615",
"0.72672635",
"0.7190524",
"0.7189609",
"0.71369797",
"0.7067448",
"0.7022683",
"0.6996279",
"0.6992667",
"0.6962755",
"0.690849",
"0.68871385",
"0.6861115",
"0.6765002",
"0.6743826",
"0.6743826",
"0.6743826",
"0.6743197",
"0.6733798",
"0.6728061",
... | 0.6642395 | 29 |
Converts a 2D or 3D stack to a colored image (maximal 3 channels). | def to_color(arr, pmin=1, pmax=99.8, gamma=1., colors=((0, 1, 0), (1, 0, 1), (0, 1, 1))):
if not arr.ndim in (2,3):
raise ValueError("only 2d or 3d arrays supported")
if arr.ndim ==2:
arr = arr[np.newaxis]
ind_min = np.argmin(arr.shape)
arr = np.moveaxis(arr, ind_min, 0).astype(np.floa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_3d(im_stack):\n im_stack /= 127.5\n im_stack -= 1.0\n return im_stack",
"def batch_rgb2gray(imstack):\n grayim = np.zeros((imstack.shape[0], imstack.shape[1], imstack.shape[2]), \"float32\")\n for i in range(grayim.shape[0]):\n grayim[i] = rgb2gray(imstack[i].astype(\"uint8\"... | [
"0.67036676",
"0.62252903",
"0.6009412",
"0.59640753",
"0.59429044",
"0.59268093",
"0.57883483",
"0.57472986",
"0.5678458",
"0.5621185",
"0.5615368",
"0.5583152",
"0.5572368",
"0.5548536",
"0.5517618",
"0.5498324",
"0.5489708",
"0.5468431",
"0.54646695",
"0.54549956",
"0.5444... | 0.0 | -1 |
Generate default DataKeepers for VarLoadSpeed workflow | def gen_datakeeper_list(self):
datakeeper_list = []
simu = self.parent
# Save speed
datakeeper_list.append(
DataKeeper(
name="Speed",
symbol="N0",
unit="rpm",
keeper="lambda output: output.elec.N0",
)
)
# Get default datakeeper
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_savers(self):\n with self.graph.as_default():\n #Loop through to find variables to ignore\n all_vars = tf.compat.v1.global_variables()\n load_vars = [v for v in all_vars if v not in self.full_model_load_ignore]\n self.full_saver = tf.compat.v1.train.Saver(max_to_keep=self.param... | [
"0.60901564",
"0.5736703",
"0.5667407",
"0.5600917",
"0.55990887",
"0.5540418",
"0.55107814",
"0.54961354",
"0.5494534",
"0.54596895",
"0.5437185",
"0.5413207",
"0.5400129",
"0.5386552",
"0.5373071",
"0.53684455",
"0.5367128",
"0.5360437",
"0.52821386",
"0.5277415",
"0.525839... | 0.5209084 | 28 |
On which days did more than 1% of requests lead to errors? | def daily_error_gt_1pct(db):
query = """
select day, round(error_pct,2) as error_pct
from ( select day,
( ( sum(occurance) filter(where status != '200 OK')
/ sum(occurance) ) * 100 ) as error_pct
from ( select to_char(time, 'Month DD, YYYY') as day,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def days_with_request():\n\n # To print information\n information_string = '3. Days with more than ' \\\n '1% of request that lead to an error:\\n'\n\n # Query string\n query = \"\"\"select * from (select date(time),\n round(100.0*sum(case log.status\n whe... | [
"0.74429655",
"0.73769623",
"0.70260245",
"0.70131814",
"0.69248164",
"0.6859821",
"0.68585485",
"0.6589264",
"0.6509256",
"0.64472634",
"0.6404929",
"0.6339969",
"0.63344014",
"0.62129766",
"0.61929214",
"0.61694694",
"0.60457176",
"0.59663457",
"0.5903446",
"0.5840939",
"0.... | 0.6823604 | 7 |
Initialise the QEMAdapter instance. This constructor initialises the adapter instance, extracting the appropriate configuration options passed in by the server, creating a InterfaceData object to interact with the sevrer and backplane handlers and starting a period update loop within the tornado IOLoop instance to hand... | def __init__(self, **kwargs):
# Initialise the superclass ApiAdapter - this parses the keyword arguments
# into the options used below.
super(InterfaceAdapter, self).__init__(**kwargs)
interface_options = {
'working_dir' : str(self.options.get('working_directory')),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(\n self, config: interface.BaseConfig, session_manager: ClientSessionManager\n ):\n super().__init__(max_calls=1) # To StateProducer via interface.AppleTV\n self._config = config\n self._session_manager = session_manager\n self._protocols_to_setup: Queue[SetupDat... | [
"0.6246754",
"0.6134311",
"0.60056937",
"0.59435606",
"0.59399885",
"0.5938015",
"0.58114725",
"0.5783236",
"0.57771885",
"0.57014894",
"0.56744635",
"0.5656668",
"0.56562054",
"0.5633026",
"0.5632867",
"0.5621585",
"0.5616236",
"0.56147224",
"0.56017303",
"0.55965614",
"0.55... | 0.684456 | 0 |
Handle an HTTP GET request. This method handles an HTTP GET request routed to the adapter. This passes the path of the request to the underlying InterfaceData instance, where it is interpreted and returned as a dictionary containing the appropriate parameter tree. | def get(self, path, request):
try:
#Check for metadata argument
metadata = False
if "Accept" in request.headers:
splitted = request.headers["Accept"].split(';')
if len(splitted) > 1:
splitted = splitted[1:]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_GET(self):\n\n try:\n self.parsed_url = urllib.parse.urlsplit(self.path)\n self.request_params = dict(urllib.parse.parse_qsl(self.parsed_url.query))\n\n handler = self._dispatch_on_path()\n\n if isinstance(handler, Handler):\n\n self._check_r... | [
"0.7317181",
"0.7053826",
"0.68583715",
"0.6845075",
"0.6772212",
"0.6740971",
"0.6593313",
"0.65820014",
"0.65498316",
"0.653717",
"0.64670396",
"0.64539516",
"0.64454687",
"0.6416539",
"0.64149696",
"0.63978124",
"0.63909775",
"0.6355734",
"0.63305265",
"0.6291063",
"0.6269... | 0.65356284 | 10 |
Handle an HTTP PUT request. This method handles an HTTP PUT request routed to the adapter.This decodes the JSON body of the request into a dict, and passes the result with the request path to the underlying InterfaceData instance, where it is parsed and appropriate actions taken. | def put(self, path, request):
try:
data = json_decode(request.body)
self.interface_data.set(path, data)
response = self.interface_data.get(path, False)
status_code = 200
except MetadataParameterError as e:
response = {'error': str(e)}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(self, path, request):\n\n content_type = 'application/json'\n\n try:\n data = json_decode(request.body)\n self.fileInterface.set(path, data)\n response = self.fileInterface.get(path)\n status_code = 200\n except FileInterfaceError as e:\n ... | [
"0.7248065",
"0.6955489",
"0.6941687",
"0.6785341",
"0.6680217",
"0.6676589",
"0.66458213",
"0.6615419",
"0.6500376",
"0.64675933",
"0.64273846",
"0.6404214",
"0.6280552",
"0.62804186",
"0.62793255",
"0.6271429",
"0.6265722",
"0.6231033",
"0.6231033",
"0.6231033",
"0.618072",... | 0.7927173 | 0 |
Handle background update loop tasks. This method polls the sensors in the background and is executed periodically in the tornado IOLoop instance. | def update_loop(self):
# Handle background tasks
#self.interface_data.backplane.poll_all_sensors()
# Schedule the update loop to run in the IOLoop instance again after appropriate
# interval
IOLoop.instance().call_later(self.update_interval, self.update_loop) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n while True:\n # Do something\n print('Doing something imporant in the background')\n\n self.loadData()\n time.sleep(self.interval)",
"def add_update_loop(self):\n l = LoopingCall(self.update_active_node)\n l.clock = self.reactor\n ... | [
"0.66790515",
"0.6355443",
"0.634593",
"0.6324028",
"0.6284374",
"0.62757915",
"0.62316465",
"0.62310386",
"0.6216169",
"0.6204409",
"0.6203999",
"0.61990917",
"0.6163417",
"0.61604416",
"0.6124282",
"0.6124282",
"0.61110944",
"0.60961056",
"0.60944873",
"0.60881984",
"0.6076... | 0.8306783 | 0 |
Returns a mesh of squares in the xyplane where each unit is one of the two given colors and adjacent squares have opposite colors. | def checkerboard(
radius: int = 4,
color1: Tuple[float, ...] = (0.0, 0.0, 0.0),
color2: Tuple[float, ...] = (1.0, 1.0, 1.0),
device: Optional[torch.types._device] = None,
) -> Meshes:
if device is None:
device = torch.device("cpu")
if radius < 1:
raise ValueError("radius must be... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_square_triangle_mesh():\n vertices = np.array(\n ((0, 0, 0), (1, 0, 0), (0, 1, 0), (1, 1, 0), (0.5, 0.5, 0)),\n dtype=np.float32)\n faces = np.array(\n ((0, 1, 4), (1, 3, 4), (3, 2, 4), (2, 0, 4)), dtype=np.int32)\n return vertices, faces",
"def yield_isosceles_triangles(cls):\n ... | [
"0.63428485",
"0.6201984",
"0.607834",
"0.60289735",
"0.58987814",
"0.5778267",
"0.5738428",
"0.5700882",
"0.5674927",
"0.562093",
"0.5596301",
"0.5584693",
"0.5582065",
"0.55752957",
"0.55621064",
"0.5553264",
"0.5553264",
"0.55416226",
"0.5519514",
"0.5519514",
"0.5519514",... | 0.5708757 | 7 |
Saves a new baseline file into the port's baseline directory. The file will be named simply "expected", suitable for use as the expected results in a later run. | def _save_baseline_data(self, data, modifier, generate_new_baseline=True):
port = self._port
fs = port._filesystem
if generate_new_baseline:
relative_dir = fs.dirname(self._testname)
baseline_path = port.baseline_path()
output_dir = fs.join(baseline_path, rel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_test_baseline(self, file_name):\n return os.path.abspath(\n os.path.join(\n os.path.abspath(__file__),\n u'..',\n u'baselines',\n file_name))",
"def bless_output(self):\n actual_output_file = path.splitext(self.source_na... | [
"0.61419886",
"0.61045825",
"0.5936975",
"0.56854904",
"0.5615434",
"0.5565428",
"0.55316305",
"0.5527674",
"0.54743046",
"0.54691416",
"0.54440033",
"0.53628296",
"0.53045976",
"0.5276994",
"0.5240396",
"0.52365404",
"0.5218536",
"0.52183956",
"0.5201798",
"0.51563257",
"0.5... | 0.676486 | 0 |
Receives the output from a DumpRenderTree process, subjects it to a number of tests, and returns a list of failure types the test produced. | def _process_output(self, driver_output):
fs = self._port._filesystem
failures = self._handle_error(driver_output)
expected_driver_output = self._expected_driver_output()
# Check the output and save the results.
start_time = time.time()
time_for_diffs = {}
for te... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_failed_tests_info():\n global g_failed_testnames\n global g_failed_test_paths\n\n if os.path.isfile(g_temp_filename):\n console_file = open(g_temp_filename,'r') # open temp file that stored jenkins job console output\n try:\n for each_line in console_file: # go throu... | [
"0.6139017",
"0.58134925",
"0.5801882",
"0.57782215",
"0.57617205",
"0.575985",
"0.57558024",
"0.57512224",
"0.5713094",
"0.5690147",
"0.56870687",
"0.5684887",
"0.5628258",
"0.5627857",
"0.5616837",
"0.5599172",
"0.55200875",
"0.5511547",
"0.5509322",
"0.5497192",
"0.5496381... | 0.55722797 | 16 |
Returns the name/category of the budget. | def name(self) -> str:
return str(self.category.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def budget_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"budget_name\")",
"def budget_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"budget_name\")",
"def budget_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"budget_name\")",
"def get... | [
"0.7660619",
"0.7269922",
"0.7156352",
"0.6941515",
"0.687923",
"0.6801441",
"0.67427135",
"0.672864",
"0.67025054",
"0.6613733",
"0.65991443",
"0.6553266",
"0.6553266",
"0.6445341",
"0.6432643",
"0.6391167",
"0.6386544",
"0.6358142",
"0.6309232",
"0.6306965",
"0.6273415",
... | 0.7123988 | 3 |
A property that calculates the exceeded ratio (amount spent / total amount) of this budget. | def exceeded_ratio(self) -> float:
return self.amount_spent / self.total_amount | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def budget_used(self):\n return int(self.total_spent() / self.budget() * 100.0)",
"def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0",
"def ratio(self):\n ... | [
"0.6591943",
"0.6559081",
"0.63274586",
"0.6305053",
"0.6276677",
"0.62711346",
"0.6237848",
"0.6213536",
"0.6212942",
"0.61523706",
"0.61523706",
"0.6116475",
"0.6113221",
"0.6110212",
"0.60746557",
"0.6064563",
"0.6050357",
"0.60138005",
"0.5991126",
"0.5988578",
"0.5982346... | 0.83884895 | 0 |
Read only property of the _locked attribute, to determine if this budget is locked. | def locked(self) -> bool:
return self._locked | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_locked(self):\n return self._is_locked",
"def locked(self):\n return self.is_locked",
"def locked(self) -> bool:\n return pulumi.get(self, \"locked\")",
"def is_locked(self):\r\n pass",
"def is_locked(self):\n ret_val = self._is_locked()\n return ret_val",
... | [
"0.7902527",
"0.77848",
"0.7781904",
"0.7753825",
"0.76652926",
"0.7660343",
"0.7645482",
"0.7565413",
"0.75639856",
"0.7493816",
"0.74647826",
"0.74602294",
"0.7433045",
"0.7423135",
"0.74167967",
"0.74167967",
"0.74167967",
"0.73956585",
"0.73792064",
"0.7378929",
"0.728194... | 0.7400543 | 17 |
Adds a budget to the dictionary. | def add_budget(self, budget: Budget) -> None:
self.budgets[budget.category] = budget | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deposit(self, amount, budget):\r\n if budget != \"Total Balance\":\r\n assert budget in self.budgets, \"Specified budget doesn't exist\"\r\n self.budgets[budget] += float(amount)\r\n self.balance += float(amount)",
"def declare_new_budget(date, exp_data):\n\n exp_list =... | [
"0.63456917",
"0.60231787",
"0.5939616",
"0.59035134",
"0.5890429",
"0.5828401",
"0.5779284",
"0.57482374",
"0.5545248",
"0.5494234",
"0.5493827",
"0.5463563",
"0.5444056",
"0.5438311",
"0.54316634",
"0.5424708",
"0.54197586",
"0.540606",
"0.5402471",
"0.53940505",
"0.5336805... | 0.7852479 | 0 |
Finds and returns budget stored in the dictionary. | def get_budget(self, category: BudgetCategory) -> Budget:
return self.budgets.get(category, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def budget(self):\n return self._budget",
"def get_budget_by_name(self, budget_name):\n return next((budget for budget in self.budgets\n if budget.name.lower() == budget_name.lower()), None)",
"def getBudget(movieInfo):\n if \"budget\" in movieInfo:\n return int(movi... | [
"0.644745",
"0.6405999",
"0.62401956",
"0.60685647",
"0.6040692",
"0.5716305",
"0.5598385",
"0.5519935",
"0.5446943",
"0.54325116",
"0.54259604",
"0.5413207",
"0.535384",
"0.53050965",
"0.5295184",
"0.5284351",
"0.5279604",
"0.5254645",
"0.5236342",
"0.52344924",
"0.5230984",... | 0.64537567 | 0 |
Returns budgets stored in the dictionary as a list. | def get_budgets(self) -> list:
return list(self.budgets.values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_budgets(self) -> list:\n return self.budget_manager.get_budgets()",
"def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")",
"def get_expenses(budget):\n return sum(expense['bgt'] for expense i... | [
"0.74353254",
"0.6164198",
"0.6107933",
"0.6100253",
"0.58037996",
"0.5798786",
"0.57337105",
"0.5695821",
"0.56689733",
"0.566745",
"0.56575996",
"0.5653672",
"0.5653672",
"0.5638305",
"0.56300706",
"0.5625624",
"0.5610835",
"0.5596588",
"0.5596588",
"0.5596588",
"0.5596588"... | 0.8426276 | 0 |
Counts and returns the number of locked budgets. | def no_locked_budgets(self) -> int:
count = 0
for budget in self.budgets.values():
if budget.locked:
count += 1
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outstanding(self):\n return sum(\n transfer.lock.amount\n for transfer in self.locked.values()\n )",
"def budget_used(self):\n return int(self.total_spent() / self.budget() * 100.0)",
"def count_total(self):\n\t\twith self._c_lock: # I can't believe I implemented ... | [
"0.64319116",
"0.59869766",
"0.5931925",
"0.5908128",
"0.5878541",
"0.58729374",
"0.58525044",
"0.5819347",
"0.58104414",
"0.57775193",
"0.5762641",
"0.5753774",
"0.57415694",
"0.57415694",
"0.57394975",
"0.57261735",
"0.57024676",
"0.5688358",
"0.5645157",
"0.563684",
"0.562... | 0.85815716 | 0 |
Creates and returns a budget from user input for the given budget category. | def create_budget(budget_category: BudgetCategory) -> Budget:
amount = -1
while amount <= 0:
amount = float(input(f'Enter {budget_category.value} budget: '))
if amount <= 0:
print('Budget amount must be greater than 0! Please enter '
'again!'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_budget(self, category: BudgetCategory) -> Budget:\n return self.budgets.get(category, None)",
"def execute_budgets_menu() -> BudgetCategory:\n categories = list(BudgetCategory)\n no_budgets = len(categories)\n choice = -1\n print('Select a budget category:')\n wh... | [
"0.6900647",
"0.683713",
"0.6413041",
"0.62244904",
"0.6032063",
"0.5851567",
"0.58220255",
"0.57313067",
"0.5693593",
"0.55933374",
"0.54202634",
"0.54114354",
"0.5408077",
"0.5401938",
"0.53535455",
"0.5352132",
"0.53383446",
"0.5330315",
"0.5309922",
"0.5308046",
"0.528334... | 0.85561347 | 0 |
Prompts the user for the amount of each budget. These budgets will be added to a BudgetManager. The manager then will be returned out. | def create_budget_manager(cls) -> BudgetManager:
manager = BudgetManager()
for category in list(BudgetCategory):
budget = cls.create_budget(category)
manager.add_budget(budget)
return manager | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_budgets(self) -> None:\n Menu.prompt_view_budgets()\n for budget in self.user.budget_manager:\n print(f\"{budget}\\n\")",
"def declare_new_budget(date, exp_data):\n\n exp_list = exp_data[env.EXPENSE_DATA_KEY]\n local_budget = {}\n month_total = util.get_float_input(\n ... | [
"0.71636736",
"0.61009943",
"0.604694",
"0.6036869",
"0.59618825",
"0.5900128",
"0.5894699",
"0.57592595",
"0.56952924",
"0.5673455",
"0.5662743",
"0.5650943",
"0.5648747",
"0.56033427",
"0.55529106",
"0.5543389",
"0.5530661",
"0.55166674",
"0.549556",
"0.5487224",
"0.5478001... | 0.5490783 | 19 |
Presents the budget menu for the user to select and returns the budget category that user chooses. | def execute_budgets_menu() -> BudgetCategory:
categories = list(BudgetCategory)
no_budgets = len(categories)
choice = -1
print('Select a budget category:')
while choice < 1 or choice > no_budgets:
for idx, category in enumerate(categories):
print(f' {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def category_choice(self):\n self.leave_category_choice = 1\n while self.leave_category_choice:\n print(fr.FR[15])\n for element in config.CATEGORIES:\n print(str(config.CATEGORIES.index(element)+1)\n + \" : \" + element)\n self.cat... | [
"0.65938395",
"0.6233436",
"0.6190896",
"0.61505425",
"0.6138054",
"0.604541",
"0.5960599",
"0.5843633",
"0.5817664",
"0.5801775",
"0.5791902",
"0.5737235",
"0.57300234",
"0.56732094",
"0.56335896",
"0.56010336",
"0.55867344",
"0.55579084",
"0.55082554",
"0.5506753",
"0.54915... | 0.8198939 | 0 |
Sets up and returns a BudgetManager with each budget of amount $100. | def load_test_budget_manager(cls) -> BudgetManager:
manager = BudgetManager()
for category in list(BudgetCategory):
budget = Budget(category, 100)
manager.add_budget(budget)
return manager | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_budget_manager(cls) -> BudgetManager:\n manager = BudgetManager()\n for category in list(BudgetCategory):\n budget = cls.create_budget(category)\n manager.add_budget(budget)\n return manager",
"def __init__(self, bank_account_no: str, bank_name: str,\n ... | [
"0.7738722",
"0.6067128",
"0.5915157",
"0.5754487",
"0.57359993",
"0.5603405",
"0.5476045",
"0.5440444",
"0.5365476",
"0.52967113",
"0.52317",
"0.5221079",
"0.52009493",
"0.5193181",
"0.5189404",
"0.51420105",
"0.5124656",
"0.5121084",
"0.5118158",
"0.508111",
"0.50754696",
... | 0.77666306 | 0 |
The sandbox is subdivided in self.box_shape boxes and each box is analysed. An R and theta array is returned. | def process_sandbox(self, data):
return mapfeatures.process_window(data, self.box_shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def box(self):\n r2 = self.radius\n res = [self.x - r2, self.y - r2, self.x + r2, self.y + r2]\n return res",
"def get_boxes(self):\r\n\r\n boxes = [(\" \", self.worldbox.tl, self.worldbox.br)]\r\n# boxes = []\r\n boxes += [(\".\", b.tl, b.br) for b in self.wallboxes]\r\... | [
"0.57753634",
"0.57500136",
"0.5702575",
"0.5616116",
"0.55639243",
"0.54722744",
"0.54668117",
"0.53439415",
"0.5328033",
"0.5326278",
"0.52923673",
"0.52458465",
"0.5231402",
"0.5204559",
"0.5186256",
"0.51697683",
"0.5161667",
"0.5140625",
"0.5140335",
"0.51207787",
"0.509... | 0.5444292 | 7 |
Looks for the best match between the tuple of the sandbox and all Europe tuples. | def correlate_sandbox(self, tuple_sb, tuple_eur, plot=False) -> tuple:
# Initialize parameters with extreme values
cost_best = 10000
position_best = -1
# Initialize solution vector
if plot:
cost_all = []
# Extract parameters from tuple
R_sb, theta_sb = tuple_sb
R_eur, theta_eur =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_best_offer(\n self, all_offers: List[Tuple[str, Dict]]\n ) -> Tuple[List, float]:\n bests, best_gain = [], 0\n\n for partner, offers in all_offers:\n partial_asgt = self._neighbors_values.copy()\n current_partner = self._neighbor_var(partner)\n\n #... | [
"0.5896853",
"0.5688851",
"0.5675493",
"0.5655122",
"0.5638799",
"0.5624046",
"0.55762094",
"0.5547533",
"0.54540485",
"0.54252297",
"0.5417066",
"0.53604704",
"0.5357901",
"0.5335932",
"0.5335924",
"0.5314372",
"0.5297954",
"0.5288686",
"0.52860814",
"0.5281672",
"0.52807474... | 0.60800743 | 0 |
The minimal distance between a bunch of vectors is searched. | def vector_substraction(self, th_eur, r_eur, th_sb, r_sb):
# Initialize the cost vector
cost = []
# Loop through the fraction of europe and calculate the vector cost
for i in range(1, len(r_eur)):
# Check if the location is just sea and nothing else. Do not take this position.
if (np.su... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_min_distance():\n return np.argmin(d)",
"def _minimum_distance(self,arg):\n return min([abs(arg-e) for e in self if not e is arg])",
"def smallest_distance(self, clusters):\n i, j = numpy.unravel_index(numpy.argmin(clusters), clusters.shape)\n return clusters[i, j], i, j",
"d... | [
"0.73687935",
"0.67609227",
"0.67483205",
"0.6721468",
"0.6635303",
"0.6502757",
"0.6498622",
"0.64140505",
"0.6376266",
"0.6340204",
"0.6319625",
"0.6301285",
"0.6261604",
"0.6236108",
"0.6235101",
"0.6223768",
"0.6221162",
"0.621856",
"0.6218279",
"0.61902165",
"0.6160359",... | 0.0 | -1 |
Load application configurations and models. Import each application module and then each model module. It is threadsafe and idempotent, but not reentrant. | def populate(self, workspace, installed_apps=None):
if self.ready:
return
# populate() might be called by two threads in parallel on servers
# that create threads before initializing the WSGI callable.
with self._lock:
if self.ready:
return
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _populate(self):\n if self.loaded:\n return\n # Note that we want to use the import lock here - the app loading is\n # in many cases initiated implicitly by importing, and thus it is\n # possible to end up in deadlock when one thread initiates loading\n # without h... | [
"0.6745917",
"0.6733646",
"0.6592259",
"0.65557784",
"0.63941354",
"0.63707244",
"0.6354497",
"0.63299286",
"0.62991405",
"0.628444",
"0.62597865",
"0.6241433",
"0.62310606",
"0.61505884",
"0.6121388",
"0.6119536",
"0.6091743",
"0.60726917",
"0.60283834",
"0.5982072",
"0.5923... | 0.6525624 | 4 |
Raise an exception if all apps haven't been imported yet. | def check_apps_ready(self):
if not self.apps_ready:
raise RuntimeError("Apps aren't loaded yet.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import_app(self):\n dirs.attempt_app_import(\"mediabrute\")\n with self.assertRaises(ImproperlyConfigured):\n dirs.attempt_app_import(\"NONONONONO\")",
"def _load_installed_applications(self):\n for application in self.settings.get('apps', None) or []:\n path =... | [
"0.63963807",
"0.63125914",
"0.6118928",
"0.6049964",
"0.59116197",
"0.5881896",
"0.5864091",
"0.58242136",
"0.5800848",
"0.57961357",
"0.5771751",
"0.574039",
"0.5713385",
"0.57008845",
"0.56540954",
"0.56355935",
"0.55529803",
"0.55522925",
"0.5543512",
"0.55320776",
"0.552... | 0.7175082 | 0 |
Raise an exception if all models haven't been imported yet. | def check_models_ready(self):
if not self.models_ready:
raise RuntimeError("Models aren't loaded yet.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_all():\n\n # count the number of files loaded\n count = 0\n\n # get model name\n model_name_list = [model for data_models in settings.OBJECT_DATA_MODELS\n for model in data_models]\n\n model_name_list += [model for model in settings.OTHER_DATA_MODELS]\n\n # import... | [
"0.6702693",
"0.6597641",
"0.63824916",
"0.6288562",
"0.61351323",
"0.605479",
"0.60163903",
"0.5974453",
"0.5934281",
"0.5840787",
"0.57924795",
"0.57813746",
"0.57655495",
"0.5670896",
"0.5662005",
"0.565143",
"0.56474614",
"0.5552075",
"0.553675",
"0.55349326",
"0.55294484... | 0.70884115 | 0 |
Import applications and return an iterable of app configs. | def get_app_configs(self):
self.check_apps_ready()
return self.app_configs.values() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_installed_applications(self):\n for application in self.settings.get('apps', None) or []:\n path = None\n if isinstance(application, six.string_types):\n application_name = application\n if application.startswith('gordon.contrib.'):\n ... | [
"0.7147316",
"0.6836849",
"0.6666008",
"0.6357849",
"0.62566024",
"0.6244669",
"0.6241416",
"0.61968774",
"0.61936617",
"0.6067515",
"0.60390776",
"0.6026536",
"0.601573",
"0.598151",
"0.5948439",
"0.5910892",
"0.5884694",
"0.58798975",
"0.58368564",
"0.58337295",
"0.5828102"... | 0.6826606 | 2 |
Import applications and returns an app config for the given label. Raise LookupError if no application exists with this label. | def get_app_config(self, app_label):
self.check_apps_ready()
try:
return self.app_configs[app_label]
except KeyError:
message = "No installed app with label '%s'." % app_label
for app_config in self.get_app_configs():
if app_config.name == app_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_app(self, app_label, emptyOK=False):\n self._populate()\n imp.acquire_lock()\n try:\n app_name = extract_app_name(app_label)\n if app_name is None:\n raise ImproperlyConfigured('App with label %s could not be '\n 'found' % app_lab... | [
"0.6948026",
"0.60602397",
"0.5971664",
"0.5592162",
"0.5575013",
"0.5373725",
"0.5323228",
"0.53103024",
"0.52559143",
"0.52429235",
"0.5188659",
"0.51339275",
"0.51230484",
"0.51016665",
"0.5075056",
"0.5073376",
"0.50494814",
"0.5046278",
"0.5040093",
"0.49333227",
"0.4921... | 0.7493551 | 0 |
Check whether an application with this name exists in the registry. app_name is the full name of the app e.g. 'restful_falcon.contrib.admin'. | def is_installed(self, app_name):
self.check_apps_ready()
return any(ac.name == app_name for ac in self.app_configs.values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_appname(appname):\n return appname in Registry.monomers",
"def is_app_exists(self, name, app_path) -> bool:\n ah_write = self.get_iis_object()\n section = ah_write.GetAdminSection(\"system.applicationHost/sites\", \"MACHINE/WEBROOT/APPHOST\")\n collection = section.Collection\... | [
"0.8244724",
"0.79095787",
"0.737276",
"0.7302646",
"0.67597425",
"0.6723505",
"0.6713614",
"0.66180587",
"0.66102314",
"0.65533984",
"0.65130615",
"0.6512317",
"0.65088826",
"0.642864",
"0.64203596",
"0.6358602",
"0.63582283",
"0.63429815",
"0.62443733",
"0.62442684",
"0.620... | 0.7581279 | 2 |
Recall metric. Only computes a batchwise average of recall. Computes the recall, a metric for multilabel classification of how many relevant items are selected. | def recall(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives / (possible_positives + K.epsilon())
return recall | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recall(y_true, y_pred, average, labels):\n\n y_true, y_pred = check_metric_args(y_true, y_pred, average, labels)\n\n result = None\n\n m = len(y_true)\n n = len(labels)\n\n confusion_matrix = get_confusion_matrix(y_true, y_pred, labels).T\n\n if average == \"micro\":\n numerator = np.t... | [
"0.76052207",
"0.74484503",
"0.74047023",
"0.7281549",
"0.7209793",
"0.7166467",
"0.71581",
"0.7145881",
"0.7145881",
"0.7145881",
"0.7145881",
"0.7145881",
"0.7145881",
"0.7132385",
"0.71016103",
"0.70670533",
"0.70652425",
"0.7063426",
"0.7063426",
"0.7063426",
"0.7063426",... | 0.7097688 | 33 |
Precision metric. Only computes a batchwise average of precision. Computes the precision, a metric for multilabel classification of how many selected items are relevant. | def precision(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives / (predicted_positives + K.epsilon())
return precision | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precision(self):\n self.overall_precision = precision_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_precision = precision_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)",
"def comp... | [
"0.7489052",
"0.7288358",
"0.7159325",
"0.715323",
"0.7065856",
"0.6984727",
"0.6964892",
"0.69536865",
"0.6912471",
"0.68334424",
"0.68176156",
"0.68093187",
"0.6804945",
"0.6804945",
"0.6804945",
"0.6804945",
"0.6804945",
"0.6804945",
"0.67855513",
"0.67575085",
"0.67575085... | 0.675501 | 44 |
Test packet generation and fake send. | def test_generate_and_send(mock_sr):
# mock send packets
mock_sr.return_value = fake_sr_return()
# init generator
netprobify = NetProbify()
netprobify.instantiate_generator()
# generate packets
TARGET.generate_packets(GROUP, netprobify.id_gen)
assert len(TARGET.packets) == 10
asser... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_send(self):\n msg_flag = self.instance.send(self.msg_short)\n assert(msg_flag)\n msg_flag, msg_recv = self.driver.recv(self.timeout)\n assert(msg_flag)\n nt.assert_equal(msg_recv, self.msg_short)",
"def test_send_network(self) :\n symbol = 'A' \n oProtoc... | [
"0.6892069",
"0.66339993",
"0.649775",
"0.6465824",
"0.6439808",
"0.6425743",
"0.63774353",
"0.63420707",
"0.63226706",
"0.6289918",
"0.62796855",
"0.62690765",
"0.62690526",
"0.625604",
"0.624448",
"0.62306184",
"0.61947006",
"0.61494166",
"0.6146559",
"0.6113945",
"0.604760... | 0.7693772 | 0 |
Text that 's in contractions is not lemmatized as '. | def test_issue401(EN, text, i):
tokens = EN(text)
assert tokens[i].lemma_ != "'" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_contractions(text):\r\n return contractions.fix(text)",
"def _replace_contractions(text):\n return contractions.fix(text)",
"def replace_contractions(text):\n return contractions.fix(text)",
"def replace_contractions(text):\n return contractions.fix(text)",
"def expand_contractions(... | [
"0.6775942",
"0.6719504",
"0.66563076",
"0.66563076",
"0.6441767",
"0.63712335",
"0.6275531",
"0.62549996",
"0.6237941",
"0.61390126",
"0.6138355",
"0.61180866",
"0.6060835",
"0.60040885",
"0.59310406",
"0.58554614",
"0.58482164",
"0.5792963",
"0.57772267",
"0.57377017",
"0.5... | 0.5456694 | 43 |
Returns an HTTP response object that redirects to the supplied URL with the supplied query parameters applied. | def HttpResponseRedirectWithQuery(redirect_uri, query_params):
nq = "?"
for pname in query_params.keys():
if query_params[pname]:
redirect_uri += nq + pname + "=" + quote(query_params[pname])
nq = "&"
return HttpResponseRedirect(redirect_uri) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redirect_to():\n\n args_dict = request.args.items()\n args = CaseInsensitiveDict(args_dict)\n\n # We need to build the response manually and convert to UTF-8 to prevent\n # werkzeug from \"fixing\" the URL. This endpoint should set the Location\n # header to the exact string supplied.\n respo... | [
"0.6659504",
"0.64636075",
"0.63889945",
"0.63879377",
"0.610228",
"0.60225797",
"0.60220236",
"0.6000811",
"0.59948146",
"0.5985534",
"0.58978784",
"0.5849514",
"0.58246356",
"0.5768415",
"0.5704956",
"0.5704761",
"0.57001656",
"0.56676114",
"0.5625186",
"0.5616323",
"0.5571... | 0.66205907 | 1 |
Returns an HTTP response object that is used at the end of an authentication flow. It redirects to the user_profile_url stored in the current session, with continuation to the supplied continuation_url, with the userid for the (attempted) authentication as a further query parameter. | def HttpResponseRedirectLogin(request, message=None):
user_profile_url = request.session.get('user_profile_url', reverse("AnnalistSiteView"))
query_params = {}
if 'continuation_url' in request.session:
query_params['continuation_url'] = request.session['continuation_url']
if 'recent_userid' in r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_authenticated_user(self, redirect_uri, client_id, client_secret,\n code, callback, extra_fields=None):\n logging.debug('gau ' + redirect_uri)\n http = tornado.httpclient.AsyncHTTPClient()\n args = {\n \"redirect_uri\": redirect_uri,\n \"co... | [
"0.59704",
"0.57576066",
"0.57576066",
"0.56492937",
"0.56403655",
"0.5556867",
"0.5509907",
"0.5499047",
"0.54631555",
"0.54217714",
"0.538807",
"0.5379946",
"0.5378877",
"0.5330215",
"0.5329715",
"0.53291154",
"0.5300578",
"0.5300578",
"0.5294871",
"0.5291251",
"0.52382874"... | 0.53972936 | 10 |
Utility function that creates dictionary representation of an object. | def object_to_dict(obj, strip):
t = type(obj)
d = copy.copy(obj.__dict__)
for member in strip:
if member in d:
del d[member]
d['_class'] = t.__name__
d['_module'] = t.__module__
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def todict(obj):\n if isinstance(obj, str):\n return obj\n elif isinstance(obj, enum.Enum):\n return str(obj)\n elif isinstance(obj, dict):\n return dict((key, todict(val)) for key, val in obj.items())\n elif isinstance(obj, collections.Iterable):\n return [todict(val) for v... | [
"0.7310001",
"0.7195056",
"0.70770437",
"0.705504",
"0.70312023",
"0.7030219",
"0.7020099",
"0.7001358",
"0.6902885",
"0.68736845",
"0.67525834",
"0.67378587",
"0.66853493",
"0.66853493",
"0.66723883",
"0.666358",
"0.6656492",
"0.66415584",
"0.6622443",
"0.65721786",
"0.65451... | 0.69886494 | 8 |
Return a response corresponding to the given key. | def __getitem__(self, key):
# Sanity check: This might be easy.
# If the URL is an exact match via. the regular `dict` lookup,
# then just return that.
no = object()
super_answer = super(Registry, self).get(key, no)
if super_answer != no:
return super_answer
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def read(self, key: str) -> ResponseOrKey:",
"def get(self, key, headers=Headers()):",
"def get(self, key):\n return self.execute_command(self.GET_CMD, key)",
"def get(self, key):\n \n print(\"Getting from node {}\".format(self.url))\n\n (headers, content) = self.http_client... | [
"0.7400327",
"0.70474446",
"0.68870306",
"0.6693863",
"0.662304",
"0.6497534",
"0.6377405",
"0.6365614",
"0.6348494",
"0.6304377",
"0.6297758",
"0.62936944",
"0.6262766",
"0.62330174",
"0.62269306",
"0.62030137",
"0.6202612",
"0.6189245",
"0.61835074",
"0.61835074",
"0.616490... | 0.0 | -1 |
Return the full method and URL, as a string. | def __str__(self):
# Start with the basic URI.
answer = '%s %s' % (self.method, self.uri)
# Append any keyword arguments to the query-string
if self.qs:
qs_list = []
for key, values in self.qs.items():
# Convert `values` to a list if it's not one... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_method_url(self):\n formatter = \"json\"\n if self.method:\n url = \"%s/%d/%s/%s.%s\" % (self.base_url, self.version,\n self.account, self.method,\n formatter)\n request_url = requests.head(url, p... | [
"0.7257215",
"0.6996861",
"0.6880669",
"0.6531301",
"0.65246946",
"0.6417852",
"0.6371235",
"0.63354814",
"0.6317191",
"0.6285708",
"0.62852126",
"0.62748575",
"0.62604576",
"0.6250731",
"0.6239291",
"0.62013763",
"0.6184284",
"0.6173069",
"0.61529315",
"0.61058116",
"0.60952... | 0.65113395 | 5 |
Return True if this URL is an exact superset of the URL provided by `other`. | def is_exact_superset_of(self, other):
# If this is a string of some kind, convert it to a URL.
if isinstance(other, (six.text_type, six.binary_type)):
other = self.__class__(other)
# Type check!
if not hasattr(other, 'qs') or not hasattr(other, 'uri'):
raise Typ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_strict_superset(self, other):\n return self.is_superset(other) and self != other",
"def is_superset(self, other):\n \n for element in other:\n if element not in self:\n return False\n\n return True",
"def is_superset(self, other):\n if isinsta... | [
"0.71028805",
"0.69356734",
"0.68522155",
"0.68476844",
"0.65793014",
"0.6502486",
"0.63076425",
"0.6304706",
"0.6214503",
"0.6210435",
"0.62005806",
"0.61623186",
"0.61595505",
"0.6034027",
"0.60209525",
"0.59925973",
"0.59876674",
"0.59673166",
"0.59448874",
"0.5917174",
"0... | 0.82324034 | 0 |
Prepares the note response | def note_repr(key):
return {
'url': request.host_url.rstrip('/') + url_for('notes_detail', key=key),
'text': notes[key]
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_note(self):\n if self._report_data and self._report_data['note']:\n note = self._report_data['note']\n if note.get('createDateTime'):\n note['createDateTime'] = Report._to_report_datetime(note.get('createDateTime'))\n if note.get('expiryDateTime') and... | [
"0.6375515",
"0.57853264",
"0.5783189",
"0.57436967",
"0.56131977",
"0.559248",
"0.5586506",
"0.55410945",
"0.5422713",
"0.5422447",
"0.5408178",
"0.5375322",
"0.52852714",
"0.5280615",
"0.5269546",
"0.5258682",
"0.52485454",
"0.5236615",
"0.5225189",
"0.5219878",
"0.5215029"... | 0.49806014 | 55 |
Retrieve, update or delete note instances. | def notes_detail(key):
if request.method == 'PUT':
note = str(request.data.get('text', ''))
notes[key] = note
return note_repr(key)
elif request.method == 'DELETE':
notes.pop(key, None)
return '', status.HTTP_204_NO_CONTENT
# request.method == 'GET'
if key not i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_note():\n\n return Note.query.all()",
"def notes(self):\n return reapy.NoteList(self)",
"def get_notes(self, note_limit=200):\n return Note.get_by_person_record_id(\n self.subdomain, self.record_id, limit=note_limit)",
"def ls(self, count = 200):\n return self._mana... | [
"0.6639361",
"0.617886",
"0.6110275",
"0.60966027",
"0.5886469",
"0.58836895",
"0.58836895",
"0.5878445",
"0.58600885",
"0.5844162",
"0.5819225",
"0.5809799",
"0.58091563",
"0.5807114",
"0.58009684",
"0.57272816",
"0.5714965",
"0.5691968",
"0.56813973",
"0.56525964",
"0.56464... | 0.555653 | 30 |
Redirects to front page. | def mainpage():
return render_template('presence_weekday.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def root_redirect():\r\n return redirect(url_for(\"display_top\"))",
"def home_page():\n return redirect(url_for(_DEFAULT_ROUTE, _external=True))",
"def start_page():\n if not _home:\n abort(404)\n return redirect(_home)",
"def start_page():\n if not _home:\n abort(404)\n retu... | [
"0.7155309",
"0.71402824",
"0.7081907",
"0.7081907",
"0.6828993",
"0.68113315",
"0.680891",
"0.663342",
"0.6594873",
"0.6594873",
"0.6594873",
"0.65614533",
"0.6539556",
"0.65361327",
"0.6511136",
"0.65066427",
"0.64762396",
"0.6432043",
"0.6339064",
"0.6331238",
"0.63289326"... | 0.0 | -1 |
Redirects to mean_time_weekday page. | def mean_time():
return render_template('mean_time_weekday.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home(request):\n today = datetime.date.today()\n return HttpResponseRedirect(\"%s/newsletter/%d/%d/%d/\" % (SUBSITE, today.year, today.month, today.day))",
"def mainpage():\n return render_template('presence_weekday.html')",
"def mainpage(name=None):\n if not name:\n return redirect(url_... | [
"0.62515265",
"0.6238297",
"0.5995797",
"0.5972302",
"0.5677064",
"0.5641092",
"0.55807924",
"0.5452718",
"0.5416457",
"0.53435457",
"0.5311708",
"0.5308008",
"0.5263703",
"0.52506274",
"0.52275354",
"0.52275354",
"0.52275354",
"0.52263916",
"0.5193816",
"0.5187562",
"0.51827... | 0.6704054 | 0 |
Redirects to presence_start_end page. | def start_end():
return render_template('presence_start_end.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_page():\n if not _home:\n abort(404)\n return redirect(_home)",
"def start_page():\n if not _home:\n abort(404)\n return redirect(_home)",
"def toLanding():\n return redirect(url_for('landingurl'))",
"def get(self, request):\n return redirect('start:home')",
"d... | [
"0.5971557",
"0.5971557",
"0.5943474",
"0.57099074",
"0.57099074",
"0.57099074",
"0.55752295",
"0.5566747",
"0.5566221",
"0.55043846",
"0.54831034",
"0.5478961",
"0.5430729",
"0.5429293",
"0.5403134",
"0.5393614",
"0.53604597",
"0.52630067",
"0.52586526",
"0.5183116",
"0.5173... | 0.666048 | 0 |
Users listing for dropdown. | def users_view():
users = get_users()
data = get_data()
result = [{'user_id': i, 'name': users[i]}
for i in users.keys() if int(i) in data.keys()]
#import pdb; pdb.set_trace()
result.sort(key=lambda item: item['name'], cmp=locale.strcoll)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_users():\r\n users = User.query.order_by(User.last_name,User.first_name).all()\r\n return render_template('list.html', users=users)",
"def KLP_Users_list(request):\n\n # get logged in user\n\n user = request.user\n if user.id:\n\n # check logged in user permissions, to get user lis... | [
"0.7448725",
"0.73301697",
"0.7327242",
"0.7327242",
"0.7327242",
"0.7327242",
"0.7327242",
"0.7327242",
"0.7318417",
"0.73143923",
"0.7297931",
"0.72241616",
"0.7139011",
"0.712823",
"0.71233916",
"0.69906664",
"0.6973133",
"0.6961896",
"0.6916275",
"0.69009453",
"0.688397",... | 0.0 | -1 |
Returns mean presence time of given user grouped by weekday. | def mean_time_weekday_view(user_id):
#import pdb; pdb.set_trace()
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], mean(intervals))
for weekday... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_time_weekday_view(user_id=None):\n data = get_data()\n if not user_id:\n raise abort(400)\n\n if user_id not in data:\n log.debug('User %s not found!', user_id)\n return []\n\n weekdays = group_by_weekday(data[user_id])\n result = [(calendar.day_abbr[weekday], mean(inte... | [
"0.7820907",
"0.6851208",
"0.6848811",
"0.6119349",
"0.6025002",
"0.5929798",
"0.5753107",
"0.5695754",
"0.5610047",
"0.5583093",
"0.5531452",
"0.5494475",
"0.547884",
"0.53997254",
"0.53785306",
"0.5343953",
"0.5343953",
"0.53423256",
"0.53400195",
"0.52665937",
"0.5253249",... | 0.7910484 | 0 |
Returns total presence time of given user grouped by weekday. | def presence_weekday_view(user_id):
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], sum(intervals))
for weekday, intervals in weekdays.items()]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def presence_weekday_view(user_id=None):\n data = get_data()\n if not user_id:\n raise abort(400)\n\n if user_id not in data:\n log.debug('User %s not found!', user_id)\n return []\n\n weekdays = group_by_weekday(data[user_id])\n result = [(calendar.day_abbr[weekday], sum(interv... | [
"0.7513305",
"0.666141",
"0.6574399",
"0.64891076",
"0.5944046",
"0.59074956",
"0.58471644",
"0.5814486",
"0.57856905",
"0.5762274",
"0.5762274",
"0.5672877",
"0.5672623",
"0.5629637",
"0.54893243",
"0.5468925",
"0.54269946",
"0.540859",
"0.54045403",
"0.5379421",
"0.5338772"... | 0.75307816 | 0 |
Returns mean start and end hours grouped by weekday. | def presence_start_end_view(user_id):
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
result_start, result_stop = group_by_weekday_start_end(data[user_id])
result = []
for i in range(7):
result.append((
calendar.day_ab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_time_weekday_view(user_id):\n #import pdb; pdb.set_trace()\n data = get_data()\n if user_id not in data:\n log.debug('User %s not found!', user_id)\n return []\n\n weekdays = group_by_weekday(data[user_id])\n result = [(calendar.day_abbr[weekday], mean(intervals))\n ... | [
"0.70767546",
"0.691566",
"0.60244334",
"0.6006631",
"0.59523463",
"0.5813882",
"0.5720163",
"0.57031125",
"0.56863064",
"0.56797594",
"0.56209344",
"0.5582896",
"0.55791557",
"0.55611074",
"0.55569315",
"0.54988813",
"0.5399546",
"0.53779376",
"0.53592837",
"0.5350021",
"0.5... | 0.50501186 | 35 |
Returns labels associated with Image. | def labels(self) -> Dict[str, str]:
return self.attrs.get("Labels", {}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def detect_labels(path):\n client = vision.ImageAnnotatorClient()\n\n with io.open(path, 'rb') as image_file:\n content = image_file.read()\n\n image = vision.types.Image(content=content)\n\n response = client.label_detection(image=image)\n labels = response.label_annotations\n #print('Lab... | [
"0.7138663",
"0.7133516",
"0.7130016",
"0.7122506",
"0.7111845",
"0.7087622",
"0.70217323",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
"0.7000098",
... | 0.0 | -1 |
Returns tags from Image. | def tags(self) -> List[str]:
if "RepoTags" in self.attrs:
return [tag for tag in self.attrs["RepoTags"] if tag != "<none>:<none>"]
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tags(self):\n tags = []\n for image in self.client.images.list():\n for tag in image.tags:\n if tag.startswith(self.repository_name):\n tokens = tag.split(':')\n tags.append(tokens[1])\n return tags",
"def get_image_tags... | [
"0.7594638",
"0.7571425",
"0.72571933",
"0.69148505",
"0.69091725",
"0.662919",
"0.65037465",
"0.65037465",
"0.6470392",
"0.63407135",
"0.62951803",
"0.61895055",
"0.6180819",
"0.6146112",
"0.61458826",
"0.6142214",
"0.6104417",
"0.60859585",
"0.60708004",
"0.60700417",
"0.60... | 0.0 | -1 |
Returns history of the Image. | def history(self) -> List[Dict[str, Any]]:
response = self.client.get(f"/images/{self.id}/history")
body = response.json()
if response.status_code == 200:
return body
if response.status_code == 404:
raise ImageNotFound(body["cause"], response=response, explanat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dohistory(self, *args, **kwargs):\n return _image.image_dohistory(self, *args, **kwargs)",
"def history():",
"def history(self):\n return self.info['history']",
"def get_history(self):\n return self.history",
"def history(self):\n return self.board.history",
"def history(s... | [
"0.82483864",
"0.7789621",
"0.7495005",
"0.7354837",
"0.7303717",
"0.7291426",
"0.7291426",
"0.72496754",
"0.72476786",
"0.7220276",
"0.7191091",
"0.71893007",
"0.71339124",
"0.7076902",
"0.6949881",
"0.68829805",
"0.68773735",
"0.68484914",
"0.68127704",
"0.68097353",
"0.678... | 0.83448565 | 0 |
Returns Image as tarball. | def save(
self, chunk_size: Optional[int] = 2097152, named: Union[str, bool] = False
) -> Iterator[bytes]:
_ = named
response = self.client.get(f"/images/{self.id}/get", stream=True)
if response.status_code == 200:
return response.iter_content(chunk_size=chunk_size)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_to_tgz(image, quiet):\n\n temp_dir = tempfile.mkdtemp()\n tar_file = path.join(temp_dir, path.basename(image) + '.tar')\n tar_gz_file = tar_file + '.gz'\n\n cmd = ['singularity', 'export', '-f', tar_file, image]\n\n if not quiet:\n sys.stderr.write(\"Exporting image to .tar\\n\")\n\... | [
"0.6866923",
"0.6039955",
"0.602726",
"0.6003644",
"0.5970418",
"0.5964112",
"0.5886299",
"0.5867114",
"0.58565104",
"0.5853468",
"0.58134466",
"0.5777255",
"0.57716244",
"0.57533777",
"0.57440144",
"0.5714641",
"0.5710571",
"0.56837445",
"0.5678078",
"0.56721973",
"0.5660147... | 0.0 | -1 |
Tag Image into repository. | def tag(self, repository: str, tag: Optional[str], force: bool = False) -> bool:
_ = force
params = {"repo": repository}
if tag is not None:
params["tag"] = tag
response = self.client.post(f"/images/{self.id}/tag", params=params)
if response.status_code == 201:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tag(self, **kwargs):\n return self.getField('image').tag(self, **kwargs)",
"def tag(self, **kwargs):\n return self.getField('image').tag(self, **kwargs)",
"def tag(self, image, repo, tag):\n check_blacklist(repo)\n logger.info(\"Tagging Docker image {} as {}:{}\".format(image, r... | [
"0.71349096",
"0.71349096",
"0.71301895",
"0.70288086",
"0.68998545",
"0.6836816",
"0.6630423",
"0.66236347",
"0.6545502",
"0.64330405",
"0.63881534",
"0.6354384",
"0.6343031",
"0.63360643",
"0.6188394",
"0.61422634",
"0.6105857",
"0.61012286",
"0.6098683",
"0.6093301",
"0.60... | 0.71320766 | 2 |
Getter function returns user id against the specified email. | def get_id(self, email):
query = self._db.User.select(self._db.User.c.email == email)
query = query.with_only_columns([self._db.User.c.id_, ])
record = query.execute().fetchone()
return record[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_id(email):\n try:\n user = session.query(User).filter_by(email=email).one()\n return user.id\n except:\n return None",
"def getUserID(email):\r\n try:\r\n session = DBSession()\r\n return session.query(User).filter_by(email=email).one().id\r\n except:\r... | [
"0.81937325",
"0.8104995",
"0.80850965",
"0.8067864",
"0.8065274",
"0.80627054",
"0.80515283",
"0.7991437",
"0.7979025",
"0.7979025",
"0.794362",
"0.7879122",
"0.7856898",
"0.7781442",
"0.7704244",
"0.7685305",
"0.7562969",
"0.7524555",
"0.7518592",
"0.7483379",
"0.74065524",... | 0.84576696 | 0 |
Getter function returns the specified user's email. | def get_email(self, id_):
query = self._db.User.select(self._db.User.c.id_ == id_)
query = query.with_only_columns([self._db.User.c.email, ])
record = query.execute().fetchone()
return record[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_email(self):\n member = self.get_user()\n if member:\n return member.getProperty('email')",
"def get_email(obj):\r\n return obj.user.email",
"def user_email(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"user_email\")",
"def get(self):\n user_i... | [
"0.87113273",
"0.82361025",
"0.7884297",
"0.78725815",
"0.78565764",
"0.7744766",
"0.764593",
"0.755152",
"0.7539069",
"0.7512469",
"0.7478125",
"0.7477021",
"0.7456686",
"0.744357",
"0.74370015",
"0.74066263",
"0.73810107",
"0.7358525",
"0.73503655",
"0.73461527",
"0.7274743... | 0.7104593 | 30 |
Getter function returns the specified user infomation. SELECT Profile.name_, Profile.kana, Profile.nickname, ... from Profile inner join User on Profile.userId = User.id_ inner join Prefecture on Profile.prefectureId = Prefecture.id_; | def get_all(self, id_):
joined_query = self._db.User.join(
self._db.Profile, self._db.User.c.id_ == self._db.Profile.c.userId)
joined_query = joined_query.join(
self._db.Prefecture, self._db.Profile.c.prefectureId == self._db.Prefecture.c.id_)
joined_query = joined_query... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getdat(user):\r\n profile = user.profile\r\n return [user.username, user.email] + [getattr(profile, xkey, '') for xkey in profkeys]",
"def get_user_profile(self):\n return self.request('get', 'id/users')",
"def get_profile():\n\n if request['user_id']:\n\n user = User.selec... | [
"0.6711432",
"0.64871967",
"0.6378424",
"0.63459224",
"0.63411635",
"0.6307972",
"0.62849563",
"0.62816036",
"0.62378174",
"0.62269497",
"0.6220193",
"0.62060094",
"0.6197635",
"0.61876595",
"0.61854666",
"0.61354107",
"0.6124501",
"0.6111729",
"0.610672",
"0.6106198",
"0.609... | 0.0 | -1 |
Update account information against the specified user id. | def update_account_with(self, id_, **kwargs):
self.update_user_with(id_, **kwargs)
self.update_profile_with(id_, **kwargs)
# TODO:
# self.update_prefecture_with(id_, kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_user(id):\n pass",
"def update_user(self):\n self.client.force_authenticate(user=self.user)\n self.response = self.client.patch(\n reverse(\n 'edit_account',kwargs={ 'pk': self.user.id}),\n self.updated_data, format='json'\n )\n s... | [
"0.7563365",
"0.75483066",
"0.7502834",
"0.7481452",
"0.7370565",
"0.72471577",
"0.7134882",
"0.71121",
"0.7078587",
"0.70584905",
"0.7002422",
"0.6990923",
"0.6987949",
"0.69791096",
"0.6962229",
"0.6920091",
"0.68333936",
"0.68257654",
"0.6802805",
"0.6716634",
"0.6700307",... | 0.77432007 | 0 |
Generator function which returns ability records with the specified users and below query. SELECT Profile.lastName, Profile.firstName, ... FROM User INNER JOIN Profile ON Profile.userId = User.id_ INNER JOIN UsersAbility ON User.id_ = UsersAbility.userId INNER JOIN Ability ON UsersAbility.abilityId = Ability.id_; | def yield_record(self, user_ids=[], columns=None):
filter_ = None
if user_ids:
filter_ = self._db.User.c.id_ == user_ids[0]
for user_id in user_ids[1:]:
filter_ |= self._db.User.c.id_ == user_id
if columns:
columns = [col for col in columns if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_models_organization_get_abilities_member_user(self):\n access = factories.UserOrganizationAccessFactory(role=\"member\")\n\n with self.assertNumQueries(1):\n abilities = access.organization.get_abilities(access.user)\n\n self.assertEqual(\n abilities,\n ... | [
"0.5391291",
"0.5223448",
"0.5184904",
"0.5113543",
"0.49423173",
"0.49127218",
"0.48708478",
"0.4827274",
"0.48093134",
"0.48089716",
"0.48043194",
"0.47699356",
"0.47529572",
"0.47479445",
"0.47470778",
"0.47262278",
"0.47191784",
"0.47191784",
"0.47117633",
"0.4708607",
"0... | 0.72041345 | 0 |
Get the number of requests. SELECT COUNT() FROM Request INNER JOIN UsersRequest ON UsersRequest.requestId = Request.id_; | def _get_request_count(self):
joined_query = self._db.Request.join(
self._db.UsersRequest, self._db.UsersRequest.c.requestId == self._db.Request.c.id_)
joined_query = joined_query.select().with_only_columns([func.count()])
res = joined_query.execute()
return [_ for _ in res]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def friend_request_count(self) -> int:\n e = await self.request.request(url=f'https://friends.roblox.com/v1/user/friend-requests/count', method='get',\n )\n return e['count']",
"def count(self):\n return len(self._request_sessions)",
"def client_... | [
"0.69484293",
"0.6632788",
"0.65044624",
"0.6379204",
"0.6297678",
"0.6280874",
"0.62785643",
"0.62650543",
"0.62540686",
"0.6237054",
"0.6202207",
"0.61585265",
"0.61410373",
"0.6129518",
"0.6103263",
"0.61020875",
"0.609978",
"0.6065355",
"0.60639393",
"0.60524714",
"0.6030... | 0.8224526 | 0 |
Generator function which returns request records with below query. SELECT Profile.lastName, Profile.firstName, Profile.lastKanaName, Profile.firstKanaName, Request.detail FROM User INNER JOIN Profile ON User.id = Profile.userId INNER JOIN UsersRequest ON User.id_ = UsersRequest.userId INNER JOIN Request ON UsersRequest... | def yield_record(self, user_ids=[], columns=None):
filter_ = None
if user_ids:
filter_ = self._db.User.c.id_ == user_ids[0]
for user_id in user_ids[1:]:
filter_ |= self._db.User.c.id_ == user_id
if columns:
columns = [col for col in columns if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yield_record(self, user_ids=[], columns=None):\n filter_ = None\n if user_ids:\n filter_ = self._db.User.c.id_ == user_ids[0]\n for user_id in user_ids[1:]:\n filter_ |= self._db.User.c.id_ == user_id\n\n if columns:\n columns = [col for col ... | [
"0.607708",
"0.5801224",
"0.563434",
"0.5436275",
"0.5435522",
"0.54041797",
"0.5401012",
"0.52706105",
"0.5223789",
"0.52082694",
"0.5188554",
"0.5173161",
"0.5173011",
"0.5165055",
"0.5140934",
"0.51273125",
"0.5110731",
"0.5102614",
"0.5070352",
"0.5065051",
"0.5059272",
... | 0.70053494 | 0 |
Generator function which returns prefectures with below query. SELECT Prefecture.id_, Prefecture.name_ FROM Prefecture; | def yield_record(self, columns=None):
query = self._db.Prefecture.select().with_only_columns(self.get_all_column())
for record in query.execute():
yield record | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_one():\n puppies = session.query(Puppy.name).order_by(Puppy.name.asc()).all()\n\n for puppy in puppies:\n print puppy.name",
"def _getAllProvas(self):\n return self.execSql(\"select_all_provas\")",
"def get_people(self):\n cursor = self.cur()\n cursor.execute('SELECT... | [
"0.5559843",
"0.5441475",
"0.5225257",
"0.5199897",
"0.51973164",
"0.518491",
"0.5142329",
"0.5121006",
"0.5119528",
"0.5104191",
"0.5100354",
"0.5074651",
"0.5074651",
"0.50393736",
"0.5030389",
"0.50123405",
"0.49912012",
"0.4979582",
"0.4968754",
"0.49064863",
"0.4904445",... | 0.6172738 | 0 |
Disggregations should split data along the transformed dimension | def test_disaggregation_operation(self, space, time, expected):
data = np.array([[1]])
intermediate = Adaptor.convert_with_coefficients(data, space, 0)
actual = Adaptor.convert_with_coefficients(intermediate, time, 1)
np.testing.assert_allclose(actual, expected, rtol=1e-2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_dataset(self):",
"def _postprocess(self, outs, das, params):\n outs = super()._postprocess(outs, das, params)\n\n for i in range(len(outs)):\n if \"group\" in outs[i].dims:\n outs[i] = outs[i].squeeze(\"group\", drop=True)\n\n return outs",
"def dime... | [
"0.621968",
"0.6202799",
"0.61711615",
"0.5748643",
"0.5718049",
"0.5630885",
"0.55704653",
"0.55564606",
"0.5521332",
"0.548884",
"0.54875845",
"0.54647595",
"0.5454543",
"0.54487014",
"0.54333174",
"0.54291487",
"0.5418553",
"0.54017574",
"0.5387758",
"0.5380691",
"0.536761... | 0.51870686 | 53 |
Aggregations should collect data along the transformed dimension | def test_aggregation_operation(self, space, time, expected):
# Two regions, three intervals
data = np.array([[333.333, 333.333, 333.333], [333.333, 333.333, 333.333]])
intermediate = Adaptor.convert_with_coefficients(data, space, 0)
actual = Adaptor.convert_with_coefficients(intermediate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _aggregation_target(self):\n ...",
"def get_results_from_aggregation_sources(self, context):",
"def aggregator():\n return Aggregator(\n agg_col=\"col_a\", values_col=\"col_b\", aggregates=[\"min\", \"max\", \"avg\", \"sum\"]\n )",
"def aggregate(global_params, running_aggregate, aggr... | [
"0.6487456",
"0.60881907",
"0.60661906",
"0.6037719",
"0.5968184",
"0.59415835",
"0.5932226",
"0.59083897",
"0.5887001",
"0.5827151",
"0.5749039",
"0.57236975",
"0.56986797",
"0.56873745",
"0.56847465",
"0.5674025",
"0.5640821",
"0.56200093",
"0.56139773",
"0.5605245",
"0.559... | 0.5151263 | 93 |
Operations over 3dimensional data | def test_multidimensional_operation(self):
# start with something (1, 2, 3)
data = np.array([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]])
# split 1st dim (2, 2, 3)
coefficients = np.ones((1, 2)) / 2
expected = np.array(
[[[0.0, 0.5, 1.0], [1.5, 2.0, 2.5]], [[0.0, 0.5, 1.0], ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeCenters3d(self, data):\n\n\n for i in range(self.nPoints):\n print(\"Label of point \", i, \" is \", self.labels[i])\n for j in range(3):\n self.centers[self.labels[i]][j] += data[i][j]\n\n for c in range(self.n):\n for j in range(3):\n ... | [
"0.649511",
"0.64435244",
"0.6118735",
"0.6059016",
"0.60539794",
"0.6026208",
"0.5995588",
"0.59794426",
"0.59654516",
"0.59632635",
"0.5910405",
"0.5840366",
"0.582828",
"0.58131075",
"0.57950956",
"0.5764925",
"0.57469416",
"0.57458824",
"0.5715937",
"0.5696391",
"0.569589... | 0.62115836 | 2 |
Test the TabularOutputFormatter class. | def test_tabular_output_formatter():
headers = ["text", "numeric"]
data = [
["abc", Decimal(1)],
["defg", Decimal("11.1")],
["hi", Decimal("1.1")],
["Pablo\rß\n", 0],
]
expected = dedent(
"""\
+-------+---------+
| text | numeric |
+------... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_headless_tabulate_format():\n formatter = TabularOutputFormatter(format_name=\"minimal\")\n headers = [\"text\", \"numeric\"]\n data = [[\"a\"], [\"b\"], [\"c\"]]\n expected = \"a\\nb\\nc\"\n assert expected == \"\\n\".join(\n TabularOutputFormatter().format_output(\n iter... | [
"0.7598825",
"0.6803152",
"0.6683861",
"0.6668478",
"0.6604555",
"0.64349806",
"0.6323238",
"0.6221877",
"0.62087774",
"0.6080011",
"0.59904414",
"0.59258485",
"0.5906039",
"0.57514274",
"0.57006407",
"0.5679148",
"0.56766784",
"0.5619825",
"0.5604824",
"0.55946857",
"0.55943... | 0.7742016 | 0 |
Test the ascii_escaped output format. | def test_tabular_output_escaped():
headers = ["text", "numeric"]
data = [
["abc", Decimal(1)],
["defg", Decimal("11.1")],
["hi", Decimal("1.1")],
["Pablo\rß\n", 0],
]
expected = dedent(
"""\
+------------+---------+
| text | numeric |
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_plain_ansi(self):\n irc_ansi = irc.parse_ansi_to_irc(string.printable)\n ansi_irc = irc.parse_irc_to_ansi(string.printable)\n self.assertEqual(irc_ansi, string.printable)\n self.assertEqual(ansi_irc, string.printable)",
"def is_printable(c):\n return ord(c)>=32 or c in ['\... | [
"0.6732766",
"0.6406619",
"0.6277316",
"0.6251546",
"0.61997485",
"0.6184127",
"0.6170037",
"0.6024704",
"0.6006847",
"0.5948027",
"0.5901922",
"0.58854496",
"0.58677125",
"0.5860605",
"0.5801056",
"0.5801056",
"0.5796908",
"0.5796908",
"0.5795084",
"0.57895523",
"0.5780044",... | 0.6542039 | 1 |
Test the format_output wrapper. | def test_tabular_format_output_wrapper():
data = [["1", None], ["2", "Sam"], ["3", "Joe"]]
headers = ["id", "name"]
expected = dedent(
"""\
+----+------+
| id | name |
+----+------+
| 1 | N/A |
| 2 | Sam |
| 3 | Joe |
+----+------+"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _test_output_formatting_func(self, sample: Any):\n try:\n if not type(sample) == iter:\n self._formatting_func_return_types(format=sample)\n return True\n except Exception:\n raise ValueError(\n f\"formatting_func must return {self._f... | [
"0.7369798",
"0.70274675",
"0.67627716",
"0.6762203",
"0.6761139",
"0.6622697",
"0.65406054",
"0.6526979",
"0.64411855",
"0.6382983",
"0.6381997",
"0.6381733",
"0.63810277",
"0.63721865",
"0.6358712",
"0.6331598",
"0.63055885",
"0.62849057",
"0.62764215",
"0.62751293",
"0.627... | 0.5988137 | 53 |
Test that additional preprocessors are run. | def test_additional_preprocessors():
def hello_world(data, headers, **_):
def hello_world_data(data):
for row in data:
for i, value in enumerate(row):
if value == "hello":
row[i] = "{}, world".format(value)
yield row
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_processor(self):",
"def test_preprocessed_data(self):\n self.assertEqual(self.tester.preprocessed_data, [1, 2])",
"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_proce... | [
"0.6938419",
"0.5952152",
"0.5880601",
"0.5880601",
"0.5880601",
"0.5880601",
"0.5880601",
"0.57874",
"0.5712376",
"0.56677914",
"0.5662688",
"0.55605817",
"0.55309963",
"0.54661083",
"0.5465676",
"0.5465676",
"0.5465676",
"0.5465676",
"0.54530454",
"0.5423807",
"0.53889424",... | 0.6088411 | 1 |
Test the the format_name attribute be set and retrieved. | def test_format_name_attribute():
formatter = TabularOutputFormatter(format_name="plain")
assert formatter.format_name == "plain"
formatter.format_name = "simple"
assert formatter.format_name == "simple"
with pytest.raises(ValueError):
formatter.format_name = "foobar" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_format_metadata(self):\n\n format_metadata = self.group_tr.getFormatMetadata()\n self.assertIsInstance(format_metadata, OCIO.FormatMetadata)\n self.assertEqual(format_metadata.getName(), 'ROOT')",
"def format_(self):\n return self.set_format or self.default_format or self.FAL... | [
"0.6153331",
"0.6076459",
"0.6012055",
"0.59826183",
"0.592901",
"0.58396417",
"0.5767246",
"0.5702269",
"0.5685611",
"0.56719285",
"0.56719285",
"0.5670935",
"0.5660645",
"0.56290805",
"0.5619688",
"0.5610569",
"0.5610569",
"0.5579394",
"0.5572902",
"0.55696183",
"0.5552509"... | 0.6804895 | 0 |
Test that a headless formatter doesn't display headers | def test_headless_tabulate_format():
formatter = TabularOutputFormatter(format_name="minimal")
headers = ["text", "numeric"]
data = [["a"], ["b"], ["c"]]
expected = "a\nb\nc"
assert expected == "\n".join(
TabularOutputFormatter().format_output(
iter(data),
headers,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_headers(self):\n msg = self.shortDescription()\n self.assertTrue(False, msg=msg)\n pass",
"def test_raw_empty(self):\n self.assertRaisesHeaderError([''])",
"def test_header_constructor_without_separator(self):\n\n expected = False\n actual = self.file_instance... | [
"0.63604164",
"0.63151926",
"0.6163514",
"0.6104256",
"0.6095177",
"0.60750955",
"0.6004281",
"0.60040116",
"0.586322",
"0.5856205",
"0.5847177",
"0.5778657",
"0.57778144",
"0.5774725",
"0.57422394",
"0.5724278",
"0.572363",
"0.5721617",
"0.5695007",
"0.56886226",
"0.5687411"... | 0.68265456 | 0 |
Test that TabularOutputFormatter rejects unknown formats. | def test_unsupported_format():
formatter = TabularOutputFormatter()
with pytest.raises(ValueError):
formatter.format_name = "foobar"
with pytest.raises(ValueError):
formatter.format_output((), (), format_name="foobar") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_all_text_type(extra_kwargs):\n data = [[1, \"\", None, Decimal(2)]]\n headers = [\"col1\", \"col2\", \"col3\", \"col4\"]\n output_formatter = TabularOutputFormatter()\n for format_name in output_formatter.supported_formats:\n for row in output_formatter.format_output(\n iter(... | [
"0.70976675",
"0.6928261",
"0.6896788",
"0.68242085",
"0.6706267",
"0.6496966",
"0.6446614",
"0.64220536",
"0.63867015",
"0.63490313",
"0.63261265",
"0.6246182",
"0.62458897",
"0.6236886",
"0.6201243",
"0.6187324",
"0.61603105",
"0.6087869",
"0.6058924",
"0.6046744",
"0.60211... | 0.8258656 | 0 |
Test that ANSI escape codes work with tabulate. | def test_tabulate_ansi_escape_in_default_value():
data = [["1", None], ["2", "Sam"], ["3", "Joe"]]
headers = ["id", "name"]
styled = format_output(
iter(data),
headers,
format_name="psql",
missing_value="\x1b[38;5;10mNULL\x1b[39m",
)
unstyled = format_output(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_asciitable_m_pretty_ansi(self):\n input = '''\n┏━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓ \n┃\\x1b[1m \\x1b[0m\\x1b[1mReleased \\x1b[0m\\x1b[1m \\x1b[0m┃\\x1b[1m \\x1b[0m\\x1b[1mTitle \\x1b[0m\\x1b[1m \\x1b[0... | [
"0.70575464",
"0.653272",
"0.6358273",
"0.6196326",
"0.60648966",
"0.58987457",
"0.58536655",
"0.58270675",
"0.5749906",
"0.5715439",
"0.5708848",
"0.5671626",
"0.56693846",
"0.56251574",
"0.55986124",
"0.5450305",
"0.544031",
"0.540491",
"0.5401781",
"0.53985673",
"0.5381614... | 0.71552247 | 0 |
Test that _get_type returns the expected type. | def test_get_type():
formatter = TabularOutputFormatter()
tests = (
(1, int),
(2.0, float),
(b"binary", binary_type),
("text", text_type),
(None, type(None)),
((), text_type),
)
for value, data_type in tests:
assert data_type is formatter._get_ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testTheType(self, theTestType):\n \n pass",
"def test_get_types(self):\n pass",
"def test_type_error(self):\n self._error_test(TypeError)",
"def test_type(self):\n return self._test_type",
"def check_type(self):\n return True",
"def test_expected_type(val, exp_type):... | [
"0.7581937",
"0.74386394",
"0.71448725",
"0.7063024",
"0.689651",
"0.6880583",
"0.6850508",
"0.68018067",
"0.67980486",
"0.67575514",
"0.67144805",
"0.6710216",
"0.67087543",
"0.6700503",
"0.6680118",
"0.6680118",
"0.6680118",
"0.6680118",
"0.6680118",
"0.6680118",
"0.6680118... | 0.6922414 | 4 |
Test that provided column types are passed to preprocessors. | def test_provide_column_types():
expected_column_types = (bool, float)
data = ((1, 1.0), (0, 2))
headers = ("a", "b")
def preprocessor(data, headers, column_types=(), **_):
assert expected_column_types == column_types
return data, headers
format_output(
data,
header... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_type_in_col(arch, **kwargs):\n return all(\n attrib.isdigit()\n for attrib in arch.xpath('//@col')\n )",
"def _column_type(strings, has_invisible=True, numparse=True):\n types = [_type(s, has_invisible, numparse) for s in strings]\n return reduce(_more_generic, types, bool)",
... | [
"0.69267917",
"0.68872726",
"0.65001106",
"0.61542696",
"0.60413736",
"0.5988151",
"0.59039944",
"0.5828359",
"0.5757172",
"0.5706538",
"0.5698194",
"0.56468266",
"0.564525",
"0.564525",
"0.5624118",
"0.56221634",
"0.5595887",
"0.5567571",
"0.5535115",
"0.55180484",
"0.551586... | 0.7498186 | 0 |
Test that all output formatters accept iterable | def test_enforce_iterable():
formatter = TabularOutputFormatter()
loremipsum = (
"lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod".split(
" "
)
)
for format_name in formatter.supported_formats:
formatter.format_name = format_name
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _test_output_formatting_func(self, sample: Any):\n try:\n if not type(sample) == iter:\n self._formatting_func_return_types(format=sample)\n return True\n except Exception:\n raise ValueError(\n f\"formatting_func must return {self._f... | [
"0.70609593",
"0.6536862",
"0.626699",
"0.6217377",
"0.61381465",
"0.61156595",
"0.6076685",
"0.60205024",
"0.60205024",
"0.59102875",
"0.5902321",
"0.58030295",
"0.5667096",
"0.5649909",
"0.56128067",
"0.5604238",
"0.5603586",
"0.5540967",
"0.5523543",
"0.55017066",
"0.54822... | 0.83657736 | 0 |
Test the TabularOutputFormatter class. | def test_all_text_type(extra_kwargs):
data = [[1, "", None, Decimal(2)]]
headers = ["col1", "col2", "col3", "col4"]
output_formatter = TabularOutputFormatter()
for format_name in output_formatter.supported_formats:
for row in output_formatter.format_output(
iter(data), headers, forma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_tabular_output_formatter():\n headers = [\"text\", \"numeric\"]\n data = [\n [\"abc\", Decimal(1)],\n [\"defg\", Decimal(\"11.1\")],\n [\"hi\", Decimal(\"1.1\")],\n [\"Pablo\\rß\\n\", 0],\n ]\n expected = dedent(\n \"\"\"\\\n +-------+---------+\n ... | [
"0.7742016",
"0.7598825",
"0.6803152",
"0.6683861",
"0.6668478",
"0.6604555",
"0.64349806",
"0.6221877",
"0.62087774",
"0.6080011",
"0.59904414",
"0.59258485",
"0.5906039",
"0.57514274",
"0.57006407",
"0.5679148",
"0.56766784",
"0.5619825",
"0.5604824",
"0.55946857",
"0.55943... | 0.6323238 | 7 |
coroutine Open a cluster, connecting to all available hosts as specified in configuration. | async def open(cls, loop, *, aliases=None, configfile=None, **config):
cluster = cls(loop, aliases=aliases, **config)
if configfile:
cluster.config_from_file(configfile)
await cluster.establish_hosts()
return cluster | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(ctx, config):\n log.info('Opening connections...')\n remotes = []\n machs = []\n for name in ctx.config['targets'].iterkeys():\n machs.append(name)\n for t, key in ctx.config['targets'].iteritems():\n t = misc.canonicalize_hostname(t)\n log.debug('connecting to %s', ... | [
"0.67443687",
"0.6651427",
"0.64465094",
"0.63779134",
"0.62812424",
"0.6279923",
"0.6241238",
"0.6115502",
"0.59951556",
"0.5991341",
"0.5940241",
"0.5907062",
"0.58718926",
"0.58476406",
"0.58214194",
"0.5781779",
"0.5775787",
"0.5634603",
"0.5625746",
"0.5581556",
"0.55773... | 0.7019515 | 0 |
coroutine Get connection from next available host in a round robin fashion. | async def get_connection(self, hostname=None):
if not self._hosts:
await self.establish_hosts()
if hostname:
try:
host = self._hostmap[hostname]
except KeyError:
raise exception.ConfigError(
'Unknown host: {}'.format... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect(self):\n for attempt in range(1, self.num_attempts + 1):\n try:\n conn = self.rabbitmq_context.get_connection(self.timeout)\n chan = conn.channel()\n return (conn, chan)\n except AMQPError as ex:\n if attempt >= s... | [
"0.65758437",
"0.60254616",
"0.5965089",
"0.58990353",
"0.5885591",
"0.57209206",
"0.56956804",
"0.5667477",
"0.5656335",
"0.563919",
"0.5549618",
"0.5547971",
"0.55371743",
"0.55303013",
"0.55273753",
"0.55196035",
"0.5503916",
"0.5498301",
"0.5498018",
"0.54843074",
"0.5479... | 0.59024113 | 3 |
coroutine Connect to all hosts as specified in configuration. | async def establish_hosts(self):
scheme = self._config['scheme']
hosts = self._config['hosts']
port = self._config['port']
for hostname in hosts:
url = '{}://{}:{}/gremlin'.format(scheme, hostname, port)
host = await driver.GremlinServer.open(
url,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_connect(self, args):\r\n for host in self.host:\r\n client = paramiko.SSHClient()\r\n client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\r\n client.connect(host[0], username=host[1], password=host[2])\r\n self.connections.append(client)",
"def c... | [
"0.76126385",
"0.69372785",
"0.68551636",
"0.67098475",
"0.6545347",
"0.65244",
"0.6407366",
"0.63640463",
"0.6282757",
"0.61959034",
"0.6195543",
"0.61844474",
"0.6115662",
"0.61116165",
"0.60936683",
"0.60836387",
"0.60481113",
"0.60062855",
"0.59707445",
"0.5946551",
"0.59... | 0.7258675 | 1 |
Load configuration from from file. | def config_from_file(self, filename):
if filename.endswith('yml') or filename.endswith('yaml'):
self.config_from_yaml(filename)
elif filename.endswith('.json'):
self.config_from_json(filename)
else:
raise exception.ConfigurationError('Unknown config file forma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(file):\n _config.load(file)",
"def load_config(self, config_file):\n self.config = ConfigParser.ConfigParser()\n self.config.read(config_file)",
"def load_config(self):\r\n with open('config.json', 'r') as f:\r\n self.config = json.load(f)",
"def loadConf(self):\n\... | [
"0.8430217",
"0.78977937",
"0.7896458",
"0.78061134",
"0.77894324",
"0.7721845",
"0.76945454",
"0.76910096",
"0.7682791",
"0.760624",
"0.75849247",
"0.7573283",
"0.7562032",
"0.7558948",
"0.7533638",
"0.7493862",
"0.7468128",
"0.74427754",
"0.7439994",
"0.74397856",
"0.741206... | 0.746959 | 16 |
Load configuration from from YAML file. | def config_from_yaml(self, filename):
with open(filename, 'r') as f:
config = yaml.load(f)
config = self._process_config_imports(config)
self._config.update(config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_yaml(cls, file=None):\n if file is None: file = f'{rcp.base_path}cfg.yml'\n try:\n with open(file, 'r') as f:\n config = yaml.load(f, Loader=yaml.FullLoader)\n cfg.__dict__ = config\n return cfg\n except FileNotFoundError:\n p... | [
"0.79749984",
"0.7948293",
"0.7870235",
"0.7864097",
"0.7782877",
"0.7770844",
"0.7759317",
"0.7758727",
"0.77337193",
"0.77292687",
"0.7688582",
"0.7679165",
"0.76457",
"0.7640206",
"0.7639675",
"0.76378214",
"0.7629019",
"0.76260763",
"0.75758195",
"0.7562336",
"0.7479118",... | 0.78772604 | 2 |
Load configuration from from JSON file. | def config_from_json(self, filename):
with open(filename, 'r') as f:
config = json.load(f)
config = self._process_config_imports(config)
self.config.update(config) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_config(self):\r\n with open('config.json', 'r') as f:\r\n self.config = json.load(f)",
"def loadConf(self):\n\n with open(self.configFile) as f:\n self.config = json.load(f)",
"def load_config():\n global config\n\n with open(\"config.json\") as f:\n js... | [
"0.8539941",
"0.82377046",
"0.8098964",
"0.80969477",
"0.8014216",
"0.80130273",
"0.79837704",
"0.79833937",
"0.79324776",
"0.7875829",
"0.78704065",
"0.78406453",
"0.78028023",
"0.77925986",
"0.7734833",
"0.7696995",
"0.7658866",
"0.76542926",
"0.76527035",
"0.763015",
"0.76... | 0.84245086 | 1 |
Load configuration from Python module. | def config_from_module(self, module):
if isinstance(module, str):
module = importlib.import_module(module)
config = dict()
for item in dir(module):
if not item.startswith('_') and item.lower() in self.DEFAULT_CONFIG:
config[item.lower()] = getattr(module, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load():\n # get (or create) config path\n p = initialize()\n return load_config(open(p['config']))",
"def load_config(self):\n pass",
"def import_configuration(module_name, data_dir):\n\n try:\n debug(\"Attempting to load {module_name}.py from {data_dir}\",\n module_n... | [
"0.7303593",
"0.7138871",
"0.71056706",
"0.7068878",
"0.7045024",
"0.701708",
"0.6915462",
"0.68093777",
"0.6704642",
"0.6702429",
"0.66010815",
"0.6574525",
"0.65442324",
"0.6477583",
"0.64685637",
"0.6463062",
"0.64604574",
"0.6456965",
"0.64501286",
"0.6439395",
"0.6414435... | 0.6922377 | 6 |
coroutine Get a connected client. Main API method. | async def connect(self, hostname=None, aliases=None):
aliases = aliases or self._aliases
if not self._hosts:
await self.establish_hosts()
# if session:
# host = self._hosts.popleft()
# client = client.SessionedClient(host, self._loop, session,
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def client():\n\n client = Client()\n return client",
"async def get_client_async(\n client_id: str, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs\n):\n request = GetClient.create(\n client_id=client_id,\n )\n return await run_request_async(\n request, additional... | [
"0.70981216",
"0.69342744",
"0.69309705",
"0.68255496",
"0.677095",
"0.67015225",
"0.66983896",
"0.6686263",
"0.6632668",
"0.66281176",
"0.6584124",
"0.6577778",
"0.6531688",
"0.65143883",
"0.6509944",
"0.6434681",
"0.64121413",
"0.64000314",
"0.6398781",
"0.6397054",
"0.6340... | 0.0 | -1 |
coroutine Close cluster and all connected hosts. | async def close(self):
waiters = []
while self._hosts:
host = self._hosts.popleft()
waiters.append(host.close())
await asyncio.gather(*waiters, loop=self._loop)
self._closed = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n self.cluster.shutdown()",
"def close(self):\n if self.connected:\n self._close_cluster()",
"def shutdown_cluster(self):\n self.cluster.shutdown()",
"def close(self):\n for conn in self._conns:\n conn.send((self.CLOSE,()))",
"def cluster_shutdown():\n ... | [
"0.80359495",
"0.7946197",
"0.73420334",
"0.70863855",
"0.68911695",
"0.6771123",
"0.65967685",
"0.6574503",
"0.6539615",
"0.6539615",
"0.6539615",
"0.65233886",
"0.65046805",
"0.6472192",
"0.64719164",
"0.64410585",
"0.636139",
"0.6355587",
"0.63540643",
"0.632373",
"0.63053... | 0.7704905 | 2 |
Get the greatest common dividisor. | def _gcd_f(a, b):
return a if b == 0 else _gcd_f(b, a % b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def greatest_common_divisor(x: int, y: int) -> int:\n while y != 0:\n (x, y) = (y, x % y)\n return x",
"def greatest_common_divisor(a: int, b: int) -> int:\n#[SOLUTION]\n while b:\n a, b = b, a % b\n return a",
"def gcd_algo(a,b):\n i = max(a,b)\n j = min(a,b)\n\n if j == 0:\... | [
"0.76645106",
"0.74440897",
"0.70103806",
"0.70037377",
"0.6842229",
"0.68309116",
"0.6827134",
"0.6827134",
"0.6815804",
"0.6798665",
"0.67862236",
"0.6785387",
"0.6770141",
"0.6755159",
"0.66933185",
"0.66908",
"0.6687727",
"0.66838616",
"0.66838616",
"0.66838616",
"0.66838... | 0.6431989 | 64 |
Get the least common multiple. | def _lcm_f(a, b):
return int((a * b) / _gcd_f(a, b)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def least_common_multiple(number1, number2):\n return number1 * number2 // math.gcd(number1, number2)",
"def least_common_multiple2(number1, number2, number3, number4):\n return least_common_multiple((number1 * number2 // math.gcd(number1, number2)),\n (number3 * number4 // ... | [
"0.7903114",
"0.75025064",
"0.73285586",
"0.7166786",
"0.6805132",
"0.6473004",
"0.6357267",
"0.62809765",
"0.61856556",
"0.61782134",
"0.61521375",
"0.61483604",
"0.6133332",
"0.61324215",
"0.60736656",
"0.6026523",
"0.60008913",
"0.60008913",
"0.60008913",
"0.59906423",
"0.... | 0.55290264 | 75 |
For global_average_pooling, DPU will do padding to replace rectangle kernel to squre kernel. | def _get_dpu_kernel_size(kh, kw):
new_k = _lcm_f(kh, kw)
return new_k, new_k | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def avg_pool2d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\n return _pool('AVG', utils._pair, **locals())",
"def global_avg_pooling(self, x: tf.Tensor) -> tf.Tensor:\n x = tf.reduce_mean(x, [1, 2], name='pool5', keepdims=True)\n x = slim.conv2d(x, self.num_classes, [1, 1], activat... | [
"0.6771808",
"0.67420304",
"0.66497076",
"0.6578936",
"0.64375925",
"0.6418065",
"0.6361562",
"0.6351175",
"0.633016",
"0.6306614",
"0.629251",
"0.61938196",
"0.61428696",
"0.6023366",
"0.6018505",
"0.5975755",
"0.59645456",
"0.5927973",
"0.5879244",
"0.5846322",
"0.5787767",... | 0.0 | -1 |
Create a Vitis.GlobalAveragePooling2D Layer. | def __init__(self, **kwargs):
super(VitisGlobalAveragePooling2D, self).__init__(**kwargs)
self.rescale_factor = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n super(VitisAveragePooling2D, self).__init__(**kwargs)",
"def _create_globalaveragepool(cls, onnx_node, inputs, opset_version):\n data_format = onnx_node.getattr(\"data_format\", 'channels_first')\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\... | [
"0.61525106",
"0.609915",
"0.5919478",
"0.5911318",
"0.58175915",
"0.5786517",
"0.5785733",
"0.5725473",
"0.57131076",
"0.57019055",
"0.56622005",
"0.5642687",
"0.5559154",
"0.54910403",
"0.5473044",
"0.5453422",
"0.54310554",
"0.54178834",
"0.53916913",
"0.5368832",
"0.53341... | 0.6580204 | 0 |
Create a Vitis.AveragePooling2D Layer. | def __init__(self, **kwargs):
super(VitisAveragePooling2D, self).__init__(**kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n super(VitisGlobalAveragePooling2D, self).__init__(**kwargs)\n self.rescale_factor = None",
"def avg_pool2d(input, kernel_size, stride=1, padding=0, ceil_mode=False):\n return _pool('AVG', utils._pair, **locals())",
"def __init__(self, incoming, ksize=(1, 3, 3, 1), strid... | [
"0.6457442",
"0.6351592",
"0.63016933",
"0.6263064",
"0.6204219",
"0.6127676",
"0.6081943",
"0.6059515",
"0.605608",
"0.5863216",
"0.5845179",
"0.5788462",
"0.5774942",
"0.57626235",
"0.5740961",
"0.57336354",
"0.56914294",
"0.5654503",
"0.56451905",
"0.56366557",
"0.5619244"... | 0.6591949 | 0 |
Check if this average_pooling can be converted to global_average_pooling. | def _is_global_pooling(self, input_shape):
output_shape = self.compute_output_shape(input_shape).as_list()
return output_shape[1] == 1 and output_shape[2] == 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_broadcast(self, op, op_reg_manager):\n op_slices = op_reg_manager.get_op_slices(op)\n op_groups = [op_reg_manager.get_op_group(op_slice)\n for op_slice in op_slices]\n return op_handler_util.get_op_size(op) == 1 and all(op_groups)",
"def _create_globalaveragepool(cls, onnx_node, ... | [
"0.5702395",
"0.5538844",
"0.5531251",
"0.55049336",
"0.5397743",
"0.5374523",
"0.5364051",
"0.53428036",
"0.52849174",
"0.5265467",
"0.5254244",
"0.52519786",
"0.5186632",
"0.5176284",
"0.51702154",
"0.5170172",
"0.5161271",
"0.51423174",
"0.5126535",
"0.50942713",
"0.509141... | 0.73045886 | 0 |
Return any restricted teams for particualr users that our plugin may define. | def restricted_teams(self, user):
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_teams():",
"def get_available_teams(self):\n teams = self.request.user.team_set.filter(competition__is_open=True)\n if not teams.exists():\n msg = \"Can't send invites at this time. You're not\"\n msg += \" registered for any open competitions\"\n messages.e... | [
"0.6975286",
"0.68651044",
"0.6603281",
"0.6549819",
"0.6532676",
"0.6517242",
"0.6496614",
"0.648852",
"0.6457178",
"0.6403878",
"0.6360511",
"0.6280246",
"0.62778485",
"0.62211406",
"0.6210954",
"0.6171425",
"0.6165721",
"0.6151758",
"0.60374504",
"0.60309184",
"0.5981556",... | 0.83617604 | 0 |
Given a (Django) USER object, return any extra roles defined by our plugin. | def roles(self, user):
return {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_roles(user=None):\n if user is None:\n user = g.user\n return user.roles",
"def token_auth_get_user_roles(user):\n print(user)\n return user.get_roles()",
"def _listAllowedRolesAndUsers(self, user):\n result = list(user.getRoles())\n if hasattr(aq_base(... | [
"0.6987547",
"0.69320935",
"0.657485",
"0.65712994",
"0.623313",
"0.6149452",
"0.61279637",
"0.5949688",
"0.592528",
"0.5896143",
"0.5832695",
"0.58255416",
"0.58077645",
"0.5799637",
"0.5794509",
"0.57523865",
"0.5712782",
"0.57127666",
"0.56953585",
"0.5647589",
"0.5622482"... | 0.66918993 | 2 |
Test with augmentations. If rescale is False, then returned bboxes will fit the scale of imgs[0]. | def aug_test(self, imgs, img_metas, templates, proposals=None, rescale=False):
# recompute feats to save memory
#y = self.extract_feats(imgs, templates)
proposal_list = self.aug_test_rpn(self.extract_feats(imgs, templates), img_metas, self.test_cfg.rpn)
rcnn_test_cfg = self.test_cfg.rcnn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aug_test(self, imgs, img_metas, rescale=False):\n # recompute feats to save memory\n proposal_list = self.aug_test_rpn(\n self.extract_feats(imgs), img_metas, self.test_cfg.rpn)\n det_bboxes, det_labels = self.aug_test_bboxes(\n self.extract_feats(imgs), img_metas, pr... | [
"0.68419516",
"0.6574216",
"0.6549093",
"0.6481572",
"0.6396106",
"0.63814837",
"0.63660586",
"0.63358074",
"0.63159716",
"0.6262087",
"0.6254781",
"0.62417847",
"0.61867654",
"0.6185712",
"0.6176265",
"0.61736345",
"0.61701804",
"0.61697906",
"0.6157004",
"0.61568195",
"0.61... | 0.6817737 | 1 |
Read data Size of returned data expected to be in range [1..size], otherwise BrokenPipeError must be raised. Reading scope must be entered for duration of reading. | def read(self, size):
with self.reading:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self, size: int = -1) -> bytes:\n if self.size_read >= self.chunksize:\n return b''\n if size < 0:\n size = self.chunksize - self.size_read\n if size > self.chunksize - self.size_read:\n size = self.chunksize - self.size_read\n data = self.file.... | [
"0.7203594",
"0.71555114",
"0.68909967",
"0.68868846",
"0.6877114",
"0.68765837",
"0.678092",
"0.6759065",
"0.67104393",
"0.6689464",
"0.6680275",
"0.66459846",
"0.66349393",
"0.66163135",
"0.6571038",
"0.65568054",
"0.6509626",
"0.6477556",
"0.6435627",
"0.64335006",
"0.6431... | 0.686824 | 6 |
Write data Returns length of written data. Writing scope must be entered for duration of writing. | def write(self, data):
with self.writing:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_data(self, data):\n print('Wrote %d bytes' % (len(data)))",
"def _writeSomeData(self, data):\n if self.consumer is None:\n return 0\n self.consumer.write(data)\n return len(data)",
"def write(self, data):\n return 0",
"def write(self, data):\n wi... | [
"0.72757506",
"0.72544014",
"0.71922183",
"0.6731189",
"0.6619201",
"0.6602798",
"0.6471862",
"0.64083594",
"0.6364985",
"0.63516694",
"0.6344728",
"0.63193315",
"0.63137215",
"0.63096243",
"0.6309239",
"0.6277473",
"0.6271191",
"0.62258345",
"0.6195639",
"0.61901796",
"0.614... | 0.6268723 | 17 |
Flush write buffers Must hook continuation to the current flush if any or start new one. | def flush(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flush( finishing=False, callback=None ):",
"def flush(self):\n if self.index < self.bufsize:\n self.writer(\n self.linesep.join(self.read1_batch[0:self.index]),\n self.linesep.join(self.read2_batch[0:self.index]))\n else:\n self.writer(\n ... | [
"0.72197866",
"0.6825687",
"0.6762548",
"0.67556584",
"0.6626207",
"0.65444833",
"0.6481918",
"0.6443816",
"0.6437833",
"0.6389314",
"0.638791",
"0.6369492",
"0.6365876",
"0.63625133",
"0.6264878",
"0.6097336",
"0.60739243",
"0.60723567",
"0.6068778",
"0.60441273",
"0.6013682... | 0.5962441 | 32 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.