def download(self, team_id, remote_path, local_save_path, cache: FileCache = None, progress_cb=None): if cache is None: self._download(team_id, remote_path, local_save_path, progress_cb) else: file_info = self.get_info_by_path(team_id, remote_path) if file_info.hash is None: self._download(team_id, remote_path, local_save_path, progress_cb) else: cache_path = cache.check_storage_object( file_info.hash, get_file_ext(remote_path)) if cache_path is None: # file not in cache self._download(team_id, remote_path, local_save_path, progress_cb) if file_info.hash != get_file_hash(local_save_path): raise KeyError( f"Remote and local hashes are different (team id: {team_id}, file: {remote_path})" ) cache.write_object(local_save_path, file_info.hash) else: cache.read_object(file_info.hash, local_save_path) if progress_cb is not None: progress_cb(get_file_size(local_save_path))
def _convert_json_info(self, info: dict, skip_missing=True): if info is None: return None temp_ext = None field_values = [] for field_name in self.info_sequence(): if field_name == ApiField.EXT: continue if skip_missing is True: val = info.get(field_name, None) else: val = info[field_name] field_values.append(val) if field_name == ApiField.MIME: temp_ext = val.split('/')[1] field_values.append(temp_ext) for idx, field_name in enumerate(self.info_sequence()): if field_name == ApiField.NAME: cur_ext = get_file_ext(field_values[idx]).replace(".", "").lower() if not cur_ext: field_values[idx] = "{}.{}".format(field_values[idx], temp_ext) break if temp_ext == 'jpeg' and cur_ext in ['jpg', 'jpeg', 'mpo']: break if temp_ext != cur_ext: field_values[idx] = "{}.{}".format(field_values[idx], temp_ext) break return self.InfoType(*field_values)
def generate_names(base_name, count): name = sly_fs.get_file_name(base_name) ext = sly_fs.get_file_ext(base_name) names = [base_name] for idx in range(1, count): names.append('{}_{:02d}{}'.format(name, idx, ext)) return names
def gen_video_stream_name(file_name, stream_index): ''' Create name to video stream from given filename and index of stream :param file_name: str :param stream_index: int :return: str ''' return "{}_stream_{}_{}{}".format(get_file_name(file_name), stream_index, rand_str(5), get_file_ext(file_name))
def _get_free_name(exist_check_fn, name): res_title = name suffix = 1 name_without_ext = get_file_name(name) ext = get_file_ext(name) while exist_check_fn(res_title): res_title = '{}_{:03d}{}'.format(name_without_ext, suffix, ext) suffix += 1 return res_title
def generate_free_name(used_names, possible_name, with_ext=False): res_name = possible_name new_suffix = 1 while res_name in set(used_names): if with_ext is True: res_name = '{}_{:02d}{}'.format( sly_fs.get_file_name(possible_name), new_suffix, sly_fs.get_file_ext(possible_name)) else: res_name = '{}_{:02d}'.format(possible_name, new_suffix) new_suffix += 1 return res_name
def load_font(font_file_name: str, font_size: int = 12) -> ImageFont.FreeTypeFont: """ Set global font true-type for drawing. Args: font_file_name: name of font file (example: 'DejaVuSansMono.ttf') font_size: selected font size Returns: loaded from file font """ if get_file_ext(font_file_name) == FONT_EXTENSION: font_path = _get_font_path_by_name(font_file_name) if (font_path is not None) and file_exists(font_path): return ImageFont.truetype(font_path, font_size, encoding='utf-8') else: raise ValueError( 'Font file "{}" not found in system paths. Try to set another font.'.format(font_file_name)) else: raise ValueError('Supported only TrueType fonts!')
def get_free_name(self, team_id, path): directory = Path(path).parent name = get_file_name(path) ext = get_file_ext(path) res_name = name suffix = 0 def _combine(suffix: int = None): res = "{}/{}".format(directory, res_name) if suffix is not None: res += "_{:03d}".format(suffix) if ext: res += "{}".format(ext) return res res_path = _combine() while self.exists(team_id, res_path): res_path = _combine(suffix) suffix += 1 return res_path
def create_img_infos(project_fs): tag_id_map = { tag["name"]: tag["id"] for tag in project_fs.meta.tag_metas.to_json() } images_infos = [] for dataset_fs in project_fs: img_info_dir = os.path.join(dataset_fs.directory, "img_info") mkdir(img_info_dir) for idx, item_name in enumerate(os.listdir(dataset_fs.item_dir)): item_ext = get_file_ext(item_name).lstrip(".") item_path = os.path.join(dataset_fs.item_dir, item_name) item = sly.image.read(item_path) h, w = item.shape[:2] item_size = os.path.getsize(item_path) created_at = datetime.fromtimestamp( os.stat(item_path).st_ctime, tz=timezone.utc).strftime("%d-%m-%Y %H:%M:%S") modified_at = datetime.fromtimestamp( os.stat(item_path).st_mtime, tz=timezone.utc).strftime("%d-%m-%Y %H:%M:%S") item_ann_path = os.path.join(dataset_fs.ann_dir, f"{item_name}.json") ann_json = load_json_file(item_ann_path) ann = sly.Annotation.from_json(ann_json, project_fs.meta) tags = ann.img_tags tags_json = tags.to_json() labels_count = len(ann.labels) tags_img_info = [] for tag in tags_json: tag_info = { "entityId": None, "tagId": tag_id_map[tag["name"]], "id": None, "labelerLogin": tag["labelerLogin"], "createdAt": tag["createdAt"], "updatedAt": tag["updatedAt"], "name": tag["name"] } tags_img_info.append(tag_info) item_img_info = { "id": idx, "name": item_name, "link": "", "hash": "", "mime": f"image/{item_ext}", "ext": item_ext, "size": item_size, "width": w, "height": h, "labels_count": labels_count, "dataset_id": dataset_fs.name, "created_at": created_at, "updated_at": modified_at, "meta": {}, "path_original": "", "full_storage_url": "", "tags": tags_img_info } save_path = os.path.join(img_info_dir, f"{item_name}.json") dump_json_file(item_img_info, save_path) images_infos.append(item_img_info) return images_infos
parser = argparse.ArgumentParser(description='Inference REST client for standalone Supervisely models.') parser.add_argument('--server-url', required=True) parser.add_argument('--request-type', required=True, choices=SUPPORTED_REQUEST_TYPES) parser.add_argument('--in-image', default='') parser.add_argument('--out-json', default='') args = parser.parse_args() request_url = args.server_url + '/' + MODEL + '/' + args.request_type response_json = None if args.request_type == GET_OUTPUT_META: response = requests.post(request_url) elif args.request_type == INFERENCE: with open(args.in_image, 'rb') as fin: img_bytes = fin.read() img_ext = sly_fs.get_file_ext(args.in_image) encoder = MultipartEncoder({IMAGE: (args.in_image, io.BytesIO(img_bytes), 'application/octet-stream')}) response = requests.post(request_url, data=encoder, headers={'Content-Type': encoder.content_type}) else: raise ValueError( 'Unknown model request type: {!r}. Only the following request types are supported: {!r}.'.format( args.request_type, SUPPORTED_REQUEST_TYPES)) response.raise_for_status() response_str = json.dumps(response.json(), indent=4, sort_keys=True) if args.out_json: with open(args.out_json, 'w') as fout: fout.write(response_str) else: print(response_str)
def img_to_hash(item): img, name = item[0], item[1] return sly_image.get_hash(img, get_file_ext(name))
def img_to_bytes_stream(item): img, name = item[0], item[1] img_bytes = sly_image.write_bytes(img, get_file_ext(name)) return io.BytesIO(img_bytes)
def _get_suffix(self, path): return sly_fs.get_file_ext(path)