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

equal deleted inserted replaced

-:27971a13089f
+:2e0b0af889be
 PostalAddress = datastore_types.PostalAddress
 Rating = datastore_types.Rating
 Text = datastore_types.Text
 Blob = datastore_types.Blob
 ByteString = datastore_types.ByteString
+BlobKey = datastore_types.BlobKey
 _kind_map = {}
 _SELF_REFERENCE = object()
 GeoPt,
 IM,
 PhoneNumber,
 PostalAddress,
 Rating,
+BlobKey,
 ])
 _ALLOWED_EXPANDO_PROPERTY_TYPES = set(_ALLOWED_PROPERTY_TYPES)
 _ALLOWED_EXPANDO_PROPERTY_TYPES.update((list, tuple, type(None)))
 "using a different name like %(attr_name)s_ and adding "
 "name='%(attr_name)s' to the parameter list of the property "
 "definition." % locals())
+def query_descendants(model_instance):
+"""Returns a query for all the descendants of a model instance.
+Args:
+model_instance: Model instance to find the descendants of.
+Returns:
+Query that will retrieve all entities that have the given model instance
+as an ancestor. Unlike normal ancestor queries, this does not include the
+ancestor itself.
+"""
+result = Query().ancestor(model_instance);
+result.filter(datastore_types._KEY_SPECIAL_PROPERTY + ' >',
+model_instance.key());
+return result;
+def model_to_protobuf(model_instance, _entity_class=datastore.Entity):
+"""Encodes a model instance as a protocol buffer.
+Args:
+model_instance: Model instance to encode.
+Returns:
+entity_pb.EntityProto representation of the model instance
+"""
+return model_instance._populate_entity(_entity_class).ToPb()
+def model_from_protobuf(pb, _entity_class=datastore.Entity):
+"""Decodes a model instance from a protocol buffer.
+Args:
+pb: The protocol buffer representation of the model instance. Can be an
+entity_pb.EntityProto or str encoding of an entity_bp.EntityProto
+Returns:
+Model instance resulting from decoding the protocol buffer
+"""
+entity = _entity_class.FromPb(pb)
+return class_for_kind(entity.kind()).from_entity(entity)
 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 = {}
+property_source = {}
+def get_attr_source(name, cls):
+for src_cls  in cls.mro():
+if name in src_cls.__dict__:
+return src_cls
 defined = set()
 for base in bases:
 if hasattr(base, '_properties'):
-property_keys = base._properties.keys()
+property_keys = set(base._properties.keys())
-duplicate_properties = defined.intersection(property_keys)
+duplicate_property_keys = defined & property_keys
-if duplicate_properties:
+for dupe_prop_name in duplicate_property_keys:
-raise DuplicatePropertyError(
+old_source = property_source[dupe_prop_name] = get_attr_source(
-'Duplicate properties in base class %s already defined: %s' %
+dupe_prop_name, property_source[dupe_prop_name])
-(base.__name__, list(duplicate_properties)))
+new_source = get_attr_source(dupe_prop_name, base)
-defined.update(property_keys)
+if old_source != new_source:
-model_class._properties.update(base._properties)
+raise DuplicatePropertyError(
+'Duplicate property, %s, is inherited from both %s and %s.' %
+(dupe_prop_name, old_source.__name__, new_source.__name__))
+property_keys -= duplicate_property_keys
+if property_keys:
+defined |= property_keys
+property_source.update(dict.fromkeys(property_keys, base))
+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)
 __metaclass__ = PropertiedClass
 def __init__(self,
 parent=None,
 key_name=None,
+key=None,
 _app=None,
 _from_entity=False,
 **kwds):
 """Creates a new instance of this model.
 Args:
 parent: Parent instance for this instance or None, indicating a top-
 level instance.
 key_name: Name for new model instance.
-_app: Intentionally undocumented.
+key: Key instance for this instance, overrides parent and key_name
 _from_entity: Intentionally undocumented.
 args: Keyword arguments mapping to properties of model.
 """
