add rustpython

Author: marcomq

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tauri-plugin-python"
-version = "0.2.1"
+version = "0.3.0"
 authors = [ "Marco Mengelkoch" ]
 description = "A tauri 2 plugin to use python code in the backend."
 keywords = ["rust", "python", "tauri", "gui"]
@@ -16,8 +16,19 @@ repository = "https://github.com/marcomq/tauri-plugin-python"
 tauri = { version = "2" }
 serde = { version = "1", features = ["derive"] }
 thiserror = "2"
-pyo3 = { version = "0.23.3", features=["auto-initialize", "abi3-py39", "generate-import-lib"] }
 lazy_static = "1.5.0"
+pyo3 = { version = "0.23.3", features=["auto-initialize", "abi3-py39", "generate-import-lib"], optional = true }
+rustpython-pylib = { version = "0.4.0" }
+rustpython-stdlib = { version = "0.4.0", features = ["threading"] }
+rustpython-vm = { version = "0.4.0", features = [
+    "importlib",
+    "serde",
+    "threading",
+] }
+serde_json = "1.0.136"
 
 [build-dependencies]
 tauri-plugin = { version = "2", features = ["build"] }
+
+[features]
+pyo3 = ["dep:pyo3"]

examples/plain-javascript/src-tauri/tauri.conf.json

