Chapter 18
Python Client API

HyperDex provides Python bindings to the client in the module hyperdex.client. This library wraps the HyperDex C client library and enables the use of native Python data types.

18.0.10 Building the HyperDex Python Binding

The HyperDex Python bindings must be requested at configure time as it is not automatically built. You can ensure that the Python bindings are always built by providing the –enable-python-bindings option to ./configure like so:

    % ./configure --enable-client --enable-python-bindings

18.0.11 Using Python Within Your Application

All client operation are defined in the hyperdex.client module. You can access this in your program with:

    import  hyperdex.client

18.0.12 Hello World

The following is a minimal application that stores the value ”Hello World” and then immediately retrieves the value:

    import  hyperdex.client
    
   c  = hyperdex.client.Client("127.0.0.1",  1982)
   c.put("kv",  "some key", {"v":  "Hello World!"})
    print  ’put "Hello World!"’
    print  ’got:’, c.get("kv",  "some key")

You can run this example with:

    % python hello-world.py
    put "Hello World!"
    got:
    {’v’: ’Hello World!’}

Right away, there are several points worth noting in this example:

• Every operation is synchronous. The put and get operations run to completion by default.
• Python types are automatically converted to HyperDex types. There’s no need to specify information such as the length of each string, as one would do with the C API.

18.0.13 Asynchronous Operations

For convenience, the Python bindings treat every operation as synchronous. This enables you to write short scripts without concern for asynchronous operations. Most operations come with an asynchronous form, denoted by the async_ prefix. For example, the above Hello World example could be rewritten in asynchronous fashion as such:

    import  hyperdex.client
    
   c  = hyperdex.client.Client("127.0.0.1",  1982)
   p  = c.async_put("kv",  "some key", {"v":  "Hello World!"})
   p.wait()
    print  ’put "Hello World!"’
   g  = c.async_get("kv",  "some key")
    print  ’got:’, g.wait()

This enables applications to issue multiple requests simultaneously and wait for their completion in an application-specific order. It’s also possible to use the loop method on the client object to wait for the next request to complete:

    import  hyperdex.client
    
   c  = hyperdex.client.Client("127.0.0.1",  1982)
   p  = c.async_put("kv",  "some key", {"v":  "Hello World!"})
   p1  = c.loop()
    print  ’put objects are the same:’, p  is p1
   p.wait()
    print  ’put "Hello World!"’
   g  = c.async_get("kv",  "some key")
   g1  = c.loop()
    print  ’get objects are the same:’, g  is g1
    print  ’got:’, g.wait()

18.0.14 Data Structures

The Python bindings automatically manage conversion of data types from Python to HyperDex types, enabling applications to be written in idiomatic Python.

18.0.14.1 Examples

This section shows examples of Python data structures that are recognized by HyperDex. The examples here are for illustration purposes and are not exhaustive. Strings The HyperDex client recognizes Python’s strings and automatically converts them to HyperDex strings. For example:

   c.put("kv",  "somekey", {"v":  "somevalue"})

Integers The HyperDex client recognizes Pythons’s integers and longs and automatically converts them to HyperDex integers. For example:

   c.put("k"’, "somekey", {"v": 42})

Floats The HyperDex client recognizes Pythons’s floating point numbers and automatically converts them to HyperDex floats. For example:

   c.put("kv",  "somekey", {"v":  3.1415})

Lists The HyperDex client recognizes Python lists and automatically converts them to HyperDex lists. For example:

   c.put("kv",  "somekey", {"v1": ["a",  "b",  "c"]})
   c.put("kv",  "somekey", {"v2": [1,  2,  3]})
   c.put("kv",  "somekey", {"v3": [1.0,  0.5,  0.25]})

Sets The HyperDex client recognizes Python sets and automaticaly converts them to HyperDex sets. For example:

   require  ’set’
   c.put("kv",  "somekey", {"v1":  set(["a",  "b",  "c"])})
   c.put("kv",  "somekey", {"v2":  set([1,  2,  3])})
   c.put("kv",  "somekey", {"v3":  set([1.0,  0.5,  0.25])})

