@primate/python 0.1.4 → 0.2.0

package/lib/private/Default.d.ts

@@ -0,0 +1,7 @@
+import Runtime from "#Runtime";
+import type BuildApp from "@primate/core/BuildApp";
+import type NextBuild from "@primate/core/NextBuild";
+export default class Default extends Runtime {
+    build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
+}
+//# sourceMappingURL=Default.d.ts.map

package/lib/private/Default.js

@@ -0,0 +1,100 @@
+import Runtime from "#Runtime";
+import wrap from "@primate/core/route/wrap";
+import assert from "@rcompat/assert";
+import FileRef from "@rcompat/fs/FileRef";
+const js_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("primate-run", { 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):
+    Route.set_session(session_obj, helpers_obj)
+    request = Route.Request(js_request, helpers_obj)
+    return Route.call_route("\${route.toUpperCase()}", request)
+\`).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);
+      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 };
+    }
+  });
+}
+`;
+};
+export default class Default extends Runtime {
+    async build(app, next) {
+        const requirements_txt = app.root.join("requirements.txt");
+        let packages = [];
+        if (await requirements_txt.exists()) {
+            const requirements = await FileRef.text(requirements_txt);
+            packages = requirements
+                .split("\n")
+                .filter(line => line.trim() && !line.startsWith("#"))
+                .map(p => p.trim());
+        }
+        app.bind(this.fileExtension, async (route, { build, 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 next(app);
+    }
+}
+//# sourceMappingURL=Default.js.map

package/lib/private/Runtime.d.ts

@@ -0,0 +1,6 @@
+import Module from "@primate/core/backend/Module";
+export default class Runtime extends Module {
+    name: string;
+    defaultExtension: string;
+}
+//# sourceMappingURL=Runtime.d.ts.map

package/lib/private/Runtime.js

@@ -0,0 +1,6 @@
+import Module from "@primate/core/backend/Module";
+export default class Runtime extends Module {
+    name = "python";
+    defaultExtension = ".py";
+}
+//# sourceMappingURL=Runtime.js.map

package/lib/private/borrow.d.ts

@@ -0,0 +1,4 @@
+import type { PyProxy } from "pyodide/ffi";
+declare const _default: (proxy?: PyProxy) => any;
+export default _default;
+//# sourceMappingURL=borrow.d.ts.map

package/lib/private/borrow.js

@@ -0,0 +1,8 @@
+const dict_converter = (value) => Object.fromEntries(value);
+export default (proxy) => {
+    if (proxy === undefined) {
+        return proxy;
+    }
+    return proxy.toJs({ dict_converter });
+};
+//# sourceMappingURL=borrow.js.map

package/lib/private/handler-property.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "__PRMT__";
+export default _default;
+//# sourceMappingURL=handler-property.d.ts.map

package/lib/private/handler-property.js

@@ -0,0 +1,2 @@
+export default "__PRMT__";
+//# sourceMappingURL=handler-property.js.map

package/lib/private/helpers.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    type(value: unknown): "string" | "boolean" | "array" | "object" | "integer" | "float" | "nil" | undefined;
+};
+export default _default;
+//# sourceMappingURL=helpers.d.ts.map

package/lib/private/helpers.js

@@ -0,0 +1,22 @@
+function integer(n) {
+    return Number.isInteger(n);
+}
+export default {
+    type(value) {
+        if (typeof value === "number")
+            return integer(value) ? "integer" : "float";
+        if (typeof value === "boolean")
+            return "boolean";
+        if (typeof value === "string")
+            return "string";
+        if (typeof value === "object") {
+            if (Array.isArray(value))
+                return "array";
+            if (value === null)
+                return "nil";
+            return "object";
+        }
+        return undefined;
+    },
+};
+//# sourceMappingURL=helpers.js.map

package/lib/private/pyodide.d.ts

@@ -0,0 +1,2 @@
+export default function (): Promise<any>;
+//# sourceMappingURL=pyodide.d.ts.map

package/lib/private/pyodide.js

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

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

@@ -0,0 +1,41 @@
+import type RequestFacade from "@primate/core/request/RequestFacade";
+import type Dict from "@rcompat/type/Dict";
+type FileEntry = {
+    bytes: Uint8Array;
+    field: string;
+    name: string;
+    size: number;
+    type: string;
+};
+export default function to_request(request: RequestFacade): Promise<{
+    url: {
+        href: string;
+        origin: string;
+        protocol: string;
+        username: string;
+        password: string;
+        host: string;
+        hostname: string;
+        port: string;
+        pathname: string;
+        search: string;
+        hash: string;
+    };
+    body: {
+        text: () => string;
+        json: () => string;
+        fields: () => Record<string, string>;
+        files: () => FileEntry[];
+        binary: () => {
+            buffer: Uint8Array<ArrayBuffer>;
+            mime: string;
+        };
+        none: () => null;
+    };
+    path: Dict;
+    query: Dict;
+    headers: Dict;
+    cookies: Dict;
+}>;
+export {};
+//# sourceMappingURL=to-request.d.ts.map

package/lib/private/to-request.js

@@ -0,0 +1,102 @@
+function plainUrl(u) {
+    return {
+        href: u.href,
+        origin: u.origin,
+        protocol: u.protocol,
+        username: u.username,
+        password: u.password,
+        host: u.host,
+        hostname: u.hostname,
+        port: u.port,
+        pathname: u.pathname,
+        search: u.search,
+        hash: u.hash,
+    };
+}
+function toDict(obj) {
+    const out = Object.create(null);
+    if (obj instanceof URLSearchParams) {
+        obj.forEach((v, k) => {
+            if (!(k in out))
+                out[k] = v ?? "";
+        });
+    }
+    else {
+        for (const [k, v] of Object.entries(obj)) {
+            out[k] = v == null ? "" : String(v);
+        }
+    }
+    return out;
+}
+async function bridgeFields(body) {
+    const fields = body.fields(); // can be strings or File
+    const plain = 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,
+                });
+            }));
+        }
+    }
+    await Promise.all(pending);
+    return {
+        fields: () => plain,
+        files: () => files,
+    };
+}
+async function bridgeBody(body) {
+    let fields, buffer, blob;
+    if (body.type === "fields") {
+        fields = await bridgeFields(body);
+    }
+    if (body.type === "binary") {
+        blob = body.binary();
+        buffer = new Uint8Array(await blob.arrayBuffer());
+    }
+    return {
+        text: () => body.text(),
+        json: () => {
+            return JSON.stringify(body.json());
+        },
+        fields: () => fields.fields(),
+        files: () => fields.files(),
+        binary: () => {
+            const mime = blob.type || "application/octet-stream";
+            return {
+                buffer,
+                mime,
+            };
+        },
+        none: () => null,
+    };
+}
+export default async function to_request(request) {
+    const body = await bridgeBody(request.body);
+    const cookies = toDict(request.cookies.toJSON());
+    const headers = toDict(request.headers.toJSON());
+    const path = toDict(request.path.toJSON());
+    const query = toDict(request.query.toJSON());
+    const u = request.url;
+    const url = plainUrl(new URL(String(u)));
+    return {
+        url,
+        body,
+        path, query, headers, cookies,
+    };
+}
+//# sourceMappingURL=to-request.js.map

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

