@primate/python 0.4.0 → 0.6.0

package/lib/private/default.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from "#module";
+import type { Module } from "@primate/core";
+export default function default_module(input?: Input): Module;
+//# sourceMappingURL=default.d.ts.map

package/lib/private/default.js

@@ -0,0 +1,73 @@
+import E from "#errors";
+import module from "#module";
+import log from "@primate/core/log";
+import server from "@primate/core/server";
+import assert from "@rcompat/assert";
+import fs from "@rcompat/fs";
+import io from "@rcompat/io";
+const PACKAGE = "primate-run";
+const [MAJOR, MINOR] = server.TAG.split(".").map(Number);
+async function show_package() {
+    const str0 = () => "";
+    let out = await io.run(`pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim().length > 0)
+        return out;
+    out = await io.run(`uv pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim().length > 0)
+        return out;
+    out = await io.run(`python -m pip show ${PACKAGE} 2>/dev/null`).catch(str0);
+    if (out.trim().length > 0)
+        return out;
+    return null;
+}
+async function check_version() {
+    const output = await show_package();
+    if (output === null)
+        throw E.package_not_found();
+    const version_match = output.match(/Version:\s*(\d+)\.(\d+)\.(\d+)/);
+    if (version_match === null)
+        throw E.package_not_found();
+    const [major, minor] = version_match.slice(1).map(Number);
+    if (major !== MAJOR || minor !== MINOR)
+        throw E.package_mismatch(major, minor);
+    log.info("using {0} package {1}.{2}.x", PACKAGE, major, minor);
+}
+export default function default_module(input = {}) {
+    const { extension = module.extension } = module.schema.parse(input);
+    return {
+        name: module.name,
+        setup({ onBuild }) {
+            onBuild(async (app) => {
+                await check_version();
+                const requirements_txt = app.root.join("requirements.txt");
+                let packages = [];
+                if (await requirements_txt.exists()) {
+                    const requirements = await fs.text(requirements_txt);
+                    packages = requirements
+                        .split("\n")
+                        .filter(line => line.trim().length > 0 && !line.startsWith("#"))
+                        .map(p => p.trim());
+                }
+                const packages_str = JSON.stringify(packages);
+                app.bind(extension, async (file, { context }) => {
+                    assert.true(context === "routes", E.only_route_files());
+                    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}~=${server.TAG}.0",
+          "${relative}",
+          { i18n, session }
+        );
+      `;
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=default.js.map

package/lib/private/errors.d.ts

@@ -0,0 +1,12 @@
+declare function only_route_files(): import("@rcompat/error").TemplateError;
+declare function package_not_found(): import("@rcompat/error").TemplateError;
+declare function package_mismatch(major: number, minor: number): import("@rcompat/error").TemplateError;
+declare const errors: {
+    only_route_files: typeof only_route_files;
+    package_not_found: typeof package_not_found;
+    package_mismatch: typeof package_mismatch;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=errors.d.ts.map

package/lib/private/errors.js

@@ -0,0 +1,24 @@
+import server from "@primate/core/server";
+import error from "@rcompat/error";
+const PACKAGE = "primate-run";
+const t = error.template;
+function only_route_files() {
+    return t `python: only route files are supported`;
+}
+function package_not_found() {
+    const command = `pip install ${PACKAGE}~=${server.TAG}.0`;
+    return t `package not found, run ${command}`;
+}
+function package_mismatch(major, minor) {
+    const range = `~> ${server.TAG}.x`;
+    const version = `${major}.${minor}.x`;
+    return t `${PACKAGE} package version ${version} not in range ${range}`;
+}
+const errors = error.coded({
+    only_route_files,
+    package_not_found,
+    package_mismatch,
+});
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=errors.js.map

package/lib/private/module.d.ts

@@ -0,0 +1,13 @@
+declare const module: {
+    schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+        readonly extension: import("pema").OptionalType<import("pema").StringType>;
+    }>, {
+        extension: string | undefined;
+    }>;
+    name: string;
+    extension: string;
+};
+type Input = typeof module.schema.input;
+export type { Input };
+export default module;
+//# sourceMappingURL=module.d.ts.map

package/lib/private/module.js

@@ -0,0 +1,11 @@
+import p from "pema";
+const schema = p({
+    extension: p.string.optional(),
+});
+const module = {
+    schema,
+    name: "python",
+    extension: ".py",
+};
+export default module;
+//# sourceMappingURL=module.js.map

package/lib/private/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from "#module";
+import type { Module } from "@primate/core";
+export default function runtime_module(input?: Input): Module;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/private/runtime.js

@@ -0,0 +1,10 @@
+import module from "#module";
+export default function runtime_module(input = {}) {
+    const options = module.schema.parse(input);
+    void options;
+    return {
+        name: module.name,
+        setup() { },
+    };
+}
+//# sourceMappingURL=runtime.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";
+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,5 @@
-import type Dict from "@rcompat/type/Dict";
 import type { PyProxy } from "pyodide/ffi";
-export default function unwrap(response: PyProxy): Dict;
+export default function unwrap(response: PyProxy): {
+    [k: string]: unknown;
+};
 //# sourceMappingURL=unwrap.d.ts.map

package/lib/private/wrapper.d.ts

@@ -1,2 +1,5 @@
-export default function wrapper(source: string, packages: string[], primate_run: string, id: string): Promise<void>;
+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

@@ -3,7 +3,6 @@ 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 session from "primate/config/session";
 import route from "primate/route";
 const messageCallback = () => { };
 let _micropip = null;
@@ -23,7 +22,33 @@ async function load_package(micropip, pkg) {
     await micropip.install(pkg, { messageCallback });
     installed.add(pkg);
 }
-export default async function wrapper(source, packages, primate_run, id) {
+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);
@@ -41,39 +66,19 @@ export default async function wrapper(source, packages, primate_run, id) {
     from primate import Route
     list(Route.registry(${route_id}).keys())
   `).toJs();
-    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 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)
+          await Route.call_js(${route_id}, ${verb_str}, js_req, helpers_obj, session_obj, i18n_obj)
         `);
                 return to_response(result);
             }
@@ -85,6 +90,7 @@ export default async function wrapper(source, packages, primate_run, id) {
                 python.globals.delete("js_req");
                 python.globals.delete("helpers_obj");
                 python.globals.delete("session_obj");
+                python.globals.delete("i18n_obj");
             }
         });
     }

package/lib/public/default.d.ts

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

package/lib/public/default.js

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

package/lib/public/runtime.d.ts

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

package/lib/public/runtime.js

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

package/package.json

@@ -1,35 +1,39 @@
 {
   "name": "@primate/python",
-  "version": "0.4.0",
-  "description": "Primate Python backend",
+  "version": "0.6.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.22.3",
-    "@rcompat/stdio": "^0.12.2",
-    "pyodide": "^0.29.0",
-    "@primate/core": "^0.4.0",
-    "pema": "^0.4.0"
+    "@rcompat/assert": "^0.8.1",
+    "@rcompat/error": "^0.3.1",
+    "@rcompat/fs": "^0.28.1",
+    "@rcompat/io": "^0.5.1",
+    "pyodide": "^0.29.3",
+    "@primate/core": "^0.6.0",
+    "pema": "^0.6.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.11.1"
   },
   "peerDependencies": {
-    "primate": "^0.35.0"
+    "primate": "^0.37.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
@@ -39,13 +43,14 @@
       "default": "./lib/public/default.js"
     },
     "./*": {
-      "apekit": "./src/public/*.ts",
+      "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"
     }
   },
   "scripts": {
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "test": "npx proby"
   }
 }

package/lib/private/Default.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,71 +0,0 @@
-import Runtime from "#Runtime";
-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";
-const PACKAGE = "primate-run";
-const [MAJOR, MINOR] = TAG.split(".").map(Number);
-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 execute(`pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim())
-        return out;
-    out = await execute(`uv pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim())
-        return out;
-    out = await execute(`python -m pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim())
-        return out;
-    return null;
-}
-async function check_version() {
-    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) {
-        await check_version();
-        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());
-        }
-        const packages_str = JSON.stringify(packages);
-        app.bind(this.fileExtension, async (file, { context }) => {
-            assert(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";
-        await wrapper(
-          ${JSON.stringify(source)},
-          ${packages_str},
-          "${PACKAGE}~=${TAG}.0",
-          "${relative}"
-        );
-      `;
-        });
-        return next(app);
-    }
-}
-//# sourceMappingURL=Default.js.map

package/lib/private/Runtime.d.ts

@@ -1,6 +0,0 @@
-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

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