Maps The HyperDex client recognizes Python dictionaries and automatically converts them to HyperDex maps. For example:

   c.put("kv",  "somekey", {"v1": {"k":  "v"}})
   c.put("kv",  "somekey", {"v2": {1:  2}})
   c.put("kv",  "somekey", {"v3": {3.14:  0.125}})
   c.put("kv",  "somekey", {"v3": {"a":  1}})

18.0.15 Attributes

Attributes in Python are specified in the form of a dictinary from attribute names to their values. As you can see in the examples above, attributes are specified in the form:

   {"name":  "value"}

18.0.16 Map Attributes

Map attributes in Python are specified in the form of a nested dictionary. The outer diction key specifies the name, while the inner diction key-value pair specifies the key-value pair of the map. For example:

   {"name": {"key":  "value"}}

18.0.17 Predicates

Predicates in Python are specified in the form of a diction from attribute names to their predicates. In the simple case, the predicate is just a value to be compared against:

   {"v":  "value"}

This is the same as saying:

   {"v": hyperdex.client.Equals(’value’)}

The Python bindings support the full range of predicates supported by HyperDex itself. For example:

   {"v": hyperdex.client.LessEqual(5)}
   {"v": hyperdex.client.GreaterEqual(5)}
   {"v": hyperdex.client.Range(5,  10)}
   {"v": hyperdex.client.Regex(’^s.*’)}
   {"v": hyperdex.client.LengthEquals(5)}
   {"v": hyperdex.client.LengthLessEqual(5)}
   {"v": hyperdex.client.LengthGreaterEqual(5)}
   {"v": hyperdex.client.Contains(’value’)}

18.0.18 Error Handling

All error handling within the Python bindings is done via the exception handling mechanism of Python. Errors will be raised by the library and should be handled by your application. For example, if we were trying to store an integer (5) as attribute “v”, where “v” is actually a string, we’d generate an error.

    try:
           c.put("kv",  "my_key", {"v":  5})
    except HyperDexClientException  as e:
            print e.status
            print e.symbol
            print e

Errors of type HyperDexClientException will contain both a message indicating what went wrong, as well as the underlying enum hyperdex_client_returncode. The member status indicates the numeric value of this enum, while symbol returns the enum as a string. The above code will fail with the following output:

18.0.19 Operations

18.0.19.1 get

Retrieve an object from space using key. Definition:

    def  get(self, spacename, key)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.

Returns: Object if found, None if not found. Raises exception on error.

18.0.19.2 async_get

Retrieve an object from space using key. Definition:

    def  async_get(self, spacename, key)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.

Returns: A Deferred object with a wait method that returns the object if found, None if not found. Raises exception on error. See also: This is the asynchronous form of get.

18.0.19.3 get_partial

Retrieve part of an object from space using key. Only the specified attributes of the object will be returned to the client. Definition:

    def  get_partial(self, spacename, key, attributenames)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributenames
  A list of attributes to return.

Returns: Object if found, None if not found. Raises exception on error.

18.0.19.4 async_get_partial

Retrieve part of an object from space using key. Only the specified attributes of the object will be returned to the client. Definition:

    def  async_get_partial(self, spacename, key, attributenames)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributenames
  A list of attributes to return.

Returns: A Deferred object with a wait method that returns the object if found, None if not found. Raises exception on error. See also: This is the asynchronous form of get_partial.

18.0.19.5 put

