A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
refactor: change/cleanup transport logic for different backens (ws, pyodide, static) (#7552)
Myles Scolnick3ba0e3d3df83
diff --git a/development_docs/pyodide.md b/development_docs/pyodide.mdindex 333693ccf6..342fca9f7c 100644--- a/development_docs/pyodide.md+++ b/development_docs/pyodide.md@@ -4,7 +4,7 @@```bashcd frontend-PYODIDE=true pnpm dev+PYODIDE=true VITE_WASM_MARIMO_PREBUILT_WHEEL=true pnpm dev```## Running the frontend against a local backend@@ -16,5 +16,5 @@ hatch builduv run pyodide/build_and_serve.py# in another terminalcd frontend-PYODIDE=true VITE_MARIMO_VERSION=$(marimo --version) pnpm dev+PYODIDE=true pnpm dev```diff --git a/frontend/src/core/edit-app.tsx b/frontend/src/core/edit-app.tsxindex 5a2549ced7..ac263e7780 100644--- a/frontend/src/core/edit-app.tsx+++ b/frontend/src/core/edit-app.tsx@@ -35,7 +35,7 @@ import { useRequestClient } from "./network/requests";import { useFilename } from "./saving/filename";import { lastSavedNotebookAtom } from "./saving/state";import { useJotaiEffect } from "./state/jotai";-import { useMarimoWebSocket } from "./websocket/useMarimoWebSocket";+import { useMarimoKernelConnection } from "./websocket/useMarimoKernelConnection";interface AppProps {/**@@ -80,7 +80,7 @@ export const EditApp: React.FC<AppProps> = ({};}, []);- const { connection } = useMarimoWebSocket({+ const { connection } = useMarimoKernelConnection({autoInstantiate: userConfig.runtime.auto_instantiate,setCells: (cells, layout) => {setCells(cells);diff --git a/frontend/src/core/run-app.tsx b/frontend/src/core/run-app.tsxindex 3a0116a61e..c3538934c0 100644--- a/frontend/src/core/run-app.tsx+++ b/frontend/src/core/run-app.tsx@@ -13,7 +13,7 @@ import { RuntimeState } from "./kernel/RuntimeState";import { getSessionId } from "./kernel/session";import { useRequestClient } from "./network/requests";import { isAppConnecting } from "./websocket/connection-utils";-import { useMarimoWebSocket } from "./websocket/useMarimoWebSocket";+import { useMarimoKernelConnection } from "./websocket/useMarimoKernelConnection";interface AppProps {appConfig: AppConfig;@@ -31,7 +31,7 @@ export const RunApp: React.FC<AppProps> = ({ appConfig }) => {};}, []);- const { connection } = useMarimoWebSocket({+ const { connection } = useMarimoKernelConnection({autoInstantiate: true,setCells: setCells,sessionId: getSessionId(),diff --git a/frontend/src/core/wasm/bridge.ts b/frontend/src/core/wasm/bridge.tsindex cfb2e392de..146d84ba82 100644--- a/frontend/src/core/wasm/bridge.ts+++ b/frontend/src/core/wasm/bridge.ts@@ -29,7 +29,8 @@ import type {Snippets,} from "../network/types";import { store } from "../state/jotai";-import type { IReconnectingWebSocket } from "../websocket/types";+import { BasicTransport } from "../websocket/transports/basic";+import type { IConnectionTransport } from "../websocket/transports/transport";import { PyodideRouter } from "./router";import { getWorkerRPC } from "./rpc";import { createShareableLink } from "./share";@@ -55,7 +56,9 @@ export class PyodideBridge implements RunRequests, EditRequests {private rpc!: ReturnType<typeof getWorkerRPC<WorkerSchema>>;private saveRpc: SaveWorker | undefined;private interruptBuffer?: Uint8Array;- private messageConsumer: ((message: string) => void) | undefined;+ private messageConsumer:+ | ((message: MessageEvent<string>) => void)+ | undefined;public initialized = new Deferred<void>();@@ -131,7 +134,7 @@ export class PyodideBridge implements RunRequests, EditRequests {this.initialized.reject(new Error(error));});this.rpc.addMessageListener("kernelMessage", ({ message }) => {- this.messageConsumer?.(message);+ this.messageConsumer?.(new MessageEvent("message", { data: message }));});}@@ -184,7 +187,7 @@ export class PyodideBridge implements RunRequests, EditRequests {}}- consumeMessages(consumer: (message: string) => void) {+ attachMessageConsumer(consumer: (message: MessageEvent<string>) => void) {this.messageConsumer = consumer;this.rpc.proxy.send.consumerReady({});}@@ -562,88 +565,8 @@ export class PyodideBridge implements RunRequests, EditRequests {}}-export class PyodideWebsocket implements IReconnectingWebSocket {- CONNECTING = WebSocket.CONNECTING;- OPEN = WebSocket.OPEN;- CLOSING = WebSocket.CLOSING;- CLOSED = WebSocket.CLOSED;- binaryType = "blob" as BinaryType;- bufferedAmount = 0;- extensions = "";- protocol = "";- url = "";-- onclose = null;- onerror = null;- onmessage = null;- onopen = null;-- openSubscriptions = new Set<() => void>();- closeSubscriptions = new Set<() => void>();- messageSubscriptions = new Set<(event: MessageEvent) => void>();- errorSubscriptions = new Set<(event: Event) => void>();-- private bridge: Pick<PyodideBridge, "consumeMessages">;-- constructor(bridge: Pick<PyodideBridge, "consumeMessages">) {- this.bridge = bridge;- }-- private consumeMessages() {- this.bridge.consumeMessages((message) => {- this.messageSubscriptions.forEach((callback) => {- callback({ data: message } as MessageEvent);- });- });- }-- addEventListener(type: unknown, callback: any, options?: unknown): void {- switch (type) {- case "open":- this.openSubscriptions.add(callback);- // Call open right away- callback();- break;- case "close":- this.closeSubscriptions.add(callback);- break;- case "message":- this.messageSubscriptions.add(callback);- // Don't start consuming messages until we have a message listener- this.consumeMessages();- break;- case "error":- this.errorSubscriptions.add(callback);- break;- }- }-- removeEventListener(type: unknown, callback: any, options?: unknown): void {- switch (type) {- case "open":- this.openSubscriptions.delete(callback);- break;- case "close":- this.closeSubscriptions.delete(callback);- break;- case "message":- this.messageSubscriptions.delete(callback);- break;- case "error":- this.errorSubscriptions.delete(callback);- break;- }- }-- dispatchEvent = throwNotImplemented;- reconnect = throwNotImplemented;- send = throwNotImplemented;-- readyState = WebSocket.OPEN;- retryCount = 0;- shouldReconnect = false;-- close() {- return;- }+export function createPyodideConnection(): IConnectionTransport {+ return BasicTransport.withProducerCallback((callback) => {+ PyodideBridge.INSTANCE.attachMessageConsumer(callback);+ });}diff --git a/frontend/src/core/wasm/worker/getMarimoWheel.ts b/frontend/src/core/wasm/worker/getMarimoWheel.tsindex 104363ce5c..a323884bad 100644--- a/frontend/src/core/wasm/worker/getMarimoWheel.ts+++ b/frontend/src/core/wasm/worker/getMarimoWheel.ts@@ -1,10 +1,15 @@/* Copyright 2024 Marimo. All rights reserved. */export function getMarimoWheel(version: string) {- if (import.meta.env.DEV && import.meta.env.VITE_MARIMO_VERSION) {+ if (import.meta.env.DEV && import.meta.env.VITE_WASM_MARIMO_PREBUILT_WHEEL) {+ return "marimo-base";+ }++ if (import.meta.env.DEV) {return `http://localhost:8000/dist/marimo-${import.meta.env.VITE_MARIMO_VERSION}-py3-none-any.whl`;}+return "marimo-base";}diff --git a/frontend/src/core/websocket/StaticWebsocket.ts b/frontend/src/core/websocket/StaticWebsocket.tsdeleted file mode 100644index c838c3f26a..0000000000--- a/frontend/src/core/websocket/StaticWebsocket.ts+++ /dev/null@@ -1,61 +0,0 @@-/* Copyright 2024 Marimo. All rights reserved. */--import { isIslands } from "@/core/islands/utils";-import type { IReconnectingWebSocket } from "./types";--export class StaticWebsocket implements IReconnectingWebSocket {- CONNECTING = WebSocket.CONNECTING;- OPEN = WebSocket.OPEN;- CLOSING = WebSocket.CLOSING;- CLOSED = WebSocket.CLOSED;- binaryType = "blob" as BinaryType;- bufferedAmount = 0;- extensions = "";- protocol = "";- url = "";-- onclose = null;- onerror = null;- onmessage = null;- onopen = null;-- addEventListener(- type: string,- callback: EventListener,- _options?: unknown,- ): void {- // Normally this would be a no-op in a mock, but we simulate a synthetic "open" event- // to mimic the WebSocket transitioning from CONNECTING to OPEN state.- if (type === "open" && !isIslands()) {- queueMicrotask(() => {- callback(new Event("open"));- });- }- }-- removeEventListener(- type: unknown,- callback: unknown,- options?: unknown,- ): void {- // Noop- }- dispatchEvent(event: Event): boolean {- // Noop- return false;- }-- readyState = WebSocket.OPEN;- retryCount = 0;- shouldReconnect = false;-- reconnect(code?: number | undefined, reason?: string | undefined): void {- // Noop- }- send(data: string | ArrayBuffer | Blob | ArrayBufferView) {- // Noop- }- close() {- // Noop- }-}diff --git a/frontend/src/core/websocket/transports/__tests__/basic.test.ts b/frontend/src/core/websocket/transports/__tests__/basic.test.tsnew file mode 100644index 0000000000..f17ff5f3f6--- /dev/null+++ b/frontend/src/core/websocket/transports/__tests__/basic.test.ts@@ -0,0 +1,275 @@+/* Copyright 2024 Marimo. All rights reserved. */++import { describe, expect, it, vi } from "vitest";+import { BasicTransport } from "../basic";++describe("BasicTransport", () => {+ describe("close", () => {+ it("should trigger close event", () => {+ const transport = BasicTransport.empty();+ const closeCallback = vi.fn();++ transport.addEventListener("close", closeCallback);+ transport.close();++ expect(closeCallback).toHaveBeenCalledTimes(1);+ expect(closeCallback).toHaveBeenCalledWith(expect.any(Event));+ });+ });++ describe("reconnect", () => {+ it("should trigger close and open events", async () => {+ const transport = BasicTransport.empty();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();++ transport.addEventListener("open", openCallback);+ transport.addEventListener("close", closeCallback);++ // Clear the initial open callback+ openCallback.mockClear();++ transport.reconnect();++ // Wait for connect to complete+ await new Promise((resolve) => setTimeout(resolve, 10));++ expect(closeCallback).toHaveBeenCalledTimes(1);+ expect(openCallback).toHaveBeenCalledTimes(1);+ });+ });++ describe("send", () => {+ it("should trigger message event with string data", async () => {+ const transport = BasicTransport.empty();+ const messageCallback = vi.fn();++ transport.addEventListener("message", messageCallback);++ transport.send("test message");++ expect(messageCallback).toHaveBeenCalledTimes(1);+ expect(messageCallback).toHaveBeenCalledWith(+ expect.objectContaining({+ data: "test message",+ }),+ );+ });++ it("should trigger message event with ArrayBuffer data", async () => {+ const transport = BasicTransport.empty();+ const messageCallback = vi.fn();++ transport.addEventListener("message", messageCallback);++ const buffer = new ArrayBuffer(8);+ transport.send(buffer);++ expect(messageCallback).toHaveBeenCalledTimes(1);+ expect(messageCallback).toHaveBeenCalledWith(+ expect.objectContaining({+ data: buffer,+ }),+ );+ });+ });++ describe("addEventListener", () => {+ it("should add open event listener and call it immediately", () => {+ const transport = BasicTransport.empty();+ const callback = vi.fn();++ transport.addEventListener("open", callback);++ expect(callback).toHaveBeenCalledTimes(1);+ expect(callback).toHaveBeenCalledWith(expect.any(Event));+ });++ it("should add message event listener and start producer", () => {+ const producer = vi.fn();+ const transport = BasicTransport.withProducerCallback(producer);+ const callback = vi.fn();++ transport.addEventListener("message", callback);++ // Producer should be called once+ expect(producer).toHaveBeenCalledTimes(1);+ expect(producer).toHaveBeenCalledWith(expect.any(Function));+ });+ });++ describe("removeEventListener", () => {+ it("should remove event listener", async () => {+ const transport = BasicTransport.empty();+ const callback = vi.fn();++ transport.addEventListener("message", callback);+ transport.removeEventListener("message", callback);++ transport.send("test");++ expect(callback).not.toHaveBeenCalled();+ });++ it("should only remove the specific listener", () => {+ const transport = BasicTransport.empty();+ const callback1 = vi.fn();+ const callback2 = vi.fn();++ transport.addEventListener("close", callback1);+ transport.addEventListener("close", callback2);++ transport.removeEventListener("close", callback1);++ transport.close();++ expect(callback1).not.toHaveBeenCalled();+ expect(callback2).toHaveBeenCalledTimes(1);+ });+ });++ describe("Producer functionality", () => {+ it("should pass producer callback that triggers message events", () => {+ let producerCallback: ((message: MessageEvent) => void) | undefined;+ const producer = vi.fn((callback) => {+ producerCallback = callback;+ });+ const transport = BasicTransport.withProducerCallback(producer);+ const messageCallback = vi.fn();++ transport.addEventListener("message", messageCallback);++ expect(producerCallback).toBeDefined();++ const testMessage = new MessageEvent("message", { data: "test" });+ producerCallback?.(testMessage);++ expect(messageCallback).toHaveBeenCalledWith(testMessage);+ });++ it("should handle multiple messages from producer", () => {+ let producerCallback: ((message: MessageEvent) => void) | undefined;+ const producer = vi.fn((callback) => {+ producerCallback = callback;+ });+ const transport = BasicTransport.withProducerCallback(producer);+ const messageCallback = vi.fn();++ transport.addEventListener("message", messageCallback);++ producerCallback?.(new MessageEvent("message", { data: "msg1" }));+ producerCallback?.(new MessageEvent("message", { data: "msg2" }));+ producerCallback?.(new MessageEvent("message", { data: "msg3" }));++ expect(messageCallback).toHaveBeenCalledTimes(3);+ expect(messageCallback).toHaveBeenNthCalledWith(+ 1,+ expect.objectContaining({ data: "msg1" }),+ );+ expect(messageCallback).toHaveBeenNthCalledWith(+ 2,+ expect.objectContaining({ data: "msg2" }),+ );+ expect(messageCallback).toHaveBeenNthCalledWith(+ 3,+ expect.objectContaining({ data: "msg3" }),+ );+ });++ it("should not start producer if no message listener is added", () => {+ const producer = vi.fn();+ const transport = BasicTransport.withProducerCallback(producer);++ transport.addEventListener("open", vi.fn());+ transport.addEventListener("close", vi.fn());++ expect(producer).not.toHaveBeenCalled();+ });+ });++ describe("Integration scenarios", () => {+ it("should handle complete connection lifecycle", async () => {+ const transport = BasicTransport.empty();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();++ transport.addEventListener("open", openCallback);+ transport.addEventListener("close", closeCallback);++ expect(openCallback).toHaveBeenCalledTimes(1);++ transport.reconnect();+ await new Promise((resolve) => setTimeout(resolve, 10));+ expect(openCallback).toHaveBeenCalledTimes(2);+ expect(closeCallback).toHaveBeenCalledTimes(1);++ transport.close();+ expect(closeCallback).toHaveBeenCalledTimes(2);+ });++ it("should handle send and receive flow", async () => {+ let producerCallback: ((message: MessageEvent) => void) | undefined;+ const producer = vi.fn((callback) => {+ producerCallback = callback;+ });+ const transport = BasicTransport.withProducerCallback(producer);+ const messageCallback = vi.fn();++ transport.addEventListener("message", messageCallback);++ transport.send("outgoing");+ expect(messageCallback).toHaveBeenCalledWith(+ expect.objectContaining({ data: "outgoing" }),+ );++ messageCallback.mockClear();++ producerCallback?.(new MessageEvent("message", { data: "incoming" }));+ expect(messageCallback).toHaveBeenCalledWith(+ expect.objectContaining({ data: "incoming" }),+ );+ });++ it("should maintain separate event queues for different event types", async () => {+ const transport = BasicTransport.empty();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();+ const messageCallback = vi.fn();++ transport.addEventListener("open", openCallback);+ transport.addEventListener("close", closeCallback);+ transport.addEventListener("message", messageCallback);++ openCallback.mockClear();++ transport.reconnect();+ await new Promise((resolve) => setTimeout(resolve, 10));+ transport.send("test");+ transport.close();++ expect(openCallback).toHaveBeenCalledTimes(1);+ expect(messageCallback).toHaveBeenCalledTimes(1);+ expect(closeCallback).toHaveBeenCalledTimes(2);+ });++ it("should handle rapid reconnections", async () => {+ const transport = BasicTransport.empty();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();++ transport.addEventListener("open", openCallback);+ transport.addEventListener("close", closeCallback);++ openCallback.mockClear();++ transport.reconnect();+ transport.reconnect();+ transport.reconnect();++ await new Promise((resolve) => setTimeout(resolve, 20));++ expect(closeCallback).toHaveBeenCalledTimes(3);+ expect(openCallback).toHaveBeenCalledTimes(3);+ });+ });+});diff --git a/frontend/src/core/websocket/transports/__tests__/transport.test.ts b/frontend/src/core/websocket/transports/__tests__/transport.test.tsnew file mode 100644index 0000000000..c427d3800b--- /dev/null+++ b/frontend/src/core/websocket/transports/__tests__/transport.test.ts@@ -0,0 +1,308 @@+/* Copyright 2024 Marimo. All rights reserved. */++import { describe, expect, it, vi } from "vitest";+import { ConnectionSubscriptions } from "../transport";++describe("ConnectionSubscriptions", () => {+ describe("addSubscription", () => {+ it("should add a subscription for an event", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("open", callback);++ // Verify by notifying+ subscriptions.notify("open", new Event("open") as Event);+ expect(callback).toHaveBeenCalledTimes(1);+ });++ it("should add multiple subscriptions for the same event", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback1 = vi.fn();+ const callback2 = vi.fn();+ const callback3 = vi.fn();++ subscriptions.addSubscription("message", callback1);+ subscriptions.addSubscription("message", callback2);+ subscriptions.addSubscription("message", callback3);++ const messageEvent = new MessageEvent("message", { data: "test" });+ subscriptions.notify("message", messageEvent);++ expect(callback1).toHaveBeenCalledWith(messageEvent);+ expect(callback2).toHaveBeenCalledWith(messageEvent);+ expect(callback3).toHaveBeenCalledWith(messageEvent);+ });++ it("should add subscriptions for different event types", () => {+ const subscriptions = new ConnectionSubscriptions();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();+ const messageCallback = vi.fn();++ subscriptions.addSubscription("open", openCallback);+ subscriptions.addSubscription("close", closeCallback);+ subscriptions.addSubscription("message", messageCallback);++ subscriptions.notify("open", new Event("open") as Event);+ expect(openCallback).toHaveBeenCalledTimes(1);+ expect(closeCallback).not.toHaveBeenCalled();+ expect(messageCallback).not.toHaveBeenCalled();+ });++ it("should not add duplicate subscriptions for the same callback", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("close", callback);+ subscriptions.addSubscription("close", callback);+ subscriptions.addSubscription("close", callback);++ subscriptions.notify("close", new Event("close") as Event);++ // Set only stores unique callbacks, so should be called once+ expect(callback).toHaveBeenCalledTimes(1);+ });+ });++ describe("removeSubscription", () => {+ it("should remove a subscription", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("message", callback);+ subscriptions.removeSubscription("message", callback);++ const messageEvent = new MessageEvent("message", { data: "test" });+ subscriptions.notify("message", messageEvent);++ expect(callback).not.toHaveBeenCalled();+ });++ it("should only remove the specific callback", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback1 = vi.fn();+ const callback2 = vi.fn();+ const callback3 = vi.fn();++ subscriptions.addSubscription("close", callback1);+ subscriptions.addSubscription("close", callback2);+ subscriptions.addSubscription("close", callback3);++ subscriptions.removeSubscription("close", callback2);++ subscriptions.notify("close", new Event("close") as Event);++ expect(callback1).toHaveBeenCalledTimes(1);+ expect(callback2).not.toHaveBeenCalled();+ expect(callback3).toHaveBeenCalledTimes(1);+ });++ it("should handle removing subscription from non-existent event type", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("open", callback);++ expect(() =>+ subscriptions.removeSubscription("close", callback),+ ).not.toThrow();++ subscriptions.notify("open", new Event("open") as Event);+ expect(callback).toHaveBeenCalledTimes(1);+ });+ });++ describe("notify", () => {+ it("should notify all subscribed callbacks for an event", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback1 = vi.fn();+ const callback2 = vi.fn();++ subscriptions.addSubscription("open", callback1);+ subscriptions.addSubscription("open", callback2);++ const openEvent = new Event("open");+ subscriptions.notify("open", openEvent as Event);++ expect(callback1).toHaveBeenCalledWith(openEvent);+ expect(callback2).toHaveBeenCalledWith(openEvent);+ });++ it("should pass the correct data to callbacks", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("message", callback);++ const messageEvent = new MessageEvent("message", {+ data: "test data",+ });+ subscriptions.notify("message", messageEvent);++ expect(callback).toHaveBeenCalledWith(messageEvent);+ expect(callback.mock.calls[0][0].data).toBe("test data");+ });++ it("should not notify callbacks for different event types", () => {+ const subscriptions = new ConnectionSubscriptions();+ const openCallback = vi.fn();+ const closeCallback = vi.fn();++ subscriptions.addSubscription("open", openCallback);+ subscriptions.addSubscription("close", closeCallback);++ subscriptions.notify("open", new Event("open") as Event);++ expect(openCallback).toHaveBeenCalledTimes(1);+ expect(closeCallback).not.toHaveBeenCalled();+ });++ it("should handle exceptions in callbacks without affecting other callbacks", () => {+ const subscriptions = new ConnectionSubscriptions();+ const throwingCallback = vi.fn(() => {+ throw new Error("Callback error");+ });+ const normalCallback = vi.fn();++ subscriptions.addSubscription("message", throwingCallback);+ subscriptions.addSubscription("message", normalCallback);++ const messageEvent = new MessageEvent("message", { data: "test" });++ expect(() => subscriptions.notify("message", messageEvent)).toThrow(+ "Callback error",+ );++ expect(throwingCallback).toHaveBeenCalledWith(messageEvent);+ expect(normalCallback).not.toHaveBeenCalled();+ });+ });++ describe("Integration scenarios", () => {+ it("should handle complete subscription lifecycle", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("open", callback);++ subscriptions.notify("open", new Event("open") as Event);+ expect(callback).toHaveBeenCalledTimes(1);++ subscriptions.removeSubscription("open", callback);++ subscriptions.notify("open", new Event("open") as Event);+ expect(callback).toHaveBeenCalledTimes(1);+ });++ it("should handle multiple events with multiple callbacks", () => {+ const subscriptions = new ConnectionSubscriptions();++ const openCallback1 = vi.fn();+ const openCallback2 = vi.fn();+ const closeCallback1 = vi.fn();+ const messageCallback = vi.fn();++ subscriptions.addSubscription("open", openCallback1);+ subscriptions.addSubscription("open", openCallback2);+ subscriptions.addSubscription("close", closeCallback1);+ subscriptions.addSubscription("message", messageCallback);++ subscriptions.notify("open", new Event("open") as Event);+ expect(openCallback1).toHaveBeenCalledTimes(1);+ expect(openCallback2).toHaveBeenCalledTimes(1);+ expect(closeCallback1).not.toHaveBeenCalled();+ expect(messageCallback).not.toHaveBeenCalled();++ const messageEvent = new MessageEvent("message", { data: "test" });+ subscriptions.notify("message", messageEvent);+ expect(openCallback1).toHaveBeenCalledTimes(1);+ expect(openCallback2).toHaveBeenCalledTimes(1);+ expect(closeCallback1).not.toHaveBeenCalled();+ expect(messageCallback).toHaveBeenCalledTimes(1);+ expect(messageCallback).toHaveBeenCalledWith(messageEvent);++ subscriptions.notify("close", new Event("close") as Event);+ expect(openCallback1).toHaveBeenCalledTimes(1);+ expect(openCallback2).toHaveBeenCalledTimes(1);+ expect(closeCallback1).toHaveBeenCalledTimes(1);+ expect(messageCallback).toHaveBeenCalledTimes(1);+ });++ it("should handle add and remove operations interleaved", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback1 = vi.fn();+ const callback2 = vi.fn();+ const callback3 = vi.fn();++ subscriptions.addSubscription("message", callback1);+ subscriptions.addSubscription("message", callback2);++ const msg1 = new MessageEvent("message", { data: "msg1" });+ subscriptions.notify("message", msg1);++ expect(callback1).toHaveBeenCalledWith(msg1);+ expect(callback2).toHaveBeenCalledWith(msg1);+ expect(callback3).not.toHaveBeenCalled();++ subscriptions.removeSubscription("message", callback1);+ subscriptions.addSubscription("message", callback3);++ const msg2 = new MessageEvent("message", { data: "msg2" });+ subscriptions.notify("message", msg2);++ expect(callback1).toHaveBeenCalledTimes(1);+ expect(callback2).toHaveBeenCalledWith(msg2);+ expect(callback3).toHaveBeenCalledWith(msg2);+ });++ it("should maintain separate subscription lists per event type", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback = vi.fn();++ subscriptions.addSubscription("open", callback);+ subscriptions.addSubscription("close", callback);+ subscriptions.addSubscription("message", callback);++ subscriptions.removeSubscription("close", callback);++ subscriptions.notify("open", new Event("open") as Event);+ expect(callback).toHaveBeenCalledTimes(1);++ subscriptions.notify(+ "message",+ new MessageEvent("message", { data: "test" }),+ );+ expect(callback).toHaveBeenCalledTimes(2);++ subscriptions.notify("close", new Event("close") as Event);+ expect(callback).toHaveBeenCalledTimes(2);+ });+ });++ describe("Edge cases", () => {+ it("should handle callback that modifies subscriptions", () => {+ const subscriptions = new ConnectionSubscriptions();+ const callback1 = vi.fn();+ const callback2 = vi.fn(() => {+ subscriptions.removeSubscription("message", callback1);+ });++ subscriptions.addSubscription("message", callback1);+ subscriptions.addSubscription("message", callback2);++ const messageEvent = new MessageEvent("message", { data: "test" });+ subscriptions.notify("message", messageEvent);++ expect(callback1).toHaveBeenCalledTimes(1);+ expect(callback2).toHaveBeenCalledTimes(1);++ callback1.mockClear();+ callback2.mockClear();++ subscriptions.notify("message", messageEvent);+ expect(callback1).not.toHaveBeenCalled();+ expect(callback2).toHaveBeenCalledTimes(1);+ });+ });+});diff --git a/frontend/src/core/websocket/transports/basic.ts b/frontend/src/core/websocket/transports/basic.tsnew file mode 100644index 0000000000..ff12430f7c--- /dev/null+++ b/frontend/src/core/websocket/transports/basic.ts@@ -0,0 +1,95 @@+/* Copyright 2024 Marimo. All rights reserved. */++import {+ type ConnectionEvent,+ ConnectionSubscriptions,+ type ConnectionTransportCallback,+ type IConnectionTransport,+} from "./transport";++type MessageProducer = (callback: (message: MessageEvent) => void) => void;++export class BasicTransport implements IConnectionTransport {+ private subscriptions = new ConnectionSubscriptions();+ private producer?: MessageProducer;++ static withProducerCallback(producer: MessageProducer): IConnectionTransport {+ return new BasicTransport(producer);+ }++ static empty(): IConnectionTransport {+ return new BasicTransport();+ }++ private constructor(producer?: MessageProducer) {+ this.producer = producer;+ }++ private startProducer() {+ if (this.producer) {+ this.producer((message) => {+ this.subscriptions.notify("message", message);+ });+ }+ }++ private connect(): Promise<void> {+ return new Promise<void>((resolve) => setTimeout(resolve, 0)).then(() => {+ this.subscriptions.notify("open", new Event("open"));+ });+ }++ get readyState(): WebSocket["readyState"] {+ return WebSocket.OPEN;+ }++ reconnect(code?: number | undefined, reason?: string | undefined): void {+ this.close();+ this.connect();+ return;+ }++ close(): void {+ this.subscriptions.notify("close", new Event("close"));+ }++ send(data: string | ArrayBuffer | Blob | ArrayBufferView): Promise<void> {+ this.subscriptions.notify(+ "message",+ new MessageEvent("message", {+ data,+ }),+ );+ return Promise.resolve();+ }++ addEventListener<T extends ConnectionEvent>(+ event: T,+ callback: ConnectionTransportCallback<T>,+ ): void {+ this.subscriptions.addSubscription(+ event,+ callback as ConnectionTransportCallback<ConnectionEvent>,+ );++ // Call open right away+ if (event === "open") {+ (callback as ConnectionTransportCallback<"open">)(new Event("open"));+ }++ // Start the producer when we have one consumer+ if (event === "message") {+ this.startProducer();+ }+ }++ removeEventListener<T extends ConnectionEvent>(+ event: T,+ callback: ConnectionTransportCallback<T>,+ ): void {+ this.subscriptions.removeSubscription(+ event,+ callback as ConnectionTransportCallback<ConnectionEvent>,+ );+ }+}diff --git a/frontend/src/core/websocket/transports/transport.ts b/frontend/src/core/websocket/transports/transport.tsnew file mode 100644index 0000000000..908fedeb83--- /dev/null+++ b/frontend/src/core/websocket/transports/transport.ts@@ -0,0 +1,62 @@+export type ConnectionEvent = "open" | "close" | "message" | "error";++export interface IConnectionTransportMap {+ open: WebSocketEventMap["open"];+ message: WebSocketEventMap["message"];+ close: WebSocketEventMap["close"];+ error: WebSocketEventMap["error"];+}++export type ConnectionTransportCallback<T extends ConnectionEvent> = (+ data: IConnectionTransportMap[T],+) => void;++export interface IConnectionTransport {+ reconnect(code?: number | undefined, reason?: string | undefined): void;+ close(): void;+ send(data: string | ArrayBuffer | Blob | ArrayBufferView): void;+ addEventListener<T extends ConnectionEvent>(+ event: T,+ callback: ConnectionTransportCallback<T>,+ ): void;+ removeEventListener<T extends ConnectionEvent>(+ event: T,+ callback: ConnectionTransportCallback<T>,+ ): void;+ readyState: WebSocket["readyState"];+}++export class ConnectionSubscriptions {+ private subscriptions = new Map<+ ConnectionEvent,+ Set<ConnectionTransportCallback<ConnectionEvent>>+ >();++ addSubscription(+ event: ConnectionEvent,+ callback: ConnectionTransportCallback<ConnectionEvent>,+ ): void {+ if (!this.subscriptions.has(event)) {+ this.subscriptions.set(event, new Set());+ }+ this.subscriptions.get(event)?.add(callback);+ }++ removeSubscription(+ event: ConnectionEvent,+ callback: ConnectionTransportCallback<ConnectionEvent>,+ ): void {+ this.subscriptions+ .get(event)+ ?.delete(callback as ConnectionTransportCallback<ConnectionEvent>);+ }++ notify(+ event: ConnectionEvent,+ data: IConnectionTransportMap[ConnectionEvent],+ ): void {+ for (const callback of this.subscriptions.get(event) ?? []) {+ callback(data);+ }+ }+}diff --git a/frontend/src/core/websocket/types.ts b/frontend/src/core/websocket/types.tsindex 6e7a086a4b..d09f44f6bc 100644--- a/frontend/src/core/websocket/types.ts+++ b/frontend/src/core/websocket/types.ts@@ -1,7 +1,6 @@/* Copyright 2024 Marimo. All rights reserved. */-import type ReconnectingWebSocket from "partysocket/ws";-+// TODO: rename to ConnectionStateexport const WebSocketState = {CONNECTING: "CONNECTING",OPEN: "OPEN",@@ -41,9 +40,3 @@ export type ConnectionStatus =| typeof WebSocketState.OPEN| typeof WebSocketState.CLOSING;};--type PublicInterface<T> = {- [P in keyof T]: T[P];-};--export type IReconnectingWebSocket = PublicInterface<ReconnectingWebSocket>;diff --git a/frontend/src/core/websocket/useMarimoWebSocket.tsx b/frontend/src/core/websocket/useMarimoKernelConnection.tsxsimilarity index 96%rename from frontend/src/core/websocket/useMarimoWebSocket.tsxrename to frontend/src/core/websocket/useMarimoKernelConnection.tsxindex 0d6dfc1ddb..86679dd7c1 100644--- a/frontend/src/core/websocket/useMarimoWebSocket.tsx+++ b/frontend/src/core/websocket/useMarimoKernelConnection.tsx@@ -7,7 +7,7 @@ import { toast } from "@/components/ui/use-toast";import { getNotebook, useCellActions } from "@/core/cells/cells";import { AUTOCOMPLETER } from "@/core/codemirror/completion/Autocompleter";import type { OperationMessage } from "@/core/kernel/messages";-import { useWebSocket } from "@/core/websocket/useWebSocket";+import { useConnectionTransport } from "@/core/websocket/useWebSocket";import { renderHTML } from "@/plugins/core/RenderHTML";import {handleWidgetMessage,@@ -58,12 +58,13 @@ import { SECRETS_REGISTRY } from "../secrets/request-registry";import { isStaticNotebook } from "../static/static-state";import { useVariablesActions } from "../variables/state";import type { VariableName } from "../variables/types";+import { isWasm } from "../wasm/utils";import { WebSocketClosedReason, WebSocketState } from "./types";/**- * WebSocket that connects to the Marimo kernel and handles incoming messages.+ * Creates a connection to the Marimo kernel and handles incoming messages.*/-export function useMarimoWebSocket(opts: {+export function useMarimoKernelConnection(opts: {sessionId: SessionId;autoInstantiate: boolean;setCells: (cells: CellData[], layout: LayoutState) => void;@@ -296,7 +297,7 @@ export function useMarimoWebSocket(opts: {}};- const ws = useWebSocket({+ const ws = useConnectionTransport({static: isStaticNotebook(),/*** Unique URL for this session.@@ -317,7 +318,17 @@ export function useMarimoWebSocket(opts: {setConnection({ state: WebSocketState.OPEN });},+ /**+ * Wait to connect, in case the remote kernel still starting up.+ */waitToConnect: async () => {+ if (isStaticNotebook()) {+ return;+ }+ if (isWasm()) {+ return;+ }+if (runtimeManager.isSameOrigin) {return;}@@ -325,7 +336,7 @@ export function useMarimoWebSocket(opts: {},/**- * Message callback. Handle messages sent by the kernel.+ * Handle messages sent by the kernel.*/onMessage: (e) => {try {diff --git a/frontend/src/core/websocket/useWebSocket.tsx b/frontend/src/core/websocket/useWebSocket.tsxindex 2f3fa1b802..8729d83a36 100644--- a/frontend/src/core/websocket/useWebSocket.tsx+++ b/frontend/src/core/websocket/useWebSocket.tsx@@ -3,51 +3,57 @@import ReconnectingWebSocket from "partysocket/ws";import { useEffect, useState } from "react";import { Logger } from "@/utils/Logger";-import { isStaticNotebook } from "../static/static-state";-import { PyodideBridge, PyodideWebsocket } from "../wasm/bridge";+import { createPyodideConnection } from "../wasm/bridge";import { isWasm } from "../wasm/utils";-import { StaticWebsocket } from "./StaticWebsocket";-import type { IReconnectingWebSocket } from "./types";+import { BasicTransport } from "./transports/basic";+import type { IConnectionTransport } from "./transports/transport";-interface UseWebSocketOptions {+interface UseConnectionTransportOptions {url: () => string;static: boolean;- waitToConnect?: () => Promise<void>;- onOpen?: (event: WebSocketEventMap["open"]) => void;- onMessage?: (event: WebSocketEventMap["message"]) => void;- onClose?: (event: WebSocketEventMap["close"]) => void;- onError?: (event: WebSocketEventMap["error"]) => void;+ waitToConnect: () => Promise<void>;+ onOpen: (event: WebSocketEventMap["open"]) => void;+ onMessage: (event: WebSocketEventMap["message"]) => void;+ onClose: (event: WebSocketEventMap["close"]) => void;+ onError: (event: WebSocketEventMap["error"]) => void;+}++function createConnectionTransport(+ options: Pick<UseConnectionTransportOptions, "url" | "static">,+): IConnectionTransport {+ if (options.static) {+ return BasicTransport.empty();+ }+ if (isWasm()) {+ return createPyodideConnection();+ }+ // Create a connection transport using the ReconnectingWebSocket from partysocket+ // This handles reconnecting when the connection is lost.+ return new ReconnectingWebSocket(options.url(), undefined, {+ // We don't want Infinity retries+ maxRetries: 10,+ debug: false,+ startClosed: true,+ // long timeout -- the server can become slow when many notebooks+ // are open.+ connectionTimeout: 10_000,+ });}/**- * A hook for creating a WebSocket connection with React.- *- * We use the WebSocket from partysocket, which is a wrapper around the native WebSocket API with reconnect logic.+ * A hook for creating a connection transport with React.*/-export function useWebSocket(options: UseWebSocketOptions) {- const { onOpen, onMessage, onClose, onError, waitToConnect, ...rest } =- options;+export function useConnectionTransport(options: UseConnectionTransportOptions) {+ const { onOpen, onMessage, onClose, onError, waitToConnect } = options;// eslint-disable-next-line react/hook-use-state- const [ws] = useState<IReconnectingWebSocket>(() => {- const socket: IReconnectingWebSocket = isWasm()- ? new PyodideWebsocket(PyodideBridge.INSTANCE)- : options.static- ? new StaticWebsocket()- : new ReconnectingWebSocket(rest.url, undefined, {- // We don't want Infinity retries- maxRetries: 10,- debug: false,- startClosed: true,- // long timeout -- the server can become slow when many notebooks- // are open.- connectionTimeout: 10_000,- });+ const [transport] = useState<IConnectionTransport>(() => {+ const socket = createConnectionTransport(options);- onOpen && socket.addEventListener("open", onOpen);- onClose && socket.addEventListener("close", onClose);- onError && socket.addEventListener("error", onError);- onMessage && socket.addEventListener("message", onMessage);+ socket.addEventListener("open", onOpen);+ socket.addEventListener("close", onClose);+ socket.addEventListener("error", onError);+ socket.addEventListener("message", onMessage);return socket;});@@ -55,34 +61,27 @@ export function useWebSocket(options: UseWebSocketOptions) {useEffect(() => {// If it's closed, reconnect// This starts closed, so we need to connect for the first time- if (ws.readyState === WebSocket.CLOSED) {- // Ignore waitToConnect for static and wasm notebooks- if (waitToConnect && !isStaticNotebook() && !isWasm()) {- waitToConnect()- .then(() => {- ws.reconnect();- })- .catch((error) => {- Logger.error("Healthy connection never made", error);- ws.close();- });- } else {- ws.reconnect();- }+ if (transport.readyState === WebSocket.CLOSED) {+ void waitToConnect()+ .then(() => transport.reconnect())+ .catch((error) => {+ Logger.error("Healthy connection never made", error);+ transport.close();+ });}return () => {Logger.warn(- "useWebSocket is unmounting. This likely means there is a bug.",+ "useConnectionTransport is unmounting. This likely means there is a bug.",);- ws.close();- onOpen && ws.removeEventListener("open", onOpen);- onClose && ws.removeEventListener("close", onClose);- onError && ws.removeEventListener("error", onError);- onMessage && ws.removeEventListener("message", onMessage);+ transport.close();+ transport.removeEventListener("open", onOpen);+ transport.removeEventListener("close", onClose);+ transport.removeEventListener("error", onError);+ transport.removeEventListener("message", onMessage);};// eslint-disable-next-line react-hooks/exhaustive-deps- }, [ws]);+ }, [transport]);- return ws;+ return transport;}diff --git a/frontend/vite.config.mts b/frontend/vite.config.mtsindex 176c1410bb..471bb55a85 100644--- a/frontend/vite.config.mts+++ b/frontend/vite.config.mts@@ -1,5 +1,6 @@/* Copyright 2024 Marimo. All rights reserved. */+import { execSync } from "node:child_process";import { codecovVitePlugin } from "@codecov/vite-plugin";import react from "@vitejs/plugin-react";import { JSDOM } from "jsdom";@@ -44,6 +45,9 @@ const htmlDevPlugin = (): Plugin => {}if (isPyodide) {+ const marimoVersion = execSync("uv run marimo --version")+ .toString()+ .trim();const modeFromUrl = ctx.originalUrl?.includes("mode=read")? "read": "edit";@@ -56,7 +60,7 @@ const htmlDevPlugin = (): Plugin => {mode: modeFromUrl,// If VITE_MARIMO_VERSION is defined, pull the local version of marimo// Otherwise, pull the latest version of marimo from PyPI- version: process.env.VITE_MARIMO_VERSION ? "local" : "latest",+ version: process.env.VITE_MARIMO_VERSION ?? marimoVersion,config: {// Add/remove user config here while developing// runtime: {