Imported Upstream version 0.4.2upstream/0.4.2

1 files changed, 250 insertions, 72 deletions

diff --git a/rapid/rapid.py b/rapid/rapid.py
index 237c843..db5bdc6 100755
--- a/rapid/rapid.py
+++ b/rapid/rapid.py
@@ -68,6 +68,7 @@ import scan as scan_process
 import copyfiles
 import subfolderfile
 import backupfile
+from backupfile import PHOTO_BACKUP, VIDEO_BACKUP, PHOTO_VIDEO_BACKUP
 
 import errorlog
 
@@ -890,9 +891,10 @@ class ThumbnailDisplay(gtk.IconView):
     def generate_thumbnails(self, scan_pid):
         """Initiate thumbnail generation for files scanned in one process
         """
-        rpd_files = [self.rpd_files[unique_id] for unique_id in self.process_index[scan_pid]]
-        thumbnail_pid = self.thumbnail_manager.add_task((scan_pid, rpd_files))
-        self.generating_thumbnails[scan_pid] = thumbnail_pid
+        if scan_pid in self.process_index:
+            rpd_files = [self.rpd_files[unique_id] for unique_id in self.process_index[scan_pid]]
+            thumbnail_pid = self.thumbnail_manager.add_task((scan_pid, rpd_files))
+            self.generating_thumbnails[scan_pid] = thumbnail_pid
     
     def _set_thumbnail(self, unique_id, icon):
         treerowref = self.treerow_index[unique_id]
@@ -991,7 +993,7 @@ class ThumbnailDisplay(gtk.IconView):
             self.rapid_app.update_preview_image(unique_id, preview_image)
             
             # user can turn off option for thumbnail generation after a scan
-            if unique_id not in self.thumbnails:
+            if unique_id not in self.thumbnails and preview_small is not None:
                 self._set_thumbnail(unique_id, preview_small.get_image())
                 
     
@@ -1229,6 +1231,7 @@ class BackupFilesManager(TaskManager):
                        terminate_queue, run_event):
         path = task[0]
         name = task[1]
+        backup_type = task[2]
         backup_files = backupfile.BackupFiles(path, name, self.batch_size, 
                                         task_process_conn, terminate_queue, 
                                         run_event)
@@ -1236,22 +1239,36 @@ class BackupFilesManager(TaskManager):
         self._processes.append((backup_files, terminate_queue, run_event, 
                                 task_results_conn))
         
-        self.backup_devices_by_path[path] = (task_results_conn, backup_files.pid)
+        self.backup_devices_by_path[path] = (task_results_conn, backup_files.pid,
+                                            backup_type)
         
         return backup_files.pid
         
     def backup_file(self, move_succeeded, rpd_file, path_suffix, 
                                                 backup_duplicate_overwrite):
+
+        if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
+            logger.debug("Backing up photo %s", rpd_file.download_name)
+        else:
+            logger.debug("Backing up video %s", rpd_file.download_name)
+
         for path in self.backup_devices_by_path:
