Merging in latest boto.

boto/sdb/db/property.py

 # Copyright (c) 2006,2007,2008 Mitch Garnaat http://garnaat.org/
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
 #
@@ skipping 57 matching lines @@
             boto.log.exception("Exception running on_set_%s" % self.name)
 
         setattr(obj, self.slot_name, value)
 
     def __property_config__(self, model_class, property_name):
         self.model_class = model_class
         self.name = property_name
         self.slot_name = '_' + self.name
 
     def default_validator(self, value):
-        if value == self.default_value():
+        if isinstance(value, basestring) or value == self.default_value():
             return
         if not isinstance(value, self.data_type):
             raise TypeError, 'Validation Error, expecting %s, got %s' % (self.data_type, type(value))
                                       
     def default_value(self):
         return self.default
 
     def validate(self, value):
         if self.required and value==None:
             raise ValueError, '%s is a required property' % self.name
@@ skipping 39 matching lines @@
 class TextProperty(Property):
     
     type_name = 'Text'
     
     def __init__(self, verbose_name=None, name=None, default='', required=False,
                  validator=None, choices=None, unique=False, max_length=None):
         Property.__init__(self, verbose_name, name, default, required, validator, choices, unique)
         self.max_length = max_length
 
     def validate(self, value):
+        value = super(TextProperty, self).validate(value)
         if not isinstance(value, str) and not isinstance(value, unicode):
             raise TypeError, 'Expecting Text, got %s' % type(value)
         if self.max_length and len(value) > self.max_length:
             raise ValueError, 'Length of value greater than maxlength %s' % self.max_length
 
 class PasswordProperty(StringProperty):
     """
-    Hashed property who's original value can not be
-    retrieved, but still can be compaired.
+
+    Hashed property whose original value can not be
+    retrieved, but still can be compared.
+
+    Works by storing a hash of the original value instead
+    of the original value.  Once that's done all that
+    can be retrieved is the hash.
+
+    The comparison
+
+       obj.password == 'foo' 
+
+    generates a hash of 'foo' and compares it to the
+    stored hash.
+
+    Underlying data type for hashing, storing, and comparing
+    is boto.utils.Password.  The default hash function is
+    defined there ( currently sha512 in most cases, md5
+    where sha512 is not available )
+
+    It's unlikely you'll ever need to use a different hash
+    function, but if you do, you can control the behavior 
+    in one of two ways:
+
+      1) Specifying hashfunc in PasswordProperty constructor
+
+         import hashlib
+
+         class MyModel(model):
+             password = PasswordProperty(hashfunc=hashlib.sha224)
+
+      2) Subclassing Password and PasswordProperty
+        
+         class SHA224Password(Password):
+             hashfunc=hashlib.sha224
+
+         class SHA224PasswordProperty(PasswordProperty):
+             data_type=MyPassword
+             type_name="MyPassword"
+
+         class MyModel(Model):
+             password = SHA224PasswordProperty()
+
     """
     data_type = Password
     type_name = 'Password'
 
     def __init__(self, verbose_name=None, name=None, default='', required=False,
-                 validator=None, choices=None, unique=False):
+                 validator=None, choices=None, unique=False, hashfunc=None):
+
+        """
+           The hashfunc parameter overrides the default hashfunc in boto.utils.Password.
+
+           The remaining parameters are passed through to StringProperty.__init__"""
+
+
         StringProperty.__init__(self, verbose_name, name, default, required, validator, choices, unique)
+        self.hashfunc=hashfunc
 
     def make_value_from_datastore(self, value):
-        p = Password(value)
+        p = self.data_type(value, hashfunc=self.hashfunc)
         return p
 
     def get_value_for_datastore(self, model_instance):
         value = StringProperty.get_value_for_datastore(self, model_instance)
         if value and len(value):
             return str(value)
         else:
             return None
 
     def __set__(self, obj, value):
-        if not isinstance(value, Password):
-            p = Password()
+        if not isinstance(value, self.data_type):
+            p = self.data_type(hashfunc=self.hashfunc)
             p.set(value)
             value = p
         Property.__set__(self, obj, value)
 
     def __get__(self, obj, objtype):
-        return Password(StringProperty.__get__(self, obj, objtype))
+        return self.data_type(StringProperty.__get__(self, obj, objtype), hashfunc=self.hashfunc)
 
     def validate(self, value):
         value = Property.validate(self, value)
-        if isinstance(value, Password):
+        if isinstance(value, self.data_type):
             if len(value) > 1024:
                 raise ValueError, 'Length of value greater than maxlength'
         else:
-            raise TypeError, 'Expecting Password, got %s' % type(value)
+            raise TypeError, 'Expecting %s, got %s' % (type(self.data_type), type(value))
 
 class BlobProperty(Property):
     data_type = Blob
     type_name = "blob"
 
     def __set__(self, obj, value):
         if value != self.default_value():
             if not isinstance(value, Blob):
                 oldb = self.__get__(obj, type(obj))
                 id = None
                 if oldb:
                     id = oldb.id
                 b = Blob(value=value, id=id)
                 value = b
         Property.__set__(self, obj, value)
 
 class S3KeyProperty(Property):
     
     data_type = boto.s3.key.Key
     type_name = 'S3Key'
     validate_regex = "^s3:\/\/([^\/]*)\/(.*)$"
 
     def __init__(self, verbose_name=None, name=None, default=None,
                  required=False, validator=None, choices=None, unique=False):
         Property.__init__(self, verbose_name, name, default, required,
                           validator, choices, unique)
 
     def validate(self, value):