@@ -0,0 +1,6 @@
+import type ResponseLike from "@primate/core/response/ResponseLike";
+import type Dict from "@rcompat/type/Dict";
+import type { PyProxy } from "pyodide/ffi";
+declare const _default: (response: Dict | PyProxy) => ResponseLike;
+export default _default;
+//# sourceMappingURL=to-response.d.ts.map

package/lib/private/to-response.js

@@ -0,0 +1,27 @@
+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";
+const handlers = { error, redirect, view };
+const handle_handler = (handler, response) => {
+    if (handler === "view") {
+        const { name, options, props } = response;
+        return view(name, props, options);
+    }
+    if (handler === "redirect") {
+        const { location, status } = response;
+        return redirect(location, status);
+    }
+    const { options } = response;
+    return error(options);
+};
+const is_handler = (handler) => typeof handler === "string" && Object.keys(handlers).includes(handler);
+export default (response) => {
+    const unwrapped = unwrap(response);
+    const handler = unwrapped[HANDLER_PROPERTY];
+    return is_handler(handler)
+        ? handle_handler(handler, unwrapped)
+        : unwrapped;
+};
+//# sourceMappingURL=to-response.js.map

package/lib/private/unwrap.d.ts

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

package/lib/private/unwrap.js

@@ -0,0 +1,28 @@
+const dict_converter = (value) => Object.fromEntries(value);
+const normalize = (response) => response instanceof Map ? Object.fromEntries(response.entries()) : response;
+const recursively_convert = (input) => {
+    return Object.fromEntries(Object.entries(input).map(([k, o]) => {
+        if (o.toJs !== undefined) {
+            return [k, o.toJs({ dict_converter })];
+        }
+        return [k, o];
+    }));
+};
+const qualify = (response, destroy = true) => {
+    if (response.toJs !== undefined) {
+        const py_proxy = response;
+        const converted = py_proxy.toJs({ dict_converter });
+        destroy && py_proxy.destroy();
+        return converted;
+    }
+    if (typeof response === "object") {
+        return recursively_convert(response);
+    }
+    return response;
+};
+export default function unwrap(response) {
+    return normalize(qualify(response));
+}
+/*export const unwrap_async = (response: PyProxy) =>
+  normalize(qualify(response, false));*/
+//# sourceMappingURL=unwrap.js.map

