xlwings-server 1.1.0__py3-none-any.whl

xlwings_server/static/js/core/custom-functions-code.js

@@ -0,0 +1,296 @@
+const debug = false;
+let invocations = new Set();
+let bodies = new Set();
+let runtime;
+let socket = null;
+
+Office.onReady(function (info) {
+  // Socket.io
+  socket = globalThis.socket ? globalThis.socket : null;
+
+  if (socket !== null) {
+    socket.on("disconnect", () => {
+      if (debug) {
+        console.log("disconnect");
+      }
+      for (let invocation of invocations) {
+        invocation.setResult([["Stream disconnected"]]);
+      }
+      invocations.clear();
+    });
+
+    socket.on("connect", () => {
+      // Without this, you'd have to hit Ctrl+Alt+F9, which isn't available on the web
+      if (debug) {
+        console.log("connect");
+      }
+      for (let body of bodies) {
+        socket.emit("xlwings:function-call", body);
+      }
+    });
+  }
+
+  // Runtime version
+  if (
+    Office.context.requirements.isSetSupported("CustomFunctionsRuntime", "1.4")
+  ) {
+    runtime = "1.4";
+  } else if (
+    Office.context.requirements.isSetSupported("CustomFunctionsRuntime", "1.3")
+  ) {
+    runtime = "1.3";
+  } else if (
+    Office.context.requirements.isSetSupported("CustomFunctionsRuntime", "1.2")
+  ) {
+    runtime = "1.2";
+  } else {
+    runtime = "1.1";
+  }
+});
+
+function flattenVarargsArray(arr) {
+  // Turn [ [[0]], [ [[0]], [[0]] ] ] into:
+  // result: [ [[0]], [[0]], [[0]] ]
+  // indices: [ [ 0 ], [ 1, 0 ], [ 1, 1 ] ]
+  const result = [];
+  const indices = [];
+
+  function isTripleNested(item) {
+    return (
+      Array.isArray(item) && Array.isArray(item[0]) && Array.isArray(item[0][0])
+    );
+  }
+
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+
+    if (isTripleNested(item)) {
+      result.push(...item);
+      for (let j = 0; j < item.length; j++) {
+        indices.push([i, j]);
+      }
+    } else {
+      result.push(item);
+      indices.push([i]);
+    }
+  }
+
+  // Create a prototype-less object to return to prevent prototype-pollution-loop
+  const returnObject = Object.create(null);
+  returnObject.result = result;
+  returnObject.indices = indices;
+
+  return returnObject;
+}
+
+// Workbook name
+let cachedWorkbookName = null;
+
+async function getWorkbookName() {
+  if (cachedWorkbookName) {
+    return cachedWorkbookName;
+  }
+  const context = new Excel.RequestContext();
+  const workbook = context.workbook;
+  workbook.load("name");
+  await context.sync();
+  cachedWorkbookName = workbook.name;
+  return cachedWorkbookName;
+}
+
+class Semaphore {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    this.currentConcurrency = 0;
+    this.queue = [];
+  }
+
+  async acquire() {
+    if (this.currentConcurrency < this.maxConcurrency) {
+      this.currentConcurrency++;
+      return;
+    }
+    return new Promise((resolve) => this.queue.push(resolve));
+  }
+
+  release() {
+    this.currentConcurrency--;
+    if (this.queue.length > 0) {
+      this.currentConcurrency++;
+      const nextResolve = this.queue.shift();
+      nextResolve();
+    }
+  }
+}
+
+const semaphore = new Semaphore(1000);
+
+async function base() {
+  await Office.onReady(); // Block execution until office.js is ready
+  // Arguments
+  let argsArr = Array.prototype.slice.call(arguments);
+  let funcName = argsArr[0];
+  let isStreaming = argsArr[1];
+  let args = argsArr.slice(2, -1);
+  let invocation = argsArr[argsArr.length - 1];
+
+  const workbookName = await getWorkbookName();
+  const officeApiClient = localStorage.getItem("Office API client");
+
+  // For arguments that are Entities, replace the arg with their address (cache key).
+  // The issues is that invocation.parameterAddresses returns a flat list while args
+  // contains a nested array for varargs (in Office.js called 'repeating').
+  const { result: flatArgs, indices } = flattenVarargsArray(args);
+
+  // Process each flattened item with respect to its path
+  flatArgs.forEach((item, index) => {
+    if (item && item[0][0]?.type === "Entity") {
+      const address = `${officeApiClient}[${workbookName}]${invocation.parameterAddresses[index]}`;
+
+      let target = args;
+      const path = indices[index];
+
+      for (let i = 0; i < path.length - 1; i++) {
+        target = target[path[i]];
+      }
+
+      const lastIndex = path[path.length - 1];
+      target[lastIndex] = [address];
+    }
+  });
+
+  // Body
+  let body = {
+    client: "Office.js",
+    func_name: funcName,
+    args: args,
+    caller_address: `${officeApiClient}[${workbookName}]${invocation.address}`, // not available for streaming functions
+    culture_info_name: await xlwings.getCultureInfoName(),
+    date_format: await xlwings.getDateFormat(),
+    version: "placeholder_xlwings_version",
+    runtime: runtime,
+  };
+
+  // Streaming functions communicate via socket.io
+  if (isStreaming) {
+    if (socket === null) {
+      console.error(
+        "To enable streaming functions, you need to load the socket.io js client before xlwings.js and custom-functions-code",
+      );
+      return;
+    }
+    let taskKey = `${funcName}_${args}`;
+    body.task_key = taskKey;
+    socket.emit("xlwings:function-call", body);
+    if (debug) {
+      console.log(`emit xlwings:function-call ${funcName}`);
+    }
+    invocation.setResult([["Waiting for stream..."]]);
+
+    socket.off(`xlwings:set-result-${taskKey}`);
+    socket.on(`xlwings:set-result-${taskKey}`, (data) => {
+      invocation.setResult(data.result);
+      if (debug) {
+        console.log(`Set Result`);
+      }
+    });
+
+    invocations.add(invocation);
+    bodies.add(body);
+
+    return;
+  }
+
+  // Normal functions communicate via REST API
+  if (config.onWasm) {
+    return await makeWasmCall(body);
+  } else {
+    return await makeServerCall(body);
+  }
+}
+
+async function makeServerCall(body) {
+  const MAX_RETRIES = config.customFunctionsMaxRetries;
+  const RETRY_CODES = config.customFunctionsRetryCodes;
+  let attempt = 0;
+
+  while (attempt < MAX_RETRIES) {
+    attempt++;
+    let authResult =
+      typeof globalThis.getAuth === "function"
+        ? await globalThis.getAuth()
+        : { token: "", provider: "" };
+    let headers = {
+      "Content-Type": "application/json",
+      sid: socket && socket.id ? socket.id.toString() : null,
+      Authorization: authResult.token,
+      "Auth-Provider": authResult.provider,
+    };
+
+    await semaphore.acquire();
+    try {
+      const response = await axios.post(
+        window.location.origin + "placeholder_custom_functions_call_path",
+        body,
+        {
+          headers: headers,
+          timeout: config.requestTimeout * 1000,
+        },
+      );
+
+      return response.data.result;
+    } catch (error) {
+      console.error(`Attempt ${attempt}: ${error.toString()}`);
+      if (error.response) {
+        const errMsg =
+          (error.response.data && error.response.data.detail) ||
+          (error.response.data && error.response.data.error) ||
+          (typeof error.response.data === "object"
+            ? JSON.stringify(error.response.data)
+            : error.response.data) ||
+          error.response.statusText ||
+          "Unknown server error";
+        console.error(`Attempt ${attempt}: ${errMsg}`);
+
+        // Only retry if the status code is in the retry codes list
+        const shouldRetry = RETRY_CODES.includes(error.response.status);
+        if (attempt === MAX_RETRIES || !shouldRetry) {
+          return showError(errMsg);
+        }
+      } else if (attempt === MAX_RETRIES) {
+        return showError(error.toString());
+      }
+    } finally {
+      semaphore.release();
+    }
+  }
+}
+
+async function makeWasmCall(body) {
+  try {
+    let result = await globalThis.wasmCustomFunctionsCall(body);
+    if (result.error) {
+      console.error(result.details);
+      showError(result.error);
+    }
+    return result;
+  } catch (error) {
+    console.error(error);
+    showError(error);
+  }
+}
+
+function showError(errorMessage) {
+  if (
+    Office.context.requirements.isSetSupported("CustomFunctionsRuntime", "1.2")
+  ) {
+    // Error message is only visible by hovering over the error flag!
+    let excelError = new CustomFunctions.Error(
+      CustomFunctions.ErrorCode.invalidValue,
+      errorMessage,
+    );
+    throw excelError;
+  } else {
+    return [[errorMessage]];
+  }
+}

