xlwings-server 1.1.0__py3-none-any.whl

xlwings_server/static/js/core/xlwingsjs/auth.js

@@ -0,0 +1,63 @@
+// Office.auth.getAccessToken claims that it does everything that this module does,
+// only it doesn't: https://github.com/OfficeDev/office-js/issues/3298
+
+let accessToken = null;
+let isRenewingToken = false;
+let tokenLock = false;
+let tokenExpiry = null;
+
+function hasKeyExpired() {
+  if (!tokenExpiry) {
+    return true;
+  }
+  const currentTime = Math.floor(Date.now() / 1000); // Convert to seconds
+  // Renew 15 minutes before expiry
+  return currentTime >= tokenExpiry - 15 * 60;
+}
+
+async function renewAccessToken() {
+  console.log("Renewing access token");
+  try {
+    accessToken = await Office.auth.getAccessToken({
+      allowSignInPrompt: true,
+      allowConsentPrompt: true,
+    });
+
+    // Read exp
+    let payload = accessToken.split(".")[1];
+    // Add padding to base64Url string and then use atob() to decode it
+    let base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    while (base64.length % 4) {
+      base64 += "=";
+    }
+    let decodedPayload = JSON.parse(window.atob(base64));
+    tokenExpiry = decodedPayload.exp;
+
+    accessToken = "Bearer " + accessToken;
+  } catch (error) {
+    let token_error = `Error ${error.code}: ${error.message}`;
+    console.log(token_error);
+    // return token error so it can be logged on backend
+    accessToken = token_error;
+  } finally {
+    tokenLock = false;
+  }
+}
+
+export async function getAccessToken() {
+  await Office.onReady();
+  if (!accessToken || hasKeyExpired()) {
+    if (!tokenLock) {
+      tokenLock = true;
+      isRenewingToken = true;
+      await renewAccessToken();
+
+      isRenewingToken = false;
+    } else {
+      while (isRenewingToken) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
+  return accessToken;
+}

xlwings_server/static/js/core/xlwingsjs/sheet-buttons.js

@@ -0,0 +1,133 @@
+import { showGlobalStatus, hideGlobalStatus } from "./utils.js";
+
+const registeredHandlers = {};
+
+export async function registerSheetButtons(scriptsMeta) {
+  await Office.onReady();
+  await removeAllEventHandlers();
+  for (const meta of scriptsMeta) {
+    // Support both legacy target_cell and button
+    const buttonRef = meta?.button || meta?.target_cell || null;
+    if (buttonRef) {
+      await registerSheetButton(buttonRef, meta);
+    }
+  }
+}
+
+async function registerSheetButton(buttonRef, meta) {
+  // buttonRef is in the form [ShapeName]Sheet1!A1, where [ShapeName] is optional
+  await Excel.run(async (context) => {
+    let shapeName = null;
+    let sheetName, cellRef;
+
+    // Check for optional [] part
+    const match = buttonRef.match(/^\[(.*?)\](.*)$/);
+    if (match) {
+      shapeName = match[1];
+      [sheetName, cellRef] = match[2].split("!");
+    } else {
+      [sheetName, cellRef] = buttonRef.split("!");
+    }
+
+    if (sheetName.startsWith("'") && sheetName.endsWith("'")) {
+      sheetName = sheetName.slice(1, -1);
+    }
+    let sheet = context.workbook.worksheets.getItemOrNullObject(sheetName);
+    await context.sync();
+
+    // Check if shape exists
+    if (shapeName) {
+      let shape = sheet.shapes.getItemOrNullObject(shapeName);
+      await context.sync();
+      if (shape.isNullObject) {
+        return;
+      }
+    }
+
+    // Create a unique key for this handler
+    let scriptName = meta.function_name;
+    const handlerKey = `${buttonRef}_${scriptName}`;
+
+    // Register event handler and store the result
+    const eventResult = sheet.onSelectionChanged.add(async function (event) {
+      let selectedRangeAddress = event.address;
+      if (selectedRangeAddress === cellRef && !sheet.isNullObject) {
+        const startTime = Date.now();
+        try {
+          let authResult =
+            typeof globalThis.getAuth === "function"
+              ? await globalThis.getAuth()
+              : { token: "", provider: "" };
+          if (meta?.show_taskpane) {
+            await Office.addin.showAsTaskpane();
+          }
+          showGlobalStatus(`Running '${scriptName}' ...`);
+          await xlwings.runPython({
+            include: meta?.include || "",
+            exclude: meta?.exclude || "",
+            auth: authResult.token,
+            headers: { "Auth-Provider": authResult.provider },
+            scriptName: scriptName,
+          });
+        } finally {
+          // Only move selection down if it's still on the button cell
+          // If the script changed the selection, leave it as is
+          const currentSelection = context.workbook.getSelectedRange();
+          currentSelection.load("address");
+          await context.sync();
+
+          // Extract cell reference from full address (e.g., 'Sheet1!B4' -> 'B4')
+          const currentAddress = currentSelection.address.split("!").pop();
+          if (currentAddress === selectedRangeAddress) {
+            sheet.getRange(selectedRangeAddress).getOffsetRange(1, 0).select();
+            await context.sync();
+          }
+
+          // Ensure the status is shown for a minimum time to avoid flickering
+          const elapsedTime = Date.now() - startTime;
+          const minDisplayTime = 500; // milliseconds
+
+          if (elapsedTime < minDisplayTime) {
+            await new Promise((resolve) =>
+              setTimeout(resolve, minDisplayTime - elapsedTime),
+            );
+          }
+
+          hideGlobalStatus();
+        }
+      }
+    });
+
+    // Store the event result for later removal if needed
+    registeredHandlers[handlerKey] = eventResult;
+
+    await context.sync();
+  });
+}
+
+// Helper function to remove all registered event handlers
+async function removeAllEventHandlers() {
+  const handlerKeys = Object.keys(registeredHandlers);
+
+  if (handlerKeys.length === 0) {
+    return;
+  }
+
+  for (const key of handlerKeys) {
+    const eventResult = registeredHandlers[key];
+    try {
+      // Use the stored context to remove the handler
+      await Excel.run(eventResult.context, async (context) => {
+        eventResult.remove();
+        await context.sync();
+      });
+    } catch (error) {
+      console.warn(`Failed to remove handler ${key}:`, error);
+    }
+  }
+
+  // Clear the registry
+  Object.keys(registeredHandlers).forEach(
+    (key) => delete registeredHandlers[key],
+  );
+}

xlwings_server/static/js/core/xlwingsjs/utils.js

@@ -0,0 +1,119 @@
+export async function getActiveBookName() {
+  try {
+    await Office.onReady();
+    return await Excel.run(async (context) => {
+      const workbook = context.workbook;
+      workbook.load("name");
+      await context.sync();
+      return workbook.name;
+    });
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+// Culture Info Name, e.g., en-DE
+let cachedCultureInfoName = null;
+export async function getCultureInfoName() {
+  if (cachedCultureInfoName) {
+    return cachedCultureInfoName;
+  }
+  if (!Office.context.requirements.isSetSupported("ExcelApi", "1.12")) {
+    return null;
+  }
+  const context = new Excel.RequestContext();
+  context.application.cultureInfo.load(["name"]);
+  await context.sync();
+  cachedCultureInfoName = `${context.application.cultureInfo.name}`;
+  return cachedCultureInfoName;
+}
+
+// Date format
+let cachedDateFormat = null;
+export async function getDateFormat() {
+  if (cachedDateFormat) {
+    return cachedDateFormat;
+  }
+  if (!Office.context.requirements.isSetSupported("ExcelApi", "1.12")) {
+    return null;
+  }
+  const context = new Excel.RequestContext();
+  context.application.cultureInfo.datetimeFormat.load(["shortDatePattern"]);
+  await context.sync();
+  cachedDateFormat = `${context.application.cultureInfo.datetimeFormat.shortDatePattern}`;
+  return cachedDateFormat;
+}
+
+export function printSupportedApiVersions() {
+  const versions = [...Array(30)].map((_, i) => `1.${i}`);
+
+  async function printBuildInfo() {
+    if (Office.context.diagnostics) {
+      console.log(`User Agent: ${navigator.userAgent}`);
+      console.log(`Office Build: ${Office.context.diagnostics.version}`);
+      console.log(`Office Platform: ${Office.context.diagnostics.platform}`);
+      console.log(
+        `Culture Info Name: ${(await getCultureInfoName()) || "N/A"}`,
+      );
+      console.log(`Local Date Format: ${(await getDateFormat()) || "N/A"}`);
+    }
+  }
+
+  function printSupportedVersion(apiName) {
+    let supportedVersion = null;
+
+    for (const version of versions) {
+      if (Office.context.requirements.isSetSupported(apiName, version)) {
+        supportedVersion = version;
+      } else {
+        break;
+      }
+    }
+
+    if (supportedVersion) {
+      console.log(`${apiName}: ${supportedVersion}`);
+    } else {
+      console.log(`${apiName}: N/A`);
+    }
+  }
+
+  Office.onReady(async () => {
+    await printBuildInfo();
+    const apiNames = [
+      "ExcelAPI",
+      "SharedRuntime",
+      "CustomFunctions",
+      "CustomFunctionsRuntime",
+      "DialogAPI",
+      "RibbonAPI",
+    ];
+
+    apiNames.forEach((name) => {
+      printSupportedVersion(name);
+    });
+  });
+}
+
+export function showGlobalError(message) {
+  const alertEl = document.getElementById("global-error-alert");
+  const alertMessage = alertEl.querySelector("span");
+  alertMessage.textContent = message;
+  alertEl.classList.remove("d-none");
+}
+
+export function showGlobalStatus(message) {
+  const alertEl = document.getElementById("global-status-alert");
+  const alertMessage = alertEl.querySelector("span");
+  alertMessage.textContent = message;
+  alertEl.classList.remove("d-none");
+}
+
+export function hideGlobalError() {
+  const alertEl = document.getElementById("global-error-alert");
+  alertEl.classList.add("d-none");
+}
+
+export function hideGlobalStatus() {
+  const alertEl = document.getElementById("global-status-alert");
+  alertEl.classList.add("d-none");
+}

xlwings_server/static/js/core/xlwingsjs/wasm.js

@@ -0,0 +1,131 @@
+async function initPyodide() {
+  if (config.onWasm === false) {
+    return;
+  }
+
+  const globalStatusAlert = document.querySelector("#global-status-alert");
+  const globalErrorAlert = document.querySelector("#global-error-alert");
+
+  try {
+    // Show loading status
+    if (globalStatusAlert && !config.isOfficialLiteAddin) {
+      globalStatusAlert.classList.remove("d-none");
+      globalStatusAlert.querySelector("span").innerHTML = `
+        <div class="spinner-border spinner-border-sm text-alert me-1" role="status">
+          <span class="visually-hidden">Loading...</span>
+        </div>
+        Loading...
+      `;
+    }
+
+    // Hide any previous error
+    if (globalErrorAlert) {
+      globalErrorAlert.classList.add("d-none");
+    }
+
+    let pyodide = await loadPyodide();
+
+    const pyodideConfigResponse = await fetch(
+      config.appPath + "/xlwings/pyodide.json",
+    );
+    if (!pyodideConfigResponse.ok) {
+      throw new Error(
+        `Failed to fetch pyodide config: ${pyodideConfigResponse.statusText}`,
+      );
+    }
+    const pyodideConfigData = await pyodideConfigResponse.json();
+
+    // Install dependencies
+    if (!config.isOfficialLiteAddin) {
+      await pyodide.loadPackage("micropip");
+      const micropip = pyodide.pyimport("micropip");
+      let packages = pyodideConfigData["packages"];
+      await micropip.install(packages, { keep_going: true });
+    }
+
+    // Python files
+    const files = pyodideConfigData["files"];
+    function createDirectories(files) {
+      const createdDirs = new Set();
+      Object.values(files).forEach((localPath) => {
+        const parts = localPath.split("/");
+        if (parts.length > 1) {
+          const dirPath = parts.slice(0, parts.length - 1).join("/");
+          if (!createdDirs.has(dirPath)) {
+            // TODO: does this work for nested dirs? Also, ./ is probably wrong
+            if (dirPath !== ".") {
+              pyodide.FS.mkdir(dirPath);
+              pyodide.FS.mount(pyodide.FS.filesystems.MEMFS, {}, dirPath);
+            }
+            createdDirs.add(dirPath);
+          }
+        }
+      });
+    }
+
+    createDirectories(files);
+
+    for (const [endpoint, localPath] of Object.entries(files)) {
+      const response = await fetch(config.appPath + endpoint);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${endpoint}: ${response.statusText}`);
+      }
+      const content = await response.text();
+      pyodide.FS.writeFile(localPath, content);
+    }
+
+    if (!config.isOfficialLiteAddin) {
+      // Entrypoint
+      let mainText = pyodide.FS.readFile("./main.py", { encoding: "utf8" });
+      await pyodide.runPythonAsync(mainText);
+
+      // Functions
+      // You can't simply export them as the will be null when used in
+      // custom-functions-code.js (it's only assigned the function here).
+      globalThis.wasmCustomFunctionsCall = pyodide.globals.get(
+        "custom_functions_call",
+      );
+      globalThis.getXlwingsScripts = pyodide.globals.get("get_xlwings_scripts");
+      globalThis.wasmCustomFunctionsMeta = pyodide.globals.get(
+        "custom_functions_meta",
+      );
+      globalThis.wasmCustomFunctionsCode = pyodide.globals.get(
+        "custom_functions_code",
+      );
+      globalThis.wasmCustomScriptsCall = pyodide.globals.get(
+        "custom_scripts_call",
+      );
+      globalThis.wasmCustomScriptsMeta = pyodide.globals.get(
+        "custom_scripts_meta",
+      );
+
+      // Hide loading status on success
+      if (globalStatusAlert) {
+        globalStatusAlert.classList.add("d-none");
+      }
+    }
+
+    return pyodide;
+  } catch (err) {
+    console.error("Pyodide initialization failed:", err);
+
+    // Hide loading status
+    if (globalStatusAlert) {
+      globalStatusAlert.classList.add("d-none");
+    }
+
+    // Show error alert
+    if (globalErrorAlert) {
+      globalErrorAlert.classList.remove("d-none");
+      globalErrorAlert.innerHTML = `
+          Error initializing Pyodide: ${err.message}
+      `;
+    }
+
+    throw err;
+  }
+}
+
+// Call as follows:
+// let pyodide = await pyodideReadyPromise;
+export let pyodideReadyPromise = initPyodide();