!pip install --q pylint --user

!pip install pydot

!pyreverse -o dot -pdatetime datetime

import pydot

print("Creating graph ...")
(graph,) = pydot.graph_from_dot_file('classes_datetime.dot')
print("Creating PNG ...")
graph.write_png('classes_datetime.png')
print("done")

!pyreverse -o dot -pSplashScreenCollector SplashScreenCollector

import pydot

print("Creating graph ...")
(graph,) = pydot.graph_from_dot_file('classes_SplashScreenCollector.dot')
print("Creating PNG ...")
graph.write_png('classes_SplashScreenCollector.png')
print("done")

from datetime import date, timedelta
from pathlib import Path
import shutil
import filecmp
import re

from IPython.display import display, HTML, Image
import pandas as pd
from PIL import Image
from bs4 import BeautifulSoup
import requests 

# TODO: The Windows System folder with wallpapers is also to be handled
#       by SplashScreenCollection as well as the final folder Collection/
class SplashScreenCollection():
    ''' Manage a collection of Splash Screen Images in a folder by allowing for removal
        of non wallpaper files, clickable wallpaper display by HTML strings in boxes'
        results pointing the Google Reverse Image Search results, and creating commands
        for giving the wallpaper files meaningful names instead of Windows' hash keys.
    '''
    def __init__(self,path_list=None):
        ''' Set attribute  `wallpaper_path_list` to the path where wallpapers are stored
            and `src_file_list` to the list of names of all files in that folder

            Parameters:
            path_list                   list of path names of wallpapers to initialise the collection with
        '''
        self.wallpaper_path_list = path_list

    def set_path_name_timestamp(self):
        ''' Set attribute `folder_name` to the a folder with the name "YYYYMMDD_i" in the current directory
            which does not yet exist using the first possible natural number i for this.

            Return Path() object of the path to this folder.

            Return:
            result of self.set_path_name(), i.e.
            False                       because path_name is created such that it does not exist yet
                                        but a folder with this name is created anyway

            Note:
            For Windows batch a solution of finding unique names was given in
            [How do I increment a folder name using Windows batch?](https://stackoverflow.com/questions/13328421/how-do-i-increment-a-folder-name-using-windows-batch).
        '''
        self.today = date.today()
        self.month = self.today.strftime("%B")
        prefix = self.today.strftime("%Y%m%d") + "_"
        # count entries of current folder starting with "YYYYMMDD_" representing today
        list_prefixes_in_current_folder = list(Path(".").glob(prefix+"*"))  # Path().glob is iterable but no list
        running_index = len(list_prefixes_in_current_folder)
        # increment suffix for getting a new name
        running_index+=1
        return(self.set_path_name("{}{}".format(prefix,running_index)),False)

    def set_path_name(self,path_name,missing_ok=False):
        ''' Set attribute `path_name` to the passed parameter and the attribute `path` to a
            Path() object of the path to a folder with that name in the current directory.

            Parameters:
            path_name                   name of folder (usually matching "YYYYMMDD_i") to search wallpapers in
            missing_ok                  allow for setting pathes that do not exist, default: False,
                                            i.e. create a folder with name `path_name` unless it exists

            Return:
            True                        if such a folder already exists in current directory,
                                        otherwise False after creating the folder
        '''
        self.path_name = path_name
        self.path = Path(".") / self.path_name
        if self.path.is_dir():
            print(f'{self.set_path_name.__name__}: Set to collection {self.path_name=}')
            self.path_exists = True
        else:
            print(f'{self.set_path_name.__name__}: Collection {self.path_name=} not found!')
            self.path_exists = False
        if self.path_exists:
            self.set_wallpaper_path_list(False)
        else:
            if not missing_ok:
                self.create_path()
        return(self.path_exists)

    def create_path(self):
        ''' Create the (local) folder `self.path` the object self representing

            Return:
            False                       if a non-empty folder whose path is `self.path` exists
        '''
        if self.path.exists():
            # local target folder exists
            if any(self.path.iterdir()):
                # local folder path is not empty
                self.path_empty = False
                print(f"[FAIL] {self.path=} exists and is not empty")
                return(False)
            else:
                # local target folder is empty
                self.path_empty = True
                print(f"[ OK ] {self.path=} exists but is empty")
            return(True)
        else:
            print(f"[ OK ] {self.path=} is missing")
            print(f'creating {self.path}/')
            self.path.mkdir(parents=False, exist_ok=False)
            self.path_exists = True
            self.path_empty = True
            return(True)

    def from_system(self,username):
        ''' Create new collection of wallpapers currently stored in the systems folder

            Parameters:
            None
        '''
        self.copy_files_from_system(username)
        self.append_extension("jpg")
        self.set_wallpaper_path_list(True)
        self.reduce()
        self.rename_collected_wallpapers()
        print(self.print_subsection_for_folder())

    def copy_files_from_system(self,username):
        ''' Copy files from source to target

            No longer needed Parameters:
            username    (string)        Name of user in whose windows proile to look for wallpapers
        '''
        from_path = Path("/") / "Users" / username / \
            "AppData" / "Local" / "Packages" / \
            "Microsoft.Windows.ContentDeliveryManager_cw5n1h2txyewy" / \
            "LocalState" / "Assets"
        print(f"copying from {str(from_path)=}")
        for p in from_path.iterdir():
            if p.is_file():
                if shutil.copy(p, self.path):
                    print(f"[ OK ] copied {str(p)=} to {str(self.path)}/")
                else:
                    print(f"[FAIL] unable to copy {str(p)=}")

    def append_extension(self,extension):
        ''' Add the string `extension` to the names of all files in folder `self.path`

            Parameters:
            extension   (string)        extension to add to all files in the collection
        '''
        print(f'exec append_extension("{extension}") ...')
        for p in self.path.iterdir():
            if p.is_file():
                new_name = p.stem + "." + extension
                if p.rename(Path(p.parent) / new_name):
                    print(f"[ OK ] {p.stem} -> {new_name}")
                else:
                    print(f"[FAIL] unable to rename {str(p)=}")
        print(f'done append_extension("{extension} ...")')

    def set_wallpaper_path_list(self,check_size=False):
        ''' Set attribute `wallpaper_path_list` to the list of path names of wallpapers in `self.path`

            if `check_size` is True then get the the maxima of
                of all widths  of all images in `self.path` whose names end on ".jpg" and
                of all heights of all images in `self.path` whose names end on ".jpg"
            and omit all path names if they do not belong to an image with these dimensions.

            Parameters:
            check_size                  True:  Consider only the images with greatest dimensions
                                        False: Take all images (dafault)
        '''
        path_list = [path for path in self.path.iterdir()]
        # print(f'    | {path_list=}')
        if check_size:
            width_list = [self.catch(path,0) for path in path_list if str(path).endswith(".jpg")]
            if len(width_list) == 0:
                # print("    | No images with positive width in {}".format(folder.name))
                return []
            width = max(width_list)
            # print(f'    | {width=}')

            height_list = [self.catch(path,1) for path in path_list if str(path).endswith(".jpg") and self.catch(path,0)==width]
            if len(height_list) == 0:
                # print("    | No images with positive height in {}".format(folder.name))
                return []
            height = max(height_list)
            # print(f'    | {height=}')

        result = []
        if check_size:
            self.wallpaper_path_list = [str(path) for path in path_list if self.do_check_size(path,width,height)]
            # print(f'    | {len(self.wallpaper_path_list)=} wallpapers of size {width}x{height}')
            # print(f'    | {self.wallpaper_path_list=}')
        else:
            self.wallpaper_path_list = [str(path) for path in path_list]
            # print(f'    | {len(self.wallpaper_path_list)=} wallpapers')
            # print(f'    | {self.wallpaper_path_list=}')
        print(f'set_wallpaper_path_list: {len(self.wallpaper_path_list)}/{len(path_list)} files in {str(self.path)}/ meet the conditions of wallpapers')
        return self.wallpaper_path_list

    def catch(self,path,a):
        try:
            return(Image.open(str(path)).size[a])
        except Exception as e:
            return 0

    def do_check_size(self,path,width,height):
        ''' Return True if `path` is the path name to an image file with a wallpaper
            Images are considered wallpapers if their size is `width` x `height`

            Parameters:
            path                        Path() object of folder get wallpapers from
            width                       Width an image must have for being able to be a wallpaper
            height                      Height an image must have for being able to be a wallpaper
        '''
        if not str(path).endswith(".jpg"):
            return(False)
        if self.catch(path,0) != width:
            return(False)
        if self.catch(path,1) != height:
            return(False)
        return(True)

    def print(self):
        print(self.wallpaper_path_list)

    def reduce(self): # ,path_list):
        ''' Remove all files from folder `self.path` that are not contained in the
            list `self.wallpaper_path_list` of names of pathes to wallpapers

            No longer needed Parameters:
            path_list                   list of path names of the files which must not be deleted
            folder                      Path() object of folder get wallpapers from
        '''
        print(f'exec reduce() ...')
        for path in self.path.iterdir():
            if str(path) in self.wallpaper_path_list:
                print("keeping {} in {}/".format(str(path),self.path_name))
            else:
                print("removing {} from {}/".format(str(path),self.path_name))
                path.unlink()
        print(f'done reduce()')

    def rename_collected_wallpapers(self):
        ''' Check if files copied from system already were stored in the final collection
            If so rename them such that they have the same name as in the final collection
        '''
        print(f'exec rename_collected_wallpapers() ...')
        collection_path = Path('.') / 'Collection'
        wallpapers_found = 0                                      # TODO: [False for p in self.wallpaper_path_list]
        for path in collection_path.iterdir():
            for i in  range(len(self.wallpaper_path_list)):
                path_str = self.wallpaper_path_list[i]
                if filecmp.cmp(str(path),path_str, shallow=False):
                    print("rename {} -> {}".format(Path(path_str).name,path.name))
                    new_path = Path(path_str).parent / path.name
                    Path(path_str).rename(new_path)
                    self.wallpaper_path_list[i] = str(new_path)
                    wallpapers_found += 1                         # TODO: wallpapers_found[i] = True
                    break
            if wallpapers_found == len(self.wallpaper_path_list): # TODO: if all(wallpapers_found):
                break
        print(f'done rename_collected_wallpapers()')

    ### all done for from_system() ###

    def from_collection(self,collection):
        ''' Copy all the wallpaper files in SplashScreenCollection() object `collection`
            into the folder with path `self.path`

            Parameters:
            collection                  SplashScreenCollection() object with images to import
        '''
        for w in collection:
            destination.append(w)
        print(self.print_script_renaming_wallpapers())

    ### make SplashScreenCollection be an iterator:

    def __len__(self):
        try:
            return len(self.wallpaper_path_list)
        except AttributeError:
            return -1

    def append(self,path_str):
        ''' Add an item to the end of the list stored as attribute `wallpaper_path_list`, i.e.
            Import the wallpaper in file to which Path() object `path` points to.
            Equivalent to a[len(a):] = [path].

            Parameters:
            path                        path to wallpaper file to be added to this collection
        '''
        path = Path(path_str)
        if (self.path / path.name).is_file():
            print(f'[FAIL] Wallpaper "{str(self.path / path.name)}" already exists')
        else:
            shutil.copy(path, self.path)
            self.wallpaper_path_list.append(path)
            print(f'[ OK ] Wallpaper "{str(self.path / path.name)}" collected')

    # TODO: Delegate the following methods to self.wallpaper_path_list,
    #       rf. [Data Structures](https://docs.python.org/3/tutorial/datastructures.html)
    def extend(self,iterable):
        ''' Extend the list by appending all the items from the iterable.
            Equivalent to a[len(a):] = iterable.
        '''
        self.wallpaper_path_list.extend(iterable)
        pass

    def insert(self, i, x):
        ''' Insert an item at a given position.
            The first argument is the index of the element before which to insert,
            so  a.insert(0, x) inserts at the front of the list,
            and a.insert(len(a), x) is equivalent to a.append(x).
        '''
        self.wallpaper_path_list.insert(i, x)
        pass

    def remove(self,x):
        ''' Remove the first item from the list whose value is equal to x.
            It raises a `ValueError` if there is no such item.
        '''
        self.wallpaper_path_list.remove(x)
        pass

    # def pop(self,[i]):
    #     ''' Remove the item at the given position in the list, and return it.
    #         If no index is specified, a.pop() removes and returns the last item in the list.
    #         (The square brackets around the i in the method signature denote that the parameter is optional,
    #          not that you should type square brackets at that position.
    #          You will see this notation frequently in the Python Library Reference.)
    #     '''
    #     self.wallpaper_path_list.pop(x)
    #     pass

    def clear(self):
        ''' Remove all items from the list. Equivalent to del a[:].
        '''
        self.wallpaper_path_list.clear(x)
        pass

    #def index(self,x[, start[, end]]):
    #    ''' Return zero-based index in the list of the first item whose value is equal to x.
    #        Raises a ValueError if there is no such item.
    #
    #        The optional arguments start and end are interpreted as in the slice notation and
    #        are used to limit the search to a particular subsequence of the list.
    #        The returned index is computed relative to the beginning of the full sequence
    #        rather than the start argument.
    #    '''
    #    self.wallpaper_path_list.index(x)
    #    pass

    def count(self,x):
        ''' Return the number of times x appears in the list.
        '''
        self.wallpaper_path_list.count(x)
        pass

    def sort(self,*, key=None, reverse=False):
        ''' Sort the items of the list in place
            (the arguments can be used for sort customization, see sorted() for their explanation).
        '''
        self.wallpaper_path_list.sort(x)
        pass

    def reverse(self):
        ''' Reverse the elements of the list in place.
        '''
        self.wallpaper_path_list.reverse(x)
        pass

    def copy(self):
        '''Return a shallow copy of the list. Equivalent to a[:].
        '''
        self.wallpaper_path_list.copy(x)
        pass

    def get_value(self, index):
        len_ = len(self)
        if len_ == -1:
            raise AttributeError
        if index < 0 or index >= len_:
            raise IndexError('list index out of range')
        return self.wallpaper_path_list[index]

    def __getitem__(self, key):
        ''' Return item at position `key` by delegation to internal method `get_value` for
            the support of slicing

            Parameters:
            key                         index for accessing `self.wallpaper_path_list`
        '''
        if isinstance(key, slice):
            start, stop, step = key.indices(len(self))
            return SplashScreenCollection([self[i] for i in range(start, stop, step)])
        elif isinstance(key, int):
            return self.get_value(key)
        elif isinstance(key, tuple):
            raise NotImplementedError('Tuple as index')
        else:
            raise TypeError('Invalid argument type: {}'.format(type(key)))

    def __iter__(self):
        return self.SplashScreenCollectionIterator(self)

    class  SplashScreenCollectionIterator():
        def __init__(self, iterable):
            self.__iterable = iterable
            self.__index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self.__index >= len(self.__iterable):
                raise StopIteration
            # return the next path (as string) / the name of the next path
            path_name = self.__iterable.wallpaper_path_list[self.__index]
            self.__index += 1
            return path_name

    def add_spaces(self,text,indent=2):
        return('  ' * indent + text)

    def add_newline(self,text,indent=2):
        return(self.add_spaces(text,indent) + '\n')

    def print_subsection_for_folder(self):
        text = self.add_newline(f'#### Q{((self.today.month-1) // 4) + 1}/', indent = 0)
        text += self.add_newline(f'##### {self.month}/', indent = 1)
        text += self.add_newline(f'###### Show Wallpapers in {self.path}/')
        text += self.add_newline(f'collection = SplashScreenCollection()')
        text += self.add_newline(f'folder_name = "{self.path}"')
        text += self.add_newline("if collection.set_path_name(folder_name,True):")
        text += self.add_newline("    print(f'[ OK ] {folder_name=} exists')")
        # No need to generate invoking `self.reduce()` since it is called by `self.from_system(username)`
        # if not str(self.path).startswith( 'Collection' ):
        #     text += self.add_newline("    collection.reduce()")
        text += self.add_newline("    collection.show()")
        text += self.add_newline("else:")
        text += self.add_newline("    print(f'[FAIL] {folder_name=} not found')")
        text += self.add_newline(f'###### renaming')
        print("\n"+text)

    def print_script_renaming_wallpapers(self):
        ''' Output a script renaming the files given by the list file_list all of which
            need to be in the folder with name folder_name in the current directory.

            No longer needed Parameters (-> self.wallpaper_path_list, self.rename_file() renames in self.path):
            file_list                   list of files to be renamed in folder with name folder_name
            folder_name                 name of folder in current directory
        '''
        print(f'\nexec print_script_renaming_wallpapers() ...\n')
        text = ""
        for path_name in self.wallpaper_path_list:
            old_name = self.remove_prefix(path_name,self.path_name+'\\')
            comment_prefix = ""
            # TODO: comment out the statements for wallpapers that already have been renamed,
            #       i. e. for those values of Path(path_name).stem whose filename without the path is a hash key,
            #       i. e. for those values of old_name that are a hash key plus extension ".jpg"
            #       rf. [How to get only the name of the path with python?](https://stackoverflow.com/questions/50876840/how-to-get-only-the-name-of-the-path-with-python)
            # if old_name minus extension is an unrenamed hash key:
            #     comment_prefix = "# "
            if not re.search(r'^[0-9a-z]+.jpg', old_name): # old_name minus extension is an unrenamed hash key:
                comment_prefix = "# "
            text += self.add_newline(f'{comment_prefix}old_file = "{old_name}"',False)
            text += self.add_newline(f'{comment_prefix}new_file = "TTTTT.jpg"',False)
            text += self.add_newline(f"{comment_prefix}collection.rename_file(old_file,new_file)\n",False)
        print("\n"+text+"\n")
        print("print(\"\\nDo NOT forget to reload collection!\")")

    def show(self):
        ''' Search wallpapers in folder with name folder_name and show them in a dataframe
            with links to results of respective Google Reverse Image Searches.

            No longer needed Parameters (->self.wallpaper_path_list, self.display() uses self.path_name):
            folder_name                 name of folder to search wallpapers in
            check_size                  True:  Consider only the images with greatest dimensions
                                        False: Take all images (dafault)
        '''
        self.display()
        if len(self.wallpaper_path_list)>0:
            self.print_script_renaming_wallpapers()

    def display(self):
        ''' For each file in the folder passed as self.path of class Path two rows of
            a dataframe with the quoted and unquoted name of the path to the file are
            created.
            Formatting with the function `clickable_image_html()` is applied when
            converting to html the result of which is passed to display(HTML())

            No longer needed Parameters:
            file_list     -             list of pathes to the wallpapers to build a dataframe with
            folder_name   -             name of folder with the wallpapers,
        '''
        wallpaper_column='Wallpapers in {}/'.format(str(self.path_name))
        quoted_file_list = [ f'<{str(path)}>' for path in self.wallpaper_path_list]
        # DONE: insert quote entries of file_list at rows with indices 1+(2)
        files = [None]*(len(self.wallpaper_path_list)+len(quoted_file_list))
        files[::2] = quoted_file_list
        files[1::2] = self.wallpaper_path_list
        # print(f'{files=}') # OK
        df = pd.DataFrame( files, columns = [wallpaper_column] )
        # OR TODO: quote entries of file_list and insert them at rows with indices 1+(2)

        # TODO: Maybe this won't work with clickable_image_html() being a method!
        format_dict = { wallpaper_column: self.clickable_image_html }
        html_str=df.to_html(escape=False, formatters=format_dict)
        display(HTML(html_str))

    def exists(self):
        ''' Check if `self.path` is the path to a folder which exists

            Return:
            True                        if `self.path` exists, otherwise False
        '''
        if hasattr(a, 'path'):
            if isinstance(self.path, Path):
                return(self.path.is_dir())
        return(False)

    def remove_prefix(self,text,prefix):
        text_str = str(text)
        if text_str.startswith(prefix):
            return text_str[len(prefix):]
        return text_str  # or whatever

    def path_to_image_html(self,path):
        ''' This function essentially converts a path to a local image to
            '<img src="'+ path + '" />' format. And one can put any
            formatting adjustments to control the height, aspect ratio, size etc.
            within as in the below example.

            Parameters:
            path                        Path() object of local image
        '''
        # remove_prefix(str(path), str(Path.cwd())+'\\')
        result = '<img src="'+ str(path) + '" />'
        print(f'path_to_image_html({path=}):\n    {result}')
        return result

    def clickable_image_html(self,path):
        ''' Convert path to a local image to the image tag returned by
            path_to_image_html() inside an <a href...> tag pointing to
            a link to the results of a Google Reverse Image Search
            obtained as answer to a post request.

            Parameters:
            path                        Path() object of local image
        '''
        # DONE: check for quoted entries instead of for extension ".jpg"
        if str(path).startswith("<") and str(path).endswith(">"):
            # DONE: remove quotes from path if path is quoted
            return str(path).lstrip("<").rstrip(">")
        else:
            image_html_str = self.path_to_image_html(path)
            filePath = fr"{str(path)}"
            searchUrl = 'http://www.google.com/searchbyimage/upload'
            multipart = {'encoded_image': (filePath, open(filePath, 'rb')), 'image_content': ''}
            response = requests.post(searchUrl, files=multipart, allow_redirects=False)
            fetchUrl = response.headers['Location']
            # location = location_of_image(fetchUrl)
            return '<a href="{}">{}</a><br>'.format(fetchUrl,image_html_str) # "...{}".format(...,location)

    def rename_file(self,old_name,new_name):
        ''' Rename file with name old_file into new_file

            Parameters:
            old_name   (string)         old name of file
            new_name   (string)         new name of file
        '''
        try:
            old_path = self.path / old_name
            new_path = self.path / new_name
            old_path.rename(new_path)
            print("{}\n  -> {}".format(old_name,new_name))
        except Exception as e:
            # print("{e}: unable to rename {old_file}")
            print(e)

    def location_of_image(url):
        ''' Parse the results of the Google Reverse Image Search given by `url` and 
            try to determine where the photo was taken

            NICE TO HAVE, NOT WORKING YET

            Parameters:
            url             -           link to  the results page of a Google Reverse Image Search
        '''
        usr_agent = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
                          # 'Chrome/61.0.3163.100 Safari/537.36'
        }
        def fetch_results(search_url):
            response = requests.get(search_url, headers=usr_agent)
            response.raise_for_status()
            return response.text

        def parse_results(raw_html):
            soup = BeautifulSoup(raw_html, 'html.parser')
            result_block = soup.find_all('div', attrs={'class': 'g'})
            for result in result_block:
                link = result.find('a', href=True)
                title = result.find('h3')
                text = link.get_text()
                if link and title:
                    yield text[:text.index("https://")] # + " -> " + link['href']

        # return("location_of_image({})".format(url))

        html = fetch_results(url)
        results = list(parse_results(html))
        # results = ["links","from","Google"]
        results = [ "<li>{}</li>".format(elem) for elem in results ]
        return ''.join(['<ol>',''.join(results),'</ol>'])

