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

equal deleted inserted replaced

-:26491ee91e33
+:e4cb9c53db3e
 import pickle
 import types
 from google.appengine.api import api_base_pb
 from google.appengine.api import apiproxy_stub_map
+from google.appengine.api import namespace_manager
 from google.appengine.api.memcache import memcache_service_pb
 from google.appengine.runtime import apiproxy_errors
 MemcacheSetResponse = memcache_service_pb.MemcacheSetResponse
 MemcacheSetRequest = memcache_service_pb.MemcacheSetRequest
 self._make_sync_call('memcache', 'FlushAll', request, response)
 except apiproxy_errors.Error:
 return False
 return True
-def get(self, key):
+def get(self, key, namespace=None):
 """Looks up a single key in memcache.
 If you have multiple items to load, though, it's much more efficient
 to use get_multi() instead, which loads them in one bulk operation,
 reducing the networking latency that'd otherwise be required to do
 many serialized get() operations.
 Args:
 key: The key in memcache to look up.  See docs on Client
 for details of format.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 The value of the key, if found in memcache, else None.
 """
 request = MemcacheGetRequest()
 request.add_key(_key_string(key))
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheGetResponse()
 try:
 self._make_sync_call('memcache', 'Get', request, response)
 except apiproxy_errors.Error:
 return None
 return _decode_value(response.item(0).value(),
 response.item(0).flags(),
 self._do_unpickle)
-def get_multi(self, keys, key_prefix=''):
+def get_multi(self, keys, key_prefix='', namespace=None):
 """Looks up multiple keys from memcache in one operation.
 This is the recommended way to do bulk loads.
 Args:
 does the sharding and hashing automatically, though, so the hash
 value is ignored.  To memcache, keys are just series of bytes,
 and not in any particular encoding.
 key_prefix: Prefix to prepend to all keys when talking to the server;
 not included in the returned dictionary.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 A dictionary of the keys and values that were present in memcache.
 Even if the key_prefix was specified, that key_prefix won't be on
 the keys in the returned dictionary.
 """
 request = MemcacheGetRequest()
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheGetResponse()
 user_key = {}
 for key in keys:
 request.add_key(_key_string(key, key_prefix, user_key))
 try:
 value = _decode_value(returned_item.value(), returned_item.flags(),
 self._do_unpickle)
 return_value[user_key[returned_item.key()]] = value
 return return_value