xlwings_server/static/js/core/examples.js

@@ -0,0 +1,62 @@
+function alertCallback(arg) {
+  let outputContainer = document.getElementById("output-container");
+  if (!outputContainer) {
+    outputContainer = document.createElement("div");
+    outputContainer.id = "output-container";
+    document.querySelector(".container-fluid").appendChild(outputContainer);
+  }
+  outputContainer.textContent = `User clicked: ${arg}`;
+}
+xlwings.registerCallback(alertCallback);
+
+const visibility = {
+  isOpen: false,
+  label: "Show",
+  toggle() {
+    this.isOpen = !this.isOpen;
+    this.label = this.isOpen ? "Hide" : "Show";
+  },
+};
+registerAlpineComponent("visibility", visibility);
+
+const slider = {
+  percentage: 50,
+  update() {
+    this.percentage = this.$el.value;
+  },
+};
+registerAlpineComponent("slider", slider);
+
+const nameForm = {
+  firstName: "",
+  lastName: "",
+  fullName: "(empty)",
+  focus() {
+    this.$el.focus();
+  },
+  handleInput() {
+    this[this.$el.name] = this.$el.value;
+    const fullName = `${this.firstName} ${this.lastName}`;
+    this.fullName = !this.firstName && !this.lastName ? "(empty)" : fullName;
+  },
+};
+registerAlpineComponent("nameForm", nameForm);
+
+const appLoader = {
+  url: "",
+  async init() {
+    let bookName = await xlwings.getActiveBookName();
+    // Works with both an unsaved book ("Book1") as well as a saved one "Book1.xlsx"
+    if (bookName.includes("Book1")) {
+      // TODO: fix if app_path is provided
+      this.url = "/taskpane?app=1";
+    } else {
+      this.url = "/taskpane?app=2";
+    }
+    this.$nextTick(() => {
+      htmx.process(this.$el);
+      this.$dispatch("app:loadTaskpane");
+    });
+  },
+};
+registerAlpineComponent("appLoader", appLoader);

