def execute(file_filter_include, file_filter_exclude): LocalLibrary.load_library('raw') # Result format is: # { # "acronym": [list of image paths], # ... # } result = {} albums_seen = {} cache = LocalLibrary.cache_raw() albums = cache['albums'] images = cache['images'] for image in images: image_name = image['name'] image_path = image['path'] if file_filter_exclude and image_name.find(file_filter_exclude) > -1: continue if file_filter_include and image_path.find(file_filter_include) < 0: continue # Need to rerun local library caching if not os.path.exists(image_path): msg = "Local library not updated. Please rerun download_local_library again" sys.exit(msg)
def upload_album_names(album_names): gphoto.init() service = GoogleService.service() LocalLibrary.load_library('jpg') for album_name in album_names: Uploader.upload_album_name(service, album_name)
def find(et, album_path_filter, file_filter_include, file_filter_exclude): LocalLibrary.load_library('raw') # Result structure is of the form: # result = { # "model name": None, # ... # } result = {} album_path_filter_leaf = None if album_path_filter: album_path_filter_leaf = os.path.basename(album_path_filter) # Walk through each file, split its file name for # comparison, and get date shot metadata cache = LocalLibrary.cache_raw() images = cache['images'] albums = cache['albums'] for image in images: image_name = image['name'] image_path = image['path'] if file_filter_exclude and image_name.find(file_filter_exclude) > -1: continue if file_filter_include and image_path.find(file_filter_include) < 0: continue if album_path_filter and not image_path.startswith(album_path_filter): continue # Get model tag value value = None try: value = et.get_tag("Model", image_path) except Exception as e: value = None # Add the value to result result[value] = None saveto_filename = "get_unique_models" if album_path_filter_leaf: saveto_filename += '_d' + album_path_filter_leaf if file_filter_include is not None: saveto_filename += '_' + file_filter_include saveto_filename += '.json' saveto = os.path.join(gphoto.cache_dir(), saveto_filename) print(f"Saving to: '{saveto}'") with open(saveto, "w") as cache_file: json.dump(result, cache_file, indent=2)
def execute(album_path_filter): LocalLibrary.load_library('raw') album_path_filter_leaf = None if album_path_filter: album_path_filter_leaf = os.path.basename(album_path_filter) # The result is going to be of the form # { # "word": none, # ... # } result = {} # hold sections of cache as local variables cache = LocalLibrary.cache_raw() albums = cache['albums'] album_paths = cache['album_paths'] images = cache['images'] image_ids = cache['image_ids'] # Loop through each album, get caption from it # if it follows standard naming convention for album in albums: # if folder is in the include list then continue # Otherwise ignore this album album_name = album['name'] album_path = album['path'] album_images = album['images'] # filter out albums if album_path_filter and not album_path.startswith(album_path_filter): continue # Get words from album name words = album_name.split(' ') for word in words: if len(word) <= 3: result[word.capitalize()] = None saveto_filename = "get_small_words_in_album_names" if album_path_filter_leaf: saveto_filename += '_d' + album_path_filter_leaf saveto_filename += '.json' saveto = os.path.join(gphoto.cache_dir(), saveto_filename) print(f"Saving to: '{saveto}'") with open(saveto, "w") as cache_file: json.dump(result, cache_file, indent=2)
def main(): gphoto.init() LocalLibrary.cache_library("p:\\pics", 'raw') LocalLibrary.save_library('raw') LocalLibrary.cache_library("d:\\picsHres", 'jpg') LocalLibrary.save_library('jpg')
def main_library_type(et, old_word, new_word, library_type): LocalLibrary.load_library(library_type) LocalLibraryMetadata.load_library_metadata(library_type) library_cache = LocalLibrary.cache(library_type) albums = library_cache.get('albums') album_paths = library_cache.get('album_paths') album_names = library_cache.get('album_names') images = library_cache.get('images') image_ids = library_cache.get('image_ids') library_metadata_cache = LocalLibraryMetadata.cache(library_type) for image_path, image_metadata in library_metadata_cache.items(): desc = image_metadata.get('Description') title = image_metadata.get('Title') if desc is None: desc = title if desc is None: continue if not type(desc) == str: continue # If misspelled word found in the images description # then try to correct it if old_word in desc: old_desc = desc new_desc = desc.replace(old_word, new_word) print(f"image='{image_path}'") print(f" old='{old_desc}'") print(f" new='{new_desc}'") mime_type = image_metadata.get('MIMEType').split('/')[0] is_video = mime_type != 'image' ImageUtils.set_caption(et, image_path, new_desc, is_video) for album in albums: album_path = album.get('path') if old_word in album_path: new_album_path = album_path.replace(old_word, new_word) print(f"album='{album_path}'") print(f" old='{album_path}'") print(f" new='{new_album_path}'") if (os.path.exists(album_path)): shutil.move(album_path, new_album_path)
def main(): gphoto.init() # Load Local picsHres jpg Library LocalLibrary.load_library('jpg') local_cache = LocalLibrary.cache_jpg() local_albums = local_cache.get('albums') local_album_paths = local_cache.get('album_paths') local_album_names = local_cache.get('album_names') local_images = local_cache.get('images') local_image_ids = local_cache.get('image_ids') # temp_result is a dict holding image name as key # and an array value of image paths temp_result = {} # Loop through each images, get their leaf names and see # if image part with this name already exists for local_image in local_images: # Add image name and path to the temp_result image_name = local_image.get('name') image_path = local_image.get('path') image_path_list = temp_result.get(image_name) if image_path_list is None: image_path_list = [image_path] temp_result[image_name] = image_path_list else: image_path_list.append(image_path) # Now remove entries for temp_result where there is only one image path result = {} found = False for image_name in temp_result: image_path_list = temp_result.get(image_name) if len(image_path_list) > 1: found = True result[image_name] = image_path_list print(f"found duplicates = {found}") # Save to cache file also if found: gphoto.save_to_file(result, "find_duplicate_local_image_names.json")
def find(): """ This method builds the cache for local raw pics folder, traverses it and find image name duplicates """ gphoto.init() LocalLibrary.cache_raw_library("p:\\pics") LocalLibrary.save_library('raw') # The dups dict holds # key: image name # list: list of image paths name_to_paths = {} # traverse the images list. For each image add its name cache = LocalLibrary.cache_raw() cache_images = cache['images'] cache_image_ids = cache['image_ids'] for image in cache_images: imagename = image['name'] imagepath = image['path'] if imagename not in name_to_paths: name_to_paths[imagename] = [imagepath] else: name_to_paths[imagename].append(imagepath) # review the dups where imagename is holding multiple image paths dups = [] for imagename, imagelist in name_to_paths.items(): if len(imagelist) > 1: dup = { 'name': imagename, 'paths': [] } paths = dup['paths'] for imagepath in imagelist: paths.append(imagepath) dups.append(dup) return dups
def map_recursive(self, root, test): """ High-level algorithm: 1. For each local folder locate the Google album in cache 2. If Google album does not exist then call 'gphotocli album upload <...path_to_album...>' - Add local images to Google Album from the Local album if missing - Remove images from Google album that are not in Local album """ # Argument validation if not os.path.exists(root): logging.error(f"Folder does not exist: ({root})") return # Remove trailing slash slash_char = root[len(root) - 1] if slash_char == '/' or slash_char == '\\': root = root[:len(root)-1] # Get Google API service service = GoogleService.service() # Initialize Google API and load cache. google_cache = GoogleLibrary.cache() google_album_ids = google_cache.get('album_ids') google_album_titles = google_cache.get('album_titles') # Load local library cache local_cache = LocalLibrary.cache('jpg') local_albums = local_cache.get('albums') # Traverse all the sub folders in the cache for local_album in local_albums: local_album_name = local_album['name'] local_album_path = local_album['path'] if not local_album_path.lower().startswith(root.lower()): continue # If album not in Google Cache, ignore and then error out google_album_id = google_album_titles.get(local_album_name) google_album = google_album_ids[google_album_id] if google_album_id is not None else None if google_album is None: logging.error(f"Ignoring album not in Google Cache: '{google_album.get('title')}'") continue # Do mapping for each Local/Google album self.map_album(local_album, google_album, test)
def upload_album_name(service, album_name): # Get album in local library by name album_cache_jpg = LocalLibrary.cache_jpg() album_names = album_cache_jpg['album_names'] if album_name not in album_names: logging.error(f"No local album found by name '{album_name}'") return local_album_idx = album_names[album_name] local_albums = album_cache_jpg['albums'] local_album = local_albums[local_album_idx] # Call common upload method Uploader.upload_album(service, local_album)
def upload_recursive(self, root, test): # Argument validation if not os.path.exists(root): logging.error(f"Folder does not exist: ({root})") return # Remove trailing slash slash_char = root[len(root) - 1] if slash_char == '/' or slash_char == '\\': root = root[:len(root) - 1] # Get Google API service service = GoogleService.service() # Initialize Google API and load cache. google_cache = GoogleLibrary.cache() google_album_ids = google_cache.get('album_ids') google_album_titles = google_cache.get('album_titles') # Traverse all the sub folders in the cache local_cache = LocalLibrary.cache('jpg') local_albums = local_cache.get('albums') for local_album in local_albums: local_album_name = local_album['name'] local_album_path = local_album['path'] if not local_album_path.lower().startswith(root.lower()): continue # Check if album already in Google Cache google_album_id = google_album_titles.get(local_album_name) google_album = google_album_ids[ google_album_id] if google_album_id is not None else None if google_album is not None: logging.info( f"Album already uploaded: '{google_album.get('title')}'") continue # Do the actual creating of Google album album_response = self.create_shareable_album( service=service, album_name=local_album_name, test=test) if album_response: self.modified = True
def map_album(self, local_album, google_album, test): logging.error(f"Mapping album: '{google_album.get('title')}'") # Initialize Google API and load cache. google_cache = GoogleLibrary.cache() google_album_ids = google_cache.get('album_ids') google_album_titles = google_cache.get('album_titles') google_image_ids = google_cache.get('image_ids') google_album_to_images = google_cache.ge_ids('album_images') # Load local library cache local_cache = LocalLibrary.cache('jpg') local_albums = local_cache.get('albums') local_images = local_cache.get('images') # local_image_ids = local_cache.get('image_ids') # Collect local images belonging to local album local_album_image_idxs = local_album.get('images') if local_album_image_idxs is None or len(local_album_image_idxs) <= 0: logging.info(f"No images found in album '{local_album.get('name')}'") return # from local album images indices, build local album image list local_album_images = {} for idx in local_album_image_idxs: local_image = local_images[idx] local_image_name = local_image.get('name') local_album_images[local_image_name] = local_image # From google album get images already in it google_album_id = google_album.get('id') google_album_to_image_ids = google_album_to_images.get(id) google_album_images = {} for google_image_id in google_album_to_image_ids: google_album_image = google_image_ids.get(google_image_id) google_album_images[google_image_id] = google_album_image
def upload_album(service, local_album): logging.info( "------------------------------------------------------------------" ) logging.info(f" album: '{local_album['path']}'") logging.info( "------------------------------------------------------------------" ) # Create the album and make it sharable # -------------------------------------- google_album = None share_info = None try: google_album = AlbumAPI.create_album(service, local_album['name']) share_info = AlbumAPI.make_album_sharable(service, google_album['id'], share=True) except Exception as e: raise google_album_id = google_album['id'] # Loop through all images under the album and upload them # -------------------------------------------------------- local_album_image_idxs = local_album['images'] local_library_cache = LocalLibrary.cache_jpg() local_images = local_library_cache['images'] for local_image_idx in local_album_image_idxs: local_image = local_images[local_image_idx] local_image_name = local_image['name'] local_image_path = local_image['path']
def execute(file_filter_include, file_filter_exclude): LocalLibrary.load_library('raw') # Result format is: # { # "acronym": [list of image paths], # ... # } result = {} albums_seen = {} cache = LocalLibrary.cache_raw() albums = cache['albums'] images = cache['images'] for image in images: image_name = image['name'] image_path = image['path'] if file_filter_exclude and image_name.find(file_filter_exclude) > -1: continue if file_filter_include and image_path.find(file_filter_include) < 0: continue # Need to rerun local library caching if not os.path.exists(image_path): msg = "Local library not updated. Please rerun download_local_library again" sys.exit(msg) # check if file name conforms to yyyymmdd_hhmmss_XXXX if len(image_name) < _FILEPREFIX_PATTERN_LEN: continue image_basename = os.path.splitext(image_name)[0] image_name_splits = image_basename.split('_') if len(image_name_splits) < 3: continue image_date = image_name_splits[0] image_time = image_name_splits[1] image_acronym = '_'.join(image_name_splits[2:]) if len(image_date) < 8 or len(image_time) < 6: continue # Get parent album album_idx = image['parent'] album = albums[album_idx] album_name = album['name'] album_path = album['path'] # if the combination of album name and acronym has already # been seen the ignore rest of the images in this album album_plus_acronym = album_name + '__' + image_acronym if album_plus_acronym in albums_seen: continue else: albums_seen[album_plus_acronym] = None # add image acronym and image_path to the result if image_acronym not in result: image_list = [image_path] result[image_acronym] = image_list else: image_list = result[image_acronym] image_list.append(image_path) # filter out acronyms where there are no duplicates final_result = {} for acronym in result.keys(): image_list = result[acronym] if len(image_list) > 1: final_result[acronym] = image_list saveto_filename = "test_dup_file_acronym" if file_filter_include is not None: saveto_filename += '_' + file_filter_include saveto_filename += '.json' saveto = os.path.join(gphoto.cache_dir(), saveto_filename) print(f"Saving to: '{saveto}'") with open(saveto, "w") as cache_file: json.dump(final_result, cache_file, indent=2)
def __init__(self): LocalLibrary.load_library('jpg') GoogleLibrary.load_library() self.modified = False
def main(): """ Given a folder tree root like p:\\pics\\2014 loop through each album and find its images in Google photos. if the images do not have albums then they can be deleted. if the images have an album then and if the album have more images that the local album images and the albums is not shared then the images can be deleted """ if len(sys.argv) < 2: logging.error("Too few arguments. Specify folder pattern") return # Get arguments arg_album_year = sys.argv[1] arg_album_pattern = f"\\{arg_album_year}\\" LocalLibrary.load_library('jpg') local_cache = LocalLibrary.cache_jpg() local_albums = local_cache.get('albums') local_album_paths = local_cache.get('album_paths') local_images = local_cache.get('images') GoogleLibrary.load_library() google_cache = GoogleLibrary.cache() google_album_ids = google_cache['album_ids'] google_album_titles = google_cache['album_titles'] google_image_ids = google_cache['image_ids'] google_image_filenames = google_cache['image_filenames'] google_album_images = google_cache['album_images'] google_image_albums = google_cache['image_albums'] result = [] # Loop through each local folder under the root tree for local_album in local_albums: local_album_path = local_album.get('path') # filter out the ones that are not under the tree if local_album_path.find(arg_album_pattern) == -1: continue # if not local_album_path.startswith(arg_album_pattern): # continue # Add this album to the list result_album = {'path': local_album.get('path')} result.append(result_album) # Get first jpeg image of the local album first_local_image = None local_album_image_idxs = local_album.get('images') for local_album_image_idx in local_album_image_idxs: local_image = local_images[local_album_image_idx] if local_image.get('mime') == 'image/jpeg': first_local_image = local_image break if first_local_image is None: result_album[ 'ERROR'] = f"No jpeg images in local album '{local_album.get('path')}'" continue result_album['first_image'] = first_local_image['name'] # Locate this image in Google photos. Identify the pattern # If the image is of the form # YYYYMMDD_hhmmss_nn_AAAA_D800.jpeg # or just the actual name # First look for the images with actual name, if not found then # Look by date time in the filename first_google_image_id, pattern_found = find_google_image( first_local_image, google_image_ids, google_image_filenames) if first_google_image_id is None: result_album[ 'WARNING'] = f"First album image not in Google {first_local_image.get('name')}" continue first_google_image = google_image_ids.get(first_google_image_id) result_album['first_google_image'] = { 'id': first_google_image.get('id'), 'filename': first_google_image.get('filename'), 'mine': first_google_image.get('mine'), 'productUrl': first_google_image.get('productUrl') } # if the first image part of google album then # we need to know if the image is part of a shared album google_image_album_list = google_image_albums.get( first_google_image_id) if google_image_album_list is None or len( google_image_album_list) <= 0: result_album['NO-GOOGLE-ALBUM'] = True else: result_image_albums = [] result_album['HAS-ALBUMS'] = result_image_albums for google_image_album_id in google_image_album_list: google_album = google_album_ids.get(google_image_album_id) result_image_albums.append({ 'id': google_album.get('id'), 'title': google_album.get('title'), 'productUrl': google_album.get('productUrl'), 'shared': google_album.get('shared') }) gphoto.save_to_file(result, f"can_google_images_be_deleted_{arg_album_year}.json")
def check_album_readiness(et, album_path_filter_year, file_filter_include, file_filter_exclude, test_missing_date_shot, test_bad_date_shot, test_filename_FMT, test_Tag_mismatch, test_missing_caption, test_unique_caption, test_missing_caption_year, test_missing_geotags): """ Images should follow the format: YYYYMMMDD_HHmmSS.... If it does not follow this format then that is and indication that the file name does not match date shot The result is of the form { "album_path": { "reason value": [list of image paths], ... }, ... } """ print(f"-------------------- args --------------------------") print(f"album_path_filter_pattern = {album_path_filter_year}") print(f"file_filter_include = {file_filter_include}") print(f"file_filter_exclude = {file_filter_exclude}") print(f"test_missing_date_shot = {test_missing_date_shot}") print(f"test_bad_date_shot = {test_bad_date_shot}") print(f"test_filename_FMT = {test_filename_FMT}") print(f"test_Tag_mismatch = {test_Tag_mismatch}") print(f"test_missing_caption = {test_missing_caption}") print(f"test_unique_caption = {test_unique_caption}") print(f"test_missing_caption_year = {test_missing_caption_year}") print(f"test_missing_geotags = {test_missing_geotags}") print(f"----------------------------------------------------") unique_caption_reason = "non-unique-captions" mismatch_album_image_caption_reason = "mismatch-album-image-captions" missing_geotags_reason = "missing-geotags" LocalLibrary.load_library('raw') result = {} album_path_filter_pattern = f"\\{album_path_filter_year}\\" print(f"album_path_filter_pattern = {album_path_filter_pattern}") # Walk through each file, split its file name for # comparison, and get date shot metadata cache = LocalLibrary.cache_raw() images = cache.get('images') albums = cache.get('albums') for album in albums: album_name = album['name'] album_path = album['path'] if album_path_filter_pattern and album_path.find( album_path_filter_pattern) < 0: continue album_splits = album_name.split(' ') album_year = album_splits[0].split('-')[0] album_caption = album_year + ' ' + ' '.join(album_splits[1:]) # print(f"album_caption = {album_caption}") # Album level results captured here # Duplicate captions table. Every caption of images # is hashed here unique_caption_dict = {} album_images = album['images'] for image_idx in album_images: image = images[image_idx] image_name = image['name'] image_path = image['path'] if file_filter_exclude and image_name.find( file_filter_exclude) > -1: continue if file_filter_include and image_path.find( file_filter_include) < 0: continue image_ext = ImageUtils.get_file_extension(image_name) is_video = ImageUtils.is_ext_video(image_ext) # Need to rerun local library caching if not os.path.exists(image_path): msg = "Local library not updated. Please rerun download_local_library again" print(msg) sys.exit(msg) # Nothing is mismatched yet # Each test returns a result as tuple with 3 values: # ("name of the test", True|False if test failed, "extra info") mismatched = False test_results = [] # if image date shot does not match images name # then add it to the mismatched list. For PNG use PNG:CreationTime tag = None if test_missing_date_shot: tag = et.get_tag("Exif:DateTimeOriginal", image_path) if tag is None or len(tag) <= 0: tag = et.get_tag("Exif:CreateDate", image_path) if tag is None or len(tag) <= 0: tag = et.get_tag("QuickTime:CreateDate", image_path) if tag is None or len(tag) <= 0: mismatched = True test_results.append("missing-date-shot") tagsplit = None if test_missing_date_shot and test_bad_date_shot and not mismatched: tagsplit = tag.split(' ') if len(tagsplit) < 2: mismatched = True test_results.append(("bad-date-shot", tag)) # If image does not follow correct pattern # Then add it to album list mismatched_filename_format = False if test_filename_FMT: if len(image_name) < _IMAGE_PATTERN_LEN: mismatched = True mismatched_filename_format = True test_results.append("filename-FMT") filedatetime = None if test_filename_FMT and not mismatched_filename_format: filedatetime = image_name.split('_') if len(filedatetime) < 2: mismatched = True mismatched_filename_format = True test_results.append("filename-FMT") if test_Tag_mismatch and not mismatched_filename_format: file_date = filedatetime[0] file_time = filedatetime[1][0:3] tag_date = ''.join(tagsplit[0].split(':')) tag_time = ''.join(tagsplit[1].split(':'))[0:3] if tag_date != file_date or tag_time != file_time: mismatched = True test_results.append(("tag-mismatch", tag)) # Check missing Caption: check if any of the tags have any value caption = None if test_missing_caption: caption = ImageUtils.get_caption(et, image_path, is_video) if caption is None or len(caption) <= 0: mismatched = True test_results.append("missing-caption") elif test_unique_caption: year = None if len(caption) > 4: year = caption[0:4] if not year.isdecimal(): unique_caption_dict[caption] = None # Check missing Caption year if test_missing_caption_year and caption is not None: if not test_missing_caption: caption = ImageUtils.get_caption(et, image_path, is_video) if not test_missing_caption and (caption is None or len(caption) <= 0): mismatched = True test_results.append("missing-caption") elif not test_missing_caption and len(caption) < 5: mismatched = True test_results.append("missing-caption") else: caption_year = caption[0:4] if not caption_year.isdecimal(): mismatched = True test_results.append(("missing-caption-year", caption)) # If caption has full date then report it if caption is not None and len(caption) > 11: caption_year = caption[0:4] first_dash = caption[4] second_dash = caption[7] if caption_year.isdecimal( ) and first_dash == '-' and second_dash == '-': mismatched = True test_results.append(("full-date-prefix", caption)) # If caption different from album then report it if caption is not None and caption != album_caption: unique_caption_dict[caption] = None # Test missing geotags if test_missing_geotags and not is_video: geotags = None try: geotags = et.get_tags([ "GPSLatitude", "GPSLongitude", "GPSLatitudeRef", "GPSLongitudeRef" ], image_path) except Exception as e: geotags = None if geotags is None or len(geotags) < 4: mismatched = True test_results.append(missing_geotags_reason) if mismatched: for test_result in test_results: mismatch_reason = None mismatch_desc = None if type(test_result) is not tuple: mismatch_reason = test_result else: mismatch_reason = test_result[0] mismatch_desc = test_result[1] reason_result = None if mismatch_reason not in result: reason_result = {} result[mismatch_reason] = reason_result else: reason_result = result[mismatch_reason] album_result = None if album_path not in reason_result: album_result = [] reason_result[album_path] = album_result else: album_result = reason_result[album_path] if type(test_result) is not tuple: album_result.append(image_path) else: album_result.append((mismatch_desc, image_path)) # add duplicate caption results if len(unique_caption_dict) > 1: unique_caption_result = None if unique_caption_reason not in result: unique_caption_result = {} result[unique_caption_reason] = unique_caption_result else: unique_caption_result = result[unique_caption_reason] unique_caption_result[album_path] = list( unique_caption_dict.keys()) # If caption is same for all images but diff from album then report it if len(unique_caption_dict) == 1: image_caption = str(next(iter(unique_caption_dict))) # Strip the month and day from the album name splits = album_name.split(' ') album_date = splits[0] album_desc = splits[1:] album_year = album_date[0:4] album_caption = album_year + ' ' + ' '.join(album_desc) if album_caption != image_caption: mismatch_album_image_caption_result = None if mismatch_album_image_caption_reason not in result: mismatch_album_image_caption_result = {} result[ mismatch_album_image_caption_reason] = mismatch_album_image_caption_result else: mismatch_album_image_caption_result = result[ mismatch_album_image_caption_reason] mismatch_album_image_caption_result[album_path] = { 'album_caption': album_caption, 'image_caption': image_caption } saveto_filename = "check_album_readiness" if album_path_filter_year: saveto_filename += '_d' + album_path_filter_year if file_filter_include is not None: saveto_filename += '_' + file_filter_include if test_missing_date_shot or test_bad_date_shot: saveto_filename += "_dtshot" if test_filename_FMT: saveto_filename += "_ffmt" if test_Tag_mismatch: saveto_filename += "_Tagmm" if test_missing_caption: saveto_filename += "_miscap" if test_unique_caption: saveto_filename += "_dupcap" saveto_filename += '.json' saveto = os.path.join(gphoto.cache_dir(), saveto_filename) print(f"Saving to: '{saveto}'") with open(saveto, "w") as cache_file: json.dump(result, cache_file, indent=2)
def main_with_exiftool(et, file_filter_pattern): """ If date shot is missing in iPhone file then get it from the filename of the format is like: "2015-02-17 19.30.28.jpg" then update the dateshot from the filename """ LocalLibrary.load_library('raw') result = {} # Walk through each file, split its file name for # comparison, and get date shot metadata cache = LocalLibrary.cache_raw() images = cache['images'] albums = cache['albums'] for image in images: image_name = image['name'] image_path = image['path'] image_ext = ImageUtils.get_file_extension(image_name) # if filter is specified and does not match to the file path # then ignore the file if file_filter_pattern and image_path.find(file_filter_pattern) < 0: continue if not os.path.exists(image_path): continue is_video = image_ext in gphoto.core.VIDEO_EXTENSIONS # If the file has dateshot then ignore it tag = None if not is_video: tag = et.get_Tag("Exif:DateTimeOriginal", image_path) else: tag = et.get_Tag("QuickTime:CreateDate", image_path) if tag is not None: continue # at this point dateshot is missing # parse the file and check for format as "2015-02-17 19.30.28.jpg" splits = image_name.split(' ') if len(splits) < 2: continue file_date = splits[0] file_time = splits[1] if file_date is None or file_time is None: continue file_date_splits = file_date.split('-') if len(file_date_splits) < 3: continue file_time_splits = file_time.split('.') if len(file_time_splits) < 4: continue dateshot = ':'.join(file_date_splits) + ' ' + ':'.join( file_time_splits[0:3]) # cmd = "\"-" + ImageUtils._TagIPTCObjectName + '=' + dateshot + '"' # cmd += "\" -" + ImageUtils._TagIPTCCaptionAbstract + '=' + dateshot + '"' # cmd += "\" -" + ImageUtils._TagExifImageDescription + '=' + dateshot + '"' # cmd += "\" -" + ImageUtils._TagXmpDescription + '=' + dateshot + '"' # ret = subprocess.run(["exiftool", f"-EXIF:DateTimeOriginal={dateshot}", "-EXIF:CreateDate={dateshot}", "-overwrite_original", "-P", image_path]) ret = None if not is_video: ret = subprocess.run([ "exiftool", f"-EXIF:DateTimeOriginal={dateshot}", "-overwrite_original", image_path ]) print(f"Image Date Set: {image_path}") else: ret = subprocess.run([ "exiftool", f"-QuickTime:CreateDate={dateshot}", "-overwrite_original", "-ext", "mov", "-ext", "mp4", image_path ]) print(f"Video Date Set: {image_path}") print(f"retcode: {ret.returncode}, {dateshot}, {image_path}")
def main(): """ Collect all the images with the date shot of the given year. Check if they follow the YYYYMMDD_HHMMDD_.... format If all follow this format then images of the whole year can be deleted in one shot. Otherwise list out the odd image months from the date shot as culprits. For each of these images see in the local folder album what to do. """ if len(sys.argv) < 2: logging.error("Too few arguments. Specify date shot year") return # Get arguments args_year = sys.argv[1] LocalLibrary.load_library('jpg') local_cache = LocalLibrary.cache_jpg() local_albums = local_cache.get('albums') local_album_paths = local_cache.get('album_paths') local_images = local_cache.get('images') GoogleLibrary.load_library() google_cache = GoogleLibrary.cache() google_album_ids = google_cache['album_ids'] google_album_titles = google_cache['album_titles'] google_image_ids = google_cache['image_ids'] google_image_filenames = google_cache['image_filenames'] google_album_images = google_cache['album_images'] google_image_albums = google_cache['image_albums'] google_images_with_missing_dateshot = [] google_images_missing_locally = [] local_images_with_non_standandard_filename = [] google_images_with_non_standandard_filename = [] google_images_with_arg_year = [] google_images_by_datetime = {} local_images_by_datetime = {} result = { 'google_images_with_missing_dateshot': google_images_with_missing_dateshot, 'google_images_missing_locally': google_images_missing_locally, 'local_images_with_non_standandard_filename': local_images_with_non_standandard_filename, 'google_images_with_non_standandard_filename': google_images_with_non_standandard_filename, 'google_images_with_arg_year': google_images_with_arg_year, 'google_images_by_datetime': google_images_by_datetime, 'local_images_by_datetime': local_images_by_datetime } # First collect all google images in the given year for google_image_id, google_image in google_image_ids.items(): mediaMetadata = google_image.get('mediaMetadata') if mediaMetadata is None: google_images_with_missing_dateshot.append(google_image) else: creationTime = mediaMetadata.get('creationTime') if creationTime is None: google_images_with_missing_dateshot.append(google_image) else: # Date shot is of the format "2021-02-15T20:29:52Z # Extract the year from it image_year = creationTime.split('-')[0] if image_year == args_year: google_images_with_arg_year.append(google_image) # If the google images does not have format YYYYMMDD_HHMMSS_... # then there is an issue for google_image in google_images_with_arg_year: filename = google_image.get('filename') splits = filename.split('_') if len(splits) < 3: google_images_with_non_standandard_filename.append(google_image) else: image_date = splits[0] image_time = splits[1] if len(image_date) < 8 or not image_date.isdecimal(): google_images_with_non_standandard_filename.append(google_image) elif len(image_time) < 6 or not image_time.isdecimal(): google_images_with_non_standandard_filename.append(google_image) else: pass # image_datetime = image_date + '_' + image_time # google_images_by_datetime[image_datetime] = { # 'filename': google_image.get('filename'), # 'productUrl': google_image.get('productUrl') # } # now make a list of all the local images in the year specified # and add them to the local_images_by_dateshot. pattern = f"\\{args_year}\\" for local_album_idx, local_album in enumerate(local_albums): album_path = local_album.get('path') if pattern not in album_path: continue album_image_idxs = local_album.get('images') for album_image_idx in album_image_idxs: local_image = local_images[album_image_idx] local_image_name = local_image.get('name') splits = local_image_name.split('_') if len(splits) < 3: local_images_with_non_standandard_filename.append(local_image.get('path')) image_date = splits[0] image_time = splits[1] if len(image_date) < 8 or not image_date.isdecimal(): local_images_with_non_standandard_filename.append(local_image.get('path')) elif len(image_time) < 6 or not image_time.isdecimal(): local_images_with_non_standandard_filename.append(local_image.get('path')) else: image_datetime = image_date + '_' + image_time local_images_by_datetime[image_datetime] = { 'filename': local_image.get('name'), 'path': local_image.get('path') } # Now traverse through all the google images with date shot # and locate them in local images # If not found then error for datetime, google_image in google_images_by_datetime.items(): local_image = local_images_by_datetime.get(datetime) if local_image is None: google_images_missing_locally.append(google_image) bn = os.path.basename(args_year) gphoto.save_to_file(result, f"can_google_images_be_deleted_by_year_{bn}.json")
def do_work(et, google_image_filter, album_folder_path, list_only): # Find folder album in the database LocalLibrary.load_library('raw') local_library_cache = LocalLibrary.cache_raw() images = local_library_cache['images'] albums = local_library_cache['albums'] album_paths = local_library_cache['album_paths'] album_idx = album_paths[album_folder_path] album = albums[album_idx] local_album_path = album['path'] print(f"[INFO]: Found album '{local_album_path}'") # Collect list of local album files local_files_results = [] local_album_images = album['images'] for image_idx in local_album_images: image = images[image_idx] image_name = image['name'] image_path = image['path'] local_files_results.append(image_path) sorted(local_files_results) util.pprint(local_files_results) print(f"[INFO] Local files count '{len(local_files_results)}'") # Collect a list of images from google photos # Each element in this list will be an object: # {'path': 'image path', 'caption': 'images caption...'} google_images_results = [] gphoto.init() GoogleImages.load_images() google_image_cache = GoogleImages.cache() google_images = google_image_cache['list'] for google_image in google_images: image_name = google_image['filename'] if image_name.find(google_image_filter) < 0: continue image_desc = google_image['description'] google_images_results.append((image_name, image_desc)) google_images_results = sorted(google_images_results, key=lambda record: record[0]) util.pprint(google_images_results) print(f"[INFO] Google files count '{len(google_images_results)}'") # Perform basic validations # If counts are not the same then error out if len(local_files_results) != len(google_images_results): print( f"[ERROR]: Count mismatch local: '{len(local_files_results)}', google: '{len(google_images_results)}'. Aborting" ) # Now loop through the list of folder images, get its # equivalent caption from the corresponding google image if list_only: return for image_idx, local_image_path in enumerate(local_files_results): desc = google_images_results[image_idx][1] # Get image extension and identify it as an image or video image_name = os.path.basename(local_image_path) image_ext = ImageUtils.get_file_extension(image_name) is_video = ImageUtils.is_ext_video(image_ext) # Set the caption now ImageUtils.set_caption(et, local_image_path, desc, is_video)
def main(): gphoto.init() # Load Google Library GoogleLibrary.load_library() google_cache = GoogleLibrary.cache() google_album_ids = google_cache['album_ids'] google_album_titles = google_cache['album_titles'] google_image_ids = google_cache['image_ids'] google_image_filenames = google_cache['image_filenames'] google_album_images = google_cache['album_images'] google_image_albums = google_cache['image_albums'] # Load Local picsHres jpg Library LocalLibrary.load_library('jpg') local_cache = LocalLibrary.cache_jpg() local_albums = local_cache.get('albums') local_album_paths = local_cache.get('album_paths') local_album_names = local_cache.get('album_names') local_images = local_cache.get('images') local_image_ids = local_cache.get('image_ids') local_image_names = local_cache.get('image_names') # Initialize the result missing_images_with_album_reason = "MISSING_IMAGES_WITH_ALBUM" missing_images_with_no_album_reason = "MISSING_IMAGES_WITH_NO_ALBUM" image_exist_locally_reason = "IMAGE_EXIST_LOCALLY" result_missing_images_with_album = {} result_missing_images_with_no_album = [] result_image_exist_locally = [] result = { missing_images_with_album_reason: result_missing_images_with_album, missing_images_with_no_album_reason: result_missing_images_with_no_album, image_exist_locally_reason: result_image_exist_locally } # Walk through each Google images that begins with PFILMmmm_nnn.jpg for google_image_id in google_image_ids: google_image = google_image_ids[google_image_id] # Ignore images not begining with "PFILM" image_name = google_image.get('filename') if image_name is not None and not image_name.startswith("PFILM"): continue # Check for image exist locally local_image_idx = local_image_names.get(image_name) if local_image_idx is not None: local_image = local_images[local_image_idx] result_image_exist_locally.append(local_image.get('path')) continue # We now know that the image is missing locally # No figure out if this images does not have an album parent google_albums_of_this_image = google_image_albums.get(google_image_id) if google_albums_of_this_image is not None: # Images does have parent albums # add first album to the result first if not already done google_album_idx = None for idx in google_albums_of_this_image: google_album_idx = idx break google_album = google_album[google_album_idx] google_album_id = google_album.get('id') result_album = result.get(google_album_id) # If album not in result then add the album missing_images_with_album = None if result_album is None: missing_images_with_album = [] result_album = { 'id': google_album_id, 'title': google_album.get('title'), 'images': missing_images_with_album } result_missing_images_with_album[google_album_id] = result_album # Add missing image to parent album result missing_images_with_album.append({ 'id': google_image_id, 'filename': image_name, 'productUrl': google_image['productUrl'] }) # Google image is missing locally and has no parent album else: result_missing_images_with_no_album.append({ 'id': google_image_id, 'filename': image_name, 'productUrl': google_image['productUrl'] }) # Save to cache file also gphoto.save_to_file(result, "can_PFILMs_be_deleted.json")