summaryrefslogtreecommitdiff
path: root/rapid/renamesubfolderprefs.py
diff options
context:
space:
mode:
Diffstat (limited to 'rapid/renamesubfolderprefs.py')
-rw-r--r--rapid/renamesubfolderprefs.py1470
1 files changed, 1470 insertions, 0 deletions
diff --git a/rapid/renamesubfolderprefs.py b/rapid/renamesubfolderprefs.py
new file mode 100644
index 0000000..9804c59
--- /dev/null
+++ b/rapid/renamesubfolderprefs.py
@@ -0,0 +1,1470 @@
+#!/usr/bin/python
+# -*- coding: latin1 -*-
+
+### Copyright (C) 2007, 2008, 2009 Damon Lynch <damonlynch@gmail.com>
+
+### This program 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 2 of the License, or
+### (at your option) any later version.
+
+### This program 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 this program; if not, write to the Free Software
+### Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+""" Define and test preferences for use in PlusMinus tables.
+
+These are displayed to the user as a series of rows in the user
+preferences dialog window.
+
+Preferences for subfolders and image renaming are defined below
+in dictionaries and lists. This makes it easier for checking validity and
+creating combo boxes.
+
+There are 3 levels: 0, 1 and 2, which specify the depth of the pref value.
+Level 0 is the topmost level, and corresponds to the first entry in the
+row of preferences the user sees in the preferences dialog window.
+
+Custom exceptions are defined to handle invalid preferences.
+
+The user's actual preferences, on the other hand, are stored in flat lists.
+Each list has members which are a multiple of 3 in length.
+Each group of 3 members is equal to one line of preferences in the plus minus
+table.
+"""
+#needed for python 2.5, unneeded for python 2.6
+from __future__ import with_statement
+
+import string
+
+import os
+import re
+import sys
+
+import gtk.gdk as gdk
+
+try:
+ import pygtk
+ pygtk.require("2.0")
+except:
+ pass
+try:
+ import gtk
+except:
+ sys.exit(1)
+
+from common import Configi18n
+global _
+_ = Configi18n._
+
+import datetime
+
+import ValidatedEntry
+import config
+
+from common import pythonifyVersion
+
+# Special key in each dictionary which specifies the order of elements.
+# It is very important to have a consistent and rational order when displaying
+# these prefs to the user, and dictionaries are unsorted.
+
+ORDER_KEY = "__order__"
+
+# PLEASE NOTE: these values are duplicated in a dummy class whose function
+# is to have them put into the translation template. If you change the values below
+# then change the value in class i18TranslateMeThanks as well!! Thanks!!
+
+# *** Level 0
+DATE_TIME = 'Date time'
+TEXT = 'Text'
+FILENAME = 'Filename'
+METADATA = 'Metadata'
+SEQUENCES = 'Sequences'
+
+SEPARATOR = os.sep
+
+# *** Level 1
+
+# Date time
+IMAGE_DATE = 'Image date'
+TODAY = 'Today'
+YESTERDAY = 'Yesterday'
+
+# File name
+NAME_EXTENSION = 'Name + extension'
+NAME = 'Name'
+EXTENSION = 'Extension'
+IMAGE_NUMBER = 'Image number'
+
+# Metadata
+APERTURE = 'Aperture'
+ISO = 'ISO'
+EXPOSURE_TIME = 'Exposure time'
+FOCAL_LENGTH = 'Focal length'
+CAMERA_MAKE = 'Camera make'
+CAMERA_MODEL = 'Camera model'
+SHORT_CAMERA_MODEL = 'Short camera model'
+SHORT_CAMERA_MODEL_HYPHEN = 'Hyphenated short camera model'
+SERIAL_NUMBER = 'Serial number'
+SHUTTER_COUNT = 'Shutter count'
+OWNER_NAME = 'Owner name'
+
+#Image sequences
+DOWNLOAD_SEQ_NUMBER = 'Downloads today'
+SESSION_SEQ_NUMBER = 'Session number'
+SUBFOLDER_SEQ_NUMBER = 'Subfolder number'
+STORED_SEQ_NUMBER = 'Stored number'
+
+SEQUENCE_LETTER = 'Sequence letter'
+
+
+
+# *** Level 2
+
+# Image number
+IMAGE_NUMBER_ALL = 'All digits'
+IMAGE_NUMBER_1 = 'Last digit'
+IMAGE_NUMBER_2 = 'Last 2 digits'
+IMAGE_NUMBER_3 = 'Last 3 digits'
+IMAGE_NUMBER_4 = 'Last 4 digits'
+
+
+# Case
+ORIGINAL_CASE = "Original Case"
+UPPERCASE = "UPPERCASE"
+LOWERCASE = "lowercase"
+
+# Sequence number
+SEQUENCE_NUMBER_1 = "One digit"
+SEQUENCE_NUMBER_2 = "Two digits"
+SEQUENCE_NUMBER_3 = "Three digits"
+SEQUENCE_NUMBER_4 = "Four digits"
+SEQUENCE_NUMBER_5 = "Five digits"
+SEQUENCE_NUMBER_6 = "Six digits"
+
+
+# Now, define dictionaries and lists of valid combinations of preferences.
+
+# Level 2
+
+# Date
+
+SUBSECONDS = 'Subseconds'
+
+# ****** note if changing LIST_DATE_TIME_L2, update the default subfolder preference below :D *****
+LIST_DATE_TIME_L2 = ['YYYYMMDD', 'YYYY-MM-DD','YYMMDD', 'YY-MM-DD',
+ 'MMDDYYYY', 'MMDDYY', 'MMDD',
+ 'DDMMYYYY', 'DDMMYY', 'YYYY', 'YY',
+ 'MM', 'DD',
+ 'HHMMSS', 'HHMM']
+
+LIST_IMAGE_DATE_TIME_L2 = LIST_DATE_TIME_L2 + [SUBSECONDS]
+
+DEFAULT_SUBFOLDER_PREFS = [DATE_TIME, IMAGE_DATE, LIST_DATE_TIME_L2[9], '/', '', '', DATE_TIME, IMAGE_DATE, LIST_DATE_TIME_L2[0]]
+
+class i18TranslateMeThanks:
+ """ this class is never used in actual running code
+ It's purpose is to have these values inserted into the program's i18n template file
+
+ """
+ def __init__(self):
+ _('Date time')
+ _('Text')
+ _('Filename')
+ _('Metadata')
+ _('Sequences')
+ _('Image date')
+ _('Today')
+ _('Yesterday')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Name + extension')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Name')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Extension')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Image number')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Aperture')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('ISO')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Exposure time')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Focal length')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Camera make')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Camera model')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Short camera model')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Hyphenated short camera model')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Serial number')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Shutter count')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamemetadata
+ _('Owner name')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#sequencenumbers
+ _('Downloads today')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#sequencenumbers
+ _('Session number')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#sequencenumbers
+ _('Subfolder number')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#sequencenumbers
+ _('Stored number')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#sequenceletters
+ _('Sequence letter')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('All digits')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Last digit')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Last 2 digits')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Last 3 digits')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamefilename
+ _('Last 4 digits')
+ # Translators: please not the capitalization of this text, and keep it the same if your language features capitalization
+ _("Original Case")
+ # Translators: please not the capitalization of this text, and keep it the same if your language features capitalization
+ _("UPPERCASE")
+ # Translators: please not the capitalization of this text, and keep it the same if your language features capitalization
+ _("lowercase")
+ _("One digit")
+ _("Two digits")
+ _("Three digits")
+ _("Four digits")
+ _("Five digits")
+ _("Six digits")
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('Subseconds')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YYYYMMDD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YYYY-MM-DD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YYMMDD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YY-MM-DD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('MMDDYYYY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('MMDDYY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('MMDD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('DDMMYYYY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('DDMMYY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YYYY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('YY')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('MM')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('DD')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('HHMMSS')
+ # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#renamedateandtime
+ _('HHMM')
+
+
+# Convenience values for python datetime conversion using values in
+# LIST_DATE_TIME_L2. Obviously the two must remain synchronized.
+
+DATE_TIME_CONVERT = ['%Y%m%d', '%Y-%m-%d','%y%m%d', '%y-%m-%d',
+ '%m%d%Y', '%m%d%y', '%m%d',
+ '%d%m%Y', '%d%m%y', '%Y', '%y',
+ '%m', '%d',
+ '%H%M%S', '%H%M']
+
+
+LIST_IMAGE_NUMBER_L2 = [IMAGE_NUMBER_ALL, IMAGE_NUMBER_1, IMAGE_NUMBER_2,
+ IMAGE_NUMBER_3, IMAGE_NUMBER_4]
+
+
+LIST_CASE_L2 = [ORIGINAL_CASE, UPPERCASE, LOWERCASE]
+
+LIST_SEQUENCE_LETTER_L2 = [
+ UPPERCASE,
+ LOWERCASE
+ ]
+
+
+
+LIST_SEQUENCE_NUMBERS_L2 = [
+ SEQUENCE_NUMBER_1,
+ SEQUENCE_NUMBER_2,
+ SEQUENCE_NUMBER_3,
+ SEQUENCE_NUMBER_4,
+ SEQUENCE_NUMBER_5,
+ SEQUENCE_NUMBER_6,
+ ]
+
+
+
+LIST_SHUTTER_COUNT_L2 = [
+ SEQUENCE_NUMBER_3,
+ SEQUENCE_NUMBER_4,
+ SEQUENCE_NUMBER_5,
+ SEQUENCE_NUMBER_6,
+ ]
+
+# Level 1
+LIST_DATE_TIME_L1 = [IMAGE_DATE, TODAY, YESTERDAY]
+
+DICT_DATE_TIME_L1 = {
+ IMAGE_DATE: LIST_IMAGE_DATE_TIME_L2,
+ TODAY: LIST_DATE_TIME_L2,
+ YESTERDAY: LIST_DATE_TIME_L2,
+ ORDER_KEY: LIST_DATE_TIME_L1
+ }
+
+
+LIST_FILENAME_L1 = [NAME_EXTENSION, NAME, EXTENSION, IMAGE_NUMBER]
+
+DICT_FILENAME_L1 = {
+ NAME_EXTENSION: LIST_CASE_L2,
+ NAME: LIST_CASE_L2,
+ EXTENSION: LIST_CASE_L2,
+ IMAGE_NUMBER: LIST_IMAGE_NUMBER_L2,
+ ORDER_KEY: LIST_FILENAME_L1
+ }
+
+
+
+LIST_SUBFOLDER_FILENAME_L1 = [EXTENSION]
+
+DICT_SUBFOLDER_FILENAME_L1 = {
+ EXTENSION: LIST_CASE_L2,
+ ORDER_KEY: LIST_SUBFOLDER_FILENAME_L1
+}
+
+LIST_METADATA_L1 = [APERTURE, ISO, EXPOSURE_TIME, FOCAL_LENGTH,
+ CAMERA_MAKE, CAMERA_MODEL,
+ SHORT_CAMERA_MODEL,
+ SHORT_CAMERA_MODEL_HYPHEN,
+ SERIAL_NUMBER,
+ SHUTTER_COUNT,
+ OWNER_NAME]
+
+DICT_METADATA_L1 = {
+ APERTURE: None,
+ ISO: None,
+ EXPOSURE_TIME: None,
+ FOCAL_LENGTH: None,
+ CAMERA_MAKE: LIST_CASE_L2,
+ CAMERA_MODEL: LIST_CASE_L2,
+ SHORT_CAMERA_MODEL: LIST_CASE_L2,
+ SHORT_CAMERA_MODEL_HYPHEN: LIST_CASE_L2,
+ SERIAL_NUMBER: None,
+ SHUTTER_COUNT: LIST_SHUTTER_COUNT_L2,
+ OWNER_NAME: LIST_CASE_L2,
+ ORDER_KEY: LIST_METADATA_L1
+ }
+
+
+LIST_SEQUENCE_L1 = [
+ DOWNLOAD_SEQ_NUMBER,
+ STORED_SEQ_NUMBER,
+ SESSION_SEQ_NUMBER,
+ SEQUENCE_LETTER
+ ]
+
+DICT_SEQUENCE_L1 = {
+ DOWNLOAD_SEQ_NUMBER: LIST_SEQUENCE_NUMBERS_L2,
+ STORED_SEQ_NUMBER: LIST_SEQUENCE_NUMBERS_L2,
+ SESSION_SEQ_NUMBER: LIST_SEQUENCE_NUMBERS_L2,
+ SEQUENCE_LETTER: LIST_SEQUENCE_LETTER_L2,
+ ORDER_KEY: LIST_SEQUENCE_L1
+ }
+
+
+# Level 0
+
+
+LIST_IMAGE_RENAME_L0 = [DATE_TIME, TEXT, FILENAME, METADATA,
+ SEQUENCES]
+
+
+DICT_IMAGE_RENAME_L0 = {
+ DATE_TIME: DICT_DATE_TIME_L1,
+ TEXT: None,
+ FILENAME: DICT_FILENAME_L1,
+ METADATA: DICT_METADATA_L1,
+ SEQUENCES: DICT_SEQUENCE_L1,
+ ORDER_KEY: LIST_IMAGE_RENAME_L0
+ }
+
+LIST_SUBFOLDER_L0 = [DATE_TIME, TEXT, FILENAME, METADATA, SEPARATOR]
+
+DICT_SUBFOLDER_L0 = {
+ DATE_TIME: DICT_DATE_TIME_L1,
+ TEXT: None,
+ FILENAME: DICT_SUBFOLDER_FILENAME_L1,
+ METADATA: DICT_METADATA_L1,
+ SEPARATOR: None,
+ ORDER_KEY: LIST_SUBFOLDER_L0
+ }
+
+# preference elements that require metadata
+# note there is no need to specify lower level elements if a higher level
+# element is necessary for them to be present to begin with
+METADATA_ELEMENTS = [METADATA, IMAGE_DATE]
+
+# preference elements that are sequence numbers or letters
+SEQUENCE_ELEMENTS = [
+ DOWNLOAD_SEQ_NUMBER,
+ SESSION_SEQ_NUMBER,
+ SUBFOLDER_SEQ_NUMBER,
+ STORED_SEQ_NUMBER,
+ SEQUENCE_LETTER]
+
+# preference elements that do not require metadata and are not fixed
+# as above, there is no need to specify lower level elements if a higher level
+# element is necessary for them to be present to begin with
+DYNAMIC_NON_METADATA_ELEMENTS = [
+ TODAY, YESTERDAY,
+ FILENAME] + SEQUENCE_ELEMENTS
+
+
+
+#the following is what the preferences looked in older versions of the program
+#they are here for reference, and for checking the validity of preferences
+
+USER_INPUT = 'User'
+
+DOWNLOAD_SEQ_NUMBER_V_0_0_8_B7 = 'Downloads today'
+SESSION_SEQ_NUMBER_V_0_0_8_B7 = 'Session sequence number'
+SUBFOLDER_SEQ_NUMBER_V_0_0_8_B7 = 'Subfolder sequence number'
+STORED_SEQ_NUMBER_V_0_0_8_B7 = 'Stored sequence number'
+SEQUENCE_LETTER_V_0_0_8_B7 = 'Sequence letter'
+
+LIST_SEQUENCE_NUMBERS_L1_L2_V_0_0_8_B7 = [
+ SEQUENCE_NUMBER_1,
+ SEQUENCE_NUMBER_2,
+ SEQUENCE_NUMBER_3,
+ SEQUENCE_NUMBER_4,
+ SEQUENCE_NUMBER_5,
+ SEQUENCE_NUMBER_6,
+ ]
+
+DICT_SEQUENCE_NUMBERS_L1_L2_V_0_0_8_B7 = {
+ SEQUENCE_NUMBER_1: None,
+ SEQUENCE_NUMBER_2: None,
+ SEQUENCE_NUMBER_3: None,
+ SEQUENCE_NUMBER_4: None,
+ SEQUENCE_NUMBER_5: None,
+ SEQUENCE_NUMBER_6: None,
+ ORDER_KEY: LIST_SEQUENCE_NUMBERS_L1_L2_V_0_0_8_B7
+ }
+
+LIST_SEQUENCE_L1_V_0_0_8_B7 = [USER_INPUT]
+
+DICT_SEQUENCE_L1_V_0_0_8_B7 = {
+ USER_INPUT: DICT_SEQUENCE_NUMBERS_L1_L2_V_0_0_8_B7,
+ ORDER_KEY: LIST_SEQUENCE_L1_V_0_0_8_B7
+ }
+
+LIST_SEQUENCE_LETTER_L1_L1_V_0_0_8_B7 = [
+ UPPERCASE,
+ LOWERCASE
+ ]
+
+DICT_SEQUENCE_LETTER_L1_V_0_0_8_B7 = {
+ UPPERCASE: None,
+ LOWERCASE: None,
+ ORDER_KEY: LIST_SEQUENCE_LETTER_L1_L1_V_0_0_8_B7
+ }
+
+LIST_IMAGE_RENAME_L0_V_0_0_8_B7 = [DATE_TIME, TEXT, FILENAME, METADATA,
+ DOWNLOAD_SEQ_NUMBER_V_0_0_8_B7,
+ SESSION_SEQ_NUMBER_V_0_0_8_B7,
+ SEQUENCE_LETTER_V_0_0_8_B7]
+
+DICT_IMAGE_RENAME_L0_V_0_0_8_B7 = {
+ DATE_TIME: DICT_DATE_TIME_L1,
+ TEXT: None,
+ FILENAME: DICT_FILENAME_L1,
+ METADATA: DICT_METADATA_L1,
+ DOWNLOAD_SEQ_NUMBER_V_0_0_8_B7: None,
+ SESSION_SEQ_NUMBER_V_0_0_8_B7: None,
+ SEQUENCE_LETTER_V_0_0_8_B7: DICT_SEQUENCE_LETTER_L1_V_0_0_8_B7,
+ ORDER_KEY: LIST_IMAGE_RENAME_L0_V_0_0_8_B7
+ }
+
+PREVIOUS_IMAGE_RENAME= {
+ '0.0.8~b7': DICT_IMAGE_RENAME_L0_V_0_0_8_B7,
+ }
+
+
+# Functions to work with above data
+
+def _getPrevPrefs(oldDefs, currentDefs, previousVersion):
+ k = oldDefs.keys()
+ # if there were other defns, we'd need to figure out which one
+ # but currently, there are no others
+ # there will be in future, and this code wil be updated then
+ version_change = pythonifyVersion(k[0])
+ if pythonifyVersion(previousVersion) <= version_change:
+ return oldDefs[k[0]]
+ else:
+ return currentDefs
+
+def _upgradePreferencesToCurrent(prefs, previousVersion):
+ """ checks to see if preferences should be upgraded
+
+ returns True if they were upgraded, and the new prefs
+
+ VERY IMPORTANT: the new prefs will be a new list, not an inplace
+ modification of the existing preferences! Otherwise, the check on
+ assignment in the prefs.py __setattr__ will not work as expected!!
+ """
+ upgraded = False
+ # code to upgrade from <= 0.0.8~b7 to >= 0.0.8~b8
+ p = []
+ for i in range(0, len(prefs), 3):
+ if prefs[i] in [SEQUENCE_LETTER_V_0_0_8_B7, SESSION_SEQ_NUMBER_V_0_0_8_B7]:
+ upgraded = True
+ p.append(SEQUENCES)
+ if prefs[i] == SEQUENCE_LETTER_V_0_0_8_B7:
+ p.append(SEQUENCE_LETTER)
+ p.append(prefs[i+1])
+ else:
+ p.append(SESSION_SEQ_NUMBER)
+ p.append(prefs[i+2])
+ else:
+ p += prefs[i:i+3]
+
+ assert(len(prefs)==len(p))
+ return (upgraded, p)
+
+
+def upgradePreferencesToCurrent(imageRenamePrefs, subfolderPrefs, previousVersion):
+ """Upgrades user preferences to current version
+
+ returns True if the preferences were upgraded"""
+
+ # only check image rename, for now....
+ upgraded, imageRenamePrefs = _upgradePreferencesToCurrent(imageRenamePrefs, previousVersion)
+ return (upgraded, imageRenamePrefs , subfolderPrefs)
+
+def checkPreferencesForValidity(imageRenamePrefs, subfolderPrefs, version=config.version):
+ """Returns true if the passed in preferences are valid"""
+
+ if version == config.version:
+ try:
+ checkPreferenceValid(DICT_SUBFOLDER_L0, subfolderPrefs)
+ checkPreferenceValid(DICT_IMAGE_RENAME_L0, imageRenamePrefs)
+ except:
+ return False
+ return True
+ else:
+ defn = _getPrevPrefs(PREVIOUS_IMAGE_RENAME, DICT_IMAGE_RENAME_L0, version)
+ try:
+ checkPreferenceValid(defn, imageRenamePrefs)
+ checkPreferenceValid(DICT_SUBFOLDER_L0, subfolderPrefs)
+ except:
+ return False
+ return True
+
+def checkPreferenceValid(prefDefinition, prefs, modulo=3):
+ """
+ Checks to see if prefs are valid according to definition.
+
+ prefs is a list of preferences.
+ prefDefinition is a Dict specifying what is valid.
+ modulo is how many list elements are equivalent to one line of preferences.
+
+ Returns True if prefs match with prefDefinition,
+ else raises appropriate error.
+ """
+
+ if (len(prefs) % modulo <> 0) or not prefs:
+ raise PrefLengthError(prefs)
+ else:
+ for i in range(0, len(prefs), modulo):
+ _checkPreferenceValid(prefDefinition, prefs[i:i+modulo])
+
+ return True
+
+def _checkPreferenceValid(prefDefinition, prefs):
+
+ key = prefs[0]
+ value = prefs[1]
+
+
+ if prefDefinition.has_key(key):
+
+ nextPrefDefinition = prefDefinition[key]
+
+ if value == None:
+ # value should never be None, at any time
+ raise PrefValueInvalidError((None, nextPrefDefinition))
+
+ if nextPrefDefinition and not value:
+ raise PrefValueInvalidError((value, nextPrefDefinition))
+
+ if type(nextPrefDefinition) == type({}):
+ return _checkPreferenceValid(nextPrefDefinition, prefs[1:])
+ else:
+ if type(nextPrefDefinition) == type([]):
+ result = value in nextPrefDefinition
+ if not result:
+ raise PrefValueInvalidError((value, nextPrefDefinition))
+ return True
+ elif not nextPrefDefinition:
+ return True
+ else:
+ result = nextPrefDefinition == value
+ if not result:
+ raise PrefKeyValue((value, nextPrefDefinition))
+ return True
+ else:
+ raise PrefKeyError((key, prefDefinition[ORDER_KEY]))
+
+def filterSubfolderPreferences(prefList):
+ """
+ Filters out extraneous preference choices
+ """
+ prefs_changed = False
+ continueCheck = True
+ while continueCheck and prefList:
+ continueCheck = False
+ if prefList[0] == SEPARATOR:
+ # Subfolder preferences should not start with a /
+ prefList = prefList[3:]
+ prefs_changed = True
+ continueCheck = True
+ elif prefList[-3] == SEPARATOR:
+ # Subfolder preferences should not end with a /
+ prefList = prefList[:-3]
+ continueCheck = True
+ prefs_changed = True
+ else:
+ for i in range(0, len(prefList) - 3, 3):
+ if prefList[i] == SEPARATOR and prefList[i+3] == SEPARATOR:
+ # Subfolder preferences should not contain two /s side by side
+ continueCheck = True
+ prefs_changed = True
+ # note we are messing with the contents of the pref list,
+ # must exit loop and try again
+ prefList = prefList[:i] + prefList[i+3:]
+ break
+
+ return (prefs_changed, prefList)
+
+
+class PrefError(Exception):
+ """ base class """
+ def unpackList(self, l):
+ s = ''
+ for i in l:
+ if i <> ORDER_KEY:
+ s += "'" + i + "', "
+ return s[:-2]
+
+ def __str__(self):
+ return self.msg
+
+class PrefKeyError(PrefError):
+ def __init__(self, error):
+ value = error[0]
+ expectedValues = self.unpackList(error[1])
+ self.msg = _("Preference key '%(key)s' is invalid.\nExpected one of %(value)s") % {
+ 'key': value, 'value': expectedValues}
+
+
+class PrefValueInvalidError(PrefKeyError):
+ def __init__(self, error):
+ value = error[0]
+ self.msg = _("Preference value '%(value)s' is invalid") % {'value': value}
+
+class PrefLengthError(PrefError):
+ def __init__(self, error):
+ self.msg = _("These preferences are not well formed:") % self.unpackList(error) + "\n %s"
+
+class PrefValueKeyComboError(PrefError):
+ def __init__(self, error):
+ self.msg = error
+
+
+def convertDateForStrftime(dateTimeUserChoice):
+ try:
+ return DATE_TIME_CONVERT[LIST_DATE_TIME_L2.index(dateTimeUserChoice)]
+ except:
+ raise PrefValueInvalidError(dateTimeUserChoice)
+
+
+class Comboi18n(gtk.ComboBox):
+ """ very simple i18n version of the venerable combo box
+ with one column displayed to the user.
+
+ This combo box has two columns:
+ 1. the first contains the actual value and is invisible
+ 2. the second contains the translation of the first column, and this is what
+ the users sees
+ """
+ def __init__(self):
+ liststore = gtk.ListStore(str, str)
+ gtk.ComboBox.__init__(self, liststore)
+ cell = gtk.CellRendererText()
+ self.pack_start(cell, True)
+ self.add_attribute(cell, 'text', 1)
+
+ def append_text(self, text):
+ model = self.get_model()
+ model.append((text, _(text)))
+
+ def get_active_text(self):
+ model = self.get_model()
+ active = self.get_active()
+ if active < 0:
+ return None
+ return model[active][0]
+
+class ImageRenamePreferences:
+ def __init__(self, prefList, parent, fileSequenceLock=None, sequences=None):
+ """
+ Exception raised if preferences are invalid.
+
+ This should be caught by calling class."""
+
+ self.parent = parent
+ self.prefList = prefList
+
+ # use variables for determining sequence numbers
+ # there are two possibilities:
+ # 1. this code is being called while being run from within a copy photos process
+ # 2. it's being called from within the preferences dialog window
+
+ self.fileSequenceLock = fileSequenceLock
+ self.sequences = sequences
+
+ # derived classes will have their own definitions, do not overwrite
+ if not hasattr(self, "prefsDefnL0"):
+ self.prefsDefnL0 = DICT_IMAGE_RENAME_L0
+ self.defaultPrefs = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE]
+ self.defaultRow = self.defaultPrefs
+ self.stripForwardSlash = True
+
+
+
+ def checkPrefsForValidity(self):
+ """
+ Checks image preferences validity
+ """
+
+ return checkPreferenceValid(self.prefsDefnL0, self.prefList)
+
+ def formatPreferencesForPrettyPrint(self):
+ """ returns a string useful for printing the preferences"""
+
+ v = ''
+
+ for i in range(0, len(self.prefList), 3):
+ s = "%s: " % self.prefList[i]
+ if self.prefList[i+1]:
+ s = "%s%s" % (s, self.prefList[i+1])
+ if self.prefList[i+2]:
+ s = "%s (%s)" % (s, self.prefList[i+2])
+
+ v += s + "\n"
+ return v
+
+
+ def _getDateComponent(self):
+ """
+ Returns portion of new image / subfolder name based on date time
+ """
+
+ problem = None
+ if self.L1 == IMAGE_DATE:
+ if self.L2 == SUBSECONDS:
+ d = self.photo.subSeconds()
+ problem = _("Subsecond metadata not present in image")
+ else:
+ d = self.photo.dateTime(missing=None)
+ problem = _("%s metadata is not present in image") % self.L1.lower()
+ elif self.L1 == TODAY:
+ d = datetime.datetime.now()
+ elif self.L1 == YESTERDAY:
+ delta = datetime.timedelta(days = 1)
+ d = datetime.datetime.now() - delta
+ else:
+ raise("Date options invalid")
+
+ if d:
+ if self.L2 <> SUBSECONDS:
+ try:
+ return (d.strftime(convertDateForStrftime(self.L2)), None)
+ except:
+ v = ''
+ problem = _('Error in date time component. Value %s appears invalid') % d
+ return (v, problem)
+ else:
+ return (d, None)
+ else:
+ return ('', problem)
+
+ def _getFilenameComponent(self):
+ """
+ Returns portion of new image / subfolder name based on the file name
+ """
+
+ name, extension = os.path.splitext(self.existingFilename)
+ problem = None
+
+ if self.L1 == NAME_EXTENSION:
+ filename = self.existingFilename
+ elif self.L1 == NAME:
+ filename = name
+ elif self.L1 == EXTENSION:
+ if extension:
+ if not self.stripInitialPeriodFromExtension:
+ # keep the period / dot of the extension, so the user does not
+ # need to manually specify it
+ filename = extension
+ else:
+ # having the period when this is used as a part of a subfolder name
+ # is a bad idea!
+ filename = extension[1:]
+ else:
+ filename = ""
+ problem = _("extension was specified but image name has no extension")
+ elif self.L1 == IMAGE_NUMBER:
+ n = re.search("(?P<image_number>[0-9]+$)", name)
+ if not n:
+ problem = _("image number was specified but image filename has no number")
+ else:
+ image_number = n.group("image_number")
+
+ if self.L2 == IMAGE_NUMBER_ALL:
+ filename = image_number
+ elif self.L2 == IMAGE_NUMBER_1:
+ filename = image_number[-1]
+ elif self.L2 == IMAGE_NUMBER_2:
+ filename = image_number[-2:]
+ elif self.L2 == IMAGE_NUMBER_3:
+ filename = image_number[-3:]
+ elif self.L2 == IMAGE_NUMBER_4:
+ filename = image_number[-4:]
+ else:
+ raise TypeError("Incorrect filename option")
+
+ if self.L2 == UPPERCASE:
+ filename = filename.upper()
+ elif self.L2 == LOWERCASE:
+ filename = filename.lower()
+
+ return (filename, problem)
+
+ def _getMetadataComponent(self):
+ """
+ Returns portion of new image / subfolder name based on the metadata
+
+ Note: date time metadata found in _getDateComponent()
+ """
+
+ problem = None
+ if self.L1 == APERTURE:
+ v = self.photo.aperture()
+ elif self.L1 == ISO:
+ v = self.photo.iso()
+ elif self.L1 == EXPOSURE_TIME:
+ v = self.photo.exposureTime(alternativeFormat=True)
+ elif self.L1 == FOCAL_LENGTH:
+ v = self.photo.focalLength()
+ elif self.L1 == CAMERA_MAKE:
+ v = self.photo.cameraMake()
+ elif self.L1 == CAMERA_MODEL:
+ v = self.photo.cameraModel()
+ elif self.L1 == SHORT_CAMERA_MODEL:
+ v = self.photo.shortCameraModel()
+ elif self.L1 == SHORT_CAMERA_MODEL_HYPHEN:
+ v = self.photo.shortCameraModel(includeCharacters = "\-")
+ elif self.L1 == SERIAL_NUMBER:
+ v = self.photo.cameraSerial()
+ elif self.L1 == SHUTTER_COUNT:
+ v = self.photo.shutterCount()
+ if v:
+ v = int(v)
+ padding = LIST_SHUTTER_COUNT_L2.index(self.L2) + 3
+ formatter = '%0' + str(padding) + "i"
+ v = formatter % v
+
+ elif self.L1 == OWNER_NAME:
+ v = self.photo.ownerName()
+ else:
+ raise TypeError("Invalid metadata option specified")
+ if self.L1 in [CAMERA_MAKE, CAMERA_MODEL, SHORT_CAMERA_MODEL,
+ SHORT_CAMERA_MODEL_HYPHEN, OWNER_NAME]:
+ if self.L2 == UPPERCASE:
+ v = v.upper()
+ elif self.L2 == LOWERCASE:
+ v = v.lower()
+ if not v:
+ if self.L1 <> ISO:
+ md = self.L1.lower()
+ else:
+ md = ISO
+ problem = _("%s metadata is not present in image") % md
+ return (v, problem)
+
+
+ def _formatSequenceNo(self, value, amountToPad):
+ padding = LIST_SEQUENCE_NUMBERS_L2.index(amountToPad) + 1
+ formatter = '%0' + str(padding) + "i"
+ return formatter % value
+
+
+ def _calculateLetterSequence(self, sequence):
+
+ def _letters(x):
+ """
+ Adapted from algorithm at http://en.wikipedia.org/wiki/Hexavigesimal
+ """
+ v = ''
+ while x > 25:
+ r = x % 26
+ x= x / 26 - 1
+ v = string.lowercase[r] + v
+ v = string.lowercase[x] + v
+
+ return v
+
+
+ v = _letters(sequence)
+ if self.L2 == UPPERCASE:
+ v = v.upper()
+
+ return v
+
+ def _getSubfolderSequenceNo(self):
+ """
+ Add a sequence number to the filename
+
+ * Sequence numbering is per subfolder
+ * Assume the user might actually have a (perhaps odd) reason to have more
+ than one subfolder sequence number in the same file name
+ """
+
+ problem = None
+ self.subfolderSeqNoInstanceInFilename += 1
+
+ if self.downloadSubfolder:
+ subfolder = self.downloadSubfolder + str(self.subfolderSeqNoInstanceInFilename)
+ else:
+ subfolder = "__subfolder__" + str(self.subfolderSeqNoInstanceInFilename)
+
+ if self.fileSequenceLock:
+ with self.fileSequenceLock:
+ v = self.sequenceNos.calculate(subfolder)
+ v = self.formatSequenceNo(v, self.L1)
+ else:
+ v = self.sequenceNos.calculate(subfolder)
+ v = self.formatSequenceNo(v, self.L1)
+
+ return (v, problem)
+
+ def _getSessionSequenceNo(self):
+ problem = None
+ v = self._formatSequenceNo(self.sequences.getSessionSequenceNoUsingCounter(self.sequenceCounter), self.L2)
+ return (v, problem)
+
+ def _getDownloadsTodaySequenceNo(self):
+ problem = None
+
+ v = self._formatSequenceNo(self.sequences.getDownloadsTodayUsingCounter(self.sequenceCounter), self.L2)
+
+ return (v, problem)
+
+ def _getStoredSequenceNo(self):
+ problem = None
+ v = self._formatSequenceNo(self.sequences.getStoredSequenceNoUsingCounter(self.sequenceCounter), self.L2)
+
+ return (v, problem)
+
+ def _getSequenceLetter(self):
+
+ problem = None
+ v = self._calculateLetterSequence(self.sequences.getSequenceLetterUsingCounter(self.sequenceCounter))
+ return (v, problem)
+
+ def _getSequencesComponent(self):
+ problem = None
+ if self.L1 == DOWNLOAD_SEQ_NUMBER:
+ return self._getDownloadsTodaySequenceNo()
+ elif self.L1 == SESSION_SEQ_NUMBER:
+ return self._getSessionSequenceNo()
+ elif self.L1 == SUBFOLDER_SEQ_NUMBER:
+ return self._getSubfolderSequenceNo()
+ elif self.L1 == STORED_SEQ_NUMBER:
+ return self._getStoredSequenceNo()
+ elif self.L1 == SEQUENCE_LETTER:
+ return self._getSequenceLetter()
+
+ def _getComponent(self):
+ try:
+ if self.L0 == DATE_TIME:
+ return self._getDateComponent()
+ elif self.L0 == TEXT:
+ return (self.L1, None)
+ elif self.L0 == FILENAME:
+ return self._getFilenameComponent()
+ elif self.L0 == METADATA:
+ return self._getMetadataComponent()
+ elif self.L0 == SEQUENCES:
+ return self._getSequencesComponent()
+ elif self.L0 == SEPARATOR:
+ return (os.sep, None)
+ except:
+ v = ""
+ problem = _("error generating name with component %s") % self.L2
+ return (v, problem)
+
+ def _getValuesFromList(self):
+ for i in range(0, len(self.prefList), 3):
+ yield (self.prefList[i], self.prefList[i+1], self.prefList[i+2])
+
+
+ def _generateName(self, photo, existingFilename, stripCharacters, subfolder, stripInitialPeriodFromExtension, sequence):
+ self.photo = photo
+ self.existingFilename = existingFilename
+ self.stripInitialPeriodFromExtension = stripInitialPeriodFromExtension
+
+ name = ''
+ problem = ''
+
+ #the subfolder in which the image will be downloaded to
+ self.downloadSubfolder = subfolder
+
+ self.sequenceCounter = sequence
+
+ for self.L0, self.L1, self.L2 in self._getValuesFromList():
+ v, p = self._getComponent()
+ if v:
+ name += v
+ if p:
+ problem += p + "; "
+
+ if problem:
+ # remove final semicolon and space
+ problem = problem[:-2] + '.'
+
+ if stripCharacters:
+ for c in r'\:*?"<>|':
+ name = name.replace(c, '')
+
+ if self.stripForwardSlash:
+ name = name.replace('/', '')
+
+ return (name, problem)
+
+ def generateNameUsingPreferences(self, photo, existingFilename=None,
+ stripCharacters = False, subfolder=None,
+ stripInitialPeriodFromExtension=False,
+ sequencesPreliminary = True):
+ """
+ Generate a filename for the photo in string format based on user prefs.
+
+ Returns a tuple of two strings:
+ - the name
+ - any problems generating the name. If blank, there were no problems
+ """
+
+ if self.sequences:
+ if sequencesPreliminary:
+ sequence = self.sequences.getPrelimSequence()
+ else:
+ sequence = self.sequences.getFinalSequence()
+ else:
+ sequence = 0
+
+ return self._generateName(photo, existingFilename, stripCharacters, subfolder,
+ stripInitialPeriodFromExtension, sequence)
+
+ def generateNameSequencePossibilities(self, photo, existingFilename,
+ stripCharacters=False, subfolder=None,
+ stripInitialPeriodFromExtension=False):
+
+ """ Generates the possible image names using the sequence numbers / letter possibilities"""
+
+ for sequence in self.sequences.getSequencePossibilities():
+ yield self._generateName(photo, existingFilename, stripCharacters , subfolder,
+ stripInitialPeriodFromExtension, sequence)
+
+ def filterPreferences(self):
+ """
+ Filters out extraneous preference choices
+ Expected to be implemented in derived classes when needed
+ """
+ pass
+
+ def needImageMetaDataToCreateUniqueName(self):
+ """
+ Returns True if an image's metadata is essential to properly generate a unique image name
+
+ Image names should be unique. Some images may not have metadata. If
+ only non-dynamic components make up the rest of an image name
+ (e.g. text specified by the user), then relying on metadata will likely
+ produce duplicate names.
+
+ File extensions are not considered dynamic.
+
+ This is NOT a general test to see if unique filenames can be generated. It is a test
+ to see if an image's metadata is needed.
+ """
+ hasMD = hasDynamic = False
+
+ for e in METADATA_ELEMENTS:
+ if e in self.prefList:
+ hasMD = True
+ break
+
+ if hasMD:
+ for e in DYNAMIC_NON_METADATA_ELEMENTS:
+ if e in self.prefList:
+ if e == FILENAME and (NAME_EXTENSION in self.prefList or
+ NAME in self.prefList or
+ IMAGE_NUMBER in self.prefList):
+ hasDynamic = True
+ break
+
+ if hasMD and not hasDynamic:
+ return True
+ else:
+ return False
+
+ def usesSequenceElements(self):
+ """ Returns true if any sequence numbers or letters are used to generate the filename """
+
+ for e in SEQUENCE_ELEMENTS:
+ if e in self.prefList:
+ return True
+
+ return False
+
+ def usesTheSequenceElement(self, e):
+ """ Returns true if a stored sequence number is used to generate the filename """
+ return e in self.prefList
+
+
+ def _createCombo(self, choices):
+ combobox = Comboi18n()
+ for text in choices:
+ combobox.append_text(text)
+ return combobox
+
+ def getDefaultRow(self):
+ """
+ returns a list of default widgets
+ """
+ return self.getWidgetsBasedOnUserSelection(self.defaultRow)
+
+ def _getPreferenceWidgets(self, prefDefinition, prefs, widgets):
+ key = prefs[0]
+ value = prefs[1]
+
+ # supply a default value if the user has not yet chosen a value!
+ if not key:
+ key = prefDefinition[ORDER_KEY][0]
+
+ if not key in prefDefinition:
+ raise PrefKeyError((key, prefDefinition.keys()))
+
+
+ list0 = prefDefinition[ORDER_KEY]
+
+ # the first widget will always be a combo box
+ widget0 = self._createCombo(list0)
+ widget0.set_active(list0.index(key))
+
+ widgets.append(widget0)
+
+ if key == TEXT:
+ widget1 = gtk.Entry()
+ widget1.set_text(value)
+
+ widgets.append(widget1)
+ widgets.append(None)
+ return
+ elif key == SEPARATOR:
+ widgets.append(None)
+ widgets.append(None)
+ return
+ else:
+ nextPrefDefinition = prefDefinition[key]
+ if type(nextPrefDefinition) == type({}):
+ return self._getPreferenceWidgets(nextPrefDefinition,
+ prefs[1:],
+ widgets)
+ else:
+ if type(nextPrefDefinition) == type([]):
+ widget1 = self._createCombo(nextPrefDefinition)
+ if not value:
+ value = nextPrefDefinition[0]
+ try:
+ widget1.set_active(nextPrefDefinition.index(value))
+ except:
+ raise PrefValueInvalidError((value, nextPrefDefinition))
+
+ widgets.append(widget1)
+ else:
+ widgets.append(None)
+
+ def getWidgetsBasedOnPreferences(self):
+ """
+ Yields a list of widgets and their callbacks based on the users preferences.
+
+ This list is equivalent to one row of preferences when presented to the
+ user in the Plus Minus Table.
+ """
+
+ for L0, L1, L2 in self._getValuesFromList():
+ prefs = [L0, L1, L2]
+ widgets = []
+ self._getPreferenceWidgets(self.prefsDefnL0, prefs, widgets)
+ yield widgets
+
+
+ def getWidgetsBasedOnUserSelection(self, selection):
+ """
+ Returns a list of widgets and their callbacks based on what the user has selected.
+
+ Selection is the values the user has chosen thus far in comboboxes.
+ It determines the contents of the widgets returned.
+ It should be a list of three values, with None for values not chosen.
+ For values which are None, the first value in the preferences
+ definition is chosen.
+
+ """
+ widgets = []
+
+ self._getPreferenceWidgets(self.prefsDefnL0, selection, widgets)
+ return widgets
+
+class SubfolderPreferences(ImageRenamePreferences):
+ def __init__(self, prefList, parent):
+ self.prefsDefnL0 = DICT_SUBFOLDER_L0
+ self.defaultPrefs = DEFAULT_SUBFOLDER_PREFS
+ self.defaultRow = [DATE_TIME, IMAGE_DATE, LIST_DATE_TIME_L2[0]]
+ self.stripForwardSlash = False
+ ImageRenamePreferences.__init__(self, prefList, parent)
+
+ def generateNameUsingPreferences(self, photo, existingFilename=None,
+ stripCharacters = False):
+ """
+ Generate a filename for the photo in string format based on user prefs.
+
+ Returns a tuple of two strings:
+ - the name
+ - any problems generating the name. If blank, there were no problems
+ """
+
+ subfolders, problem = ImageRenamePreferences.generateNameUsingPreferences(
+ self, photo,
+ existingFilename, stripCharacters, stripInitialPeriodFromExtension=True)
+ # subfolder value must never start with a separator, or else any
+ # os.path.join function call will fail to join a subfolder to its
+ # parent folder
+ if subfolders:
+ if subfolders[0] == os.sep:
+ subfolders = subfolders[1:]
+
+ return (subfolders, problem)
+
+ def filterPreferences(self):
+ filtered, prefList = filterSubfolderPreferences(self.prefList)
+ if filtered:
+ self.prefList = prefList
+
+ def needMetaDataToCreateUniqueName(self):
+ """
+ Returns True if metadata is essential to properly generate subfolders
+
+ This will be the case if the only components are metadata and separators
+ """
+
+ for e in self.prefList:
+ if (not e) and ((e not in METADATA_ELEMENTS) or (e <> SEPARATOR)):
+ return True
+
+ return False
+
+
+
+
+ def checkPrefsForValidity(self):
+ """
+ Checks subfolder preferences validity above and beyond image name checks.
+
+ See parent method for full description.
+
+ Subfolders have additional requirments to that of image names.
+ """
+ v = ImageRenamePreferences.checkPrefsForValidity(self)
+ if v:
+ # peform additional checks:
+ # 1. do not start with a separator
+ # 2. do not end with a separator
+ # 3. do not have two separators in a row
+ # these three rules will ensure something else other than a
+ # separator is specified
+ L1s = []
+ for i in range(0, len(self.prefList), 3):
+ L1s.append(self.prefList[i])
+
+ 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)
+ return v
+
+
+class Sequences:
+ """ Holds sequence numbers and letters used in generating filenames"""
+ def __init__(self, downloadsToday, storedSequenceNo):
+
+
+ self.subfolderSequenceNo = {}
+ self.sessionSequenceNo = 1
+ self.sequenceLetter = 0
+
+ self.setUseOfSequenceElements(False, False)
+
+ self.assignedSequenceCounter = 1
+ self.reset(downloadsToday, storedSequenceNo)
+
+ def setUseOfSequenceElements(self, usesSessionSequenceNo, usesSequenceLetter):
+ self.usesSessionSequenceNo = usesSessionSequenceNo
+ self.usesSequenceLetter = usesSequenceLetter
+
+ def reset(self, downloadsToday, storedSequenceNo):
+ self.downloadsToday = downloadsToday
+ self.downloadsTodayOffset = 0
+ self.storedSequenceNo = storedSequenceNo
+ if self.usesSessionSequenceNo:
+ self.sessionSequenceNo = self.sessionSequenceNo + self.assignedSequenceCounter - 1
+ if self.usesSequenceLetter:
+ self.sequenceLetter = self.sequenceLetter + self.assignedSequenceCounter - 1
+ self.doNotAddToPool = False
+ self.pool = []
+ self.poolSequenceCounter = 0
+ self.assignedSequenceCounter = 1
+
+ def getPrelimSequence(self):
+ if self.doNotAddToPool:
+ self.doNotAddToPool = False
+ else:
+ # increment pool sequence number
+ self.poolSequenceCounter += 1
+ self.pool.append(self.poolSequenceCounter)
+
+ return self.poolSequenceCounter
+
+ def getFinalSequence(self):
+ # get oldest queue value
+ # remove from queue or flag it should be removed
+
+ return self.assignedSequenceCounter
+
+ def getSequencePossibilities(self):
+ for i in self.pool:
+ yield i
+
+ def getSessionSequenceNo(self):
+ return self.sessionSequenceNo + self.assignedSequenceCounter - 1
+
+ def getSessionSequenceNoUsingCounter(self, counter):
+ return self.sessionSequenceNo + counter - 1
+
+ def setSessionSequenceNo(self, value):
+ self.sessionSequenceNo = value
+
+ def setStoredSequenceNo(self, value):
+ self.storedSequenceNo = value
+
+ def getDownloadsTodayUsingCounter(self, counter):
+ return self.downloadsToday + counter - self.downloadsTodayOffset
+
+ def setDownloadsToday(self, value):
+ self.downloadsToday = value
+ self.downloadsTodayOffset = self.assignedSequenceCounter - 1
+
+ def getStoredSequenceNoUsingCounter(self, counter):
+ return self.storedSequenceNo + counter
+
+ def getSequenceLetterUsingCounter(self, counter):
+ return self.sequenceLetter + counter - 1
+
+ def imageCopyFailed(self):
+ self.doNotAddToPool = True
+
+ def imageCopySucceeded(self):
+ self.increment()
+
+ def increment(self, subfolder=None):
+ assert(self.assignedSequenceCounter == self.pool[0])
+ self.assignedSequenceCounter += 1
+ self.pool = self.pool[1:]
+
+
+
+
+if __name__ == '__main__':
+ import sys
+ import os.path
+ from metadata import MetaData
+
+ if False:
+ if (len(sys.argv) != 2):
+ print 'Usage: ' + sys.argv[0] + ' path/to/photo/containing/metadata'
+ sys.exit(1)
+ else:
+ p0 = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE]
+ p1 = [FILENAME, NAME_EXTENSION, LOWERCASE]
+ p2 = [METADATA, APERTURE, None]
+ p3 = [FILENAME, IMAGE_NUMBER, IMAGE_NUMBER_ALL]
+ p4 = [METADATA, CAMERA_MODEL, ORIGINAL_CASE]
+ p5 = [TEXT, '-', None]
+ p6 = [TEXT, 'Job', None]
+
+ p = [p0, p1, p2, p3, p4]
+ p = [p6 + p5 + p2 + p5 + p3]
+
+ d0 = [DATE_TIME, IMAGE_DATE, 'YYYYMMDD']
+ d1 = [DATE_TIME, IMAGE_DATE, 'HHMMSS']
+ d2 = [DATE_TIME, IMAGE_DATE, SUBSECONDS]
+
+ d = [d0 + d1 + d2]
+
+ fullpath = sys.argv[1]
+ path, filename = os.path.split(fullpath)
+
+ m = MetaData(fullpath)
+ m.readMetadata()
+
+ for pref in p:
+ i = ImageRenamePreferences(pref, None)
+ print i.generateNameUsingPreferences(m, filename)
+
+ for pref in d:
+ i = ImageRenamePreferences(pref, None)
+ print i.generateNameUsingPreferences(m, filename)
+ else:
+ prefs = [SEQUENCES, SESSION_SEQ_NUMBER, SEQUENCE_NUMBER_3]
+# prefs = ['Filename2', NAME_EXTENSION, UPPERCASE]
+ print checkPreferenceValid(DICT_IMAGE_RENAME_L0, prefs)
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-15 10:27:30 +0000