py_tasks_melange: comparison thirdparty/google_appengine/google/appengine/api/datastore.py

equal deleted inserted replaced

-:27971a13089f
+:2e0b0af889be
 from google.appengine.datastore import datastore_index
 from google.appengine.datastore import datastore_pb
 from google.appengine.runtime import apiproxy_errors
 from google.appengine.datastore import entity_pb
+try:
+from google.appengine.api.labs.taskqueue import taskqueue_service_pb
+except ImportError:
+from google.appengine.api.taskqueue import taskqueue_service_pb
 MAX_ALLOWABLE_QUERIES = 30
 DEFAULT_TRANSACTION_RETRIES = 3
 _MAX_INDEXED_PROPERTIES = 5000
+_MAX_ID_BATCH_SIZE = 1000 * 1000 * 1000
 Key = datastore_types.Key
 typename = datastore_types.typename
 _txes = {}
 if multiple and not entities:
 return []
 for entity in entities:
-if not entity.kind() or not entity.app():
+if not entity.kind() or not entity.app_id_namespace():
 raise datastore_errors.BadRequestError(
 'App and kind must not be empty, in entity: %s' % entity)
 req = datastore_pb.PutRequest()
 req.entity_list().extend([e._ToPb() for e in entities])
 keys = [e.key() for e in entities]
 tx = _MaybeSetupTransaction(req, keys)
-if tx:
-tx.RecordModifiedKeys([k for k in keys if k.has_id_or_name()])
 resp = datastore_pb.PutResponse()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Put', req, resp)
 except apiproxy_errors.ApplicationError, err:
 for entity, key in zip(entities, keys):
 entity._Entity__key._Key__reference.CopyFrom(key)
 if tx:
-tx.RecordModifiedKeys([e.key() for e in entities], error_on_repeat=False)
 tx.entity_group = entities[0].entity_group()
 if multiple:
 return [Key._FromPb(k) for k in keys]
 else:
 req = datastore_pb.DeleteRequest()
 req.key_list().extend([key._Key__reference for key in keys])
 tx = _MaybeSetupTransaction(req, keys)
-if tx:
-tx.RecordModifiedKeys(keys)
 resp = datastore_pb.DeleteResponse()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Delete', req, resp)
 except apiproxy_errors.ApplicationError, err:
 """A datastore entity.
 Includes read-only accessors for app id, kind, and primary key. Also
 provides dictionary-style access to properties.
 """
-def __init__(self, kind, parent=None, _app=None, name=None,
+def __init__(self, kind, parent=None, _app=None, name=None, id=None,
-unindexed_properties=[]):
+unindexed_properties=[], _namespace=None):
 """Constructor. Takes the kind and transaction root, which cannot be
 changed after the entity is constructed, and an optional parent. Raises
 BadArgumentError or BadKeyError if kind is invalid or parent is not an
 existing Entity or Key in the datastore.
 kind: string
 # if provided, this entity's parent. Its key must be complete.
 parent: Entity or Key
 # if provided, this entity's name.
 name: string
+# if provided, this entity's id.
+id: integer
 # if provided, a sequence of property names that should not be indexed
 # by the built-in single property indices.
 unindexed_properties: list or tuple of strings
 """
 ref = entity_pb.Reference()
-_app = datastore_types.ResolveAppId(_app)
+_app_namespace = datastore_types.ResolveAppIdNamespace(_app, _namespace)
-ref.set_app(_app)
+ref.set_app(_app_namespace.to_encoded())
 datastore_types.ValidateString(kind, 'kind',
 datastore_errors.BadArgumentError)
 if parent is not None:
 parent = _GetCompleteKeyOrError(parent)
-if _app != parent.app():
+if _app_namespace != parent.app_id_namespace():
 raise datastore_errors.BadArgumentError(
-"_app %s doesn't match parent's app %s" % (_app, parent.app()))
+" %s doesn't match parent's app_namespace %s" %
+(_app_namespace, parent.app_id_namespace()))
 ref.CopyFrom(parent._Key__reference)
 last_path = ref.mutable_path().add_element()
 last_path.set_type(kind.encode('utf-8'))
+if name is not None and id is not None:
+raise datastore_errors.BadArgumentError(
+"Cannot set both name and id on an Entity")
 if name is not None:
 datastore_types.ValidateString(name, 'name')