-if key_name == '':
+if key is not None:
-raise BadKeyError('Name cannot be empty.')
+if isinstance(key, (tuple, list)):
-elif key_name is not None and not isinstance(key_name, basestring):
+key = Key.from_path(*key)
-raise BadKeyError('Name must be string type, not %s' %
+if isinstance(key, basestring):
-key_name.__class__.__name__)
+key = Key(encoded=key)
+if not isinstance(key, Key):
-if parent is not None:
+raise TypeError('Expected Key type; received %s (is %s)' %
-if not isinstance(parent, (Model, Key)):
+(key, key.__class__.__name__))
-raise TypeError('Expected Model type; received %s (is %s)' %
+if not key.has_id_or_name():
-(parent, parent.__class__.__name__))
+raise BadKeyError('Key must have an id or name')
-if isinstance(parent, Model) and not parent.has_key():
+if key.kind() != self.kind():
-raise BadValueError(
+raise BadKeyError('Expected Key kind to be %s; received %s' %
-"%s instance must have a complete key before it can be used as a "
+(self.kind(), key.kind()))
-"parent." % parent.kind())
+if _app is not None and key.app() != _app:
-if isinstance(parent, Key):
+raise BadKeyError('Expected Key app to be %s; received %s' %
-self._parent_key = parent
+(_app, key.app()))
+if key_name is not None:
+raise BadArgumentError('Cannot use key and key_name at the same time')
+if parent is not None:
+raise BadArgumentError('Cannot use key and parent at the same time')
+self._key = key
+self._key_name = None
+self._parent = None
+self._parent_key = None
+else:
+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, Key)):
+raise TypeError('Expected Model type; received %s (is %s)' %
+(parent, parent.__class__.__name__))
+if isinstance(parent, Model) and not parent.has_key():
+raise BadValueError(
+"%s instance must have a complete key before it can be used as a "
+"parent." % parent.kind())
+if isinstance(parent, Key):
+self._parent_key = parent
+self._parent = None
+else:
+self._parent_key = parent.key()
+self._parent = parent
+else:
+self._parent_key = None
 self._parent = None
-else:
+self._key_name = key_name
-self._parent_key = parent.key()
+self._key = None
-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()
 def key(self):
 """Unique key for this entity.
 This property is only available if this entity is already stored in the
-datastore, so it is available if this entity was fetched returned from a
+datastore or if it has a full key, so it is available if this entity was
-query, or after put() is called the first time for new entities.
+fetched returned from a query, or after put() is called the first time
+for new entities, or if a complete key was given when constructed.
 Returns:
 Datastore key of persisted entity.
 Raises:
 NotSavedError when entity is not persistent.
 """
 if self.is_saved():
 return self._entity.key()
+elif self._key:
+return self._key
 elif self._key_name:
-if self._parent_key:
-parent_key = self._parent_key
-elif self._parent:
-parent_key = self._parent.key()
 parent = self._parent_key or (self._parent and self._parent.key())
-return Key.from_path(self.kind(), self._key_name, parent=parent)
+self._key = Key.from_path(self.kind(), self._key_name, parent=parent)
+return self._key
 else:
 raise NotSavedError()
 def _to_entity(self, entity):
 """Copies information from this model to provided entity.
 Returns:
 Populated self._entity
 """
 self._entity = self._populate_entity(_entity_class=_entity_class)
-if hasattr(self, '_key_name'):
+for attr in ('_key_name', '_key'):
-del self._key_name
+try:
+delattr(self, attr)
+except AttributeError:
+pass
 return self._entity
 def put(self):
 """Writes this model instance to the datastore.
 """
 if self.is_saved():
 entity = self._entity
 else:
 kwds = {'_app': self._app,
-'name': self._key_name,
 'unindexed_properties': self._unindexed_properties}
