async def run_sample():
async with cosmos_client.CosmosClient(HOST, MASTER_KEY) as client:
try:
# setup database for this sample
try:
db = await client.create_database(id=DATABASE_ID)
except exceptions.CosmosResourceExistsError:
db = await client.get_database_client(DATABASE_ID)
# setup container for this sample
try:
container, document = create_nonpartitioned_container(db)
print('Container with id \'{0}\' created'.format(CONTAINER_ID))
except exceptions.CosmosResourceExistsError:
print(
'Container with id \'{0}\' was found'.format(CONTAINER_ID))
# Read Item created in non partitioned container using older API version
await read_item(container, document)
await create_items(container)
await read_items(container)
await query_items(container, 'SalesOrder1')
await replace_item(container, 'SalesOrder1')
await upsert_item(container, 'SalesOrder1')
await delete_item(container, 'SalesOrder1')
# cleanup database after sample
try:
await client.delete_database(db)
except exceptions.CosmosResourceNotFoundError:
pass
except exceptions.CosmosHttpResponseError as e:
print('\nrun_sample has caught an error. {0}'.format(e.message))
async def run_sample():
async with cosmos_client.CosmosClient(HOST,
{'masterKey': MASTER_KEY}) as client:
try:
# setup database for this sample
db = await client.create_database_if_not_exists(id=DATABASE_ID)
# setup container for this sample
container = await db.create_container_if_not_exists(
id=CONTAINER_ID,
partition_key=PartitionKey(path='/id', kind='Hash'))
print('Container with id \'{0}\' created'.format(CONTAINER_ID))
await create_items(container)
await read_item(container, 'SalesOrder1')
await read_items(container)
await query_items(container, 'SalesOrder1')
await replace_item(container, 'SalesOrder1')
await upsert_item(container, 'SalesOrder1')
await delete_item(container, 'SalesOrder1')
# cleanup database after sample
try:
await client.delete_database(db)
except exceptions.CosmosResourceNotFoundError:
pass
except exceptions.CosmosHttpResponseError as e:
print('\nrun_sample has caught an error. {0}'.format(e.message))
finally:
print("\nrun_sample done")
async def test_client_user_agent(self):
client_sync = sync_client.CosmosClient(
url=_test_config.host, credential=_test_config.masterKey)
client_async = async_client.CosmosClient(
url=_test_config.host, credential=_test_config.masterKey)
self.assertTrue(
client_sync.client_connection._user_agent.startswith(
"azsdk-python-cosmos/"))
self.assertTrue(
client_async.client_connection._user_agent.startswith(
"azsdk-python-cosmos-async/"))
self.assertTrue(client_async.client_connection._user_agent !=
client_sync.client_connection._user_agent)
await client_async.close()
async def run_sample():
async with cosmos_client.CosmosClient(HOST, MASTER_KEY) as client:
try:
# setup database for this sample
try:
db = await client.create_database(id=DATABASE_ID)
except exceptions.CosmosResourceExistsError:
raise RuntimeError(
"Database with id '{}' already exists".format(DATABASE_ID))
# setup container for this sample
try:
container = await db.create_container(
id=CONTAINER_ID,
partition_key=partition_key.PartitionKey(
path='/address/state',
kind=documents.PartitionKind.Hash))
print('Container with id \'{0}\' created'.format(CONTAINER_ID))
except exceptions.CosmosResourceExistsError:
raise RuntimeError(
"Container with id '{}' already exists".format(
CONTAINER_ID))
await create_items(container, 100)
await read_change_feed(container)
# cleanup database after sample
try:
await client.delete_database(db)
except exceptions.CosmosResourceNotFoundError:
pass
except exceptions.CosmosHttpResponseError as e:
print('\nrun_sample has caught an error. {0}'.format(e.message))
finally:
print("\nrun_sample done")
async def run_sample():
async with cosmos_client.CosmosClient(HOST,
{'masterKey': MASTER_KEY}) as client:
try:
# query for a database
await find_database(client, DATABASE_ID)
# create a database
await create_database(client, DATABASE_ID)
# get a database using its id
await read_database(client, DATABASE_ID)
# list all databases on an account
await list_databases(client)
# delete database by id
await delete_database(client, DATABASE_ID)
except exceptions.CosmosHttpResponseError as e:
print('\nrun_sample has caught an error. {0}'.format(e.message))
finally:
print("\nrun_sample done")
async def run_sample():
async with cosmos_client.CosmosClient(HOST, {'masterKey': MASTER_KEY}) as client:
try:
db = await client.create_database_if_not_exists(id=DATABASE_ID)
# query for a container
await find_container(db, CONTAINER_ID)
# create a container
await create_container(db, CONTAINER_ID)
# get & change Provisioned Throughput of container
await manage_provisioned_throughput(db, CONTAINER_ID)
# get a container using its id
await read_container(db, CONTAINER_ID)
# list all container on an account
await list_containers(db)
# delete container by id
await delete_container(db, CONTAINER_ID)
# cleanup database after sample
try:
await client.delete_database(db)
except exceptions.CosmosResourceNotFoundError:
pass
except exceptions.CosmosHttpResponseError as e:
print('\nrun_sample has caught an error. {0}'.format(e.message))
finally:
print("\nrun_sample done")
def obtain_client():
# Try to setup the cacert.pem
# connection_policy.SSLConfiguration.SSLCaCerts = CaCertPath
# Else, disable verification
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
return cosmos_client.CosmosClient(HOST, MASTER_KEY)
async def run_sample():
async with cosmos_client.CosmosClient(HOST, MASTER_KEY) as client:
try:
try:
db = await client.create_database(DATABASE_ID)
except exceptions.CosmosResourceExistsError:
db = client.get_database_client(DATABASE_ID)
try:
container = await db.create_container(
id=CONTAINER_ID, partition_key=PARTITION_KEY
)
except exceptions.CosmosResourceExistsError:
container = db.get_container_client(CONTAINER_ID)
user = await create_user_if_not_exists(db, USERNAME)
# Permission to perform operations on all items inside a container
permission_definition = {
"id": CONTAINER_ALL_PERMISSION,
"permissionMode": documents.PermissionMode.All,
"resource": container.container_link,
}
permission = await create_permission_if_not_exists(user, permission_definition)
token = {}
token[container.container_link] = permission.properties["_token"]
# Use token to connect to database
# If you initialize the asynchronous client without using 'async with' in your context,
# make sure to close the client once you're done using it
token_client = cosmos_client.CosmosClient(HOST, token)
token_db = token_client.get_database_client(DATABASE_ID)
token_container = token_db.get_container_client(CONTAINER_ID)
ITEM_1_ID, ITEM_2_ID, ITEM_3_ID = "1", "2", "3"
# Update or insert item if not exists
await token_client_upsert(token_container, USERNAME, ITEM_1_ID)
await token_client_upsert(token_container, USERNAME, ITEM_2_ID)
await token_client_upsert(token_container, USERNAME_2, ITEM_3_ID)
# Read all items in the container, across all partitions
await token_client_read_all(token_container)
# Read specific item
await token_client_read_item(token_container, USERNAME, ITEM_2_ID)
# Query for items in a certain partition
await token_client_query(token_container, USERNAME_2)
# Delete an item
await token_client_delete(token_container, USERNAME, ITEM_2_ID)
# Give user read-only permission, for a specific partition
user_2 = await create_user_if_not_exists(db, USERNAME_2)
permission_definition = {
"id": PARTITION_READ_PERMISSION,
"permissionMode": documents.PermissionMode.Read,
"resource": container.container_link,
"resourcePartitionKey": [USERNAME_2],
}
permission = await create_permission_if_not_exists(user_2, permission_definition)
read_token = {}
read_token[container.container_link] = permission.properties["_token"]
# Closing current token client in order to re-initialize with read_token below:
await token_client.close()
# Use token to connect to database
# If you initialize the asynchronous client without using 'async with' make sure to close it once you're done
token_client = cosmos_client.CosmosClient(HOST, read_token)
token_db = token_client.get_database_client(DATABASE_ID)
token_container = token_db.get_container_client(CONTAINER_ID)
# Fails since this client has access to only items with partition key USERNAME_2 (ie. "user2")
await token_client_read_all(token_container)
# Ok to read item(s) with partition key "user2"
await token_client_read_item(token_container, USERNAME_2, ITEM_3_ID)
# Can't upsert or delete since it's read-only
await token_client_upsert(token_container, USERNAME_2, ITEM_3_ID)
# Give user CRUD permissions, only for a specific item
item_3 = await token_container.read_item(item=ITEM_3_ID, partition_key=USERNAME_2)
permission_list = user_2.list_permissions()
async for p in permission_list:
await user_2.delete_permission(p.get('id'))
user_2_permissions = [permission async for permission in user_2.list_permissions()]
assert len(user_2_permissions) == 0
permission_definition = {
"id": DOCUMENT_ALL_PERMISSION,
"permissionMode": documents.PermissionMode.All,
"resource": item_3.get('_self') #this identifies the item with id "3"
}
permission = await create_permission_if_not_exists(user_2, permission_definition)
item_token = {}
item_token[container.container_link] = permission.properties["_token"]
# Closing current token client in order to re-initialize with item_token below:
await token_client.close()
# Use token to connect to database
token_client = cosmos_client.CosmosClient(HOST, item_token)
token_db = token_client.get_database_client(DATABASE_ID)
token_container = token_db.get_container_client(CONTAINER_ID)
# Fails since this client only has access to a specific item
await token_client_read_all(token_container)
# Fails too, for same reason
await token_client_read_item(token_container, USERNAME, ITEM_1_ID)
# Ok to perform operations on that specific item
await token_client_read_item(token_container, USERNAME_2, ITEM_3_ID)
await token_client_delete(token_container, USERNAME_2, ITEM_3_ID)
# Cleaning up and closing current token client
await token_client.delete_database(DATABASE_ID)
await token_client.close()
except exceptions.CosmosHttpResponseError as e:
print("\nrun_sample has caught an error. {0}".format(e.message))
finally:
print("\nrun_sample done")