Scripts to download files from google storage based on sha1 sums

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

Index: third_party/gsutil/boto/boto/dynamodb/layer2.py
diff --git a/third_party/gsutil/boto/boto/dynamodb/layer2.py b/third_party/gsutil/boto/boto/dynamodb/layer2.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec8cc51d357ac696b73b3a07015cc82fe26797a9
--- /dev/null
+++ b/third_party/gsutil/boto/boto/dynamodb/layer2.py
@@ -0,0 +1,798 @@
+# 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
+
+
+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):
+        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)
+        self.dynamizer = dynamizer()
+
+    def use_decimals(self):
+        """
+        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()
+
+    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 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 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.
+
+        :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.
+
+        :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)