def change_event_title(pickle_path, event_index, new_title, verbose): HBFUN.verbose("Change event title", verbose) album = HBAL.load_album(pickle_path) album.change_event_title(event_index, new_title) HBAL.save_album(album, pickle_path)
def make_new_properties_list(self, verbose = False): """ make_new_properties_list: write a new csv file where you can assign title and captions to photos 20130103/RB: started the function The property list can be found in 'album_path + resources_dir + event_dir + 'props.csv''. To prevent overwriting old files with all captions, new files will always have a number appended. You have to manually change it to 'props.csv', as this file is used. """ HBFUN.verbose("HBevent/make_new_properties_list()", verbose) # get the list with photos source_list = os.listdir(self.source_path + self.event_dir_src) source_list = [n for n in source_list if n[-4:] == ".jpg"] # create a save filename prop_fn = "props" prop_ext = "txt" path_and_filename = HBFUN.file_numbering(self.album_path + self.resources_dir + self.event_dir, prop_fn, prop_ext) # write the properties csvfile = open(path_and_filename, "wb") csvwriter = csv.writer(csvfile, delimiter = ";") for i in range(len(source_list)): csvwriter.writerow([source_list[i], " ", " "]) csvfile.close()
def test_check_path_exists(): print("HBtest/test_check_path_exists()") verbose = True path = "/Users/robbert/" res = HBFun.check_path_exists(path, verbose) if res == True: print(" pass") else: print(" FAIL:", res) path = "/Users/bernard/" res = HBFun.check_path_exists(path, verbose) if res == False: print(" pass") else: print(" FAIL:", res) path = "/Users/robbert/croc_tests.py" res = HBFun.check_path_exists(path, verbose) if res == True: print(" pass") else: print(" FAIL:", res) path = "/Users/robbert/does_not_exist.py" res = HBFun.check_path_exists(path, verbose) if res == False: print(" pass") else: print(" FAIL:", res)
def test_check_path(): print("HBtest/test_check_path()") verbose = True path = "fiets" out = HBFun.check_path(path, verbose) if out == "fiets/": print(" pass") else: print(" FAIL:", out) path = "/fiets" out = HBFun.check_path(path, verbose) if out == "fiets/": print(" pass") else: print(" FAIL:", out) path = "/Users/fiets" out = HBFun.check_path(path, verbose) if out == "/Users/fiets/": print(" pass") else: print(" FAIL:", out) path = "Users/fiets" out = HBFun.check_path(path, verbose) if out == "/Users/fiets/": print(" pass") else: print(" FAIL:", out)
def add_photos(self, index, flag_new_properties_list = False, flag_redo_resize = False, flag_redo_thumbs = False, verbose = False): """ add_photos: add photos to an event 20130103/RB: started function INPUT: - index (int): index of the event in event_array. Use 'list_events' to find the correct index. - flag_new_properties_list (BOOL, False): complicated. The properties list is a csv-file with the file names and space for titles and caption for individual photos. You don't want to override it. The file is found in 'album_path + resources_dir + event_dir + 'props.csv'' - if the file does not exist, it will be made - if the file exists and the flag is False, it will not make a new one - if the file exists and the flag is True, it will make a new file, with a number appended to it (like 'props_1.csv'). THE OLD FILE WILL CONTINUE TO BE USED. You have to manually rename it to 'props.csv'. - flag_redo_resize (BOOL, False): the photos are copied from the source, resize and put in the destination folder. During this, the exif information is copied to the resized photos. - no photos found in destination: will always resize them - photos are found, flag is False: will not do anything - photos are found, flag is True: will resize the photos - flag_redo_thumbs (BOOL, False): similar to flag_redo_resize, but for the thumbnails. REMARK: This function is a convenient collection of steps. Error checking etc should be done in the respective functions. """ HBFUN.verbose("\nHBalbum/add_photos(): redo resize: " + str(flag_redo_resize), verbose) self.event_array[index].add_and_resize_photos(flag_redo_resize, verbose) self.event_array[index].add_and_resize_thumbs(flag_redo_thumbs, verbose) self.event_array[index].add_photos_to_array(verbose) if HBFUN.check_path_exists(self.album_path + self.resources_dir + self.event_array[index].event_dir) or flag_new_properties_list: self.event_array[index].make_new_properties_list(verbose) self.event_array[index].read_properties_list(verbose)
def set_folder_thumbnail(self, event_index, photo_index, verbose = False): """ set_folder_thumbnail: change the thumbnail used for an event 20130103/RB: started function INPUT: - event_index (int): index of the event in event_array. Use 'list_events' with 'show_photos = True' to find the correct index. - photo_index (int): index if the photo used for the thumbnail OUTPUT: - True: success, False: the one of the indices does not exist. """ try: HBFUN.verbose("set_folder_thumbnail, event: " + str(event_index) + " photo: " + str(photo_index), verbose) self.event_array[event_index].photo_array[photo_index] except IndexError: HBFUN.printError("Either the event_index or photo_index is incorrect", inspect.stack()) return False self.event_array[event_index].event_thumb = photo_index self.save_events_in_csv(verbose) return True
def __init__(self, album_title, album_path, default_source_path, verbose = False): """ __init__: start an album 20130103/RB: started the function INPUT: - album_title (str): title used for the site - album_path (str): the path with all the resized photos etc - default_source_path (str): the default path to the original photos OUTPUT: - True """ HBFUN.verbose("\nalbum/__init__", verbose) self.album_title = album_title # name of the album self._album_path = HBFUN.check_path(album_path, verbose) # path of the album self._default_source_path = HBFUN.check_path(default_source_path, verbose) self.events_csv_filename = "events" # default source of photos self._pics_dir = "pics/" # pictures self._thumbs_dir = "thumbs/" # thumbs self._resources_dir = "res/" # resources self._html_dir = "html/" # html self.event_array = [] # array with events self.make_folders(verbose)
def init_new_album(album_title, album_path, default_source_path, verbose): """ init_new_album: start or restart an album 20130103/RB: started function INPUT: - album_title: title of the page (as seen on the web page) - album_path: path to where the album is located on the computer - default_source_path: the default path to the folder with the originals INTERACTION: - the album will be saved. If it already exists it will ask for confirmation before it overwrites the old album. """ HBFUN.verbose("== INIT NEW ALBUM ==", True) # make new album album = HBAL.album(album_title = album_title, album_path = album_path, default_source_path = default_source_path, verbose = verbose) # save it, if it already exists, ask for confirmation if HBFUN.check_path_exists(pickle_path): if HBFUN.ask_user_confirmation("This will overwrite the old pickle. Destroy it? y/n"): HBAL.save_album(album, pickle_path) else: HBAL.save_album(album, pickle_path)
def make_html(pickle_path, verbose): """ make_html: compile the html 20130103/RB: started function """ HBFUN.verbose("Make html", verbose) album = HBAL.load_album(pickle_path) album = HBHTML.make_html(album, verbose = verbose) HBAL.save_album(album, pickle_path) # to save the newly imported properties
def disable_photo(pickle_path, event_index, photo_index, disable, verbose = False): """ disable_photo: see disable_event for info 20130103/RB: started function """ HBFUN.verbose("Disable photo", verbose) album = HBAL.load_album(pickle_path) album.disable_photo(event_index, photo_index, disable, verbose = True) HBAL.save_album(album, pickle_path)
def add_event(self, index, event_title, event_dir, event_dir_src = "", source_path = "", verbose = False): """ add_event: add an event to the album 20130103/RB: started the function INPUT: - index (int): position of the new album. Use 'list_events' to find the correct position. The newest event should have index = 0 - event_title (str): the title of the event. It usually has the format 'Some event (July 2012)' - event_dir (str): the directory name of the event on the web - event_dir_src (str, opt): if the source directory (with the original photos) has a different directory name - source_path (str, opt): is the source_path of the original photos is not the default. OUTPUT: - True: success or False: fail """ HBFUN.verbose("HBalbum/add_event(): " + str(index) + ", " + event_title + ", " + event_dir + ", " + source_path, verbose) # if no new source_path is given, use the default if source_path == "": source_path = self.default_source_path # if a new source_path is given, check for correctness else: source_path = HBFUN.check_path(source_path, verbose) if self.album_path == source_path: HBFUN.printError("album_path and source_path are the same, this is not allowed!", inspect.stack()) return False # check the event_dir event_dir = HBFUN.check_path(event_dir) # is the source event dir different? if event_dir_src == "": event_dir_src = event_dir else: event_dir_src = HBFUN.check_path(event_dir_src, verbose) # check if the source exists if HBFUN.check_path_exists(source_path + event_dir_src) == False: HBFUN.printError("The source path does not exist!", inspect.stack()) return False # check if the event already exists. If not, make it if self.check_event_exists(event_title, event_dir, verbose): ev = HBEV.event(event_title, event_dir, event_dir_src, self.album_title, self.album_path, source_path, self.pics_dir, self.thumbs_dir, self.resources_dir, self.html_dir, verbose) self.event_array.insert(index, ev) self.save_events_in_csv(verbose) return True
def change_event_title(self, event_index, new_title, verbose = False): """ change_event_title: change the title 20130127/RB: wrote this function """ HBFUN.verbose("HBalbum/change_event_title()", verbose) self.event_array[event_index].event_title = new_title return True
def list_events(pickle_path, show_photos = False, verbose = False): """ list_events: list events, and maybe also photos 20130103/RB: started function INPUT: - pickle_path (str): path and filename of the pickle - show_photos (BOOL, False): if True, it will also list the photos """ HBFUN.verbose("List events", verbose) album = HBAL.load_album(pickle_path) album.list_events(show_photos)
def check_event_exists(self, event_title, event_dir, verbose = False): """ check_event_exists 20130103/RB: started function INPUT: - event_title (str): the title of the event. It usually has the format 'Some event (July 2012)' - event_dir (str): the directory name of the event on the web OUTPUT: - True: if it does not exist, False if it does exist """ HBFUN.verbose("HBalbum/check_event_exists(): " + event_title + ", " + event_dir, verbose) ev_titles = [] ev_dirs = [] for i in range(len(self.event_array)): ev_titles.append(self.event_array[i].event_title) ev_dirs.append(self.event_array[i].event_dir) if event_title in ev_titles: HBFUN.printError("the event_title does already exist!", inspect.stack()) return False elif event_dir in ev_dirs: HBFUN.printError("the event_dir does already exist!", inspect.stack()) return False else: HBFUN.verbose(" HBalbum/check_event_exists(): event_title and event_dir do not yet exist", verbose) return True
def disable_event(pickle_path, event_index, disable, verbose = False): """ disable_event: disable an event. This will exclude it from the events gallery, but it will not remove the html code itself 20130103/RB: started function - event_index (int): index of the event in event_array. Use 'list_events' to find the correct index. If index is -1, it will affect all albums. - disable (BOOL): True to disable, False to enable. If you try to re-disable an event, it will give a warning and continue """ HBFUN.verbose("Disable event", verbose) album = HBAL.load_album(pickle_path) album.disable_event(index = event_index, disable = disable, verbose = verbose) HBAL.save_album(album, pickle_path)
def change_event_thumb(pickle_path, event_index, photo_index, verbose): """ change_event_thumb: change the thumbnail used for the event 20130103/RB: started function INPUT: - event_index (int): a valid index of an event - photo_index: a valid index of a photo """ HBFUN.verbose("Change event thumbnail", verbose) album = HBAL.load_album(pickle_path) album.set_folder_thumbnail(event_index, photo_index) HBAL.save_album(album, pickle_path)
def load_events_from_csv(pickle_path, verbose): """ load_events_from_csv: should only be used if you had to re-init an album 20130105/RB: started function INPUT: - events_csv_filename (str): the filename, without extension, of the csv file. Warning: save_file_in_csv will number filenames! - pickle_path: path and filename of the pickle """ HBFUN.verbose("load_events_from_csv", verbose) album = HBAL.load_album(pickle_path) album.load_events_from_csv(verbose) HBAL.save_album(album, pickle_path)
def __init__(self, event_title, event_dir, event_dir_src, album_title, album_path, source_path, pics_dir, thumbs_dir, resources_dir, html_dir, verbose = False): """ __init__: start a new event 20130103/RB: started the function INPUT: - event_title (str): title of the event - event_dir (str): the directory name of the event on the web - event_dir_src (str): the directory name of the event on the computer - source_path (str): source path, where the photos can be found - album_title, album_path, pics_dir, thumbs_dir, resources_dir, html_dir OUTPUT: - True """ HBFUN.verbose("HBevent/__init__: " + event_title + ", " + event_dir + ", " + album_title + " etc.", verbose) # "inherited" self.album_title = album_title self.album_path = album_path self.source_path = source_path self.pics_dir = pics_dir self.thumbs_dir = thumbs_dir self.resources_dir = resources_dir self.html_dir = html_dir # own self.event_title = event_title self.event_dir = event_dir # correctness already checked by album self.event_dir_src = event_dir_src # source of the pics self.disabled = False # disable but not delete event self.photo_array = [] # array with photos self.event_thumb = 0 # index of thumb for event self.max_pic_size = 1500 # max size for pictures self.thumb_size = 150 # size for thumbs self.make_folders(verbose)
def add_event(pickle_path, event_index, event_title, event_dir, event_dir_src = "", source_path = "", verbose = False): """ add_event: add an event to the album and add the photos to the event 20130103/RB: started function INPUT: - pickle_path (str): path and filename of the pickle - index (int): position of the new album. Use 'list_events' to find the correct position. The newest event should have index = 0 - event_title (str): the title of the event. It usually has the format 'Some event (July 2012)' - event_dir (str): the directory name of the event on the web - event_dir_src (str, opt): if the source directory (with the original photos) has a different directory name - source_path (str, opt): if the source_path of the original photos is not the default. """ HBFUN.verbose("Add event", verbose) album = HBAL.load_album(pickle_path) album.add_event(event_index, event_title, event_dir, event_dir_src, source_path = source_path, verbose = verbose) album.add_photos(event_index, flag_new_properties_list = False, flag_redo_resize = False, flag_redo_thumbs = False, verbose = verbose) HBAL.save_album(album, pickle_path)
def add_and_resize_thumbs(self, flag_redo_thumbs = False, verbose = False): """ add_and_resize_thumbs: copy photos from the source, resize and put them in web folder 20130103/RB: started the function See for details add_and_resize_photos. """ HBFUN.verbose("\nHBevent/add_and_resize_thumbs(): redo resize? " + str(flag_redo_thumbs), verbose) # compare the contents of the folders. No need to do double work! source_list = os.listdir(self.source_path + self.event_dir_src) thumbs_list = os.listdir(self.album_path + self.thumbs_dir + self.event_dir) # clean up the source list from non-jpgs source_list = [n for n in source_list if n[-4:] == ".jpg"] # remove items that already have been resized if flag_redo_thumbs: source_to_pics_list = source_list else: source_to_pics_list = [n for n in source_list if n not in thumbs_list] HBFUN.verbose(str(len(source_to_pics_list)) + " of " + str(len(source_list)) + " thumbs will be resized", verbose) src_path = self.source_path + self.event_dir_src dest_path = self.album_path + self.thumbs_dir + self.event_dir # actually resize the thumbs HBFUN.make_thumbs(src_path, dest_path, source_to_pics_list, self.thumb_size, verbose)
def add_photos_to_array(self, verbose = False): """ add_photos_to_array: actually add photos to the photo_array 20130103/RB: started the function If the photos are already in the array, it will skip them. """ HBFUN.verbose("HBevent/add_photos_to_array()", verbose) # get the list with photos already in photo_array photo_array_fn = self.get_photo_filename_from_photo_array() # get the list with photos source_list = os.listdir(self.source_path + self.event_dir_src) source_list = [n for n in source_list if n[-4:] == ".jpg"] # only add new photos to the array add_to_photo_array = [n for n in source_list if n not in photo_array_fn] if add_to_photo_array == []: HBFUN.verbose(" all photos are already in photo_array", verbose) return True for photo_filename in add_to_photo_array: # read the exif. this has to be done from the source exif = HBFUN.get_exif(self.source_path + self.event_dir_src + photo_filename) # make a photo object ph = HBPH.photo(self.album_path, self.event_dir, photo_filename, exif) # add object to photo_array self.photo_array.append(ph) return True
def load_events_from_csv(self, verbose = False): """ 20130105/RB: started the function """ HBFUN.verbose("HBalbum/load_events_in_csv()", verbose) path_and_filename = self.album_path + self.resources_dir + self.events_csv_filename + ".txt" csvfile = open(path_and_filename, "rb") csvreader = csv.reader(csvfile, delimiter=';') temp_ev_list = [] for row in csvreader: temp_ev_list.append(row) for i in range(len(temp_ev_list)): self.add_event( index = int(temp_ev_list[i][0]), event_title = temp_ev_list[i][1], event_dir = temp_ev_list[i][2], event_dir_src = temp_ev_list[i][3], source_path = temp_ev_list[i][4], verbose = verbose) for i in range(len(temp_ev_list)): self.add_photos( index = int(temp_ev_list[i][0]), flag_new_properties_list = False, flag_redo_resize = False, flag_redo_thumbs = False, verbose = verbose) self.set_folder_thumbnail(int(temp_ev_list[i][0]), int(temp_ev_list[i][5]))
def read_properties_list(self, verbose = False): """ read_properties_list: read the csv properties list and write the titles and captions to the photo objects 20130103/RB: started the function """ HBFUN.verbose("HBevent/read_properties_list()", verbose) photo_array_fn = self.get_photo_filename_from_photo_array() path_and_filename = self.album_path + self.resources_dir + self.event_dir + "props.txt" csvfile = open(path_and_filename, "rb") csvreader = csv.reader(csvfile, delimiter=';') props_list = [] for row in csvreader: props_list.append(row) for i in range(len(props_list)): # we assume the photos are in the same order... self.photo_array[i].photo_title = props_list[i][1] self.photo_array[i].photo_caption = props_list[i][2]
def make_folders(self, verbose = False): """ make_folders: create the event specific folders 20130103/RB: started the function To clean up __init__ """ HBFUN.verbose("\nHBevent/make_folders()", verbose) path = self.album_path + self.pics_dir + self.event_dir HBFUN.check_and_make_folder(path, verbose) path = self.album_path + self.thumbs_dir + self.event_dir HBFUN.check_and_make_folder(path, verbose) path = self.album_path + self.resources_dir + self.event_dir HBFUN.check_and_make_folder(path, verbose) path = self.album_path + self.html_dir + self.event_dir HBFUN.check_and_make_folder(path, verbose) return True
def save_events_in_csv(self, verbose = False): """ 20130105/RB: started the function """ # create a save filename prop_ext = "txt" path_and_filename = HBFUN.file_numbering(self.album_path + self.resources_dir, self.events_csv_filename, prop_ext) # write the properties csvfile = open(path_and_filename, "wb") csvwriter = csv.writer(csvfile, delimiter = ";") for i in range(len(self.event_array)): ev = self.event_array[i] csvwriter.writerow([i, ev.event_title, ev.event_dir, ev.event_dir_src, ev.source_path, ev.event_thumb]) csvfile.close()
def add_and_resize_photos(self, flag_redo_resize = False, verbose = False): """ add_and_resize_photos: copy photos from the source, resize and put them in web folder 20130103/RB: started the function INPUT: - flag_redo_resize (BOOL, False): the photos are copied from the source, resize and put in the destination folder. During this, the exif information is copied to the resized photos. - no photos found in destination: will always resize them - photos are found, flag is False: will not do anything - photos are found, flag is True: will resize the photos REMARKS: The function reads the photos in the source and destination folder into two arrays. It compares the arrays and removes the ones that have already been resized (unless flag_redo_resize = True). """ HBFUN.verbose("\nHBevent/add_and_resize_photos(): redo resize? " + str(flag_redo_resize), verbose) # compare the contents of the folders. No need to do double work! source_list = os.listdir(self.source_path + self.event_dir_src) pics_list = os.listdir(self.album_path + self.pics_dir + self.event_dir) # clean up the source list from non-jpgs source_list = [n for n in source_list if n[-4:] == ".jpg"] # remove items that already have been resized if flag_redo_resize: source_to_pics_list = source_list else: source_to_pics_list = [n for n in source_list if n not in pics_list] HBFUN.verbose(str(len(source_to_pics_list)) + " of " + str(len(source_list)) + " pics will be resized", verbose) src_path = self.source_path + self.event_dir_src dest_path = self.album_path + self.pics_dir + self.event_dir # actually resize the photos HBFUN.resize_pics(src_path, dest_path, source_to_pics_list, self.max_pic_size, verbose)
def test_ask_user_confirmation(): answer = HBFun.ask_user_confirmation("This will destroy the world y/n: ") print(answer)
def default_source_path(self, path): self._default_source_path = HBFUN.check_path(path)
def pics_dir(self, path): self._pics_dir = HBFUN.check_path(path)
def thumbs_dir(self, path): self._thumbs_dir = HBFUN.check_path(path)