Add files via upload

filesystem.py

@@ -0,0 +1,295 @@
+"""
+General file system methods.
+
+.. moduleauthor:: Jaisen Mathai <jaisen@jmathai.com>
+"""
+from __future__ import print_function
+from builtins import object
+
+import os
+import re
+import shutil
+import time
+
+from elodie import geolocation
+from elodie import constants
+from elodie.localstorage import Db
+from elodie.media.media import Media
+from elodie.media.text import Text
+from elodie.media.audio import Audio
+from elodie.media.photo import Photo
+from elodie.media.video import Video
+
+
+class FileSystem(object):
+
+    """A class for interacting with the file system."""
+
+    def create_directory(self, directory_path):
+        """Create a directory if it does not already exist.
+
+        :param str directory_name: A fully qualified path of the
+            to create.
+        :returns: bool
+        """
+        try:
+            if os.path.exists(directory_path):
+                return True
+            else:
+                os.makedirs(directory_path)
+                return True
+        except OSError:
+            # OSError is thrown for cases like no permission
+            pass
+
+        return False
+
+    def delete_directory_if_empty(self, directory_path):
+        """Delete a directory only if it's empty.
+
+        Instead of checking first using `len([name for name in
+        os.listdir(directory_path)]) == 0`, we catch the OSError exception.
+
+        :param str directory_name: A fully qualified path of the directory
+            to delete.
+        """
+        try:
+            os.rmdir(directory_path)
+            return True
+        except OSError:
+            pass
+
+        return False
+
+    def get_all_files(self, path, extensions=None):
+        """Recursively get all files which match a path and extension.
+
+        :param str path string: Path to start recursive file listing
+        :param tuple(str) extensions: File extensions to include (whitelist)
+        """
+        files = []
+        for dirname, dirnames, filenames in os.walk(path):
+            # print path to all filenames.
+            for filename in filenames:
+                if(
+                    extensions is None or
+                    filename.lower().endswith(extensions)
+                ):
+                    files.append(os.path.join(dirname, filename))
+        return files
+
+    def get_current_directory(self):
+        """Get the current working directory.
+
+        :returns: str
+        """
+        return os.getcwd()
+
+    def get_file_name(self, media):
+        """Generate file name for a photo or video using its metadata.
+
+        We use an ISO8601-like format for the file name prefix. Instead of
+        colons as the separator for hours, minutes and seconds we use a hyphen.
+        https://en.wikipedia.org/wiki/ISO_8601#General_principles
+
+        :param media: A Photo or Video instance
+        :type media: :class:`~elodie.media.photo.Photo` or
+            :class:`~elodie.media.video.Video`
+        :returns: str or None for non-photo or non-videos
+        """
+        if(not media.is_valid()):
+            return None
+
+        metadata = media.get_metadata()
+        if(metadata is None):
+            return None
+
+        # If the file has EXIF title we use that in the file name
+        #   (i.e. my-favorite-photo-img_1234.jpg)
+        # We want to remove the date prefix we add to the name.
+        # This helps when re-running the program on file which were already
+        #   processed.
+        base_name = re.sub(
+            '^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-',
+            '',
+            metadata['base_name']
+        )
+        if(len(base_name) == 0):
+            base_name = metadata['base_name']
+
+        if(
+            'title' in metadata and
+            metadata['title'] is not None and
+            len(metadata['title']) > 0
+        ):
+            title_sanitized = re.sub('\W+', '-', metadata['title'].strip())
+            base_name = base_name.replace('-%s' % title_sanitized, '')
+            base_name = '%s-%s' % (base_name, title_sanitized)
+
+        file_name = '%s-%s.%s' % (
+            time.strftime(
+                '%Y-%m-%d_%H-%M-%S',
+                metadata['date_taken']
+            ),
+            base_name,
+            metadata['extension'])
+        return file_name.lower()
+
+    def get_folder_name_by_date(self, time_obj):
+        """Get date based folder name.
+
+        :param time time_obj: Time object to be used to determine folder name.
+        :returns: str
+        """
+        return time.strftime('%Y-%m-%b', time_obj)
+
+    def get_folder_path(self, metadata):
+        """Get folder path by various parameters.
+
+        :param time time_obj: Time object to be used to determine folder name.
+        :returns: str
+        """
+        path = []
+        if(metadata['date_taken'] is not None):
+            path.append(time.strftime('%Y-%m-%b', metadata['date_taken']))
+
+        if(metadata['album'] is not None):
+            path.append(metadata['album'])
+        elif(
+            metadata['latitude'] is not None and
+            metadata['longitude'] is not None
+        ):
+            place_name = geolocation.place_name(
+                metadata['latitude'],
+                metadata['longitude']
+            )
+            if(place_name is not None):
+                path.append(place_name)
+
+        # if we don't have a 2nd level directory we use 'Unknown Location'
+        if(len(path) < 2):
+            path.append('Unknown Location')
+
+        # return '/'.join(path[::-1])
+        return os.path.join(*path)
+
+    def process_file(self, _file, destination, media, **kwargs):
+        move = False
+        if('move' in kwargs):
+            move = kwargs['move']
+
+        allow_duplicate = False
+        if('allowDuplicate' in kwargs):
+            allow_duplicate = kwargs['allowDuplicate']
+
+        if(not media.is_valid()):
+            print('%s is not a valid media file. Skipping...' % _file)
+            return
+
+        metadata = media.get_metadata()
+
+        directory_name = self.get_folder_path(metadata)
+
+        dest_directory = os.path.join(destination, directory_name)
+        file_name = self.get_file_name(media)
+        dest_path = os.path.join(dest_directory, file_name)
+
+        db = Db()
+        checksum = db.checksum(_file)
+        if(checksum is None):
+            if(constants.debug is True):
+                print('Could not get checksum for %s. Skipping...' % _file)
+            return
+
+        # If duplicates are not allowed and this hash exists in the db then we
+        #   return
+        if(allow_duplicate is False and db.check_hash(checksum) is True):
+            if(constants.debug is True):
+                print('%s already exists at %s. Skipping...' % (
+                    _file,
+                    db.get_hash(checksum)
+                ))
+            return
+
+        self.create_directory(dest_directory)
+
+        if(move is True):
+            stat = os.stat(_file)
+            shutil.move(_file, dest_path)
+            os.utime(dest_path, (stat.st_atime, stat.st_mtime))
+        else:
+            shutil.copy(_file, dest_path)
+            self.set_date_from_filename(dest_path)
+
+        db.add_hash(checksum, dest_path)
+        db.update_hash_db()
+
+        return dest_path
+
+    def set_date_from_filename(self, file):
+        """ Set the modification time on the file base on the file name.
+        """
+    
+        date_taken = None
+        file_name = os.path.basename(file)
+        # Initialize date taken to what's returned from the metadata function.
+        # If the folder and file name follow a time format of
+        #   YYYY-MM/DD-IMG_0001.JPG then we override the date_taken
+        (year, month, day) = [None] * 3
+        year_month_day_match = re.search('(\d{4})-(\d{2})-(\d{2})', file_name)
+        if(year_month_day_match is not None):
+            (year, month, day) = year_month_day_match.groups()        
+
+        # check if the file system path indicated a date and if so we
+        #   override the metadata value
+        if(year is not None and month is not None and day is not None):
+                date_taken = time.strptime(
+                    '{}-{}-{}'.format(year, month, day),
+                    '%Y-%m-%d'
+                )            
+        
+                os.utime(file, (time.time(), time.mktime(date_taken)))
+    
+    def set_date_from_path_video(self, video):
+        """Set the modification time on the file based on the file path.
+
+        Noop if the path doesn't match the format YYYY-MM/DD-IMG_0001.JPG.
+
+        :param elodie.media.video.Video video: An instance of Video.
+        """
+        date_taken = None
+
+        video_file_path = video.get_file_path()
+
+        # Initialize date taken to what's returned from the metadata function.
+        # If the folder and file name follow a time format of
+        #   YYYY-MM/DD-IMG_0001.JPG then we override the date_taken
+        (year, month, day) = [None] * 3
+        directory = os.path.dirname(video_file_path)
+        # If the directory matches we get back a match with
+        #   groups() = (year, month)
+        year_month_match = re.search('(\d{4})-(\d{2})', directory)
+        if(year_month_match is not None):
+            (year, month) = year_month_match.groups()
+        day_match = re.search(
+            '^(\d{2})',
+            os.path.basename(video.get_file_path())
+        )
+        if(day_match is not None):
+            day = day_match.group(1)
+
+        # check if the file system path indicated a date and if so we
+        #   override the metadata value
+        if(year is not None and month is not None):
+            if(day is not None):
+                date_taken = time.strptime(
+                    '{}-{}-{}'.format(year, month, day),
+                    '%Y-%m-%d'
+                )
+            else:
+                date_taken = time.strptime(
+                    '{}-{}'.format(year, month),
+                    '%Y-%m'
+                )
+
+            os.utime(video_file_path, (time.time(), time.mktime(date_taken)))