-if name[0] in string.digits:
-raise datastore_errors.BadValueError('name cannot begin with a digit')
 last_path.set_name(name.encode('utf-8'))
+if id is not None:
+datastore_types.ValidateInteger(id, 'id')
+last_path.set_id(id)
 unindexed_properties, multiple = NormalizeAndTypeCheck(unindexed_properties, basestring)
 if not multiple:
 raise datastore_errors.BadArgumentError(
 'unindexed_properties must be a sequence; received %s (a %s).' %
 self.__key = Key._FromPb(ref)
 def app(self):
 """Returns the name of the application that created this entity, a
-string.
+string or None if not set.
 """
 return self.__key.app()
+def namespace(self):
+"""Returns the namespace of this entity, a string or None.
+"""
+return self.__key.namespace()
+def app_id_namespace(self):
+"""Returns the AppIdNamespace of this entity or None if not set.
+"""
+return self.__key.app_id_namespace()
 def kind(self):
 """Returns this entity's kind, a string.
 """
 return self.__key.kind()
+def is_saved(self):
+"""Returns if this entity has been saved to the datastore
+"""
+last_path = self.__key._Key__reference.path().element_list()[-1]
+return ((last_path.has_name() ^ last_path.has_id()) and
+self.__key.has_id_or_name())
 def key(self):
 """Returns this entity's primary key, a Key instance.
 """
 return self.__key
 else:
 xml.append(saxutils.escape(unicode(val)))
 return xml
-def _ToPb(self):
+def ToPb(self):
+"""Converts this Entity to its protocol buffer representation.
+Returns:
+entity_pb.Entity
+"""
+return self._ToPb(False)
+def _ToPb(self, mark_key_as_saved=True):
 """Converts this Entity to its protocol buffer representation. Not
 intended to be used by application developers.
 Returns:
 entity_pb.Entity
 """
 pb = entity_pb.EntityProto()
 pb.mutable_key().CopyFrom(self.key()._ToPb())
+last_path = pb.key().path().element_list()[-1]
+if mark_key_as_saved and last_path.has_name() and last_path.has_id():
+last_path.clear_id()
 group = pb.mutable_entity_group()
 if self.__key.has_id_or_name():
 root = pb.key().path().element(0)
 group.add_element().CopyFrom(root)
 'Too many indexed properties for entity %r.' % self.key())
 return pb
 @staticmethod
-def _FromPb(pb):
+def FromPb(pb):
+"""Static factory method. Returns the Entity representation of the
+given protocol buffer (datastore_pb.Entity).
+Args:
+pb: datastore_pb.Entity or str encoding of a datastore_pb.Entity
+Returns:
+Entity: the Entity representation of pb
+"""
+if isinstance(pb, str):
+real_pb = entity_pb.EntityProto()
+real_pb.ParseFromString(pb)
+pb = real_pb
+return Entity._FromPb(pb, require_valid_key=False)
+@staticmethod
+def _FromPb(pb, require_valid_key=True):
 """Static factory method. Returns the Entity representation of the
 given protocol buffer (datastore_pb.Entity). Not intended to be used by
 application developers.
 The Entity PB's key must be complete. If it isn't, an AssertionError is
 Entity
 """
 assert pb.key().path().element_size() > 0
 last_path = pb.key().path().element_list()[-1]
-assert last_path.has_id() ^ last_path.has_name()
+if require_valid_key:
-if last_path.has_id():
+assert last_path.has_id() ^ last_path.has_name()
-assert last_path.id() != 0
+if last_path.has_id():
-else:
+assert last_path.id() != 0
-assert last_path.has_name()
+else:
-assert last_path.name()
+assert last_path.has_name()
+assert last_path.name()
 unindexed_properties = [p.name() for p in pb.raw_property_list()]
 e = Entity(unicode(last_path.type().decode('utf-8')),
 unindexed_properties=unindexed_properties)
 __filter_counter = 0
 __inequality_prop = None
 __inequality_count = 0
-def __init__(self, kind, filters={}, _app=None, keys_only=False):
+def __init__(self, kind=None, filters={}, _app=None, keys_only=False,
+_namespace=None):
 """Constructor.
 Raises BadArgumentError if kind is not a string. Raises BadValueError or
 BadFilterError if filters is not a dictionary of valid filters.
 # as an initial set of property filters. keys_only defaults to False.
 kind: string
 filters: dict
 keys_only: boolean
 """
