py_tasks_melange: comparison thirdparty/google_appengine/google/appengine/ext/db/__init_

equal deleted inserted replaced

-:a440ced9a75f
+:df109be0567c
 import datetime
 import logging
 import time
 import urlparse
 PostalAddress = datastore_types.PostalAddress
 Rating = datastore_types.Rating
 Text = datastore_types.Text
 Blob = datastore_types.Blob
 _kind_map = {}
 _SELF_REFERENCE = object()
 _RESERVED_WORDS = set(['key_name'])
 class DuplicatePropertyError(Error):
 """Raised when a property is duplicated in a model definition."""
 class ConfigurationError(Error):
-"""Raised when a property is improperly configured."""
+"""Raised when a property or model is improperly configured."""
 class ReservedWordError(Error):
 """Raised when a property is defined for a reserved word."""
+class DerivedPropertyError(Error):
+"""Raised when attempting to assign a value to a derived property."""
 _ALLOWED_PROPERTY_TYPES = set([
 basestring,
 str,
 "using a different name like %(attr_name)s_ and adding "
 "name='%(attr_name)s' to the parameter list of the property "
 "definition." % locals())
+def _initialize_properties(model_class, name, bases, dct):
+"""Initialize Property attributes for Model-class.
+Args:
+model_class: Model class to initialize properties for.
+"""
+model_class._properties = {}
+defined = set()
+for base in bases:
+if hasattr(base, '_properties'):
+property_keys = base._properties.keys()
+duplicate_properties = defined.intersection(property_keys)
+if duplicate_properties:
+raise DuplicatePropertyError(
+'Duplicate properties in base class %s already defined: %s' %
+(base.__name__, list(duplicate_properties)))
+defined.update(property_keys)
+model_class._properties.update(base._properties)
+for attr_name in dct.keys():
+attr = dct[attr_name]
+if isinstance(attr, Property):
+check_reserved_word(attr_name)
+if attr_name in defined:
+raise DuplicatePropertyError('Duplicate property: %s' % attr_name)
+defined.add(attr_name)
+model_class._properties[attr_name] = attr
+attr.__property_config__(model_class, attr_name)
 class PropertiedClass(type):
 """Meta-class for initializing Model classes properties.
 Used for initializing Properties defined in the context of a model.
 By using a meta-class much of the configuration of a Property
 do appropriate initialization via __property_config__.
 Duplicate properties are not permitted.
 """
-def __init__(cls, name, bases, dct):
+def __init__(cls, name, bases, dct, map_kind=True):
 """Initializes a class that might have property definitions.
 This method is called when a class is created with the PropertiedClass
 meta-class.
 ReservedWordError when a property is given a name that is in the list of
 reserved words, attributes of Model and names of the form '__.*__'.
 """
 super(PropertiedClass, cls).__init__(name, bases, dct)
-cls._properties = {}
+_initialize_properties(cls, name, bases, dct)
-defined = set()
-for base in bases:
+if map_kind:
-if hasattr(base, '_properties'):
+_kind_map[cls.kind()] = cls
-property_keys = base._properties.keys()
-duplicate_properties = defined.intersection(property_keys)
-if duplicate_properties:
-raise DuplicatePropertyError(
-'Duplicate properties in base class %s already defined: %s' %
-(base.__name__, list(duplicate_properties)))
-defined.update(property_keys)
-cls._properties.update(base._properties)
-for attr_name in dct.keys():
-attr = dct[attr_name]
-if isinstance(attr, Property):
-check_reserved_word(attr_name)
-if attr_name in defined:
-raise DuplicatePropertyError('Duplicate property: %s' % attr_name)
-defined.add(attr_name)
-cls._properties[attr_name] = attr
-attr.__property_config__(cls, attr_name)
-_kind_map[cls.kind()] = cls
 class Property(object):
 """A Property is an attribute of a Model.
 The value converted for use as a model instance attribute.
 """
 return value
 def _attr_name(self):
-"""Attribute name we use for this property in model instances."""
+"""Attribute name we use for this property in model instances.
+DO NOT USE THIS METHOD.
+"""
 return '_' + self.name
 data_type = str
 def datastore_type(self):
 group are ACID.
 """
 __metaclass__ = PropertiedClass
-def __init__(self, parent=None, key_name=None, _app=None, **kwds):
+def __init__(self,
+parent=None,
+key_name=None,
+_app=None,
+_from_entity=False,
+**kwds):
 """Creates a new instance of this model.
 To create a new entity, you instantiate a model and then call save(),
 which saves the entity to the datastore:
 Args:
 parent: Parent instance for this instance or None, indicating a top-
 level instance.
 key_name: Name for new model instance.
 _app: Intentionally undocumented.
+_from_entity: Intentionally undocumented.
 args: Keyword arguments mapping to properties of model.
 """
 if key_name == '':
 raise BadKeyError('Name cannot be empty.')
 elif key_name is not None and not isinstance(key_name, basestring):
 raise BadKeyError('Name must be string type, not %s' %
 key_name.__class__.__name__)
 if parent is not None:
-if not isinstance(parent, Model):
+if not isinstance(parent, (Model, Key)):
 raise TypeError('Expected Model type; received %s (is %s)' %
 (parent, parent.__class__.__name__))
-if not parent.is_saved():
+if isinstance(parent, Model) and not parent.has_key():
 raise BadValueError(
-"%s instance must be saved before it can be used as a "
+"%s instance must have a complete key before it can be used as a "
 "parent." % parent.kind())
+if isinstance(parent, Key):
-self._parent = parent
+self._parent_key = parent
+self._parent = None
+else:
+self._parent_key = parent.key()
+self._parent = parent
+else:
+self._parent_key = None
+self._parent = None
 self._entity = None
 self._key_name = key_name
 self._app = _app
 properties = self.properties()
 for prop in self.properties().values():
 if prop.name in kwds:
 value = kwds[prop.name]
 else:
 value = prop.default_value()
-prop.__set__(self, value)
+try:
+prop.__set__(self, value)
+except DerivedPropertyError, e:
+if prop.name in kwds and not _from_entity:
+raise
 def key(self):
 """Unique key for this entity.
 This property is only available if this entity is already stored in the
 Raises:
 NotSavedError when entity is not persistent.
 """
 if self.is_saved():
 return self._entity.key()
+elif self._key_name:
+parent = self._parent and self._parent.key()
+return Key.from_path(self.kind(), self._key_name, parent=parent)
 else:
 raise NotSavedError()
 def _to_entity(self, entity):
 """Copies information from this model to provided entity.
 self._entity or a new Entity which is not stored on the instance.
 """
 if self.is_saved():
 entity = self._entity
 else:
-if self._parent is not None:
+if self._parent_key is not None:
+entity = _entity_class(self.kind(),
+parent=self._parent_key,
+name=self._key_name,
+_app=self._app)
+elif self._parent is not None:
 entity = _entity_class(self.kind(),
 parent=self._parent._entity,
 name=self._key_name,
 _app=self._app)
 else:
 Returns:
 True if object has been persisted to the datastore, otherwise False.
 """
 return self._entity is not None
+def has_key(self):
+"""Determine if this model instance has a complete key.
+Ids are not assigned until the data is saved to the Datastore, but
+instances with a key name always have a full key.
+Returns:
+True if the object has been persisted to the datastore or has a key_name,
+otherwise False.
+"""
+return self.is_saved() or self._key_name
 def dynamic_properties(self):
 """Returns a list of all dynamic properties defined for instance."""
 return []
 def instance_properties(self):
 Returns:
 Parent of contained entity or parent provided in constructor, None if
 instance has no parent.
 """
-if (self._parent is None and
+if self._parent is None:
-self._entity is not None and
+parent_key = self.parent_key()
-self._entity.parent() is not None):
+if parent_key is not None:
-self._parent = get(self._entity.parent())
+self._parent = get(parent_key)
 return self._parent
 def parent_key(self):
 """Get the parent's key.
 but still get information about the instances parent.
 Returns:
 Parent key of entity, None if there is no parent.
 """
-if self._parent is not None:
+if self._parent_key is not None:
+return self._parent_key
+elif self._parent is not None:
 return self._parent.key()
 elif self._entity is not None:
 return self._entity.parent()
 else:
 return None
 if cls.kind() != entity.kind():
 raise KindError('Class %s cannot handle kind \'%s\'' %
 (repr(cls), entity.kind()))
 entity_values = cls._load_entity_values(entity)
-instance = cls(None, **entity_values)
+instance = cls(None, _from_entity=True, **entity_values)
 instance._entity = entity
 del instance._key_name
 return instance
 @classmethod
 def delete(models):
 """Delete one or more Model instances.
 Args:
-models: Model instance or list of Model instances.
+models_or_keys: Model instance or list of Model instances.
 Raises:
 TransactionFailedError if the data could not be committed.
 """
-models, multiple = datastore.NormalizeAndTypeCheck(models, Model)
+models_or_keys, multiple = datastore.NormalizeAndTypeCheck(
-entities = [model.key() for model in models]
+models, (Model, Key, basestring))
-keys = datastore.Delete(entities)
+keys = []
+for model_or_key in models_or_keys:
+if isinstance(model_or_key, Model):
+key = model_or_key = model_or_key.key()
+elif isinstance(model_or_key, basestring):
+key = model_or_key = Key(model_or_key)
+else:
+key = model_or_key
+keys.append(key)
+datastore.Delete(keys)
 class Expando(Model):
 """Dynamically expandable model.
 type(value).__name__)
 if self._dynamic_properties is None:
 self._dynamic_properties = {}
 self._dynamic_properties[key] = value
 else:
-Model.__setattr__(self, key, value)
+super(Expando, self).__setattr__(key, value)
 def __getattr__(self, key):
 """If no explicit attribute defined, retrieve value from entity.
 Tries to get the value on the object normally, but failing that
 property on the model.
 Args:
 entity: Entity which contain values to search dyanmic properties for.
 """
-entity_values = Model._load_entity_values(entity)
+entity_values = super(Expando, cls)._load_entity_values(entity)
 for key, value in entity.iteritems():
 if key not in entity_values:
 entity_values[str(key)] = value
 return entity_values
 if ancestor.has_id_or_name():
 self.__ancestor = ancestor
 else:
 raise NotSavedError()
 elif isinstance(ancestor, Model):
-if ancestor.is_saved():
+if ancestor.has_key():
 self.__ancestor = ancestor.key()
 else:
 raise NotSavedError()
 else:
 raise TypeError('ancestor should be Key or Model')
 value = super(ListProperty, self).validate(value)
 if value is not None:
 if not isinstance(value, list):
 raise BadValueError('Property %s must be a list' % self.name)
-if self.item_type in (int, long):
+value = self.validate_list_contents(value)
-item_type = (int, long)
+return value
-else:
-item_type = self.item_type
+def validate_list_contents(self, value):
+"""Validates that all items in the list are of the correct type.
-for item in value:
-if not isinstance(item, item_type):
+Returns:
-if item_type == (int, long):
+The validated list.
-raise BadValueError('Items in the %s list must all be integers.' %
-self.name)
+Raises:
-else:
+BadValueError if the list has items are not instances of the
-raise BadValueError(
+item_type given to the constructor.
-'Items in the %s list must all be %s instances' %
+"""
-(self.name, self.item_type.__name__))
+if self.item_type in (int, long):
+item_type = (int, long)
+else:
+item_type = self.item_type
+for item in value:
+if not isinstance(item, item_type):
+if item_type == (int, long):
+raise BadValueError('Items in the %s list must all be integers.' %
+self.name)
+else:
+raise BadValueError(
+'Items in the %s list must all be %s instances' %
+(self.name, self.item_type.__name__))
 return value
 def empty(self, value):
 """Is list property empty.
 Returns:
 Copy of the default value.
 """
 return list(super(ListProperty, self).default_value())
+def get_value_for_datastore(self, model_instance):
+"""Get value from property to send to datastore.
+Returns:
+validated list appropriate to save in the datastore.
+"""
+return self.validate_list_contents(
+super(ListProperty, self).get_value_for_datastore(model_instance))
 class StringListProperty(ListProperty):
 """A property that stores a list of strings.
 - Object not of correct model type for reference.
 """
 if isinstance(value, datastore.Key):
 return value
-if value is not None and not value.is_saved():
+if value is not None and not value.has_key():
 raise BadValueError(
-'%s instance must be saved before it can be stored as a '
+'%s instance must have a complete key before it can be stored as a '
 'reference' % self.reference_class.kind())
 value = super(ReferenceProperty, self).validate(value)
 if value is not None and not isinstance(value, self.reference_class):

changeset 686	df109be0567c
parent 297	35211afcd563
child 828	f5fd65cc3bf3