Rename By Metadata of Photos/Videos Files

Prepare

windows

• pip install certifi
• 下载 mediainfo dll: https://mediaarea.net/en/MediaInfo/Download/Windows
  (required by pymediainfo)

linux

apt install mediainfo

windows && linux

pip{3} install exifread
pip{3} install pymediainfo

---

Talk is cheap, show xxxx

#!/usr/bin/env python3

# finalx

# for win:
# https://github.com/pypa/pip/issues/4205 fix installing pymediainfo issue
# https://github.com/sbraz/pymediainfo/issues/39 fix pymediainfo module not found issue(dll)
#  useful dll link:
#  https://mediaarea.net/en/MediaInfo/Download/Windows

import os
import sys
import logging
import re
import time
import traceback
import platform
from distutils.version import StrictVersion

## prepare depends packages
#import importlib
#def install_and_import(package):
#    try:
#        importlib.import_module(package)
#    except ImportError:
#        import pip
#        if StrictVersion(pip.__version__) < StrictVersion('10.0.0'):
#            pip.main(['install', package])
#        else:
#            pip._internal.main(['install', package])
#    finally:
#        globals()[package] = importlib.import_module(package)
#
#if platform.system() == 'Windows':
#    install_and_import('exifread')
#    install_and_import('setuptools')
#    install_and_import('certifi')
#    install_and_import('pymediainfo')

if platform.system() == 'Windows':
    import certifi  #just make sure it's installed or raise exception

# pip3 install exifread
import exifread
# pip3 install pymediainfo
import pymediainfo

# now begin
""" Retrieve the files in specified path with below suffixs(case ignored):
    .jpg
    .jpeg
    .jpe

    .mov
    .mp4
    .m4v
    .3gp
    .3g2
    .m2v
    .mkv
"""
gRegImg = re.compile(r".*\.(?:(?:jpg)|(?:jpeg)|(?:jpe))$", re.IGNORECASE|re.UNICODE)
gRegVid = re.compile(r".*\.(?:(?:mov)|(?:mp4)|(?:m4v)|(?:3gp)|(?:3g2)|(?:m2v)|(?:mkv))$", re.IGNORECASE|re.UNICODE)
def isFilePathImg(filepath):
    logging.debug("{} match:{}".format(filepath, re.match(gRegImg, filepath)))
    return re.match(gRegImg, filepath)


def isFilePathVideo(filepath):
    logging.debug("{} match:{}".format(filepath, re.match(gRegVid, filepath)))
    return re.match(gRegVid, filepath)


def getMediaFiles(dir):

    pathnames = []
    for (dirpath, dirnames, filenames) in os.walk(dir):
        pathnames.extend(
            (os.path.join(dirpath, afile) for afile in filenames if (isFilePathImg(afile) or isFilePathVideo(afile)))
        )

    logging.debug("getMediaFiles returns {}".format(pathnames))
    return pathnames


def getImgDateTaken(filepath):

    dateTaken = None
    with open(filepath, 'rb') as fh:
        tagsOfDateTime = ('Image DateTime', 'EXIF DateTimeOriginal', 'EXIF DateTimeDigitized')
        tagsOfGps = ('GPS GPSDate', 'GPS GPSTimeStamp')
        tagsAll = exifread.process_file(fh)
        #print tagsAll

        if tagsAll:
            for tag in tagsOfDateTime:
                if tag in tagsAll:
                    dateTaken = tagsAll[tag]
                    #logging.info("type: {}, repr:{}, str:{}".format(type(dateTaken), repr(dateTaken), str(dateTaken)))
                    break

    ret = None
    if (dateTaken):
        ret = time.strptime(str(dateTaken), "%Y:%m:%d %H:%M:%S")

    return ret


def getVideoDateTaken(filepath):
    mediaInfo = pymediainfo.MediaInfo.parse(filepath)

    if (not mediaInfo):
        return None

    trackGeneral = mediaInfo.tracks[0]
    if not trackGeneral:
        return None

    if not trackGeneral.encoded_date:
        return None

    return time.strptime(trackGeneral.encoded_date, "%Z %Y-%m-%d %H:%M:%S")


def getDateBirth(filepath):
    return time.localtime(
                       os.path.getmtime(filepath)
           );


def getNewPathNameUnderSameDir(pathname, newBaseNameHint):
    dirName = os.path.dirname(pathname)
    extName = os.path.splitext(pathname)[1]
    newPathName = os.path.join(dirName, newBaseNameHint + extName)

    count = 1;
    while os.path.exists(newPathName):

        if pathname == newPathName:
            break

        assert count < 1000000 # impossible
        # '_' < [0-9A-Za-z]
        newPathName = os.path.join(dirName, newBaseNameHint + "_{:0>4X}".format(count) + extName)

        count += 1

    return newPathName


def do_gogogo(dirs, doMove):
    for adir in (os.path.abspath(i) for i in dirs):

        logging.basicConfig(level=logging.INFO, filename=os.path.join(adir, "Log_MyRenameByExif.txt"),
                            format='%(asctime)s %(levelname)s#%(lineno)d: %(message)s')

        # '_' < [0-9A-Za-z]
        for pathname in sorted(getMediaFiles(adir)):
            logging.info("Processing {}".format(pathname))

            isImg = isFilePathImg(pathname)
            isVideo = isFilePathVideo(pathname)

            assert os.path.isfile(pathname)
            assert (isImg or isVideo)

            prefix = None
            dateTakenTm = getImgDateTaken(pathname) if isImg else getVideoDateTaken(pathname)

            if dateTakenTm:
                prefix = "meta"
            else:
                dateTakenTm = getDateBirth(pathname)
                prefix = "FAKE"

            newPathName = getNewPathNameUnderSameDir(pathname, time.strftime('%Y%m%d_%H%M%S', dateTakenTm))

            if pathname == newPathName:
                logging.info("\tSkiping src = dst\n\n");
                continue

            if (doMove):
                logging.info("\t[{}] DO! --> {}\n\n".format(prefix, newPathName))
                os.rename(pathname, newPathName)
            else:
                logging.info("\t[{}] Will move --> {}\n\n".format(prefix, newPathName))


def gogogo(dirs, doMove=False):
    try:
        do_gogogo(dirs, doMove)
    except Exception:
        logging.critical(traceback.format_exc())

# default search path is CWD
if __name__ == '__main__':
    dirs = ["."]
    if len(sys.argv) > 1:
        dirs = sys.argv[1:]

    gogogo(dirs, doMove=False)