docs: def update_item(self, table_name, key_dict,
                      condition_expression=None,
                      update_expression=None,
                      expression_attribute_names=None,
                      expression_attribute_values=None,
                      return_consumed_capacity=None,
                      return_item_collection_metrics=None,
                      return_values=None):
          """Invoke the `UpdateItem`_ function.
  
          Edits an existing item's attributes, or adds a new item to the table
          if it does not already exist. You can put, delete, or add attribute
          values. You can also perform a conditional update on an existing item
          (insert a new attribute name-value pair if it doesn't exist, or replace
          an existing name-value pair if it has certain expected attribute
          values).
  
          :param str table_name: The name of the table that contains the item to
              update
          :param dict key_dict: A dictionary of key/value pairs that are used to
              define the primary key values for the item. For the primary key,
              you must provide all of the attributes. For example, with a simple
              primary key, you only need to provide a value for the partition
              key. For a composite primary key, you must provide values for both
              the partition key and the sort key.
          :param str condition_expression: A condition that must be satisfied in
              order for a conditional *UpdateItem* operation to succeed. One of:
              ``attribute_exists``, ``attribute_not_exists``, ``attribute_type``,
              ``contains``, ``begins_with``, ``size``, ``=``, ``<>``, ``<``,
              ``>``, ``<=``, ``>=``, ``BETWEEN``, ``IN``, ``AND``, ``OR``, or
              ``NOT``.
          :param str update_expression: An expression that defines one or more
              attributes to be updated, the action to be performed on them, and
              new value(s) for them.
          :param dict expression_attribute_names: One or more substitution tokens
              for attribute names in an expression.
          :param dict expression_attribute_values: One or more values that can be
              substituted in an expression.
          :param str return_consumed_capacity: Determines the level of detail
              about provisioned throughput consumption that is returned in the
              response. See the `AWS documentation
              for ReturnConsumedCapacity <http://docs.aws.amazon.com/
              amazondynamodb/latest/APIReference/API_UpdateItem.html#DDB-Update
              Item-request-ReturnConsumedCapacity>`_ for more information.
          :param str return_item_collection_metrics: Determines whether item
              collection metrics are returned.
          :param str return_values: Use ReturnValues if you want to get the item
              attributes as they appeared either before or after they were
              updated. See the `AWS documentation for ReturnValues <http://docs.
              aws.amazon.com/amazondynamodb/latest/APIReference/
              API_UpdateItem.html#DDB-UpdateItem-request-ReturnValues>`_
          :rtype: tornado.concurrent.Future
  
          .. _UpdateItem: http://docs.aws.amazon.com/amazondynamodb/
             latest/APIReference/API_UpdateItem.html
  
          """
          payload = {'TableName': table_name,
                     'Key': utils.marshall(key_dict),
                     'UpdateExpression': update_expression}
          if condition_expression:
              payload['ConditionExpression'] = condition_expression
          if expression_attribute_names:
              payload['ExpressionAttributeNames'] = expression_attribute_names
          if expression_attribute_values:
              payload['ExpressionAttributeValues'] = \
                  utils.marshall(expression_attribute_values)
          if return_consumed_capacity:
              _validate_return_consumed_capacity(return_consumed_capacity)
              payload['ReturnConsumedCapacity'] = return_consumed_capacity
          if return_item_collection_metrics:
              _validate_return_item_collection_metrics(
                  return_item_collection_metrics)
              payload['ReturnItemCollectionMetrics'] = \
                  return_item_collection_metrics
          if return_values:
              _validate_return_values(return_values)
              payload['ReturnValues'] = return_values
          return self.execute('UpdateItem', payload)