package/lib/public/borrow.d.ts

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

package/lib/public/borrow.js

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

package/lib/public/default.d.ts

@@ -0,0 +1,4 @@
+import Default from "#Default";
+declare const _default: (options?: typeof Default.input) => Default;
+export default _default;
+//# sourceMappingURL=default.d.ts.map

package/lib/public/default.js

@@ -0,0 +1,3 @@
+import Default from "#Default";
+export default (options) => new Default(options);
+//# sourceMappingURL=default.js.map

package/lib/public/helpers.d.ts

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

package/lib/public/helpers.js

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

package/lib/public/pyodide.d.ts

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

package/lib/public/pyodide.js

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

package/lib/public/runtime.d.ts

@@ -0,0 +1,4 @@
+import Runtime from "#Runtime";
+declare const _default: (options?: typeof Runtime.input) => Runtime;
+export default _default;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/public/runtime.js

@@ -0,0 +1,3 @@
+import Runtime from "#Runtime";
+export default (options) => new Runtime(options);
+//# sourceMappingURL=runtime.js.map

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

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

package/lib/public/to-request.js

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

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

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

package/lib/public/to-response.js

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

package/package.json

@@ -1,39 +1,50 @@
 {
   "name": "@primate/python",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Primate Python backend",
-  "homepage": "https://primatejs.com/modules/python",
-  "bugs": "https://github.com/primatejs/primate/issues",
+  "homepage": "https://primate.run/docs/backend/python",
+  "bugs": "https://github.com/primate-run/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.spec.js"
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/primatejs/primate",
+    "url": "https://github.com/primate-run/primate",
     "directory": "packages/python"
   },
   "dependencies": {
-    "@rcompat/fs": "^0.5.0",
-    "pyodide": "^0.26.2",
-    "@primate/core": "^0.1.6"
+    "@rcompat/assert": "^0.3.1",
+    "@rcompat/fs": "^0.21.1",
+    "pyodide": "^0.28.3",
+    "@primate/core": "^0.2.0",
+    "pema": "^0.2.0"
   },
   "peerDependencies": {
-    "primate": "^0.32.3"
+    "primate": "^0.33.0"
   },
   "type": "module",
   "imports": {
     "#*": {
-      "@primate/lt": "./src/private/*.js",
-      "default": "./src/private/*.js"
+      "apekit": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "runtime": "./src/runtime.js",
-      "default": "./src/default.js"
+      "runtime": "./lib/public/runtime.js",
+      "default": "./lib/public/default.js"
     },
-    "./*": "./src/*.js"
+    "./*": {
+      "apekit": "./src/public/*.ts",
+      "default": "./lib/public/*.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint ."
   }
 }

package/src/default.js

@@ -1,8 +0,0 @@
-import build from "#build";
-import default_extension from "#extension";
-import pkgname from "#pkgname";
-
-export default ({ extension = default_extension, packages = [] } = {}) => ({
-  name: pkgname,
-  build: build({ extension, packages }),
-});

package/src/load.js

@@ -1 +0,0 @@
-export { loadPyodide as default } from "pyodide";

package/src/private/build.js

@@ -1,42 +0,0 @@
-const routes_re = /def (?<route>get|post|put|delete)/gu;
-const get_routes = code => [...code.matchAll(routes_re)]
-  .map(({ groups: { route } }) => route);
-
-const make_route = route => `async ${route.toLowerCase()}(request) {
-  const ${route}_fn = pyodide.globals.get("${route}");
-  return to_response(await ${route}_fn(to_request(pyodide.toPy, request)));
-}`;
-
-const make_package = pkg => `await pyodide.loadPackage("${pkg}", {
-  messageCallback: _ => _,
-});\n`;
-
-const js_wrapper = async (path, routes, packages) => `
-  import file from "primate/runtime/file";
-  import to_request from "@primate/python/to-request";
-  import to_response from "@primate/python/to-response";
-  import wrap from "@primate/python/wrap";
-  import load from "@primate/python/load";
-
-  const pyodide = await load({ indexURL: "./node_modules/pyodide" });
-  const python_route = await file(${JSON.stringify(path)}).text();
-  ${packages.map(make_package)}
-  pyodide.runPython(wrap(python_route));
-  export default {
-  ${routes.map(route => make_route(route)).join(",\n")}
-  };
-`;
-
-export default ({ extension, packages }) => async (app, next) => {
-  app.bind(extension, async (directory, file) => {
-    const path = directory.join(file);
-    const base = path.directory;
-    const js = path.base.concat(".js");
-    const code = await path.text();
-    const routes = get_routes(code);
-    // write .js wrapper
-    await base.join(js).write(await js_wrapper(`${path}`, routes, packages));
-  });
-
-  return next(app);
-};