+if self._key is not None:
-if self._parent_key is not None:
+if self._key.id():
-kwds['parent'] = self._parent_key
+kwds['id'] = self._key.id()
-elif self._parent is not None:
+else:
-kwds['parent'] = self._parent._entity
+kwds['name'] = self._key.name()
+if self._key.parent():
+kwds['parent'] = self._key.parent()
+else:
+if self._key_name is not None:
+kwds['name'] = self._key_name
+if self._parent_key is not None:
+kwds['parent'] = self._parent_key
+elif self._parent is not None:
+kwds['parent'] = self._parent._entity
 entity = _entity_class(self.kind(), **kwds)
 self._to_entity(entity)
 return entity
 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
+When not using a fully self-assigned Key, ids are not assigned until the
-instances with a key name always have a full key.
+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,
+Returns:
-otherwise False.
+True if the object has been persisted to the datastore or has a key
-"""
+or has a key_name, otherwise False.
-return self.is_saved() or self._key_name
+"""
+return self.is_saved() or self._key or self._key_name
 def dynamic_properties(self):
 """Returns a list of all dynamic properties defined for instance."""
 return []
 return self._parent_key
 elif self._parent is not None:
 return self._parent.key()
 elif self._entity is not None:
 return self._entity.parent()
+elif self._key is not None:
+return self._key.parent()
 else:
 return None
 def to_xml(self, _entity_class=datastore.Entity):
 """Generate an XML representation of this model instance.
 raise KindError('Class %s cannot handle kind \'%s\'' %
 (repr(cls), entity.kind()))
 entity_values = cls._load_entity_values(entity)
 instance = cls(None, _from_entity=True, **entity_values)
-instance._entity = entity
+if entity.is_saved():
-del instance._key_name
+instance._entity = entity
+del instance._key_name
+del instance._key
+elif entity.key().has_id_or_name():
+instance._key = entity.key()
 return instance
 @classmethod
 def kind(cls):
 """Returns the datastore kind we use for this model.
 else:
 key = model_or_key
 keys.append(key)
 datastore.Delete(keys)
+def allocate_ids(model, size):
+"""Allocates a range of IDs of size for the model_key defined by model
+Allocates a range of IDs in the datastore such that those IDs will not
+be automatically assigned to new entities. You can only allocate IDs
+for model keys from your app. If there is an error, raises a subclass of
+datastore_errors.Error.
+Args:
+model: Model, Key or string to serve as a model specifying the ID sequence
+in which to allocate IDs
+Returns:
+(start, end) of the allocated range, inclusive.
+"""
+models_or_keys, multiple = datastore.NormalizeAndTypeCheck(
+model, (Model, Key, basestring))
+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)
+return datastore.AllocateIds(keys, size)
 class Expando(Model):
 """Dynamically expandable model.
 An Expando does not require (but can still benefit from) the definition
 class _BaseQuery(object):
 """Base class for both Query and GqlQuery."""
-def __init__(self, model_class, keys_only=False):
+def __init__(self, model_class=None, keys_only=False):
 """Constructor.
 Args:
 model_class: Model class from which entities are constructed.
 keys_only: Whether the query should return full entities or only keys.
 raw = self._get_query().Get(limit, offset)
 if self._keys_only:
 return raw
 else:
-return [self._model_class.from_entity(e) for e in raw]
+if self._model_class is not None:
+return [self._model_class.from_entity(e) for e in raw]
+else:
+return [class_for_kind(e.kind()).from_entity(e) for e in raw]
 def __getitem__(self, arg):
 """Support for query[index] and query[start:stop].
 Beware: this ignores the LIMIT clause on GQL queries.
 Next model instance.
 Raises:
 StopIteration when there are no more results in query.
 """
-return self.__model_class.from_entity(self.__iterator.next())
+if self.__model_class is not None:
+return self.__model_class.from_entity(self.__iterator.next())
+else:
+entity = self.__iterator.next()
+return class_for_kind(entity.kind()).from_entity(entity)
 def _normalize_query_parameter(value):
 """Make any necessary type conversions to a query parameter.
 for story in Query(story).filter('title =', 'Foo').order('-date'):
 print story.title
 """
