qmsk.irclogs: comparison preferences.py

equal deleted inserted replaced

-:2a8a190f8aee
+:67a30d680f60
 import functools
 import Cookie
 from qmsk.web import urltree
+import utils
 class Preference (urltree.URLType) :
 """
 A specific preference
 """
 # the name to use
 name = None
-# the default value
+# the default value, as from parse()
 default = None
+def is_default (self, value) :
+"""
+Returns True if the given post-value is the default value for this preference.
+Defaults to just compare against self.default
+"""
+return (value == self.default)
 def process (self, preferences, value) :
 """
-Post-process this preference value. This can access the values of other preferences or the request via
+Post-process this preference value. This can access the post-processed values of all other preferences that
-the given RequestPreferences. Note that the other items will not be post-processed here.
+were defined before this one in the list given to Preferences.
 Defaults to just return value.
 """
 return value
 Represents the specific preferences for some request
 """
 def __init__ (self, preferences, request, value_map=None) :
 """
-Initialize with the given Preferences object, http Request, and list of mapping of raw preference values
+Initialize with the given Preferences object, http Request, and { key: value } mapping of raw preference values.
+This will build a mapping of { name: pre-value } using Preference.parse/Preference.default, and then
+post-process them into the final { name: value } mapping using Preference.process, in strict pref_list
+order. Note that the process() method will only have access to those preferences processed before it was.
 """
 # store
 self.preferences = preferences
 self.request = request
 # initialize
 self.values = {}
 self.set_cookies = {}
+# initial value map
+pre_values = {}
 # load preferences
 for pref in preferences.pref_list :
 # got a value for it?
 if value_map and pref.name in value_map :
 value = pref.parse(value)
 else :
 # use default value
 value = pref.default
 # add
-self.values[pref.name] = value
+pre_values[pref.name] = value
-# then post-process using the Preferences
+# then post-process using Preferences.process(), in strict pref_list order
-self.values = dict(
+for pref in preferences.pref_list :
-(name, self.preferences.pref_map[name].process(self, value)) for name, value in self.values.iteritems()
+# store into self.values, so that pref.get(...) will be able to access the still-incomplete self.values
-)
+# dict
+self.values[pref.name] = pref.process(self, pre_values[pref.name])
-def get (self, pref) :
-"""
+def _get_name (self, pref) :
-Return the value for the given Preference, or preference name
+"""
-"""
+Look up a Preference's name, either by class, object or name.
+"""
 # Preference -> name
 if isinstance(pref, Preference) :
 pref = pref.name
+return pref
+def pref (self, name) :
+"""
+Look up a Preference by object, name
+"""
+# Preference
+if isinstance(name, Preference) :
+return name
+# Preference.name
+elif isinstance(name, basestring) :
+return self.preferences.pref_map[name]
+# XXX: class?
+else :
+assert False
+def get (self, pref) :
+"""
+Return the value for the given Preference, or preference name
+"""
 # look up
-return self.values[pref]
+return self.values[self._get_name(pref)]
 # support dict-access
 __getitem__ = get
-def set (self, name, value_obj) :
+def is_default (self, pref) :
 """
-Set a new value for the given preference
+Returns True if the given preference is at its default value
+"""
+# determine using Preference.is_default
+return self.pref(pref).is_default(self.get(pref))
+def build (self, pref) :
+"""
+Like 'get', but return the raw cookie value
+"""
+# the Preference
+pref = self.pref(pref)
+# build
+return pref.build(self.get(pref))
+def parse (self, pref, value=None) :
+"""
+Parse+process the raw value for some pref into a value object.
+Is the given raw value is None, this uses Preference.default
+"""
+# lookup pref
+pref = self.pref(pref)
+# build value
+if value is not None :
+# parse
+value = pref.parse(value)
+else :
+# default
+value = pref.default
+# post-process
+value = pref.process(self, value)
+# return
+return value
+def set (self, name, value_obj=None) :
+"""
+Set a new value for the given preference (by str name).
+If value_obj is None, then the preference cookie is unset
 """
 # sanity-check to make sure we're not setting it twice...
 assert name not in self.set_cookies
-# encode using the Preference object
+# None?
-value_str = self.preferences.pref_map[name].build(value_obj)
+if value_obj is not None :
+# encode using the Preference object
+value_str = self.preferences.pref_map[name].build(value_obj)
+else :
+# unset as None
+value_str = None
 # update in our dict
 self.values[name] = value_obj
 # add to set_cookies
 Handle user preferences using cookies
 """
 def __init__ (self, pref_list) :
 """
-Use the given list of Preference objects
+Use the given list of Preference objects.
+The ordering of the given pref_list is significant for the process() implementation, as the
+Preferences are process()'d in order.
 """
 # store
 self.pref_list = pref_list
 # handle to get response
 response = func(request, **args)
 # set cookies?
 if prefs.set_cookies :
