Remove telemetry/third_party/gsutilz

tools/telemetry/third_party/gsutilz/third_party/boto/boto/dynamodb2/layer1.py

Index: tools/telemetry/third_party/gsutilz/third_party/boto/boto/dynamodb2/layer1.py
diff --git a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/dynamodb2/layer1.py b/tools/telemetry/third_party/gsutilz/third_party/boto/boto/dynamodb2/layer1.py
deleted file mode 100644
index bd1eb1ea9d40c147943575563b0c3d3a00d8dc3d..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/dynamodb2/layer1.py
+++ /dev/null
@@ -1,2904 +0,0 @@
-# Copyright (c) 2014 Amazon.com, Inc. or its affiliates.  All Rights Reserved
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-from binascii import crc32
-
-import boto
-from boto.compat import json
-from boto.connection import AWSQueryConnection
-from boto.regioninfo import RegionInfo
-from boto.exception import JSONResponseError
-from boto.dynamodb2 import exceptions
-
-
-class DynamoDBConnection(AWSQueryConnection):
-    """
-    Amazon DynamoDB
-    **Overview**
-
-    This is the Amazon DynamoDB API Reference. This guide provides
-    descriptions and samples of the low-level DynamoDB API. For
-    information about DynamoDB application development, go to the
-    `Amazon DynamoDB Developer Guide`_.
-
-    Instead of making the requests to the low-level DynamoDB API
-    directly from your application, we recommend that you use the AWS
-    Software Development Kits (SDKs). The easy-to-use libraries in the
-    AWS SDKs make it unnecessary to call the low-level DynamoDB API
-    directly from your application. The libraries take care of request
-    authentication, serialization, and connection management. For more
-    information, go to `Using the AWS SDKs with DynamoDB`_ in the
-    Amazon DynamoDB Developer Guide .
-
-    If you decide to code against the low-level DynamoDB API directly,
-    you will need to write the necessary code to authenticate your
-    requests. For more information on signing your requests, go to
-    `Using the DynamoDB API`_ in the Amazon DynamoDB Developer Guide .
-
-    The following are short descriptions of each low-level API action,
-    organized by function.
-
-    **Managing Tables**
-
-
-    + CreateTable - Creates a table with user-specified provisioned
-      throughput settings. You must designate one attribute as the hash
-      primary key for the table; you can optionally designate a second
-      attribute as the range primary key. DynamoDB creates indexes on
-      these key attributes for fast data access. Optionally, you can
-      create one or more secondary indexes, which provide fast data
-      access using non-key attributes.
-    + DescribeTable - Returns metadata for a table, such as table
-      size, status, and index information.
-    + UpdateTable - Modifies the provisioned throughput settings for a
-      table. Optionally, you can modify the provisioned throughput
-      settings for global secondary indexes on the table.
-    + ListTables - Returns a list of all tables associated with the
-      current AWS account and endpoint.
-    + DeleteTable - Deletes a table and all of its indexes.
-
-
-    For conceptual information about managing tables, go to `Working
-    with Tables`_ in the Amazon DynamoDB Developer Guide .
-
-    **Reading Data**
-
-
-    + GetItem - Returns a set of attributes for the item that has a
-      given primary key. By default, GetItem performs an eventually
-      consistent read; however, applications can specify a strongly
-      consistent read instead.
-    + BatchGetItem - Performs multiple GetItem requests for data items
-      using their primary keys, from one table or multiple tables. The
-      response from BatchGetItem has a size limit of 16 MB and returns a
-      maximum of 100 items. Both eventually consistent and strongly
-      consistent reads can be used.
-    + Query - Returns one or more items from a table or a secondary
-      index. You must provide a specific hash key value. You can narrow
-      the scope of the query using comparison operators against a range
-      key value, or on the index key. Query supports either eventual or
-      strong consistency. A single response has a size limit of 1 MB.
-    + Scan - Reads every item in a table; the result set is eventually
-      consistent. You can limit the number of items returned by
-      filtering the data attributes, using conditional expressions. Scan
-      can be used to enable ad-hoc querying of a table against non-key
-      attributes; however, since this is a full table scan without using
-      an index, Scan should not be used for any application query use
-      case that requires predictable performance.
-
-
-    For conceptual information about reading data, go to `Working with
-    Items`_ and `Query and Scan Operations`_ in the Amazon DynamoDB
-    Developer Guide .
-
-    **Modifying Data**
-
-
-    + PutItem - Creates a new item, or replaces an existing item with
-      a new item (including all the attributes). By default, if an item
-      in the table already exists with the same primary key, the new
-      item completely replaces the existing item. You can use
-      conditional operators to replace an item only if its attribute
-      values match certain conditions, or to insert a new item only if
-      that item doesn't already exist.
-    + UpdateItem - Modifies the attributes of an existing item. You
-      can also use conditional operators to perform an update only if
-      the item's attribute values match certain conditions.
-    + DeleteItem - Deletes an item in a table by primary key. You can
-      use conditional operators to perform a delete an item only if the
-      item's attribute values match certain conditions.
-    + BatchWriteItem - Performs multiple PutItem and DeleteItem
-      requests across multiple tables in a single request. A failure of
-      any request(s) in the batch will not cause the entire
-      BatchWriteItem operation to fail. Supports batches of up to 25
-      items to put or delete, with a maximum total request size of 16
-      MB.
-
-
-    For conceptual information about modifying data, go to `Working
-    with Items`_ and `Query and Scan Operations`_ in the Amazon
-    DynamoDB Developer Guide .
-    """
-    APIVersion = "2012-08-10"
-    DefaultRegionName = "us-east-1"
-    DefaultRegionEndpoint = "dynamodb.us-east-1.amazonaws.com"
-    ServiceName = "DynamoDB"
-    TargetPrefix = "DynamoDB_20120810"
-    ResponseError = JSONResponseError
-
-    _faults = {
-        "ProvisionedThroughputExceededException": exceptions.ProvisionedThroughputExceededException,
-        "LimitExceededException": exceptions.LimitExceededException,
-        "ConditionalCheckFailedException": exceptions.ConditionalCheckFailedException,
-        "ResourceInUseException": exceptions.ResourceInUseException,
-        "ResourceNotFoundException": exceptions.ResourceNotFoundException,
-        "InternalServerError": exceptions.InternalServerError,
-        "ItemCollectionSizeLimitExceededException": exceptions.ItemCollectionSizeLimitExceededException,
-    }
-
-    NumberRetries = 10
-
-
-    def __init__(self, **kwargs):
-        region = kwargs.pop('region', None)
-        validate_checksums = kwargs.pop('validate_checksums', True)
-        if not region:
-            region_name = boto.config.get('DynamoDB', 'region',
-                                          self.DefaultRegionName)
-            for reg in boto.dynamodb2.regions():
-                if reg.name == region_name:
-                    region = reg
-                    break
-
-        # Only set host if it isn't manually overwritten
-        if 'host' not in kwargs:
-            kwargs['host'] = region.endpoint
-
-        super(DynamoDBConnection, self).__init__(**kwargs)
-        self.region = region
-        self._validate_checksums = boto.config.getbool(
-            'DynamoDB', 'validate_checksums', validate_checksums)
-        self.throughput_exceeded_events = 0
-
-    def _required_auth_capability(self):
-        return ['hmac-v4']
-
-    def batch_get_item(self, request_items, return_consumed_capacity=None):
-        """
-        The BatchGetItem operation returns the attributes of one or
-        more items from one or more tables. You identify requested
-        items by primary key.
-
-        A single operation can retrieve up to 16 MB of data, which can
-        contain as many as 100 items. BatchGetItem will return a
-        partial result if the response size limit is exceeded, the
-        table's provisioned throughput is exceeded, or an internal
-        processing failure occurs. If a partial result is returned,
-        the operation returns a value for UnprocessedKeys . You can
-        use this value to retry the operation starting with the next
-        item to get.
-
-        For example, if you ask to retrieve 100 items, but each
-        individual item is 300 KB in size, the system returns 52 items
-        (so as not to exceed the 16 MB limit). It also returns an
-        appropriate UnprocessedKeys value so you can get the next page
-        of results. If desired, your application can include its own
-        logic to assemble the pages of results into one data set.
-
-        If none of the items can be processed due to insufficient
-        provisioned throughput on all of the tables in the request,
-        then BatchGetItem will return a
-        ProvisionedThroughputExceededException . If at least one of
-        the items is successfully processed, then BatchGetItem
-        completes successfully, while returning the keys of the unread
-        items in UnprocessedKeys .
-
-        If DynamoDB returns any unprocessed items, you should retry
-        the batch operation on those items. However, we strongly
-        recommend that you use an exponential backoff algorithm . If
-        you retry the batch operation immediately, the underlying read
-        or write requests can still fail due to throttling on the
-        individual tables. If you delay the batch operation using
-        exponential backoff, the individual requests in the batch are
-        much more likely to succeed.
-
-        For more information, go to `Batch Operations and Error
-        Handling`_ in the Amazon DynamoDB Developer Guide .
-
-        By default, BatchGetItem performs eventually consistent reads
-        on every table in the request. If you want strongly consistent
-        reads instead, you can set ConsistentRead to `True` for any or
-        all tables.
-
-        In order to minimize response latency, BatchGetItem retrieves
-        items in parallel.
-
-        When designing your application, keep in mind that DynamoDB
-        does not return attributes in any particular order. To help
-        parse the response by item, include the primary key values for
-        the items in your request in the AttributesToGet parameter.
-
-        If a requested item does not exist, it is not returned in the
-        result. Requests for nonexistent items consume the minimum
-        read capacity units according to the type of read. For more
-        information, see `Capacity Units Calculations`_ in the Amazon
-        DynamoDB Developer Guide .
-
-        :type request_items: map
-        :param request_items:
-        A map of one or more table names and, for each table, the corresponding
-            primary keys for the items to retrieve. Each table name can be
-            invoked only once.
-
-        Each element in the map consists of the following:
-
-
-        + Keys - An array of primary key attribute values that define specific
-              items in the table. For each primary key, you must provide all of
-              the key attributes. For example, with a hash type primary key, you
-              only need to specify the hash attribute. For a hash-and-range type
-              primary key, you must specify both the hash attribute and the range
-              attribute.
-        + AttributesToGet - One or more attributes to be retrieved from the
-              table. By default, all attributes are returned. If a specified
-              attribute is not found, it does not appear in the result. Note that
-              AttributesToGet has no effect on provisioned throughput
-              consumption. DynamoDB determines capacity units consumed based on
-              item size, not on the amount of data that is returned to an
-              application.
-        + ConsistentRead - If `True`, a strongly consistent read is used; if
-              `False` (the default), an eventually consistent read is used.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        """
-        params = {'RequestItems': request_items, }
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        return self.make_request(action='BatchGetItem',
-                                 body=json.dumps(params))
-
-    def batch_write_item(self, request_items, return_consumed_capacity=None,
-                         return_item_collection_metrics=None):
-        """
-        The BatchWriteItem operation puts or deletes multiple items in
-        one or more tables. A single call to BatchWriteItem can write
-        up to 16 MB of data, which can comprise as many as 25 put or
-        delete requests. Individual items to be written can be as
-        large as 400 KB.
-
-
-        BatchWriteItem cannot update items. To update items, use the
-        UpdateItem API.
-
-
-        The individual PutItem and DeleteItem operations specified in
-        BatchWriteItem are atomic; however BatchWriteItem as a whole
-        is not. If any requested operations fail because the table's
-        provisioned throughput is exceeded or an internal processing
-        failure occurs, the failed operations are returned in the
-        UnprocessedItems response parameter. You can investigate and
-        optionally resend the requests. Typically, you would call
-        BatchWriteItem in a loop. Each iteration would check for
-        unprocessed items and submit a new BatchWriteItem request with
-        those unprocessed items until all items have been processed.
-
-        Note that if none of the items can be processed due to
-        insufficient provisioned throughput on all of the tables in
-        the request, then BatchWriteItem will return a
-        ProvisionedThroughputExceededException .
-
-        If DynamoDB returns any unprocessed items, you should retry
-        the batch operation on those items. However, we strongly
-        recommend that you use an exponential backoff algorithm . If
-        you retry the batch operation immediately, the underlying read
-        or write requests can still fail due to throttling on the
-        individual tables. If you delay the batch operation using
-        exponential backoff, the individual requests in the batch are
-        much more likely to succeed.
-
-        For more information, go to `Batch Operations and Error
-        Handling`_ in the Amazon DynamoDB Developer Guide .
-
-        With BatchWriteItem , you can efficiently write or delete
-        large amounts of data, such as from Amazon Elastic MapReduce
-        (EMR), or copy data from another database into DynamoDB. In
-        order to improve performance with these large-scale
-        operations, BatchWriteItem does not behave in the same way as
-        individual PutItem and DeleteItem calls would For example, you
-        cannot specify conditions on individual put and delete
-        requests, and BatchWriteItem does not return deleted items in
-        the response.
-
-        If you use a programming language that supports concurrency,
-        such as Java, you can use threads to write items in parallel.
-        Your application must include the necessary logic to manage
-        the threads. With languages that don't support threading, such
-        as PHP, you must update or delete the specified items one at a
-        time. In both situations, BatchWriteItem provides an
-        alternative where the API performs the specified put and
-        delete operations in parallel, giving you the power of the
-        thread pool approach without having to introduce complexity
-        into your application.
-
-        Parallel processing reduces latency, but each specified put
-        and delete request consumes the same number of write capacity
-        units whether it is processed in parallel or not. Delete
-        operations on nonexistent items consume one write capacity
-        unit.
-
-        If one or more of the following is true, DynamoDB rejects the
-        entire batch write operation:
-
-
-        + One or more tables specified in the BatchWriteItem request
-          does not exist.
-        + Primary key attributes specified on an item in the request
-          do not match those in the corresponding table's primary key
-          schema.
-        + You try to perform multiple operations on the same item in
-          the same BatchWriteItem request. For example, you cannot put
-          and delete the same item in the same BatchWriteItem request.
-        + There are more than 25 requests in the batch.
-        + Any individual item in a batch exceeds 400 KB.
-        + The total request size exceeds 16 MB.
-
-        :type request_items: map
-        :param request_items:
-        A map of one or more table names and, for each table, a list of
-            operations to be performed ( DeleteRequest or PutRequest ). Each
-            element in the map consists of the following:
-
-
-        + DeleteRequest - Perform a DeleteItem operation on the specified item.
-              The item to be deleted is identified by a Key subelement:
-
-            + Key - A map of primary key attribute values that uniquely identify
-                  the ! item. Each entry in this map consists of an attribute name
-                  and an attribute value. For each primary key, you must provide all
-                  of the key attributes. For example, with a hash type primary key,
-                  you only need to specify the hash attribute. For a hash-and-range
-                  type primary key, you must specify both the hash attribute and the
-                  range attribute.
-
-        + PutRequest - Perform a PutItem operation on the specified item. The
-              item to be put is identified by an Item subelement:
-
-            + Item - A map of attributes and their values. Each entry in this map
-                  consists of an attribute name and an attribute value. Attribute
-                  values must not be null; string and binary type attributes must
-                  have lengths greater than zero; and set type attributes must not be
-                  empty. Requests that contain empty values will be rejected with a
-                  ValidationException exception. If you specify any attributes that
-                  are part of an index key, then the data types for those attributes
-                  must match those of the schema in the table's attribute definition.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type return_item_collection_metrics: string
-        :param return_item_collection_metrics: A value that if set to `SIZE`,
-            the response includes statistics about item collections, if any,
-            that were modified during the operation are returned in the
-            response. If set to `NONE` (the default), no statistics are
-            returned.
-
-        """
-        params = {'RequestItems': request_items, }
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if return_item_collection_metrics is not None:
-            params['ReturnItemCollectionMetrics'] = return_item_collection_metrics
-        return self.make_request(action='BatchWriteItem',
-                                 body=json.dumps(params))
-
-    def create_table(self, attribute_definitions, table_name, key_schema,
-                     provisioned_throughput, local_secondary_indexes=None,
-                     global_secondary_indexes=None):
-        """
-        The CreateTable operation adds a new table to your account. In
-        an AWS account, table names must be unique within each region.
-        That is, you can have two tables with same name if you create
-        the tables in different regions.
-
-        CreateTable is an asynchronous operation. Upon receiving a
-        CreateTable request, DynamoDB immediately returns a response
-        with a TableStatus of `CREATING`. After the table is created,
-        DynamoDB sets the TableStatus to `ACTIVE`. You can perform
-        read and write operations only on an `ACTIVE` table.
-
-        You can optionally define secondary indexes on the new table,
-        as part of the CreateTable operation. If you want to create
-        multiple tables with secondary indexes on them, you must
-        create the tables sequentially. Only one table with secondary
-        indexes can be in the `CREATING` state at any given time.
-
-        You can use the DescribeTable API to check the table status.
-
-        :type attribute_definitions: list
-        :param attribute_definitions: An array of attributes that describe the
-            key schema for the table and indexes.
-
-        :type table_name: string
-        :param table_name: The name of the table to create.
-
-        :type key_schema: list
-        :param key_schema: Specifies the attributes that make up the primary
-            key for a table or an index. The attributes in KeySchema must also
-            be defined in the AttributeDefinitions array. For more information,
-            see `Data Model`_ in the Amazon DynamoDB Developer Guide .
-        Each KeySchemaElement in the array is composed of:
-
-
-        + AttributeName - The name of this key attribute.
-        + KeyType - Determines whether the key attribute is `HASH` or `RANGE`.
-
-
-        For a primary key that consists of a hash attribute, you must specify
-            exactly one element with a KeyType of `HASH`.
-
-        For a primary key that consists of hash and range attributes, you must
-            specify exactly two elements, in this order: The first element must
-            have a KeyType of `HASH`, and the second element must have a
-            KeyType of `RANGE`.
-
-        For more information, see `Specifying the Primary Key`_ in the Amazon
-            DynamoDB Developer Guide .
-
-        :type local_secondary_indexes: list
-        :param local_secondary_indexes:
-        One or more local secondary indexes (the maximum is five) to be created
-            on the table. Each index is scoped to a given hash key value. There
-            is a 10 GB size limit per hash key; otherwise, the size of a local
-            secondary index is unconstrained.
-
-        Each local secondary index in the array includes the following:
-
-
-        + IndexName - The name of the local secondary index. Must be unique
-              only for this table.
-        + KeySchema - Specifies the key schema for the local secondary index.
-              The key schema must begin with the same hash key attribute as the
-              table.
-        + Projection - Specifies attributes that are copied (projected) from
-              the table into the index. These are in addition to the primary key
-              attributes and index key attributes, which are automatically
-              projected. Each attribute specification is composed of:
-
-            + ProjectionType - One of the following:
-
-                + `KEYS_ONLY` - Only the index and primary keys are projected into the
-                      index.
-                + `INCLUDE` - Only the specified table attributes are projected into
-                      the index. The list of projected attributes are in NonKeyAttributes
-                      .
-                + `ALL` - All of the table attributes are projected into the index.
-
-            + NonKeyAttributes - A list of one or more non-key attribute names that
-                  are projected into the secondary index. The total count of
-                  attributes specified in NonKeyAttributes , summed across all of the
-                  secondary indexes, must not exceed 20. If you project the same
-                  attribute into two different indexes, this counts as two distinct
-                  attributes when determining the total.
-
-        :type global_secondary_indexes: list
-        :param global_secondary_indexes:
-        One or more global secondary indexes (the maximum is five) to be
-            created on the table. Each global secondary index in the array
-            includes the following:
-
-
-        + IndexName - The name of the global secondary index. Must be unique
-              only for this table.
-        + KeySchema - Specifies the key schema for the global secondary index.
-        + Projection - Specifies attributes that are copied (projected) from
-              the table into the index. These are in addition to the primary key
-              attributes and index key attributes, which are automatically
-              projected. Each attribute specification is composed of:
-
-            + ProjectionType - One of the following:
-
-                + `KEYS_ONLY` - Only the index and primary keys are projected into the
-                      index.
-                + `INCLUDE` - Only the specified table attributes are projected into
-                      the index. The list of projected attributes are in NonKeyAttributes
-                      .
-                + `ALL` - All of the table attributes are projected into the index.
-
-            + NonKeyAttributes - A list of one or more non-key attribute names that
-                  are projected into the secondary index. The total count of
-                  attributes specified in NonKeyAttributes , summed across all of the
-                  secondary indexes, must not exceed 20. If you project the same
-                  attribute into two different indexes, this counts as two distinct
-                  attributes when determining the total.
-
-        + ProvisionedThroughput - The provisioned throughput settings for the
-              global secondary index, consisting of read and write capacity
-              units.
-
-        :type provisioned_throughput: dict
-        :param provisioned_throughput: Represents the provisioned throughput
-            settings for a specified table or index. The settings can be
-            modified using the UpdateTable operation.
-        For current minimum and maximum provisioned throughput values, see
-            `Limits`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {
-            'AttributeDefinitions': attribute_definitions,
-            'TableName': table_name,
-            'KeySchema': key_schema,
-            'ProvisionedThroughput': provisioned_throughput,
-        }
-        if local_secondary_indexes is not None:
-            params['LocalSecondaryIndexes'] = local_secondary_indexes
-        if global_secondary_indexes is not None:
-            params['GlobalSecondaryIndexes'] = global_secondary_indexes
-        return self.make_request(action='CreateTable',
-                                 body=json.dumps(params))
-
-    def delete_item(self, table_name, key, expected=None,
-                    conditional_operator=None, return_values=None,
-                    return_consumed_capacity=None,
-                    return_item_collection_metrics=None,
-                    condition_expression=None,
-                    expression_attribute_names=None,
-                    expression_attribute_values=None):
-        """
-        Deletes a single item in a table by primary key. You can
-        perform a conditional delete operation that deletes the item
-        if it exists, or if it has an expected attribute value.
-
-        In addition to deleting an item, you can also return the
-        item's attribute values in the same operation, using the
-        ReturnValues parameter.
-
-        Unless you specify conditions, the DeleteItem is an idempotent
-        operation; running it multiple times on the same item or
-        attribute does not result in an error response.
-
-        Conditional deletes are useful for deleting items only if
-        specific conditions are met. If those conditions are met,
-        DynamoDB performs the delete. Otherwise, the item is not
-        deleted.
-
-        :type table_name: string
-        :param table_name: The name of the table from which to delete the item.
-
-        :type key: map
-        :param key: A map of attribute names to AttributeValue objects,
-            representing the primary key of the item to delete.
-        For the primary key, you must provide all of the attributes. For
-            example, with a hash type primary key, you only need to specify the
-            hash attribute. For a hash-and-range type primary key, you must
-            specify both the hash attribute and the range attribute.
-
-        :type expected: map
-        :param expected:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use Expected and ConditionExpression at the same
-            time, DynamoDB will return a ValidationException exception.
-
-        This parameter does not support lists or maps.
-
-        A map of attribute/condition pairs. Expected provides a conditional
-            block for the DeleteItem operation.
-
-        Each element of Expected consists of an attribute name, a comparison
-            operator, and one or more values. DynamoDB compares the attribute
-            with the value(s) you supplied, using the comparison operator. For
-            each Expected element, the result of the evaluation is either true
-            or false.
-
-        If you specify more than one element in the Expected map, then by
-            default all of the conditions must evaluate to true. In other
-            words, the conditions are ANDed together. (You can use the
-            ConditionalOperator parameter to OR the conditions instead. If you
-            do this, then at least one of the conditions must evaluate to true,
-            rather than all of them.)
-
-        If the Expected map evaluates to true, then the conditional operation
-            succeeds; otherwise, it fails.
-
-        Expected contains the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              ComparisonOperator being used. For type Number, value comparisons
-              are numeric. String value comparisons for greater than, equals, or
-              less than are based on ASCII character code values. For example,
-              `a` is greater than `A`, and `a` is greater than `B`. For a list of
-              code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For type Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions.
-        + ComparisonOperator - A comparator for evaluating attributes in the
-              AttributeValueList . When performing the comparison, DynamoDB uses
-              strongly consistent reads. The following comparison operators are
-              available: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL |
-              CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` The following
-              are descriptions of each comparison operator.
-
-            + `EQ` : Equal. `EQ` is supported for all datatypes, including lists
-                and maps. AttributeValueList can contain only one AttributeValue
-                element of type String, Number, Binary, String Set, Number Set, or
-                Binary Set. If an item contains an AttributeValue element of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `NE` : Not equal. `NE` is supported for all datatypes, including
-                lists and maps. AttributeValueList can contain only one
-                AttributeValue of type String, Number, Binary, String Set, Number
-                Set, or Binary Set. If an item contains an AttributeValue of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `LE` : Less than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `LT` : Less than. AttributeValueList can contain only one
-                AttributeValue of type String, Number, or Binary (not a set type).
-                If an item contains an AttributeValue element of a different type
-                than the one specified in the request, the value does not match.
-                For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GE` : Greater than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GT` : Greater than. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  existence of an attribute, not its data type. If the data type of
-                  attribute " `a`" is null, and you evaluate it using `NOT_NULL`, the
-                  result is a Boolean true . This result is because the attribute "
-                  `a`" exists; its data type is not relevant to the `NOT_NULL`
-                  comparison operator.
-            + `NULL` : The attribute does not exist. `NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  nonexistence of an attribute, not its data type. If the data type
-                  of attribute " `a`" is null, and you evaluate it using `NULL`, the
-                  result is a Boolean false . This is because the attribute " `a`"
-                  exists; its data type is not relevant to the `NULL` comparison
-                  operator.
-            + `CONTAINS` : Checks for a subsequence, or value in a set.
-                  AttributeValueList can contain only one AttributeValue element of
-                  type String, Number, or Binary (not a set type). If the target
-                  attribute of the comparison is of type String, then the operator
-                  checks for a substring match. If the target attribute of the
-                  comparison is of type Binary, then the operator looks for a
-                  subsequence of the target that matches the input. If the target
-                  attribute of the comparison is a set (" `SS`", " `NS`", or "
-                  `BS`"), then the operator evaluates to true if it finds an exact
-                  match with any member of the set. CONTAINS is supported for lists:
-                  When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
-                  `b`" cannot be a set, a map, or a list.
-            + `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
-                  value in a set. AttributeValueList can contain only one
-                  AttributeValue element of type String, Number, or Binary (not a set
-                  type). If the target attribute of the comparison is a String, then
-                  the operator checks for the absence of a substring match. If the
-                  target attribute of the comparison is Binary, then the operator
-                  checks for the absence of a subsequence of the target that matches
-                  the input. If the target attribute of the comparison is a set ("
-                  `SS`", " `NS`", or " `BS`"), then the operator evaluates to true if
-                  it does not find an exact match with any member of the set.
-                  NOT_CONTAINS is supported for lists: When evaluating " `a NOT
-                  CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
-                  set, a map, or a list.
-            + `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
-                only one AttributeValue of type String or Binary (not a Number or a
-                set type). The target attribute of the comparison must be of type
-                String or Binary (not a Number or a set type). > <li>
-            + `IN` : Checks for matching elements within two sets.
-                  AttributeValueList can contain one or more AttributeValue elements
-                  of type String, Number, or Binary (not a set type). These
-                  attributes are compared against an existing set type attribute of
-                  an item. If any elements of the input set are present in the item
-                  attribute, the expression evaluates to true.
-            + `BETWEEN` : Greater than or equal to the first value, and less than
-                  or equal to the second value. AttributeValueList must contain two
-                  AttributeValue elements of the same type, either String, Number, or
-                  Binary (not a set type). A target attribute matches if the target
-                  value is greater than, or equal to, the first element and less
-                  than, or equal to, the second element. If an item contains an
-                  AttributeValue element of a different type than the one specified
-                  in the request, the value does not match. For example, `{"S":"6"}`
-                  does not compare to `{"N":"6"}`. Also, `{"N":"6"}` does not compare
-                  to `{"NS":["6", "2", "1"]}`
-
-
-
-        For usage examples of AttributeValueList and ComparisonOperator , see
-            `Legacy Conditional Parameters`_ in the Amazon DynamoDB Developer
-            Guide .
-
-        For backward compatibility with previous DynamoDB releases, the
-            following parameters can be used instead of AttributeValueList and
-            ComparisonOperator :
-
-
-        + Value - A value for DynamoDB to compare with an attribute.
-        + Exists - A Boolean value that causes DynamoDB to evaluate the value
-              before attempting the conditional operation:
-
-            + If Exists is `True`, DynamoDB will check to see if that attribute
-                  value already exists in the table. If it is found, then the
-                  condition evaluates to true; otherwise the condition evaluate to
-                  false.
-            + If Exists is `False`, DynamoDB assumes that the attribute value does
-                  not exist in the table. If in fact the value does not exist, then
-                  the assumption is valid and the condition evaluates to true. If the
-                  value is found, despite the assumption that it does not exist, the
-                  condition evaluates to false.
-          Note that the default value for Exists is `True`.
-
-
-        The Value and Exists parameters are incompatible with
-            AttributeValueList and ComparisonOperator . Note that if you use
-            both sets of parameters at once, DynamoDB will return a
-            ValidationException exception.
-
-        :type conditional_operator: string
-        :param conditional_operator:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use ConditionalOperator and ConditionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter does not support lists or maps.
-
-        A logical operator to apply to the conditions in the Expected map:
-
-
-        + `AND` - If all of the conditions evaluate to true, then the entire
-              map evaluates to true.
-        + `OR` - If at least one of the conditions evaluate to true, then the
-              entire map evaluates to true.
-
-
-        If you omit ConditionalOperator , then `AND` is the default.
-
-        The operation will succeed only if the entire map evaluates to true.
-
-        :type return_values: string
-        :param return_values:
-        Use ReturnValues if you want to get the item attributes as they
-            appeared before they were deleted. For DeleteItem , the valid
-            values are:
-
-
-        + `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
-              then nothing is returned. (This setting is the default for
-              ReturnValues .)
-        + `ALL_OLD` - The content of the old item is returned.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type return_item_collection_metrics: string
-        :param return_item_collection_metrics: A value that if set to `SIZE`,
-            the response includes statistics about item collections, if any,
-            that were modified during the operation are returned in the
-            response. If set to `NONE` (the default), no statistics are
-            returned.
-
-        :type condition_expression: string
-        :param condition_expression: A condition that must be satisfied in
-            order for a conditional DeleteItem to succeed.
-        An expression can contain any of the following:
-
-
-        + Boolean functions: `attribute_exists | attribute_not_exists |
-              contains | begins_with` These function names are case-sensitive.
-        + Comparison operators: ` = | <> | < | > | <=
-              | >= | BETWEEN | IN`
-        + Logical operators: `AND | OR | NOT`
-
-
-        For more information on condition expressions, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_values: map
-        :param expression_attribute_values: One or more values that can be
-            substituted in an expression.
-        Use the **:** (colon) character in an expression to dereference an
-            attribute value. For example, suppose that you wanted to check
-            whether the value of the ProductStatus attribute was one of the
-            following:
-
-        `Available | Backordered | Discontinued`
-
-        You would first need to specify ExpressionAttributeValues as follows:
-
-        `{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
-            ":disc":{"S":"Discontinued"} }`
-
-        You could then use these values in an expression, such as this:
-
-        `ProductStatus IN (:avail, :back, :disc)`
-
-        For more information on expression attribute values, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {'TableName': table_name, 'Key': key, }
-        if expected is not None:
-            params['Expected'] = expected
-        if conditional_operator is not None:
-            params['ConditionalOperator'] = conditional_operator
-        if return_values is not None:
-            params['ReturnValues'] = return_values
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if return_item_collection_metrics is not None:
-            params['ReturnItemCollectionMetrics'] = return_item_collection_metrics
-        if condition_expression is not None:
-            params['ConditionExpression'] = condition_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        if expression_attribute_values is not None:
-            params['ExpressionAttributeValues'] = expression_attribute_values
-        return self.make_request(action='DeleteItem',
-                                 body=json.dumps(params))
-
-    def delete_table(self, table_name):
-        """
-        The DeleteTable operation deletes a table and all of its
-        items. After a DeleteTable request, the specified table is in
-        the `DELETING` state until DynamoDB completes the deletion. If
-        the table is in the `ACTIVE` state, you can delete it. If a
-        table is in `CREATING` or `UPDATING` states, then DynamoDB
-        returns a ResourceInUseException . If the specified table does
-        not exist, DynamoDB returns a ResourceNotFoundException . If
-        table is already in the `DELETING` state, no error is
-        returned.
-
-
-        DynamoDB might continue to accept data read and write
-        operations, such as GetItem and PutItem , on a table in the
-        `DELETING` state until the table deletion is complete.
-
-
-        When you delete a table, any indexes on that table are also
-        deleted.
-
-        Use the DescribeTable API to check the status of the table.
-
-        :type table_name: string
-        :param table_name: The name of the table to delete.
-
-        """
-        params = {'TableName': table_name, }
-        return self.make_request(action='DeleteTable',
-                                 body=json.dumps(params))
-
-    def describe_table(self, table_name):
-        """
-        Returns information about the table, including the current
-        status of the table, when it was created, the primary key
-        schema, and any indexes on the table.
-
-
-        If you issue a DescribeTable request immediately after a
-        CreateTable request, DynamoDB might return a
-        ResourceNotFoundException. This is because DescribeTable uses
-        an eventually consistent query, and the metadata for your
-        table might not be available at that moment. Wait for a few
-        seconds, and then try the DescribeTable request again.
-
-        :type table_name: string
-        :param table_name: The name of the table to describe.
-
-        """
-        params = {'TableName': table_name, }
-        return self.make_request(action='DescribeTable',
-                                 body=json.dumps(params))
-
-    def get_item(self, table_name, key, attributes_to_get=None,
-                 consistent_read=None, return_consumed_capacity=None,
-                 projection_expression=None, expression_attribute_names=None):
-        """
-        The GetItem operation returns a set of attributes for the item
-        with the given primary key. If there is no matching item,
-        GetItem does not return any data.
-
-        GetItem provides an eventually consistent read by default. If
-        your application requires a strongly consistent read, set
-        ConsistentRead to `True`. Although a strongly consistent read
-        might take more time than an eventually consistent read, it
-        always returns the last updated value.
-
-        :type table_name: string
-        :param table_name: The name of the table containing the requested item.
-
-        :type key: map
-        :param key: A map of attribute names to AttributeValue objects,
-            representing the primary key of the item to retrieve.
-        For the primary key, you must provide all of the attributes. For
-            example, with a hash type primary key, you only need to specify the
-            hash attribute. For a hash-and-range type primary key, you must
-            specify both the hash attribute and the range attribute.
-
-        :type attributes_to_get: list
-        :param attributes_to_get:
-        There is a newer parameter available. Use ProjectionExpression instead.
-            Note that if you use AttributesToGet and ProjectionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter allows you to retrieve lists or maps; however, it cannot
-            retrieve individual list or map elements.
-
-        The names of one or more attributes to retrieve. If no attribute names
-            are specified, then all attributes will be returned. If any of the
-            requested attributes are not found, they will not appear in the
-            result.
-
-        Note that AttributesToGet has no effect on provisioned throughput
-            consumption. DynamoDB determines capacity units consumed based on
-            item size, not on the amount of data that is returned to an
-            application.
-
-        :type consistent_read: boolean
-        :param consistent_read: A value that if set to `True`, then the
-            operation uses strongly consistent reads; otherwise, eventually
-            consistent reads are used.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type projection_expression: string
-        :param projection_expression: A string that identifies one or more
-            attributes to retrieve from the table. These attributes can include
-            scalars, sets, or elements of a JSON document. The attributes in
-            the expression must be separated by commas.
-        If no attribute names are specified, then all attributes will be
-            returned. If any of the requested attributes are not found, they
-            will not appear in the result.
-
-        For more information on projection expressions, go to `Accessing Item
-            Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {'TableName': table_name, 'Key': key, }
-        if attributes_to_get is not None:
-            params['AttributesToGet'] = attributes_to_get
-        if consistent_read is not None:
-            params['ConsistentRead'] = consistent_read
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if projection_expression is not None:
-            params['ProjectionExpression'] = projection_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        return self.make_request(action='GetItem',
-                                 body=json.dumps(params))
-
-    def list_tables(self, exclusive_start_table_name=None, limit=None):
-        """
-        Returns an array of table names associated with the current
-        account and endpoint. The output from ListTables is paginated,
-        with each page returning a maximum of 100 table names.
-
-        :type exclusive_start_table_name: string
-        :param exclusive_start_table_name: The first table name that this
-            operation will evaluate. Use the value that was returned for
-            LastEvaluatedTableName in a previous operation, so that you can
-            obtain the next page of results.
-
-        :type limit: integer
-        :param limit: A maximum number of table names to return. If this
-            parameter is not specified, the limit is 100.
-
-        """
-        params = {}
-        if exclusive_start_table_name is not None:
-            params['ExclusiveStartTableName'] = exclusive_start_table_name
-        if limit is not None:
-            params['Limit'] = limit
-        return self.make_request(action='ListTables',
-                                 body=json.dumps(params))
-
-    def put_item(self, table_name, item, expected=None, return_values=None,
-                 return_consumed_capacity=None,
-                 return_item_collection_metrics=None,
-                 conditional_operator=None, condition_expression=None,
-                 expression_attribute_names=None,
-                 expression_attribute_values=None):
-        """
-        Creates a new item, or replaces an old item with a new item.
-        If an item that has the same primary key as the new item
-        already exists in the specified table, the new item completely
-        replaces the existing item. You can perform a conditional put
-        operation (add a new item if one with the specified primary
-        key doesn't exist), or replace an existing item if it has
-        certain attribute values.
-
-        In addition to putting an item, you can also return the item's
-        attribute values in the same operation, using the ReturnValues
-        parameter.
-
-        When you add an item, the primary key attribute(s) are the
-        only required attributes. Attribute values cannot be null.
-        String and Binary type attributes must have lengths greater
-        than zero. Set type attributes cannot be empty. Requests with
-        empty values will be rejected with a ValidationException
-        exception.
-
-        You can request that PutItem return either a copy of the
-        original item (before the update) or a copy of the updated
-        item (after the update). For more information, see the
-        ReturnValues description below.
-
-
-        To prevent a new item from replacing an existing item, use a
-        conditional put operation with ComparisonOperator set to
-        `NULL` for the primary key attribute, or attributes.
-
-
-        For more information about using this API, see `Working with
-        Items`_ in the Amazon DynamoDB Developer Guide .
-
-        :type table_name: string
-        :param table_name: The name of the table to contain the item.
-
-        :type item: map
-        :param item: A map of attribute name/value pairs, one for each
-            attribute. Only the primary key attributes are required; you can
-            optionally provide other attribute name-value pairs for the item.
-        You must provide all of the attributes for the primary key. For
-            example, with a hash type primary key, you only need to specify the
-            hash attribute. For a hash-and-range type primary key, you must
-            specify both the hash attribute and the range attribute.
-
-        If you specify any attributes that are part of an index key, then the
-            data types for those attributes must match those of the schema in
-            the table's attribute definition.
-
-        For more information about primary keys, see `Primary Key`_ in the
-            Amazon DynamoDB Developer Guide .
-
-        Each element in the Item map is an AttributeValue object.
-
-        :type expected: map
-        :param expected:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use Expected and ConditionExpression at the same
-            time, DynamoDB will return a ValidationException exception.
-
-        This parameter does not support lists or maps.
-
-        A map of attribute/condition pairs. Expected provides a conditional
-            block for the PutItem operation.
-
-        Each element of Expected consists of an attribute name, a comparison
-            operator, and one or more values. DynamoDB compares the attribute
-            with the value(s) you supplied, using the comparison operator. For
-            each Expected element, the result of the evaluation is either true
-            or false.
-
-        If you specify more than one element in the Expected map, then by
-            default all of the conditions must evaluate to true. In other
-            words, the conditions are ANDed together. (You can use the
-            ConditionalOperator parameter to OR the conditions instead. If you
-            do this, then at least one of the conditions must evaluate to true,
-            rather than all of them.)
-
-        If the Expected map evaluates to true, then the conditional operation
-            succeeds; otherwise, it fails.
-
-        Expected contains the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              ComparisonOperator being used. For type Number, value comparisons
-              are numeric. String value comparisons for greater than, equals, or
-              less than are based on ASCII character code values. For example,
-              `a` is greater than `A`, and `a` is greater than `B`. For a list of
-              code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For type Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions.
-        + ComparisonOperator - A comparator for evaluating attributes in the
-              AttributeValueList . When performing the comparison, DynamoDB uses
-              strongly consistent reads. The following comparison operators are
-              available: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL |
-              CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` The following
-              are descriptions of each comparison operator.
-
-            + `EQ` : Equal. `EQ` is supported for all datatypes, including lists
-                and maps. AttributeValueList can contain only one AttributeValue
-                element of type String, Number, Binary, String Set, Number Set, or
-                Binary Set. If an item contains an AttributeValue element of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `NE` : Not equal. `NE` is supported for all datatypes, including
-                lists and maps. AttributeValueList can contain only one
-                AttributeValue of type String, Number, Binary, String Set, Number
-                Set, or Binary Set. If an item contains an AttributeValue of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `LE` : Less than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `LT` : Less than. AttributeValueList can contain only one
-                AttributeValue of type String, Number, or Binary (not a set type).
-                If an item contains an AttributeValue element of a different type
-                than the one specified in the request, the value does not match.
-                For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GE` : Greater than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GT` : Greater than. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  existence of an attribute, not its data type. If the data type of
-                  attribute " `a`" is null, and you evaluate it using `NOT_NULL`, the
-                  result is a Boolean true . This result is because the attribute "
-                  `a`" exists; its data type is not relevant to the `NOT_NULL`
-                  comparison operator.
-            + `NULL` : The attribute does not exist. `NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  nonexistence of an attribute, not its data type. If the data type
-                  of attribute " `a`" is null, and you evaluate it using `NULL`, the
-                  result is a Boolean false . This is because the attribute " `a`"
-                  exists; its data type is not relevant to the `NULL` comparison
-                  operator.
-            + `CONTAINS` : Checks for a subsequence, or value in a set.
-                  AttributeValueList can contain only one AttributeValue element of
-                  type String, Number, or Binary (not a set type). If the target
-                  attribute of the comparison is of type String, then the operator
-                  checks for a substring match. If the target attribute of the
-                  comparison is of type Binary, then the operator looks for a
-                  subsequence of the target that matches the input. If the target
-                  attribute of the comparison is a set (" `SS`", " `NS`", or "
-                  `BS`"), then the operator evaluates to true if it finds an exact
-                  match with any member of the set. CONTAINS is supported for lists:
-                  When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
-                  `b`" cannot be a set, a map, or a list.
-            + `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
-                  value in a set. AttributeValueList can contain only one
-                  AttributeValue element of type String, Number, or Binary (not a set
-                  type). If the target attribute of the comparison is a String, then
-                  the operator checks for the absence of a substring match. If the
-                  target attribute of the comparison is Binary, then the operator
-                  checks for the absence of a subsequence of the target that matches
-                  the input. If the target attribute of the comparison is a set ("
-                  `SS`", " `NS`", or " `BS`"), then the operator evaluates to true if
-                  it does not find an exact match with any member of the set.
-                  NOT_CONTAINS is supported for lists: When evaluating " `a NOT
-                  CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
-                  set, a map, or a list.
-            + `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
-                only one AttributeValue of type String or Binary (not a Number or a
-                set type). The target attribute of the comparison must be of type
-                String or Binary (not a Number or a set type). > <li>
-            + `IN` : Checks for matching elements within two sets.
-                  AttributeValueList can contain one or more AttributeValue elements
-                  of type String, Number, or Binary (not a set type). These
-                  attributes are compared against an existing set type attribute of
-                  an item. If any elements of the input set are present in the item
-                  attribute, the expression evaluates to true.
-            + `BETWEEN` : Greater than or equal to the first value, and less than
-                  or equal to the second value. AttributeValueList must contain two
-                  AttributeValue elements of the same type, either String, Number, or
-                  Binary (not a set type). A target attribute matches if the target
-                  value is greater than, or equal to, the first element and less
-                  than, or equal to, the second element. If an item contains an
-                  AttributeValue element of a different type than the one specified
-                  in the request, the value does not match. For example, `{"S":"6"}`
-                  does not compare to `{"N":"6"}`. Also, `{"N":"6"}` does not compare
-                  to `{"NS":["6", "2", "1"]}`
-
-
-
-        For usage examples of AttributeValueList and ComparisonOperator , see
-            `Legacy Conditional Parameters`_ in the Amazon DynamoDB Developer
-            Guide .
-
-        For backward compatibility with previous DynamoDB releases, the
-            following parameters can be used instead of AttributeValueList and
-            ComparisonOperator :
-
-
-        + Value - A value for DynamoDB to compare with an attribute.
-        + Exists - A Boolean value that causes DynamoDB to evaluate the value
-              before attempting the conditional operation:
-
-            + If Exists is `True`, DynamoDB will check to see if that attribute
-                  value already exists in the table. If it is found, then the
-                  condition evaluates to true; otherwise the condition evaluate to
-                  false.
-            + If Exists is `False`, DynamoDB assumes that the attribute value does
-                  not exist in the table. If in fact the value does not exist, then
-                  the assumption is valid and the condition evaluates to true. If the
-                  value is found, despite the assumption that it does not exist, the
-                  condition evaluates to false.
-          Note that the default value for Exists is `True`.
-
-
-        The Value and Exists parameters are incompatible with
-            AttributeValueList and ComparisonOperator . Note that if you use
-            both sets of parameters at once, DynamoDB will return a
-            ValidationException exception.
-
-        :type return_values: string
-        :param return_values:
-        Use ReturnValues if you want to get the item attributes as they
-            appeared before they were updated with the PutItem request. For
-            PutItem , the valid values are:
-
-
-        + `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
-              then nothing is returned. (This setting is the default for
-              ReturnValues .)
-        + `ALL_OLD` - If PutItem overwrote an attribute name-value pair, then
-              the content of the old item is returned.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type return_item_collection_metrics: string
-        :param return_item_collection_metrics: A value that if set to `SIZE`,
-            the response includes statistics about item collections, if any,
-            that were modified during the operation are returned in the
-            response. If set to `NONE` (the default), no statistics are
-            returned.
-
-        :type conditional_operator: string
-        :param conditional_operator:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use ConditionalOperator and ConditionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter does not support lists or maps.
-
-        A logical operator to apply to the conditions in the Expected map:
-
-
-        + `AND` - If all of the conditions evaluate to true, then the entire
-              map evaluates to true.
-        + `OR` - If at least one of the conditions evaluate to true, then the
-              entire map evaluates to true.
-
-
-        If you omit ConditionalOperator , then `AND` is the default.
-
-        The operation will succeed only if the entire map evaluates to true.
-
-        :type condition_expression: string
-        :param condition_expression: A condition that must be satisfied in
-            order for a conditional PutItem operation to succeed.
-        An expression can contain any of the following:
-
-
-        + Boolean functions: `attribute_exists | attribute_not_exists |
-              contains | begins_with` These function names are case-sensitive.
-        + Comparison operators: ` = | <> | < | > | <=
-              | >= | BETWEEN | IN`
-        + Logical operators: `AND | OR | NOT`
-
-
-        For more information on condition expressions, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_values: map
-        :param expression_attribute_values: One or more values that can be
-            substituted in an expression.
-        Use the **:** (colon) character in an expression to dereference an
-            attribute value. For example, suppose that you wanted to check
-            whether the value of the ProductStatus attribute was one of the
-            following:
-
-        `Available | Backordered | Discontinued`
-
-        You would first need to specify ExpressionAttributeValues as follows:
-
-        `{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
-            ":disc":{"S":"Discontinued"} }`
-
-        You could then use these values in an expression, such as this:
-
-        `ProductStatus IN (:avail, :back, :disc)`
-
-        For more information on expression attribute values, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {'TableName': table_name, 'Item': item, }
-        if expected is not None:
-            params['Expected'] = expected
-        if return_values is not None:
-            params['ReturnValues'] = return_values
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if return_item_collection_metrics is not None:
-            params['ReturnItemCollectionMetrics'] = return_item_collection_metrics
-        if conditional_operator is not None:
-            params['ConditionalOperator'] = conditional_operator
-        if condition_expression is not None:
-            params['ConditionExpression'] = condition_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        if expression_attribute_values is not None:
-            params['ExpressionAttributeValues'] = expression_attribute_values
-        return self.make_request(action='PutItem',
-                                 body=json.dumps(params))
-
-    def query(self, table_name, key_conditions, index_name=None, select=None,
-              attributes_to_get=None, limit=None, consistent_read=None,
-              query_filter=None, conditional_operator=None,
-              scan_index_forward=None, exclusive_start_key=None,
-              return_consumed_capacity=None, projection_expression=None,
-              filter_expression=None, expression_attribute_names=None,
-              expression_attribute_values=None):
-        """
-        A Query operation directly accesses items from a table using
-        the table primary key, or from an index using the index key.
-        You must provide a specific hash key value. You can narrow the
-        scope of the query by using comparison operators on the range
-        key value, or on the index key. You can use the
-        ScanIndexForward parameter to get results in forward or
-        reverse order, by range key or by index key.
-
-        Queries that do not return results consume the minimum number
-        of read capacity units for that type of read operation.
-
-        If the total number of items meeting the query criteria
-        exceeds the result set size limit of 1 MB, the query stops and
-        results are returned to the user with LastEvaluatedKey to
-        continue the query in a subsequent operation. Unlike a Scan
-        operation, a Query operation never returns both an empty
-        result set and a LastEvaluatedKey . The LastEvaluatedKey is
-        only provided if the results exceed 1 MB, or if you have used
-        Limit .
-
-        You can query a table, a local secondary index, or a global
-        secondary index. For a query on a table or on a local
-        secondary index, you can set ConsistentRead to true and obtain
-        a strongly consistent result. Global secondary indexes support
-        eventually consistent reads only, so do not specify
-        ConsistentRead when querying a global secondary index.
-
-        :type table_name: string
-        :param table_name: The name of the table containing the requested
-            items.
-
-        :type index_name: string
-        :param index_name: The name of an index to query. This index can be any
-            local secondary index or global secondary index on the table.
-
-        :type select: string
-        :param select: The attributes to be returned in the result. You can
-            retrieve all item attributes, specific item attributes, the count
-            of matching items, or in the case of an index, some or all of the
-            attributes projected into the index.
-
-        + `ALL_ATTRIBUTES` - Returns all of the item attributes from the
-              specified table or index. If you query a local secondary index,
-              then for each matching item in the index DynamoDB will fetch the
-              entire item from the parent table. If the index is configured to
-              project all item attributes, then all of the data can be obtained
-              from the local secondary index, and no fetching is required.
-        + `ALL_PROJECTED_ATTRIBUTES` - Allowed only when querying an index.
-              Retrieves all attributes that have been projected into the index.
-              If the index is configured to project all attributes, this return
-              value is equivalent to specifying `ALL_ATTRIBUTES`.
-        + `COUNT` - Returns the number of matching items, rather than the
-              matching items themselves.
-        + `SPECIFIC_ATTRIBUTES` - Returns only the attributes listed in
-              AttributesToGet . This return value is equivalent to specifying
-              AttributesToGet without specifying any value for Select . If you
-              query a local secondary index and request only attributes that are
-              projected into that index, the operation will read only the index
-              and not the table. If any of the requested attributes are not
-              projected into the local secondary index, DynamoDB will fetch each
-              of these attributes from the parent table. This extra fetching
-              incurs additional throughput cost and latency. If you query a
-              global secondary index, you can only request attributes that are
-              projected into the index. Global secondary index queries cannot
-              fetch attributes from the parent table.
-
-
-        If neither Select nor AttributesToGet are specified, DynamoDB defaults
-            to `ALL_ATTRIBUTES` when accessing a table, and
-            `ALL_PROJECTED_ATTRIBUTES` when accessing an index. You cannot use
-            both Select and AttributesToGet together in a single request,
-            unless the value for Select is `SPECIFIC_ATTRIBUTES`. (This usage
-            is equivalent to specifying AttributesToGet without any value for
-            Select .)
-
-        :type attributes_to_get: list
-        :param attributes_to_get:
-        There is a newer parameter available. Use ProjectionExpression instead.
-            Note that if you use AttributesToGet and ProjectionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter allows you to retrieve lists or maps; however, it cannot
-            retrieve individual list or map elements.
-
-        The names of one or more attributes to retrieve. If no attribute names
-            are specified, then all attributes will be returned. If any of the
-            requested attributes are not found, they will not appear in the
-            result.
-
-        Note that AttributesToGet has no effect on provisioned throughput
-            consumption. DynamoDB determines capacity units consumed based on
-            item size, not on the amount of data that is returned to an
-            application.
-
-        You cannot use both AttributesToGet and Select together in a Query
-            request, unless the value for Select is `SPECIFIC_ATTRIBUTES`.
-            (This usage is equivalent to specifying AttributesToGet without any
-            value for Select .)
-
-        If you query a local secondary index and request only attributes that
-            are projected into that index, the operation will read only the
-            index and not the table. If any of the requested attributes are not
-            projected into the local secondary index, DynamoDB will fetch each
-            of these attributes from the parent table. This extra fetching
-            incurs additional throughput cost and latency.
-
-        If you query a global secondary index, you can only request attributes
-            that are projected into the index. Global secondary index queries
-            cannot fetch attributes from the parent table.
-
-        :type limit: integer
-        :param limit: The maximum number of items to evaluate (not necessarily
-            the number of matching items). If DynamoDB processes the number of
-            items up to the limit while processing the results, it stops the
-            operation and returns the matching values up to that point, and a
-            key in LastEvaluatedKey to apply in a subsequent operation, so that
-            you can pick up where you left off. Also, if the processed data set
-            size exceeds 1 MB before DynamoDB reaches this limit, it stops the
-            operation and returns the matching values up to the limit, and a
-            key in LastEvaluatedKey to apply in a subsequent operation to
-            continue the operation. For more information, see `Query and Scan`_
-            in the Amazon DynamoDB Developer Guide .
-
-        :type consistent_read: boolean
-        :param consistent_read: A value that if set to `True`, then the
-            operation uses strongly consistent reads; otherwise, eventually
-            consistent reads are used.
-        Strongly consistent reads are not supported on global secondary
-            indexes. If you query a global secondary index with ConsistentRead
-            set to `True`, you will receive an error message.
-
-        :type key_conditions: map
-        :param key_conditions: The selection criteria for the query. For a
-            query on a table, you can have conditions only on the table primary
-            key attributes. You must specify the hash key attribute name and
-            value as an `EQ` condition. You can optionally specify a second
-            condition, referring to the range key attribute. If you do not
-            specify a range key condition, all items under the hash key will be
-            fetched and processed. Any filters will applied after this.
-        For a query on an index, you can have conditions only on the index key
-            attributes. You must specify the index hash attribute name and
-            value as an EQ condition. You can optionally specify a second
-            condition, referring to the index key range attribute.
-
-        Each KeyConditions element consists of an attribute name to compare,
-            along with the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              ComparisonOperator being used. For type Number, value comparisons
-              are numeric. String value comparisons for greater than, equals, or
-              less than are based on ASCII character code values. For example,
-              `a` is greater than `A`, and `a` is greater than `B`. For a list of
-              code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions.
-        + ComparisonOperator - A comparator for evaluating attributes, for
-              example, equals, greater than, less than, and so on. For
-              KeyConditions , only the following comparison operators are
-              supported: `EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN` The
-              following are descriptions of these comparison operators.
-
-            + `EQ` : Equal. AttributeValueList can contain only one AttributeValue
-                  of type String, Number, or Binary (not a set type). If an item
-                  contains an AttributeValue element of a different type than the one
-                  specified in the request, the value does not match. For example,
-                  `{"S":"6"}` does not equal `{"N":"6"}`. Also, `{"N":"6"}` does not
-                  equal `{"NS":["6", "2", "1"]}`.
-            + `LE` : Less than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `LT` : Less than. AttributeValueList can contain only one
-                AttributeValue of type String, Number, or Binary (not a set type).
-                If an item contains an AttributeValue element of a different type
-                than the one specified in the request, the value does not match.
-                For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GE` : Greater than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GT` : Greater than. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
-                only one AttributeValue of type String or Binary (not a Number or a
-                set type). The target attribute of the comparison must be of type
-                String or Binary (not a Number or a set type). > <li>
-            + `BETWEEN` : Greater than or equal to the first value, and less than
-                  or equal to the second value. AttributeValueList must contain two
-                  AttributeValue elements of the same type, either String, Number, or
-                  Binary (not a set type). A target attribute matches if the target
-                  value is greater than, or equal to, the first element and less
-                  than, or equal to, the second element. If an item contains an
-                  AttributeValue element of a different type than the one specified
-                  in the request, the value does not match. For example, `{"S":"6"}`
-                  does not compare to `{"N":"6"}`. Also, `{"N":"6"}` does not compare
-                  to `{"NS":["6", "2", "1"]}`
-
-
-
-        For usage examples of AttributeValueList and ComparisonOperator , see
-            `Legacy Conditional Parameters`_ in the Amazon DynamoDB Developer
-            Guide .
-
-        :type query_filter: map
-        :param query_filter:
-        There is a newer parameter available. Use FilterExpression instead.
-            Note that if you use QueryFilter and FilterExpression at the same
-            time, DynamoDB will return a ValidationException exception.
-
-        This parameter does not support lists or maps.
-
-        A condition that evaluates the query results after the items are read
-            and returns only the desired values.
-        Query filters are applied after the items are read, so they do not
-            limit the capacity used.
-        If you specify more than one condition in the QueryFilter map, then by
-            default all of the conditions must evaluate to true. In other
-            words, the conditions are ANDed together. (You can use the
-            ConditionalOperator parameter to OR the conditions instead. If you
-            do this, then at least one of the conditions must evaluate to true,
-            rather than all of them.)
-
-
-        QueryFilter does not allow key attributes. You cannot define a filter
-            condition on a hash key or range key.
-
-
-        Each QueryFilter element consists of an attribute name to compare,
-            along with the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              operator specified in ComparisonOperator . For type Number, value
-              comparisons are numeric. String value comparisons for greater than,
-              equals, or less than are based on ASCII character code values. For
-              example, `a` is greater than `A`, and `a` is greater than `B`. For
-              a list of code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For type Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions. For information on specifying data
-              types in JSON, see `JSON Data Format`_ in the Amazon DynamoDB
-              Developer Guide .
-        + ComparisonOperator - A comparator for evaluating attributes. For
-              example, equals, greater than, less than, etc. The following
-              comparison operators are available: `EQ | NE | LE | LT | GE | GT |
-              NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN |
-              BETWEEN` For complete descriptions of all comparison operators, see
-              `API_Condition.html`_.
-
-        :type conditional_operator: string
-        :param conditional_operator:
-        This parameter does not support lists or maps.
-
-        A logical operator to apply to the conditions in the QueryFilter map:
-
-
-        + `AND` - If all of the conditions evaluate to true, then the entire
-              map evaluates to true.
-        + `OR` - If at least one of the conditions evaluate to true, then the
-              entire map evaluates to true.
-
-
-        If you omit ConditionalOperator , then `AND` is the default.
-
-        The operation will succeed only if the entire map evaluates to true.
-
-        :type scan_index_forward: boolean
-        :param scan_index_forward: A value that specifies ascending (true) or
-            descending (false) traversal of the index. DynamoDB returns results
-            reflecting the requested order determined by the range key. If the
-            data type is Number, the results are returned in numeric order. For
-            type String, the results are returned in order of ASCII character
-            code values. For type Binary, DynamoDB treats each byte of the
-            binary data as unsigned when it compares binary values.
-        If ScanIndexForward is not specified, the results are returned in
-            ascending order.
-
-        :type exclusive_start_key: map
-        :param exclusive_start_key: The primary key of the first item that this
-            operation will evaluate. Use the value that was returned for
-            LastEvaluatedKey in the previous operation.
-        The data type for ExclusiveStartKey must be String, Number or Binary.
-            No set data types are allowed.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type projection_expression: string
-        :param projection_expression: A string that identifies one or more
-            attributes to retrieve from the table. These attributes can include
-            scalars, sets, or elements of a JSON document. The attributes in
-            the expression must be separated by commas.
-        If no attribute names are specified, then all attributes will be
-            returned. If any of the requested attributes are not found, they
-            will not appear in the result.
-
-        For more information on projection expressions, go to `Accessing Item
-            Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type filter_expression: string
-        :param filter_expression: A condition that evaluates the query results
-            after the items are read and returns only the desired values.
-        The condition you specify is applied to the items queried; any items
-            that do not match the expression are not returned.
-        Filter expressions are applied after the items are read, so they do not
-            limit the capacity used.
-        A FilterExpression has the same syntax as a ConditionExpression . For
-            more information on expression syntax, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_values: map
-        :param expression_attribute_values: One or more values that can be
-            substituted in an expression.
-        Use the **:** (colon) character in an expression to dereference an
-            attribute value. For example, suppose that you wanted to check
-            whether the value of the ProductStatus attribute was one of the
-            following:
-
-        `Available | Backordered | Discontinued`
-
-        You would first need to specify ExpressionAttributeValues as follows:
-
-        `{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
-            ":disc":{"S":"Discontinued"} }`
-
-        You could then use these values in an expression, such as this:
-
-        `ProductStatus IN (:avail, :back, :disc)`
-
-        For more information on expression attribute values, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {
-            'TableName': table_name,
-            'KeyConditions': key_conditions,
-        }
-        if index_name is not None:
-            params['IndexName'] = index_name
-        if select is not None:
-            params['Select'] = select
-        if attributes_to_get is not None:
-            params['AttributesToGet'] = attributes_to_get
-        if limit is not None:
-            params['Limit'] = limit
-        if consistent_read is not None:
-            params['ConsistentRead'] = consistent_read
-        if query_filter is not None:
-            params['QueryFilter'] = query_filter
-        if conditional_operator is not None:
-            params['ConditionalOperator'] = conditional_operator
-        if scan_index_forward is not None:
-            params['ScanIndexForward'] = scan_index_forward
-        if exclusive_start_key is not None:
-            params['ExclusiveStartKey'] = exclusive_start_key
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if projection_expression is not None:
-            params['ProjectionExpression'] = projection_expression
-        if filter_expression is not None:
-            params['FilterExpression'] = filter_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        if expression_attribute_values is not None:
-            params['ExpressionAttributeValues'] = expression_attribute_values
-        return self.make_request(action='Query',
-                                 body=json.dumps(params))
-
-    def scan(self, table_name, attributes_to_get=None, limit=None,
-             select=None, scan_filter=None, conditional_operator=None,
-             exclusive_start_key=None, return_consumed_capacity=None,
-             total_segments=None, segment=None, projection_expression=None,
-             filter_expression=None, expression_attribute_names=None,
-             expression_attribute_values=None):
-        """
-        The Scan operation returns one or more items and item
-        attributes by accessing every item in the table. To have
-        DynamoDB return fewer items, you can provide a ScanFilter
-        operation.
-
-        If the total number of scanned items exceeds the maximum data
-        set size limit of 1 MB, the scan stops and results are
-        returned to the user as a LastEvaluatedKey value to continue
-        the scan in a subsequent operation. The results also include
-        the number of items exceeding the limit. A scan can result in
-        no table data meeting the filter criteria.
-
-        The result set is eventually consistent.
-
-        By default, Scan operations proceed sequentially; however, for
-        faster performance on large tables, applications can request a
-        parallel Scan operation by specifying the Segment and
-        TotalSegments parameters. For more information, see `Parallel
-        Scan`_ in the Amazon DynamoDB Developer Guide .
-
-        :type table_name: string
-        :param table_name: The name of the table containing the requested
-            items.
-
-        :type attributes_to_get: list
-        :param attributes_to_get:
-        There is a newer parameter available. Use ProjectionExpression instead.
-            Note that if you use AttributesToGet and ProjectionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter allows you to retrieve lists or maps; however, it cannot
-            retrieve individual list or map elements.
-
-        The names of one or more attributes to retrieve. If no attribute names
-            are specified, then all attributes will be returned. If any of the
-            requested attributes are not found, they will not appear in the
-            result.
-
-        Note that AttributesToGet has no effect on provisioned throughput
-            consumption. DynamoDB determines capacity units consumed based on
-            item size, not on the amount of data that is returned to an
-            application.
-
-        :type limit: integer
-        :param limit: The maximum number of items to evaluate (not necessarily
-            the number of matching items). If DynamoDB processes the number of
-            items up to the limit while processing the results, it stops the
-            operation and returns the matching values up to that point, and a
-            key in LastEvaluatedKey to apply in a subsequent operation, so that
-            you can pick up where you left off. Also, if the processed data set
-            size exceeds 1 MB before DynamoDB reaches this limit, it stops the
-            operation and returns the matching values up to the limit, and a
-            key in LastEvaluatedKey to apply in a subsequent operation to
-            continue the operation. For more information, see `Query and Scan`_
-            in the Amazon DynamoDB Developer Guide .
-
-        :type select: string
-        :param select: The attributes to be returned in the result. You can
-            retrieve all item attributes, specific item attributes, or the
-            count of matching items.
-
-        + `ALL_ATTRIBUTES` - Returns all of the item attributes.
-        + `COUNT` - Returns the number of matching items, rather than the
-              matching items themselves.
-        + `SPECIFIC_ATTRIBUTES` - Returns only the attributes listed in
-              AttributesToGet . This return value is equivalent to specifying
-              AttributesToGet without specifying any value for Select .
-
-
-        If neither Select nor AttributesToGet are specified, DynamoDB defaults
-            to `ALL_ATTRIBUTES`. You cannot use both AttributesToGet and Select
-            together in a single request, unless the value for Select is
-            `SPECIFIC_ATTRIBUTES`. (This usage is equivalent to specifying
-            AttributesToGet without any value for Select .)
-
-        :type scan_filter: map
-        :param scan_filter:
-        There is a newer parameter available. Use FilterExpression instead.
-            Note that if you use ScanFilter and FilterExpression at the same
-            time, DynamoDB will return a ValidationException exception.
-
-        This parameter does not support lists or maps.
-
-        A condition that evaluates the scan results and returns only the
-            desired values.
-
-        If you specify more than one condition in the ScanFilter map, then by
-            default all of the conditions must evaluate to true. In other
-            words, the conditions are ANDed together. (You can use the
-            ConditionalOperator parameter to OR the conditions instead. If you
-            do this, then at least one of the conditions must evaluate to true,
-            rather than all of them.)
-
-        Each ScanFilter element consists of an attribute name to compare, along
-            with the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              operator specified in ComparisonOperator . For type Number, value
-              comparisons are numeric. String value comparisons for greater than,
-              equals, or less than are based on ASCII character code values. For
-              example, `a` is greater than `A`, and `a` is greater than `B`. For
-              a list of code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions. For information on specifying data
-              types in JSON, see `JSON Data Format`_ in the Amazon DynamoDB
-              Developer Guide .
-        + ComparisonOperator - A comparator for evaluating attributes. For
-              example, equals, greater than, less than, etc. The following
-              comparison operators are available: `EQ | NE | LE | LT | GE | GT |
-              NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN |
-              BETWEEN` For complete descriptions of all comparison operators, see
-              `Condition`_.
-
-        :type conditional_operator: string
-        :param conditional_operator:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use ConditionalOperator and ConditionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter does not support lists or maps.
-
-        A logical operator to apply to the conditions in the ScanFilter map:
-
-
-        + `AND` - If all of the conditions evaluate to true, then the entire
-              map evaluates to true.
-        + `OR` - If at least one of the conditions evaluate to true, then the
-              entire map evaluates to true.
-
-
-        If you omit ConditionalOperator , then `AND` is the default.
-
-        The operation will succeed only if the entire map evaluates to true.
-
-        :type exclusive_start_key: map
-        :param exclusive_start_key: The primary key of the first item that this
-            operation will evaluate. Use the value that was returned for
-            LastEvaluatedKey in the previous operation.
-        The data type for ExclusiveStartKey must be String, Number or Binary.
-            No set data types are allowed.
-
-        In a parallel scan, a Scan request that includes ExclusiveStartKey must
-            specify the same segment whose previous Scan returned the
-            corresponding value of LastEvaluatedKey .
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type total_segments: integer
-        :param total_segments: For a parallel Scan request, TotalSegments
-            represents the total number of segments into which the Scan
-            operation will be divided. The value of TotalSegments corresponds
-            to the number of application workers that will perform the parallel
-            scan. For example, if you want to scan a table using four
-            application threads, specify a TotalSegments value of 4.
-        The value for TotalSegments must be greater than or equal to 1, and
-            less than or equal to 1000000. If you specify a TotalSegments value
-            of 1, the Scan operation will be sequential rather than parallel.
-
-        If you specify TotalSegments , you must also specify Segment .
-
-        :type segment: integer
-        :param segment: For a parallel Scan request, Segment identifies an
-            individual segment to be scanned by an application worker.
-        Segment IDs are zero-based, so the first segment is always 0. For
-            example, if you want to scan a table using four application
-            threads, the first thread specifies a Segment value of 0, the
-            second thread specifies 1, and so on.
-
-        The value of LastEvaluatedKey returned from a parallel Scan request
-            must be used as ExclusiveStartKey with the same segment ID in a
-            subsequent Scan operation.
-
-        The value for Segment must be greater than or equal to 0, and less than
-            the value provided for TotalSegments .
-
-        If you specify Segment , you must also specify TotalSegments .
-
-        :type projection_expression: string
-        :param projection_expression: A string that identifies one or more
-            attributes to retrieve from the table. These attributes can include
-            scalars, sets, or elements of a JSON document. The attributes in
-            the expression must be separated by commas.
-        If no attribute names are specified, then all attributes will be
-            returned. If any of the requested attributes are not found, they
-            will not appear in the result.
-
-        For more information on projection expressions, go to `Accessing Item
-            Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type filter_expression: string
-        :param filter_expression: A condition that evaluates the scan results
-            and returns only the desired values.
-        The condition you specify is applied to the items scanned; any items
-            that do not match the expression are not returned.
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_values: map
-        :param expression_attribute_values: One or more values that can be
-            substituted in an expression.
-        Use the **:** (colon) character in an expression to dereference an
-            attribute value. For example, suppose that you wanted to check
-            whether the value of the ProductStatus attribute was one of the
-            following:
-
-        `Available | Backordered | Discontinued`
-
-        You would first need to specify ExpressionAttributeValues as follows:
-
-        `{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
-            ":disc":{"S":"Discontinued"} }`
-
-        You could then use these values in an expression, such as this:
-
-        `ProductStatus IN (:avail, :back, :disc)`
-
-        For more information on expression attribute values, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {'TableName': table_name, }
-        if attributes_to_get is not None:
-            params['AttributesToGet'] = attributes_to_get
-        if limit is not None:
-            params['Limit'] = limit
-        if select is not None:
-            params['Select'] = select
-        if scan_filter is not None:
-            params['ScanFilter'] = scan_filter
-        if conditional_operator is not None:
-            params['ConditionalOperator'] = conditional_operator
-        if exclusive_start_key is not None:
-            params['ExclusiveStartKey'] = exclusive_start_key
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if total_segments is not None:
-            params['TotalSegments'] = total_segments
-        if segment is not None:
-            params['Segment'] = segment
-        if projection_expression is not None:
-            params['ProjectionExpression'] = projection_expression
-        if filter_expression is not None:
-            params['FilterExpression'] = filter_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        if expression_attribute_values is not None:
-            params['ExpressionAttributeValues'] = expression_attribute_values
-        return self.make_request(action='Scan',
-                                 body=json.dumps(params))
-
-    def update_item(self, table_name, key, attribute_updates=None,
-                    expected=None, conditional_operator=None,
-                    return_values=None, return_consumed_capacity=None,
-                    return_item_collection_metrics=None,
-                    update_expression=None, condition_expression=None,
-                    expression_attribute_names=None,
-                    expression_attribute_values=None):
-        """
-        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 (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).
-
-        You can also return the item's attribute values in the same
-        UpdateItem operation using the ReturnValues parameter.
-
-        :type table_name: string
-        :param table_name: The name of the table containing the item to update.
-
-        :type key: map
-        :param key: The primary key of the item to be updated. Each element
-            consists of an attribute name and a value for that attribute.
-        For the primary key, you must provide all of the attributes. For
-            example, with a hash type primary key, you only need to specify the
-            hash attribute. For a hash-and-range type primary key, you must
-            specify both the hash attribute and the range attribute.
-
-        :type attribute_updates: map
-        :param attribute_updates:
-        There is a newer parameter available. Use UpdateExpression instead.
-            Note that if you use AttributeUpdates and UpdateExpression at the
-            same time, DynamoDB will return a ValidationException exception.
-
-        This parameter can be used for modifying top-level attributes; however,
-            it does not support individual list or map elements.
-
-        The names of attributes to be modified, the action to perform on each,
-            and the new value for each. If you are updating an attribute that
-            is an index key attribute for any indexes on that table, the
-            attribute type must match the index key type defined in the
-            AttributesDefinition of the table description. You can use
-            UpdateItem to update any nonkey attributes.
-
-        Attribute values cannot be null. String and Binary type attributes must
-            have lengths greater than zero. Set type attributes must not be
-            empty. Requests with empty values will be rejected with a
-            ValidationException exception.
-
-        Each AttributeUpdates element consists of an attribute name to modify,
-            along with the following:
-
-
-        + Value - The new value, if applicable, for this attribute.
-        + Action - A value that specifies how to perform the update. This
-              action is only valid for an existing attribute whose data type is
-              Number or is a set; do not use `ADD` for other data types. If an
-              item with the specified primary key is found in the table, the
-              following values perform the following actions:
-
-            + `PUT` - Adds the specified attribute to the item. If the attribute
-                  already exists, it is replaced by the new value.
-            + `DELETE` - Removes the attribute and its value, if no value is
-                  specified for `DELETE`. The data type of the specified value must
-                  match the existing value's data type. If a set of values is
-                  specified, then those values are subtracted from the old set. For
-                  example, if the attribute value was the set `[a,b,c]` and the
-                  `DELETE` action specifies `[a,c]`, then the final attribute value
-                  is `[b]`. Specifying an empty set is an error.
-            + `ADD` - Adds the specified value to the item, if the attribute does
-                  not already exist. If the attribute does exist, then the behavior
-                  of `ADD` depends on the data type of the attribute:
-
-                + If the existing attribute is a number, and if Value is also a number,
-                      then Value is mathematically added to the existing attribute. If
-                      Value is a negative number, then it is subtracted from the existing
-                      attribute. If you use `ADD` to increment or decrement a number
-                      value for an item that doesn't exist before the update, DynamoDB
-                      uses 0 as the initial value. Similarly, if you use `ADD` for an
-                      existing item to increment or decrement an attribute value that
-                      doesn't exist before the update, DynamoDB uses `0` as the initial
-                      value. For example, suppose that the item you want to update
-                      doesn't have an attribute named itemcount , but you decide to `ADD`
-                      the number `3` to this attribute anyway. DynamoDB will create the
-                      itemcount attribute, set its initial value to `0`, and finally add
-                      `3` to it. The result will be a new itemcount attribute, with a
-                      value of `3`.
-                + If the existing data type is a set, and if Value is also a set, then
-                      Value is appended to the existing set. For example, if the
-                      attribute value is the set `[1,2]`, and the `ADD` action specified
-                      `[3]`, then the final attribute value is `[1,2,3]`. An error occurs
-                      if an `ADD` action is specified for a set attribute and the
-                      attribute type specified does not match the existing set type. Both
-                      sets must have the same primitive data type. For example, if the
-                      existing data type is a set of strings, Value must also be a set of
-                      strings.
-
-          If no item with the specified key is found in the table, the following
-              values perform the following actions:
-
-            + `PUT` - Causes DynamoDB to create a new item with the specified
-                  primary key, and then adds the attribute.
-            + `DELETE` - Nothing happens, because attributes cannot be deleted from
-                  a nonexistent item. The operation succeeds, but DynamoDB does not
-                  create a new item.
-            + `ADD` - Causes DynamoDB to create an item with the supplied primary
-                  key and number (or set of numbers) for the attribute value. The
-                  only data types allowed are Number and Number Set.
-
-
-
-        If you specify any attributes that are part of an index key, then the
-            data types for those attributes must match those of the schema in
-            the table's attribute definition.
-
-        :type expected: map
-        :param expected:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use Expected and ConditionExpression at the same
-            time, DynamoDB will return a ValidationException exception.
-
-        This parameter does not support lists or maps.
-
-        A map of attribute/condition pairs. Expected provides a conditional
-            block for the UpdateItem operation.
-
-        Each element of Expected consists of an attribute name, a comparison
-            operator, and one or more values. DynamoDB compares the attribute
-            with the value(s) you supplied, using the comparison operator. For
-            each Expected element, the result of the evaluation is either true
-            or false.
-
-        If you specify more than one element in the Expected map, then by
-            default all of the conditions must evaluate to true. In other
-            words, the conditions are ANDed together. (You can use the
-            ConditionalOperator parameter to OR the conditions instead. If you
-            do this, then at least one of the conditions must evaluate to true,
-            rather than all of them.)
-
-        If the Expected map evaluates to true, then the conditional operation
-            succeeds; otherwise, it fails.
-
-        Expected contains the following:
-
-
-        + AttributeValueList - One or more values to evaluate against the
-              supplied attribute. The number of values in the list depends on the
-              ComparisonOperator being used. For type Number, value comparisons
-              are numeric. String value comparisons for greater than, equals, or
-              less than are based on ASCII character code values. For example,
-              `a` is greater than `A`, and `a` is greater than `B`. For a list of
-              code values, see
-              `http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters`_.
-              For type Binary, DynamoDB treats each byte of the binary data as
-              unsigned when it compares binary values, for example when
-              evaluating query expressions.
-        + ComparisonOperator - A comparator for evaluating attributes in the
-              AttributeValueList . When performing the comparison, DynamoDB uses
-              strongly consistent reads. The following comparison operators are
-              available: `EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL |
-              CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN` The following
-              are descriptions of each comparison operator.
-
-            + `EQ` : Equal. `EQ` is supported for all datatypes, including lists
-                and maps. AttributeValueList can contain only one AttributeValue
-                element of type String, Number, Binary, String Set, Number Set, or
-                Binary Set. If an item contains an AttributeValue element of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `NE` : Not equal. `NE` is supported for all datatypes, including
-                lists and maps. AttributeValueList can contain only one
-                AttributeValue of type String, Number, Binary, String Set, Number
-                Set, or Binary Set. If an item contains an AttributeValue of a
-                different type than the one specified in the request, the value
-                does not match. For example, `{"S":"6"}` does not equal
-                `{"N":"6"}`. Also, `{"N":"6"}` does not equal `{"NS":["6", "2",
-                "1"]}`. > <li>
-            + `LE` : Less than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `LT` : Less than. AttributeValueList can contain only one
-                AttributeValue of type String, Number, or Binary (not a set type).
-                If an item contains an AttributeValue element of a different type
-                than the one specified in the request, the value does not match.
-                For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GE` : Greater than or equal. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `GT` : Greater than. AttributeValueList can contain only one
-                AttributeValue element of type String, Number, or Binary (not a set
-                type). If an item contains an AttributeValue element of a different
-                type than the one specified in the request, the value does not
-                match. For example, `{"S":"6"}` does not equal `{"N":"6"}`. Also,
-                `{"N":"6"}` does not compare to `{"NS":["6", "2", "1"]}`. > <li>
-            + `NOT_NULL` : The attribute exists. `NOT_NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  existence of an attribute, not its data type. If the data type of
-                  attribute " `a`" is null, and you evaluate it using `NOT_NULL`, the
-                  result is a Boolean true . This result is because the attribute "
-                  `a`" exists; its data type is not relevant to the `NOT_NULL`
-                  comparison operator.
-            + `NULL` : The attribute does not exist. `NULL` is supported for all
-                  datatypes, including lists and maps. This operator tests for the
-                  nonexistence of an attribute, not its data type. If the data type
-                  of attribute " `a`" is null, and you evaluate it using `NULL`, the
-                  result is a Boolean false . This is because the attribute " `a`"
-                  exists; its data type is not relevant to the `NULL` comparison
-                  operator.
-            + `CONTAINS` : Checks for a subsequence, or value in a set.
-                  AttributeValueList can contain only one AttributeValue element of
-                  type String, Number, or Binary (not a set type). If the target
-                  attribute of the comparison is of type String, then the operator
-                  checks for a substring match. If the target attribute of the
-                  comparison is of type Binary, then the operator looks for a
-                  subsequence of the target that matches the input. If the target
-                  attribute of the comparison is a set (" `SS`", " `NS`", or "
-                  `BS`"), then the operator evaluates to true if it finds an exact
-                  match with any member of the set. CONTAINS is supported for lists:
-                  When evaluating " `a CONTAINS b`", " `a`" can be a list; however, "
-                  `b`" cannot be a set, a map, or a list.
-            + `NOT_CONTAINS` : Checks for absence of a subsequence, or absence of a
-                  value in a set. AttributeValueList can contain only one
-                  AttributeValue element of type String, Number, or Binary (not a set
-                  type). If the target attribute of the comparison is a String, then
-                  the operator checks for the absence of a substring match. If the
-                  target attribute of the comparison is Binary, then the operator
-                  checks for the absence of a subsequence of the target that matches
-                  the input. If the target attribute of the comparison is a set ("
-                  `SS`", " `NS`", or " `BS`"), then the operator evaluates to true if
-                  it does not find an exact match with any member of the set.
-                  NOT_CONTAINS is supported for lists: When evaluating " `a NOT
-                  CONTAINS b`", " `a`" can be a list; however, " `b`" cannot be a
-                  set, a map, or a list.
-            + `BEGINS_WITH` : Checks for a prefix. AttributeValueList can contain
-                only one AttributeValue of type String or Binary (not a Number or a
-                set type). The target attribute of the comparison must be of type
-                String or Binary (not a Number or a set type). > <li>
-            + `IN` : Checks for matching elements within two sets.
-                  AttributeValueList can contain one or more AttributeValue elements
-                  of type String, Number, or Binary (not a set type). These
-                  attributes are compared against an existing set type attribute of
-                  an item. If any elements of the input set are present in the item
-                  attribute, the expression evaluates to true.
-            + `BETWEEN` : Greater than or equal to the first value, and less than
-                  or equal to the second value. AttributeValueList must contain two
-                  AttributeValue elements of the same type, either String, Number, or
-                  Binary (not a set type). A target attribute matches if the target
-                  value is greater than, or equal to, the first element and less
-                  than, or equal to, the second element. If an item contains an
-                  AttributeValue element of a different type than the one specified
-                  in the request, the value does not match. For example, `{"S":"6"}`
-                  does not compare to `{"N":"6"}`. Also, `{"N":"6"}` does not compare
-                  to `{"NS":["6", "2", "1"]}`
-
-
-
-        For usage examples of AttributeValueList and ComparisonOperator , see
-            `Legacy Conditional Parameters`_ in the Amazon DynamoDB Developer
-            Guide .
-
-        For backward compatibility with previous DynamoDB releases, the
-            following parameters can be used instead of AttributeValueList and
-            ComparisonOperator :
-
-
-        + Value - A value for DynamoDB to compare with an attribute.
-        + Exists - A Boolean value that causes DynamoDB to evaluate the value
-              before attempting the conditional operation:
-
-            + If Exists is `True`, DynamoDB will check to see if that attribute
-                  value already exists in the table. If it is found, then the
-                  condition evaluates to true; otherwise the condition evaluate to
-                  false.
-            + If Exists is `False`, DynamoDB assumes that the attribute value does
-                  not exist in the table. If in fact the value does not exist, then
-                  the assumption is valid and the condition evaluates to true. If the
-                  value is found, despite the assumption that it does not exist, the
-                  condition evaluates to false.
-          Note that the default value for Exists is `True`.
-
-
-        The Value and Exists parameters are incompatible with
-            AttributeValueList and ComparisonOperator . Note that if you use
-            both sets of parameters at once, DynamoDB will return a
-            ValidationException exception.
-
-        :type conditional_operator: string
-        :param conditional_operator:
-        There is a newer parameter available. Use ConditionExpression instead.
-            Note that if you use ConditionalOperator and ConditionExpression at
-            the same time, DynamoDB will return a ValidationException
-            exception.
-
-        This parameter does not support lists or maps.
-
-        A logical operator to apply to the conditions in the Expected map:
-
-
-        + `AND` - If all of the conditions evaluate to true, then the entire
-              map evaluates to true.
-        + `OR` - If at least one of the conditions evaluate to true, then the
-              entire map evaluates to true.
-
-
-        If you omit ConditionalOperator , then `AND` is the default.
-
-        The operation will succeed only if the entire map evaluates to true.
-
-        :type return_values: string
-        :param return_values:
-        Use ReturnValues if you want to get the item attributes as they
-            appeared either before or after they were updated. For UpdateItem ,
-            the valid values are:
-
-
-        + `NONE` - If ReturnValues is not specified, or if its value is `NONE`,
-              then nothing is returned. (This setting is the default for
-              ReturnValues .)
-        + `ALL_OLD` - If UpdateItem overwrote an attribute name-value pair,
-              then the content of the old item is returned.
-        + `UPDATED_OLD` - The old versions of only the updated attributes are
-              returned.
-        + `ALL_NEW` - All of the attributes of the new version of the item are
-              returned.
-        + `UPDATED_NEW` - The new versions of only the updated attributes are
-              returned.
-
-        :type return_consumed_capacity: string
-        :param return_consumed_capacity: A value that if set to `TOTAL`, the
-            response includes ConsumedCapacity data for tables and indexes. If
-            set to `INDEXES`, the response includes ConsumedCapacity for
-            indexes. If set to `NONE` (the default), ConsumedCapacity is not
-            included in the response.
-
-        :type return_item_collection_metrics: string
-        :param return_item_collection_metrics: A value that if set to `SIZE`,
-            the response includes statistics about item collections, if any,
-            that were modified during the operation are returned in the
-            response. If set to `NONE` (the default), no statistics are
-            returned.
-
-        :type update_expression: string
-        :param 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.
-        The following action values are available for UpdateExpression .
-
-
-        + `SET` - Adds one or more attributes and values to an item. If any of
-              these attribute already exist, they are replaced by the new values.
-              You can also use `SET` to add or subtract from an attribute that is
-              of type Number. `SET` supports the following functions:
-
-            + `if_not_exists (path, operand)` - if the item does not contain an
-                  attribute at the specified path, then `if_not_exists` evaluates to
-                  operand; otherwise, it evaluates to path. You can use this function
-                  to avoid overwriting an attribute that may already be present in
-                  the item.
-            + `list_append (operand, operand)` - evaluates to a list with a new
-                  element added to it. You can append the new element to the start or
-                  the end of the list by reversing the order of the operands.
-          These function names are case-sensitive.
-        + `REMOVE` - Removes one or more attributes from an item.
-        + `ADD` - Adds the specified value to the item, if the attribute does
-              not already exist. If the attribute does exist, then the behavior
-              of `ADD` depends on the data type of the attribute:
-
-            + If the existing attribute is a number, and if Value is also a number,
-                  then Value is mathematically added to the existing attribute. If
-                  Value is a negative number, then it is subtracted from the existing
-                  attribute. If you use `ADD` to increment or decrement a number
-                  value for an item that doesn't exist before the update, DynamoDB
-                  uses `0` as the initial value. Similarly, if you use `ADD` for an
-                  existing item to increment or decrement an attribute value that
-                  doesn't exist before the update, DynamoDB uses `0` as the initial
-                  value. For example, suppose that the item you want to update
-                  doesn't have an attribute named itemcount , but you decide to `ADD`
-                  the number `3` to this attribute anyway. DynamoDB will create the
-                  itemcount attribute, set its initial value to `0`, and finally add
-                  `3` to it. The result will be a new itemcount attribute in the
-                  item, with a value of `3`.
-            + If the existing data type is a set and if Value is also a set, then
-                  Value is added to the existing set. For example, if the attribute
-                  value is the set `[1,2]`, and the `ADD` action specified `[3]`,
-                  then the final attribute value is `[1,2,3]`. An error occurs if an
-                  `ADD` action is specified for a set attribute and the attribute
-                  type specified does not match the existing set type. Both sets must
-                  have the same primitive data type. For example, if the existing
-                  data type is a set of strings, the Value must also be a set of
-                  strings.
-          The `ADD` action only supports Number and set data types. In addition,
-              `ADD` can only be used on top-level attributes, not nested
-              attributes.
-        + `DELETE` - Deletes an element from a set. If a set of values is
-              specified, then those values are subtracted from the old set. For
-              example, if the attribute value was the set `[a,b,c]` and the
-              `DELETE` action specifies `[a,c]`, then the final attribute value
-              is `[b]`. Specifying an empty set is an error. The `DELETE` action
-              only supports Number and set data types. In addition, `DELETE` can
-              only be used on top-level attributes, not nested attributes.
-
-
-        You can have many actions in a single expression, such as the
-            following: `SET a=:value1, b=:value2 DELETE :value3, :value4,
-            :value5`
-
-        For more information on update expressions, go to `Modifying Items and
-            Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type condition_expression: string
-        :param condition_expression: A condition that must be satisfied in
-            order for a conditional update to succeed.
-        An expression can contain any of the following:
-
-
-        + Boolean functions: `attribute_exists | attribute_not_exists |
-              contains | begins_with` These function names are case-sensitive.
-        + Comparison operators: ` = | <> | < | > | <=
-              | >= | BETWEEN | IN`
-        + Logical operators: `AND | OR | NOT`
-
-
-        For more information on condition expressions, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_names: map
-        :param expression_attribute_names: One or more substitution tokens for
-            simplifying complex expressions. The following are some use cases
-            for using ExpressionAttributeNames :
-
-        + To shorten an attribute name that is very long or unwieldy in an
-              expression.
-        + To create a placeholder for repeating occurrences of an attribute
-              name in an expression.
-        + To prevent special characters in an attribute name from being
-              misinterpreted in an expression.
-
-
-        Use the **#** character in an expression to dereference an attribute
-            name. For example, consider the following expression:
-
-
-        + `order.customerInfo.LastName = "Smith" OR order.customerInfo.LastName
-              = "Jones"`
-
-
-        Now suppose that you specified the following for
-            ExpressionAttributeNames :
-
-
-        + `{"#name":"order.customerInfo.LastName"}`
-
-
-        The expression can now be simplified as follows:
-
-
-        + `#name = "Smith" OR #name = "Jones"`
-
-
-        For more information on expression attribute names, go to `Accessing
-            Item Attributes`_ in the Amazon DynamoDB Developer Guide .
-
-        :type expression_attribute_values: map
-        :param expression_attribute_values: One or more values that can be
-            substituted in an expression.
-        Use the **:** (colon) character in an expression to dereference an
-            attribute value. For example, suppose that you wanted to check
-            whether the value of the ProductStatus attribute was one of the
-            following:
-
-        `Available | Backordered | Discontinued`
-
-        You would first need to specify ExpressionAttributeValues as follows:
-
-        `{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
-            ":disc":{"S":"Discontinued"} }`
-
-        You could then use these values in an expression, such as this:
-
-        `ProductStatus IN (:avail, :back, :disc)`
-
-        For more information on expression attribute values, go to `Specifying
-            Conditions`_ in the Amazon DynamoDB Developer Guide .
-
-        """
-        params = {'TableName': table_name, 'Key': key, }
-        if attribute_updates is not None:
-            params['AttributeUpdates'] = attribute_updates
-        if expected is not None:
-            params['Expected'] = expected
-        if conditional_operator is not None:
-            params['ConditionalOperator'] = conditional_operator
-        if return_values is not None:
-            params['ReturnValues'] = return_values
-        if return_consumed_capacity is not None:
-            params['ReturnConsumedCapacity'] = return_consumed_capacity
-        if return_item_collection_metrics is not None:
-            params['ReturnItemCollectionMetrics'] = return_item_collection_metrics
-        if update_expression is not None:
-            params['UpdateExpression'] = update_expression
-        if condition_expression is not None:
-            params['ConditionExpression'] = condition_expression
-        if expression_attribute_names is not None:
-            params['ExpressionAttributeNames'] = expression_attribute_names
-        if expression_attribute_values is not None:
-            params['ExpressionAttributeValues'] = expression_attribute_values
-        return self.make_request(action='UpdateItem',
-                                 body=json.dumps(params))
-
-    def update_table(self, table_name, provisioned_throughput=None,
-                     global_secondary_index_updates=None,
-                     attribute_definitions=None):
-        """
-        Updates the provisioned throughput for the given table, or
-        manages the global secondary indexes on the table.
-
-        You can increase or decrease the table's provisioned
-        throughput values within the maximums and minimums listed in
-        the `Limits`_ section in the Amazon DynamoDB Developer Guide .
-
-        In addition, you can use UpdateTable to add, modify or delete
-        global secondary indexes on the table. For more information,
-        see `Managing Global Secondary Indexes`_ in the Amazon
-        DynamoDB Developer Guide .
-
-        The table must be in the `ACTIVE` state for UpdateTable to
-        succeed. UpdateTable is an asynchronous operation; while
-        executing the operation, the table is in the `UPDATING` state.
-        While the table is in the `UPDATING` state, the table still
-        has the provisioned throughput from before the call. The
-        table's new provisioned throughput settings go into effect
-        when the table returns to the `ACTIVE` state; at that point,
-        the UpdateTable operation is complete.
-
-        :type attribute_definitions: list
-        :param attribute_definitions: An array of attributes that describe the
-            key schema for the table and indexes. If you are adding a new
-            global secondary index to the table, AttributeDefinitions must
-            include the key element(s) of the new index.
-
-        :type table_name: string
-        :param table_name: The name of the table to be updated.
-
-        :type provisioned_throughput: dict
-        :param provisioned_throughput: Represents the provisioned throughput
-            settings for a specified table or index. The settings can be
-            modified using the UpdateTable operation.
-        For current minimum and maximum provisioned throughput values, see
-            `Limits`_ in the Amazon DynamoDB Developer Guide .
-
-        :type global_secondary_index_updates: list
-        :param global_secondary_index_updates:
-        An array of one or more global secondary indexes for the table. For
-            each index in the array, you can specify one action:
-
-
-        + Create - add a new global secondary index to the table.
-        + Update - modify the provisioned throughput settings of an existing
-              global secondary index.
-        + Delete - remove a global secondary index from the table.
-
-        """
-        params = {'TableName': table_name, }
-        if attribute_definitions is not None:
-            params['AttributeDefinitions'] = attribute_definitions
-        if provisioned_throughput is not None:
-            params['ProvisionedThroughput'] = provisioned_throughput
-        if global_secondary_index_updates is not None:
-            params['GlobalSecondaryIndexUpdates'] = global_secondary_index_updates
-        return self.make_request(action='UpdateTable',
-                                 body=json.dumps(params))
-
-    def make_request(self, action, body):
-        headers = {
-            'X-Amz-Target': '%s.%s' % (self.TargetPrefix, action),
-            'Host': self.host,
-            'Content-Type': 'application/x-amz-json-1.0',
-            'Content-Length': str(len(body)),
-        }
-        http_request = self.build_base_http_request(
-            method='POST', path='/', auth_path='/', params={},
-            headers=headers, data=body, host=self.host)
-        response = self._mexe(http_request, sender=None,
-                              override_num_retries=self.NumberRetries,
-                              retry_handler=self._retry_handler)
-        response_body = response.read().decode('utf-8')
-        boto.log.debug(response_body)
-        if response.status == 200:
-            if response_body:
-                return json.loads(response_body)
-        else:
-            json_body = json.loads(response_body)
-            fault_name = json_body.get('__type', None)
-            exception_class = self._faults.get(fault_name, self.ResponseError)
-            raise exception_class(response.status, response.reason,
-                                  body=json_body)
-
-    def _retry_handler(self, response, i, next_sleep):
-        status = None
-        boto.log.debug("Saw HTTP status: %s" % response.status)
-        if response.status == 400:
-            response_body = response.read().decode('utf-8')
-            boto.log.debug(response_body)
-            data = json.loads(response_body)
-            if 'ProvisionedThroughputExceededException' in data.get('__type'):
-                self.throughput_exceeded_events += 1
-                msg = "%s, retry attempt %s" % (
-                    'ProvisionedThroughputExceededException',
-                    i
-                )
-                next_sleep = self._truncated_exponential_time(i)
-                i += 1
-                status = (msg, i, next_sleep)
-                if i == self.NumberRetries:
-                    # If this was our last retry attempt, raise
-                    # a specific error saying that the throughput
-                    # was exceeded.
-                    raise exceptions.ProvisionedThroughputExceededException(
-                        response.status, response.reason, data)
-            elif 'ConditionalCheckFailedException' in data.get('__type'):
-                raise exceptions.ConditionalCheckFailedException(
-                    response.status, response.reason, data)
-            elif 'ValidationException' in data.get('__type'):
-                raise exceptions.ValidationException(
-                    response.status, response.reason, data)
-            else:
-                raise self.ResponseError(response.status, response.reason,
-                                         data)
-        expected_crc32 = response.getheader('x-amz-crc32')
-        if self._validate_checksums and expected_crc32 is not None:
-            boto.log.debug('Validating crc32 checksum for body: %s',
-                           response.read())
-            actual_crc32 = crc32(response.read()) & 0xffffffff
-            expected_crc32 = int(expected_crc32)
-            if actual_crc32 != expected_crc32:
-                msg = ("The calculated checksum %s did not match the expected "
-                       "checksum %s" % (actual_crc32, expected_crc32))
-                status = (msg, i + 1, self._truncated_exponential_time(i))
-        return status
-
-    def _truncated_exponential_time(self, i):
-        if i == 0:
-            next_sleep = 0
-        else:
-            next_sleep = min(0.05 * (2 ** i),
-                             boto.config.get('Boto', 'max_retry_delay', 60))
-        return next_sleep