def __str__(self): if self.file_name is not None: s = "{}\n".format(os.path.split(self.file_name)[1]) else: s = self.ext if self.datetime: # type: datetime.datetime s += "Datetime in metadata: {}\n".format( self.datetime.strftime("%c")) if not datetime_roughly_equal(self.datetime, self.fs_datetime): s += "Differs from datetime on file system: {}\n".format( self.fs_datetime.strftime("%c")) else: s += "Datetime on file system: {}\n".format( self.fs_datetime.strftime("%c")) s += "Disk cache after metadata read:\n[{}]\n".format(self.in_memory) if self.minimum_read_size_in_bytes_datetime is not None: s += "Minimum read size to extract datetime: {} of {}\n".format( format_size_for_user(self.minimum_read_size_in_bytes_datetime), format_size_for_user(self.file_size), ) if self.minimum_read_size_in_bytes_thumbnail: s += "Minimum read size to extract thumbnail: {} of {}\n".format( format_size_for_user( self.minimum_read_size_in_bytes_thumbnail), format_size_for_user(self.file_size), ) if self.minimum_metadata_read_size_in_bytes_all is not None: s += "Minimum read size to extract variety of tags: {}\n".format( format_size_for_user( self.minimum_metadata_read_size_in_bytes_all)) else: s += "Could not extract variety of tags with minimal read\n" return s
def __init__(self, parent=None, bytes_downloaded: int=0, download_size: int=0) -> None: super().__init__(parent) self.rapidApp = parent # type: 'RapidWindow' self.setModal(True) self.setSizeGripEnabled(False) self.download_size_display = format_size_for_user(download_size, zero_string='0 KB') bytes_downloaded_display = format_size_for_user(bytes_downloaded, zero_string='0 KB') # Translators: shows how much of a file has been downloaded e.g 123 KB of 1.3 MB # Translators: %(variable)s represents Python code, not a plural of the term # variable. You must keep the %(variable)s untranslated, or the program will # crash. self.text = _('%(downloaded)s of %(total)s') self.message = QLabel( self.text % dict(downloaded=bytes_downloaded_display, total=self.download_size_display) ) self.progressBar = QProgressBar() self.progressBar.setMinimumWidth(standardProgressBarWidth()) self.progressBar.setMaximum(download_size) self.progressBar.setValue(bytes_downloaded) buttonBox = QDialogButtonBox(QDialogButtonBox.Cancel) translateDialogBoxButtons(buttonBox) buttonBox.rejected.connect(self.reject) grid = QGridLayout() grid.addWidget(self.message, 0, 0, 1, 2) grid.addWidget(self.progressBar, 1, 0, 1, 2) grid.addWidget(buttonBox, 2, 0, 1, 2) self.setLayout(grid) self.setWindowTitle(_('Downloading...'))
def dump_camera_details() -> None: import itertools context = gp.Context() cameras = autodetect_cameras(context) for model, port in cameras: is_mtp_device = camera_is_mtp_device(camera_port=port) c = Camera( model=model, port=port, is_mtp_device=is_mtp_device, context=context, ) if not c.camera_initialized: logging.error("Camera %s could not be initialized", model) else: print() print(c.display_name) print("=" * len(c.display_name)) print(f"\nMTP: {is_mtp_device}") print() if not c.specific_folder_located: print("Specific folder was not located") else: print( "Specific folders:", ", ".join(itertools.chain.from_iterable( c.specific_folders)), ) print("Can fetch thumbnails:", c.can_fetch_thumbnails) sc = c.get_storage_media_capacity() if not sc: print("Unable to determine storage media capacity") else: title = "Storage capacity" print("\n{}\n{}".format(title, "-" * len(title))) for ss in sc: print("\nPath: {}\nCapacity: {}\nFree {}".format( ss.path, format_size_for_user(ss.bytes_total), format_size_for_user(ss.bytes_free), )) sd = c.get_storage_descriptions() if not sd: print("Unable to determine storage descriptions") else: title = "Storage description(s)" print("\n{}\n{}".format(title, "-" * len(title))) for ss in sd: print("\n{}".format(ss)) c.free_camera()
def updateProgress(self, bytes_downloaded: int) -> None: bytes_downloaded_display = format_size_for_user(bytes_downloaded, zero_string="0 KB") self.message.setText(self.text % dict(downloaded=bytes_downloaded_display, total=self.download_size_display)) self.progressBar.setValue(bytes_downloaded)
def analyze_videos(videos: List[VideoAttributes], verbose: bool) -> None: size_by_extension = defaultdict(list) datetime_read = defaultdict(list) thumbnail_extract = defaultdict(list) variety_read = defaultdict(list) variety_read_raw = defaultdict(list) for va in videos: print("%s" % va) size_by_extension[va.ext].append(va.bytes_cached) total = format_size_for_user(va.file_size) if va.minimum_read_size_in_bytes_datetime is not None: # size = format_size_for_user(va.minimum_read_size_in_bytes_datetime) # datetime_read[va.ext].append('{} of {}'.format(size, total)) datetime_read[va.ext].append( va.minimum_read_size_in_bytes_datetime) if va.minimum_read_size_in_bytes_thumbnail is not None: # size = format_size_for_user(va.minimum_read_size_in_bytes_thumbnail) # thumbnail_extract[va.ext].append('{} of {}'.format(size, total)) thumbnail_extract[va.ext].append( va.minimum_read_size_in_bytes_thumbnail) if va.minimum_metadata_read_size_in_bytes_all is not None: # size = format_size_for_user(va.minimum_metadata_read_size_in_bytes_all) # variety_read[va.ext].append('{} of {}'.format(size, total)) variety_read_raw[va.ext].append( va.minimum_metadata_read_size_in_bytes_all) exts = list(size_by_extension.keys()) exts.sort() print("\nKB cached after date time extraction:") for ext in exts: print(ext, Counter(size_by_extension[ext]).most_common()) exts = list(thumbnail_extract.keys()) exts.sort() print("\nThumbnail extract:") for ext in exts: print(ext, Counter(thumbnail_extract[ext]).most_common()) exts = list(datetime_read.keys()) exts.sort() print("\nDate time read:") for ext in exts: print(ext, Counter(datetime_read[ext]).most_common()) exts = list(variety_read.keys()) exts.sort() print("\nVariety of tags read:") for ext in exts: print(ext, Counter(variety_read[ext]).most_common()) m = max(variety_read_raw[ext]) print(ext, "max + 20% (bytes):", round(int(m) * 1.2)) print() if verbose: for va in videos: print(va)
def setDownloadSize(self, download_size: int) -> None: self.download_size_display = format_size_for_user(download_size, zero_string="0 KB") self.progressBar.setMaximum(download_size)
def __str__(self): s = "" if self.model is not None: s += "{}\n".format(self.model) elif self.file_name is not None: s += "{}\n".format(os.path.split(self.file_name)[1]) if self.width is not None: s += "{}x{}\n".format(self.width, self.height) if self.datetime: # type: datetime.datetime s += "{}\n".format(self.datetime.strftime("%c")) if self.iso: s += "ISO: {}\n".format(self.iso) if self.orientation is not None: s += "Orientation: {}\n".format(self.orientation) if self.has_gps: s += "Has GPS tag: True\n" if self.has_exif_thumbnail: s += "Exif thumbnail: {}\n".format(self.exif_thumbnail_details) if self.preview_source is not None: s += self.show_preview_source() if self.exif_thumbnail_and_preview_identical == False: # Check against False as value is one of None, True or # False s += "Exif thumbnail differs from smallest preview\n" if self.preview_size_and_types: s += "All preview images: {}\n".format(self.preview_size_and_types) if self.in_memory is not None: s += "Disk cache after exif read:\n[{}]\n".format(self.in_memory) if self.in_memory is not None and self.in_memory_post_thumb is not None: if self.in_memory != self.in_memory_post_thumb: s += "Disk cache after thumbnail / preview extraction:\n[{}]\n".format( self.in_memory_post_thumb) if self.bytes_cached is not None and self.bytes_cached_post_thumb is not None: if self.bytes_cached == self.bytes_cached_post_thumb: s += "Cached: {:,}KB of {:,}KB\n".format( self.bytes_cached, self.total) else: s += "Cached: {:,}KB(+{:,}KB after extraction) of {:,}KB\n".format( self.bytes_cached, self.bytes_cached_post_thumb, self.total) if self.minimum_exif_read_size_in_bytes_thumbnail is not None: s += "Minimum read size for thumbnail or first preview: {}\n".format( format_size_for_user( self.minimum_exif_read_size_in_bytes_thumbnail)) if self.minimum_exif_read_size_in_bytes_orientation is not None: s += "Minimum read size to extract orientation tag: {}\n".format( format_size_for_user( self.minimum_exif_read_size_in_bytes_orientation)) if (self.minimum_exif_read_size_in_bytes_orientation is None and self.orientation is not None and not self.analyze_previews): s += "Could not extract orientation tag with minimal read\n" if self.minimum_exif_read_size_in_bytes_datetime is not None: s += "Minimum read size to extract datetime tag: {}\n".format( format_size_for_user( self.minimum_exif_read_size_in_bytes_datetime)) if (self.minimum_exif_read_size_in_bytes_datetime is None and self.datetime is not None and not self.analyze_previews): s += "Could not extract datetime tag with minimal read\n" if self.minimum_metadata_read_size_in_bytes_all is not None: s += "Minimum read size to extract variety of tags: {}\n".format( format_size_for_user( self.minimum_metadata_read_size_in_bytes_all)) elif self.in_memory is not None: s += "Could not extract variety of tags with minimal read\n" return s
def analyze_photos(photos: List[PhotoAttributes], verbose: bool, analyze_previews: bool) -> None: if analyze_previews: previews_by_extension = defaultdict(list) for pa in photos: # type: PhotoAttributes previews_by_extension[pa.ext].append( (pa.preview_size_and_types, pa.has_exif_thumbnail)) exts = list(previews_by_extension.keys()) exts.sort() print("\nImage previews:") for ext in exts: print(ext, Counter(previews_by_extension[ext]).most_common()) print() if verbose: print() for pa in photos: print(pa) return size_by_extension = defaultdict(list) orientation_read = defaultdict(list) datetime_read = defaultdict(list) variety_read = defaultdict(list) thumbnail_read = defaultdict(list) for pa in photos: # type: PhotoAttributes size_by_extension[pa.ext].append(pa.bytes_cached_post_thumb) if pa.minimum_exif_read_size_in_bytes_orientation is not None: orientation_read[pa.ext].append( pa.minimum_exif_read_size_in_bytes_orientation) if pa.minimum_exif_read_size_in_bytes_datetime is not None: datetime_read[pa.ext].append( pa.minimum_exif_read_size_in_bytes_datetime) if pa.minimum_metadata_read_size_in_bytes_all is not None: variety_read[pa.ext].append( pa.minimum_metadata_read_size_in_bytes_all) if pa.minimum_exif_read_size_in_bytes_thumbnail is not None: thumbnail_read[pa.ext].append( pa.minimum_exif_read_size_in_bytes_thumbnail) exts = list(size_by_extension.keys()) exts.sort() print("\nKB cached after thumbnail extraction:") for ext in exts: print(ext, Counter(size_by_extension[ext]).most_common()) exts = list(thumbnail_read.keys()) exts.sort() print("\nThumbnail or preview read:") for ext in exts: print(ext, Counter(thumbnail_read[ext]).most_common()) m = max(thumbnail_read[ext]) max_bytes = round(int(m) * 1.2) print( ext, "max ({}) + 20%: {} {}".format(m, max_bytes, format_size_for_user(max_bytes)), ) exts = list(orientation_read.keys()) exts.sort() print("\nOrientation tag read:") for ext in exts: print(ext, Counter(orientation_read[ext]).most_common()) exts = list(datetime_read.keys()) exts.sort() print("\nDate time tag read:") for ext in exts: print(ext, Counter(datetime_read[ext]).most_common()) exts = list(variety_read.keys()) exts.sort() print("\nVariety of tags read:") for ext in exts: print(ext, Counter(variety_read[ext]).most_common()) m = max(variety_read[ext]) print(ext, "max + 20%:", round(int(m) * 1.2)) print() if verbose: for pa in photos: print(pa) file_formats = FileFormatSQL() for pa in photos: # type: PhotoAttributes file_formats.add_format(pa)
def make_body_details( bytes_total: int, bytes_free: int, files_to_display: DisplayingFilesOfType, marked: FileTypeCounter, photos_size_to_download: int, videos_size_to_download: int, ) -> BodyDetails: """ Gather the details to render for destination storage usage for photo and video downloads, and their backups. :param bytes_total: :param bytes_free: :param files_to_display: :param marked: :param photos_size_to_download: :param videos_size_to_download: :return: """ bytes_total_text = format_size_for_user(bytes_total, no_decimals=0) existing_bytes = bytes_total - bytes_free existing_size = format_size_for_user(existing_bytes) photos = videos = photos_size = videos_size = "" if files_to_display != DisplayingFilesOfType.videos: # Translators: %(variable)s represents Python code, not a plural of the term # variable. You must keep the %(variable)s untranslated, or the program will # crash. photos = _("%(no_photos)s Photos") % { "no_photos": thousands(marked[FileType.photo]) } photos_size = format_size_for_user(photos_size_to_download) if files_to_display != DisplayingFilesOfType.photos: # Translators: %(variable)s represents Python code, not a plural of the term # variable. You must keep the %(variable)s untranslated, or the program will # crash. videos = _("%(no_videos)s Videos") % { "no_videos": thousands(marked[FileType.video]) } videos_size = format_size_for_user(videos_size_to_download) size_to_download = photos_size_to_download + videos_size_to_download comp1_file_size_sum = photos_size_to_download comp2_file_size_sum = videos_size_to_download comp3_file_size_sum = existing_bytes comp1_text = photos comp2_text = videos comp3_text = _("Used") comp4_text = _("Excess") comp1_size_text = photos_size comp2_size_text = videos_size comp3_size_text = existing_size bytes_to_use = size_to_download + existing_bytes percent_used = "" if bytes_total == 0: bytes_free_of_total = _("Device size unknown") comp4_file_size_sum = 0 comp4_size_text = 0 comp3_size_text = 0 elif bytes_to_use > bytes_total: bytes_total_ = bytes_total bytes_total = bytes_to_use excess_bytes = bytes_to_use - bytes_total_ comp4_file_size_sum = excess_bytes comp4_size_text = format_size_for_user(excess_bytes) # Translators: %(variable)s represents Python code, not a plural of the term # variable. You must keep the %(variable)s untranslated, or the program will # crash. bytes_free_of_total = _("No space free on %(size_total)s device" ) % dict(size_total=bytes_total_text) else: comp4_file_size_sum = 0 comp4_size_text = 0 bytes_free = bytes_total - bytes_to_use # Translators: %(variable)s represents Python code, not a plural of the term # variable. You must keep the %(variable)s untranslated, or the program will # crash. bytes_free_of_total = _("%(size_free)s free of %(size_total)s") % dict( size_free=format_size_for_user(bytes_free, no_decimals=1), size_total=bytes_total_text, ) return BodyDetails( bytes_total_text=bytes_total_text, bytes_total=bytes_total, percent_used_text=percent_used, bytes_free_of_total=bytes_free_of_total, comp1_file_size_sum=comp1_file_size_sum, comp2_file_size_sum=comp2_file_size_sum, comp3_file_size_sum=comp3_file_size_sum, comp4_file_size_sum=comp4_file_size_sum, comp1_text=comp1_text, comp2_text=comp2_text, comp3_text=comp3_text, comp4_text=comp4_text, comp1_size_text=comp1_size_text, comp2_size_text=comp2_size_text, comp3_size_text=comp3_size_text, comp4_size_text=comp4_size_text, color1=QColor(CustomColors.color1.value), color2=QColor(CustomColors.color2.value), color3=QColor(CustomColors.color3.value), displaying_files_of_type=files_to_display, )