-            task_results_conn = self.backup_devices_by_path[path][0]
-            task_results_conn.send((move_succeeded, rpd_file, path_suffix, 
+            backup_type = self.backup_devices_by_path[path][2]
+            if ((backup_type == PHOTO_VIDEO_BACKUP) or 
+                    (rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO and backup_type == PHOTO_BACKUP) or
+                    (rpd_file.file_type == rpdfile.FILE_TYPE_VIDEO and backup_type == VIDEO_BACKUP)):
+                logger.debug("Backing up to %s", path)
+                task_results_conn = self.backup_devices_by_path[path][0]
+                task_results_conn.send((move_succeeded, rpd_file, path_suffix, 
                                     backup_duplicate_overwrite))
+            else:
+                logger.debug("Not backing up to %s", path)
             
-    def add_device(self, path, name):
+    def add_device(self, path, name, backup_type):
         """
         Convenience function to setup adding a backup device
         """
-        return self.add_task((path, name))
+        return self.add_task((path, name, backup_type))
     
     def remove_device(self, path):
         pid = self.backup_devices_by_path[path][1]
@@ -1643,10 +1660,10 @@ class RapidApp(dbus.service.Object):
     
     
     def _backup_device_name(self, path):
-        if self.backup_devices[path] is None:
+        if self.backup_devices[path][0] is None:
             name = path
         else:
-            name = self.backup_devices[path].get_name()
+            name = self.backup_devices[path][0].get_name()
         return name
         
     def start_device_scan(self, device):
@@ -1699,9 +1716,9 @@ class RapidApp(dbus.service.Object):
                             logger.info("%s ignored", mount.get_name())
                         else:
                             logger.info("Detected %s", mount.get_name())
-                            is_backup_mount = self.check_if_backup_mount(path)
+                            is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
                             if is_backup_mount:
-                                self.backup_devices[path] = mount
+                                self.backup_devices[path] = (mount, backup_file_type)
                             elif (self.prefs.device_autodetection and 
                                  (dv.is_DCIM_device(path) or 
                                   self.search_for_PSD())):
@@ -1723,14 +1740,8 @@ class RapidApp(dbus.service.Object):
 
         if self.prefs.backup_images:
             if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                # will backup to this path, but don't need any volume info 
-                # associated with it
-                self.backup_devices[self.prefs.backup_location] = None
-                
-            for path in self.backup_devices:
-                name = self._backup_device_name(path)
-                self.backup_manager.add_device(path, name)
+                self._setup_manual_backup()
+            self._add_backup_devices()
                 
         self.update_no_backup_devices()
         
@@ -1760,6 +1771,38 @@ class RapidApp(dbus.service.Object):
         if not mounts:
             self.set_download_action_sensitivity()
         
+    def _setup_manual_backup(self):
+        """
+        Setup backup devices that the user has manually specified.
+        Depending on the folder the user has chosen, the paths for photo and
+        video backup will either be the same or they will differ.
+        """
+        # user manually specified backup locations
+        # will backup to these paths, but don't need any volume info 
+        # associated with them        
+        self.backup_devices[self.prefs.backup_location] = (None, PHOTO_BACKUP)
+        if DOWNLOAD_VIDEO:
+            if self.prefs.backup_location <> self.prefs.backup_video_location:
+                self.backup_devices[self.prefs.backup_video_location] = (None, VIDEO_BACKUP)
+                logger.info("Backing up photos to %s", self.prefs.backup_location)
+                logger.info("Backing up videos to %s", self.prefs.backup_video_location)
+            else:
+                # videos and photos are being backed up to the same location
+                self.backup_devices[self.prefs.backup_location] = (None, PHOTO_VIDEO_BACKUP)
+                logger.info("Backing up photos and videos to %s", self.prefs.backup_location)
+        else:
+            logger.info("Backing up photos to %s", self.prefs.backup_location)
+            
+    def _add_backup_devices(self):
+        """
+        Add each backup devices / path to backup manager
+        """
+        for path in self.backup_devices:
+            name = self._backup_device_name(path)
+            backup_type = self.backup_devices[path][1]
+            self.backup_manager.add_device(path, name, backup_type)
+        
+        
     def get_use_device(self, device):  
         """ Prompt user whether or not to download from this device """
         
@@ -1797,26 +1840,67 @@ class RapidApp(dbus.service.Object):
         """
         return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
 
-    def check_if_backup_mount(self,  path):
+    def check_if_backup_mount(self, path):
         """
-        Checks to see if backups are enabled and path represents a valid backup location
+        Checks to see if backups are enabled and path represents a valid backup 
+        location. It must be writeable.
         
         Checks against user preferences.
+        
+        Returns a tuple:
+        (True, <backup-type> (one of PHOTO_VIDEO_BACKUP, PHOTO_BACKUP, or VIDEO_BACKUP)) or
+        (False, None) 
         """
-        identifiers = [self.prefs.backup_identifier]
-        if DOWNLOAD_VIDEO:
-            identifiers.append(self.prefs.video_backup_identifier)
         if self.prefs.backup_images:
             if self.prefs.backup_device_autodetection:
-                if dv.is_backup_media(path, identifiers):
-                    return True
+                # Determine if the auto-detected backup device is 
+                # to be used to backup only photos, or videos, or both.
+                # Use the presence of a corresponding directory to 
+                # determine this.
+                # The directory must be writable.
+                photo_path = os.path.join(path, self.prefs.backup_identifier)
+                p_backup = os.path.isdir(photo_path) and os.access(photo_path, os.W_OK)
+                if DOWNLOAD_VIDEO:
+                    video_path = os.path.join(path, self.prefs.video_backup_identifier)
+                    v_backup = os.path.isdir(video_path) and os.access(video_path, os.W_OK)
+                else:
+                    v_backup = False
+                if p_backup and v_backup:
+                    logger.info("Photos and videos will be backed up to %s", path)
+                    return (True, PHOTO_VIDEO_BACKUP)
+                elif p_backup:
+                    logger.info("Photos will be backed up to %s", path)
+                    return (True, PHOTO_BACKUP)
+                elif v_backup:
+                    logger.info("Videos will be backed up to %s", path)
+                    return (True, VIDEO_BACKUP)
             elif path == self.prefs.backup_location:
+                # user manually specified the path    
+                if os.access(self.prefs.backup_location, os.W_OK):
+                    return (True, PHOTO_BACKUP)
+            elif path == self.prefs.backup_video_location:
                 # user manually specified the path
-                return True
-        return False        
+                if os.access(self.prefs.backup_video_location, os.W_OK):
+                    return (True, VIDEO_BACKUP)
+        return (False, None)
 
     def update_no_backup_devices(self):
-        self.download_tracker.set_no_backup_devices(len(self.backup_devices))
+        self.no_photo_backup_devices = 0
+        self.no_video_backup_devices = 0
+        for path, value in self.backup_devices.iteritems():
+            backup_type = value[1]
+            if backup_type == PHOTO_BACKUP:
+                self.no_photo_backup_devices += 1
+            elif backup_type == VIDEO_BACKUP:
+                self.no_video_backup_devices += 1
+            else:
+                #both videos and photos are backed up to this device / path
+                self.no_photo_backup_devices += 1
+                self.no_video_backup_devices += 1
+        logger.info("# photo backup devices: %s; # video backup devices: %s", 
+                    self.no_photo_backup_devices, self.no_video_backup_devices)
+        self.download_tracker.set_no_backup_devices(self.no_photo_backup_devices, 
+                                                    self.no_video_backup_devices)
 
     def refresh_backup_media(self):
         """
@@ -1832,22 +1916,19 @@ class RapidApp(dbus.service.Object):
         self.backup_devices = {}
         if self.prefs.backup_images:
             if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                # will backup to this path, but don't need any volume info associated with it
-                self.backup_devices[self.prefs.backup_location] = None
+                self._setup_manual_backup()
             else:
                 for mount in self.vmonitor.get_mounts():
                     if not mount.is_shadowed():
                         path = mount.get_root().get_path()
                         if path:
-                            if self.check_if_backup_mount(path):
+                            is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
+                            if is_backup_mount:
                                 # is a backup volume
                                 if path not in self.backup_devices:
-                                    self.backup_devices[path] = mount
+                                    self.backup_devices[path] = (mount, backup_file_type)
             
-            for path in self.backup_devices:
-                name = self._backup_device_name(path)
-                self.backup_manager.add_device(path, name)
+            self._add_backup_devices()
 
         self.update_no_backup_devices()
         self.display_free_space()
@@ -1880,13 +1961,13 @@ class RapidApp(dbus.service.Object):
                 logger.info("Device %(device)s (%(path)s) ignored" % {
                             'device': mount.get_name(), 'path': path})
             else:
-                is_backup_mount = self.check_if_backup_mount(path)
+                is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
                             
                 if is_backup_mount:
                     if path not in self.backup_devices:
                         self.backup_devices[path] = mount
                         name = self._backup_device_name(path)
-                        self.backup_manager.add_device(path, name)
+                        self.backup_manager.add_device(path, name, backup_file_type)
                         self.update_no_backup_devices()
                         self.display_free_space()
 
@@ -2158,25 +2239,40 @@ class RapidApp(dbus.service.Object):
         """
         Initiate downloading and renaming of files
         """
-        
         # Check which file types will be downloaded for this particular process
-        if self.files_of_type_present(files, rpdfile.FILE_TYPE_PHOTO):
+        no_photos_to_download = self.files_of_type_present(files, 
+                                                    rpdfile.FILE_TYPE_PHOTO, 
+                                                    return_file_count=True)
+        if no_photos_to_download:
             photo_download_folder = self.prefs.download_folder
         else:
             photo_download_folder = None
             
-        if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
-            video_download_folder = self.prefs.video_download_folder
+        if DOWNLOAD_VIDEO:
+            no_videos_to_download = self.files_of_type_present(files, 
+                                        rpdfile.FILE_TYPE_VIDEO,
+                                        return_file_count=True)
+            if no_videos_to_download:
+                video_download_folder = self.prefs.video_download_folder
+            else:
+                video_download_folder = None
         else:
             video_download_folder = None
+            no_videos_to_download = 0
         
-        download_size = self.size_files_to_be_downloaded(files)
+        photo_download_size, video_download_size = self.size_files_to_be_downloaded(files)
         self.download_tracker.init_stats(scan_pid=scan_pid, 
-                                bytes=download_size,
-                                no_files=len(files))
+                                photo_size_in_bytes=photo_download_size, 
+                                video_size_in_bytes=video_download_size,
+                                no_photos_to_download=no_photos_to_download,
+                                no_videos_to_download=no_videos_to_download)
+        
+        
+        download_size = photo_download_size + video_download_size
         
         if self.prefs.backup_images:
-            download_size = download_size * (len(self.backup_devices) + 1)
+            download_size = download_size + ((self.no_photo_backup_devices * photo_download_size) +
+                                             (self.no_video_backup_devices * video_download_size))
             
         self.time_remaining.set(scan_pid, download_size)
         self.time_check.set_download_mark()
@@ -2276,10 +2372,6 @@ class RapidApp(dbus.service.Object):
         if rpd_file.status == config.STATUS_DOWNLOADED_WITH_WARNING:
             self.log_error(config.WARNING, rpd_file.error_title, 
                            rpd_file.error_msg, rpd_file.error_extra_detail)
-            self.error_title = ''
-            self.error_msg = ''
-            self.error_extra_detail = ''
-                           
                            
         if self.prefs.backup_images and len(self.backup_devices):
             if self.prefs.backup_device_autodetection:
@@ -2296,8 +2388,20 @@ class RapidApp(dbus.service.Object):
         else:
             self.file_download_finished(move_succeeded, rpd_file)
      
-     
+    
+    def multiple_backup_devices(self, file_type):
+        """Returns true if more than one backup device is being used for that
+        file type
+        """
+        return ((file_type == rpdfile.FILE_TYPE_PHOTO and 
+                 self.no_photo_backup_devices > 1) or
+                (file_type == rpdfile.FILE_TYPE_VIDEO and 
+                 self.no_video_backup_devices > 1))
+                                 
     def backup_results(self, source, condition):
+        """
+        Handle results sent from backup processes
+        """
         connection = self.backup_manager.get_pipe(source)
         conn_type, msg_data = connection.recv()
         if conn_type == rpdmp.CONN_PARTIAL:
@@ -2315,8 +2419,20 @@ class RapidApp(dbus.service.Object):
                 
             elif msg_type == rpdmp.MSG_FILE:
                 backup_succeeded, rpd_file = data
+                
+                # Only show an error message if there is more than one device
+                # backing up files of this type - if that is the case,
+                # do not want to reply on showing an error message in the 
+                # function file_download_finished, as it is only called once,
+                # when all files have been backed up
+                if not backup_succeeded and self.multiple_backup_devices(rpd_file.file_type):
+                    self.log_error(config.SERIOUS_ERROR, 
+                        rpd_file.error_title, 
+                        rpd_file.error_msg, rpd_file.error_extra_detail)
+                
                 self.download_tracker.file_backed_up(rpd_file.unique_id)
-                if self.download_tracker.all_files_backed_up(rpd_file.unique_id):
+                if self.download_tracker.all_files_backed_up(rpd_file.unique_id,
+                                                             rpd_file.file_type):
                     self.file_download_finished(backup_succeeded, rpd_file)
             return True
         else:
@@ -2324,10 +2440,13 @@ class RapidApp(dbus.service.Object):
 
     
     def file_download_finished(self, succeeded, rpd_file):
+        """
+        Called when a file has been downloaded i.e. copied, renamed, and backed up
+        """
         scan_pid = rpd_file.scan_pid
         unique_id = rpd_file.unique_id
         # Update error log window if neccessary
-        if not succeeded:
+        if not succeeded and not self.multiple_backup_devices(rpd_file.file_type):
             self.log_error(config.SERIOUS_ERROR, rpd_file.error_title, 
                            rpd_file.error_msg, rpd_file.error_extra_detail)
         elif self.prefs.auto_delete:
@@ -2340,7 +2459,7 @@ class RapidApp(dbus.service.Object):
                                                         rpd_file.file_type,
                                                         rpd_file.status)
                                                         
