def test_get_item(self):
"""
Connection.get_item
"""
conn = Connection(self.region)
table_name = 'Thread'
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), GET_ITEM_DATA
item = conn.get_item(table_name, "Amazon DynamoDB", "How do I update multiple items?")
self.assertEqual(item, GET_ITEM_DATA)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), None
self.assertRaises(
GetError,
conn.get_item,
table_name,
"Amazon DynamoDB",
"How do I update multiple items?"
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), GET_ITEM_DATA
conn.get_item(
table_name,
"Amazon DynamoDB",
"How do I update multiple items?",
attributes_to_get=['ForumName']
)
params = {
'return_consumed_capacity': 'TOTAL',
'attributes_to_get': ['ForumName'],
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'consistent_read': False,
'table_name': 'Thread'
}
self.assertEqual(req.call_args[1], params)
def test_describe_table(self):
"""
Connection.describe_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn = Connection(self.region)
conn.describe_table(self.test_table_name)
self.assertEqual(req.call_args[1], {'table_name': 'ci-table'})
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), DESCRIBE_TABLE_DATA
conn = Connection(self.region)
table = conn.describe_table(self.test_table_name)
self.assertIsNone(table)
with patch(PATCH_METHOD) as req:
req.return_value = HttpUnavailable(), None
conn = Connection(self.region)
self.assertRaises(TableError, conn.describe_table, self.test_table_name)
"""
Examples using a connection
"""
from pynamodb.connection import Connection
# Get a connection
conn = Connection(host='http://localhost:8000')
print(conn)
# List tables
print(conn.list_tables())
# Describe a table
print(conn.describe_table('Thread'))
# Get an item
print(conn.get_item('Thread', 'hash-key', 'range-key'))
# Put an item
conn.put_item('Thread',
'hash-key',
'range-key',
attributes={
'forum_name': 'value',
'subject': 'value'
})
# Delete an item
conn.delete_item('Thread', 'hash-key', 'range-key')
def test_connection_integration(ddb_url):
table_name = 'pynamodb-ci-connection'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = Connection(host=ddb_url)
print(conn)
print("conn.describe_table...")
table = None
try:
table = conn.describe_table(table_name)
except TableDoesNotExist:
params = {
'read_capacity_units':
1,
'write_capacity_units':
1,
'attribute_definitions': [{
'attribute_type': STRING,
'attribute_name': 'Forum'
}, {
'attribute_type': STRING,
'attribute_name': 'Thread'
}, {
'attribute_type': STRING,
'attribute_name': 'AltKey'
}, {
'attribute_type': NUMBER,
'attribute_name': 'number'
}],
'key_schema': [{
'key_type': HASH,
'attribute_name': 'Forum'
}, {
'key_type': RANGE,
'attribute_name': 'Thread'
}],
'global_secondary_indexes': [{
'index_name':
'alt-index',
'key_schema': [{
'KeyType': 'HASH',
'AttributeName': 'AltKey'
}],
'projection': {
'ProjectionType': 'KEYS_ONLY'
},
'provisioned_throughput': {
'ReadCapacityUnits': 1,
'WriteCapacityUnits': 1,
}
}],
'local_secondary_indexes': [{
'index_name':
'view-index',
'key_schema': [{
'KeyType': 'HASH',
'AttributeName': 'Forum'
}, {
'KeyType': 'RANGE',
'AttributeName': 'AltKey'
}],
'projection': {
'ProjectionType': 'KEYS_ONLY'
}
}]
}
print("conn.create_table...")
conn.create_table(table_name, **params)
while table is None:
time.sleep(1)
table = conn.describe_table(table_name)
while table['TableStatus'] == 'CREATING':
time.sleep(2)
table = conn.describe_table(table_name)
print("conn.list_tables")
conn.list_tables()
print("conn.update_table...")
conn.update_table(table_name,
read_capacity_units=table.get(
PROVISIONED_THROUGHPUT).get(READ_CAPACITY_UNITS) + 1,
write_capacity_units=2)
table = conn.describe_table(table_name)
while table['TableStatus'] != 'ACTIVE':
time.sleep(2)
table = conn.describe_table(table_name)
print("conn.put_item")
conn.put_item(
table_name,
'item1-hash',
range_key='item1-range',
attributes={'foo': {
'S': 'bar'
}},
condition=NotExists(Path('Forum')),
)
conn.get_item(table_name, 'item1-hash', range_key='item1-range')
conn.delete_item(table_name, 'item1-hash', range_key='item1-range')
items = []
for i in range(10):
items.append({"Forum": "FooForum", "Thread": f"thread-{i}"})
print("conn.batch_write_items...")
conn.batch_write_item(table_name, put_items=items)
print("conn.batch_get_items...")
data = conn.batch_get_item(table_name, items)
print("conn.query...")
conn.query(
table_name,
"FooForum",
range_key_condition=(BeginsWith(Path('Thread'), Value('thread'))),
)
print("conn.scan...")
conn.scan(table_name, )
print("conn.delete_table...")
conn.delete_table(table_name)
def test_batch_write_item(self):
"""
Connection.batch_write_item
"""
items = []
conn = Connection()
table_name = 'Thread'
for i in range(10):
items.append(
{"ForumName": "FooForum", "Subject": "thread-{0}".format(i)}
)
self.assertRaises(
ValueError,
conn.batch_write_item,
table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_write_item(
table_name,
put_items=items,
return_item_collection_metrics='SIZE',
return_consumed_capacity='TOTAL'
)
params = {
'return_consumed_capacity': 'TOTAL',
'return_item_collection_metrics': 'SIZE',
'request_items': {
'Thread': [
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}}}
]
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_write_item(
table_name,
put_items=items
)
params = {
'return_consumed_capacity': 'TOTAL',
'request_items': {
'Thread': [
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}}}},
{'PutRequest': {'Item': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}}}
]
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
PutError,
conn.batch_write_item,
table_name,
delete_items=items
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_write_item(
table_name,
delete_items=items
)
params = {
'return_consumed_capacity': 'TOTAL',
'request_items': {
'Thread': [
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}}}
]
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_write_item(
table_name,
delete_items=items,
return_consumed_capacity='TOTAL',
return_item_collection_metrics='SIZE'
)
params = {
'return_consumed_capacity': 'TOTAL',
'return_item_collection_metrics': 'SIZE',
'request_items': {
'Thread': [
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}}}},
{'DeleteRequest': {'Key': {'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}}}
]
}
}
self.assertEqual(req.call_args[1], params)
def test_put_item(self):
"""
Connection.put_item
"""
conn = Connection(self.region)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
self.test_table_name,
'foo-key',
range_key='foo-range-key',
return_consumed_capacity='TOTAL',
return_item_collection_metrics='SIZE',
return_values='ALL_NEW',
attributes={'ForumName': 'foo-value'}
)
params = {
'return_values': 'ALL_NEW',
'return_consumed_capacity': 'TOTAL',
'return_item_collection_metrics': 'SIZE',
'table_name': self.test_table_name,
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
PutError,
conn.put_item,
self.test_table_name,
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
self.test_table_name,
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {'table_name': self.test_table_name,
'return_consumed_capacity': 'TOTAL',
'item': {'ForumName': {'S': 'foo-value'}, 'Subject': {'S': 'foo-range-key'}}}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
self.test_table_name,
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {
'return_consumed_capacity': 'TOTAL',
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'table_name': self.test_table_name
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
self.test_table_name,
'item1-hash',
range_key='item1-range',
attributes={'foo': {'S': 'bar'}},
expected={'Forum': {'Exists': False}}
)
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': self.test_table_name,
'expected': {
'Forum': {
'Exists': False
}
},
'item': {
'ForumName': {
'S': 'item1-hash'
},
'foo': {
'S': 'bar'
},
'Subject': {
'S': 'item1-range'
}
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
self.test_table_name,
'item1-hash',
range_key='item1-range',
attributes={'foo': {'S': 'bar'}},
expected={'ForumName': {'Value': 'item1-hash'}}
)
params = {
'table_name': self.test_table_name,
'expected': {
'ForumName': {
'Value': {
'S': 'item1-hash'
}
}
},
'return_consumed_capacity': 'TOTAL',
'item': {
'ForumName': {
'S': 'item1-hash'
},
'foo': {
'S': 'bar'
},
'Subject': {
'S': 'item1-range'
}
}
}
self.assertEqual(req.call_args[1], params)
def test_update_item(self):
"""
Connection.update_item
"""
conn = Connection()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(self.test_table_name)
self.assertRaises(ValueError, conn.update_item, self.test_table_name, 'foo-key')
attr_updates = {
'Subject': {
'Value': 'foo-subject',
'Action': 'PUT'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
UpdateError,
conn.update_item,
self.test_table_name,
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
with patch(PATCH_METHOD) as req:
bad_attr_updates = {
'Subject': {
'Value': 'foo-subject',
'Action': 'BADACTION'
},
}
req.return_value = HttpOK(), {}
self.assertRaises(
ValueError,
conn.update_item,
self.test_table_name,
'foo-key',
attribute_updates=bad_attr_updates,
range_key='foo-range-key',
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
self.test_table_name,
'foo-key',
return_consumed_capacity='TOTAL',
return_item_collection_metrics='NONE',
return_values='ALL_NEW',
expected={'Forum': {'Exists': False}},
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'return_values': 'ALL_NEW',
'return_item_collection_metrics': 'NONE',
'return_consumed_capacity': 'TOTAL',
'key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'expected': {
'Forum': {
'Exists': False
}
},
'attribute_updates': {
'Subject': {
'Value': {
'S': 'foo-subject'
},
'Action': 'PUT'
}
},
'table_name': 'ci-table'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
self.test_table_name,
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'attribute_updates': {
'Subject': {
'Value': {
'S': 'foo-subject'
},
'Action': 'PUT'
}
},
'return_consumed_capacity': 'TOTAL',
'table_name': 'ci-table'
}
self.assertEqual(req.call_args[1], params)
attr_updates = {
'Subject': {
'Value': {'S': 'foo-subject'},
'Action': 'PUT'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
self.test_table_name,
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'attribute_updates': {
'Subject': {
'Value': {
'S': 'foo-subject'
},
'Action': 'PUT'
}
},
'return_consumed_capacity': 'TOTAL',
'table_name': 'ci-table'
}
self.assertEqual(req.call_args[1], params)
attr_updates = {
'Subject': {
'Value': {'N': '1'},
'Action': 'ADD'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
self.test_table_name,
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'attribute_updates': {
'Subject': {
'Value': {
'N': '1'
},
'Action': 'ADD'
}
},
'return_consumed_capacity': 'TOTAL',
'table_name': 'ci-table'
}
self.assertEqual(req.call_args[1], params)
def test_delete_item(self):
"""
Connection.delete_item
"""
conn = Connection(self.region)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(DeleteError, conn.delete_item, self.test_table_name, "foo", "bar")
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.delete_item(
self.test_table_name,
"Amazon DynamoDB",
"How do I update multiple items?")
params = {
'return_consumed_capacity': 'TOTAL',
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'table_name': self.test_table_name}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.delete_item(
self.test_table_name,
"Amazon DynamoDB",
"How do I update multiple items?",
return_values='ALL_NEW'
)
params = {
'return_consumed_capacity': 'TOTAL',
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'table_name': self.test_table_name,
'return_values': 'ALL_NEW'
}
self.assertEqual(req.call_args[1], params)
self.assertRaises(
ValueError,
conn.delete_item,
self.test_table_name,
"foo",
"bar",
return_values='bad_values')
self.assertRaises(
ValueError,
conn.delete_item,
self.test_table_name,
"foo",
"bar",
return_consumed_capacity='badvalue')
self.assertRaises(
ValueError,
conn.delete_item,
self.test_table_name,
"foo",
"bar",
return_item_collection_metrics='badvalue')
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.delete_item(
self.test_table_name,
"Amazon DynamoDB",
"How do I update multiple items?",
return_consumed_capacity='TOTAL'
)
params = {
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'table_name': self.test_table_name,
'return_consumed_capacity': 'TOTAL'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.delete_item(
self.test_table_name,
"Amazon DynamoDB",
"How do I update multiple items?",
return_item_collection_metrics='SIZE'
)
params = {
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'table_name': self.test_table_name,
'return_item_collection_metrics': 'SIZE',
'return_consumed_capacity': 'TOTAL'
}
self.assertEqual(req.call_args[1], params)
self.assertRaises(
ValueError,
conn.delete_item,
self.test_table_name,
"Foo", "Bar",
expected={'Bad': {'Value': False}}
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.delete_item(
self.test_table_name,
"Amazon DynamoDB",
"How do I update multiple items?",
expected={'ForumName': {'Exists': False}},
return_item_collection_metrics='SIZE'
)
params = {
'key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'expected': {
'ForumName': {
'Exists': False
}
},
'table_name': self.test_table_name,
'return_consumed_capacity': 'TOTAL',
'return_item_collection_metrics': 'SIZE'
}
self.assertEqual(req.call_args[1], params)
def test_query(self):
"""
Connection.query
"""
conn = Connection()
table_name = 'Thread'
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(table_name)
self.assertRaises(
ValueError,
conn.query,
table_name,
"FooForum",
return_consumed_capacity='TOTAL',
key_conditions={'ForumName': {'ComparisonOperator': 'BAD_OPERATOR', 'AttributeValueList': ['thread']}}
)
self.assertRaises(
ValueError,
conn.query,
table_name,
"FooForum",
return_consumed_capacity='TOTAL',
select='BAD_VALUE',
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
QueryError,
conn.query,
table_name,
"FooForum",
scan_index_forward=True,
return_consumed_capacity='TOTAL',
select='ALL_ATTRIBUTES',
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query(
table_name,
"FooForum",
scan_index_forward=True,
return_consumed_capacity='TOTAL',
select='ALL_ATTRIBUTES',
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
params = {
'scan_index_forward': True,
'select': 'ALL_ATTRIBUTES',
'return_consumed_capacity': 'TOTAL',
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': [{
'S': 'thread'
}]
}
},
'table_name': 'Thread'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query(
table_name,
"FooForum",
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
params = {
'return_consumed_capacity': 'TOTAL',
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': [{
'S': 'thread'
}]
}
},
'table_name': 'Thread'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query(
table_name,
"FooForum",
limit=1,
index_name='LastPostIndex',
attributes_to_get=['ForumName'],
exclusive_start_key="FooForum",
consistent_read=True
)
params = {
'limit': 1,
'return_consumed_capacity': 'TOTAL',
'consistent_read': True,
'exclusive_start_key': {
'ForumName': {
'S': 'FooForum'
}
},
'index_name': 'LastPostIndex',
'attributes_to_get': ['ForumName'],
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'EQ', 'AttributeValueList': [{
'S': 'FooForum'
}]
}
},
'table_name': 'Thread'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query(
table_name,
"FooForum",
select='ALL_ATTRIBUTES',
exclusive_start_key="FooForum"
)
params = {
'return_consumed_capacity': 'TOTAL',
'exclusive_start_key': {
'ForumName': {
'S': 'FooForum'
}
},
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'EQ', 'AttributeValueList': [{
'S': 'FooForum'
}]
}
},
'table_name': 'Thread',
'select': 'ALL_ATTRIBUTES'
}
self.assertEqual(req.call_args[1], params)
def test_scan(self):
"""
Connection.scan
"""
conn = Connection()
table_name = 'Thread'
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan(
table_name,
segment=0,
total_segments=22,
)
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': table_name,
'segment': 0,
'total_segments': 22,
}
self.assertDictEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan(
table_name,
return_consumed_capacity='TOTAL',
exclusive_start_key="FooForum",
limit=1,
segment=2,
total_segments=4,
attributes_to_get=['ForumName']
)
params = {
'attributes_to_get': ['ForumName'],
'exclusive_start_key': {
"ForumName": {
"S": "FooForum"
}
},
'table_name': table_name,
'limit': 1,
'segment': 2,
'total_segments': 4,
'return_consumed_capacity': 'TOTAL'
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan(
table_name,
)
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': table_name
}
self.assertEqual(req.call_args[1], params)
kwargs = {
'scan_filter': {
'ForumName': {
'ComparisonOperator': 'BadOperator',
'AttributeValueList': ['Foo']
}
}
}
self.assertRaises(
ValueError,
conn.scan,
table_name,
**kwargs)
kwargs = {
'scan_filter': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH',
'AttributeValueList': ['Foo']
}
}
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
ScanError,
conn.scan,
table_name,
**kwargs)
kwargs = {
'scan_filter': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH',
'AttributeValueList': ['Foo']
}
}
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan(
table_name,
**kwargs
)
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': table_name,
'scan_filter': {
'ForumName': {
'AttributeValueList': [
{'S': 'Foo'}
],
'ComparisonOperator': 'BEGINS_WITH'
}
}
}
self.assertEqual(req.call_args[1], params)
def test_batch_get_item(self):
"""
Connection.batch_get_item
"""
items = []
conn = Connection()
table_name = 'Thread'
for i in range(10):
items.append(
{"ForumName": "FooForum", "Subject": "thread-{0}".format(i)}
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table(table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpBadRequest(), {}
self.assertRaises(
GetError,
conn.batch_get_item,
table_name,
items,
consistent_read=True,
return_consumed_capacity='TOTAL',
attributes_to_get=['ForumName']
)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_get_item(
table_name,
items,
consistent_read=True,
return_consumed_capacity='TOTAL',
attributes_to_get=['ForumName']
)
params = {
'return_consumed_capacity': 'TOTAL',
'request_items': {
'Thread': {
'consistent_read': True,
'attributes_to_get': ['ForumName'],
'Keys': [
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}
]
}
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_get_item(
table_name,
items
)
params = {
'return_consumed_capacity': 'TOTAL',
'request_items': {
'Thread': {
'Keys': [
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}
]
}
}
}
self.assertEqual(req.call_args[1], params)
"""
Examples using a connection
"""
from __future__ import print_function
from pynamodb.connection import Connection
# Get a connection
conn = Connection(host='http://localhost:8000')
print(conn)
# List tables
print(conn.list_tables())
# Describe a table
print(conn.describe_table('Thread'))
# Get an item
print(conn.get_item('Thread', 'hash-key', 'range-key'))
# Put an item
conn.put_item('Thread', 'hash-key', 'range-key', attributes={'forum_name': 'value', 'subject': 'value'})
# Delete an item
conn.delete_item('Thread', 'hash-key', 'range-key')
def dump_table(host, region, table_name, total_segments=1, hash_keys=None,
compress=False, parallelism=1, capacity_consumption=0.5):
if hash_keys is None:
hash_keys = []
capacity_consumption = max(0.01, capacity_consumption)
capacity_consumption = min(1.0, capacity_consumption)
connection = Connection(host=host, region=region)
desc = connection.describe_table(table_name)
if desc is None:
sys.stderr.writelines(["Table does not exist."])
sys.exit(-1)
total_items = desc['ItemCount']
total_capacity = desc[PROVISIONED_THROUGHPUT][READ_CAPACITY_UNITS]
capacity_per_process = max(
1.0,
(capacity_consumption * total_capacity) / float(parallelism)
)
queue = multiprocessing.Queue()
pool = multiprocessing.Pool(
processes=parallelism,
initializer=pool_init,
initargs=[queue, capacity_per_process, host, region, compress, table_name]
)
# Keys or segments?
if len(hash_keys):
for key in hash_keys:
pool.apply_async(dump_part, [key])
num_to_do = len(hash_keys)
else:
for segment in range(total_segments):
pool.apply_async(dump_part, [segment, total_segments])
num_to_do = total_segments
num_complete = 0
items_dumped = 0
while True:
sleep(1)
while not queue.empty():
update = queue.get()
if update == 'complete':
num_complete += 1
else:
items_dumped += update
print("{}/~{} items dumped - {}/{} {}.".format(
items_dumped,
total_items,
num_complete,
num_to_do,
"keys" if len(hash_keys) else "segments"
))
if num_complete == num_to_do:
break
pool.close()
pool.join()
print("Done.")
from __future__ import print_function
import time
import config as cfg
from pynamodb.connection import Connection
from pynamodb.constants import PROVISIONED_THROUGHPUT, READ_CAPACITY_UNITS
from pynamodb.types import STRING, HASH, RANGE, NUMBER
table_name = 'pynamodb-ci'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = Connection(host=cfg.DYNAMODB_HOST)
print(conn)
print("conn.describe_table...")
table = conn.describe_table(table_name)
if table is None:
params = {
'read_capacity_units': 1,
'write_capacity_units': 1,
'attribute_definitions': [
{
'attribute_type': STRING,
'attribute_name': 'Forum'
},
{
'attribute_type': STRING,
'attribute_name': 'Thread'
},
{
'attribute_type': STRING,
from __future__ import print_function
import time
import config as cfg
from pynamodb.connection import Connection
from pynamodb.constants import PROVISIONED_THROUGHPUT, READ_CAPACITY_UNITS
from pynamodb.types import STRING, HASH, RANGE, NUMBER
table_name = 'pynamodb-ci'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = Connection(host=cfg.DYNAMODB_HOST)
print(conn)
print("conn.describe_table...")
table = conn.describe_table(table_name)
if table is None:
params = {
'read_capacity_units':
1,
'write_capacity_units':
1,
'attribute_definitions': [{
'attribute_type': STRING,
'attribute_name': 'Forum'
}, {
'attribute_type': STRING,
'attribute_name': 'Thread'
}, {
'attribute_type': STRING,
'attribute_name': 'AltKey'
