Azure Tables for Python
A practical guide to building authenticated Azure Tables applications with Python entity CRUD, queries, and partition-scoped batch operations.
The document recommends DefaultAzureCredential, constrains the production credential chain, and requires context managers for clients and async credentials, showing awareness of credential exposure and deterministic cleanup. However, it includes table/entity create, update, and delete operations without user-confirmation guidance, rollback or recovery procedures, sensitive-data handling, or permission-scope disclosure, so points are deducted.
The main client, CRUD, query, batch, and async paths are broadly consistent, and a transaction exception is shown. However, there are no skill-specific tests or version-pinned reproduction results, lifecycle integration is incomplete, and abnormal-input and failure handling are thin; under static calibration the score stays at or below 10.
Triggers, Python audience, and Azure Storage Tables/Cosmos DB Table API scenarios are reasonably clear. Non-fit boundaries, service-specific differences, precise invocation boundaries, Chinese-language guidance, and regional/network reachability evidence are limited, so false triggering and environment-fit uncertainty reduce the score.
The documentation is well organized and includes installation, environment variables, authentication, client types, operation examples, best practices, MIT licensing, author/version metadata, and reference-file links. It lacks a changelog, explicit maintainer update path, dependency version constraints, comprehensive troubleshooting, and fuller limitation disclosures, so points are deducted.
The skill directly supports common client setup, entity CRUD, queries, batch operations, and async code generation, with clear core-task value. However, examples lack a complete end-to-end runnable context, cleanup/delete paths for created resources, deployment permission setup, and production-grade error handling, requiring substantial review before use.
The skill provides concrete code, parameters, and reference material, while the repository includes general CI and harness tests. The supplied material does not show committed tests covering this specific skill or third-party execution evidence, and no code was executed during this static review, limiting verification.
- Table and entity deletion examples have irreversible or high-impact external effects; add explicit confirmation, least-privilege permissions, and backup/recovery procedures before production use.
- azure-data-tables and azure-identity versions are not pinned, and no skill-specific reproducible tests are supplied; verify method signatures and query parameters against the current official API documentation.
- The documentation is primarily English and provides no mainland-China network, Azure-region, or endpoint reachability guidance; validate the target environment separately.
What does this skill do, and when should you use it?
This skill guides Python development against Azure Storage Tables and the Cosmos DB Table API. It covers synchronous and asynchronous clients, table lifecycle management, entity CRUD, filtered queries, property selection, and batch transactions. It recommends DefaultAzureCredential and deterministic client and credential cleanup through context managers. It fits developers building structured NoSQL key-value storage into Python applications.
It explains how to install azure-data-tables and azure-identity, configure Azure service endpoints, and create TableServiceClient and TableClient instances. It provides code patterns for creating, deleting, and listing tables; creating, retrieving, replacing, merging, upserting, and deleting entities; querying partitions; applying parameterized filters; selecting properties; and listing entities. It also demonstrates same-partition transactions, async clients, supported Python-to-Table Storage data types, and credential lifecycle management.
- A Python developer needs entity CRUD against Azure Storage Tables and wants a TableClient implementation pattern.
- An application stores structured key-value data through the Cosmos DB Table API and needs endpoint and identity-credential guidance.
- A team queries orders or business records by partition and needs advice for avoiding unnecessary cross-partition queries.
- A service writes several entities in one partition and needs the SDK transaction format.
- A high-throughput Python service needs an async table client pattern with proper credential cleanup.
What are this skill's strengths and limitations?
- Supports both Azure Storage Tables and the Cosmos DB Table API.
- Provides synchronous and asynchronous Python client examples.
- Covers table management, entity CRUD, queries, property selection, and batch transactions.
- Includes concrete guidance for DefaultAzureCredential, parameterized queries, partition design, and context managers.
- Every entity requires both PartitionKey and RowKey.
- Batch transactions are limited to operations in the same partition.
- Cross-partition listing is explicitly presented as a pattern to use sparingly.
- The supplied material does not document dedicated tests or the contents of the referenced files for this specific skill.
How do you install this skill?
Run npx skills add microsoft/skills and select this skill in the wizard. The collection installs into the chosen Agent directory, such as .github/skills/ for GitHub Copilot, and can be linked across multiple Agents.
How do you use this skill?
Give a coding Agent a request such as: Help me implement Azure Table Storage entity CRUD in Python using TableClient and DefaultAzureCredential. Relevant trigger terms include table storage, TableServiceClient, TableClient, entities, PartitionKey, and RowKey. Set the appropriate endpoint environment variable, then choose either the synchronous or asynchronous client pattern.