summaryrefslogtreecommitdiff
path: root/raphodo/preferences.py
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2018-01-04 08:57:25 +0100
committerJörg Frings-Fürst <debian@jff-webhosting.net>2018-01-04 08:57:25 +0100
commit8ce494b17065c724187dd3f9faec1e419496f871 (patch)
treefa0c7fb1296f30bfd0cdc241c7556cec8d1e8ba1 /raphodo/preferences.py
parent18afe3e2ebdb10bbc542d79280344d9adf923d2f (diff)
parenteba0a9bd6f142cdb299cc070060723d00e81205f (diff)
Merge branch 'feature/upstream' into develop
Diffstat (limited to 'raphodo/preferences.py')
-rw-r--r--raphodo/preferences.py1030
1 files changed, 1030 insertions, 0 deletions
diff --git a/raphodo/preferences.py b/raphodo/preferences.py
new file mode 100644
index 0000000..001c147
--- /dev/null
+++ b/raphodo/preferences.py
@@ -0,0 +1,1030 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2011-2017 Damon Lynch <damonlynch@gmail.com>
+
+# This file is part of Rapid Photo Downloader.
+#
+# Rapid Photo Downloader is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Rapid Photo Downloader is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Rapid Photo Downloader. If not,
+# see <http://www.gnu.org/licenses/>.
+
+__author__ = 'Damon Lynch'
+__copyright__ = "Copyright 2011-2017, Damon Lynch"
+
+import logging
+import re
+import os
+import pkg_resources
+import datetime
+from typing import List, Tuple, Optional
+
+from PyQt5.QtCore import QSettings, QTime, Qt
+
+from gettext import gettext as _
+
+from raphodo.storage import (
+ xdg_photos_directory, xdg_videos_directory, xdg_photos_identifier, xdg_videos_identifier
+)
+from raphodo.generatenameconfig import *
+import raphodo.constants as constants
+from raphodo.constants import PresetPrefType
+from raphodo.utilities import available_cpu_count, make_internationalized_list
+import raphodo.__about__
+from raphodo.rpdfile import ALL_KNOWN_EXTENSIONS
+
+
+class ScanPreferences:
+ r"""
+ Handle user preferences while scanning devices like memory cards,
+ cameras or the filesystem.
+
+ Sets data attribute valid to True if ignored paths are valid. An ignored
+ path is always assumed to be valid unless regular expressions are used.
+ If regular expressions are used, then it is valid only if a valid
+ regular expression can be compiled from each line.
+
+ >>> no_ignored_paths = ScanPreferences([])
+ >>> no_ignored_paths.valid
+ True
+
+ >>> some_paths = ScanPreferences(['.Trash', '.thumbnails'])
+ >>> some_paths.valid
+ True
+
+ >>> some_re_paths = ScanPreferences(['.Trash', '\.[tT]humbnails'], True)
+ >>> some_re_paths.valid
+ True
+
+ >>> some_more_re_paths = ScanPreferences(['.Trash', '\.[tThumbnails'], True)
+ >>> some_more_re_paths.valid
+ False
+ """
+
+ def __init__(self, ignored_paths, use_regular_expressions=False):
+ """
+ :type ignored_paths: List[str]
+ :type use_regular_expressions: bool
+ """
+
+ self.ignored_paths = ignored_paths
+ self.use_regular_expressions = use_regular_expressions
+
+ if ignored_paths and use_regular_expressions:
+ self.valid = self._check_and_compile_re()
+ else:
+ self.re_pattern = None
+ self.valid = True
+
+ def scan_this_path(self, path: str) -> bool:
+ """
+ Returns true if the path should be included in the scan.
+ Assumes path is a full path
+
+ :return: True|False
+ """
+
+ # see method list_not_empty() in Preferences class to see
+ # what an "empty" list is: ['']
+ if not (self.ignored_paths and self.ignored_paths[0]):
+ return True
+
+ if not self.use_regular_expressions:
+ return not path.endswith(tuple(self.ignored_paths))
+
+ return not self.re_pattern.match(path)
+
+ def _check_and_compile_re(self) -> bool:
+ """
+ Take the ignored paths and attempt to compile a regular expression
+ out of them. Checks line by line.
+
+ :return: True if there were no problems creating the regular
+ expression pattern
+ """
+
+ assert self.use_regular_expressions
+
+ error_encountered = False
+ pattern = ''
+ for path in self.ignored_paths:
+ # check path for validity
+ try:
+ re.match(path, '')
+ pattern += '.*{}s$|'.format(path)
+ except re.error:
+ logging.error("Ignoring malformed regular expression: {}".format(path))
+ error_encountered = True
+
+ if pattern:
+ pattern = pattern[:-1]
+
+ try:
+ self.re_pattern = re.compile(pattern)
+ except re.error:
+ logging.error('This regular expression is invalid: {}'.format(pattern))
+ self.re_pattern = None
+ error_encountered = True
+
+ logging.debug("Ignored paths regular expression pattern: {}".format(pattern))
+
+ return not error_encountered
+
+
+class DownloadsTodayTracker:
+ """
+ Handles tracking the number of successful downloads undertaken
+ during any one day.
+
+ When a day starts is flexible. See for more details:
+ http://damonlynch.net/rapid/documentation/#renameoptions
+ """
+
+ def __init__(self, downloads_today: List[str], day_start: str) -> None:
+ """
+
+ :param downloads_today: list[str,str] containing date and the
+ number of downloads today e.g. ['2015-08-15', '25']
+ :param day_start: the time the day starts, e.g. "03:00"
+ indicates the day starts at 3 a.m.
+ """
+ self.day_start = day_start
+ self.downloads_today = downloads_today
+
+ def get_or_reset_downloads_today(self) -> int:
+ """
+ Primary method to get the Downloads Today value, because it
+ resets the value if no downloads have already occurred on the
+ day of the download.
+ :return: the number of successful downloads that have occurred
+ today
+ """
+ v = self.get_downloads_today()
+ if v <= 0:
+ self.reset_downloads_today()
+ # -1 was returned in the Gtk+ version of Rapid Photo Downloader -
+ # why?
+ v = 0
+ return v
+
+ def get_downloads_today(self) -> int:
+ """
+ :return the preference value for the number of successful
+ downloads performed today. If value is less than zero,
+ the date has changed since the value was last updated.
+ """
+
+ hour, minute = self.get_day_start()
+ try:
+ adjusted_today = datetime.datetime.strptime(
+ "%s %s:%s" % (self.downloads_today[0], hour, minute),
+ "%Y-%m-%d %H:%M")
+ except:
+ logging.critical(
+ "Failed to calculate date adjustment. Download today values "
+ "appear to be corrupted: %s %s:%s",
+ self.downloads_today[0], hour, minute)
+ adjusted_today = None
+
+ now = datetime.datetime.today()
+
+ if adjusted_today is None:
+ return -1
+
+ if now < adjusted_today:
+ try:
+ return int(self.downloads_today[1])
+ except ValueError:
+ logging.error(
+ "Invalid Downloads Today value. Resetting value to zero.")
+ self.reset_downloads_today()
+ return 0
+ else:
+ return -1
+
+ def get_day_start(self) -> Tuple[int, int]:
+ """
+ :return: hour and minute components as Tuple of ints
+ """
+ try:
+ t1, t2 = self.day_start.split(":")
+ return int(t1), int(t2)
+ except ValueError:
+ logging.error(
+ "'Start of day' preference value %s is corrupted. Resetting "
+ "to midnight",
+ self.day_start)
+ self.day_start = "0:0"
+ return 0, 0
+
+ def increment_downloads_today(self) -> bool:
+ """
+ :return: True if day changed
+ """
+ v = self.get_downloads_today()
+ if v >= 0:
+ self.set_downloads_today(self.downloads_today[0], v + 1)
+ return False
+ else:
+ self.reset_downloads_today(1)
+ return True
+
+ def reset_downloads_today(self, value: int=0) -> None:
+ now = datetime.datetime.today()
+ hour, minute = self.get_day_start()
+ t = datetime.time(hour, minute)
+ if now.time() < t:
+ date = today()
+ else:
+ d = datetime.datetime.today() + datetime.timedelta(days=1)
+ date = d.strftime(('%Y-%m-%d'))
+
+ self.set_downloads_today(date, value)
+
+ def set_downloads_today(self, date: str, value: int=0) -> None:
+ self.downloads_today = [date, str(value)]
+
+ def set_day_start(self, hour: int, minute: int) -> None:
+ self.day_start = "%s:%s" % (hour, minute)
+
+ def log_vals(self) -> None:
+ logging.info("Date %s Value %s Day start %s", self.downloads_today[0],
+ self.downloads_today[1], self.day_start)
+
+
+def today():
+ return datetime.date.today().strftime('%Y-%m-%d')
+
+
+class Preferences:
+ """
+ Program preferences, being a mix of user facing and non-user facing prefs.
+ """
+ program_defaults = dict(program_version='')
+ rename_defaults = dict(
+ photo_download_folder=xdg_photos_directory(),
+ video_download_folder=xdg_videos_directory(),
+ photo_subfolder=DEFAULT_SUBFOLDER_PREFS,
+ video_subfolder=DEFAULT_VIDEO_SUBFOLDER_PREFS,
+ photo_rename=DEFAULT_PHOTO_RENAME_PREFS,
+ video_rename=DEFAULT_VIDEO_RENAME_PREFS,
+ # following two extension values introduced in 0.9.0a4:
+ photo_extension=LOWERCASE,
+ video_extension=LOWERCASE,
+ day_start="03:00",
+ downloads_today=[today(), '0'],
+ stored_sequence_no=0,
+ strip_characters=True,
+ synchronize_raw_jpg=False,
+ job_codes=[_('Wedding'), _('Birthday')],
+ remember_job_code=True,
+ ignore_mdatatime_for_mtp_dng=True,
+ )
+
+ # custom preset prefs are define below in code such as get_preset()
+ timeline_defaults = dict(proximity_seconds=3600)
+
+ display_defaults = dict(
+ detailed_time_remaining=False,
+ warn_downloading_all=True,
+ warn_backup_problem=True,
+ warn_broken_or_missing_libraries=True,
+ warn_fs_metadata_error=True,
+ warn_unhandled_files=True,
+ ignore_unhandled_file_exts=['TMP', 'DAT'],
+ job_code_sort_key=0,
+ job_code_sort_order=0,
+ did_you_know_on_startup=True,
+ did_you_know_index=0,
+ # see constants.CompletedDownloads:
+ completed_downloads=3,
+ consolidate_identical=True,
+ # see constants.TreatRawJpeg:
+ treat_raw_jpeg=2,
+ # see constants.MarkRawJpeg:
+ mark_raw_jpeg=3,
+ # introduced in 0.9.6b1:
+ auto_scroll=True
+ )
+ device_defaults = dict(
+ only_external_mounts=True,
+ device_autodetection=True,
+ this_computer_source = False,
+ this_computer_path='',
+ scan_specific_folders=True,
+ # pre 0.9.3a1 value: device_without_dcim_autodetection=False, is now replaced by
+ # scan_specific_folders
+ folders_to_scan=['DCIM', 'PRIVATE', 'MP_ROOT'],
+ ignored_paths=['.Trash', '.thumbnails'],
+ use_re_ignored_paths=False,
+ volume_whitelist=[''],
+ volume_blacklist=[''],
+ camera_blacklist=[''],
+ )
+ backup_defaults = dict(
+ backup_files=False,
+ backup_device_autodetection=True,
+ photo_backup_identifier=xdg_photos_identifier(),
+ video_backup_identifier=xdg_videos_identifier(),
+ backup_photo_location=os.path.expanduser('~'),
+ backup_video_location=os.path.expanduser('~'),
+ )
+ automation_defaults = dict(
+ auto_download_at_startup=False,
+ auto_download_upon_device_insertion=False,
+ auto_unmount=False,
+ auto_exit=False,
+ auto_exit_force=False,
+ move=False,
+ verify_file=False
+ )
+ performance_defaults = dict(
+ generate_thumbnails=True,
+ use_thumbnail_cache=True,
+ save_fdo_thumbnails=True,
+ max_cpu_cores=max(available_cpu_count(physical_only=True), 2),
+ keep_thumbnails_days=30
+ )
+ error_defaults = dict(
+ conflict_resolution=int(constants.ConflictResolution.skip),
+ backup_duplicate_overwrite=False
+ )
+ destinations = dict(
+ photo_backup_destinations=[''],
+ video_backup_destinations=['']
+ )
+ version_check = dict(
+ check_for_new_versions=True,
+ include_development_release=False,
+ ignore_versions=['']
+ )
+ restart_directives = dict(
+ purge_thumbnails=False,
+ optimize_thumbnail_db=False
+ )
+
+
+ def __init__(self) -> None:
+ # To avoid infinite recursions arising from the use of __setattr__,
+ # manually assign class values to the class dict
+ self.__dict__['settings'] = QSettings("Rapid Photo Downloader", "Rapid Photo Downloader")
+ self.__dict__['valid'] = True
+
+ # These next two values must be kept in sync
+ dicts = (self.program_defaults, self.rename_defaults,
+ self.timeline_defaults, self.display_defaults,
+ self.device_defaults,
+ self.backup_defaults, self.automation_defaults,
+ self.performance_defaults, self.error_defaults,
+ self.destinations, self.version_check, self.restart_directives)
+ group_names = ('Program', 'Rename', 'Timeline', 'Display', 'Device', 'Backup',
+ 'Automation', 'Performance', 'ErrorHandling', 'Destinations',
+ 'VersionCheck', 'RestartDirectives')
+ assert len(dicts) == len(group_names)
+
+ # Create quick lookup table for types of each value, including the
+ # special case of lists, which use the type of what they contain.
+ # While we're at it also merge the dictionaries into one dictionary
+ # of default values.
+ self.__dict__['types'] = {}
+ self.__dict__['defaults'] = {}
+ for d in dicts:
+ for key, value in d.items():
+ if isinstance(value, list):
+ t = type(value[0])
+ else:
+ t = type(value)
+ self.types[key] = t
+ self.defaults[key] = value
+ # Create quick lookup table of the group each key is in
+ self.__dict__['groups'] = {}
+ for idx, d in enumerate(dicts):
+ for key in d:
+ self.groups[key] = group_names[idx]
+
+ def __getitem__(self, key):
+ group = self.groups.get(key, 'General')
+ self.settings.beginGroup(group)
+ v = self.settings.value(key, self.defaults[key], self.types[key])
+ self.settings.endGroup()
+ return v
+
+ def __getattr__(self, key):
+ return self[key]
+
+ def __setitem__(self, key, value):
+ group = self.groups.get(key, 'General')
+ self.settings.beginGroup(group)
+ self.settings.setValue(key, value)
+ self.settings.endGroup()
+
+ def __setattr__(self, key, value):
+ self[key] = value
+
+ def value_is_set(self, key, group: Optional[str]=None) -> bool:
+ if group is None:
+ group = 'General'
+
+ group = self.groups.get(key, group)
+ self.settings.beginGroup(group)
+ v = self.settings.contains(key)
+ self.settings.endGroup()
+ return v
+
+ def sync(self):
+ self.settings.sync()
+
+ def restore(self, key: str) -> None:
+ self[key] = self.defaults[key]
+
+ def get_preset(self, preset_type: PresetPrefType) -> Tuple[List[str],
+ List[List[str]]]:
+ """
+ Returns the custom presets for the particular type.
+
+ :param preset_type: one of photo subfolder, video subfolder, photo
+ rename, or video rename
+ :return: Tuple of list of present names and list of pref lists. Each
+ item in the first list corresponds with the item of the same index in the
+ second list.
+ """
+
+ preset_pref_lists = []
+ preset_names = []
+
+ self.settings.beginGroup('Presets')
+
+ preset = preset_type.name
+ size = self.settings.beginReadArray(preset)
+ for i in range(size):
+ self.settings.setArrayIndex(i)
+ preset_names.append(self.settings.value('name', type=str))
+ preset_pref_lists.append(self.settings.value('pref_list', type=str))
+ self.settings.endArray()
+
+ self.settings.endGroup()
+
+ return preset_names, preset_pref_lists
+
+ def set_preset(self, preset_type: PresetPrefType,
+ preset_names: List[str],
+ preset_pref_lists: List[str]) -> None:
+ """
+ Saves a list of custom presets in the user's preferences.
+
+ If the list of preset names is empty, the preference value will be cleared.
+
+ :param preset_type: one of photo subfolder, video subfolder, photo
+ rename, or video rename
+ :param preset_names: list of names for each pref list
+ :param preset_pref_lists: the list of pref lists
+ """
+
+ self.settings.beginGroup('Presets')
+
+ preset = preset_type.name
+
+ # Clear all the existing presets with that name.
+ # If we don't do this, when the array shrinks, old values can hang around,
+ # even though the array size is set correctly.
+ self.settings.remove(preset)
+
+ self.settings.beginWriteArray(preset)
+ for i in range(len(preset_names)):
+ self.settings.setArrayIndex(i)
+ self.settings.setValue('name', preset_names[i])
+ self.settings.setValue('pref_list', preset_pref_lists[i])
+ self.settings.endArray()
+
+ self.settings.endGroup()
+
+ def get_proximity(self) -> int:
+ """
+ Validates preference value proxmity_seconds against standard list.
+
+ Given the user could enter any old value into the preferences, need to validate it.
+ The validation technique is to match whatever value is in the preferences with the
+ closest value we need, which is found in the list of int proximity_time_steps.
+
+ For the algorithm, see:
+ http://stackoverflow.com/questions/12141150/from-list-of-integers-get-number-closest-to-a
+ -given-value
+ No need to use bisect list, as our list is tiny, and using min has the advantage
+ of getting the closest value.
+
+ Note: we store the value in seconds, but use it in minutes, just in case a user one day
+ makes a compelling case to be able to specify a proximity value less than 1 minute.
+
+ :return: closest valid value in minutes
+ """
+
+ minutes = self.proximity_seconds // 60
+ return min(constants.proximity_time_steps, key=lambda x:abs(x - minutes))
+
+ def set_proximity(self, minutes: int) -> None:
+ self.proximity_seconds = minutes * 60
+
+ def _pref_list_uses_component(self, pref_list, pref_component, offset: int=1) -> bool:
+ for i in range(0, len(pref_list), 3):
+ if pref_list[i+offset] == pref_component:
+ return True
+ return False
+
+ def any_pref_uses_stored_sequence_no(self) -> bool:
+ """
+ :return True if any of the pref lists contain a stored sequence no
+ """
+ for pref_list in self.get_pref_lists():
+ if self._pref_list_uses_component(pref_list, STORED_SEQ_NUMBER):
+ return True
+ return False
+
+ def any_pref_uses_session_sequence_no(self) -> bool:
+ """
+ :return True if any of the pref lists contain a session sequence no
+ """
+ for pref_list in self.get_pref_lists():
+ if self._pref_list_uses_component(pref_list, SESSION_SEQ_NUMBER):
+ return True
+ return False
+
+ def any_pref_uses_sequence_letter_value(self) -> bool:
+ """
+ :return True if any of the pref lists contain a sequence letter
+ """
+ for pref_list in self.get_pref_lists():
+ if self._pref_list_uses_component(pref_list, SEQUENCE_LETTER):
+ return True
+ return False
+
+ def photo_rename_pref_uses_downloads_today(self) -> bool:
+ """
+ :return: True if the photo rename pref list contains a downloads today
+ """
+ return self._pref_list_uses_component(self.photo_rename, DOWNLOAD_SEQ_NUMBER)
+
+ def video_rename_pref_uses_downloads_today(self) -> bool:
+ """
+ :return: True if the video rename pref list contains a downloads today
+ """
+ return self._pref_list_uses_component(self.video_rename, DOWNLOAD_SEQ_NUMBER)
+
+ def photo_rename_pref_uses_stored_sequence_no(self) -> bool:
+ """
+ :return: True if the photo rename pref list contains a stored sequence no
+ """
+ return self._pref_list_uses_component(self.photo_rename, STORED_SEQ_NUMBER)
+
+ def video_rename_pref_uses_stored_sequence_no(self) -> bool:
+ """
+ :return: True if the video rename pref list contains a stored sequence no
+ """
+ return self._pref_list_uses_component(self.video_rename, STORED_SEQ_NUMBER)
+
+ def check_prefs_for_validity(self) -> Tuple[bool, str]:
+ """
+ Checks photo & video rename, and subfolder generation
+ preferences ensure they follow name generation rules. Moreover,
+ subfolder name specifications must not:
+ 1. start with a separator
+ 2. end with a separator
+ 3. have two separators in a row
+
+ :return: tuple with two values: (1) bool and error message if
+ prefs are invalid (else empy string)
+ """
+
+ msg = ''
+ valid = True
+ tests = (
+ (self.photo_rename, DICT_IMAGE_RENAME_L0),
+ (self.video_rename, DICT_VIDEO_RENAME_L0),
+ (self.photo_subfolder, DICT_SUBFOLDER_L0),
+ (self.video_subfolder, DICT_VIDEO_SUBFOLDER_L0)
+ )
+
+ # test file renaming
+ for pref, pref_defn in tests[:2]:
+ try:
+ check_pref_valid(pref_defn, pref)
+ except PrefError as e:
+ valid = False
+ msg += e.msg + "\n"
+
+ # test subfolder generation
+ for pref, pref_defn in tests[2:]:
+ try:
+ check_pref_valid(pref_defn, pref)
+
+ L1s = [pref[i] for i in range(0, len(pref), 3)]
+
+ if L1s[0] == SEPARATOR:
+ raise PrefValueKeyComboError(
+ _("Subfolder preferences should not start with a %s") % os.sep
+ )
+ elif L1s[-1] == SEPARATOR:
+ raise PrefValueKeyComboError(
+ _("Subfolder preferences should not end with a %s") % os.sep
+ )
+ else:
+ for i in range(len(L1s) - 1):
+ if L1s[i] == SEPARATOR and L1s[i + 1] == SEPARATOR:
+ raise PrefValueKeyComboError(
+ _(
+ "Subfolder preferences should not contain two %s one after "
+ "the other"
+ ) % os.sep
+ )
+
+ except PrefError as e:
+ valid = False
+ msg += e.msg + "\n"
+
+ return valid, msg
+
+ def _filter_duplicate_generation_prefs(self, preset_type: PresetPrefType) -> None:
+ preset_names, preset_pref_lists = self.get_preset(preset_type=preset_type)
+ seen = set()
+ filtered_names = []
+ filtered_pref_lists = []
+ duplicates = []
+ for name, pref_list in zip(preset_names, preset_pref_lists):
+ value = tuple(pref_list)
+ if value in seen:
+ duplicates.append(name)
+ else:
+ seen.add(value)
+ filtered_names.append(name)
+ filtered_pref_lists.append(pref_list)
+
+ if duplicates:
+ human_readable = preset_type.name[len('preset_'):].replace('_', ' ')
+ logging.warning(
+ 'Removed %s duplicate(s) from %s presets: %s',
+ len(duplicates), human_readable, make_internationalized_list(duplicates)
+ )
+ self.set_preset(
+ preset_type=preset_type, preset_names=filtered_names,
+ preset_pref_lists=filtered_pref_lists
+ )
+
+ def filter_duplicate_generation_prefs(self) -> None:
+ """
+ Remove any duplicate subfolder generation or file renaming custom presets
+ """
+
+ logging.info("Checking for duplicate name generation preference values")
+ for preset_type in PresetPrefType:
+ self._filter_duplicate_generation_prefs(preset_type)
+
+ def must_synchronize_raw_jpg(self) -> bool:
+ """
+ :return: True if synchronize_raw_jpg is True and photo
+ renaming uses sequence values
+ """
+ if self.synchronize_raw_jpg:
+ for s in LIST_SEQUENCE_L1:
+ if self._pref_list_uses_component(self.photo_rename, s, 1):
+ return True
+ return False
+
+ def format_pref_list_for_pretty_print(self, pref_list) -> str:
+ """
+ :return: string useful for printing the preferences
+ """
+
+ v = ''
+ for i in range(0, len(pref_list), 3):
+ if (pref_list[i+1] or pref_list[i+2]):
+ c = ':'
+ else:
+ c = ''
+ s = "%s%s " % (pref_list[i], c)
+
+ if pref_list[i+1]:
+ s = "%s%s" % (s, pref_list[i+1])
+ if pref_list[i+2]:
+ s = "%s (%s)" % (s, pref_list[i+2])
+ v += s + "\n"
+ return v
+
+ def get_pref_lists(self) -> Tuple[List[str], List[str], List[str], List[str]]:
+ """
+ :return: a tuple of the photo & video rename and subfolder
+ generation preferences
+ """
+ return self.photo_rename, self.photo_subfolder, self.video_rename, self.video_subfolder
+
+ def get_day_start_qtime(self) -> QTime:
+ """
+ :return: day start time in QTime format, resetting to midnight on value error
+ """
+ try:
+ h, m = self.day_start.split(":")
+ h = int(h)
+ m = int(m)
+ assert 0 <= h <= 23
+ assert 0 <= m <= 59
+ return QTime(h, m)
+ except (ValueError, AssertionError):
+ logging.error(
+ "'Start of day' preference value %s is corrupted. Resetting to midnight.",
+ self.day_start)
+ self.day_start = "0:0"
+ return QTime(0, 0)
+
+ def get_checkable_value(self, key: str) -> Qt.CheckState:
+ """
+ Gets a boolean preference value using Qt's CheckState values
+ :param key: the preference item to get
+ :return: value converted from bool to an Qt.CheckState enum value
+ """
+
+ value = self[key]
+ if value:
+ return Qt.Checked
+ else:
+ return Qt.Unchecked
+
+ def pref_uses_job_code(self, pref_list: List[str]):
+ """ Returns True if the particular preferences contains a job code"""
+ for i in range(0, len(pref_list), 3):
+ if pref_list[i] == JOB_CODE:
+ return True
+ return False
+
+ def any_pref_uses_job_code(self) -> bool:
+ """ Returns True if any of the preferences contain a job code"""
+ for pref_list in self.get_pref_lists():
+ if self.pref_uses_job_code(pref_list):
+ return True
+ return False
+
+ def most_recent_job_code(self, missing: Optional[str]=None) -> str:
+ """
+ Get the most recent Job Code used (which is assumed to be at the top).
+ :param missing: If there is no Job Code, and return this default value
+ :return: most recent job code, or missing, or if not found, ''
+ """
+
+ if len(self.job_codes) > 0:
+ value = self.job_codes[0]
+ return value or missing or ''
+ elif missing is not None:
+ return missing
+ else:
+ return ''
+
+ def photo_subfolder_index(self, preset_pref_lists: List[List[str]]) -> int:
+ """
+ Matches the photo pref list with program subfolder generation
+ defaults and the user's presets.
+
+ :param preset_pref_lists: list of custom presets
+ :return: -1 if no match (i.e. custom), or the index into
+ PHOTO_SUBFOLDER_MENU_DEFAULTS + photo subfolder presets if it matches
+ """
+
+ subfolders = PHOTO_SUBFOLDER_MENU_DEFAULTS_CONV + tuple(preset_pref_lists)
+ try:
+ return subfolders.index(self.photo_subfolder)
+ except ValueError:
+ return -1
+
+ def video_subfolder_index(self, preset_pref_lists: List[List[str]]) -> int:
+ """
+ Matches the photo pref list with program subfolder generation
+ defaults and the user's presets.
+
+ :param preset_pref_lists: list of custom presets
+ :return: -1 if no match (i.e. custom), or the index into
+ VIDEO_SUBFOLDER_MENU_DEFAULTS + video subfolder presets if it matches
+ """
+
+ subfolders = VIDEO_SUBFOLDER_MENU_DEFAULTS_CONV + tuple(preset_pref_lists)
+ try:
+ return subfolders.index(self.video_subfolder)
+ except ValueError:
+ return -1
+
+ def photo_rename_index(self, preset_pref_lists: List[List[str]]) -> int:
+ """
+ Matches the photo pref list with program filename generation
+ defaults and the user's presets.
+
+ :param preset_pref_lists: list of custom presets
+ :return: -1 if no match (i.e. custom), or the index into
+ PHOTO_RENAME_MENU_DEFAULTS_CONV + photo rename presets if it matches
+ """
+
+ rename = PHOTO_RENAME_MENU_DEFAULTS_CONV + tuple(preset_pref_lists)
+ try:
+ return rename.index(self.photo_rename)
+ except ValueError:
+ return -1
+
+ def video_rename_index(self, preset_pref_lists: List[List[str]]) -> int:
+ """
+ Matches the video pref list with program filename generation
+ defaults and the user's presets.
+
+ :param preset_pref_lists: list of custom presets
+ :return: -1 if no match (i.e. custom), or the index into
+ VIDEO_RENAME_MENU_DEFAULTS_CONV + video rename presets if it matches
+ """
+
+ rename = VIDEO_RENAME_MENU_DEFAULTS_CONV + tuple(preset_pref_lists)
+ try:
+ return rename.index(self.video_rename)
+ except ValueError:
+ return -1
+
+ def add_list_value(self, key, value, max_list_size=0) -> None:
+ """
+ Add value to pref list if it doesn't already exist.
+
+ Values are added to the start of the list.
+
+ An empty list contains only one item: ['']
+
+ :param key: the preference key
+ :param value: the value to add
+ :param max_list_size: if non-zero, the list's last value will be deleted
+ """
+
+ if len(self[key]) == 1 and self[key][0] == '':
+ self[key] = [value]
+ elif value not in self[key]:
+ # Must assign the value like this, otherwise the preference value
+ # will not be updated:
+ if max_list_size:
+ self[key] = [value] + self[key][:max_list_size - 1]
+ else:
+ self[key] = [value] + self[key]
+
+ def del_list_value(self, key:str, value) -> None:
+ """
+ Remove a value from the pref list indicated by key.
+
+ Exceptions are not caught.
+
+ An empty list contains only one item: ['']
+
+ :param key: the preference key
+ :param value: the value to add
+ """
+
+ # Must remove the value like this, otherwise the preference value
+ # will not be updated:
+ l = self[key]
+ l.remove(value)
+ self[key] = l
+
+ if len(self[key]) == 0:
+ self[key] = ['']
+
+ def list_not_empty(self, key: str) -> bool:
+ """
+ In our pref schema, an empty list is [''], not []
+
+ :param key: the preference value to examine
+ :return: True if the pref list is not empty
+ """
+
+ return bool(self[key] and self[key][0])
+
+ def reset(self) -> None:
+ """
+ Reset all program preferences to their default settings
+ """
+ self.settings.clear()
+ self.program_version = raphodo.__about__.__version__
+
+ def upgrade_prefs(self, previous_version) -> None:
+ """
+ Upgrade the user's preferences if needed.
+
+ :param previous_version: previous version as returned by pkg_resources.parse_version
+ """
+
+ photo_video_rename_change = pkg_resources.parse_version('0.9.0a4')
+ if previous_version < photo_video_rename_change:
+ for key in ('photo_rename', 'video_rename'):
+ pref_list, case = upgrade_pre090a4_rename_pref(self[key])
+ if pref_list != self[key]:
+ self[key] = pref_list
+ logging.info("Upgraded %s preference value", key.replace('_', ' '))
+ if case is not None:
+ if key == 'photo_rename':
+ self.photo_extension = case
+ else:
+ self.video_extension = case
+
+ v090a5 = pkg_resources.parse_version('0.9.0a5')
+ if previous_version < v090a5:
+ # Versions prior to 0.9.0a5 incorrectly set the conflict resolution value
+ # when importing preferences from 0.4.11 or earlier
+ try:
+ value = self.conflict_resolution
+ except TypeError:
+ self.settings.endGroup()
+ default = self.defaults['conflict_resolution']
+ default_name = constants.ConflictResolution(default).name
+ logging.warning('Resetting Conflict Resolution preference value to %s',
+ default_name)
+ self.conflict_resolution = default
+ # destinationButtonPressed is no longer used by 0.9.0a5
+ self.settings.beginGroup("MainWindow")
+ key = 'destinationButtonPressed'
+ try:
+ if self.settings.contains(key):
+ logging.debug("Removing preference value %s", key)
+ self.settings.remove(key)
+ except:
+ logging.warning("Unknown error removing %s preference value", key)
+ self.settings.endGroup()
+
+ v090b6 = pkg_resources.parse_version('0.9.0b6')
+ key = 'warn_broken_or_missing_libraries'
+ group = 'Display'
+ if previous_version < v090b6 and not self.value_is_set(key, group):
+ # Versions prior to 0.9.0b6 may have a preference value 'warn_no_libmediainfo'
+ # which is now renamed to 'broken_or_missing_libraries'
+ if self.value_is_set('warn_no_libmediainfo', group):
+ self.settings.beginGroup(group)
+ v = self.settings.value('warn_no_libmediainfo', True, type(True))
+ self.settings.remove('warn_no_libmediainfo')
+ self.settings.endGroup()
+ logging.debug(
+ "Transferring preference value %s for warn_no_libmediainfo to "
+ "warn_broken_or_missing_libraries", v
+ )
+ self.warn_broken_or_missing_libraries = v
+ else:
+ logging.debug(
+ "Not transferring preference value warn_no_libmediainfo to "
+ "warn_broken_or_missing_libraries because it doesn't exist"
+ )
+
+ v093a1 = pkg_resources.parse_version('0.9.3a1')
+ key = 'scan_specific_folders'
+ group = 'Device'
+ if previous_version < v093a1 and not self.value_is_set(key, group):
+ # Versions prior to 0.9.3a1 used a preference value to indicate if
+ # devices lacking a DCIM folder should be scanned. It is now renamed
+ # to 'scan_specific_folders'
+ if self.value_is_set('device_without_dcim_autodetection'):
+ self.settings.beginGroup(group)
+ v = self.settings.value('device_without_dcim_autodetection', True, type(True))
+ self.settings.remove('device_without_dcim_autodetection')
+ self.settings.endGroup()
+ self.settings.endGroup()
+ logging.debug(
+ "Transferring preference value %s for device_without_dcim_autodetection to "
+ "scan_specific_folders as %s", v, not v
+ )
+ self.scan_specific_folders = not v
+ else:
+ logging.debug(
+ "Not transferring preference value device_without_dcim_autodetection to "
+ "scan_specific_folders because it doesn't exist"
+ )
+
+
+ def validate_max_CPU_cores(self) -> None:
+ logging.debug('Validating CPU core count for thumbnail generation...')
+ available = available_cpu_count(physical_only=True)
+ logging.debug('...%s physical cores detected', available)
+ if self.max_cpu_cores > available:
+ logging.info('Setting CPU Cores for thumbnail generation to %s', available)
+ self.max_cpu_cores = available
+
+ def validate_ignore_unhandled_file_exts(self) -> None:
+ # logging.debug('Validating list of file extension to not warn about...')
+ self.ignore_unhandled_file_exts = [ext.upper() for ext in self.ignore_unhandled_file_exts
+ if ext.lower() not in ALL_KNOWN_EXTENSIONS]
+
+ def warn_about_unknown_file(self, ext: str) -> bool:
+ if not self.warn_unhandled_files:
+ return False
+
+ if not self.ignore_unhandled_file_exts[0]:
+ return True
+
+ return ext.upper() not in self.ignore_unhandled_file_exts
+
+
+def match_pref_list(pref_lists: List[List[str]], user_pref_list: List[str]) -> int:
+ try:
+ return pref_lists.index(user_pref_list)
+ except ValueError:
+ return -1