xlwings_server/static/js/core/hotreload.js

@@ -0,0 +1,3 @@
+globalThis.socket.on("reload", () => {
+  location.reload();
+});

xlwings_server/static/js/core/htmx-handlers.js

@@ -0,0 +1,86 @@
+// Config
+htmx.config.includeIndicatorStyles = false; // required by CSP
+htmx.config.historyCacheSize = 0;
+htmx.config.allowEval = false;
+htmx.config.selfRequestsOnly = true;
+
+// Error handling
+htmx.on("htmx:sendError", function (event) {
+  // Connection issues
+  const globalErrorAlert = document.querySelector("#global-error-alert");
+  globalErrorAlert.classList.remove("d-none");
+  globalErrorAlert.querySelector("span").textContent =
+    "Connection error. Please reload the page!";
+});
+
+htmx.on("htmx:responseError", function (event) {
+  // Unhandled exceptions from Python partials or nginx.
+  // Exceptions with full page reloads are handled with FastAPI exceptions handlers.
+  const globalErrorAlert = document.querySelector("#global-error-alert");
+  const errorCode = event.detail.xhr.status;
+  globalErrorAlert.classList.remove("d-none");
+  if (errorCode === 404) {
+    globalErrorAlert.querySelector("span").textContent =
+      `Error ${errorCode}: Page not found`;
+  } else if (errorCode === 500) {
+    globalErrorAlert.querySelector("span").textContent = `Error ${errorCode}`;
+  } else if (errorCode === 401) {
+    globalErrorAlert.querySelector("span").textContent =
+      `Error ${errorCode}: Unauthorized`;
+  } else if (errorCode === 403) {
+    globalErrorAlert.querySelector("span").textContent =
+      `Error ${errorCode}: Forbidden`;
+  } else {
+    // Mostly 502/503/504 errors
+    globalErrorAlert.querySelector("span").textContent =
+      `Error ${errorCode}: Please reload the page!`;
+  }
+});
+
+// Task pane authentication (see: https://htmx.org/examples/async-auth/)
+// and bookData handling
+let authResult = null;
+let bookData = null;
+
+htmx.on("htmx:confirm", async (event) => {
+  // Block the request until the token is returned
+  event.preventDefault();
+  // Auth
+  authResult = await globalThis.getAuth();
+  // Book
+  let element = event.target;
+  let includeBook = element.getAttribute("xw-book");
+  if (includeBook === "true") {
+    let config = element.getAttribute("xw-config")
+      ? JSON.parse(element.getAttribute("xw-config"))
+      : {};
+    // TODO: use default context
+    await Excel.run(async (context) => {
+      bookData = await xlwings.getBookData(config, context);
+    });
+  }
+
+  // Resume the request
+  event.detail.issueRequest();
+});
+
+htmx.on("htmx:configRequest", (event) => {
+  event.detail.headers["Authorization"] = authResult.token;
+  event.detail.headers["Auth-Provider"] = authResult.provider;
+  let element = event.target;
+  let includeBook = element.getAttribute("xw-book");
+  if (includeBook === "true") {
+    event.detail.parameters["bookData"] = JSON.stringify(bookData);
+  }
+});
+
+htmx.on("htmx:afterSwap", async (event) => {
+  const bookDataElement = document.getElementById("book-data");
+  if (bookDataElement) {
+    const bookDataJson = JSON.parse(bookDataElement.text);
+    await Excel.run(async (context) => {
+      xlwings.runActions(bookDataJson, context);
+    });
+  }
+  await xlwings.init();
+});