-datastore_types.ValidateString(kind, 'kind',
+if kind is not None:
-datastore_errors.BadArgumentError)
+datastore_types.ValidateString(kind, 'kind',
+datastore_errors.BadArgumentError)
 self.__kind = kind
 self.__orderings = []
 self.__filter_order = {}
 self.update(filters)
-self.__app = datastore_types.ResolveAppId(_app)
+self.__app = datastore_types.ResolveAppIdNamespace(_app,
+_namespace).to_encoded()
 self.__keys_only = keys_only
 def Order(self, *orderings):
 """Specify how the query results should be sorted.
 raise datastore_errors.BadArgumentError(
 'Order() expects Query.ASCENDING or DESCENDING; received %s' %
 str(direction))
 direction = Query.ASCENDING
+if (self.__kind is None and
+(property != datastore_types._KEY_SPECIAL_PROPERTY or
+direction != Query.ASCENDING)):
+raise datastore_errors.BadArgumentError(
+'Only %s ascending orders are supported on kindless queries' %
+datastore_types._KEY_SPECIAL_PROPERTY)
 orderings[i] = (property, direction)
 if (orderings and self.__inequality_prop and
 orderings[0][0] != self.__inequality_prop):
 raise datastore_errors.BadArgumentError(
 # an iterator that provides access to the query results
 Iterator
 """
 return self._Run()
-def _Run(self, limit=None, offset=None):
+def _Run(self, limit=None, offset=None,
+prefetch_count=None, next_count=None):
 """Runs this query, with an optional result limit and an optional offset.
-Identical to Run, with the extra optional limit and offset parameters.
+Identical to Run, with the extra optional limit, offset, prefetch_count,
-limit and offset must both be integers >= 0.
+next_count parameters. These parameters must be integers >= 0.
 This is not intended to be used by application developers. Use Get()
 instead!
 """
-pb = self._ToPb(limit, offset)
+pb = self._ToPb(limit, offset, prefetch_count)
 result = datastore_pb.QueryResult()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'RunQuery', pb, result)
 except apiproxy_errors.ApplicationError, err:
 yaml = datastore_index.IndexYamlForQuery(
 *datastore_index.CompositeIndexForQuery(pb)[1:-1])
 raise datastore_errors.NeedIndexError(
 str(exc) + '\nThis query needs this index:\n' + yaml)
-return Iterator(result)
+return Iterator(result, batch_size=next_count)
 def Get(self, limit, offset=0):
 """Fetches and returns a maximum number of results from the query.
 This method fetches and returns a list of resulting entities that matched
 if not isinstance(offset, (int, long)) or offset < 0:
 raise datastore_errors.BadArgumentError(
 'Argument to Get named \'offset\' must be an int greater than or '
 'equal to 0; received %s (a %s)' % (offset, typename(offset)))
-return self._Run(limit, offset)._Get(limit)
+return self._Run(limit=limit, offset=offset,
+prefetch_count=limit)._Get(limit)
 def Count(self, limit=None):
 """Returns the number of entities that this query matches. The returned
 count is cached; successive Count() calls will not re-scan the datastore
 unless the query is changed.
 raise datastore_errors.BadFilterError(
 'Inequality operators (%s) must be on the same property as the '
 'first sort order, if any sort orders are supplied' %
 ', '.join(self.INEQUALITY_OPERATORS))
+if (self.__kind is None and
+property != datastore_types._KEY_SPECIAL_PROPERTY):
+raise datastore_errors.BadFilterError(
+'Only %s filters are allowed on kindless queries.' %
+datastore_types._KEY_SPECIAL_PROPERTY)
 if property in datastore_types._SPECIAL_PROPERTIES:
 if property == datastore_types._KEY_SPECIAL_PROPERTY:
 for value in values:
 if not isinstance(value, Key):
 raise datastore_errors.BadFilterError(
 '%s filter value must be a Key; received %s (a %s)' %
 (datastore_types._KEY_SPECIAL_PROPERTY, value, typename(value)))
 return match
