rustpython running on ios

Author: marcomq

src/desktop.rs

@@ -4,17 +4,23 @@
 //  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};
 
 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");
+    std::fs::read_to_string(py_file_path).unwrap_or_default()
+    // include_str!(concat!(env!("PWD"),  "/src-tauri/src-python/main.py"))
+}
+
 pub fn init<R: Runtime, C: DeserializeOwned>(
     app: &AppHandle<R>,
     _api: PluginApi<R, C>,
 ) -> crate::Result<Python<R>> {
-    py_lib::init_python().unwrap();
+    py_lib::init_python(read_main_py()).unwrap();
     Ok(Python(app.clone()))
 }

src/mobile.rs

@@ -5,8 +5,9 @@
 
 use serde::de::DeserializeOwned;
 use tauri::{
+    path::BaseDirectory,
     plugin::{PluginApi, PluginHandle},
-    AppHandle, Runtime,
+    AppHandle, Runtime, Manager
 };
 
 use crate::models::*;
@@ -17,14 +18,18 @@ tauri::ios_plugin_binding!(init_plugin_python);
 
 // initializes the Kotlin or Swift plugin classes
 pub fn init<R: Runtime, C: DeserializeOwned>(
-    _app: &AppHandle<R>,
+    app: &AppHandle<R>,
     api: PluginApi<R, C>,
 ) -> 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()?;
+    let py_file_path = app
+        .path()
+        .resolve("src-python/main.py", BaseDirectory::Resource)?;
+    let code = std::fs::read_to_string(py_file_path).expect("Error reading main.py");
+    py_lib::init_python(code)?;
     Ok(Python(handle))
 }
 

src/py_lib.rs

@@ -25,18 +25,7 @@ lazy_static! {
     static ref GLOBALS: rustpython_vm::scope::Scope = create_globals();
 }
 
-fn get_py_path() -> PathBuf {
-    env::current_dir().unwrap().join("src-python")
-}
-
-fn read_main_py<'a>() -> String {
-    let py_file_path = get_py_path().join("main.py");
-    std::fs::read_to_string(py_file_path).unwrap()
-    // include_str!(concat!(env!("PWD"),  "/src-tauri/src-python/main.py"))
-}
-
-pub fn init_python() -> PyResult<()> {
-    let code = read_main_py();
+pub fn init_python(code: String) -> crate::Result<()> {
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let code_obj = vm
             .compile(
@@ -50,7 +39,7 @@ pub fn init_python() -> PyResult<()> {
     Ok(())
 }
 
-pub fn run_python(payload: StringRequest) -> PyResult<()> {
+pub fn run_python(payload: StringRequest) -> crate::Result<()> {
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let code_obj = vm
             .compile(
@@ -63,36 +52,42 @@ pub fn run_python(payload: StringRequest) -> PyResult<()> {
     })?;
     Ok(())
 }
-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<()> {
     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) -> PyResult<String> {
-    // TODO,
+pub fn call_function(payload: RunRequest) -> crate::Result<String> {
+    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"),
+        ))?;
+    }
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let posargs: Vec<_> = payload
             .args
             .into_iter()
-            .map(|x| py_serde::deserialize(vm, x).unwrap())
+            .map(|value| py_serde::deserialize(vm, value).unwrap())
             .collect();
         let res = GLOBALS
             .globals
-            .get_item(&payload.function_name, vm)?
+            .get_item(&function_name, vm)?
             .call(posargs, vm)?
             .str(vm)?
             .to_string();
         Ok(res)
     })
 }
 
-pub fn read_variable(payload: StringRequest) -> PyResult<String> {
+pub fn read_variable(payload: StringRequest) -> crate::Result<String> {
     rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
         let res = GLOBALS
             .globals

src/py_lib_pyo3.rs

@@ -23,18 +23,7 @@ lazy_static! {
         Mutex::new(marker::Python::with_gil(|py| { PyDict::new(py).into() }));
 }
 
-fn get_py_path() -> PathBuf {
-    env::current_dir().unwrap().join("src-python")
-}
-
-fn read_main_py<'a>() -> String {
-    let py_file_path = get_py_path().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"))
-}
-
-pub fn init_python() -> PyResult<()> {
-    let code = read_main_py();
+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<()> {
         let syspath = py