xlwings_server/static/js/core/officejs-history-fix-part1.js

@@ -0,0 +1,3 @@
+// https://github.com/OfficeDev/office-js/issues/429#issuecomment-1971645795
+const originalReplaceState = history.replaceState;
+const originalPushState = history.pushState;

xlwings_server/static/js/core/officejs-history-fix-part2.js

@@ -0,0 +1,2 @@
+history.replaceState = originalReplaceState;
+history.pushState = originalPushState;

xlwings_server/static/js/core/reload-custom-functions.js

@@ -0,0 +1,79 @@
+async function reloadCustomFunctions(meta = null, code = null) {
+  // Unofficial API: https://github.com/OfficeDev/office-js/issues/3486
+  // This causes issues when opening a workbook in a running instance of Excel. If
+  // Excel is completely closed, it does load the add-in, but not if it is already
+  // running.
+  // Custom functions will show #NAME? until the task pane is opened
+  // manually. That's why this is only loaded in "dev" environment.
+  // await Office.addin.setStartupBehavior(Office.StartupBehavior.load); should solve
+  // the issue, but you should have a way to switch it off again, as otherwise, if you
+  // open the add-in in an unrelated workbook by accident, it would open the add-in
+  // every time you open that workbook.
+  await Office.onReady();
+  let jsonMetadataString;
+  let functionCode;
+
+  if (Office.context.requirements.isSetSupported("CustomFunctions", "1.6")) {
+    try {
+      if (meta && code) {
+        jsonMetadataString = meta;
+        functionCode = code;
+      } else {
+        const [metadataResponse, codeResponse] = await Promise.all([
+          fetch(`${config.appPath}/xlwings/custom-functions-meta.json`),
+          fetch(`${config.appPath}/xlwings/custom-functions-code.js`),
+        ]);
+
+        if (!metadataResponse.ok || !codeResponse.ok) {
+          throw new Error("Failed to fetch custom functions data");
+        }
+
+        jsonMetadataString = await metadataResponse.text();
+        functionCode = await codeResponse.text();
+      }
+
+      await Excel.CustomFunctionManager.register(
+        jsonMetadataString,
+        functionCode,
+      );
+      // console.log(jsonMetadataString)
+      // console.log(functionCode)
+      console.log("Successfully reloaded custom functions!");
+    } catch (error) {
+      console.error("Error reloading custom functions:", error);
+    }
+  } else {
+    try {
+      await Excel.run(async (context) => {
+        Excel.CustomFunctionManager.newObject(context).register(
+          jsonMetadataString,
+          functionCode,
+        );
+        await context.sync();
+      });
+    } catch (error) {
+      console.error("Failed to register custom functions:", error);
+    }
+  }
+}
+
+async function retryReloadCustomFunctions(retries, delay) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await reloadCustomFunctions();
+      // console.log(`Reloaded custom functions code at attempt ${i + 1}`);
+      return;
+    } catch (error) {
+      if (i === retries - 1) throw error;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+
+if (!config.isOfficialLiteAddin) {
+  (async () => {
+    const maxRetries = 5;
+    const delay = 100;
+    await retryReloadCustomFunctions(maxRetries, delay);
+  })();
+}

xlwings_server/static/js/core/socketio-handlers.js

@@ -0,0 +1,34 @@
+// Socket.io
+try {
+  globalThis.socket = io({
+    transports: ["websocket", "polling"],
+    path: `${config.appPath}/socket.io/`,
+    auth: async (callback) => {
+      let authResult =
+        typeof globalThis.getAuth === "function"
+          ? await globalThis.getAuth()
+          : { token: "", provider: "" };
+      callback({
+        token: authResult.token,
+        provider: authResult.provider,
+      });
+    },
+  });
+} catch (error) {
+  console.log("Didn't load socket.io: ", error);
+  globalThis.socket = null;
+}
+
+globalThis.socket.on("xlwings:trigger-script", async (data) => {
+  let authResult =
+    typeof globalThis.getAuth === "function"
+      ? await globalThis.getAuth()
+      : { token: "", provider: "" };
+  xlwings.runPython({
+    include: data?.include || "",
+    exclude: data?.exclude || "",
+    auth: authResult.token,
+    headers: { "Auth-Provider": authResult.provider },
+    scriptName: data.script_name,
+  });
+});

xlwings_server/static/js/core/xlwings-alert.js

@@ -0,0 +1,22 @@
+if (document.getElementById("ok")) {
+  document.getElementById("ok").addEventListener("click", buttonCallback);
+}
+if (document.getElementById("yes")) {
+  document.getElementById("yes").addEventListener("click", buttonCallback);
+}
+if (document.getElementById("no")) {
+  document.getElementById("no").addEventListener("click", buttonCallback);
+}
+if (document.getElementById("cancel")) {
+  document.getElementById("cancel").addEventListener("click", buttonCallback);
+}
+function buttonCallback() {
+  Office.onReady(() => {
+    // This causes this issue: https://github.com/OfficeDev/office-js/issues/3582
+    Office.context.ui.messageParent(
+      this.id +
+        "|" +
+        document.getElementById("callback").getAttribute("data-callback"),
+    );
+  });
+}

xlwings_server/static/js/core/xlwingsjs/alert.js

@@ -0,0 +1,85 @@
+// https://learn.microsoft.com/en-us/office/dev/add-ins/develop/dialog-api-in-office-add-ins
+
+let dialog;
+
+function dialogCallback(asyncResult) {
+  if (asyncResult.status === Office.AsyncResultStatus.Failed) {
+    console.log(`${asyncResult.error.message} [${asyncResult.error.code}]`);
+  } else {
+    dialog = asyncResult.value;
+    // Handle messages and events
+    dialog.addEventHandler(
+      Office.EventType.DialogMessageReceived,
+      processMessage,
+    );
+    dialog.addEventHandler(
+      Office.EventType.DialogEventReceived,
+      processDialogEvent,
+    );
+  }
+}
+
+function processMessage(arg) {
+  dialog.close();
+  let [selection, callback] = arg.message.split("|");
+  if (callback !== "" && callback in globalThis.callbacks) {
+    globalThis.callbacks[callback](selection);
+  } else {
+    if (callback !== "" && !(callback in globalThis.callbacks)) {
+      throw new Error(
+        `Didn't find callback '${callback}'! Make sure to run xlwings.registerCallback(${callback}) before calling runPython.`,
+      );
+    }
+  }
+}
+
+function processDialogEvent(arg) {
+  switch (arg.error) {
+    case 12002:
+      console.log(
+        "The dialog box has been directed to a page that it cannot find or load, or the URL syntax is invalid.",
+      );
+      break;
+    case 12003:
+      console.log("HTTPS is required.");
+      break;
+    case 12006:
+      console.log("Dialog closed by user");
+      break;
+    default:
+      console.log("Unknown error in dialog box");
+      break;
+  }
+}
+
+export async function xlAlert(prompt, title, buttons, mode, callback) {
+  await Office.onReady();
+  let width;
+  let height;
+  if (Office.context.platform.toString() === "OfficeOnline") {
+    width = 28;
+    height = 36;
+  } else if (Office.context.platform.toString() === "PC") {
+    width = 28; // seems to have a wider min width
+    height = 40;
+  } else {
+    width = 32;
+    height = 30;
+  }
+
+  if (dialog) {
+    dialog.close();
+    console.log("Closed perviously open dialog to prevent error 12007.");
+  }
+  Office.context.ui.displayDialogAsync(
+    window.location.origin +
+      config.appPath +
+      `/xlwings/alert?prompt=` +
+      encodeURIComponent(`${prompt}`) +
+      `&title=` +
+      encodeURIComponent(`${title}`) +
+      `&buttons=${buttons}&mode=${mode}&callback=${callback}`,
+    { height: height, width: width, displayInIframe: true },
+    dialogCallback,
+  );
+}