@milaboratories/pl-middle-layer 1.48.11 → 1.48.13

package/dist/network_check/template.js

@@ -1,315 +1,303 @@
-import { Pl, field, toGlobalFieldId, poll, isNotNullResourceId, isNullResourceId, ContinuePolling } from '@milaboratories/pl-client';
-import { createRenderTemplate } from '../mutator/template/render_template.js';
-import { Templates } from '@platforma-sdk/workflow-tengo';
-import { prepareTemplateSpec, loadTemplate } from '../mutator/template/template_loading.js';
-import { uploadBlob, ImportFileHandleUploadData, isUpload, isSignMatch } from '@milaboratories/pl-drivers';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import { text } from 'node:stream/consumers';
-import path from 'node:path';
-import fs__default from 'node:fs/promises';
-import os from 'node:os';
-import { randomBytes } from 'node:crypto';
+import { createRenderTemplate } from "../mutator/template/render_template.js";
+import { loadTemplate, prepareTemplateSpec } from "../mutator/template/template_loading.js";
+import path from "node:path";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import fs from "node:fs/promises";
+import { ContinuePolling, Pl, field, isNotNullResourceId, isNullResourceId, poll, toGlobalFieldId } from "@milaboratories/pl-client";
+import { randomBytes } from "node:crypto";
+import { Templates } from "@platforma-sdk/workflow-tengo";
+import { ImportFileHandleUploadData, isSignMatch, isUpload, uploadBlob } from "@milaboratories/pl-drivers";
+import { text } from "node:stream/consumers";
+import os from "node:os";
 
