use std tauri init and prefer error logs over crashes

Author: marcomq

README.md

@@ -48,7 +48,7 @@ These steps assume that you already have a basic tauri application available. Al
 
 - run `npm run tauri add python`
 - add `src-tauri/src-python/main.py` and modify it acording to your needs, for example add `def greet_python(intput): return str(input) + " from python"`
-- modify `src-tauri/src/lib.rs` and change `.plugin(tauri_plugin_python::init())` to `.plugin(tauri_plugin_python::init(["greet_python"]))`; make sure you list all python functions you 
+- modify `src-tauri/src/lib.rs` and change `.plugin(tauri_plugin_python::init())` to `.plugin(tauri_plugin_python::init_and_register(["greet_python"]))`; make sure you list all python functions you 
 want to call
 - add `"bundle": {"resources": [  "src-python/**/*"],` to `tauri.conf.json` so that python files are bundled with your application
 - add the plugin in your js, so 
@@ -71,7 +71,7 @@ def greet_python(rust_var)
     print(rust_var)
     return str(rust_var) + " from python"
 ```
-- add `.plugin(tauri_plugin_python::init(vec!["greet_python"))` to `tauri::Builder::default()`, usually in `src-tauri/src/lib.rs`. This will initialize the plugin and make the python function "greet_python" available from javascript.
+- add `.plugin(tauri_plugin_python::init_and_register(vec!["greet_python"))` to `tauri::Builder::default()`, usually in `src-tauri/src/lib.rs`. This will initialize the plugin and make the python function "greet_python" available from javascript.
 - add javascript for python plugin in the index.html file directly or in your somewhere in your javascript application. For vanilla javascript / iife, the modules can be found in `window.__TAURI__.python`. For modern javascript:
 ```javascript
 import { callFunction } from 'tauri-plugin-python-api'

examples/plain-javascript/src-tauri/src/lib.rs

@@ -8,7 +8,7 @@ fn greet_rust(name: &str) -> String {
 pub fn run() {
     tauri::Builder::default()
         .invoke_handler(tauri::generate_handler![greet_rust])
-        .plugin(tauri_plugin_python::init(vec!["greet_python"]))
+        .plugin(tauri_plugin_python::init_and_register(vec!["greet_python"]))
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

permissions/default.toml

@@ -1,5 +1,8 @@
 [default]
 description = "Default permissions for the plugin"
-permissions = ["allow-call-function", "allow-read-variable"]
+permissions = [
+    "allow-call-function", 
+    "allow-read-variable"
+]
 # "allow-register-function" is disabled due to the "secure by default" concept. It can be enabled if the UI isn't exposed via network and secured against XSS sufficiently.
 # "allow-run-python" is also disabled as it allows to run random python code. It must not be enabled if the UI is exposed via network.

src/desktop.rs

@@ -6,27 +6,12 @@
 use serde::de::DeserializeOwned;
 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");
-    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(read_main_py()).unwrap();
     Ok(Python(app.clone()))
 }

src/lib.rs

@@ -4,8 +4,9 @@
 //  git clone https://github.com/marcomq/tauri-plugin-python
 
 use tauri::{
+    path::BaseDirectory,
     plugin::{Builder, TauriPlugin},
-    Manager, Runtime,
+    AppHandle, Manager, Runtime,
 };
 
 #[cfg(desktop)]
@@ -23,7 +24,6 @@ mod py_lib_pyo3;
 #[cfg(feature = "pyo3")]
 use py_lib_pyo3 as py_lib;
 
-
 pub use error::{Error, Result};
 use models::*;
 
@@ -63,8 +63,30 @@ impl<R: Runtime, T: Manager<R>> crate::PythonExt<R> for T {
     }
 }
 
+fn read_main_py_from_resources<R: Runtime>(app: &AppHandle<R>) -> String {
+    let py_file_path = app
+        .path()
+        .resolve("src-python/main.py", BaseDirectory::Resource)
+        .unwrap_or_default();
+    std::fs::read_to_string(&py_file_path).unwrap_or_default()
+}
+
+fn read_main_py_from_current_dir() -> 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"))
+}
+
+/// Initializes the plugin with functions
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    init_and_register(vec![])
+}
+
 /// Initializes the plugin.
-pub fn init<R: Runtime>(python_functions: Vec<&'static str>) -> TauriPlugin<R> {
+pub fn init_and_register<R: Runtime>(python_functions: Vec<&'static str>) -> TauriPlugin<R> {
     Builder::new("python")
         .invoke_handler(tauri::generate_handler![
             commands::run_python,
@@ -78,6 +100,18 @@ pub fn init<R: Runtime>(python_functions: Vec<&'static str>) -> TauriPlugin<R> {
             #[cfg(desktop)]
             let python = desktop::init(app, api)?;
             app.manage(python);
+
+            let mut code = read_main_py_from_resources(app);
+            if code.is_empty() {
+                println!(
+                    "Warning: 'src-tauri/main.py' seems not to be registered in 'tauri.conf.json'"
+                );
+                code = read_main_py_from_current_dir();
+            }
+            if code.is_empty() {
+                println!("ERROR: Error reading 'src-tauri/main.py'");
+            }
+            py_lib::init_python(code).unwrap();
             for function_name in python_functions {
                 py_lib::register_function_str(function_name.into(), None).unwrap();
             }

src/mobile.rs

@@ -5,31 +5,22 @@
 
 use serde::de::DeserializeOwned;
 use tauri::{
-    path::BaseDirectory,
     plugin::{PluginApi, PluginHandle},
-    AppHandle, Manager, Runtime,
+    AppHandle, Runtime,
 };
 
-use crate::models::*;
-use crate::py_lib;
-
 #[cfg(target_os = "ios")]
 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")?;
+    let handle = api.register_android_plugin("com.plugin.python", "ExamplePlugin")?;
     #[cfg(target_os = "ios")]
     let handle = api.register_ios_plugin(init_plugin_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

@@ -59,7 +59,10 @@ pub fn register_function_str(fn_name: String, number_of_args: Option<u8>) -> cra
         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();
+        GLOBALS
+            .globals
+            .get_item(&fn_name, vm)
+            .expect(&format!("Function {fn_name} not found"));
         FUNCTION_MAP.lock().unwrap().insert(fn_name);
         Ok(())
     })

src/py_lib_pyo3.rs

@@ -22,9 +22,7 @@ lazy_static! {
 }
 
 fn get_py_path() -> std::path::PathBuf {
-    std::env::current_dir()
-        .unwrap()
-        .join("src-python")
+    std::env::current_dir().unwrap().join("src-python")
 }
 
 pub fn init_python(code: String) -> crate::Result<()> {