fixing issues after testing pyo3 feature

Author: marcomq

Cargo.toml

@@ -31,4 +31,5 @@ serde_json = "1.0.136"
 tauri-plugin = { version = "2", features = ["build"] }
 
 [features]
+# default = ["pyo3"] # enable to use pyo3 instead of rustpython
 pyo3 = ["dep:pyo3"]

src/desktop.rs

@@ -4,15 +4,21 @@
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
 use serde::de::DeserializeOwned;
-use tauri::{ plugin::PluginApi, AppHandle, Runtime};
+use tauri::{plugin::PluginApi, AppHandle, Runtime};
 
+#[cfg(feature = "pyo3")]
+use crate::py_lib_pyo3 as py_lib;
+#[cfg(not(feature = "pyo3"))]
 use crate::py_lib;
 
 /// Access to the python plugin APIs.
 pub struct Python<R: Runtime>(AppHandle<R>);
 
 fn read_main_py<'a>() -> String {
-    let py_file_path = std::env::current_dir().unwrap().join("src-python").join("main.py");
+    let py_file_path = std::env::current_dir()
+        .unwrap()
+        .join("src-python")
+        .join("main.py");
     std::fs::read_to_string(py_file_path).unwrap_or_default()
     // include_str!(concat!(env!("PWD"),  "/src-tauri/src-python/main.py"))
 }

src/error.rs

@@ -11,6 +11,8 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
+    #[error("Error: {0}")]
+    String(String),
     #[error(transparent)]
     Io(#[from] std::io::Error),
     #[cfg(mobile)]
@@ -27,10 +29,9 @@ impl Serialize for Error {
     }
 }
 
-// probably not the best solution - please optimize :)
 impl From<&str> for Error {
     fn from(error: &str) -> Self {
-        std::io::Error::new(std::io::ErrorKind::Other, error).into()
+        Error::String(error.into())
     }
 }
 
@@ -39,7 +40,7 @@ impl From<rustpython_vm::PyRef<rustpython_vm::builtins::PyBaseException>> for Er
     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()
+        Error::String(msg)
     }
 }
 
@@ -48,7 +49,7 @@ impl From<PyErr> for Error {
     fn from(error: PyErr) -> Self {
         let msg = error.to_string();
         println!("error: {}", &msg);
-        std::io::Error::new(std::io::ErrorKind::Other, msg).into()
+        Error::String(msg)
     }
 }
 

src/lib.rs

@@ -20,6 +20,9 @@ mod models;
 mod py_lib;
 #[cfg(feature = "pyo3")]
 mod py_lib_pyo3;
+#[cfg(feature = "pyo3")]
+use py_lib_pyo3 as py_lib;
+
 
 pub use error::{Error, Result};
 use models::*;