+//#region src/network_check/template.ts
 /** Uploads `hello-world` template and checks the output is correct. */
 async function uploadTemplate(logger, pl, name) {
-    try {
-        const gotGreeting = await runUploadTemplate(logger, pl, name);
-        if (gotGreeting !== `Hello, ${name}`) {
-            return {
-                status: "failed",
-                message: `Template uploading failed: expected: ${name}, got: ${gotGreeting}`,
-            };
-        }
-        return { status: "ok", message: `Template uploading succeeded: ${gotGreeting}` };
-    }
-    catch (e) {
-        return { status: "failed", message: `Template uploading failed: error occurred: ${e}` };
-    }
+	try {
+		const gotGreeting = await runUploadTemplate(logger, pl, name);
+		if (gotGreeting !== `Hello, ${name}`) return {
+			status: "failed",
+			message: `Template uploading failed: expected: ${name}, got: ${gotGreeting}`
+		};
+		return {
+			status: "ok",
+			message: `Template uploading succeeded: ${gotGreeting}`
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			message: `Template uploading failed: error occurred: ${e}`
+		};
+	}
 }
 async function runUploadTemplate(logger, pl, name) {
-    const outputs = await runTemplate(pl, Templates["check_network.upload_template"], true, (tx) => ({
-        name: tx.createValue(Pl.JsonObject, JSON.stringify(name)),
-    }), ["greeting"]);
-    try {
-        return JSON.parse(notEmpty((await getFieldValue(pl, outputs.greeting)).data?.toString()));
-    }
-    finally {
-        if (outputs != undefined) {
-            await deleteFields(pl, Object.values(outputs));
-        }
-    }
+	const outputs = await runTemplate(pl, Templates["check_network.upload_template"], true, (tx) => ({ name: tx.createValue(Pl.JsonObject, JSON.stringify(name)) }), ["greeting"]);
+	try {
+		return JSON.parse(notEmpty((await getFieldValue(pl, outputs.greeting)).data?.toString()));
+	} finally {
+		if (outputs != void 0) await deleteFields(pl, Object.values(outputs));
+	}
 }
 /** Uploads a file to the backend and checks the output is a Blob resource. */
 async function uploadFile(logger, signer, lsDriver, uploadClient, pl, filePath) {
-    try {
-        const gotBlob = await runUploadFile(logger, signer, lsDriver, uploadClient, pl, filePath);
-        if (gotBlob.type.name !== "Blob") {
-            return { status: "failed", message: `File uploading failed: ${gotBlob.type.name}` };
-        }
-        return { status: "ok", message: `File uploading succeeded: ${gotBlob.type.name}` };
-    }
-    catch (e) {
-        return { status: "failed", message: `File uploading failed: error occurred: ${e}` };
-    }
+	try {
+		const gotBlob = await runUploadFile(logger, signer, lsDriver, uploadClient, pl, filePath);
+		if (gotBlob.type.name !== "Blob") return {
+			status: "failed",
+			message: `File uploading failed: ${gotBlob.type.name}`
+		};
+		return {
+			status: "ok",
+			message: `File uploading succeeded: ${gotBlob.type.name}`
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			message: `File uploading failed: error occurred: ${e}`
+		};
+	}
 }
 async function runUploadFile(logger, signer, lsDriver, uploadClient, pl, filePath) {
-    const handle = await lsDriver.getLocalFileHandle(filePath);
-    const result = await runTemplate(pl, Templates["check_network.upload_blob"], true, (tx) => ({
-        file: tx.createValue(Pl.JsonObject, JSON.stringify(handle)),
-    }), ["progress", "file"]);
-    try {
-        const progress = await getFieldValue(pl, result.progress);
-        if (isUpload(progress)) {
-            const uploadData = ImportFileHandleUploadData.parse(JSON.parse(notEmpty(progress.data?.toString())));
-            const isUploadSignMatch = isSignMatch(signer, uploadData.localPath, uploadData.pathSignature);
-            if (isUploadSignMatch) {
-                await uploadBlob(logger, uploadClient, progress, uploadData, () => false, {
-                    nPartsWithThisUploadSpeed: 10,
-                    nPartsToIncreaseUpload: 10,
-                    currentSpeed: 10,
-                    maxSpeed: 10,
-                });
-            }
-        }
-        return await getFieldValue(pl, result.file);
-    }
-    finally {
-        await deleteFields(pl, Object.values(result));
-    }
+	const handle = await lsDriver.getLocalFileHandle(filePath);
+	const result = await runTemplate(pl, Templates["check_network.upload_blob"], true, (tx) => ({ file: tx.createValue(Pl.JsonObject, JSON.stringify(handle)) }), ["progress", "file"]);
+	try {
+		const progress = await getFieldValue(pl, result.progress);
+		if (isUpload(progress)) {
+			const uploadData = ImportFileHandleUploadData.parse(JSON.parse(notEmpty(progress.data?.toString())));
+			if (isSignMatch(signer, uploadData.localPath, uploadData.pathSignature)) await uploadBlob(logger, uploadClient, progress, uploadData, () => false, {
+				nPartsWithThisUploadSpeed: 10,
+				nPartsToIncreaseUpload: 10,
+				currentSpeed: 10,
+				maxSpeed: 10
+			});
+		}
+		return await getFieldValue(pl, result.file);
+	} finally {
+		await deleteFields(pl, Object.values(result));
+	}
 }
 /** Uploads a file to the backend and then tries to download it back. */
 async function downloadFile(logger, pl, lsDriver, uploadClient, downloadClient, filePath, fileContent) {
-    try {
-        const gotFileContent = await runDownloadFile(logger, pl, lsDriver, uploadClient, downloadClient, filePath);
-        if (gotFileContent !== fileContent) {
-            return {
-                status: "failed",
-                message: `File downloading failed: expected: ${fileContent}, got: ${gotFileContent}`,
-            };
-        }
-        return { status: "ok", message: `File downloading succeeded: ${gotFileContent}` };
-    }
-    catch (e) {
-        return { status: "failed", message: `File downloading failed: error occurred: ${e}` };
-    }
+	try {
+		const gotFileContent = await runDownloadFile(logger, pl, lsDriver, uploadClient, downloadClient, filePath);
+		if (gotFileContent !== fileContent) return {
+			status: "failed",
+			message: `File downloading failed: expected: ${fileContent}, got: ${gotFileContent}`
+		};
+		return {
+			status: "ok",
+			message: `File downloading succeeded: ${gotFileContent}`
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			message: `File downloading failed: error occurred: ${e}`
+		};
+	}
 }
 async function runDownloadFile(logger, pl, lsDriver, uploadClient, downloadClient, filePath) {
-    const handle = await lsDriver.getLocalFileHandle(filePath);
-    const outputs = await runTemplate(pl, Templates["check_network.download_blob"], true, (tx) => ({ file: tx.createValue(Pl.JsonObject, JSON.stringify(handle)) }), ["progress", "file"]);
-    try {
-        const progress = await getFieldValue(pl, outputs.progress);
-        await uploadBlob(logger, uploadClient, progress, ImportFileHandleUploadData.parse(JSON.parse(notEmpty(progress.data?.toString()))), () => false, {
-            nPartsWithThisUploadSpeed: 1,
-            nPartsToIncreaseUpload: 1,
-            currentSpeed: 1,
-            maxSpeed: 1,
-        });
-        const fileInfo = await getFieldValue(pl, outputs.file);
-        return await downloadClient.withBlobContent(fileInfo, {}, {}, async (content) => await text(content));
-    }
-    finally {
-        await deleteFields(pl, Object.values(outputs));
-    }
+	const handle = await lsDriver.getLocalFileHandle(filePath);
+	const outputs = await runTemplate(pl, Templates["check_network.download_blob"], true, (tx) => ({ file: tx.createValue(Pl.JsonObject, JSON.stringify(handle)) }), ["progress", "file"]);
+	try {
+		const progress = await getFieldValue(pl, outputs.progress);
+		await uploadBlob(logger, uploadClient, progress, ImportFileHandleUploadData.parse(JSON.parse(notEmpty(progress.data?.toString()))), () => false, {
+			nPartsWithThisUploadSpeed: 1,
+			nPartsToIncreaseUpload: 1,
+			currentSpeed: 1,
+			maxSpeed: 1
+		});
+		const fileInfo = await getFieldValue(pl, outputs.file);
+		return await downloadClient.withBlobContent(fileInfo, {}, {}, async (content) => await text(content));
+	} finally {
+		await deleteFields(pl, Object.values(outputs));
+	}
 }
 /** Runs Go's hello-world binary. */
 async function softwareCheck(pl) {
-    try {
-        const gotGreeting = await runSoftware(pl);
-        if (gotGreeting !== "Hello from go binary\n") {
-            return { status: "failed", message: `Software check failed: got: ${gotGreeting}` };
-        }
-        return { status: "ok", message: `Software check succeeded: ${gotGreeting}` };
-    }
-    catch (e) {
-        return { status: "failed", message: `Software check failed: error occurred: ${e}` };
-    }
+	try {
+		const gotGreeting = await runSoftware(pl);
+		if (gotGreeting !== "Hello from go binary\n") return {
+			status: "failed",
+			message: `Software check failed: got: ${gotGreeting}`
+		};
+		return {
+			status: "ok",
+			message: `Software check succeeded: ${gotGreeting}`
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			message: `Software check failed: error occurred: ${e}`
+		};
+	}
 }
 async function runSoftware(pl) {
-    const result = await runTemplate(pl, Templates["check_network.run_hello_world"], true, (_) => ({}), ["greeting"]);
-    try {
-        return notEmpty((await getFieldValue(pl, result.greeting)).data?.toString());
-    }
-    finally {
-        await deleteFields(pl, Object.values(result));
-    }
+	const result = await runTemplate(pl, Templates["check_network.run_hello_world"], true, (_) => ({}), ["greeting"]);
+	try {
+		return notEmpty((await getFieldValue(pl, result.greeting)).data?.toString());
+	} finally {
+		await deleteFields(pl, Object.values(result));
+	}
 }
 /** Runs Python hello-world. */
 async function pythonSoftware(pl, name) {
-    try {
-        const gotGreeting = await runPythonSoftware(pl, name);
-        if (gotGreeting !== `Hello, ${name}!\n`) {
-            return { status: "failed", message: `Python software check failed: got: ${gotGreeting}` };
-        }
-        return { status: "ok", message: `Python software check succeeded: ${gotGreeting}` };
-    }
-    catch (e) {
-        return { status: "failed", message: `Python software check failed: error occurred: ${e}` };
-    }
+	try {
+		const gotGreeting = await runPythonSoftware(pl, name);
+		if (gotGreeting !== `Hello, ${name}!\n`) return {
+			status: "failed",
+			message: `Python software check failed: got: ${gotGreeting}`
+		};
+		return {
+			status: "ok",
+			message: `Python software check succeeded: ${gotGreeting}`
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			message: `Python software check failed: error occurred: ${e}`
+		};
+	}
 }
 async function runPythonSoftware(pl, name) {
-    const result = await runTemplate(pl, Templates["check_network.run_hello_world_py"], true, (tx) => ({ name: tx.createValue(Pl.JsonObject, JSON.stringify(name)) }), ["greeting"]);
-    try {
-        return notEmpty((await getFieldValue(pl, result.greeting)).data?.toString());
-    }
-    finally {
-        await deleteFields(pl, Object.values(result));
-    }
+	const result = await runTemplate(pl, Templates["check_network.run_hello_world_py"], true, (tx) => ({ name: tx.createValue(Pl.JsonObject, JSON.stringify(name)) }), ["greeting"]);
+	try {
+		return notEmpty((await getFieldValue(pl, result.greeting)).data?.toString());
+	} finally {
+		await deleteFields(pl, Object.values(result));
+	}
 }
 /** Tries to download a file from every storage. */
 async function downloadFromEveryStorage(logger, pl, lsDriver, ops) {
-    try {
-        const storages = await lsDriver.getStorageList();
-        const results = {};
-        for (const storage of storages) {
-            const result = await chooseFile(lsDriver, storage, ops.nFilesToCheck, ops.minFileSize, ops.maxFileSize, ops.minLsRequests);
-            if (result.file === undefined) {
-                results[storage.name] = {
-                    status: "warn",
-                    message: `No file between ${ops.minFileSize} and ${ops.maxFileSize} bytes ` +
-                        `found in storage ${storage.name}, checked ${result.nCheckedFiles} files, ` +
-                        `did ${result.nLsRequests} ls requests`,
-                };
-                continue;
-            }
-            logger.info(`Downloading file ${JSON.stringify(result)} from storage ${storage.name}`);
-            const outputs = await runTemplate(pl, Templates["check_network.create_workdir_from_storage"], true, (tx) => ({
-                file: tx.createValue(Pl.JsonObject, JSON.stringify(result.file.handle)),
-            }), ["workdirTypeName"]);
-            try {
-                const workdirTypeName = JSON.parse(Buffer.from((await getFieldValue(pl, outputs.workdirTypeName)).data).toString());
-                if (workdirTypeName?.startsWith("WorkingDirectory")) {
-                    results[storage.name] = {
-                        status: "ok",
-                        message: `Workdir creation succeeded, size of file: ${result.file?.size}, ` +
-                            `checked ${result.nCheckedFiles} files, did ${result.nLsRequests} ls requests`,
-                    };
-                }
-                else {
-                    results[storage.name] = {
-                        status: "failed",
-                        message: `Workdir creation failed: ${workdirTypeName}, size of file: ${result.file?.size}, ` +
-                            `checked ${result.nCheckedFiles} files, did ${result.nLsRequests} ls requests`,
-                    };
-                }
-            }
-            finally {
-                await deleteFields(pl, Object.values(outputs));
-            }
-        }
-        return results;
-    }
-    catch (e) {
-        return {
-            unknown: {
-                status: "failed",
-                message: `Download from every storage failed: error occurred: ${e}`,
-            },
-        };
-    }
+	try {
+		const storages = await lsDriver.getStorageList();
+		const results = {};
+		for (const storage of storages) {
+			const result = await chooseFile(lsDriver, storage, ops.nFilesToCheck, ops.minFileSize, ops.maxFileSize, ops.minLsRequests);
+			if (result.file === void 0) {
+				results[storage.name] = {
+					status: "warn",
+					message: `No file between ${ops.minFileSize} and ${ops.maxFileSize} bytes found in storage ${storage.name}, checked ${result.nCheckedFiles} files, did ${result.nLsRequests} ls requests`
+				};
+				continue;
+			}
+			logger.info(`Downloading file ${JSON.stringify(result)} from storage ${storage.name}`);
+			const outputs = await runTemplate(pl, Templates["check_network.create_workdir_from_storage"], true, (tx) => ({ file: tx.createValue(Pl.JsonObject, JSON.stringify(result.file.handle)) }), ["workdirTypeName"]);
+			try {
+				const workdirTypeName = JSON.parse(Buffer.from((await getFieldValue(pl, outputs.workdirTypeName)).data).toString());
+				if (workdirTypeName?.startsWith("WorkingDirectory")) results[storage.name] = {
+					status: "ok",
+					message: `Workdir creation succeeded, size of file: ${result.file?.size}, checked ${result.nCheckedFiles} files, did ${result.nLsRequests} ls requests`
+				};
+				else results[storage.name] = {
+					status: "failed",
+					message: `Workdir creation failed: ${workdirTypeName}, size of file: ${result.file?.size}, checked ${result.nCheckedFiles} files, did ${result.nLsRequests} ls requests`
+				};
+			} finally {
+				await deleteFields(pl, Object.values(outputs));
+			}
+		}
+		return results;
+	} catch (e) {
+		return { unknown: {
+			status: "failed",
+			message: `Download from every storage failed: error occurred: ${e}`
+		} };
+	}
 }
 /** Chooses a random file from the storage in a size range.
- * If we couldn't find a normal-sized file, we'll return a small file to check at least something.
- */
+* If we couldn't find a normal-sized file, we'll return a small file to check at least something.
+*/
 async function chooseFile(lsDriver, storage, limit, minSize, maxSize, minLsRequests) {
-    const files = listFilesSequence(lsDriver, storage, "", 0);
-    // return small file in case we don't have many normal-sized files.
-    // While we'll download only a small range of bytes from the file,
-    // we don't want to return a big file in case the underlying S3 doesn't support range requests.
-    let smallFile;
-    let nCheckedFiles = 0;
-    let maxNLsRequests = 0;
-    for await (const { file, nLsRequests } of files) {
-        maxNLsRequests = Math.max(maxNLsRequests, nLsRequests);
-        if (nCheckedFiles >= limit && maxNLsRequests > minLsRequests) {
-            // we reached a limit on both the number of files and the number of ls requests.
-            return { file: smallFile, nLsRequests: maxNLsRequests, nCheckedFiles };
-        }
-        nCheckedFiles++;
-        if (minSize <= file.size && file.size <= maxSize) {
-            return { file, nLsRequests: maxNLsRequests, nCheckedFiles };
-        }
-        else if (file.size < minSize) {
-            smallFile = file;
-        }
-    }
-    return { file: smallFile, nLsRequests: maxNLsRequests, nCheckedFiles };
+	const files = listFilesSequence(lsDriver, storage, "", 0);
+	let smallFile;
+	let nCheckedFiles = 0;
+	let maxNLsRequests = 0;
+	for await (const { file, nLsRequests } of files) {
+		maxNLsRequests = Math.max(maxNLsRequests, nLsRequests);
+		if (nCheckedFiles >= limit && maxNLsRequests > minLsRequests) return {
+			file: smallFile,
+			nLsRequests: maxNLsRequests,
+			nCheckedFiles
+		};
+		nCheckedFiles++;
+		if (minSize <= file.size && file.size <= maxSize) return {
+			file,
+			nLsRequests: maxNLsRequests,
+			nCheckedFiles
+		};
+		else if (file.size < minSize) smallFile = file;
+	}
+	return {
+		file: smallFile,
+		nLsRequests: maxNLsRequests,
+		nCheckedFiles
+	};
 }
 /** Deep-first search for files in the storage. */
 async function* listFilesSequence(lsDriver, storage, parent, nLsRequests) {
-    nLsRequests++;
-    const files = await lsDriver.listRemoteFilesWithAdditionalInfo(storage.handle, parent);
-    for (const file of files.entries) {
-        if (file.type === "file" && file.fullPath.startsWith(parent)) {
-            yield {
-                file,
-                nLsRequests,
-            };
-        }
-        else if (file.type === "dir") {
-            for await (const nestedFile of listFilesSequence(lsDriver, storage, file.fullPath, nLsRequests)) {
-                nLsRequests = Math.max(nestedFile.nLsRequests, nLsRequests);
-                yield nestedFile;
-            }
-        }
-    }
+	nLsRequests++;
+	const files = await lsDriver.listRemoteFilesWithAdditionalInfo(storage.handle, parent);
+	for (const file of files.entries) if (file.type === "file" && file.fullPath.startsWith(parent)) yield {
+		file,
+		nLsRequests
+	};
+	else if (file.type === "dir") for await (const nestedFile of listFilesSequence(lsDriver, storage, file.fullPath, nLsRequests)) {
+		nLsRequests = Math.max(nestedFile.nLsRequests, nLsRequests);
+		yield nestedFile;
+	}
 }
 /** Creates a big temporary file with random content. */
 async function createBigTempFile() {
-    const filePath = path.join(os.tmpdir(), `check-network-big-temp-${Date.now()}.bin`);
-    const fileSize = 20 * 1024 * 1024; // 20 MiB
-    const fileContent = randomBytes(fileSize);
-    await fs__default.appendFile(filePath, fileContent);
-    return { filePath };
+	const filePath = path.join(os.tmpdir(), `check-network-big-temp-${Date.now()}.bin`);
+	const fileContent = randomBytes(20 * 1024 * 1024);
+	await fs.appendFile(filePath, fileContent);
+	return { filePath };
 }
 /** Creates a temporarly file we could use for uploading and downloading. */
 async function createTempFile() {
-    const filePath = path.join(os.tmpdir(), `check-network-temp-${Date.now()}.txt`);
-    const fileContent = "Hello, world! " + new Date().toISOString();
-    await fs__default.writeFile(filePath, fileContent);
-    return { filePath, fileContent };
+	const filePath = path.join(os.tmpdir(), `check-network-temp-${Date.now()}.txt`);
+	const fileContent = "Hello, world! " + (/* @__PURE__ */ new Date()).toISOString();
+	await fs.writeFile(filePath, fileContent);
+	return {
+		filePath,
+		fileContent
+	};
 }
 /** Creates a template and RenderTemplate resources, gets all resources from outputs.
- * Throws a error if any of the outputs failed.
- */
+* Throws a error if any of the outputs failed.
+*/
 async function runTemplate(client, tpl, ephemeral, inputs, outputs) {
-    return await client.withWriteTx("TemplateRender", async (tx) => {
-        const preparedTemplate = await prepareTemplateSpec(tpl);
-        const tplResource = loadTemplate(tx, preparedTemplate);
-        const outputFields = createRenderTemplate(tx, tplResource, ephemeral, inputs(tx), outputs);
-        const outputsIds = {};
-        for (const output of outputs) {
-            const fieldRef = field(client.clientRoot, output);
-            tx.createField(fieldRef, "Dynamic", outputFields[output]);
-            outputsIds[output] = await toGlobalFieldId(fieldRef);
-        }
-        await tx.commit();
-        return outputsIds;
-    });
+	return await client.withWriteTx("TemplateRender", async (tx) => {
+		const outputFields = createRenderTemplate(tx, loadTemplate(tx, await prepareTemplateSpec(tpl)), ephemeral, inputs(tx), outputs);
+		const outputsIds = {};
+		for (const output of outputs) {
+			const fieldRef = field(client.clientRoot, output);
+			tx.createField(fieldRef, "Dynamic", outputFields[output]);
+			outputsIds[output] = await toGlobalFieldId(fieldRef);
+		}
+		await tx.commit();
+		return outputsIds;
+	});
 }
 /** Gets a resource from field's value or throws a error. */
 async function getFieldValue(client, fieldId) {
-    // We could also do polling with pl-tree, but it seemed like an overkill,
-    // that's why we have a simple polling here.
-    return await poll(client, async (tx) => {
-        const field = await tx.tx.getField(fieldId);
-        if (isNotNullResourceId(field.error)) {
-            const err = await tx.tx.getResourceData(field.error, true);
-            throw new Error(`getFieldValue of "${fieldId.fieldName}" field failed: ${err.data}`);
-        }
-        if (isNullResourceId(field.value)) {
-            throw new ContinuePolling();
-        }
-        return await tx.tx.getResourceData(field.value, true);
-    });
+	return await poll(client, async (tx) => {
+		const field = await tx.tx.getField(fieldId);
+		if (isNotNullResourceId(field.error)) {
+			const err = await tx.tx.getResourceData(field.error, true);
+			throw new Error(`getFieldValue of "${fieldId.fieldName}" field failed: ${err.data}`);
+		}
+		if (isNullResourceId(field.value)) throw new ContinuePolling();
+		return await tx.tx.getResourceData(field.value, true);
+	});
 }
 async function deleteFields(client, fieldIds) {
-    await client.withWriteTx("DeleteFields", async (tx) => {
-        for (const fieldId of fieldIds) {
-            tx.resetField(fieldId);
-        }
-        await tx.commit();
-    });
+	await client.withWriteTx("DeleteFields", async (tx) => {
+		for (const fieldId of fieldIds) tx.resetField(fieldId);
+		await tx.commit();
+	});
 }
 
-export { chooseFile, createBigTempFile, createTempFile, downloadFile, downloadFromEveryStorage, listFilesSequence, pythonSoftware, runDownloadFile, runPythonSoftware, runSoftware, runUploadFile, runUploadTemplate, softwareCheck, uploadFile, uploadTemplate };
-//# sourceMappingURL=template.js.map
+//#endregion
+export { createBigTempFile, createTempFile, downloadFile, downloadFromEveryStorage, pythonSoftware, softwareCheck, uploadFile, uploadTemplate };
+//# sourceMappingURL=template.js.map