collection = SplashScreenCollection() # SplashScreenCollection(True)
folder_name = collection.set_path_name_timestamp()
collection.from_system("schwa")

collection = SplashScreenCollection()
folder_name = "20220607_1"
if collection.set_path_name(folder_name,True):
    print(f'[ OK ] {folder_name=} exists')
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

old_file = "03524bd7ed240954228c0bb4d55046c3861a758b5bd74a2a7e738e6181d04312.jpg"
new_file = "Gemälde von Thomas Cole, Blick auf die Catskill Mountains im Bundesstaat New York im Frühherbst - 1837, Hudson River School.jpg"
collection.rename_file(old_file,new_file)

old_file = "41793c049cb597aab5239c999d0958179eb1f82559061c81da316de678b60f7f.jpg"
new_file = "Costa Vedere, Madagascar.jpg"
collection.rename_file(old_file,new_file)

old_file = "45a1cdade789a5162de9527a4eec2bb9f51a82f4b51f73cda21b28c4e3e5d019.jpg"
new_file = "Bay - Scarborough Beach bei Sonnenuntergang, Südafrika.jpg"
collection.rename_file(old_file,new_file)

old_file = "8b7a9508c4aecbe67fb699a2c145f3ab86e92000db5b769a092ffbaf7dc26a91.jpg"
new_file = "Berg Wildseeloder, Tirol, Österreich.jpg"
collection.rename_file(old_file,new_file)