-def _ToPb(self, limit=None, offset=None):
+def _ToPb(self, limit=None, offset=None, count=None):
 """Converts this Query to its protocol buffer representation. Not
 intended to be used by application developers. Enforced by hiding the
 datastore_pb classes.
 Args:
 # an upper bound on the number of results returned by the query.
 limit: int
 # number of results that match the query to skip.  limit is applied
 # after the offset is fulfilled
 offset: int
+# the requested initial batch size
+count: int
 Returns:
 # the PB representation of this Query
 datastore_pb.Query
 Raises:
 BadRequestError if called inside a transaction and the query does not
 include an ancestor.
 """
 if not self.__ancestor and _CurrentTransactionKey():
 raise datastore_errors.BadRequestError(
 'Only ancestor queries are allowed inside transactions.')
 pb = datastore_pb.Query()
 _MaybeSetupTransaction(pb, [self.__ancestor])
-pb.set_kind(self.__kind.encode('utf-8'))
+if self.__kind is not None:
+pb.set_kind(self.__kind.encode('utf-8'))
 pb.set_keys_only(bool(self.__keys_only))
 if self.__app:
 pb.set_app(self.__app.encode('utf-8'))
 if limit is not None:
 pb.set_limit(limit)
 if offset is not None:
 pb.set_offset(offset)
