Mercurial > repos > shellac > guppy_basecaller
diff env/lib/python3.7/site-packages/boto/dynamodb/layer2.py @ 5:9b1c78e6ba9c draft default tip
"planemo upload commit 6c0a8142489327ece472c84e558c47da711a9142"
| author | shellac |
|---|---|
| date | Mon, 01 Jun 2020 08:59:25 -0400 |
| parents | 79f47841a781 |
| children |
line wrap: on
line diff
--- a/env/lib/python3.7/site-packages/boto/dynamodb/layer2.py Thu May 14 16:47:39 2020 -0400 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -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)