old_file = "aab37e73041d6c597e769472059550be53961bbdbf889a12cdf454a186aedd67.jpg"
new_file = "Bonsai Rock, Lake Tahoe, Nevada, USA.jpg"
collection.rename_file(old_file,new_file)

old_file = "e8f91a5f0327ecaec496ede1d22ee7cc3875c2bc0fa4ea06914b016f8fa4481a.jpg"
new_file = "Rosapelikane, Namibia.jpg"
collection.rename_file(old_file,new_file)

print("\nDo NOT forget to reload collection!")

print(f'{collection.path_name=}')

collection.show()

collection = SplashScreenCollection()
collection.set_path_name("20220615_1")
collection.print()

destination = SplashScreenCollection(False)
destination.set_path_name("Collection")
destination.from_collection(collection)

<!-- #region heading_collapsed=true -->
#### Show Wallpapers in 20211214_2/
<!-- #endregion -->

```python hidden=true
folder_name = "20211214_2"
file_name_list = display_and_prepare_renaming_wallpapers(folder_name,True)

```python hidden=true
remove_non_wallpapers("20211214_2",file_name_list)
# ?remove_non_wallpapers

```python hidden=true
from pathlib import Path

folder = Path(".") / folder_name

# old_file = folder / "2d697ab2e3cb6a9b93651304b8933e3a9c936fc969d00e45ffe4f7accd5eb1e2.jpg"
# new_file = folder / "Burg Berlanga de Duero, Provinz Soria, Kastilien und Leon, Spanien.jpg"
# old_file.rename(new_file)

# old_file = folder / "703a7716b10321e1c218dced95053070ba4ea7bd1a5968666b1196ddf9e53a04.jpg"
# new_file = folder / "Scheveningen, Den Haag, Niederlande.jpg"
# old_file.rename(new_file)

# old_file = folder / "cf7fbfa5f6d2ff49c06f62f31b580689b9406adc040950443685384c47bf9753.jpg"
# new_file = folder / "Ägerisee, Schweiz.jpg"
# old_file.rename(new_file)

# old_file = folder / "d98d37454bbda7e45887b764482edb422b24eaf35ac6738ef0d663f0f197453c.jpg"
# new_file = folder / "London in Luftaufnahme, England, UK.jpg"
# old_file.rename(new_file)

# old_file = folder / "London in Luftaufnahme, England, UK.jpg"
# new_file = folder / "London, Luftaufnahme der Tower Bridge, England, UK"
# old_file.rename(new_file)

# old_file = folder / "df367cf955beb6676a10a66b802669a85803c0015cb0fbf614b6bf36d0091886.jpg"
# new_file = folder / "Bay - Playa del Silencio in Cudillero, Asturien, Spanien.jpg"
# old_file.rename(new_file)

# old_file = folder / "e605dbbee3f37a10d2d110ccf608a16fa01aebec5f35dc5e735de39da6890001.jpg"
# new_file = folder / "Nationalpark Theodore-Roosevelt, Inselberg in Badland-Landschaft, North Dakota, USA.jpg"
# old_file.rename(new_file)

<!-- #region heading_collapsed=true -->
#### Show Wallpapers 20211217_1/
<!-- #endregion -->

<!-- #region hidden=true -->
StackOverflow: [How to do reverse image search on google by uploading image url?](https://stackoverflow.com/questions/59176559/how-to-do-reverse-image-search-on-google-by-uploading-image-url)
<!-- #endregion -->

```python hidden=true
folder_name = "20211217_1"
file_name_list = file_name_list = display_and_prepare_renaming_wallpapers(folder_name,True)

