py_tasks_melange: comparison thirdparty/google_appengine/google/appengine/api/memcache/__init_

equal deleted inserted replaced

-:b02dd2a5f329
+:35211afcd563
 """
 request = MemcacheStatsRequest()
 response = MemcacheStatsResponse()
 try:
 self._make_sync_call('memcache', 'Stats', request, response)
-except apiproxy_errors.ApplicationError, e:
+except apiproxy_errors.Error:
 return None
 if not response.has_stats():
 return None
 """
 request = MemcacheFlushRequest()
 response = MemcacheFlushResponse()
 try:
 self._make_sync_call('memcache', 'FlushAll', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return False
 return True
 def get(self, key):
 """Looks up a single key in memcache.
 request = MemcacheGetRequest()
 request.add_key(_key_string(key))
 response = MemcacheGetResponse()
 try:
 self._make_sync_call('memcache', 'Get', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return None
 if not response.item_size():
 return None
 user_key = {}
 for key in keys:
 request.add_key(_key_string(key, key_prefix, user_key))
 try:
 self._make_sync_call('memcache', 'Get', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return {}
 return_value = {}
 for returned_item in response.item_list():
 value = _decode_value(returned_item.value(), returned_item.flags(),
 delete_item = request.add_item()
 delete_item.set_key(_key_string(key))
 delete_item.set_delete_time(int(math.ceil(seconds)))
 try:
 self._make_sync_call('memcache', 'Delete', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return DELETE_NETWORK_FAILURE
 assert response.delete_status_size() == 1, 'Unexpected status size.'
 if response.delete_status(0) == MemcacheDeleteResponse.DELETED:
 return DELETE_SUCCESSFUL
 delete_item = request.add_item()
 delete_item.set_key(_key_string(key, key_prefix=key_prefix))
 delete_item.set_delete_time(int(math.ceil(seconds)))
 try:
 self._make_sync_call('memcache', 'Delete', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return False
 return True
 def set(self, key, value, time=0, min_compress_len=0):
 """Sets a key's value, regardless of previous contents in cache.
 item.set_set_policy(policy)
 item.set_expiration_time(int(math.ceil(time)))
 response = MemcacheSetResponse()
 try:
 self._make_sync_call('memcache', 'Set', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return False
 if response.set_status_size() != 1:
 return False
 return response.set_status(0) == MemcacheSetResponse.STORED
+def _set_multi_with_policy(self, policy, mapping, time=0, key_prefix=''):
+"""Set multiple keys with a specified policy.
+Helper function for set_multi(), add_multi(), and replace_multi(). This
+reduces the network latency of doing many requests in serial.
+Args:
+policy:  One of MemcacheSetRequest.SET, ADD, or REPLACE.
+mapping: Dictionary of keys to values.
+time: Optional expiration time, either relative number of seconds
+from current time (up to 1 month), or an absolute Unix epoch time.
+By default, items never expire, though items may be evicted due to
+memory pressure.  Float values will be rounded up to the nearest
+whole second.
+key_prefix: Prefix for to prepend to all keys.
+Returns:
+A list of keys whose values were NOT set.  On total success,
+this list should be empty.  On network/RPC/server errors,
+a list of all input keys is returned; in this case the keys
+may or may not have been updated.
+"""
+if not isinstance(time, (int, long, float)):
+raise TypeError('Expiration must be a number.')
+if time < 0.0:
+raise ValueError('Expiration must not be negative.')
+request = MemcacheSetRequest()
+user_key = {}
+server_keys = []
+for key, value in mapping.iteritems():
+server_key = _key_string(key, key_prefix, user_key)
+stored_value, flags = _validate_encode_value(value, self._do_pickle)
+server_keys.append(server_key)
+item = request.add_item()
+item.set_key(server_key)
+item.set_value(stored_value)
+item.set_flags(flags)
+item.set_set_policy(policy)
+item.set_expiration_time(int(math.ceil(time)))
+response = MemcacheSetResponse()
+try:
+self._make_sync_call('memcache', 'Set', request, response)
+except apiproxy_errors.Error:
+return user_key.values()
+assert response.set_status_size() == len(server_keys)
+unset_list = []
+for server_key, set_status in zip(server_keys, response.set_status_list()):
+if set_status != MemcacheSetResponse.STORED:
+unset_list.append(user_key[server_key])
+return unset_list
 def set_multi(self, mapping, time=0, key_prefix='', min_compress_len=0):
-"""Set multiple keys' values at once.
+"""Set multiple keys' values at once, regardless of previous contents.
-This reduces the network latency of doing many requests in serial.
 Args:
 mapping: Dictionary of keys to values.
 time: Optional expiration time, either relative number of seconds
 from current time (up to 1 month), or an absolute Unix epoch time.
 Returns:
 A list of keys whose values were NOT set.  On total success,
 this list should be empty.
 """
-if not isinstance(time, (int, long, float)):
+return self._set_multi_with_policy(MemcacheSetRequest.SET, mapping,
-raise TypeError('Expiration must be a number.')
+time=time, key_prefix=key_prefix)
-if time < 0.0:
-raise ValueError('Expiration must not be negative.')
+def add_multi(self, mapping, time=0, key_prefix='', min_compress_len=0):
+"""Set multiple keys' values iff items are not already in memcache.
-request = MemcacheSetRequest()
-user_key = {}
+Args:
-server_keys = []
+mapping: Dictionary of keys to values.
-for key, value in mapping.iteritems():
+time: Optional expiration time, either relative number of seconds
-server_key = _key_string(key, key_prefix, user_key)
+from current time (up to 1 month), or an absolute Unix epoch time.
-stored_value, flags = _validate_encode_value(value, self._do_pickle)
+By default, items never expire, though items may be evicted due to
-server_keys.append(server_key)
+memory pressure.  Float values will be rounded up to the nearest
+whole second.
-item = request.add_item()
+key_prefix: Prefix for to prepend to all keys.
-item.set_key(server_key)
+min_compress_len: Unimplemented compatibility option.
-item.set_value(stored_value)
-item.set_flags(flags)
+Returns:
-item.set_set_policy(MemcacheSetRequest.SET)
+A list of keys whose values were NOT set because they did not already
-item.set_expiration_time(int(math.ceil(time)))
+exist in memcache.  On total success, this list should be empty.
+"""
-response = MemcacheSetResponse()
+return self._set_multi_with_policy(MemcacheSetRequest.ADD, mapping,
-try:
+time=time, key_prefix=key_prefix)
-self._make_sync_call('memcache', 'Set', request, response)
-except apiproxy_errors.ApplicationError:
+def replace_multi(self, mapping, time=0, key_prefix='', min_compress_len=0):
-return False
+"""Replace multiple keys' values, failing if the items aren't in memcache.
-assert response.set_status_size() == len(server_keys)
+Args:
+mapping: Dictionary of keys to values.
-unset_list = []
+time: Optional expiration time, either relative number of seconds
-for server_key, set_status in zip(server_keys, response.set_status_list()):
+from current time (up to 1 month), or an absolute Unix epoch time.
-if set_status != MemcacheSetResponse.STORED:
+By default, items never expire, though items may be evicted due to
-unset_list.append(user_key[server_key])
+memory pressure.  Float values will be rounded up to the nearest
+whole second.
-return unset_list
+key_prefix: Prefix for to prepend to all keys.
+min_compress_len: Unimplemented compatibility option.
+Returns:
+A list of keys whose values were NOT set because they already existed
+in memcache.  On total success, this list should be empty.
+"""
+return self._set_multi_with_policy(MemcacheSetRequest.REPLACE, mapping,
+time=time, key_prefix=key_prefix)
 def incr(self, key, delta=1):
 """Atomically increments a key's value.
 Internally, the value is a unsigned 64-bit integer.  Memcache
 key: Key to increment.  See Client's docstring for details.
 delta: Non-negative integer value (int or long) to increment key by,
 defaulting to 1.
 Returns:
-New long integer value, or None if key was not in the cache or could not
+New long integer value, or None if key was not in the cache, could not
-be incremented for any other reason.
+be incremented for any other reason, or a network/RPC/server error
+occurred.
 Raises:
 ValueError: If number is negative.
 TypeError: If delta isn't an int or long.
 """
 delta: Non-negative integer value (int or long) to decrement key by,
 defaulting to 1.
 Returns:
 New long integer value, or None if key wasn't in cache and couldn't
-be decremented.
+be decremented, or a network/RPC/server error occurred.
 Raises:
 ValueError: If number is negative.
 TypeError: If delta isn't an int or long.
 """
 is_negative: Boolean, if this is a decrement.
 delta: Non-negative integer amount (int or long) to increment
 or decrement by.
 Returns:
-New long integer value, or None on cache miss.
+New long integer value, or None on cache miss or network/RPC/server
+error.
 Raises:
 ValueError: If delta is negative.
 TypeError: If delta isn't an int or long.
 """
 else:
 request.set_direction(MemcacheIncrementRequest.INCREMENT)
 try:
 self._make_sync_call('memcache', 'Increment', request, response)
-except apiproxy_errors.ApplicationError:
+except apiproxy_errors.Error:
 return None
 if response.has_new_value():
 return response.new_value()
 return None
 var_dict['get'] = _CLIENT.get
 var_dict['get_multi'] = _CLIENT.get_multi
 var_dict['set'] = _CLIENT.set
 var_dict['set_multi'] = _CLIENT.set_multi
 var_dict['add'] = _CLIENT.add
+var_dict['add_multi'] = _CLIENT.add_multi
 var_dict['replace'] = _CLIENT.replace
+var_dict['replace_multi'] = _CLIENT.replace_multi
 var_dict['delete'] = _CLIENT.delete
 var_dict['delete_multi'] = _CLIENT.delete_multi
 var_dict['incr'] = _CLIENT.incr
 var_dict['decr'] = _CLIENT.decr
 var_dict['flush_all'] = _CLIENT.flush_all

changeset 297	35211afcd563
parent 149	f2e327a7c5de
child 2273	e4cb9c53db3e