@primate/python 0.3.0 → 0.5.0

package/lib/private/Default.js

@@ -1,107 +1,42 @@
 import Runtime from "#Runtime";
-import AppError from "@primate/core/AppError";
 import TAG from "@primate/core/backend/TAG";
 import fail from "@primate/core/fail";
 import log from "@primate/core/log";
 import assert from "@rcompat/assert";
-import FileRef from "@rcompat/fs/FileRef";
-import execute from "@rcompat/stdio/execute";
+import fs from "@rcompat/fs";
+import io from "@rcompat/io";
 const PACKAGE = "primate-run";
 const [MAJOR, MINOR] = TAG.split(".").map(Number);
-const wrapper = async (fileRef, packages) => {
-    const userPythonRaw = await fileRef.text();
-    const user_code = userPythonRaw.replace(/`/g, "\\`").replace(/\\/g, "\\\\");
-    return `
-import route from "primate/route";
-import to_request from "@primate/python/to-request";
-import to_response from "@primate/python/to-response";
-import session from "primate/config/session";
-import helpers from "@primate/python/helpers";
-import pyodide from "@primate/python/pyodide";
-import borrow from "@primate/python/borrow";
-
-const wrapped_session = {
-  get id() {
-    return session().id;
-  },
-  get exists() {
-    return session().exists;
-  },
-  create(initial) {
-    session().create(borrow(initial));
-  },
-  get() {
-    return session().get();
-  },
-  try() {
-    return session().get();
-  },
-  set(data) {
-    session().set(borrow(data));
-  },
-  destroy() {
-    session().destroy();
-  },
-};
-
-const python = await pyodide();
-const messageCallback = () => {};
-await python.loadPackage("micropip", { messageCallback });
-const micropip = python.pyimport("micropip");
-await micropip.install("${PACKAGE}~=${TAG}.0", { messageCallback });
-${packages.map(p => `await micropip.install("${p}", { messageCallback });`)
-        .join("\n")}
-
-await python.runPython(\`${user_code}\`);
-
-const registry = python.runPython("Route.registry()").toJs();
-
-await python.runPython(\`
-\${Object.keys(registry).map(route => \`
-def run_\${route.toUpperCase()}(js_request, helpers_obj, session_obj):
-    Route.set_session(session_obj, helpers_obj)
-    request = Route.Request(js_request, helpers_obj)
-    return Route.call_route("\${route.toUpperCase()}", request)
-\`).join("\\n")}
-\`);
-
-for (const [verb, func_name] of Object.entries(registry)) {
-  const route_fn = python.globals.get(\`run_\${verb.toUpperCase()}\`);
-  route[verb.toLowerCase()](async request => {
-    try {
-      const converted_request = await to_request(request);
-      const result = await route_fn(converted_request, helpers, wrapped_session);
-      return to_response(result);
-    } catch (e) {
-      console.error(\`python error (\${verb.toLowerCase()})\`, e);
-      return { status: 500, body: "Python execution error: " + e.message };
-    }
-  });
-}
-`;
-};
 function package_not_found() {
     return fail("package not found - run 'pip install {0}~={1}.0'", PACKAGE, TAG);
 }
 function pkg_mismatch(major, minor) {
     return fail("installed {0} package version {1}.{2}.x not in range ~> {3}.x", PACKAGE, major, minor, TAG);
 }
+async function show_package() {
+    const str0 = () => "";
+    let out = await io.run(`pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim())
+        return out;
+    out = await io.run(`uv pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim())
+        return out;
+    out = await io.run(`python -m pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim())
+        return out;
+    return null;
+}
 async function check_version() {
-    try {
-        const output = await execute(`pip show ${PACKAGE} 2>/dev/null`);
-        const version_match = output.match(/Version:\s*(\d+)\.(\d+)\.(\d+)/);
-        if (!version_match)
-            throw package_not_found();
-        const [, major, minor] = version_match.map(Number);
-        if (major !== MAJOR || minor !== MINOR)
-            throw pkg_mismatch(major, minor);
-        log.info("using {0} package {1}.{2}.x", PACKAGE, major, minor);
-    }
-    catch (error) {
-        if (error instanceof AppError)
-            throw error;
+    const output = await show_package();
+    if (!output)
         throw package_not_found();
-    }
+    const version_match = output.match(/Version:\s*(\d+)\.(\d+)\.(\d+)/);
+    if (!version_match)
+        throw package_not_found();
+    const [major, minor] = version_match.slice(1).map(Number);
+    if (major !== MAJOR || minor !== MINOR)
+        throw pkg_mismatch(major, minor);
+    log.info("using {0} package {1}.{2}.x", PACKAGE, major, minor);
 }
 export default class Default extends Runtime {
     async build(app, next) {
@@ -109,15 +44,29 @@ export default class Default extends Runtime {
         const requirements_txt = app.root.join("requirements.txt");
         let packages = [];
         if (await requirements_txt.exists()) {
-            const requirements = await FileRef.text(requirements_txt);
+            const requirements = await fs.text(requirements_txt);
             packages = requirements
                 .split("\n")
                 .filter(line => line.trim() && !line.startsWith("#"))
                 .map(p => p.trim());
         }
-        app.bind(this.fileExtension, async (route, { context }) => {
-            assert(context === "routes", "python: only route files are supported");
-            return await wrapper(route, packages);
+        const packages_str = JSON.stringify(packages);
+        app.bind(this.fileExtension, async (file, { context }) => {
+            assert.true(context === "routes", "python: only route files are supported");
+            const relative = file.debase(app.path.routes).path.replace(/^\//, "");
+            const source = await file.text();
+            return `
+        import wrapper from "@primate/python/wrapper";
+        import i18n from "app:config:i18n";
+        import session from "app:config:session";
+        await wrapper(
+          ${JSON.stringify(source)},
+          ${packages_str},
+          "${PACKAGE}~=${TAG}.0",
+          "${relative}",
+          { i18n, session }
+        );
+      `;
         });
         return next(app);
     }

package/lib/private/pyodide.d.ts

@@ -1,2 +1,3 @@
-export default function (): Promise<any>;
+import { type PyodideAPI } from "pyodide";
+export default function (): Promise<PyodideAPI>;
 //# sourceMappingURL=pyodide.d.ts.map

package/lib/private/pyodide.js

@@ -1,5 +1,8 @@
 import { loadPyodide } from "pyodide";
+let pyodide = null;
 export default async function () {
-    return await loadPyodide({ indexURL: "./node_modules/pyodide" });
+    if (!pyodide)
+        pyodide = await loadPyodide({ indexURL: "./node_modules/pyodide" });
+    return pyodide;
 }
 //# sourceMappingURL=pyodide.js.map

package/lib/private/to-request.d.ts

@@ -1,5 +1,5 @@
-import type RequestFacade from "@primate/core/request/RequestFacade";
-import type Dict from "@rcompat/type/Dict";
+import type { RequestFacade } from "@primate/core/request";
+import type { Dict } from "@rcompat/type";
 type FileEntry = {
     bytes: Uint8Array;
     field: string;

package/lib/private/to-response.d.ts

@@ -1,5 +1,5 @@
-import type ResponseLike from "@primate/core/response/ResponseLike";
-import type Dict from "@rcompat/type/Dict";
+import { type ResponseLike } from "@primate/core/response";
+import type { Dict } from "@rcompat/type";
 import type { PyProxy } from "pyodide/ffi";
 declare const _default: (response: Dict | PyProxy) => ResponseLike;
 export default _default;

package/lib/private/to-response.js

@@ -1,8 +1,7 @@
 import HANDLER_PROPERTY from "#handler-property";
 import unwrap from "#unwrap";
-import error from "@primate/core/response/error";
-import redirect from "@primate/core/response/redirect";
-import view from "@primate/core/response/view";
+import response from "@primate/core/response";
+const { error, redirect, view } = response;
 const handlers = { error, redirect, view };
 const handle_handler = (handler, response) => {
     if (handler === "view") {

package/lib/private/unwrap.d.ts

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 import type { PyProxy } from "pyodide/ffi";
 export default function unwrap(response: PyProxy): Dict;
 //# sourceMappingURL=unwrap.d.ts.map

package/lib/private/wrapper.d.ts

@@ -0,0 +1,5 @@
+export default function wrapper(source: string, packages: string[], primate_run: string, id: string, context?: {
+    i18n?: any;
+    session?: any;
+}): Promise<void>;
+//# sourceMappingURL=wrapper.d.ts.map

package/lib/private/wrapper.js

@@ -0,0 +1,98 @@
+import borrow from "@primate/python/borrow";
+import helpers from "@primate/python/helpers";
+import pyodide from "@primate/python/pyodide";
+import to_request from "@primate/python/to-request";
+import to_response from "@primate/python/to-response";
+import route from "primate/route";
+const messageCallback = () => { };
+let _micropip = null;
+const installed = new Set();
+async function load_micropip(python) {
+    if (!_micropip) {
+        _micropip = (async () => {
+            await python.loadPackage("micropip", { messageCallback });
+            return python.pyimport("micropip");
+        })();
+    }
+    return _micropip;
+}
+async function load_package(micropip, pkg) {
+    if (installed.has(pkg))
+        return;
+    await micropip.install(pkg, { messageCallback });
+    installed.add(pkg);
+}
+function wrap_session(session) {
+    if (!session)
+        return null;
+    return {
+        get id() { return session.id; },
+        get exists() { return session.exists; },
+        create(initial) { session.create(borrow(initial)); },
+        get() { return session.get(); },
+        try_get() { return session.try(); },
+        set(data) { session.set(borrow(data)); },
+        destroy() { session.destroy(); },
+    };
+}
+function wrap_i18n(i18n) {
+    if (!i18n)
+        return null;
+    return {
+        get locale() { return i18n.locale.get(); },
+        t(key, params) {
+            if (!params)
+                return i18n(key);
+            return i18n(key, JSON.parse(params));
+        },
+        set(locale) { i18n.locale.set(locale); },
+    };
+}
+export default async function wrapper(source, packages, primate_run, id, context = {}) {
+    const python = await pyodide();
+    const micropip = await load_micropip(python);
+    const route_id = JSON.stringify(id);
+    await load_package(micropip, primate_run);
+    for (const pkg of packages) {
+        await load_package(micropip, pkg);
+    }
+    await python.runPython(`
+    from primate import Route
+    Route.clear(${route_id})
+    Route.scope(${route_id})
+  `);
+    await python.runPython(source);
+    const verbs = python.runPython(`
+    from primate import Route
+    list(Route.registry(${route_id}).keys())
+  `).toJs();
+    const wrapped_session = wrap_session(context.session);
+    const wrapped_i18n = wrap_i18n(context.i18n);
+    for (const verb of verbs) {
+        route[verb.toLowerCase()](async (request) => {
+            python.globals.set("js_req", await to_request(request));
+            python.globals.set("helpers_obj", helpers);
+            python.globals.set("session_obj", wrapped_session);
+            python.globals.set("i18n_obj", wrapped_i18n);
+            const verb_str = JSON.stringify(verb);
+            try {
+                const result = await python.runPythonAsync(`
+          from primate import Route
+          await Route.call_js(${route_id}, ${verb_str}, js_req, helpers_obj, session_obj, i18n_obj)
+        `);
+                return to_response(result);
+            }
+            catch (e) {
+                console.error(`python error (${verb.toLowerCase()})`, e);
+                return { status: 500, body: "Python execution error: " + e.message };
+            }
+            finally {
+                python.globals.delete("js_req");
+                python.globals.delete("helpers_obj");
+                python.globals.delete("session_obj");
+                python.globals.delete("i18n_obj");
+            }
+        });
+    }
+}
+//# sourceMappingURL=wrapper.js.map

package/lib/public/wrapper.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#wrapper";
+//# sourceMappingURL=wrapper.d.ts.map

package/lib/public/wrapper.js

@@ -0,0 +1,2 @@
+export { default } from "#wrapper";
+//# sourceMappingURL=wrapper.js.map

package/package.json

@@ -1,32 +1,35 @@
 {
   "name": "@primate/python",
-  "version": "0.3.0",
-  "description": "Primate Python backend",
+  "version": "0.5.0",
+  "description": "Python backend for Primate",
   "homepage": "https://primate.run/docs/backend/python",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/python"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/fs": "^0.21.1",
-    "@rcompat/stdio": "^0.12.2",
-    "pyodide": "^0.28.3",
-    "@primate/core": "^0.3.0",
-    "pema": "^0.3.0"
+    "@rcompat/assert": "^0.6.0",
+    "@rcompat/fs": "^0.25.2",
+    "@rcompat/io": "^0.3.0",
+    "pyodide": "^0.29.3",
+    "@primate/core": "^0.5.0",
+    "pema": "^0.5.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.9.0"
   },
   "peerDependencies": {
-    "primate": "^0.34.0"
+    "primate": "^0.36.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
       "apekit": "./src/private/*.ts",