-def delete(self, key, seconds=0):
+def delete(self, key, seconds=0, namespace=None):
 """Deletes a key from memcache.
 Args:
 key: Key to delete.  See docs on Client for detils.
 seconds: Optional number of seconds to make deleted items 'locked'
 for 'add' operations. Value can be a delta from current time (up to
 1 month), or an absolute Unix epoch time.  Defaults to 0, which means
 items can be immediately added.  With or without this option,
 a 'set' operation will always work.  Float values will be rounded up to
 the nearest whole second.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 DELETE_NETWORK_FAILURE (0) on network failure,
 DELETE_ITEM_MISSING (1) if the server tried to delete the item but
 didn't have it, or
 raise TypeError('Delete timeout must be a number.')
 if seconds < 0:
 raise ValueError('Delete timeout must be non-negative.')
 request = MemcacheDeleteRequest()
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheDeleteResponse()
 delete_item = request.add_item()
 delete_item.set_key(_key_string(key))
 delete_item.set_delete_time(int(math.ceil(seconds)))
 return DELETE_SUCCESSFUL
 elif response.delete_status(0) == MemcacheDeleteResponse.NOT_FOUND:
 return DELETE_ITEM_MISSING
 assert False, 'Unexpected deletion status code.'
-def delete_multi(self, keys, seconds=0, key_prefix=''):
+def delete_multi(self, keys, seconds=0, key_prefix='', namespace=None):
 """Delete multiple keys at once.
 Args:
 keys: List of keys to delete.
 seconds: Optional number of seconds to make deleted items 'locked'
 items can be immediately added.  With or without this option,
 a 'set' operation will always work.  Float values will be rounded up to
 the nearest whole second.
 key_prefix: Prefix to put on all keys when sending specified
 keys to memcache.  See docs for get_multi() and set_multi().
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 True if all operations completed successfully.  False if one
 or more failed to complete.
 """
 raise TypeError('Delete timeout must be a number.')
 if seconds < 0:
 raise ValueError('Delete timeout must not be negative.')
 request = MemcacheDeleteRequest()
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheDeleteResponse()
 for key in keys:
 delete_item = request.add_item()
 delete_item.set_key(_key_string(key, key_prefix=key_prefix))
 self._make_sync_call('memcache', 'Delete', request, response)
 except apiproxy_errors.Error:
 return False
 return True
-def set(self, key, value, time=0, min_compress_len=0):
+def set(self, key, value, time=0, min_compress_len=0, namespace=None):
 """Sets a key's value, regardless of previous contents in cache.
 Unlike add() and replace(), this method always sets (or
 overwrites) the value in memcache, regardless of previous
 contents.
 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.
 min_compress_len: Ignored option for compatibility.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 True if set.  False on error.
 """
-return self._set_with_policy(MemcacheSetRequest.SET, key, value, time=time)
+return self._set_with_policy(MemcacheSetRequest.SET, key, value, time=time,
+namespace=namespace)
-def add(self, key, value, time=0, min_compress_len=0):
+def add(self, key, value, time=0, min_compress_len=0, namespace=None):
 """Sets a key's value, iff item is not already in memcache.
 Args:
 key: Key to set.  See docs on Client for details.
 value: Value to set.  Any type.  If complex, will be pickled.
 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.
 min_compress_len: Ignored option for compatibility.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 True if added.  False on error.
 """
-return self._set_with_policy(MemcacheSetRequest.ADD, key, value, time=time)
+return self._set_with_policy(MemcacheSetRequest.ADD, key, value, time=time,
+namespace=namespace)
-def replace(self, key, value, time=0, min_compress_len=0):
+def replace(self, key, value, time=0, min_compress_len=0, namespace=None):
 """Replaces a key's value, failing if item isn't already in memcache.
 Args:
 key: Key to set.  See docs on Client for details.
 value: Value to set.  Any type.  If complex, will be pickled.
 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.
 min_compress_len: Ignored option for compatibility.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 True if replaced.  False on RPC error or cache miss.
 """
 return self._set_with_policy(MemcacheSetRequest.REPLACE,
-key, value, time=time)
+key, value, time=time, namespace=namespace)
-def _set_with_policy(self, policy, key, value, time=0):
+def _set_with_policy(self, policy, key, value, time=0, namespace=None):
 """Sets a single key with a specified policy.
 Helper function for set(), add(), and replace().
 Args:
 policy:  One of MemcacheSetRequest.SET, .ADD, or .REPLACE.
 key: Key to add, set, or replace.  See docs on Client for details.
 value: Value to set.
 time: Expiration time, defaulting to 0 (never expiring).
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 True if stored, False on RPC error or policy error, e.g. a replace
 that failed due to the item not already existing, or an add
 failing due to the item not already existing.
 stored_value, flags = _validate_encode_value(value, self._do_pickle)
 item.set_value(stored_value)
 item.set_flags(flags)
 item.set_set_policy(policy)
 item.set_expiration_time(int(math.ceil(time)))
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheSetResponse()
 try:
 self._make_sync_call('memcache', 'Set', request, response)
 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=''):