package/src/private/extension.js

@@ -1 +0,0 @@
-export default ".py";

package/src/private/pkgname.js

@@ -1 +0,0 @@
-export default "@primate/python";

package/src/runtime.js

@@ -1,3 +0,0 @@
-import pkgname from "#pkgname";
-
-export default () => ({ name: pkgname });

package/src/to-request.js

@@ -1,78 +0,0 @@
-import { unwrap, unwrap_async } from "./unwrap.js";
-
-const dispatchers = ["path", "query", "headers", "cookies"];
-
-const wrap_dispatchers = (toPy, request) =>
-  Object.fromEntries(dispatchers.map(dispatcher =>
-    [dispatcher, {
-    ...request[dispatcher],
-    json() {
-      return toPy(request[dispatcher].json());
-    },
-  }]));
-
-const wrap_store = (toPy, store) => {
-  return {
-    ...store,
-    async validate(input) {
-      return toPy(await store.validate(unwrap_async(input)));
-    },
-    async get(value) {
-      return toPy(await store.get(unwrap_async(value)));
-    },
-    async count(criteria) {
-      return store.count(unwrap_async(criteria));
-    },
-    async find(criteria) {
-      return toPy(await store.find(unwrap_async(criteria)));
-    },
-    async exists(criteria) {
-      return store.exists(unwrap_async(criteria));
-    },
-    async insert(document) {
-      return toPy(await store.insert(unwrap_async(document)));
-    },
-    async update(criteria, document) {
-      const ua = unwrap_async;
-      return toPy(await store.update(ua(criteria), ua(document)));
-    },
-    async save(document) {
-      return toPy(await store.save(unwrap_async(document)));
-    },
-    async delete(criteria) {
-      return store.delete(unwrap_async(criteria));
-    },
-    schema: {
-      async create(description) {
-        return store.schema.create(unwrap_async(description));
-      },
-      async delete() {
-        return store.schema.delete();
-      },
-    },
-  };
-};
-
-const is_store = value => value.connection !== undefined;
-const wrap_stores = (toPy, object) => Object.entries(object)
-  .reduce((reduced, [key, value]) => ({
-    ...reduced,
-    [key]: is_store(value) ? wrap_store(toPy, value) : wrap_stores(toPy, value),
-  }), {});
-
-const wrap_session = (toPy, { session }) => ({
-  ...session,
-  create(data) {
-    session.create(unwrap(data));
-  },
-  json() {
-    return toPy(session.json());
-  },
-});
-
-export default (toPy, request) => ({
-  ...request,
-  ...wrap_dispatchers(toPy, request),
-  session: wrap_session(toPy, request),
-  store: wrap_stores(toPy, request.store),
-});

package/src/to-response.js

@@ -1,31 +0,0 @@
-import error from "@primate/core/handler/error";
-import redirect from "@primate/core/handler/redirect";
-import view from "@primate/core/handler/view";
-
-import { unwrap } from "./unwrap.js";
-
-const handlers = {
-  view({ name, props = {}, options = {} }) {
-    return view(name, props, options);
-  },
-  redirect({ location, options }) {
-    return redirect(location, options);
-  },
-  error({ body, options }) {
-    return error(body, options);
-  },
-};
-
-const handle_handler = response => {
-  const { __handler__ : handler, ...args } = response;
-  return handlers[handler]?.(args) ?? error();
-};
-
-const handle_other = response => response;
-
-export default raw_response => {
-  const response = unwrap(raw_response);
-  return response.__handler__ === undefined
-    ? handle_other(response)
-    : handle_handler(response);
-};

package/src/unwrap.js

@@ -1,17 +0,0 @@
-const dict_converter = value => Object.fromEntries(value);
-
-const normalize = response =>
-  response instanceof Map ? Object.fromEntries(response.entries()) : response;
-const qualify = (response, destroy = true) => {
-  if (response?.toJs !== undefined) {
-    const py_proxy = response;
-    const converted = py_proxy.toJs({ dict_converter });
-    destroy && py_proxy.destroy();
-    return converted;
-  }
-  return response;
-};
-
-export const unwrap = response => normalize(qualify(response));
-
-export const unwrap_async = response => normalize(qualify(response, false));

package/src/wrap.js

@@ -1,24 +0,0 @@
-export default code => `
-class Primate():
-    @staticmethod
-    def view(name, props = None, options = None):
-        return {
-            "__handler__": "view",
-            "name": name,
-            "props": props,
-            "options": options,
-        }
-    @staticmethod
-    def redirect(location, options = None):
-        return {
-            "__handler__": "redirect",
-            "location": location,
-            "options": options,
-        }
-    @staticmethod
-    def error(body, options = None):
-        return {
-            "__handler__": "error",
-            "body": body,
-            "options": options,
-        }\n${code}`;