+if count is not None:
+pb.set_count(count)
 if self.__ancestor:
 pb.mutable_ancestor().CopyFrom(self.__ancestor._Key__reference)
 if ((self.__hint == self.ORDER_FIRST and self.__orderings) or
 (self.__hint == self.ANCESTOR_FIRST and self.__ancestor) or
 order = pb.add_order()
 order.set_property(property.encode('utf-8'))
 order.set_direction(direction)
 return pb
+def AllocateIds(model_key, size):
+"""Allocates a range of IDs of size for the key defined by model_key
+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_key: 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.
+"""
+keys, multiple = NormalizeAndTypeCheckKeys(model_key)
+if len(keys) > 1:
+raise datastore_errors.BadArgumentError(
+'Cannot allocate IDs for more than one model key at a time')
+if size > _MAX_ID_BATCH_SIZE:
+raise datastore_errors.BadArgumentError(
+'Cannot allocate more than %s ids at a time' % _MAX_ID_BATCH_SIZE)
+req = datastore_pb.AllocateIdsRequest()
+req.mutable_model_key().CopyFrom(keys[0]._Key__reference)
+req.set_size(size)
+resp = datastore_pb.AllocateIdsResponse()
+try:
+apiproxy_stub_map.MakeSyncCall('datastore_v3', 'AllocateIds', req, resp)
+except apiproxy_errors.ApplicationError, err:
+raise _ToDatastoreError(err)
+return resp.start(), resp.end()
 class MultiQuery(Query):
 """Class representing a query which requires multiple datastore queries.
 > it = Query('Person').Run()
 > for person in it:
 >   print 'Hi, %s!' % person['name']
 """
-def __init__(self, query_result_pb):
+def __init__(self, query_result_pb, batch_size=None):
 self.__cursor = query_result_pb.cursor()
 self.__keys_only = query_result_pb.keys_only()
+self.__batch_size = batch_size
 self.__buffer = self._ProcessQueryResult(query_result_pb)
 def _Get(self, count):
 """Gets the next count result(s) of the query.
 Returns:
 # a list of entities or keys
 [Entity or Key, ...]
 """
-entityList = self._Next(count)
+entity_list = self._Next(count)
-while len(entityList) < count and self.__more_results:
+while len(entity_list) < count and self.__more_results:
-next_results = self._Next(count - len(entityList))
+next_results = self._Next(count - len(entity_list), self.__batch_size)
 if not next_results:
 break
-entityList += next_results
+entity_list += next_results
-return entityList;
+return entity_list;
-def _Next(self, count):
+def _Next(self, count=None):
-"""Returns the next result(s) of the query.
+"""Returns the next batch of results.
 Not intended to be used by application developers. Use the python
 iterator protocol instead.
 This method returns the next entities or keys from the list of matching
 results. If the query specified a sort order, results are returned in that
 order. Otherwise, the order is undefined.
-The argument, count, specifies the number of results to return. However, the
+The optional argument, count, specifies the number of results to return.
-length of the returned list may be smaller than count. This is the case if
+However, the length of the returned list may be smaller than count. This is
-count is greater than the number of remaining results or the size of the
+the case if count is greater than the number of remaining results or the
-remaining results exciteds the RPC buffer limit. Use _Get to insure all
+size of the remaining results exceeds the RPC buffer limit. Use _Get to
-possible entities are retrieved.
+insure all possible entities are retrieved.
+If the count is omitted, the datastore backend decides how many entities to
+send.
 There is an internal buffer for use with the next() method. If this buffer
 is not empty, up to 'count' values are removed from this buffer and
 returned. It's best not to mix _Next() and next().
 The results are always returned as a list. If there are no results left,
 an empty list is returned.
 Args:
 # the number of results to return; must be >= 1
-count: int or long
+count: int or long or None
 Returns:
 # a list of entities or keys
 [Entity or Key, ...]
 """
-if not isinstance(count, (int, long)) or count <= 0:
+if count is not None and (not isinstance(count, (int, long)) or count <= 0):
 raise datastore_errors.BadArgumentError(
 'Argument to _Next must be an int greater than 0; received %s (a %s)' %
 (count, typename(count)))
 if self.__buffer:
-if count <= len(self.__buffer):
+if count is None:
+entity_list = self.__buffer
+self.__buffer = []
+return entity_list
+elif count <= len(self.__buffer):
 entity_list = self.__buffer[:count]
 del self.__buffer[:count]
 return entity_list
 else:
 entity_list = self.__buffer
 self.__buffer = []
 count -= len(entity_list)
 else:
-entity_list=[]
+entity_list = []
 if not self.__more_results:
 return entity_list
 req = datastore_pb.NextRequest()
-req.set_count(count)
+if count is not None:
+req.set_count(count)
 req.mutable_cursor().CopyFrom(self.__cursor)
 result = datastore_pb.QueryResult()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Next', req, result)
 except apiproxy_errors.ApplicationError, err:
 if self.__keys_only:
 return [Key._FromPb(e.key()) for e in result.result_list()]
 else:
 return [Entity._FromPb(e) for e in result.result_list()]
-_BUFFER_SIZE = 20
 def next(self):
 if not self.__buffer:
-self.__buffer = self._Next(self._BUFFER_SIZE)
+self.__buffer = self._Next(self.__batch_size)
 try:
 return self.__buffer.pop(0)
 except IndexError:
 raise StopIteration
 def __iter__(self): return self
 class _Transaction(object):
 """Encapsulates a transaction currently in progress.
-If we've sent a BeginTransaction call, then handle will be a
-datastore_pb.Transaction that holds the transaction handle.
 If we know the entity group for this transaction, it's stored in the
-entity_group attribute, which is set by RecordModifiedKeys().
+entity_group attribute, which is set by RunInTransaction().
 modified_keys is a set containing the Keys of all entities modified (ie put
 or deleted) in this transaction. If an entity is modified more than once, a
 BadRequestError is raised.
 """
-def __init__(self):
+def __init__(self, handle):
-"""Initializes modified_keys to the empty set."""
+"""Initializes the transaction.
-self.handle = None
+Args:
+handle: a datastore_pb.Transaction returned by a BeginTransaction call
+"""
+assert isinstance(handle, datastore_pb.Transaction)
+explanation = []
+assert handle.IsInitialized(explanation), explanation
+self.handle = handle
 self.entity_group = None
 self.modified_keys = None
 self.modified_keys = set()
-def RecordModifiedKeys(self, keys, error_on_repeat=True):
-"""Updates the modified keys seen so far.
-If error_on_repeat is True and any of the given keys have already been
-modified, raises BadRequestError.
-Args:
-keys: sequence of Keys
-"""
-keys, _ = NormalizeAndTypeCheckKeys(keys)
-keys = set(keys)
-if error_on_repeat:
-already_modified = self.modified_keys.intersection(keys)
-if already_modified:
-raise datastore_errors.BadRequestError(
-"Can't update entity more than once in a transaction: %r" %
-already_modified.pop())
-self.modified_keys.update(keys)
 def RunInTransaction(function, *args, **kwargs):
 """Runs a function inside a datastore transaction.
 tx_key = None
 try:
 tx_key = _NewTransactionKey()
-tx = _Transaction()
-_txes[tx_key] = tx
 for i in range(0, retries + 1):
-tx.modified_keys.clear()
+handle = datastore_pb.Transaction()
+try:
+apiproxy_stub_map.MakeSyncCall('datastore_v3', 'BeginTransaction',
+api_base_pb.VoidProto(), handle)
+except apiproxy_errors.ApplicationError, err:
+raise _ToDatastoreError(err)
+tx = _Transaction(handle)
+_txes[tx_key] = tx
 try:
 result = function(*args, **kwargs)
 except:
 original_exception = sys.exc_info()
-if tx.handle:
+try:
-try:
+resp = api_base_pb.VoidProto()
-resp = api_base_pb.VoidProto()
+apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Rollback',
-apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Rollback',
+tx.handle, resp)
-tx.handle, resp)
+except:
-except:
+exc_info = sys.exc_info()
-exc_info = sys.exc_info()
+logging.info('Exception sending Rollback:\n' +
-logging.info('Exception sending Rollback:\n' +
+''.join(traceback.format_exception(*exc_info)))
-''.join(traceback.format_exception(*exc_info)))
 type, value, trace = original_exception
 if type is datastore_errors.Rollback:
 return
 else:
 raise type, value, trace