+        value = super(S3KeyProperty, self).validate(value)
         if value == self.default_value() or value == str(self.default_value()):
             return self.default_value()
         if isinstance(value, self.data_type):
             return
         match = re.match(self.validate_regex, value)
         if match:
             return
         raise TypeError, 'Validation Error, expecting %s, got %s' % (self.data_type, type(value))
 
     def __get__(self, obj, objtype):
@@ skipping 112 matching lines @@
         Property.__init__(self, verbose_name, name, default, required, validator, choices, unique)
         self.auto_now = auto_now
         self.auto_now_add = auto_now_add
 
     def default_value(self):
         if self.auto_now or self.auto_now_add:
             return self.now()
         return Property.default_value(self)
 
     def validate(self, value):
+        value = super(DateTimeProperty, self).validate(value)
         if value == None:
             return
         if not isinstance(value, self.data_type):
             raise TypeError, 'Validation Error, expecting %s, got %s' % (self.data_type, type(value))
 
     def get_value_for_datastore(self, model_instance):
         if self.auto_now:
             setattr(model_instance, self.name, self.now())
         return Property.get_value_for_datastore(self, model_instance)
 
@@ skipping 10 matching lines @@
         Property.__init__(self, verbose_name, name, default, required, validator, choices, unique)
         self.auto_now = auto_now
         self.auto_now_add = auto_now_add
 
     def default_value(self):
         if self.auto_now or self.auto_now_add:
             return self.now()
         return Property.default_value(self)
 
     def validate(self, value):
+        value = super(DateProperty, self).validate(value)
         if value == None:
             return
         if not isinstance(value, self.data_type):
             raise TypeError, 'Validation Error, expecting %s, got %s' % (self.data_type, type(value))
 
     def get_value_for_datastore(self, model_instance):
         if self.auto_now:
             setattr(model_instance, self.name, self.now())
         val = Property.get_value_for_datastore(self, model_instance)
         if isinstance(val, datetime.datetime):
             val = val.date()
         return val
 
     def now(self):
         return datetime.date.today()
 
+
+class TimeProperty(Property):
+    data_type = datetime.time
+    type_name = 'Time'
+
+    def __init__(self, verbose_name=None, name=None,
+                 default=None, required=False, validator=None, choices=None, unique=False):
+        Property.__init__(self, verbose_name, name, default, required, validator, choices, unique)
+
+    def validate(self, value):
+        value = super(TimeProperty, self).validate(value)
+        if value is None:
+            return
+        if not isinstance(value, self.data_type):
+            raise TypeError, 'Validation Error, expecting %s, got %s' % (self.data_type, type(value))
+
+
 class ReferenceProperty(Property):
 
     data_type = Key
     type_name = 'Reference'
 
     def __init__(self, reference_class=None, collection_name=None,
                  verbose_name=None, name=None, default=None, required=False, validator=None, choices=None, unique=False):
         Property.__init__(self, verbose_name, name, default, required, validator, choices, unique)
         self.reference_class = reference_class
         self.collection_name = collection_name
@@ skipping 37 matching lines @@
         try:
             obj_lineage = value.get_lineage()
             cls_lineage = self.reference_class.get_lineage()
             if obj_lineage.startswith(cls_lineage):
                 return
             raise TypeError, '%s not instance of %s' % (obj_lineage, cls_lineage)
         except:
             raise ValueError, '%s is not a Model' % value
             
     def validate(self, value):
+        if self.validator:
+            self.validator(value)
         if self.required and value==None:
             raise ValueError, '%s is a required property' % self.name
         if value == self.default_value():
             return
         if not isinstance(value, str) and not isinstance(value, unicode):
             self.check_instance(value)
         
 class _ReverseReferenceProperty(Property):
     data_type = Query
     type_name = 'query'
@@ skipping 65 matching lines @@
     data_type = list
     type_name = 'List'
 
     def __init__(self, item_type, verbose_name=None, name=None, default=None, **kwds):
         if default is None:
             default = []
         self.item_type = item_type
         Property.__init__(self, verbose_name, name, default=default, required=True, **kwds)
 
     def validate(self, value):
+        if self.validator:
+            self.validator(value)
         if value is not None:
             if not isinstance(value, list):
                 value = [value]
 
         if self.item_type in (int, long):
             item_type = (int, long)
         elif self.item_type in (str, unicode):
             item_type = (str, unicode)
         else:
             item_type = self.item_type
@@ skipping 33 matching lines @@
     data_type = dict
     type_name = 'Map'
 
     def __init__(self, item_type=str, verbose_name=None, name=None, default=None, **kwds):
         if default is None:
             default = {}
         self.item_type = item_type
         Property.__init__(self, verbose_name, name, default=default, required=True, **kwds)
 
     def validate(self, value):
+        value = super(MapProperty, self).validate(value)
         if value is not None:
             if not isinstance(value, dict):
                 raise ValueError, 'Value must of type dict'
 
         if self.item_type in (int, long):
             item_type = (int, long)
         elif self.item_type in (str, unicode):
             item_type = (str, unicode)
         else:
             item_type = self.item_type
 
         for key in value:
             if not isinstance(value[key], item_type):
                 if item_type == (int, long):
                     raise ValueError, 'Values in the %s Map must all be integers.' % self.name
                 else:
                     raise ValueError('Values in the %s Map must all be %s instances' %
                                      (self.name, self.item_type.__name__))
         return value
 
     def empty(self, value):
         return value is None
 
     def default_value(self):
         return {}