async def delete_entity(
self,
partition_key, # type: str
row_key, # type: str
**kwargs # type: Any
):
# type: (...) -> None
"""Deletes the specified entity in a table.
:param partition_key: The partition key of the entity.
:type partition_key: str
:param row_key: The row key of the entity.
:type row_key: str
:keyword str etag: Etag of the entity
:keyword ~azure.core.MatchConditions match_condition: MatchCondition
:return: None
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
if_match, if_not_match = _get_match_headers(
kwargs=dict(kwargs,
etag=kwargs.pop('etag', None),
match_condition=kwargs.pop('match_condition', None)),
etag_param='etag',
match_param='match_condition')
try:
await self._client.table.delete_entity(table=self.table_name,
partition_key=partition_key,
row_key=row_key,
if_match=if_match
or if_not_match or '*',
**kwargs)
except HttpResponseError as error:
process_table_error(error)
async def set_table_access_policy(
self,
signed_identifiers, # type: dict[str,AccessPolicy]
**kwargs):
# type: (...) -> None
"""Sets stored access policies for the table that may be used with Shared Access Signatures.
:param signed_identifiers:
:type signed_identifiers: dict[str,AccessPolicy]
:return: None
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
self._validate_signed_identifiers(signed_identifiers)
identifiers = []
for key, value in signed_identifiers.items():
if value:
value.start = serialize_iso(value.start)
value.expiry = serialize_iso(value.expiry)
identifiers.append(SignedIdentifier(id=key, access_policy=value))
signed_identifiers = identifiers # type: ignore
try:
await self._client.table.set_access_policy(
table=self.table_name,
table_acl=signed_identifiers or None,
**kwargs)
except HttpResponseError as error:
process_table_error(error)
async def get_entity(
self,
partition_key, # type: str
row_key, # type: str
**kwargs # type: Any
):
# type: (...) -> TableEntity
"""Queries entities in a table.
:param partition_key: The partition key of the entity.
:type partition_key: str
:param row_key: The row key of the entity.
:type row_key: str
:return: TableEntity mapping str to azure.data.tables.EntityProperty
:rtype: ~azure.data.tables.TableEntity
:raises: ~azure.core.exceptions.HttpResponseError
"""
try:
entity = await self._client.table.query_entities_with_partition_and_row_key(
table=self.table_name,
partition_key=partition_key,
row_key=row_key,
**kwargs)
properties = _convert_to_entity(entity.additional_properties)
return properties
except HttpResponseError as error:
process_table_error(error)
async def create_entity(
self,
entity, # type: Union[TableEntity, dict[str,str]]
**kwargs # type: Any
):
# type: (...) -> TableEntity
"""Insert entity in a table.
:param entity: The properties for the table entity.
:type entity: dict[str, str]
:return: TableEntity mapping str to azure.data.tables.EntityProperty
:rtype: ~azure.data.tables.TableEntity
:raises: ~azure.core.exceptions.HttpResponseError
"""
if entity:
if "PartitionKey" in entity and "RowKey" in entity:
entity = _add_entity_properties(entity)
else:
raise ValueError(
'PartitionKey and RowKey were not provided in entity')
try:
inserted_entity = await self._client.table.insert_entity(
table=self.table_name,
table_entity_properties=entity,
**kwargs)
properties = _convert_to_entity(inserted_entity)
return properties
except ResourceNotFoundError as error:
process_table_error(error)
async def set_service_properties(
self,
analytics_logging=None, # type: Optional[TableAnalyticsLogging]
hour_metrics=None, # type: Optional[Metrics]
minute_metrics=None, # type: Optional[Metrics]
cors=None, # type: Optional[CorsRule]
**kwargs # type: Any
):
# type: (...) -> None
"""Sets properties for an account's Table service endpoint,
including properties for Analytics and CORS (Cross-Origin Resource Sharing) rules.
:param analytics_logging: Properties for analytics
:type analytics_logging: ~azure.data.tables.TableAnalyticsLogging
:param hour_metrics: Hour level metrics
:type hour_metrics: ~azure.data.tables.Metrics
:param minute_metrics: Minute level metrics
:type minute_metrics: ~azure.data.tables.Metrics
:param cors: Cross-origin resource sharing rules
:type cors: ~azure.data.tables.CorsRule
:return: None
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
props = TableServiceProperties(logging=analytics_logging,
hour_metrics=hour_metrics,
minute_metrics=minute_metrics,
cors=cors)
try:
return await self._client.service.set_properties(props, **kwargs
) # type: ignore
except HttpResponseError as error:
process_table_error(error)
async def _get_next_cb(self, continuation_token, **kwargs):
try:
return await self._command(
next_table_name=continuation_token or None,
cls=kwargs.pop('cls', return_context_and_deserialized),
use_location=self.location_mode)
except HttpResponseError as error:
process_table_error(error)
async def update_entity(
self,
entity, # type: Union[TableEntity, dict[str,str]]
mode=UpdateMode.MERGE, # type: UpdateMode
**kwargs # type: Any
):
# type: (...) -> None
"""Update entity in a table.
:param mode: Merge or Replace entity
:type mode: ~azure.data.tables.UpdateMode
:param entity: The properties for the table entity.
:type entity: dict[str, str]
:param partition_key: The partition key of the entity.
:type partition_key: str
:param row_key: The row key of the entity.
:type row_key: str
:param etag: Etag of the entity
:type etag: str
:param match_condition: MatchCondition
:type match_condition: ~azure.core.MatchConditions
:return: None
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
if_match, if_not_match = _get_match_headers(
kwargs=dict(kwargs,
etag=kwargs.pop('etag', None),
match_condition=kwargs.pop('match_condition', None)),
etag_param='etag',
match_param='match_condition')
partition_key = entity['PartitionKey']
row_key = entity['RowKey']
entity = _add_entity_properties(entity)
try:
if mode is UpdateMode.REPLACE:
await self._client.table.update_entity(
table=self.table_name,
partition_key=partition_key,
row_key=row_key,
table_entity_properties=entity,
if_match=if_match or if_not_match or "*",
**kwargs)
elif mode is UpdateMode.MERGE:
await self._client.table.merge_entity(
table=self.table_name,
partition_key=partition_key,
row_key=row_key,
if_match=if_match or if_not_match or "*",
table_entity_properties=entity,
**kwargs)
else:
raise ValueError('Mode type is not supported')
except HttpResponseError as error:
process_table_error(error)
async def delete_table(
self,
**kwargs # type: Any
):
# type: (...) -> None
"""Creates a new table under the given account.
:return: None
:rtype: None
"""
try:
await self._client.table.delete(table=self.table_name, **kwargs)
except HttpResponseError as error:
process_table_error(error)
async def create_table(
self,
**kwargs # type: Any
):
# type: (...) -> Table
"""Creates a new table under the given account.
:return: Table created
:rtype: Table
:raises: ~azure.core.exceptions.HttpResponseError
"""
table_properties = TableProperties(table_name=self.table_name,
**kwargs)
try:
table = await self._client.table.create(table_properties)
return Table(table)
except HttpResponseError as error:
process_table_error(error)
async def get_service_properties(self, **kwargs):
# type: (...) -> dict[str,Any]
"""Gets the properties of an account's Table service,
including properties for Analytics and CORS (Cross-Origin Resource Sharing) rules.
:keyword callable cls: A custom type or function that will be passed the direct response
:return: TableServiceProperties, or the result of cls(response)
:rtype: ~azure.data.tables.models.TableServiceProperties
:raises: ~azure.core.exceptions.HttpResponseError
"""
timeout = kwargs.pop('timeout', None)
try:
service_props = await self._client.service.get_properties(
timeout=timeout, **kwargs) # type: ignore
return service_properties_deserialize(service_props)
except HttpResponseError as error:
process_table_error(error)
async def _get_next_cb(self, continuation_token):
row_key = ""
partition_key = ""
for key, value in continuation_token.items():
if key == "RowKey":
row_key = value
if key == "PartitionKey":
partition_key = value
try:
return await self._command(query_options=self.results_per_page
or None,
next_row_key=row_key or None,
next_partition_key=partition_key
or None,
table=self.table,
cls=return_context_and_deserialized,
use_location=self.location_mode)
except HttpResponseError as error:
process_table_error(error)
async def get_service_stats(self, **kwargs):
# type: (...) -> dict[str,object]
"""Retrieves statistics related to replication for the Table service. It is only available on the secondary
location endpoint when read-access geo-redundant replication is enabled for the account.
:keyword callable cls: A custom type or function that will be passed the direct response
:return: TableServiceStats, or the result of cls(response)
:rtype: ~azure.data.tables.models.TableServiceStats
:raises: ~azure.core.exceptions.HttpResponseError
"""
try:
timeout = kwargs.pop('timeout', None)
stats = await self._client.service.get_statistics( # type: ignore
timeout=timeout,
use_location=LocationMode.SECONDARY,
**kwargs)
return service_stats_deserialize(stats)
except HttpResponseError as error:
process_table_error(error)
async def get_table_access_policy(
self,
**kwargs # type: Any
):
# type: (...) -> dict[str,AccessPolicy]
"""
Retrieves details about any stored access policies specified on the table that may be
used with Shared Access Signatures.
:return: Dictionary of SignedIdentifiers
:rtype: dict[str,~azure.data.tables.AccessPolicy]
:raises: ~azure.core.exceptions.HttpResponseError
"""
timeout = kwargs.pop('timeout', None)
try:
_, identifiers = await self._client.table.get_access_policy(
table=self.table_name,
timeout=timeout,
cls=return_headers_and_deserialized,
**kwargs)
except HttpResponseError as error:
process_table_error(error)
return {s.id: s.access_policy or AccessPolicy() for s in identifiers}