```python hidden=true
remove_non_wallpapers(folder_name)

```python hidden=true
from pathlib import Path

old_file = folder / "58fbc0f1cfe19d326edbf51b74c61995c3386dc92f4848bd73596097ef2051a1.jpg"
new_file = folder / "Naturpark - Valley of Fire, NV, USA.jpg"
old_file.rename(new_file)

old_file = folder / "2a2a3438ed1ff5525b8089ec285a7b30fa3135134f7547f9b55fdad87f9b62ce.jpg"
new_file = folder / "Nationalpark Los Glaciares, Berg Cerro Torre, Patagonien, Argentinien.jpg"
old_file.rename(new_file)

old_file = folder / "a46575de4ee21b793677cde31b37d0cd7eb6081a1dfa59b816ed8138c7fe58c0.jpg"
new_file = folder / "Nationalpark Amboró, Santa Cruz, Bolivien.jpg"
old_file.rename(new_file)

```python hidden=true
from pathlib import Path

folder = Path(".") / "20220104_1"

old_file = folder / "0657a2d3fd21087aea9bf1831e13bde67796995742c70173d2d9c965b4965ad4.jpg"
new_file = folder / "Gemälde Canadian Rockies (Lake Louise) von Albert Bierstadt, The Metropolitan Museum of Art.jpg"
old_file.rename(new_file)

old_file = folder / "0fedc38e49a5796f5bfdbc7fde6553b944486b2b76e7a0f2043e489f98a2c72d.jpg"
new_file = folder / "Abtei Mont Saint-Michel, UNESCO-Welterbe, Normandie, Frankreich, Departement Manche.jpg"
old_file.rename(new_file)

old_file = folder / "119991f059b995449935e0bd4993f7edccd8a916900110f7c7e737bad1511c0e.jpg"
new_file = folder / "natural landscape.jpg"
old_file.rename(new_file)

old_file = folder / "2bfe9a4e72c787f17812dc49bb926f38ba3d20ccaad47c7422198e97fbdeaade.jpg"
new_file = folder / "Wasserfall - Saltos de Petrohué, Nationalpark Vicente Pérez Rosales, Región de los Lagos, Chile.jpg"
old_file.rename(new_file)

old_file = folder / "c5827f7a5f4a5ba9c10cba9ca949b2861e2961e5cdb21cfae9cf1b2fb68fbd13.jpg"
new_file = folder / "Banyak Inseln, tropischer Archipel nahe Sumatra, Aceh, Indonesien.jpg"
old_file.rename(new_file)

old_file = folder / "c75b76e8b7a1fca82786f9bb9723cbb616c00ea0ed7ec5bf88aba0e9f1e88ee5.jpg"
new_file = folder / "Wasserfall - Nationalpark Plitvicer Seen 1, Kroatien.jpg"
old_file.rename(new_file)

```python hidden=true
path = Path(".") / "20220106_1"
file_name_list = get_wallpapers(path,True)
print("filtered {}  wallpapers {}".format(len(file_name_list),file_name_list))
create_script_rename_wallpapers(file_name_list,path.name)

<!-- #region hidden=true -->
##### Show Wallpapers in 20220109/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220109_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220111/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220111_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220115_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220115_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220125_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220125_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220130_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220130_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220131_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220131_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
#### February
<!-- #endregion -->

<!-- #region hidden=true -->
##### Show Wallpapers in 20220204_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220204_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220208_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220208_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220219_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220219_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220223_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220223_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220225_1/
<!-- #endregion -->

```python hidden=true
folder_name = "20220225_1"
file_name_list = reduce_to_wallpapers(folder_name,True)

<!-- #region hidden=true -->
#### March
<!-- #endregion -->

<!-- #region hidden=true -->
##### Show Wallpapers in 20220305_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220305_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220309_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220309_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220313_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220313_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220320_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220320_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220322_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220322_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')

<!-- #region hidden=true -->
##### Show Wallpapers in 20220326_1/
<!-- #endregion -->

```python hidden=true
collection = SplashScreenCollection(True)
folder_name = "20220326_1"
if collection.set_path_name(folder_name):
    print(f'[ OK ] {folder_name=} exists')
    collection.reduce()
    collection.show()
else:
    print(f'[FAIL] {folder_name=} not found')