@stainless-api/playgrounds 0.0.1-beta.0

package/src/codemirror/python/pyodide.ts

@@ -0,0 +1,180 @@
+import { expose } from '../comlink';
+import type { Logger } from '../../Logs.tsx';
+import Anser from './anser.ts';
+
+const indexURL = 'https://cdn.jsdelivr.net/pyodide/v0.28.1/full';
+const pyodidePromise = (
+  import(
+    /* @vite-ignore */
+    (indexURL + '/pyodide.mjs') as string
+  ) as Promise<typeof import('pyodide')>
+).then((mod) =>
+  mod.loadPyodide({
+    indexURL,
+  }),
+);
+function withResolvers<T>(): { promise: Promise<T>; resolve(value: T): void; reject(err: unknown): void } {
+  let resolve: (value: T) => void, reject: (err: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve!, reject: reject! };
+}
+const wheelPromise = withResolvers<{ blob: Blob; name: string }>();
+const micropipPromise = pyodidePromise.then(async (pyodide) => {
+  await pyodide.loadPackage('micropip');
+});
+const sdkPromise = Promise.all([wheelPromise.promise, pyodidePromise, micropipPromise]).then(
+  async ([wheel, pyodide]) => {
+    pyodide.FS.writeFile('/' + wheel.name, new Uint8Array(await wheel.blob.arrayBuffer()));
+    const micropip = pyodide.pyimport('micropip');
+    await Promise.all([
+      micropip.install('emfs:/' + wheel.name),
+      micropip.install(
+        'https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl',
+      ),
+    ]);
+  },
+);
+const blackPromise = Promise.all([pyodidePromise, micropipPromise]).then(async ([pyodide]) => {
+  const micropip = pyodide.pyimport('micropip');
+  await micropip.install(
+    'https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl',
+  );
+  const black = pyodide.pyimport('black');
+  const mode = black.Mode();
+  return (code: string) => black.format_file_contents.callKwargs(code, { fast: false, mode });
+});
+const setEnvFromJSONPromise = sdkPromise.then(async () => {
+  const pyodide = await pyodidePromise;
+  pyodide.runPython(`
+  def __mk_stl_setenv__():
+    async def setenv(vars):
+      __import__("os").environ.update(__import__("json").loads(vars))
+    return setenv
+  `);
+  const setEnvFromJSON = pyodide.globals.__mk_stl_setenv__();
+  delete pyodide.globals.__mk_stl_setenv__;
+  return setEnvFromJSON;
+});
+const wrapperPromise = sdkPromise.then(async () => {
+  const pyodide = await pyodidePromise;
+  pyodide.runPython(`
+  __import__("os").environ["COLORTERM"] = "truecolor"
+  __import__("os").environ["FORCE_COLOR"] = "3"
+  def __mk_stl_run__():
+    async def run(code):
+      try:
+        compiled = compile(
+          code,
+          "<playground>",
+          "exec",
+          flags=__import__("ast").PyCF_ALLOW_TOP_LEVEL_AWAIT,
+        )
+        coroutine = eval(compiled, {})
+        if coroutine is not None:
+          await coroutine
+      except:
+        re = __import__("re")
+        print(re.sub(r"^ *File \\"<exec>\\",.+, in run\\n", "", __import__("traceback").format_exc(), flags=re.MULTILINE), file=__import__("sys").stderr)
+    return run
+  `);
+  const run = pyodide.globals.__mk_stl_run__();
+  delete pyodide.globals.__mk_stl_run__;
+  return run;
+});
+
+function anserToCSS(jsonChunk: Anser.AnserJsonEntry) {
+  const rules: string[] = [];
+  const textDecorations: string[] = [];
+
+  if (jsonChunk.fg) {
+    rules.push('color:' + jsonChunk.fg);
+  }
+
+  if (jsonChunk.bg) {
+    rules.push('background-color:' + jsonChunk.bg);
+  }
+
+  jsonChunk.decorations.forEach((decoration) => {
+    // use styles
+    if (decoration === 'bold') {
+      rules.push('font-weight:bold');
+    } else if (decoration === 'dim') {
+      rules.push('opacity:0.5');
+    } else if (decoration === 'italic') {
+      rules.push('font-style:italic');
+    } else if (decoration === 'hidden') {
+      rules.push('visibility:hidden');
+    } else if (decoration === 'strikethrough') {
+      textDecorations.push('line-through');
+    } else {
+      // underline and blink are treated here
+      textDecorations.push(decoration);
+    }
+  });
+
+  if (textDecorations.length) {
+    rules.push('text-decoration:' + textDecorations.join(' '));
+  }
+
+  return rules.join(';');
+}
+
+let packagesInstalling = true;
+wrapperPromise.finally(() => {
+  packagesInstalling = false;
+});
+
+let anser = new Anser();
+const api = {
+  async setLogger(callback: Logger) {
+    const pyodide = await pyodidePromise;
+    const ansi = (level: 'stdout' | 'stderr') => (str: string) => {
+      console.log({ str });
+      if (packagesInstalling && /^Loaded|^Loading/.test(str)) return;
+      callback({
+        type: level,
+        parts: anser
+          .ansiToJson(str)
+          .filter((e) => e.content !== '')
+          .map((e) => ({
+            css: anserToCSS(e),
+            value: e.content,
+            type: 'string',
+          })),
+      });
+    };
+    pyodide.setStdout({
+      batched: ansi('stdout'),
+    });
+    pyodide.setStderr({
+      batched: ansi('stderr'),
+    });
+  },
+  async run(s: string) {
+    try {
+      const wrapper = await wrapperPromise;
+      await wrapper(s);
+    } finally {
+      anser = new Anser();
+    }
+  },
+  async setEnv(vars: Record<string, string>) {
+    const setEnvFromJSON = await setEnvFromJSONPromise;
+    setEnvFromJSON(JSON.stringify(vars));
+  },
+  async format(s: string): Promise<string | undefined> {
+    try {
+      return (await blackPromise)(s).replace(/\n+$/, '');
+    } catch {
+      return undefined;
+    }
+  },
+  init(o: { blob: Blob; name: string }) {
+    wheelPromise.resolve(o);
+  },
+};
+export type API = typeof api;
+expose(api);