-        completed, files_remaining = self._update_file_download_device_progress(scan_pid, unique_id)
+        completed, files_remaining = self._update_file_download_device_progress(scan_pid, unique_id, rpd_file.file_type)
         
         if self.download_is_occurring():
             self.update_time_remaining()
@@ -2538,7 +2657,7 @@ class RapidApp(dbus.service.Object):
             self.display_summary_notification = False # don't show it again unless needed
       
         
-    def _update_file_download_device_progress(self, scan_pid, unique_id):
+    def _update_file_download_device_progress(self, scan_pid, unique_id, file_type):
         """
         Increments the progress bar for an individual device
         
@@ -2552,7 +2671,7 @@ class RapidApp(dbus.service.Object):
         file_types = self.download_tracker.get_file_types_present(scan_pid)
         completed = files_downloaded == files_to_download
         if completed and (self.prefs.backup_images and len(self.backup_devices)):
-            completed = self.download_tracker.all_files_backed_up(unique_id)
+            completed = self.download_tracker.all_files_backed_up(unique_id, file_type)
         
         if completed:
             files_remaining = self.thumbnails.get_no_files_remaining(scan_pid)
@@ -2649,6 +2768,11 @@ class RapidApp(dbus.service.Object):
         # related values in the preferences dialog window
         self.refresh_downloads_today = False
         
+        # these values are used to track the number of backup devices / 
+        # locations for each file type
+        self.no_photo_backup_devices = 0
+        self.no_video_backup_devices = 0
+        
         self.downloads_today_tracker = self.prefs.get_downloads_today_tracker()
         
         downloads_today = self.downloads_today_tracker.get_and_maybe_reset_downloads_today()
@@ -2669,6 +2793,7 @@ class RapidApp(dbus.service.Object):
         self.uses_session_sequece_no_value = Value(c_bool, self.prefs.any_pref_uses_session_sequece_no())
         self.uses_sequence_letter_value = Value(c_bool, self.prefs.any_pref_uses_sequence_letter_value())
         
+        self.check_prefs_upgrade(__version__)
         self.prefs.program_version = __version__
         
     def _check_for_sequence_value_use(self):
@@ -2676,6 +2801,33 @@ class RapidApp(dbus.service.Object):
         self.uses_session_sequece_no_value.value = self.prefs.any_pref_uses_session_sequece_no()
         self.uses_sequence_letter_value.value = self.prefs.any_pref_uses_sequence_letter_value()    
     
+    def check_prefs_upgrade(self, running_version):
+        """
+        Checks if the running version of the program is different from the 
+        version recorded in the preferences.
+        
+        If the version is different, the preferences are checked to see
+        whether they should be upgraded or not.
+        """
+        previous_version = self.prefs.program_version
+        if len(previous_version) > 0:
+            # the program has been run previously for this user
+        
+            pv = utilities.pythonify_version(previous_version)
+            rv = utilities.pythonify_version(running_version)
+        
+            if pv <> rv:
+                # 0.4.1 and below had only one manual backup location
+                # 0.4.2 introduced a distinct video back up location that can be manually set
+                # Therefore must duplicate the previous photo & video manual backup location into the 
+                # new video field, unless it has already been changed already.
+                
+                if pv < utilities.pythonify_version('0.4.2'):
+                    if self.prefs.backup_video_location == os.path.expanduser('~'):
+                        self.prefs.backup_video_location = self.prefs.backup_location
+                        logger.info("Migrated manual backup location preference to videos: %s", 
+                                    self.prefs.backup_video_location)
+    
     def on_preference_changed(self, key, value):
         """
         Called when user changes the program's preferences