@@ -51,10 +54,8 @@ impl<R: Runtime, T: Manager<R>> crate::PythonExt<R> for T {
         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(),
-        })
+        let py_res: String = py_lib::call_function(payload)?.into();
+        Ok(StringResponse { value: py_res })
     }
     fn read_variable(&self, payload: StringRequest) -> crate::Result<StringResponse> {
         let py_res = py_lib::read_variable(payload)?;

src/mobile.rs

@@ -7,7 +7,7 @@ use serde::de::DeserializeOwned;
 use tauri::{
     path::BaseDirectory,
     plugin::{PluginApi, PluginHandle},
-    AppHandle, Runtime, Manager
+    AppHandle, Manager, Runtime,
 };
 
 use crate::models::*;

src/models.rs

@@ -13,8 +13,6 @@ pub struct StringRequest {
 
 #[cfg(feature = "pyo3")]
 #[derive(Debug, Serialize, Deserialize, pyo3::IntoPyObject)]
-#[cfg(not(feature = "pyo3"))]
-#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum JsMany {
     Bool(bool),

src/py_lib.rs

@@ -3,16 +3,14 @@
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
-use std::env;
-use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 use std::{collections::HashSet, sync::Mutex};
 
-use rustpython_vm::{py_serde, PyResult};
+use rustpython_vm::py_serde;
 
 use lazy_static::lazy_static;
 
-use crate::models::*;
+use crate::{models::*, Error};
 
 fn create_globals() -> rustpython_vm::scope::Scope {
     rustpython_vm::Interpreter::without_stdlib(Default::default())
@@ -57,19 +55,22 @@ pub fn register_function(payload: RegisterRequest) -> crate::Result<()> {
 }
 
 pub fn register_function_str(fn_name: String, number_of_args: Option<u8>) -> crate::Result<()> {
+    if INIT_BLOCKED.load(std::sync::atomic::Ordering::Relaxed) {
+        return Err("Cannot register after function called".into());
+    }
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         GLOBALS.globals.get_item(&fn_name, vm).unwrap();
         FUNCTION_MAP.lock().unwrap().insert(fn_name);
         Ok(())
     })
 }
 pub fn call_function(payload: RunRequest) -> crate::Result<String> {
+    INIT_BLOCKED.store(true, std::sync::atomic::Ordering::Relaxed);
     let function_name = payload.function_name;
     if FUNCTION_MAP.lock().unwrap().get(&function_name).is_none() {
-        Err(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!("Function {function_name} has not been registered yet"),
-        ))?;
+        return Err(Error::String(format!(
+            "Function {function_name} has not been registered yet"
+        )));
     }
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let posargs: Vec<_> = payload

src/py_lib_pyo3.rs

@@ -3,8 +3,6 @@
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
-use std::env;
-use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 use std::{collections::HashMap, ffi::CString, sync::Mutex};
 
@@ -14,7 +12,7 @@ use pyo3::types::{PyAnyMethods, PyDictMethods, PyList, PyListMethods};
 use pyo3::PyErr;
 use pyo3::{marker, types::PyDict, Py, PyAny, PyResult};
 
-use crate::models::*;
+use crate::{models::*, Error};
 
 lazy_static! {
     static ref INIT_BLOCKED: AtomicBool = false.into();
@@ -23,55 +21,56 @@ lazy_static! {
         Mutex::new(marker::Python::with_gil(|py| { PyDict::new(py).into() }));
 }
 
+fn get_py_path() -> std::path::PathBuf {
+    std::env::current_dir()
+        .unwrap()
+        .join("src-python")
+}
+
 pub fn init_python(code: String) -> crate::Result<()> {
     let c_code = CString::new(code).expect("error creating cstring from code");
-    marker::Python::with_gil(|py| -> PyResult<()> {
+    Ok(marker::Python::with_gil(|py| -> PyResult<()> {
         let syspath = py
             .import("sys")?
             .getattr("path")?
             .downcast_into::<PyList>()?;
         syspath.insert(0, get_py_path().to_str())?;
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
         py.run(&c_code, Some(&globals), None)
-    })
+    })?)
 }
 
-pub fn run_python(payload: StringRequest) -> PyResult<()> {
-    marker::Python::with_gil(|py| {
+pub fn run_python(payload: StringRequest) -> crate::Result<()> {
+    marker::Python::with_gil(|py| -> crate::Result<()> {
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
-        let code_c = CString::new(payload.value).expect("CString::new failed");
-        py.run(&code_c, Some(&globals), None)
+        let c_code = CString::new(payload.value).expect("CString::new failed");
+        Ok(py.run(&c_code, Some(&globals), None)?)
     })
 }
-pub fn register_function(payload: RegisterRequest) -> PyResult<()> {
+pub fn register_function(payload: RegisterRequest) -> crate::Result<()> {
     register_function_str(payload.python_function_call, payload.number_of_args)
 }
 
-pub fn register_function_str(fn_name: String, number_of_args: Option<u8>) -> PyResult<()> {
+pub fn register_function_str(fn_name: String, number_of_args: Option<u8>) -> crate::Result<()> {
     // TODO, check actual function signature
     if INIT_BLOCKED.load(std::sync::atomic::Ordering::Relaxed) {
-        return Err(pyo3::exceptions::PyException::new_err(
-            "Cannot register after function called",
-        ));
+        return Err("Cannot register after function called".into());
     }
-    marker::Python::with_gil(|py| -> PyResult<()> {
+    marker::Python::with_gil(|py| -> crate::Result<()> {
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
 
         let fn_dot_split: Vec<&str> = fn_name.split(".").collect();
         let app = globals.get_item(&fn_dot_split[0])?;
         if app.is_none() {
-            return Err(pyo3::exceptions::PyException::new_err(format!(
-                "{} not found",
-                &fn_name
-            )));
+            return Err(Error::String(format!("{} not found", &fn_name)));
         }
         let app = if fn_dot_split.len() > 1 {
             app.unwrap().getattr(fn_dot_split.get(1).unwrap())?
         } else {
             app.unwrap()
         };
         if !app.is_callable() {
-            return Err(pyo3::exceptions::PyException::new_err(format!(
+            return Err(Error::String(format!(
                 "{} not a callable function",
                 &fn_name
             )));
@@ -95,30 +94,30 @@ if True:
         Ok(())
     })
 }
-pub fn call_function(payload: RunRequest) -> PyResult<Py<PyAny>> {
+pub fn call_function(payload: RunRequest) -> crate::Result<String> {
     INIT_BLOCKED.store(true, std::sync::atomic::Ordering::Relaxed);
-    marker::Python::with_gil(|py| -> PyResult<Py<PyAny>> {
+    marker::Python::with_gil(|py| -> crate::Result<String> {
         let arg = pyo3::types::PyTuple::new(py, payload.args)?;
         let map = FUNCTION_MAP
             .lock()
             .map_err(|msg| PyErr::new::<PyBaseException, _>(msg.to_string()))?;
         match map.get(&payload.function_name) {
             Some(app) => {
                 // dbg!(&arg);
-                let res = app.call1(py, arg);
+                let res = app.call1(py, arg)?;
                 // dbg!(&res);
-                res
+                Ok(res.to_string())
             }
-            _ => Err(pyo3::exceptions::PyException::new_err(format!(
+            _ => Err(Error::String(format!(
                 "{} not found",
                 payload.function_name
             ))),
         }
     })
 }
 
-pub fn read_variable(payload: StringRequest) -> PyResult<String> {
-    marker::Python::with_gil(|py| -> PyResult<String> {
+pub fn read_variable(payload: StringRequest) -> crate::Result<String> {
+    marker::Python::with_gil(|py| -> crate::Result<String> {
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
 
         let var_dot_split: Vec<&str> = payload.value.split(".").collect();
@@ -130,10 +129,7 @@ pub fn read_variable(payload: StringRequest) -> PyResult<String> {
                 Ok(var.to_string())
             }
         } else {
-            Err(pyo3::exceptions::PyException::new_err(format!(
-                "{} not set",
-                &payload.value
-            )))
+            Err(Error::String(format!("{} not set", &payload.value)))
         }
     })
 }