Revert "Add gsutil 4.13 to telemetry/third_party"

tools/telemetry/third_party/gsutil/third_party/boto/boto/dynamodb/layer2.py

Index: tools/telemetry/third_party/gsutil/third_party/boto/boto/dynamodb/layer2.py
diff --git a/tools/telemetry/third_party/gsutil/third_party/boto/boto/dynamodb/layer2.py b/tools/telemetry/third_party/gsutil/third_party/boto/boto/dynamodb/layer2.py
deleted file mode 100644
index 9510d49927be5cce5a1591edf6be8668c4eecdcc..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutil/third_party/boto/boto/dynamodb/layer2.py
+++ /dev/null
@@ -1,806 +0,0 @@
-# Copyright (c) 2011 Mitch Garnaat http://garnaat.org/
-# Copyright (c) 2011 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 boto.dynamodb.layer1 import Layer1
-from boto.dynamodb.table import Table
-from boto.dynamodb.schema import Schema
-from boto.dynamodb.item import Item
-from boto.dynamodb.batch import BatchList, BatchWriteList
-from boto.dynamodb.types import get_dynamodb_type, Dynamizer, \
-        LossyFloatDynamizer, NonBooleanDynamizer
-
-
-class TableGenerator(object):
-    """
-    This is an object that wraps up the table_generator function.
-    The only real reason to have this is that we want to be able
-    to accumulate and return the ConsumedCapacityUnits element that
-    is part of each response.
-
-    :ivar last_evaluated_key: A sequence representing the key(s)
-        of the item last evaluated, or None if no additional
-        results are available.
-
-    :ivar remaining: The remaining quantity of results requested.
-
-    :ivar table: The table to which the call was made.
-    """
-
-    def __init__(self, table, callable, remaining, item_class, kwargs):
-        self.table = table
-        self.callable = callable
-        self.remaining = -1 if remaining is None else remaining
-        self.item_class = item_class
-        self.kwargs = kwargs
-        self._consumed_units = 0.0
-        self.last_evaluated_key = None
-        self._count = 0
-        self._scanned_count = 0
-        self._response = None
-
-    @property
-    def count(self):
-        """
-        The total number of items retrieved thus far.  This value changes with
-        iteration and even when issuing a call with count=True, it is necessary
-        to complete the iteration to assert an accurate count value.
-        """
-        self.response
-        return self._count
-
-    @property
-    def scanned_count(self):
-        """
-        As above, but representing the total number of items scanned by
-        DynamoDB, without regard to any filters.
-        """
-        self.response
-        return self._scanned_count
-
-    @property
-    def consumed_units(self):
-        """
-        Returns a float representing the ConsumedCapacityUnits accumulated.
-        """
-        self.response
-        return self._consumed_units
-
-    @property
-    def response(self):
-        """
-        The current response to the call from DynamoDB.
-        """
-        return self.next_response() if self._response is None else self._response
-
-    def next_response(self):
-        """
-        Issue a call and return the result.  You can invoke this method
-        while iterating over the TableGenerator in order to skip to the
-        next "page" of results.
-        """
-        # preserve any existing limit in case the user alters self.remaining
-        limit = self.kwargs.get('limit')
-        if (self.remaining > 0 and (limit is None or limit > self.remaining)):
-            self.kwargs['limit'] = self.remaining
-        self._response = self.callable(**self.kwargs)
-        self.kwargs['limit'] = limit
-        self._consumed_units += self._response.get('ConsumedCapacityUnits', 0.0)
-        self._count += self._response.get('Count', 0)
-        self._scanned_count += self._response.get('ScannedCount', 0)
-        # at the expense of a possibly gratuitous dynamize, ensure that
-        # early generator termination won't result in bad LEK values
-        if 'LastEvaluatedKey' in self._response:
-            lek = self._response['LastEvaluatedKey']
-            esk = self.table.layer2.dynamize_last_evaluated_key(lek)
-            self.kwargs['exclusive_start_key'] = esk
-            lektuple = (lek['HashKeyElement'],)
-            if 'RangeKeyElement' in lek:
-                lektuple += (lek['RangeKeyElement'],)
-            self.last_evaluated_key = lektuple
-        else:
-            self.last_evaluated_key = None
-        return self._response
-
-    def __iter__(self):
-        while self.remaining != 0:
-            response = self.response
-            for item in response.get('Items', []):
-                self.remaining -= 1
-                yield self.item_class(self.table, attrs=item)
-                if self.remaining == 0:
-                    break
-                if response is not self._response:
-                    break
-            else:
-                if self.last_evaluated_key is not None:
-                    self.next_response()
-                    continue
-                break
-            if response is not self._response:
-                continue
-            break
-
-
-class Layer2(object):
-
-    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
-                 is_secure=True, port=None, proxy=None, proxy_port=None,
-                 debug=0, security_token=None, region=None,
-                 validate_certs=True, dynamizer=LossyFloatDynamizer,
-                 profile_name=None):
-        self.layer1 = Layer1(aws_access_key_id, aws_secret_access_key,
-                             is_secure, port, proxy, proxy_port,
-                             debug, security_token, region,
-                             validate_certs=validate_certs,
-                             profile_name=profile_name)
-        self.dynamizer = dynamizer()
-
-    def use_decimals(self, use_boolean=False):
-        """
-        Use the ``decimal.Decimal`` type for encoding/decoding numeric types.
-
-        By default, ints/floats are used to represent numeric types
-        ('N', 'NS') received from DynamoDB.  Using the ``Decimal``
-        type is recommended to prevent loss of precision.
-
-        """
-        # Eventually this should be made the default dynamizer.
-        self.dynamizer = Dynamizer() if use_boolean else NonBooleanDynamizer()
-
-    def dynamize_attribute_updates(self, pending_updates):
-        """
-        Convert a set of pending item updates into the structure
-        required by Layer1.
-        """
-        d = {}
-        for attr_name in pending_updates:
-            action, value = pending_updates[attr_name]
-            if value is None:
-                # DELETE without an attribute value
-                d[attr_name] = {"Action": action}
-            else:
-                d[attr_name] = {"Action": action,
-                                "Value": self.dynamizer.encode(value)}
-        return d
-
-    def dynamize_item(self, item):
-        d = {}
-        for attr_name in item:
-            d[attr_name] = self.dynamizer.encode(item[attr_name])
-        return d
-
-    def dynamize_range_key_condition(self, range_key_condition):
-        """
-        Convert a layer2 range_key_condition parameter into the
-        structure required by Layer1.
-        """
-        return range_key_condition.to_dict()
-
-    def dynamize_scan_filter(self, scan_filter):
-        """
-        Convert a layer2 scan_filter parameter into the
-        structure required by Layer1.
-        """
-        d = None
-        if scan_filter:
-            d = {}
-            for attr_name in scan_filter:
-                condition = scan_filter[attr_name]
-                d[attr_name] = condition.to_dict()
-        return d
-
-    def dynamize_expected_value(self, expected_value):
-        """
-        Convert an expected_value parameter into the data structure
-        required for Layer1.
-        """
-        d = None
-        if expected_value:
-            d = {}
-            for attr_name in expected_value:
-                attr_value = expected_value[attr_name]
-                if attr_value is True:
-                    attr_value = {'Exists': True}
-                elif attr_value is False:
-                    attr_value = {'Exists': False}
-                else:
-                    val = self.dynamizer.encode(expected_value[attr_name])
-                    attr_value = {'Value': val}
-                d[attr_name] = attr_value
-        return d
-
-    def dynamize_last_evaluated_key(self, last_evaluated_key):
-        """
-        Convert a last_evaluated_key parameter into the data structure
-        required for Layer1.
-        """
-        d = None
-        if last_evaluated_key:
-            hash_key = last_evaluated_key['HashKeyElement']
-            d = {'HashKeyElement': self.dynamizer.encode(hash_key)}
-            if 'RangeKeyElement' in last_evaluated_key:
-                range_key = last_evaluated_key['RangeKeyElement']
-                d['RangeKeyElement'] = self.dynamizer.encode(range_key)
-        return d
-
-    def build_key_from_values(self, schema, hash_key, range_key=None):
-        """
-        Build a Key structure to be used for accessing items
-        in Amazon DynamoDB.  This method takes the supplied hash_key
-        and optional range_key and validates them against the
-        schema.  If there is a mismatch, a TypeError is raised.
-        Otherwise, a Python dict version of a Amazon DynamoDB Key
-        data structure is returned.
-
-        :type hash_key: int|float|str|unicode|Binary
-        :param hash_key: The hash key of the item you are looking for.
-            The type of the hash key should match the type defined in
-            the schema.
-
-        :type range_key: int|float|str|unicode|Binary
-        :param range_key: The range key of the item your are looking for.
-            This should be supplied only if the schema requires a
-            range key.  The type of the range key should match the
-            type defined in the schema.
-        """
-        dynamodb_key = {}
-        dynamodb_value = self.dynamizer.encode(hash_key)
-        if list(dynamodb_value.keys())[0] != schema.hash_key_type:
-            msg = 'Hashkey must be of type: %s' % schema.hash_key_type
-            raise TypeError(msg)
-        dynamodb_key['HashKeyElement'] = dynamodb_value
-        if range_key is not None:
-            dynamodb_value = self.dynamizer.encode(range_key)
-            if list(dynamodb_value.keys())[0] != schema.range_key_type:
-                msg = 'RangeKey must be of type: %s' % schema.range_key_type
-                raise TypeError(msg)
-            dynamodb_key['RangeKeyElement'] = dynamodb_value
-        return dynamodb_key
-
-    def new_batch_list(self):
-        """
-        Return a new, empty :class:`boto.dynamodb.batch.BatchList`
-        object.
-        """
-        return BatchList(self)
-
-    def new_batch_write_list(self):
-        """
-        Return a new, empty :class:`boto.dynamodb.batch.BatchWriteList`
-        object.
-        """
-        return BatchWriteList(self)
-
-    def list_tables(self, limit=None):
-        """
-        Return a list of the names of all tables associated with the
-        current account and region.
-
-        :type limit: int
-        :param limit: The maximum number of tables to return.
-        """
-        tables = []
-        start_table = None
-        while not limit or len(tables) < limit:
-            this_round_limit = None
-            if limit:
-                this_round_limit = limit - len(tables)
-                this_round_limit = min(this_round_limit, 100)
-            result = self.layer1.list_tables(limit=this_round_limit, start_table=start_table)
-            tables.extend(result.get('TableNames', []))
-            start_table = result.get('LastEvaluatedTableName', None)
-            if not start_table:
-                break
-        return tables
-
-    def describe_table(self, name):
-        """
-        Retrieve information about an existing table.
-
-        :type name: str
-        :param name: The name of the desired table.
-
-        """
-        return self.layer1.describe_table(name)
-
-    def table_from_schema(self, name, schema):
-        """
-        Create a Table object from a schema.
-
-        This method will create a Table object without
-        making any API calls.  If you know the name and schema
-        of the table, you can use this method instead of
-        ``get_table``.
-
-        Example usage::
-
-            table = layer2.table_from_schema(
-                'tablename',
-                Schema.create(hash_key=('foo', 'N')))
-
-        :type name: str
-        :param name: The name of the table.
-
-        :type schema: :class:`boto.dynamodb.schema.Schema`
-        :param schema: The schema associated with the table.
-
-        :rtype: :class:`boto.dynamodb.table.Table`
-        :return: A Table object representing the table.
-
-        """
-        return Table.create_from_schema(self, name, schema)
-
-    def get_table(self, name):
-        """
-        Retrieve the Table object for an existing table.
-
-        :type name: str
-        :param name: The name of the desired table.
-
-        :rtype: :class:`boto.dynamodb.table.Table`
-        :return: A Table object representing the table.
-        """
-        response = self.layer1.describe_table(name)
-        return Table(self, response)
-
-    lookup = get_table
-
-    def create_table(self, name, schema, read_units, write_units):
-        """
-        Create a new Amazon DynamoDB table.
-
-        :type name: str
-        :param name: The name of the desired table.
-
-        :type schema: :class:`boto.dynamodb.schema.Schema`
-        :param schema: The Schema object that defines the schema used
-            by this table.
-
-        :type read_units: int
-        :param read_units: The value for ReadCapacityUnits.
-
-        :type write_units: int
-        :param write_units: The value for WriteCapacityUnits.
-
-        :rtype: :class:`boto.dynamodb.table.Table`
-        :return: A Table object representing the new Amazon DynamoDB table.
-        """
-        response = self.layer1.create_table(name, schema.dict,
-                                            {'ReadCapacityUnits': read_units,
-                                             'WriteCapacityUnits': write_units})
-        return Table(self,  response)
-
-    def update_throughput(self, table, read_units, write_units):
-        """
-        Update the ProvisionedThroughput for the Amazon DynamoDB Table.
-
-        :type table: :class:`boto.dynamodb.table.Table`
-        :param table: The Table object whose throughput is being updated.
-
-        :type read_units: int
-        :param read_units: The new value for ReadCapacityUnits.
-
-        :type write_units: int
-        :param write_units: The new value for WriteCapacityUnits.
-        """
-        response = self.layer1.update_table(table.name,
-                                            {'ReadCapacityUnits': read_units,
-                                             'WriteCapacityUnits': write_units})
-        table.update_from_response(response)
-
-    def delete_table(self, table):
-        """
-        Delete this table and all items in it.  After calling this
-        the Table objects status attribute will be set to 'DELETING'.
-
-        :type table: :class:`boto.dynamodb.table.Table`
-        :param table: The Table object that is being deleted.
-        """
-        response = self.layer1.delete_table(table.name)
-        table.update_from_response(response)
-
-    def create_schema(self, hash_key_name, hash_key_proto_value,
-                      range_key_name=None, range_key_proto_value=None):
-        """
-        Create a Schema object used when creating a Table.
-
-        :type hash_key_name: str
-        :param hash_key_name: The name of the HashKey for the schema.
-
-        :type hash_key_proto_value: int|long|float|str|unicode|Binary
-        :param hash_key_proto_value: A sample or prototype of the type
-            of value you want to use for the HashKey.  Alternatively,
-            you can also just pass in the Python type (e.g. int, float, etc.).
-
-        :type range_key_name: str
-        :param range_key_name: The name of the RangeKey for the schema.
-            This parameter is optional.
-
-        :type range_key_proto_value: int|long|float|str|unicode|Binary
-        :param range_key_proto_value: A sample or prototype of the type
-            of value you want to use for the RangeKey.  Alternatively,
-            you can also pass in the Python type (e.g. int, float, etc.)
-            This parameter is optional.
-        """
-        hash_key = (hash_key_name, get_dynamodb_type(hash_key_proto_value))
-        if range_key_name and range_key_proto_value is not None:
-            range_key = (range_key_name,
-                         get_dynamodb_type(range_key_proto_value))
-        else:
-            range_key = None
-        return Schema.create(hash_key, range_key)
-
-    def get_item(self, table, hash_key, range_key=None,
-                 attributes_to_get=None, consistent_read=False,
-                 item_class=Item):
-        """
-        Retrieve an existing item from the table.
-
-        :type table: :class:`boto.dynamodb.table.Table`
-        :param table: The Table object from which the item is retrieved.
-
-        :type hash_key: int|long|float|str|unicode|Binary
-        :param hash_key: The HashKey of the requested item.  The
-            type of the value must match the type defined in the
-            schema for the table.
-
-        :type range_key: int|long|float|str|unicode|Binary
-        :param range_key: The optional RangeKey of the requested item.
-            The type of the value must match the type defined in the
-            schema for the table.
-
-        :type attributes_to_get: list
-        :param attributes_to_get: A list of attribute names.
-            If supplied, only the specified attribute names will
-            be returned.  Otherwise, all attributes will be returned.
-
-        :type consistent_read: bool
-        :param consistent_read: If True, a consistent read
-            request is issued.  Otherwise, an eventually consistent
-            request is issued.
-
-        :type item_class: Class
-        :param item_class: Allows you to override the class used
-            to generate the items. This should be a subclass of
-            :class:`boto.dynamodb.item.Item`
-        """
-        key = self.build_key_from_values(table.schema, hash_key, range_key)
-        response = self.layer1.get_item(table.name, key,
-                                        attributes_to_get, consistent_read,
-                                        object_hook=self.dynamizer.decode)
-        item = item_class(table, hash_key, range_key, response['Item'])
-        if 'ConsumedCapacityUnits' in response:
-            item.consumed_units = response['ConsumedCapacityUnits']
-        return item
-
-    def batch_get_item(self, batch_list):
-        """
-        Return a set of attributes for a multiple items in
-        multiple tables using their primary keys.
-
-        :type batch_list: :class:`boto.dynamodb.batch.BatchList`
-        :param batch_list: A BatchList object which consists of a
-            list of :class:`boto.dynamoddb.batch.Batch` objects.
-            Each Batch object contains the information about one
-            batch of objects that you wish to retrieve in this
-            request.
-        """
-        request_items = batch_list.to_dict()
-        return self.layer1.batch_get_item(request_items,
-                                          object_hook=self.dynamizer.decode)
-
-    def batch_write_item(self, batch_list):
-        """
-        Performs multiple Puts and Deletes in one batch.
-
-        :type batch_list: :class:`boto.dynamodb.batch.BatchWriteList`
-        :param batch_list: A BatchWriteList object which consists of a
-            list of :class:`boto.dynamoddb.batch.BatchWrite` objects.
-            Each Batch object contains the information about one
-            batch of objects that you wish to put or delete.
-        """
-        request_items = batch_list.to_dict()
-        return self.layer1.batch_write_item(request_items,
-                                            object_hook=self.dynamizer.decode)
-
-    def put_item(self, item, expected_value=None, return_values=None):
-        """
-        Store a new item or completely replace an existing item
-        in Amazon DynamoDB.
-
-        :type item: :class:`boto.dynamodb.item.Item`
-        :param item: The Item to write to Amazon DynamoDB.
-
-        :type expected_value: dict
-        :param expected_value: A dictionary of name/value pairs that you expect.
-            This dictionary should have name/value pairs where the name
-            is the name of the attribute and the value is either the value
-            you are expecting or False if you expect the attribute not to
-            exist.
-
-        :type return_values: str
-        :param return_values: Controls the return of attribute
-            name-value pairs before then were changed.  Possible
-            values are: None or 'ALL_OLD'. If 'ALL_OLD' is
-            specified and the item is overwritten, the content
-            of the old item is returned.
-        """
-        expected_value = self.dynamize_expected_value(expected_value)
-        response = self.layer1.put_item(item.table.name,
-                                        self.dynamize_item(item),
-                                        expected_value, return_values,
-                                        object_hook=self.dynamizer.decode)
-        if 'ConsumedCapacityUnits' in response:
-            item.consumed_units = response['ConsumedCapacityUnits']
-        return response
-
-    def update_item(self, item, expected_value=None, return_values=None):
-        """
-        Commit pending item updates to Amazon DynamoDB.
-
-        :type item: :class:`boto.dynamodb.item.Item`
-        :param item: The Item to update in Amazon DynamoDB.  It is expected
-            that you would have called the add_attribute, put_attribute
-            and/or delete_attribute methods on this Item prior to calling
-            this method.  Those queued changes are what will be updated.
-
-        :type expected_value: dict
-        :param expected_value: A dictionary of name/value pairs that you
-            expect.  This dictionary should have name/value pairs where the
-            name is the name of the attribute and the value is either the
-            value you are expecting or False if you expect the attribute
-            not to exist.
-
-        :type return_values: str
-        :param return_values: Controls the return of attribute name/value pairs
-            before they were updated. Possible values are: None, 'ALL_OLD',
-            'UPDATED_OLD', 'ALL_NEW' or 'UPDATED_NEW'. If 'ALL_OLD' is
-            specified and the item is overwritten, the content of the old item
-            is returned. If 'ALL_NEW' is specified, then all the attributes of
-            the new version of the item are returned. If 'UPDATED_NEW' is
-            specified, the new versions of only the updated attributes are
-            returned.
-
-        """
-        expected_value = self.dynamize_expected_value(expected_value)
-        key = self.build_key_from_values(item.table.schema,
-                                         item.hash_key, item.range_key)
-        attr_updates = self.dynamize_attribute_updates(item._updates)
-
-        response = self.layer1.update_item(item.table.name, key,
-                                           attr_updates,
-                                           expected_value, return_values,
-                                           object_hook=self.dynamizer.decode)
-        item._updates.clear()
-        if 'ConsumedCapacityUnits' in response:
-            item.consumed_units = response['ConsumedCapacityUnits']
-        return response
-
-    def delete_item(self, item, expected_value=None, return_values=None):
-        """
-        Delete the item from Amazon DynamoDB.
-
-        :type item: :class:`boto.dynamodb.item.Item`
-        :param item: The Item to delete from Amazon DynamoDB.
-
-        :type expected_value: dict
-        :param expected_value: A dictionary of name/value pairs that you expect.
-            This dictionary should have name/value pairs where the name
-            is the name of the attribute and the value is either the value
-            you are expecting or False if you expect the attribute not to
-            exist.
-
-        :type return_values: str
-        :param return_values: Controls the return of attribute
-            name-value pairs before then were changed.  Possible
-            values are: None or 'ALL_OLD'. If 'ALL_OLD' is
-            specified and the item is overwritten, the content
-            of the old item is returned.
-        """
-        expected_value = self.dynamize_expected_value(expected_value)
-        key = self.build_key_from_values(item.table.schema,
-                                         item.hash_key, item.range_key)
-        return self.layer1.delete_item(item.table.name, key,
-                                       expected=expected_value,
-                                       return_values=return_values,
-                                       object_hook=self.dynamizer.decode)
-
-    def query(self, table, hash_key, range_key_condition=None,
-              attributes_to_get=None, request_limit=None,
-              max_results=None, consistent_read=False,
-              scan_index_forward=True, exclusive_start_key=None,
-              item_class=Item, count=False):
-        """
-        Perform a query on the table.
-
-        :type table: :class:`boto.dynamodb.table.Table`
-        :param table: The Table object that is being queried.
-
-        :type hash_key: int|long|float|str|unicode|Binary
-        :param hash_key: The HashKey of the requested item.  The
-            type of the value must match the type defined in the
-            schema for the table.
-
-        :type range_key_condition: :class:`boto.dynamodb.condition.Condition`
-        :param range_key_condition: A Condition object.
-            Condition object can be one of the following types:
-
-            EQ|LE|LT|GE|GT|BEGINS_WITH|BETWEEN
-
-            The only condition which expects or will accept two
-            values is 'BETWEEN', otherwise a single value should
-            be passed to the Condition constructor.
-
-        :type attributes_to_get: list
-        :param attributes_to_get: A list of attribute names.
-            If supplied, only the specified attribute names will
-            be returned.  Otherwise, all attributes will be returned.
-
-        :type request_limit: int
-        :param request_limit: The maximum number of items to retrieve
-            from Amazon DynamoDB on each request.  You may want to set
-            a specific request_limit based on the provisioned throughput
-            of your table.  The default behavior is to retrieve as many
-            results as possible per request.
-
-        :type max_results: int
-        :param max_results: The maximum number of results that will
-            be retrieved from Amazon DynamoDB in total.  For example,
-            if you only wanted to see the first 100 results from the
-            query, regardless of how many were actually available, you
-            could set max_results to 100 and the generator returned
-            from the query method will only yeild 100 results max.
-
-        :type consistent_read: bool
-        :param consistent_read: If True, a consistent read
-            request is issued.  Otherwise, an eventually consistent
-            request is issued.
-
-        :type scan_index_forward: bool
-        :param scan_index_forward: Specified forward or backward
-            traversal of the index.  Default is forward (True).
-
-        :type count: bool
-        :param count: If True, Amazon DynamoDB returns a total
-            number of items for the Query operation, even if the
-            operation has no matching items for the assigned filter.
-            If count is True, the actual items are not returned and
-            the count is accessible as the ``count`` attribute of
-            the returned object.
-
-        :type exclusive_start_key: list or tuple
-        :param exclusive_start_key: Primary key of the item from
-            which to continue an earlier query.  This would be
-            provided as the LastEvaluatedKey in that query.
-
-        :type item_class: Class
-        :param item_class: Allows you to override the class used
-            to generate the items. This should be a subclass of
-            :class:`boto.dynamodb.item.Item`
-
-        :rtype: :class:`boto.dynamodb.layer2.TableGenerator`
-        """
-        if range_key_condition:
-            rkc = self.dynamize_range_key_condition(range_key_condition)
-        else:
-            rkc = None
-        if exclusive_start_key:
-            esk = self.build_key_from_values(table.schema,
-                                             *exclusive_start_key)
-        else:
-            esk = None
-        kwargs = {'table_name': table.name,
-                  'hash_key_value': self.dynamizer.encode(hash_key),
-                  'range_key_conditions': rkc,
-                  'attributes_to_get': attributes_to_get,
-                  'limit': request_limit,
-                  'count': count,
-                  'consistent_read': consistent_read,
-                  'scan_index_forward': scan_index_forward,
-                  'exclusive_start_key': esk,
-                  'object_hook': self.dynamizer.decode}
-        return TableGenerator(table, self.layer1.query,
-                              max_results, item_class, kwargs)
-
-    def scan(self, table, scan_filter=None,
-             attributes_to_get=None, request_limit=None, max_results=None,
-             exclusive_start_key=None, item_class=Item, count=False):
-        """
-        Perform a scan of DynamoDB.
-
-        :type table: :class:`boto.dynamodb.table.Table`
-        :param table: The Table object that is being scanned.
-
-        :type scan_filter: A dict
-        :param scan_filter: A dictionary where the key is the
-            attribute name and the value is a
-            :class:`boto.dynamodb.condition.Condition` object.
-            Valid Condition objects include:
-
-             * EQ - equal (1)
-             * NE - not equal (1)
-             * LE - less than or equal (1)
-             * LT - less than (1)
-             * GE - greater than or equal (1)
-             * GT - greater than (1)
-             * NOT_NULL - attribute exists (0, use None)
-             * NULL - attribute does not exist (0, use None)
-             * CONTAINS - substring or value in list (1)
-             * NOT_CONTAINS - absence of substring or value in list (1)
-             * BEGINS_WITH - substring prefix (1)
-             * IN - exact match in list (N)
-             * BETWEEN - >= first value, <= second value (2)
-
-        :type attributes_to_get: list
-        :param attributes_to_get: A list of attribute names.
-            If supplied, only the specified attribute names will
-            be returned.  Otherwise, all attributes will be returned.
-
-        :type request_limit: int
-        :param request_limit: The maximum number of items to retrieve
-            from Amazon DynamoDB on each request.  You may want to set
-            a specific request_limit based on the provisioned throughput
-            of your table.  The default behavior is to retrieve as many
-            results as possible per request.
-
-        :type max_results: int
-        :param max_results: The maximum number of results that will
-            be retrieved from Amazon DynamoDB in total.  For example,
-            if you only wanted to see the first 100 results from the
-            query, regardless of how many were actually available, you
-            could set max_results to 100 and the generator returned
-            from the query method will only yeild 100 results max.
-
-        :type count: bool
-        :param count: If True, Amazon DynamoDB returns a total
-            number of items for the Scan operation, even if the
-            operation has no matching items for the assigned filter.
-            If count is True, the actual items are not returned and
-            the count is accessible as the ``count`` attribute of
-            the returned object.
-
-        :type exclusive_start_key: list or tuple
-        :param exclusive_start_key: Primary key of the item from
-            which to continue an earlier query.  This would be
-            provided as the LastEvaluatedKey in that query.
-
-        :type item_class: Class
-        :param item_class: Allows you to override the class used
-            to generate the items. This should be a subclass of
-            :class:`boto.dynamodb.item.Item`
-
-        :rtype: :class:`boto.dynamodb.layer2.TableGenerator`
-        """
-        if exclusive_start_key:
-            esk = self.build_key_from_values(table.schema,
-                                             *exclusive_start_key)
-        else:
-            esk = None
-        kwargs = {'table_name': table.name,
-                  'scan_filter': self.dynamize_scan_filter(scan_filter),
-                  'attributes_to_get': attributes_to_get,
-                  'limit': request_limit,
-                  'count': count,
-                  'exclusive_start_key': esk,
-                  'object_hook': self.dynamizer.decode}
-        return TableGenerator(table, self.layer1.scan,
-                              max_results, item_class, kwargs)