+# default, empty, cookiejar
 if not cookies :
 cookies = Cookie.SimpleCookie('')
 # update cookies
 for key, value in prefs.set_cookies.iteritems() :
-cookies[key] = value
+if value is None :
+assert False, "Not implemented yet..."
+else :
+# set
+cookies[key] = value
 # add headers
 for morsel in cookies.itervalues() :
 response.add_header('Set-cookie', morsel.OutputString())
 name = 'date_format'
 # default value
 default = config.PREF_DATE_FMT_DEFAULT
+class TimezoneOffset (Preference) :
+"""
+If the DST-aware 'timezone' is missing, we can fallback to a fixed-offset timezone as detected by
+Javascript.
+This is read-only, and None by default
+"""
+name = 'timezone_offset'
+default = None
+def parse (self, offset) :
+"""
+Offset in minutes -> said minutes
+"""
+return int(offset)
 class Timezone (Preference) :
 """
 Timezone
 """
 # set name
 name = 'timezone'
-# default value is UTC...
+# default is handled via process()
-default = config.PREF_TIMEZONE_DEFAULT
+default = 'auto'
+# the list of available (value, name) options for use with helpers.select_options
+OPTIONS = [('auto', "Autodetect")] + [(None, tz_name) for tz_name in pytz.common_timezones]
 def parse (self, name) :
 """
+default -> default
 tz_name -> pytz.timezone
 """
-return pytz.timezone(name)
+# special-case for 'auto'
+if name == self.default :
+return self.default
+else :
+return pytz.timezone(name)
+def is_default (self, tz) :
+"""
+True if it's a FixedOffsetTimezone
+"""
+return (isinstance(tz, utils.FixedOffsetTimezone))
 def build (self, tz) :
 """
+FixedOffsetTimezone -> None
 pytz.timezone -> tz_name
 """
-return tz.zone
+# special-case for auto/no explicit timezone
+if self.is_default(tz) :
+return self.default
+else :
+# pytz.timezone zone name
+return tz.zone
+def process (self, prefs, tz) :
+"""
+If this timezone is given, simply build that. Otherwise, try and use TimezoneOffset, and if that fails,
+just return the default.
+None -> FixedOffsetTimezone/PREF_TIMEZONE_DEFAULT
+pytz.timezone -> pytz.timezone
+"""
+# specific timezone set?
+if tz != self.default :
+return tz
+# fixed offset?
+elif prefs[timezone_offset] is not None :
+return utils.FixedOffsetTimezone(prefs[timezone_offset])
+# default
+else :
+print
+print "Timezone.process: %r, %r -> default: %r" % (prefs, tz, config.PREF_TIMEZONE_DEFAULT)
+return config.PREF_TIMEZONE_DEFAULT
 class ImageFont (Preference) :
 """
 Font for ImageFormatter
 """
 class ImageFontSize (urltree.URLIntegerType, Preference) :
 # set name, default
 name = 'image_font_size'
 default = config.PREF_IMAGE_FONT_SIZE_DEFAULT
-# XXX: params
+# XXX: constraints for valid values
 class Formatter (Preference) :
 """
 LogFormatter to use
 """
 def process (self, prefs, fmt_cls) :
 """
 class LogFormatter -> LogFormatter(tz, time_fmt, image_font.path)
 """
+# time stuff
+tz = prefs[timezone]
+time_fmt = prefs[time_format]
+# font stuff
 font_name, font_path, font_title = prefs[image_font]
 font_size = prefs[image_font_size]
-return fmt_cls(prefs[timezone], prefs[time_format], font_path, font_size)
+return fmt_cls(tz, time_fmt, font_path, font_size)
 class Count (urltree.URLIntegerType, Preference) :
 """
 Number of lines of log data to display per page
 """
 super(Count, self).__init__(allow_negative=False, allow_zero=False, max=config.PREF_COUNT_MAX)
 # and then build the Preferences object
 time_format     = TimeFormat()
 date_format     = DateFormat()
+timezone_offset = TimezoneOffset()
 timezone        = Timezone()
 image_font      = ImageFont(config.FORMATTER_IMAGE_FONTS, config.PREF_IMAGE_FONT_DEFAULT)
 image_font_size = ImageFontSize()
 formatter       = Formatter(config.LOG_FORMATTERS, config.PREF_FORMATTER_DEFAULT)
 count           = Count()
 preferences = Preferences([
 time_format,
 date_format,
+timezone_offset,
 timezone,
 image_font,
 image_font_size,
 formatter,
 count,

changeset 129	67a30d680f60
parent 79	43ac75054d5c
child 130	4212fd69d671