def createGamesTable(db): try: hostStatusDate = GlobalAllIndex("hostStatusDate", parts=[HashKey("HostId"), RangeKey("StatusDate")]) opponentStatusDate = GlobalAllIndex("opponentStatusDate", parts=[HashKey("OpponentId"), RangeKey("StatusDate")]) #global secondary indexes GSI = [hostStatusDate, opponentStatusDate] gamesTable = Table.create("Games", schema=[HashKey("GameId")], throughput={ 'read':1, 'write':1 }, global_indexes=GSI, connection=db) except JSONResponseError, jre: try: gamesTable = Table("Games", connection=db) except Exception, e: print "Games Table doesn't exist."
def create(self): Table.create(self.table_name, schema=[ HashKey(Tweet.tweet_user_id), RangeKey(Tweet.tweet_id), ], throughput=standard_throughput, indexes={ AllIndex(self.index_timestamp, parts=[ HashKey(Tweet.tweet_user_id), RangeKey(Tweet.ts_ms) ]) }, global_indexes={ GlobalAllIndex(self.index_site, parts=[ HashKey(keys.entity_site), RangeKey(Tweet.tweet_id) ], throughput=standard_throughput), GlobalAllIndex(self.index_league, parts=[ HashKey(keys.entity_league), RangeKey(Tweet.tweet_id) ], throughput=standard_throughput), GlobalAllIndex(self.index_team, parts=[ HashKey(keys.entity_team), RangeKey(Tweet.tweet_id) ], throughput=standard_throughput) })
def __init__(self, connection, debug=False): super(DatabaseManager, self).__init__() self.connection = connection tables_list = self.connection.list_tables() if TABLE_NAME in tables_list.get("TableNames"): self.table = Table(table_name=TABLE_NAME, connection=self.connection) else: self.table = Table.create(TABLE_NAME, [ HashKey("entry_type"), RangeKey("date_created", data_type=NUMBER) ], indexes=[ AllIndex("DateJoinedIndex", parts=[ HashKey("entry_type"), RangeKey( "date_created", data_type=NUMBER) ]) ], connection=self.connection)
def _get_scheduled_jobs(self, dynamodb_connection): # noqa """ WARNING -- this method requires cleanup; the user must remember to delete the table once complete. For example: >>> NEW_JOB = {'log_version': 'ad_click', 'log_schema_version': '1'} >>> def cool_test_fn(dynamodb_connection): >>> tsj = TestScheduledJobs() >>> table, scheduled_jobs = tsj._get_scheduled_jobs(dynamodb_connection) >>> assert scheduled_jobs.put(**NEW_JOB) >>> yield scheduled_jobs >>> assert table.delete() # THIS IS THE KEY CLEANUP!! """ avro_schema = get_avro_schema('mycroft/avro/scheduled_jobs.json') index_load_status = GlobalAllIndex( ScheduledJobs.INDEX_LOAD_STATUS, parts=[HashKey('load_status')]) index_et_status = GlobalAllIndex( ScheduledJobs.INDEX_ET_STATUS, parts=[HashKey('et_status')]) index_load_status = GlobalAllIndex( ScheduledJobs.INDEX_LOAD_STATUS, parts=[HashKey('load_status')]) index_log_name_and_log_schema_version = GlobalAllIndex( ScheduledJobs.INDEX_LOG_NAME_AND_LOG_SCHEMA_VERSION, parts=[HashKey('log_name'), RangeKey('log_schema_version')]) table = Table.create( 'ScheduledJobs', schema=NAME_TO_SCHEMA['scheduled_jobs'], connection=dynamodb_connection, global_indexes=[index_et_status, index_load_status, index_log_name_and_log_schema_version]) return table, ScheduledJobs(persistence_object=table, avro_schema_object=avro_schema)
def createDynamoObject(): try: users = Table.create( 'data', schema=[HashKey('id')], global_indexes=[ GlobalAllIndex('EverythingIndex', parts=[HashKey('name')]) ], connection=boto.dynamodb2.connect_to_region('us-west-2')) except boto.exception.JSONResponseError: users = Table('data', connection=boto.dynamodb2.connect_to_region('us-west-2')) print "1) Table 'data' already created." #On first Run this wont insert data because of delay to create table on aws server side. try: users.put_item( data={ 'id': '3', 'type': 'person', 'name': 'dummy', 'activities': ['activity one'], }) except: print "2) Dummy Data already added." return users
def create_router_table(tablename="router", read_throughput=5, write_throughput=5): # type: (str, int, int) -> Table """Create a new router table The last_connect index is a value used to determine the last month a user was seen in. To prevent hot-keys on this table during month switchovers the key is determined based on the following scheme: (YEAR)(MONTH)(DAY)(HOUR)(0001-0010) Note that the random key is only between 1-10 at the moment, if the key is still too hot during production the random range can be increased at the cost of additional queries during GC to locate expired users. """ return Table.create( tablename, schema=[HashKey("uaid")], throughput=dict(read=read_throughput, write=write_throughput), global_indexes=[ GlobalKeysOnlyIndex( 'AccessIndex', parts=[HashKey('last_connect', data_type=NUMBER)], throughput=dict(read=5, write=5)) ], )
def test_gsi(self): users = Table.create('gsi_users', schema=[ HashKey('user_id'), ], throughput={ 'read': 5, 'write': 3, }, global_indexes=[ GlobalKeysOnlyIndex( 'StuffIndex', parts=[HashKey('user_id')], throughput={ 'read': 2, 'write': 1, }), ]) self.addCleanup(users.delete) # Wait for it. time.sleep(60) users.update(throughput={ 'read': 3, 'write': 4 }, global_indexes={'StuffIndex': { 'read': 1, 'write': 2 }}) # Wait again for the changes to finish propagating. time.sleep(150)
def tableCreateKwargs(self): return dict( schema=[ HashKey("instance_id"), RangeKey("date_hour"), ], throughput={ "read": (taurus.engine.config.getint( "dynamodb", "instance_data_hourly_throughput_read")), "write": (taurus.engine.config.getint( "dynamodb", "instance_data_hourly_throughput_write")) }, global_indexes=[ GlobalAllIndex("taurus.instance_data_hourly-date_hour_index", parts=[HashKey("date"), RangeKey("hour")], throughput={ "read": taurus.engine.config.getint( "dynamodb", "instance_data_hourly_throughput_read"), "write": taurus.engine.config.getint( "dynamodb", "instance_data_hourly_throughput_write") }) ])
def test_settings(self): self.assertEqual(len(self.app.config['DYNAMO_TABLES']), 2) self.assertEqual(self.app.config['AWS_ACCESS_KEY_ID'], environ.get('AWS_ACCESS_KEY_ID')) self.assertEqual(self.app.config['AWS_SECRET_ACCESS_KEY'], environ.get('AWS_SECRET_ACCESS_KEY')) self.assertEqual( self.app.config['AWS_REGION'], environ.get('AWS_REGION') or self.dynamo.DEFAULT_REGION) # Test DynamoDB local settings. app = Flask(__name__) app.config['DEBUG'] = True app.config['DYNAMO_TABLES'] = [ Table('%s-phones' % self.prefix, schema=[HashKey('number')]), Table('%s-users' % self.prefix, schema=[HashKey('username')]), ] app.config['DYNAMO_ENABLE_LOCAL'] = True self.assertRaises(ConfigurationError, Dynamo, app) app.config['DYNAMO_LOCAL_HOST'] = 'localhost' self.assertRaises(ConfigurationError, Dynamo, app) app.config['DYNAMO_LOCAL_PORT'] = 8000 self.assertIsInstance(Dynamo(app), object)
def createFreshTable(self): """ Create a fresh empty distance table. """ # delete existing table if it exists try: self.__getTable().delete() time.sleep(10) except: pass # do nothing. Maybe there was no existing table # create new table tableConnectionParams = parseConnectionString(self.tableConnString) return Table.create(tableConnectionParams['name'], schema=[HashKey('from'), RangeKey('to')], throughput={ 'read': 1, 'write': 2, }, global_indexes=[ GlobalAllIndex( 'reverseIndex', parts=[HashKey('to'), RangeKey('from')], throughput={ 'read': 1, 'write': 2, }) ], connection=getDbConnection(tableConnectionParams))
def createDynamoObject(name): try: users = Table.create(name, schema=[HashKey('id')], throughput={'read': db_read_cap, 'write': db_write_cap}, global_indexes=[GlobalAllIndex('EverythingIndex' , parts=[HashKey('name')])], connection=boto.dynamodb2.connect_to_region(AWS_REGION)) except: users = Table(name, connection=boto.dynamodb2.connect_to_region('us-west-2' )) print "1) Table 'data' already created for table: " + name # On first Run this wont insert data because of delay to create table on aws server side. try: users.put_item(data={ 'id': '3', 'type': 'person', 'name': 'dummy', 'activities': ['activity one'], }) except: print '2) Dummy Data already added for tabe: ' + name return users
def _create_table(self, table_name): """ Create a table and return the table reference """ hash_key = self.hash_key() range_key = self.range_key() if range_key: self.logger.info( "Creating table with hash key: {}, range key: {}".format( hash_key, range_key)) schema = [HashKey(hash_key), RangeKey(range_key)] else: self.logger.info( "Creating table with hash key: {}".format(hash_key)) schema = [HashKey(hash_key)] new_table = Table.create(table_name, schema=schema, connection=self._conn) # Wait for our new table to be created status = 'CREATING' while status == 'CREATING': sleep(0.5) status = self._get_table_status(new_table) self.logger.debug("Table status is {}".format(status)) return new_table
def test_sanity_test_table_task(self, mock_config): mock_config.get_config.return_value.get.return_value = AWS_ACCESS_KEY t = TestSanityTestDynamoDBTableTask() # mock s3 location for writing output token s3_client = S3Client(AWS_ACCESS_KEY, AWS_SECRET_KEY) s3_client.s3.create_bucket('mybucket') # create table table_name = 'dynamo_table1' schema = [HashKey('my_hash', data_type=STRING)] indexes = [ AllIndex('IndexName', parts=[ HashKey('my_hash', data_type=STRING), RangeKey('range_index', data_type=NUMBER) ]) ] throughput = {'read': 2, 'write': 4} client = DynamoDBClient(aws_access_key_id=AWS_ACCESS_KEY, aws_secret_access_key=AWS_SECRET_KEY) client.create_table(table_name, schema, throughput, indexes=indexes) self.assertRaises(DynamoDBTaskException, luigi.build([t], local_scheduler=True))
def createTable(isLocal, localPort): """Used to create table for Dyanmo DB""" SessionTable.LOCAL_PORT = localPort secondaryIndex = [ GlobalAllIndex('expiration-index', parts=[HashKey('expiration', data_type=NUMBER)], throughput={ 'read': 5, 'write': 5 }) ] if isLocal: try: Table.create(SessionTable.TABLE_NAME, schema=[HashKey(SessionTable.KEY_NAME)], global_indexes=secondaryIndex, connection=SessionTable.getLocalConnection()) except exceptions.JSONResponseError as jre: if jre.status == 400 and "preexisting" in jre.message.lower(): #table already exists pass else: Table.create(SessionTable.TABLE_NAME, schema=[HashKey(SessionTable.KEY_NAME)], global_indexes=secondaryIndex)
def test_gsi_with_just_hash_key(self): # GSI allows for querying off of different keys. This is behavior we # previously disallowed (due to standard & LSI queries). # See https://forums.aws.amazon.com/thread.jspa?threadID=146212&tstart=0 users = Table.create('gsi_query_users', schema=[HashKey('user_id')], throughput={ 'read': 5, 'write': 3, }, global_indexes=[ GlobalIncludeIndex( 'UsernameIndex', parts=[ HashKey('username'), ], includes=['user_id', 'username'], throughput={ 'read': 3, 'write': 1, }) ]) self.addCleanup(users.delete) # Wait for it. time.sleep(60) users.put_item( data={ 'user_id': '7', 'username': '******', 'first_name': 'John', 'last_name': 'Doe', }) users.put_item( data={ 'user_id': '24', 'username': '******', 'first_name': 'Alice', 'last_name': 'Expert', }) users.put_item( data={ 'user_id': '35', 'username': '******', 'first_name': 'Jane', 'last_name': 'Doe', }) # Try the main key. Should be fine. rs = users.query_2(user_id__eq='24') results = sorted([user['username'] for user in rs]) self.assertEqual(results, ['alice']) # Now try the GSI. Also should work. rs = users.query_2(username__eq='johndoe', index='UsernameIndex') results = sorted([user['username'] for user in rs]) self.assertEqual(results, ['johndoe'])
def Init(): """ Connect to DynamoDB Local. If you want to connect to the real DynamoDB set the 'local' variable below to Fals, but make sure either you have a .boto file or you pass both the aws_access_key_id and aws_secret_access_key parameters to the create (this code fetches them from settings.cfg). """ local = True if local: # Connect to local DynamoDB server. Make sure you have that running first. conn = DynamoDBConnection(host='localhost', port=8001, aws_secret_access_key='anything', is_secure=False) else: # Connect to the real DynamoDB. config = ConfigParser.RawConfigParser() config.read("settings.cfg") id = config.get('DynamoDB', 'aws_access_key_id') key = config.get('DynamoDB', 'aws_secret_access_key') conn = boto.dynamodb2.connect_to_region('us-west-2', aws_access_key_id=id, aws_secret_access_key=key) # Get a list of all tables from DynamoDB. tables = conn.list_tables() #print "Tables:", tables """ If there isn't an employees table then create it. The table has a primary key of the employee type and id, allowing you to query them. It has a secondary index on the employee type and title, allowing you to query them as well. """ if 'employees' not in tables['TableNames']: # Create table of employees print "Creating new table" employees = Table.create( 'employees', schema=[HashKey('etype'), RangeKey('id')], indexes=[ AllIndex('TitleIndex', parts=[HashKey('etype'), RangeKey('title')]) ], connection=conn) # Wait for table to be created (DynamoDB has eventual consistency) while True: time.sleep(5) try: conn.describe_table('employees') except Exception, e: print e else: break
def get_table(): return Table(table_name, schema=[ HashKey('CreatedAt'), RangeKey('Count'), ], global_indexes=[ GlobalAllIndex('CountsIndex', parts=[ HashKey('EventType',data_type=STRING), RangeKey('Timestamp',data_type=STRING) ]) ])
def get_schema_param(hash_key_name, hash_key_type, range_key_name, range_key_type): if range_key_name: schema = [ HashKey(hash_key_name, DYNAMO_TYPE_MAP.get(hash_key_type, DYNAMO_TYPE_MAP[DYNAMO_TYPE_DEFAULT])), RangeKey(range_key_name, DYNAMO_TYPE_MAP.get(range_key_type, DYNAMO_TYPE_MAP[DYNAMO_TYPE_DEFAULT])) ] else: schema = [ HashKey(hash_key_name, DYNAMO_TYPE_MAP.get(hash_key_type, DYNAMO_TYPE_MAP[DYNAMO_TYPE_DEFAULT])) ] return schema
def init_db(self): tables = {} clients_schema = [HashKey('clientId')] # ClientId can be hostname (if unique) status_schema = [HashKey('clientId'), RangeKey('gsize')] graphs_schema = [HashKey('gsize'), RangeKey('clientId')] tables['clients'] = clients_schema tables['status'] = status_schema tables['graphs'] = graphs_schema for name in tables.keys(): self.create_table(name, schema=tables[name])
def create_or_update_dynamo_table(connection, module): table_name = module.params.get('name') hash_key_name = module.params.get('hash_key_name') hash_key_type = module.params.get('hash_key_type') range_key_name = module.params.get('range_key_name') range_key_type = module.params.get('range_key_type') read_capacity = module.params.get('read_capacity') write_capacity = module.params.get('write_capacity') if range_key_name: schema = [ HashKey(hash_key_name, DYNAMO_TYPE_MAP.get(hash_key_type)), RangeKey(range_key_name, DYNAMO_TYPE_MAP.get(range_key_type)) ] else: schema = [HashKey(hash_key_name, DYNAMO_TYPE_MAP.get(hash_key_type))] throughput = {'read': read_capacity, 'write': write_capacity} result = dict( region=module.params.get('region'), table_name=table_name, hash_key_name=hash_key_name, hash_key_type=hash_key_type, range_key_name=range_key_name, range_key_type=range_key_type, read_capacity=read_capacity, write_capacity=write_capacity, ) try: table = Table(table_name, connection=connection) if dynamo_table_exists(table): result['changed'] = update_dynamo_table( table, throughput=throughput, check_mode=module.check_mode) else: if not module.check_mode: Table.create(table_name, connection=connection, schema=schema, throughput=throughput) result['changed'] = True if not module.check_mode: result['table_status'] = table.describe()['Table']['TableStatus'] except BotoServerError: result[ 'msg'] = 'Failed to create/update dynamo table due to error: ' + traceback.format_exc( ) module.fail_json(**result) else: module.exit_json(**result)
class RacingCrewCollection(DBTable): table_name = 'racing_crew' item_class = Race global_indexes = [ GlobalAllIndex('race-index', parts=[HashKey('race')]), GlobalAllIndex('event-index', parts=[HashKey('event')]) ] def __init__(self, dbconn): super(RacingCrewCollection, self).__init__(RacingCrewCollection.table_name, DBTable.simple_schema, RacingCrewCollection.global_indexes, dbconn)
def __init__(self, db_conn, url_file): """Initialize the crawler with a connection to the database to populate and with the file containing the list of seed URLs to begin indexing.""" self._url_queue = [] self._doc_id_cache = {} self._word_id_cache = {} # Data structure for inverted index, lexicon and document index self._inverted_lexicon = {} self._inverted_index = {} self._document_index = {} self._page_rank_list = [] self._page_rank = {} self._seen = set() self._sorted_resolved_inverted_index = {} # Initialize database for crawler self._lexicon_db = Table('lexicon', schema=[ HashKey('word_id', data_type=NUMBER), ]) self._document_index_db = Table('document_index', schema=[ HashKey('doc_id', data_type=NUMBER), ]) self._inverted_index_db = Table('inverted_index', schema=[ HashKey('word_id', data_type=NUMBER), ]) self._page_rank_db = Table('page_rank', schema=[ HashKey('doc_id', data_type=NUMBER), ]) self._sorted_resolved_inverted_index_db = Table( 'sorted_resolved_inverted_index', schema=[ HashKey('word', data_type=STRING), ]) # TODO remove me in real version self._mock_next_doc_id = 1 self._mock_next_word_id = 1 # get all urls into the queue try: with open(url_file, 'r') as f: for line in f: self._url_queue.append((self._fix_url(line.strip(), ""), 0)) except IOError: pass
def create(connection): """Create dynamodb tables. """ Table.create(config.table_name('metric_names'), schema=[HashKey('domain'), RangeKey('name')], throughput=Schema.metric_names_tp, connection=connection) Table.create(config.table_name('tag_names'), schema=[HashKey('domain'), RangeKey('name')], throughput=Schema.tag_names_tp, connection=connection) Table.create(config.table_name('tag_values'), schema=[HashKey('domain'), RangeKey('value')], throughput=Schema.tag_values_tp, connection=connection) DatapointsSchema.create(connection)
def sendtodynamo_cnn(cnnjson): ''' Send json to DynamoDB Assumes that article timestamps have been deduped to avoid collisions ''' conn = connect_to_region('us-west-2', aws_access_key_id=AWS_ACCESS_KEY_ID, aws_secret_access_key=AWS_SECRET_ACCESS_KEY) hashkey = "CNN" # primary key to be used for DynamoDB table try: table = Table('CNN', connection=conn) table.describe() except boto.exception.JSONResponseError: print "Creating table" table = Table.create( 'CNN', schema=[HashKey('source'), RangeKey('tstamp', data_type=NUMBER)], throughput={ 'read': 25, 'write': 25 }, indexes=[ GlobalAllIndex('showidx', parts=[HashKey('show')], throughput={ 'read': 10, 'write': 5 }) ]) iteration = 0 for article in cnnjson: # Iterate through list of articles and upload to table rangekey = float(article['timestamp']) rowdata = { 'source': hashkey, 'tstamp': rangekey, 'cnnShow': article['show'] } for key in article.keys(): rowdata[key] = article[key] item = table.put_item(data=rowdata) iteration += 1 if iteration % 100 == 0: print "Uploaded " + iteration + " articles" return None
class Audit(DBTable): table_name = 'audit' schema = [HashKey('timeStamp'), RangeKey('user')] global_indexes = [GlobalAllIndex('race-index', parts=[HashKey('user')])] def __init__(self, dbconn): self.logger = logging.getLogger('audit') super(Audit, self).__init__(Audit.table_name, Audit.schema, Audit.global_indexes, dbconn) def info(self, message): self.logger.info(message) self.insert(data={'message': message, 'timestamp': time.time()})
def __getMappingsTable(self): return getDbTableWithSchemaAndGlobalIndexes( self.docClusterMappingTable, [ HashKey('clusterId'), RangeKey('docId') ], [ GlobalAllIndex('docId-clusterId-index', parts=[ HashKey('docId'), RangeKey('clusterId') ]) ] )
def create_router_table(tablename="router", read_throughput=5, write_throughput=5): """Create a new router table""" return Table.create( tablename, schema=[HashKey("uaid")], throughput=dict(read=read_throughput, write=write_throughput), global_indexes=[ GlobalKeysOnlyIndex( 'AccessIndex', parts=[HashKey('last_connect', data_type=NUMBER)], throughput=dict(read=5, write=5)) ], )
def create(self): Table.create(self.table_name, schema=[ HashKey(keys.entity_twitter_id), RangeKey(time_keys.ts_add, data_type=NUMBER), ], throughput=standard_throughput)
def createDdbTable(region="us-east-1", table="credential-store"): ''' create the secret store table in DDB in the specified region ''' d_conn = boto.dynamodb2.connect_to_region(region) if table in d_conn.list_tables()['TableNames']: print("Credential Store table already exists") return print("Creating table...") secrets = Table.create(table, schema=[ HashKey('name', data_type=STRING), RangeKey('version', data_type=STRING) ], throughput={ 'read': 1, 'write': 1 }, connection=d_conn) timeout = 1 while secrets.describe()['Table']['TableStatus'] != "ACTIVE": print("Waiting for table to be created...") time.sleep(timeout) timeout = timeout * 2 if timeout < 8 else timeout print("Table has been created. " "Go read the README about how to create your KMS key")
def test_failed_overwrite(): table = Table.create('messages', schema=[ HashKey('id'), ], throughput={ 'read': 7, 'write': 3, }) data1 = {'id': '123', 'data': '678'} table.put_item(data=data1) data2 = {'id': '123', 'data': '345'} table.put_item(data=data2, overwrite=True) data3 = {'id': '123', 'data': '812'} table.put_item.when.called_with( data=data3).should.throw(ConditionalCheckFailedException) returned_item = table.lookup('123') dict(returned_item).should.equal(data2) data4 = {'id': '124', 'data': 812} table.put_item(data=data4) returned_item = table.lookup('124') dict(returned_item).should.equal(data4)
def create_dynamo_schema(self, connection, tablenames=None, test=False, wait=False, throughput=None): """ Create all Dynamo tables for this model Parameters ---------- connection : :class:`~boto.dynamodb2.layer1.DynamoDBConnection` tablenames : list, optional List of tables that already exist. Will call 'describe' if not provided. test : bool, optional If True, don't actually create the table (default False) wait : bool, optional If True, block until table has been created (default False) throughput : dict, optional The throughput of the table and global indexes. Has the keys 'read' and 'write'. To specify throughput for global indexes, add the name of the index as a key and another 'read', 'write' dict as the value. Returns ------- table : str Table name that was created, or None if nothing created """ if self.abstract: return None if tablenames is None: tablenames = connection.list_tables()['TableNames'] if self.ddb_tablename in tablenames: return None elif test: return self.ddb_tablename attrs = [] indexes = [] global_indexes = [] hash_key = None raw_attrs = {} if throughput is not None: table_throughput = throughput else: table_throughput = self.throughput table_throughput = { 'ReadCapacityUnits': table_throughput['read'], 'WriteCapacityUnits': table_throughput['write'], } hash_key = HashKey(self.hash_key.name, data_type=self.hash_key.ddb_data_type) schema = [hash_key.schema()] for name, field in self.fields.iteritems(): if field.hash_key: f = hash_key elif field.range_key: f = RangeKey(name, data_type=field.ddb_data_type) schema.append(f.schema()) elif field.index: idx = field.get_boto_index(hash_key) f = idx.parts[1] indexes.append(idx.schema()) elif any(map(lambda x: name in x, self.global_indexes)): f = BaseSchemaField(name, data_type=field.ddb_data_type) else: continue attrs.append(f.definition()) raw_attrs[name] = f for gindex in self.global_indexes: index = gindex.get_boto_index(self.fields) if throughput is not None and gindex.name in throughput: index.throughput = throughput[gindex.name] global_indexes.append(index.schema()) # Make sure indexes & global indexes either have data or are None indexes = indexes or None global_indexes = global_indexes or None if not test: connection.create_table( attrs, self.ddb_tablename, schema, table_throughput, local_secondary_indexes=indexes, global_secondary_indexes=global_indexes) if wait: desc = connection.describe_table(self.ddb_tablename) while desc['Table']['TableStatus'] != 'ACTIVE': time.sleep(1) desc = connection.describe_table(self.ddb_tablename) return self.ddb_tablename