@@ -2691,7 +2843,9 @@ class RapidApp(dbus.service.Object):
             if not self.preferences_dialog_displayed:
                 self.post_preference_change()
                 
-        elif key in ['backup_images', 'backup_device_autodetection', 'backup_location', 'backup_identifier', 'video_backup_identifier']:
+        elif key in ['backup_images', 'backup_device_autodetection', 
+                     'backup_location', 'backup_video_location', 
+                     'backup_identifier', 'video_backup_identifier']:
             self.rerun_setup_available_backup_media = True
             if not self.preferences_dialog_displayed:
                 self.post_preference_change()
@@ -2954,7 +3108,7 @@ class RapidApp(dbus.service.Object):
                 elif i == (v - 1) :
                     prefix = " " + _("and")  + " "
             i += 1
-            message = "%s%s'%s'" % (message,  prefix, self.backup_devices[b].get_name())
+            message = "%s%s'%s'" % (message,  prefix, self.backup_devices[b][0].get_name())
         
         if v > 1:
             message = _("Using backup devices") + " %s" % message
@@ -3025,8 +3179,18 @@ class RapidApp(dbus.service.Object):
             
         if self.prefs.backup_images: 
             if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
+                if self.prefs.backup_location == self.prefs.backup_video_location:
+                    if DOWNLOAD_VIDEO:
+                        # user manually specified the same location for photos and video backups
+                        msg2 = _('Backing up photos and videos to %(path)s') % {'path':self.prefs.backup_location}
+                    else:
+                        # user manually specified backup location
+                        msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
+                else:
+                    # user manually specified different locations for photo and video backups
+                    msg2 = _('Backing up photos to %(path)s and videos to %(path2)s') % {
+                             'path':self.prefs.backup_location,
+                             'path2': self.prefs.backup_video_location}
             else:
                 msg2 = self.display_backup_mounts() 
                 
@@ -3070,25 +3234,39 @@ class RapidApp(dbus.service.Object):
     # Utility functions
     # # #
 
-    def files_of_type_present(self, files, file_type):
+    def files_of_type_present(self, files, file_type, return_file_count=False):
         """
         Returns true if there is at least one instance of the file_type
         in the list of files to be copied
+        
+        If return_file_count is True, then the number of files of that type
+        will be counted and returned instead of True or False
         """
+        i = 0
         for rpd_file in files:
             if rpd_file.file_type == file_type:
-                return True
-        return False
-        
+                if return_file_count:
+                    i += 1
+                else:
+                    return True
+        if not return_file_count:
+            return False
+        else:
+            return i
+                
     def size_files_to_be_downloaded(self, files):
         """
-        Returns the total size of the files to be downloaded in bytes
+        Returns the total sizes of the photos and videos to be downloaded in bytes
         """
-        size = 0
-        for i in range(len(files)):
-            size += files[i].size
+        photo_size = 0
+        video_size = 0
+        for rpd_file in files:
+            if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
+                photo_size += rpd_file.size
+            else:
+                video_size += rpd_file.size
 
-        return size
+        return (photo_size, video_size)
                                               
     def check_download_folder_validity(self, files_by_scan_pid):
         """