-def __init__(self, model_class, keys_only=False):
+def __init__(self, model_class=None, keys_only=False):
 """Constructs a query over instances of the given Model.
 Args:
 model_class: Model class to build query for.
 keys_only: Whether the query should return full entities or only keys.
 def _get_query(self,
 _query_class=datastore.Query,
 _multi_query_class=datastore.MultiQuery):
 queries = []
 for query_set in self.__query_sets:
-query = _query_class(self._model_class.kind(),
+if self._model_class is not None:
+kind = self._model_class.kind()
+else:
+kind = None
+query = _query_class(kind,
 query_set,
 keys_only=self._keys_only)
 query.Order(*self.__orderings)
 if self.__ancestor is not None:
 query.Ancestor(self.__ancestor)
 if match.group(3) is not None:
 operator = match.group(3)
 else:
 operator = '=='
-if prop in self._model_class._unindexed_properties:
+if self._model_class is None:
+if prop != datastore_types._KEY_SPECIAL_PROPERTY:
+raise BadQueryError(
+'Only %s filters are allowed on kindless queries.' %
+datastore_types._KEY_SPECIAL_PROPERTY)
+elif prop in self._model_class._unindexed_properties:
 raise PropertyError('Property \'%s\' is not indexed' % prop)
 if operator.lower() == 'in':
 if self._keys_only:
 raise BadQueryError('Keys only queries do not support IN filters.')
 property = property[1:]
 order = datastore.Query.DESCENDING
 else:
 order = datastore.Query.ASCENDING
-if not issubclass(self._model_class, Expando):
+if self._model_class is None:
-if (property not in self._model_class.properties() and
+if (property != datastore_types._KEY_SPECIAL_PROPERTY or
-property not in datastore_types._SPECIAL_PROPERTIES):
+order != datastore.Query.ASCENDING):
-raise PropertyError('Invalid property name \'%s\'' % property)
+raise BadQueryError(
+'Only %s ascending orders are supported on kindless queries' %
-if property in self._model_class._unindexed_properties:
+datastore_types._KEY_SPECIAL_PROPERTY)
-raise PropertyError('Property \'%s\' is not indexed' % property)
+else:
+if not issubclass(self._model_class, Expando):
+if (property not in self._model_class.properties() and
+property not in datastore_types._SPECIAL_PROPERTIES):
+raise PropertyError('Invalid property name \'%s\'' % property)
+if property in self._model_class._unindexed_properties:
+raise PropertyError('Property \'%s\' is not indexed' % property)
 self.__orderings.append((property, order))
 return self
 def ancestor(self, ancestor):
 """
 from google.appengine.ext import gql
 app = kwds.pop('_app', None)
 self._proto_query = gql.GQL(query_string, _app=app)
-model_class = class_for_kind(self._proto_query._entity)
+if self._proto_query._entity is not None:
+model_class = class_for_kind(self._proto_query._entity)
+else:
+model_class = None
 super(GqlQuery, self).__init__(model_class,
 keys_only=self._proto_query._keys_only)
-for property, unused in (self._proto_query.filters().keys() +
+if model_class is not None:
-self._proto_query.orderings()):
+for property, unused in (self._proto_query.filters().keys() +
-if property in model_class._unindexed_properties:
+self._proto_query.orderings()):
-raise PropertyError('Property \'%s\' is not indexed' % property)
+if property in model_class._unindexed_properties:
+raise PropertyError('Property \'%s\' is not indexed' % property)
 self.bind(*args, **kwds)
 def bind(self, *args, **kwds):
 """Bind arguments (positional or keyword) to the query.
 if self.auto_current_user:
 return users.get_current_user()
 return super(UserProperty, self).get_value_for_datastore(model_instance)
 data_type = users.User
 class ListProperty(Property):
 """A property that stores a list of things.

changeset 2864	2e0b0af889be
parent 2413	d0b7dac5325c
child 3031	7678f72140e6