-if tx.handle:
+try:
-try:
+resp = datastore_pb.CommitResponse()
-resp = datastore_pb.CommitResponse()
+apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Commit',
-apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Commit',
+tx.handle, resp)
-tx.handle, resp)
+except apiproxy_errors.ApplicationError, err:
-except apiproxy_errors.ApplicationError, err:
+if (err.application_error ==
-if (err.application_error ==
+datastore_pb.Error.CONCURRENT_TRANSACTION):
-datastore_pb.Error.CONCURRENT_TRANSACTION):
+logging.warning('Transaction collision for entity group with '
-logging.warning('Transaction collision for entity group with '
+'key %r. Retrying...', tx.entity_group)
-'key %r. Retrying...', tx.entity_group)
+tx.handle = None
-tx.handle = None
+tx.entity_group = None
-tx.entity_group = None
+continue
-continue
+else:
-else:
+raise _ToDatastoreError(err)
-raise _ToDatastoreError(err)
 return result
 raise datastore_errors.TransactionFailedError(
 'The transaction could not be committed. Please try again.')
 del _txes[tx_key]
 del tx_key
 def _MaybeSetupTransaction(request, keys):
-"""Begins a transaction, if necessary, and populates it in the request.
+"""If we're in a transaction, validates and populates it in the request.
 If we're currently inside a transaction, this records the entity group,
-checks that the keys are all in that entity group, creates the transaction
+checks that the keys are all in that entity group, and populates the
-PB, and sends the BeginTransaction. It then populates the transaction handle
+transaction handle in the request.
-in the request.
 Raises BadRequestError if the entity has a different entity group than the
 current transaction.
 Args:
 Returns:
 _Transaction if we're inside a transaction, otherwise None
 """
 assert isinstance(request, (datastore_pb.GetRequest, datastore_pb.PutRequest,
-datastore_pb.DeleteRequest, datastore_pb.Query))
+datastore_pb.DeleteRequest, datastore_pb.Query,
+taskqueue_service_pb.TaskQueueAddRequest,
+)), request.__class__
 tx_key = None
 try:
 tx_key = _CurrentTransactionKey()
 if tx_key:
 tx = _txes[tx_key]
 groups = [k.entity_group() for k in keys]
 if tx.entity_group:
 expected_group = tx.entity_group
+elif groups:
+expected_group = groups[0]
 else:
-expected_group = groups[0]
+expected_group = None
 for group in groups:
 if (group != expected_group or
 raise _DifferentEntityGroupError(expected_group, group)
 if not tx.entity_group and group.has_id_or_name():
 tx.entity_group = group
-if not tx.handle:
+assert tx.handle.IsInitialized()
-tx.handle = datastore_pb.Transaction()
-req = api_base_pb.VoidProto()
-apiproxy_stub_map.MakeSyncCall('datastore_v3', 'BeginTransaction', req,
-tx.handle)
 request.mutable_transaction().CopyFrom(tx.handle)
 return tx
 finally:

changeset 2864	2e0b0af889be
parent 2413	d0b7dac5325c
child 3031	7678f72140e6