@primate/python 0.2.0 → 0.3.0

package/lib/private/Default.js

@@ -1,8 +1,14 @@
 import Runtime from "#Runtime";
-import wrap from "@primate/core/route/wrap";
+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";
-const js_wrapper = async (fileRef, packages) => {
+import execute from "@rcompat/stdio/execute";
+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 `
@@ -40,18 +46,16 @@ const wrapped_session = {
 
 const python = await pyodide();
 const messageCallback = () => {};
-
 await python.loadPackage("micropip", { messageCallback });
 const micropip = python.pyimport("micropip");
-await micropip.install("primate-run", { messageCallback });
-${packages.map(p => `await micropip.install("${p}", { messageCallback });`).join("\n")}
+await micropip.install("${PACKAGE}~=${TAG}.0", { messageCallback });
+${packages.map(p => `await micropip.install("${p}", { messageCallback });`)
+        .join("\n")}
 
 await python.runPython(\`${user_code}\`);
 
-// Get the registry of registered route function names
 const registry = python.runPython("Route.registry()").toJs();
 
-// Create route handler functions
 await python.runPython(\`
 \${Object.keys(registry).map(route => \`
 def run_\${route.toUpperCase()}(js_request, helpers_obj, session_obj):
@@ -61,10 +65,8 @@ def run_\${route.toUpperCase()}(js_request, helpers_obj, session_obj):
 \`).join("\\n")}
 \`);
 
-// Create route handlers for each registered route
 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);
@@ -78,8 +80,32 @@ for (const [verb, func_name] of Object.entries(registry)) {
 }
 `;
 };
+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 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;
+        throw package_not_found();
+    }
+}
 export default class Default extends Runtime {
     async build(app, next) {
+        await check_version();
         const requirements_txt = app.root.join("requirements.txt");
         let packages = [];
         if (await requirements_txt.exists()) {
@@ -89,10 +115,9 @@ export default class Default extends Runtime {
                 .filter(line => line.trim() && !line.startsWith("#"))
                 .map(p => p.trim());
         }
-        app.bind(this.fileExtension, async (route, { build, context }) => {
+        app.bind(this.fileExtension, async (route, { context }) => {
             assert(context === "routes", "python: only route files are supported");
-            const code = wrap(await js_wrapper(route, packages), route, build);
-            await route.append(".js").write(code);
+            return await wrapper(route, packages);
         });
         return next(app);
     }

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

@@ -24,7 +24,7 @@ export default function to_request(request: RequestFacade): Promise<{
     body: {
         text: () => string;
         json: () => string;
-        fields: () => Record<string, string>;
+        form: () => Dict<string>;
         files: () => FileEntry[];
         binary: () => {
             buffer: Uint8Array<ArrayBuffer>;

package/lib/private/to-request.js

@@ -28,41 +28,37 @@ function toDict(obj) {
     }
     return out;
 }
-async function bridgeFields(body) {
-    const fields = body.fields(); // can be strings or File
-    const plain = Object.create(null);
+async function bridge_form(body) {
+    const form = Object.create(null);
     const files = [];
     const pending = [];
-    for (const [k, v] of Object.entries(fields)) {
-        if (typeof v === "string") {
-            plain[k] = v;
-        }
-        else {
-            // v is File
-            const name = v.name;
-            const type = v.type;
-            const size = v.size;
-            pending.push(v.arrayBuffer().then(buffer => {
-                files.push({
-                    bytes: new Uint8Array(buffer),
-                    field: k,
-                    name,
-                    size,
-                    type,
-                });
-            }));
-        }
+    for (const [k, v] of Object.entries(body.form())) {
+        form[k] = v;
+    }
+    for (const [k, v] of Object.entries(body.files())) {
+        const name = v.name;
+        const type = v.type;
+        const size = v.size;
+        pending.push(v.arrayBuffer().then(buffer => {
+            files.push({
+                bytes: new Uint8Array(buffer),
+                field: k,
+                name,
+                size,
+                type,
+            });
+        }));
     }
     await Promise.all(pending);
     return {
-        fields: () => plain,
+        form: () => form,
         files: () => files,
     };
 }
 async function bridgeBody(body) {
-    let fields, buffer, blob;
-    if (body.type === "fields") {
-        fields = await bridgeFields(body);
+    let form, buffer, blob;
+    if (body.type === "form") {
+        form = await bridge_form(body);
     }
     if (body.type === "binary") {
         blob = body.binary();
@@ -73,8 +69,8 @@ async function bridgeBody(body) {
         json: () => {
             return JSON.stringify(body.json());
         },
-        fields: () => fields.fields(),
-        files: () => fields.files(),
+        form: () => form.form(),
+        files: () => form.files(),
         binary: () => {
             const mime = blob.type || "application/octet-stream";
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/python",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Primate Python backend",
   "homepage": "https://primate.run/docs/backend/python",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -18,12 +18,13 @@
   "dependencies": {
     "@rcompat/assert": "^0.3.1",
     "@rcompat/fs": "^0.21.1",
+    "@rcompat/stdio": "^0.12.2",
     "pyodide": "^0.28.3",
-    "@primate/core": "^0.2.0",
-    "pema": "^0.2.0"
+    "@primate/core": "^0.3.0",
+    "pema": "^0.3.0"
   },
   "peerDependencies": {
-    "primate": "^0.33.0"
+    "primate": "^0.34.0"
   },
   "type": "module",
   "imports": {