package/src/codemirror/python.ts

@@ -0,0 +1,160 @@
+import { workerTransport } from './lsp';
+import { pythonLanguage } from '@codemirror/lang-python';
+import pyodideWorkerURL from './python/pyodide?worker&url';
+import type { Language } from './react';
+import { proxy, releaseProxy, type Remote, wrap } from './comlink';
+import type { API } from './python/pyodide';
+import type { Logger } from '../Logs';
+import wheelUrl from 'virtual:stl-playground/python/wheel.whl?url';
+import pyTypes from 'virtual:stl-playground/python.json';
+
+if (!pyTypes) {
+  throw new Error('Python playgrounds failed to build.');
+}
+
+const pyrightWorkerURL = 'https://cdn.jsdelivr.net/npm/browser-basedpyright@1.33.0/dist/pyright.worker.js';
+
+const wheelBlobPromise = fetch(wheelUrl).then((e) => e.blob());
+export async function createPyright(signal: AbortSignal, doc: string): Promise<Language> {
+  const { SandboxWorker } = await import('../sandbox-worker/index.js');
+  let pyodideWorker: Worker;
+  let pyodideAPI: Remote<API>;
+  const startPyodide = async () => {
+    if (pyodideWorker) {
+      pyodideWorker.terminate();
+      pyodideAPI[releaseProxy]();
+    }
+    pyodideWorker = new SandboxWorker(pyodideWorkerURL);
+    pyodideWorker.addEventListener('error', (e) => {
+      e.preventDefault();
+      logger({ type: 'error', parts: ['failed to load pyodide.'] });
+      pyodideWorker.terminate();
+      pyodideAPI[releaseProxy]();
+    });
+    pyodideAPI = wrap<API>(pyodideWorker);
+    await pyodideAPI.init({ blob: await wheelBlobPromise, name: pyTypes!.wheel });
+  };
+  await startPyodide();
+  const pyrightWorker: Worker = new SandboxWorker(pyrightWorkerURL, {
+    name: 'pyright-foreground',
+  });
+
+  pyrightWorker.postMessage({
+    type: 'browser/boot',
+    mode: 'foreground',
+  });
+
+  signal.addEventListener('abort', () => {
+    pyrightWorker.terminate();
+    pyodideWorker.terminate();
+  });
+
+  const workers: Worker[] = [pyrightWorker];
+  const realTerminate = pyrightWorker.terminate;
+  pyrightWorker.terminate = () => {
+    pyrightWorker.terminate = realTerminate;
+    workers.forEach((w) => w.terminate());
+  };
+
+  let backgroundWorkerCount = 0;
+
+  const initializationOptions = {
+    files: {
+      ...pyTypes?.files,
+      ['/play/playground.py']: doc,
+      ['/play/pyrightconfig.json']: JSON.stringify({
+        typeshedPath: '/typeshed',
+        typeCheckingMode: 'all',
+        venvPath: '.',
+        venv: '.venv',
+      }),
+    },
+  };
+
+  if (signal.aborted) throw new Error('unmounted');
+
+  const transport = workerTransport({
+    worker: pyrightWorker,
+    hooks: {
+      onSend: (message_) => {
+        const message = message_ as {
+          method: string;
+          params: {
+            capabilities?: { publishDiagnostics?: object };
+            rootPath: string;
+            rootUri: string;
+            initializationOptions?: object;
+          };
+        };
+        if (message.method === 'initialize') {
+          message.params.capabilities ??= {};
+          message.params.capabilities.publishDiagnostics = {
+            tagSupport: {
+              valueSet: [1, 2],
+            },
+            versionSupport: true,
+          };
+          message.params.rootPath = message.params.rootUri.replace(/^file:\/\//, '');
+          message.params.initializationOptions = initializationOptions;
+        }
+        return message;
+      },
+      onMessage: (data_) => {
+        // Handle Pyright-specific messages
+        const data = data_ as { type?: string; initialData: unknown; port: MessagePort };
+        if (data && data.type === 'browser/newWorker') {
+          const { initialData, port } = data;
+          const background: Worker = new SandboxWorker(pyrightWorkerURL, {
+            name: `pyright-background-${++backgroundWorkerCount}`,
+          });
+          workers.push(background);
+          background.postMessage(
+            {
+              type: 'browser/boot',
+              mode: 'background',
+              initialData,
+              port,
+            },
+            [port],
+          );
+        }
+      },
+    },
+  });
+
+  let logger: Logger;
+  const lang: Language = {
+    transport,
+    fileName: 'playground.py',
+    extensions: [pythonLanguage],
+    doc,
+    setLogger(fn) {
+      pyodideAPI.setLogger(proxy((logger = fn)));
+    },
+    async setEnv(vars) {
+      await pyodideAPI.setEnv(vars);
+    },
+    async run(code, signal) {
+      signal.addEventListener('abort', startPyodide);
+      try {
+        await pyodideAPI.run(code);
+      } catch (e) {
+        if (signal.aborted) {
+          logger({ type: 'error', parts: ['Aborted.'] });
+          return;
+        }
+        throw e;
+      } finally {
+        signal.removeEventListener('abort', startPyodide);
+      }
+    },
+    async format(code) {
+      return pyodideAPI.format(code);
+    },
+    async expandLogHandle() {
+      return [];
+    },
+    async freeLogHandle() {},
+  };
+  return lang;
+}