@@ -22,6 +22,9 @@
   "bundle": {
     "active": true,
     "targets": "all",
+    "resources": [
+      "src-python/**/*"
+    ],
     "icon": [
       "icons/32x32.png",
       "icons/128x128.png",

package.json

@@ -1,8 +1,8 @@
 {
   "name": "tauri-plugin-python-api",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "author": "Marco Mengelkoch",
-  "description": "",
+  "description": "Javascript package for tauri 2 python plugin.",
   "type": "module",
   "types": "./dist-js/index.d.ts",
   "main": "./dist-js/index.cjs",
@@ -22,6 +22,15 @@
     "prepublishOnly": "pnpm build",
     "pretest": "pnpm build"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marcomq/tauri-plugin-python.git"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/marcomq/tauri-plugin-python#readme",
+  "bugs": {
+    "url": "https://github.com/marcomq/tauri-plugin-python/issues"
+  },
   "dependencies": {
     "@tauri-apps/api": ">=2.0.0-beta.6"
   },

src/commands.rs

@@ -14,26 +14,26 @@ pub(crate) async fn run_python<R: Runtime>(
     app: AppHandle<R>,
     payload: StringRequest,
 ) -> Result<StringResponse> {
-    app.python().run_python(payload)
+    app.run_python(payload)
 }
 #[command]
 pub(crate) async fn register_function<R: Runtime>(
     app: AppHandle<R>,
     payload: RegisterRequest,
 ) -> Result<StringResponse> {
-    app.python().register_function(payload)
+    app.register_function(payload)
 }
 #[command]
 pub(crate) async fn call_function<R: Runtime>(
     app: AppHandle<R>,
     payload: RunRequest,
 ) -> Result<StringResponse> {
-    app.python().call_function(payload)
+    app.call_function(payload)
 }
 #[command]
 pub(crate) async fn read_variable<R: Runtime>(
     app: AppHandle<R>,
     payload: StringRequest,
 ) -> Result<StringResponse> {
-    app.python().read_variable(payload)
+    app.read_variable(payload)
 }

src/desktop.rs

@@ -9,11 +9,12 @@ use tauri::{plugin::PluginApi, AppHandle, Runtime};
 use crate::py_lib;
 
 /// Access to the python plugin APIs.
+pub struct Python<R: Runtime>(AppHandle<R>);
 
 pub fn init<R: Runtime, C: DeserializeOwned>(
     app: &AppHandle<R>,
     _api: PluginApi<R, C>,
-) -> crate::Result<crate::Python<R>> {
-    py_lib::init_python()?;
-    Ok(crate::Python(app.clone()))
+) -> crate::Result<Python<R>> {
+    py_lib::init_python().unwrap();
+    Ok(Python(app.clone()))
 }

src/error.rs

@@ -3,6 +3,7 @@
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
+#[cfg(feature = "pyo3")]
 use pyo3::PyErr;
 use serde::{ser::Serializer, Serialize};
 
@@ -33,16 +34,20 @@ impl From<&str> for Error {
     }
 }
 
-impl From<Error> for PyErr {
-    fn from(error: Error) -> Self {
-        pyo3::exceptions::PyValueError::new_err(error.to_string())
+#[cfg(not(feature = "pyo3"))]
+impl From<rustpython_vm::PyRef<rustpython_vm::builtins::PyBaseException>> for Error {
+    fn from(error: rustpython_vm::PyRef<rustpython_vm::builtins::PyBaseException>) -> Self {
+        let msg = format!("{:?}", &error);
+        println!("error: {}", &msg);
+        std::io::Error::new(std::io::ErrorKind::Other, msg).into()
     }
 }
 
+#[cfg(feature = "pyo3")]
 impl From<PyErr> for Error {
     fn from(error: PyErr) -> Self {
         let msg = error.to_string();
-        println!("{}", &msg);
+        println!("error: {}", &msg);
         std::io::Error::new(std::io::ErrorKind::Other, msg).into()
     }
 }

src/lib.rs

@@ -4,11 +4,10 @@
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
 use tauri::{
-    plugin::{Builder, TauriPlugin}, AppHandle, Manager, Runtime
+    plugin::{Builder, TauriPlugin},
+    Manager, Runtime,
 };
 
-pub use models::*;
-
 #[cfg(desktop)]
 mod desktop;
 #[cfg(mobile)]
@@ -17,21 +16,50 @@ mod mobile;
 mod commands;
 mod error;
 mod models;
+#[cfg(not(feature = "pyo3"))]
 mod py_lib;
+#[cfg(feature = "pyo3")]
+mod py_lib_pyo3;
 
 pub use error::{Error, Result};
+use models::*;
 
-pub struct Python<R: Runtime>(AppHandle<R>);
+#[cfg(desktop)]
+use desktop::Python;
+#[cfg(mobile)]
+use mobile::Python;
 
 /// Extensions to [`tauri::App`], [`tauri::AppHandle`] and [`tauri::Window`] to access the python APIs.
 pub trait PythonExt<R: Runtime> {
     fn python(&self) -> &Python<R>;
+    fn run_python(&self, payload: StringRequest) -> crate::Result<StringResponse>;
+    fn register_function(&self, payload: RegisterRequest) -> crate::Result<StringResponse>;
+    fn call_function(&self, payload: RunRequest) -> crate::Result<StringResponse>;
+    fn read_variable(&self, payload: StringRequest) -> crate::Result<StringResponse>;
 }
 
 impl<R: Runtime, T: Manager<R>> crate::PythonExt<R> for T {
     fn python(&self) -> &Python<R> {
         self.state::<Python<R>>().inner()
     }
+    fn run_python(&self, payload: StringRequest) -> crate::Result<StringResponse> {
+        py_lib::run_python(payload)?;
+        Ok(StringResponse { value: "Ok".into() })
+    }
+    fn register_function(&self, payload: RegisterRequest) -> crate::Result<StringResponse> {
+        py_lib::register_function(payload)?;
+        Ok(StringResponse { value: "Ok".into() })
+    }
+    fn call_function(&self, payload: RunRequest) -> crate::Result<StringResponse> {
+        let py_res = py_lib::call_function(payload)?;
+        Ok(StringResponse {
+            value: py_res.to_string(),
+        })
+    }
+    fn read_variable(&self, payload: StringRequest) -> crate::Result<StringResponse> {
+        let py_res = py_lib::read_variable(payload)?;
+        Ok(StringResponse { value: py_res })
+    }
 }
 
 /// Initializes the plugin.
@@ -50,30 +78,9 @@ pub fn init<R: Runtime>(python_functions: Vec<&'static str>) -> TauriPlugin<R> {
             let python = desktop::init(app, api)?;
             app.manage(python);
             for function_name in python_functions {
-                py_lib::register_function_str(function_name.into(), None)?;
+                py_lib::register_function_str(function_name.into(), None).unwrap();
             }
             Ok(())
         })
         .build()
 }
-
-impl<R: Runtime> Python<R> {
-    pub fn run_python(&self, payload: StringRequest) -> crate::Result<StringResponse> {
-        py_lib::run_python(payload)?;
-        Ok(StringResponse { value: "Ok".into() })
-    }
-    pub fn register_function(&self, payload: RegisterRequest) -> crate::Result<StringResponse> {
-        py_lib::register_function(payload)?;
-        Ok(StringResponse { value: "Ok".into() })
-    }
-    pub fn call_function(&self, payload: RunRequest) -> crate::Result<StringResponse> {
-        let py_res = py_lib::call_function(payload)?;
-        Ok(StringResponse {
-            value: py_res.to_string(),
-        })
-    }
-    pub fn read_variable(&self, payload: StringRequest) -> crate::Result<StringResponse> {
-        let py_res = py_lib::read_variable(payload)?;
-        Ok(StringResponse { value: py_res })
-    }
-}

src/mobile.rs

@@ -19,11 +19,13 @@ tauri::ios_plugin_binding!(init_plugin_python);
 pub fn init<R: Runtime, C: DeserializeOwned>(
     _app: &AppHandle<R>,
     api: PluginApi<R, C>,
-) -> crate::Result<crate::Python<R>> {
+) -> crate::Result<Python<R>> {
     #[cfg(target_os = "android")]
     let handle = api.register_android_plugin("com.plugin.python.application", "ExamplePlugin")?;
     #[cfg(target_os = "ios")]
     let handle = api.register_ios_plugin(init_plugin_python)?;
     py_lib::init_python()?;
-    Ok(crate::Python(handle))
+    Ok(Python(handle))
 }
+
+pub struct Python<R: Runtime>(PluginHandle<R>);

src/models.rs

@@ -3,7 +3,6 @@
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
-use pyo3::IntoPyObject;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -12,7 +11,10 @@ pub struct StringRequest {
     pub value: String,
 }
 
-#[derive(Debug, Serialize, Deserialize, IntoPyObject)]
+#[cfg(feature = "pyo3")]
+#[derive(Debug, Serialize, Deserialize, pyo3::IntoPyObject)]
+#[cfg(not(feature = "pyo3"))]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum JsMany {
     Bool(bool),
@@ -23,6 +25,9 @@ pub enum JsMany {
     FloatVec(Vec<f64>),
 }
 
+#[cfg(not(feature = "pyo3"))]
+use serde_json::Value as JsMany;
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RegisterRequest {