+def _set_multi_with_policy(self, policy, mapping, time=0, key_prefix='',
+namespace=None):
 """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.
 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.
+namespace: a string specifying an optional namespace to use in
+the request.
 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
 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)))
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheSetResponse()
 try:
 self._make_sync_call('memcache', 'Set', request, response)
 except apiproxy_errors.Error:
 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):
+def set_multi(self, mapping, time=0, key_prefix='', min_compress_len=0,
+namespace=None):
 """Set multiple keys' values at once, regardless of previous contents.
 Args:
 mapping: Dictionary of keys to values.
 time: Optional expiration time, either relative number of seconds
 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.
 min_compress_len: Unimplemented compatibility option.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 A list of keys whose values were NOT set.  On total success,
 this list should be empty.
 """
 return self._set_multi_with_policy(MemcacheSetRequest.SET, mapping,
-time=time, key_prefix=key_prefix)
+time=time, key_prefix=key_prefix,
+namespace=namespace)
-def add_multi(self, mapping, time=0, key_prefix='', min_compress_len=0):
+def add_multi(self, mapping, time=0, key_prefix='', min_compress_len=0,
+namespace=None):
 """Set multiple keys' values iff items are not already in memcache.
 Args:
 mapping: Dictionary of keys to values.
 time: Optional expiration time, either relative number of seconds
 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.
 min_compress_len: Unimplemented compatibility option.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 A list of keys whose values were NOT set because they did not already
 exist in memcache.  On total success, this list should be empty.
 """
 return self._set_multi_with_policy(MemcacheSetRequest.ADD, mapping,
-time=time, key_prefix=key_prefix)
+time=time, key_prefix=key_prefix,
+namespace=namespace)
-def replace_multi(self, mapping, time=0, key_prefix='', min_compress_len=0):
+def replace_multi(self, mapping, time=0, key_prefix='', min_compress_len=0,
+namespace=None):
 """Replace multiple keys' values, failing if the items aren't in memcache.
 Args:
 mapping: Dictionary of keys to values.
 time: Optional expiration time, either relative number of seconds
 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.
 min_compress_len: Unimplemented compatibility option.
+namespace: a string specifying an optional namespace to use in
+the request.
 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)
+time=time, key_prefix=key_prefix,
+namespace=namespace)
-def incr(self, key, delta=1):
+def incr(self, key, delta=1, namespace=None):
 """Atomically increments a key's value.
 Internally, the value is a unsigned 64-bit integer.  Memcache
 doesn't check 64-bit overflows.  The value, if too large, will
 wrap around.
 Args:
 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.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 New long integer value, or None if key was not in the cache, could not
 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.
 """
-return self._incrdecr(key, False, delta)
+return self._incrdecr(key, False, delta, namespace=namespace)
-def decr(self, key, delta=1):
+def decr(self, key, delta=1, namespace=None):
 """Atomically decrements a key's value.
 Internally, the value is a unsigned 64-bit integer.  Memcache
 caps decrementing below zero to zero.
 Args:
 key: Key to decrement.  See Client's docstring for details.
 delta: Non-negative integer value (int or long) to decrement key by,
 defaulting to 1.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 New long integer value, or None if key wasn't in cache and couldn't
 be decremented, or a network/RPC/server error occurred.
 Raises:
 ValueError: If number is negative.
 TypeError: If delta isn't an int or long.
 """
-return self._incrdecr(key, True, delta)
+return self._incrdecr(key, True, delta, namespace=namespace)
-def _incrdecr(self, key, is_negative, delta):
+def _incrdecr(self, key, is_negative, delta, namespace=None):
 """Increment or decrement a key by a provided delta.
 Args:
 key: Key to increment or decrement.
 is_negative: Boolean, if this is a decrement.
 delta: Non-negative integer amount (int or long) to increment
 or decrement by.
+namespace: a string specifying an optional namespace to use in
+the request.
 Returns:
 New long integer value, or None on cache miss or network/RPC/server
 error.
 raise TypeError('Delta must be an integer or long, received %r' % delta)
 if delta < 0:
 raise ValueError('Delta must not be negative.')
 request = MemcacheIncrementRequest()
+namespace_manager._add_name_space(request, namespace)
 response = MemcacheIncrementResponse()
 request.set_key(_key_string(key))
 request.set_delta(delta)
 if is_negative:
 request.set_direction(MemcacheIncrementRequest.DECREMENT)

changeset 2273	e4cb9c53db3e
parent 297	35211afcd563
child 2413	d0b7dac5325c