You can read Access tables with source exploration and batch syncs, or download and parse the database in code. A Python pipeline can also update one row by replacing the complete database file in Azure Files. Table exports are unavailable.
The Microsoft Access connector is a Palantir-provided driver for Microsoft Access.
To create a new Microsoft Access source, follow the standard setup flow for Palantir-provided drivers, then use the sections below for Microsoft Access-specific configuration and networking. For the complete property reference, see the official Microsoft Access driver documentation ↗.
| Capability | Status |
|---|---|
| Exploration | 🟢 Generally available |
| Batch syncs | 🟢 Generally available |
| Incremental | 🟢 Generally available |
The properties below are mandatory or recommended.
| Property | Required? | Description | Default |
|---|---|---|---|
ConnectionType ↗ | Mandatory | Specifies the file storage service, server, or file access protocol through which your Microsoft Access files are stored and retrieved. | Azure Files |
DataSource ↗ | Mandatory | The full path and name of the MS Access database file. | — |
Microsoft Access is file-backed. ConnectionType selects the storage service or file-access protocol, and DataSource identifies the .mdb or .accdb file. Follow the Microsoft Access connection guide ↗ for the properties and DataSource format required by your storage provider.
The source-in-code examples on this page use an Access source backed by Azure Files. They download the database through the imported source and parse the file in the code runtime; they do not expose an Access API or JDBC connection to code.
Set the following source properties:
| Property | Value |
|---|---|
ConnectionType | Azure Files |
DataSource | azurefile://<file-share>/<path>/<database>.accdb |
AzureStorageAccount | Your Azure storage account name |
For the AccessKey configuration used by these examples, set AuthScheme to AccessKey and add the storage account key as an encrypted AzureAccessKey property.
Add an egress policy that allows the source to reach <storage-account>.file.core.windows.net:443.
Use source exploration to preview tables in the database and create a batch sync for each table you want to ingest.
The examples below download one Azure Files-backed database and read the Departments and Employees tables. Before using an example:
MicrosoftAccessSource everywhere with the imported source's generated TypeScript identifier. Place the example in functions-typescript/src/index.ts, or export MicrosoftAccessReadFunctions from that file when using a separate module. In TypeScript v2, use the source's code API name for SOURCE_API_NAME and its RID for SOURCE_RID.| Runtime | Additional dependencies | Result and resource bounds |
|---|---|---|
| Python pipeline | pandas>=1.5,<3, requests==2.34.2, and mdbtools==1.0.1 | Streams the database in 1 MiB chunks, applies 120-second HTTP and mdb-export command timeouts, and writes one dataset snapshot. |
| Python Function | requests==2.34.2 and mdbtools==1.0.1 | Uses the same streaming and timeout bounds, then returns JSON with CSV values as strings and blank fields as null. |
| TypeScript v1 Function | mdb-reader@^3.2.0 | Loads the complete database into memory and returns JSON without an explicit request timeout. |
| TypeScript v2 Function | mdb-reader@^3.2.0 | Loads the complete database into memory and returns JSON without an explicit request timeout. |
Each example performs one Azure Files GET. These examples do not include retry requests or enforce a database-size limit, and they do not upload, replace, or mutate the Access file.
Copied!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93"""READ-only Microsoft Access table materialization through Azure Files.""" import base64 import hashlib import hmac import io import os import subprocess import tempfile from datetime import datetime, timezone from urllib.parse import quote import pandas as pd import requests from transforms.api import Output, transform from transforms.external.systems import ResolvedSource, Source, external_systems SOURCE_RID = "ri.magritte..source.<MICROSOFT_ACCESS_SOURCE_RID>" STORAGE_ACCOUNT = "<AZURE_STORAGE_ACCOUNT>" SHARE_NAME = "<AZURE_FILE_SHARE>" FILE_PATH = "<PATH_TO_ACCESS_DATABASE.accdb>" OUTPUT_PATH = ( "/<NAMESPACE>/<PROJECT>/" "<FOLDER>/<OUTPUT_DATASET>" ) AZURE_API_VERSION = "2023-11-03" TABLE_NAMES = ("Departments", "Employees") @external_systems(access=Source(SOURCE_RID)) @transform.using(output=Output(OUTPUT_PATH)) def read_access_tables(access: ResolvedSource, output) -> None: """Download, parse, and materialize Departments and Employees.""" access_key = access.get_secret("AzureAccessKey") x_ms_date = datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT") signed_headers = { "x-ms-date": x_ms_date, "x-ms-version": AZURE_API_VERSION, } canonicalized_headers = "".join( f"{name.lower()}:{' '.join(str(value).strip().split())}\n" for name, value in sorted(signed_headers.items(), key=lambda item: item[0].lower()) ) canonicalized_resource = f"/{STORAGE_ACCOUNT}/{SHARE_NAME}/{FILE_PATH}" standard_headers = ["GET", "", "", "", "", "", "", "", "", "", "", ""] string_to_sign = "\n".join(standard_headers) + "\n" + canonicalized_headers + canonicalized_resource digest = hmac.new( base64.b64decode(access_key), string_to_sign.encode("utf-8"), hashlib.sha256, ).digest() signature = base64.b64encode(digest).decode("ascii") headers = dict(signed_headers) headers["Authorization"] = f"SharedKey {STORAGE_ACCOUNT}:{signature}" encoded_path = quote(FILE_PATH, safe="/") url = f"https://{STORAGE_ACCOUNT}.file.core.windows.net/{SHARE_NAME}/{encoded_path}" proxy_uri = access.get_https_proxy_uri() proxies = {"http": proxy_uri, "https": proxy_uri} if proxy_uri else None with tempfile.TemporaryDirectory() as directory: database_path = os.path.join(directory, "testdb.accdb") response = requests.request( "GET", url, params=None, headers=headers, data=None, proxies=proxies, timeout=120, stream=True, ) response.raise_for_status() with response: with open(database_path, "wb") as output_file: for chunk in response.iter_content(chunk_size=1024 * 1024): if chunk: output_file.write(chunk) frames = [] for table_name in TABLE_NAMES: completed = subprocess.run( ["mdb-export", database_path, table_name], check=True, capture_output=True, text=True, timeout=120, ) frame = pd.read_csv(io.StringIO(completed.stdout)) frame.insert(0, "source_table", table_name) frames.append(frame) output.write_table(pd.concat(frames, ignore_index=True, sort=False))
Copied!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96"""READ-only Microsoft Access table retrieval through Azure Files.""" import base64 import csv import hashlib import hmac import io import json import os import subprocess import tempfile from datetime import datetime, timezone from urllib.parse import quote import requests from functions.api import function from functions.sources import get_source SOURCE_RID = "ri.magritte..source.<MICROSOFT_ACCESS_SOURCE_RID>" STORAGE_ACCOUNT = "<AZURE_STORAGE_ACCOUNT>" SHARE_NAME = "<AZURE_FILE_SHARE>" FILE_PATH = "<PATH_TO_ACCESS_DATABASE.accdb>" AZURE_API_VERSION = "2023-11-03" def _read_table(database_path: str, table_name: str) -> list[dict[str, str | None]]: completed = subprocess.run( ["mdb-export", database_path, table_name], check=True, capture_output=True, text=True, timeout=120, ) records: list[dict[str, str | None]] = [] for row in csv.DictReader(io.StringIO(completed.stdout)): records.append({key: value if value != "" else None for key, value in row.items()}) return records @function(sources=[SOURCE_RID]) def read_access_tables() -> str: """Return Departments and Employees as one JSON object on demand.""" source = get_source(rid=SOURCE_RID) access_key = source.get_secret("AzureAccessKey") x_ms_date = datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT") signed_headers = { "x-ms-date": x_ms_date, "x-ms-version": AZURE_API_VERSION, } canonicalized_headers = "".join( f"{name.lower()}:{' '.join(str(value).strip().split())}\n" for name, value in sorted(signed_headers.items(), key=lambda item: item[0].lower()) ) canonicalized_resource = f"/{STORAGE_ACCOUNT}/{SHARE_NAME}/{FILE_PATH}" standard_headers = ["GET", "", "", "", "", "", "", "", "", "", "", ""] string_to_sign = "\n".join(standard_headers) + "\n" + canonicalized_headers + canonicalized_resource digest = hmac.new( base64.b64decode(access_key), string_to_sign.encode("utf-8"), hashlib.sha256, ).digest() headers = { **signed_headers, "Authorization": ( f"SharedKey {STORAGE_ACCOUNT}:" f"{base64.b64encode(digest).decode('ascii')}" ), } url = ( f"https://{STORAGE_ACCOUNT}.file.core.windows.net/" f"{SHARE_NAME}/{quote(FILE_PATH, safe='/')}" ) proxy_uri = source.get_https_proxy_uri() proxies = {"http": proxy_uri, "https": proxy_uri} if proxy_uri else None response = requests.request( "GET", url, headers=headers, proxies=proxies, timeout=120, stream=True, ) response.raise_for_status() with response: with tempfile.TemporaryDirectory() as directory: database_path = os.path.join(directory, "testdb.accdb") with open(database_path, "wb") as output_file: for chunk in response.iter_content(chunk_size=1024 * 1024): if chunk: output_file.write(chunk) payload = { "Departments": _read_table(database_path, "Departments"), "Employees": _read_table(database_path, "Employees"), } return json.dumps(payload, default=str)
Copied!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65import { createHmac } from "crypto"; import { Buffer } from "buffer"; import { ExternalSystems, Function, UserFacingError } from "@foundry/functions-api"; import { MicrosoftAccessSource } from "@foundry/external-systems/sources"; import MDBReader from "mdb-reader"; const STORAGE_ACCOUNT = "<AZURE_STORAGE_ACCOUNT>"; const SHARE_NAME = "<AZURE_FILE_SHARE>"; const SOURCE_FILE_PATH = "<PATH_TO_ACCESS_DATABASE.accdb>"; const AZURE_API_VERSION = "2023-11-03"; export class MicrosoftAccessReadFunctions { @ExternalSystems({ sources: [MicrosoftAccessSource] }) @Function() public async readAccessTablesTsV1(): Promise<string> { const accessKey = MicrosoftAccessSource.getSecret("AzureAccessKey"); const xMsDate = new Date().toUTCString(); const signedHeaders: Record<string, string> = { "x-ms-date": xMsDate, "x-ms-version": AZURE_API_VERSION, }; const canonicalizedHeaders = Object.entries(signedHeaders) .sort(([left], [right]) => left.toLowerCase().localeCompare(right.toLowerCase())) .map(([name, value]) => `${name.toLowerCase()}:${value.trim().replace(/\s+/g, " ")}\n`) .join(""); const canonicalizedResource = `/${STORAGE_ACCOUNT}/${SHARE_NAME}/${SOURCE_FILE_PATH}`; const standardHeaders = ["GET", "", "", "", "", "", "", "", "", "", "", ""]; const stringToSign = `${standardHeaders.join("\n")}\n${canonicalizedHeaders}${canonicalizedResource}`; const signature = createHmac("sha256", Buffer.from(accessKey, "base64")) .update(stringToSign, "utf8") .digest("base64"); const authorization = `SharedKey ${STORAGE_ACCOUNT}:${signature}`; const encodedPath = SOURCE_FILE_PATH.split("/").map(encodeURIComponent).join("/"); const fileUrl = `https://${STORAGE_ACCOUNT}.file.core.windows.net/${SHARE_NAME}/${encodedPath}`; const response = await MicrosoftAccessSource.fetch(fileUrl, { method: "GET", headers: { ...signedHeaders, Authorization: authorization, }, }); if (!response.ok) { const body = await response.text(); throw new UserFacingError( `Azure Files GET ${SOURCE_FILE_PATH} failed (${response.status}): ${body.slice(0, 500)}`, ); } const reader = new MDBReader(Buffer.from(await response.arrayBuffer())); const tables = { Departments: reader.getTable("Departments").getData(), Employees: reader.getTable("Employees").getData(), }; return JSON.stringify(tables, (_key, item: unknown) => { if (typeof item === "bigint") { return item.toString(); } if (Buffer.isBuffer(item)) { return item.toString("base64"); } return item; }); } }
Copied!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67import { createHmac } from "node:crypto"; import { Buffer } from "node:buffer"; import MDBReader from "mdb-reader"; import { getFetch, getSource } from "@palantir/functions-sources"; import { UserFacingError } from "@osdk/functions"; const SOURCE_RID = "ri.magritte..source.<MICROSOFT_ACCESS_SOURCE_RID>"; const SOURCE_API_NAME = "<MICROSOFT_ACCESS_SOURCE_API_NAME>"; const SOURCE_FILE_PATH = "<PATH_TO_ACCESS_DATABASE.accdb>"; const STORAGE_ACCOUNT = "<AZURE_STORAGE_ACCOUNT>"; const SHARE_NAME = "<AZURE_FILE_SHARE>"; const AZURE_API_VERSION = "2023-11-03"; export const config = { sources: [SOURCE_API_NAME], }; /** Downloads the Access file and returns Departments and Employees as JSON. */ export default async function readAccessTablesTsV2(): Promise<string> { const source = await getSource({ rid: SOURCE_RID }); const accessKey = source.secrets.AzureAccessKey; if (!accessKey) throw new UserFacingError("Microsoft Access source is missing AzureAccessKey."); const fetchFromSource = await getFetch(source); const xMsDate = new Date().toUTCString(); const signedHeaders: Record<string, string> = { "x-ms-date": xMsDate, "x-ms-version": AZURE_API_VERSION, }; const canonicalizedHeaders = Object.entries(signedHeaders) .sort(([left], [right]) => left.toLowerCase().localeCompare(right.toLowerCase())) .map(([name, value]) => `${name.toLowerCase()}:${value.trim().replace(/\s+/g, " ")}\n`) .join(""); const canonicalizedResource = `/${STORAGE_ACCOUNT}/${SHARE_NAME}/${SOURCE_FILE_PATH}`; const standardHeaders = ["GET", "", "", "", "", "", "", "", "", "", "", ""]; const stringToSign = `${standardHeaders.join("\n")}\n${canonicalizedHeaders}${canonicalizedResource}`; const signature = createHmac("sha256", Buffer.from(accessKey, "base64")) .update(stringToSign, "utf8") .digest("base64"); const authorization = `SharedKey ${STORAGE_ACCOUNT}:${signature}`; const encodedPath = SOURCE_FILE_PATH.split("/").map(encodeURIComponent).join("/"); const fileUrl = `https://${STORAGE_ACCOUNT}.file.core.windows.net/${SHARE_NAME}/${encodedPath}`; const response = await fetchFromSource(fileUrl, { method: "GET", headers: { ...signedHeaders, Authorization: authorization, }, }); if (!response.ok) { const body = await response.text(); throw new UserFacingError( `Azure Files GET ${SOURCE_FILE_PATH} failed (${response.status}): ${body.slice(0, 500)}`, ); } const reader = new MDBReader(Buffer.from(await response.arrayBuffer())); const tables = { Departments: reader.getTable("Departments").getData(), Employees: reader.getTable("Employees").getData(), }; return JSON.stringify(tables, (_key, item: unknown) => { if (typeof item === "bigint") return item.toString(); if (Buffer.isBuffer(item)) return item.toString("base64"); return item; }); }
The following example conditionally changes one row in an Azure Files-backed .accdb file. It downloads the database, applies the update with UCanAccess, and uploads a uniquely named candidate. It then acquires a lease on the destination and verifies that the destination ETag has not changed. Finally, it renames the candidate over the destination.
This workflow replaces the complete .accdb file. Test it on a disposable copy before using it with operational data. Compatibility with macros, linked tables, encrypted databases, large files, and broader concurrent-writer scenarios is not established.
Before using this example:
JPype1==1.7.1, JayDeBeApi==1.2.3, requests, pandas, transforms, and transforms-external-systems.ucanaccess-5.1.8.jar, jackcess-5.1.7.jar, and hsqldb-2.7.4.jar to myproject/lib, and package lib/*.jar with myproject.AzureAccessKey property.Copied!1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185import base64 import hashlib import hmac import os import tempfile import uuid from datetime import datetime, timezone from pathlib import Path from urllib.parse import quote import jaydebeapi import pandas as pd import requests from transforms.api import Output, transform from transforms.external.systems import ResolvedSource, Source, external_systems SOURCE_RID = "ri.magritte..source.<MICROSOFT_ACCESS_SOURCE_RID>" STORAGE_ACCOUNT = "<AZURE_STORAGE_ACCOUNT>" SHARE_NAME = "<AZURE_FILE_SHARE>" FILE_PATH = "<PATH_TO_ACCESS_DATABASE.accdb>" OUTPUT_PATH = "/<NAMESPACE>/<PROJECT>/<FOLDER>/<OUTPUT_DATASET>" AZURE_API_VERSION = "2023-11-03" MAX_RANGE_BYTES = 4 * 1024 * 1024 EMPLOYEE_ID = 1001 EMPLOYEE_NAME = "Example Employee" EXPECTED_OLD_DEPT_ID = 10 NEW_DEPT_ID = 20 def _azure_request(access_key, proxies, method, path, *, query=None, headers=None, data=None): request_query = dict(query or {}) request_headers = {name.lower(): str(value) for name, value in (headers or {}).items()} request_headers["x-ms-date"] = datetime.now(timezone.utc).strftime( "%a, %d %b %Y %H:%M:%S GMT" ) request_headers["x-ms-version"] = AZURE_API_VERSION standard_headers = [method] + [ request_headers.get(name, "") for name in ( "content-encoding", "content-language", "content-length", "content-md5", "content-type", "date", "if-modified-since", "if-match", "if-none-match", "if-unmodified-since", "range", ) ] if standard_headers[3] == "0": standard_headers[3] = "" canonicalized_headers = "".join( f"{name}:{' '.join(value.strip().split())}\n" for name, value in sorted(request_headers.items()) if name.startswith("x-ms-") ) canonicalized_resource = f"/{STORAGE_ACCOUNT}/{SHARE_NAME}/{path}" for name, value in sorted(request_query.items(), key=lambda item: item[0].lower()): canonicalized_resource += f"\n{name.lower()}:{value}" string_to_sign = "\n".join(standard_headers) + "\n" + canonicalized_headers + canonicalized_resource signature = base64.b64encode( hmac.new(base64.b64decode(access_key), string_to_sign.encode("utf-8"), hashlib.sha256).digest() ).decode("ascii") request_headers["Authorization"] = f"SharedKey {STORAGE_ACCOUNT}:{signature}" return requests.request( method, f"https://{STORAGE_ACCOUNT}.file.core.windows.net/{SHARE_NAME}/{quote(path, safe='/')}", params=request_query or None, headers=request_headers, data=data, proxies=proxies, timeout=120, ) @external_systems(access=Source(SOURCE_RID)) @transform.using(output=Output(OUTPUT_PATH)) def write_access_row(access: ResolvedSource, output) -> None: access_key = access.get_secret("Azure" + "Access" + "Key") proxy_uri = access.get_https_proxy_uri() proxies = {"http": proxy_uri, "https": proxy_uri} if proxy_uri else None with _azure_request(access_key, proxies, "GET", FILE_PATH) as response: if response.status_code == 404: output.write_table(pd.DataFrame([{"status": "skipped_target_missing", "affected_rows": 0}])) return response.raise_for_status() original_bytes = response.content original_etag = response.headers.get("ETag") if not original_bytes or not original_etag: raise RuntimeError("The target download was empty or did not return an ETag") with tempfile.TemporaryDirectory() as directory: database_path = os.path.join(directory, "working.accdb") with open(database_path, "wb") as database_file: database_file.write(original_bytes) library_directory = Path(__file__).resolve().parents[1] / "lib" connection = jaydebeapi.connect( "net.ucanaccess.jdbc.UcanaccessDriver", f"jdbc:ucanaccess://{database_path}", [], [str(library_directory / name) for name in ( "ucanaccess-5.1.8.jar", "jackcess-5.1.7.jar", "hsqldb-2.7.4.jar", )], ) cursor = None try: cursor = connection.cursor() cursor.execute( "UPDATE Employees SET DeptId = ? WHERE Id = ? AND Name = ? AND DeptId = ?", [NEW_DEPT_ID, EMPLOYEE_ID, EMPLOYEE_NAME, EXPECTED_OLD_DEPT_ID], ) affected_rows = cursor.rowcount if affected_rows != 1: connection.rollback() raise RuntimeError(f"Expected one updated row, received {affected_rows}") connection.commit() finally: if cursor is not None: cursor.close() connection.close() with open(database_path, "rb") as database_file: candidate_bytes = database_file.read() candidate_path = f"{FILE_PATH}.candidate-{uuid.uuid4().hex}" lease_id = None replaced = False try: with _azure_request( access_key, proxies, "PUT", candidate_path, headers={"Content-Length": "0", "x-ms-content-length": str(len(candidate_bytes)), "x-ms-type": "file"}, data=b"", ) as response: response.raise_for_status() for start in range(0, len(candidate_bytes), MAX_RANGE_BYTES): chunk = candidate_bytes[start : start + MAX_RANGE_BYTES] with _azure_request( access_key, proxies, "PUT", candidate_path, query={"comp": "range"}, headers={ "Content-Length": str(len(chunk)), "x-ms-range": f"bytes={start}-{start + len(chunk) - 1}", "x-ms-write": "update", }, data=chunk, ) as response: response.raise_for_status() with _azure_request( access_key, proxies, "PUT", FILE_PATH, query={"comp": "lease"}, headers={"Content-Length": "0", "x-ms-lease-action": "acquire", "x-ms-lease-duration": "-1"}, data=b"", ) as response: response.raise_for_status() lease_id = response.headers.get("x-ms-lease-id") lease_etag = response.headers.get("ETag") if not lease_id or lease_etag != original_etag: raise RuntimeError("The destination changed before replacement") with _azure_request( access_key, proxies, "PUT", FILE_PATH, query={"comp": "rename"}, headers={ "Content-Length": "0", "x-ms-file-rename-source": ( f"https://{STORAGE_ACCOUNT}.file.core.windows.net/" f"{SHARE_NAME}/{quote(candidate_path, safe='/')}" ), "x-ms-file-rename-replace-if-exists": "true", "x-ms-destination-lease-id": lease_id, }, data=b"", ) as response: response.raise_for_status() replaced = True finally: if lease_id is not None: with _azure_request( access_key, proxies, "PUT", FILE_PATH, query={"comp": "lease"}, headers={"Content-Length": "0", "x-ms-lease-action": "release", "x-ms-lease-id": lease_id}, data=b"", ) as response: response.raise_for_status() if not replaced: _azure_request(access_key, proxies, "DELETE", candidate_path).close() output.write_table(pd.DataFrame([{"status": "updated", "affected_rows": affected_rows}]))
AuthScheme=AccessKey.