Store or update an object by key. The object’s attributes will be set to the values specified by attrs. If the object exists, it will be updated and all existing values not altered by attrs will be preserved. If the object does not exist, a new object will be created, with its attributes initialized to their default values. Definition:

    def  put(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.6 async_put

Store or update an object by key. The object’s attributes will be set to the values specified by attrs. If the object exists, it will be updated and all existing values not altered by attrs will be preserved. If the object does not exist, a new object will be created, with its attributes initialized to their default values. Definition:

    def  async_put(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of put.

18.0.19.7 cond_put

Conditionally update an the object stored under key in space. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_put(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.8 async_cond_put

Conditionally update an the object stored under key in space. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_put(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_put.

18.0.19.9 group_put

Update all objects stored in space that match checks. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_put(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.10 async_group_put

Update all objects stored in space that match checks. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_put(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_put.

18.0.19.11 put_if_not_exist

Store or object under key in space if and only if the operation creates a new object. The object’s attributes will be set to the values specified by attrs; any attributes not specified by attrs will be initialized to their defaults. If the object exists, the operation will fail with CMPFAIL. Definition:

    def  put_if_not_exist(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.12 async_put_if_not_exist

Store or object under key in space if and only if the operation creates a new object. The object’s attributes will be set to the values specified by attrs; any attributes not specified by attrs will be initialized to their defaults. If the object exists, the operation will fail with CMPFAIL. Definition:

    def  async_put_if_not_exist(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of put_if_not_exist.

18.0.19.13 del

Delete key from space. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  delete(self, spacename, key)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.14 async_del

Delete key from space. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_delete(self, spacename, key)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of del.

18.0.19.15 cond_del

Conditionally delete the object stored under key from space. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_del(self, spacename, key, predicates)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.16 async_cond_del

Conditionally delete the object stored under key from space. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_del(self, spacename, key, predicates)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_del.

18.0.19.17 group_del

Delete all objects that match the specified checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_del(self, spacename, predicates)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.

Returns: Number of objects found. Raises exception on error.

18.0.19.18 async_group_del

Delete all objects that match the specified checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_del(self, spacename, predicates)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_del.

18.0.19.19 atomic_add

Add the specified number to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_add(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.20 async_atomic_add

Add the specified number to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_add(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_add.

18.0.19.21 cond_atomic_add

Add the specified number to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_add(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.22 async_cond_atomic_add

Add the specified number to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_add(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_add.

18.0.19.23 group_atomic_add

Add the specified number to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_add(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.24 async_group_atomic_add

Add the specified number to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_add(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_add.

18.0.19.25 atomic_sub

Subtract the specified number from the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_sub(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.26 async_atomic_sub

Subtract the specified number from the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_sub(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_sub.

18.0.19.27 cond_atomic_sub

Subtract the specified number from the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_sub(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.28 async_cond_atomic_sub

Subtract the specified number from the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_sub(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_sub.

18.0.19.29 group_atomic_sub

Subtract the specified number from the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_sub(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.30 async_group_atomic_sub

Subtract the specified number from the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_sub(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_sub.

18.0.19.31 atomic_mul

Multiply the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_mul(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.32 async_atomic_mul

Multiply the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_mul(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_mul.

18.0.19.33 cond_atomic_mul

Multiply the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_mul(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.34 async_cond_atomic_mul

Multiply the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_mul(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_mul.

18.0.19.35 group_atomic_mul

Multiply the existing value by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_mul(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.36 async_group_atomic_mul

Multiply the existing value by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_mul(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_mul.

18.0.19.37 atomic_div

Divide the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_div(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.38 async_atomic_div

Divide the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_div(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_div.

18.0.19.39 cond_atomic_div

Divide the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_div(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.40 async_cond_atomic_div

Divide the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_div(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_div.

18.0.19.41 group_atomic_div

Divide the existing value by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_div(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.42 async_group_atomic_div

Divide the existing value by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_div(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_div.

18.0.19.43 atomic_mod

Store the existing value modulo the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_mod(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.44 async_atomic_mod

Store the existing value modulo the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_mod(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_mod.

18.0.19.45 cond_atomic_mod

Store the existing value modulo the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_mod(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.46 async_cond_atomic_mod

Store the existing value modulo the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_mod(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_mod.

18.0.19.47 group_atomic_mod

Store the existing value modulo the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_mod(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.48 async_group_atomic_mod

Store the existing value modulo the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_mod(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_mod.

18.0.19.49 atomic_and

Store the bitwise AND of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_and(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.50 async_atomic_and

Store the bitwise AND of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_and(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_and.

18.0.19.51 cond_atomic_and

Store the bitwise AND of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_and(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.52 async_cond_atomic_and

Store the bitwise AND of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_and(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_and.

18.0.19.53 group_atomic_and

Store the bitwise AND of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_and(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.54 async_group_atomic_and

Store the bitwise AND of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_and(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_and.

18.0.19.55 atomic_or

Store the bitwise OR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_or(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.56 async_atomic_or

Store the bitwise OR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_or(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_or.

18.0.19.57 cond_atomic_or

Store the bitwise OR of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_or(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.58 async_cond_atomic_or

Store the bitwise OR of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_or(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_or.

18.0.19.59 group_atomic_or

Store the bitwise OR of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_or(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.60 async_group_atomic_or

Store the bitwise OR of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_or(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_or.

18.0.19.61 atomic_xor

Store the bitwise XOR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_xor(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.62 async_atomic_xor

Store the bitwise XOR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_xor(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_xor.

18.0.19.63 cond_atomic_xor

Store the bitwise XOR of the existing value and the specified number for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_xor(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.64 async_cond_atomic_xor

Store the bitwise XOR of the existing value and the specified number for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_xor(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_xor.

18.0.19.65 group_atomic_xor

Store the bitwise XOR of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_xor(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.66 async_group_atomic_xor

Store the bitwise XOR of the existing value and the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_xor(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_xor.

18.0.19.67 atomic_min

Store the minimum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_min(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.68 async_atomic_min

Store the minimum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_min(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_min.

18.0.19.69 cond_atomic_min

Store the minimum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_min(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.70 async_cond_atomic_min

Store the minimum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_min(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_min.

18.0.19.71 group_atomic_min

Store the minimum of the existing value and the provided value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_min(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.72 async_group_atomic_min

Store the minimum of the existing value and the provided value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_min(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_min.

18.0.19.73 atomic_max

Store the maximum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  atomic_max(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.74 async_atomic_max

Store the maximum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_atomic_max(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of atomic_max.

18.0.19.75 cond_atomic_max

Store the maximum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_atomic_max(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.76 async_cond_atomic_max

Store the maximum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_atomic_max(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_atomic_max.

18.0.19.77 group_atomic_max

Store the maximum of the existing value and the provided value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_atomic_max(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.78 async_group_atomic_max

Store the maximum of the existing value and the provided value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_atomic_max(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_atomic_max.

18.0.19.79 string_prepend

Prepend the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  string_prepend(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.80 async_string_prepend

Prepend the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_string_prepend(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of string_prepend.

18.0.19.81 cond_string_prepend

Prepend the specified string to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_string_prepend(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.82 async_cond_string_prepend

Prepend the specified string to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_string_prepend(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_string_prepend.

18.0.19.83 group_string_prepend

Prepend the specified string to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_string_prepend(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.84 async_group_string_prepend

Prepend the specified string to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_string_prepend(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_string_prepend.

18.0.19.85 string_append

Append the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  string_append(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.86 async_string_append

Append the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_string_append(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of string_append.

18.0.19.87 cond_string_append

Append the specified string to the existing value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_string_append(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.88 async_cond_string_append

Append the specified string to the existing value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_string_append(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_string_append.

18.0.19.89 group_string_append

Append the specified string to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_string_append(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.90 async_group_string_append

Append the specified string to the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_string_append(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_string_append.

18.0.19.91 list_lpush

Push the specified value onto the front of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  list_lpush(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.92 async_list_lpush

Push the specified value onto the front of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_list_lpush(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of list_lpush.

18.0.19.93 cond_list_lpush

Push the specified value onto the front of the list for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_list_lpush(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.94 async_cond_list_lpush

Push the specified value onto the front of the list for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_list_lpush(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_list_lpush.

18.0.19.95 group_list_lpush

Push the specified value onto the front of the list for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_list_lpush(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.96 async_group_list_lpush

Push the specified value onto the front of the list for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_list_lpush(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_list_lpush.

18.0.19.97 list_rpush

Push the specified value onto the back of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  list_rpush(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.98 async_list_rpush

Push the specified value onto the back of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_list_rpush(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of list_rpush.

18.0.19.99 cond_list_rpush

Push the specified value onto the back of the list for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_list_rpush(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.100 async_cond_list_rpush

Push the specified value onto the back of the list for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_list_rpush(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_list_rpush.

18.0.19.101 group_list_rpush

Push the specified value onto the back of the list for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_list_rpush(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.102 async_group_list_rpush

Push the specified value onto the back of the list for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_list_rpush(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_list_rpush.

18.0.19.103 set_add

Add the specified value to the set for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  set_add(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.104 async_set_add

Add the specified value to the set for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_set_add(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_add.

18.0.19.105 cond_set_add

Add the specified value to the set for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_set_add(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.106 async_cond_set_add

Add the specified value to the set for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_set_add(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_add.

18.0.19.107 group_set_add

Add the specified value to the set for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_set_add(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.108 async_group_set_add

Add the specified value to the set for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_set_add(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_add.

18.0.19.109 set_remove

Remove the specified value from the set. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  set_remove(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.110 async_set_remove

Remove the specified value from the set. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_set_remove(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_remove.

18.0.19.111 cond_set_remove

Remove the specified value from the set if and only if the checks hold on the object. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_set_remove(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.112 async_cond_set_remove

Remove the specified value from the set if and only if the checks hold on the object. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_set_remove(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_remove.

18.0.19.113 group_set_remove

Remove the specified value from the set for each object in space that matches checks. If the value is not contained within the set, this operation will do nothing.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_set_remove(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.114 async_group_set_remove

Remove the specified value from the set for each object in space that matches checks. If the value is not contained within the set, this operation will do nothing.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_set_remove(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_remove.

18.0.19.115 set_intersect

Store the intersection of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  set_intersect(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.116 async_set_intersect

Store the intersection of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_set_intersect(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_intersect.

18.0.19.117 cond_set_intersect

Store the intersection of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_set_intersect(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.118 async_cond_set_intersect

Store the intersection of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_set_intersect(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_intersect.

18.0.19.119 group_set_intersect

Store the intersection of the specified set and the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_set_intersect(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.120 async_group_set_intersect

Store the intersection of the specified set and the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_set_intersect(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_intersect.

18.0.19.121 set_union

Store the union of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  set_union(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.122 async_set_union

Store the union of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_set_union(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of set_union.

18.0.19.123 cond_set_union

Store the union of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_set_union(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.124 async_cond_set_union

Store the union of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_set_union(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_set_union.

18.0.19.125 group_set_union

Store the union of the specified set and the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_set_union(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.126 async_group_set_union

Store the union of the specified set and the existing value for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_set_union(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_set_union.

18.0.19.127 document_rename

Move a field within a document from one name to another. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  document_rename(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.128 async_document_rename

Move a field within a document from one name to another. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_document_rename(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of document_rename.

18.0.19.129 cond_document_rename

Move a field within a document from one name to another if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_document_rename(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.130 async_cond_document_rename

Move a field within a document from one name to another if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_document_rename(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_document_rename.

18.0.19.131 group_document_rename

Move a field within a document from one name to another for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_document_rename(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.132 async_group_document_rename

Move a field within a document from one name to another for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_document_rename(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_document_rename.

18.0.19.133 document_unset

Remove a field or object from a document. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  document_unset(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.134 async_document_unset

Remove a field or object from a document. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_document_unset(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of document_unset.

18.0.19.135 cond_document_unset

Remove a field or object from a document if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_document_unset(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.136 async_cond_document_unset

Remove a field or object from a document if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_document_unset(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_document_unset.

18.0.19.137 group_document_unset

Remove a field or object from a document for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_document_unset(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.138 async_group_document_unset

Remove a field or object from a document for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_document_unset(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_document_unset.

18.0.19.139 map_add

Insert a key-value pair into the map specified by each map-attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_add(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.140 async_map_add

Insert a key-value pair into the map specified by each map-attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_add(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_add.

18.0.19.141 cond_map_add

Insert a key-value pair into the map specified by each map-attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_add(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.142 async_cond_map_add

Insert a key-value pair into the map specified by each map-attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_add(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_add.

18.0.19.143 group_map_add

Insert a key-value pair into the map specified by each map-attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_add(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.144 async_group_map_add

Insert a key-value pair into the map specified by each map-attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_add(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_add.

18.0.19.145 map_remove

Remove a key-value pair from the map specified by each attribute. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_remove(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.146 async_map_remove

Remove a key-value pair from the map specified by each attribute. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_remove(self, spacename, key, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_remove.

18.0.19.147 cond_map_remove

Remove a key-value pair from the map specified by each attribute if and only if checks hold on the object. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_remove(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.148 async_cond_map_remove

Remove a key-value pair from the map specified by each attribute if and only if checks hold on the object. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_remove(self, spacename, key, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_remove.

18.0.19.149 group_map_remove

Remove a key-value pair from the map specified by each attribute for each object in space that matches checks. If there is no pair with the specified key within the map, this operation will do nothing.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_remove(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: Number of objects found. Raises exception on error.

18.0.19.150 async_group_map_remove

Remove a key-value pair from the map specified by each attribute for each object in space that matches checks. If there is no pair with the specified key within the map, this operation will do nothing.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_remove(self, spacename, predicates, attributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• attributes
  A dictionary of attributes to modify and their respective values.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_remove.

18.0.19.151 map_atomic_add

Add the specified number to the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_add(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.152 async_map_atomic_add

Add the specified number to the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_add(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_add.

18.0.19.153 cond_map_atomic_add

Add the specified number to the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_add(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.154 async_cond_map_atomic_add

Add the specified number to the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_add(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_add.

18.0.19.155 group_map_atomic_add

Add the specified number to the value of a key-value pair within each map for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_add(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.156 async_group_map_atomic_add

Add the specified number to the value of a key-value pair within each map for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_add(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_add.

18.0.19.157 map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_sub(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.158 async_map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_sub(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_sub.

18.0.19.159 cond_map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_sub(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.160 async_cond_map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_sub(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_sub.

18.0.19.161 group_map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_sub(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.162 async_group_map_atomic_sub

Subtract the specified number from the value of a key-value pair within each map for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_sub(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_sub.

18.0.19.163 map_atomic_mul

Multiply the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_mul(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.164 async_map_atomic_mul

Multiply the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_mul(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_mul.

18.0.19.165 cond_map_atomic_mul

Multiply the value of each key-value pair by the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_mul(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.166 async_cond_map_atomic_mul

Multiply the value of each key-value pair by the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_mul(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_mul.

18.0.19.167 group_map_atomic_mul

Multiply the value of each key-value pair by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_mul(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.168 async_group_map_atomic_mul

Multiply the value of each key-value pair by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_mul(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_mul.

18.0.19.169 map_atomic_div

Divide the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_div(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.170 async_map_atomic_div

Divide the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_div(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_div.

18.0.19.171 cond_map_atomic_div

Divide the value of each key-value pair by the specified number for each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_div(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.172 async_cond_map_atomic_div

Divide the value of each key-value pair by the specified number for each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_div(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_div.

18.0.19.173 group_map_atomic_div

Divide the value of each key-value pair by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_div(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.174 async_group_map_atomic_div

Divide the value of each key-value pair by the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_div(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_div.

18.0.19.175 map_atomic_mod

Store the value of the key-value pair modulo the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_mod(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.176 async_map_atomic_mod

Store the value of the key-value pair modulo the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_mod(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_mod.

18.0.19.177 cond_map_atomic_mod

Store the value of the key-value pair modulo the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_mod(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.178 async_cond_map_atomic_mod

Store the value of the key-value pair modulo the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_mod(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_mod.

18.0.19.179 group_map_atomic_mod

Store the value of the key-value pair modulo the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_mod(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.180 async_group_map_atomic_mod

Store the value of the key-value pair modulo the specified number for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_mod(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_mod.

18.0.19.181 map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_and(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.182 async_map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_and(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_and.

18.0.19.183 cond_map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_and(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.184 async_cond_map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_and(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_and.

18.0.19.185 group_map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_and(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.186 async_group_map_atomic_and

Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_and(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_and.

18.0.19.187 map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_or(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.188 async_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_or(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_or.

18.0.19.189 cond_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_or(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.190 async_cond_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_or(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_or.

18.0.19.191 group_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_or(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.192 async_group_map_atomic_or

Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_or(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_or.

18.0.19.193 map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_xor(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.194 async_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_xor(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_xor.

18.0.19.195 cond_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_xor(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.196 async_cond_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_xor(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_xor.

18.0.19.197 group_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_xor(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.198 async_group_map_atomic_xor

Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_xor(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_xor.

18.0.19.199 map_string_prepend

Prepend the specified string to the value of the key-value pair for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_string_prepend(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.200 async_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_string_prepend(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_string_prepend.

18.0.19.201 cond_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_string_prepend(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.202 async_cond_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_string_prepend(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_string_prepend.

18.0.19.203 group_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_string_prepend(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.204 async_group_map_string_prepend

Prepend the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_string_prepend(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_string_prepend.

18.0.19.205 map_string_append

Append the specified string to the value of the key-value pair for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_string_append(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.206 async_map_string_append

Append the specified string to the value of the key-value pair for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_string_append(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_string_append.

18.0.19.207 cond_map_string_append

Append the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_string_append(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.208 async_cond_map_string_append

Append the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_string_append(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_string_append.

18.0.19.209 group_map_string_append

Append the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_string_append(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.210 async_group_map_string_append

Append the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_string_append(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_string_append.

18.0.19.211 map_atomic_min

Take the minium of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_min(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.212 async_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_min(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_min.

18.0.19.213 cond_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_min(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.214 async_cond_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_min(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_min.

18.0.19.215 group_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_min(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.216 async_group_map_atomic_min

Take the minium of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_min(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_min.

18.0.19.217 map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  map_atomic_max(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.218 async_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:

    def  async_map_atomic_max(self, spacename, key, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of map_atomic_max.

18.0.19.219 cond_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  cond_map_atomic_max(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: True if the operation succeeded, False if any of the provided predicates failed. Raises an exception on error.

18.0.19.220 async_cond_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.

This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.

All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:

    def  async_cond_map_atomic_max(self, spacename, key, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• key
  The key for the operation as a Python type.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns True if the operation succeeded, or False if any of the provided predicates failed. Raises an exception on error. See also: This is the asynchronous form of cond_map_atomic_max.

18.0.19.221 group_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  group_map_atomic_max(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: Number of objects found. Raises exception on error.

18.0.19.222 async_group_map_atomic_max

Take the maximum of the specified value and existing value for each key-value pair for each object in space that matches checks.

This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:

    def  async_group_map_atomic_max(self, spacename, predicates, mapattributes)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• mapattributes
  A dictionary of map attributes to modify and their respective key-value pairs.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of group_map_atomic_max.

18.0.19.223 search

Return all objects that match the specified checks. This operation behaves as an iterator and may return multiple objects from the single call. Definition:

    def  search(self, spacename, predicates)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.

Returns: An iterator that returns objects one at a time. Exceptions will be returned via the same method to enable applications to retrieve partial results in the face of errors.

18.0.19.224 sorted_search

Return all objects that match the specified checks, sorted according to attr. This operation behaves as an iterator and may return multiple objects from the single call. Definition:

    def  sorted_search(self, spacename, predicates, sortby, limit, maxmin)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.
• sortby
  The attribute to sort by.
• limit
  The number of results to return.
• maxmin
  Maximize (’max’) or minimize (’min’).

Returns: An iterator that returns objects one at a time. Exceptions will be returned via the same method to enable applications to retrieve partial results in the face of errors.

18.0.19.225 count

Count the number of objects that match the specified checks. This will return the number of objects counted by the search. If an error occurs during the count, the count may reflect a partial count. The real count will be higher than the returned value.

A count is the server-side equivalent of performing a search, and counting the number of objects that exist. For that reason, its efficiency closely follows that of search, except it will not transfer any objects over the network. Definition:

    def  count(self, spacename, predicates)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.

Returns: Number of objects found. Raises exception on error.

18.0.19.226 async_count

Count the number of objects that match the specified checks. This will return the number of objects counted by the search. If an error occurs during the count, the count may reflect a partial count. The real count will be higher than the returned value.

A count is the server-side equivalent of performing a search, and counting the number of objects that exist. For that reason, its efficiency closely follows that of search, except it will not transfer any objects over the network. Definition:

    def  async_count(self, spacename, predicates)

Parameters:

• spacename
  The name of the space as a string.
• predicates
  A dictionary of predicates to check against.

Returns: A Deferred object with a wait method that returns the number of objects found. Raises exception on error. See also: This is the asynchronous form of count.

18.0.20 Working with Signals

The HyperDex client library is signal-safe. Should a signal interrupt the client during a blocking operation, it will raise a HyperDexClientException with status HYPERDEX_CLIENT_INTERRUPTED.

18.0.21 Working with Threads

The Python module is fully reentrant. Instances of hyperdex.client.Client and their associated state may be accessed from multiple threads, provided that the application employs its own synchronization that provides mutual exclusion.

Put simply, a multi-threaded application should protect each Client instance with a mutex or lock to ensure correct operation.