add dot notation, make it possible to use import in python

Author: marcomq

guest-js/index.ts

@@ -18,14 +18,25 @@ export async function runPython(code: string): Promise<string> {
   });
 }
 
-export async function registerFunction(functionName: string, numberOfArgs?: number): Promise<string> {
+/** 
+ *  @param {string} pythonFunctionCall - The python function call, can contain one dot
+ *  @param {number} [numberOfArgs] - Number of arguments, used for validation in pythons, use -1 to ignore this value
+ *  @param {string} [jsFunctionName] - Name that is used in javscript: "call.jsFunctionName". Must not contain dots.
+ */
+export async function registerFunction(pythonFunctionCall: string, numberOfArgs?: number, jsFunctionName?: string): Promise<string> {
+  if (jsFunctionName === undefined) {
+    jsFunctionName = pythonFunctionCall;
+  }
+  if (numberOfArgs !== undefined && numberOfArgs < 0) {
+    numberOfArgs = undefined;
+  }
   return await invoke<{ value: string }>('plugin:python|register_function', {
     payload: {
-      functionName,
-      numberOfArgs,
+      pythonFunctionCall,
+      numberOfArgs
     },
   }).then((r:any) => {
-    call[functionName] = function (...args: any[]) { return callFunction(functionName, args) };
+    call[jsFunctionName] = function (...args: any[]) { return callFunction(pythonFunctionCall, args) };
     return r.value;
   });
 }

src/models.rs

@@ -26,7 +26,7 @@ pub enum JsMany {
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RegisterRequest {
-    pub function_name: String,
+    pub python_function_call: String,
     pub number_of_args: Option<u8>,
 }
 

src/py_lib.rs

@@ -8,7 +8,7 @@ use std::{collections::HashMap, ffi::CString, sync::Mutex};
 
 use lazy_static::lazy_static;
 use pyo3::exceptions::PyBaseException;
-use pyo3::types::{PyAnyMethods, PyDictMethods};
+use pyo3::types::{PyAnyMethods, PyDictMethods, PyList, PyListMethods};
 use pyo3::PyErr;
 use pyo3::{marker, types::PyDict, Py, PyAny, PyResult};
 
@@ -26,6 +26,11 @@ pub fn init_python() -> PyResult<()> {
     let code = py_main_import::read_at_startup();
     let c_code = CString::new(code).expect("error loading python");
     marker::Python::with_gil(|py| -> PyResult<()> {
+        let syspath = py
+            .import("sys")?
+            .getattr("path")?
+            .downcast_into::<PyList>()?;
+        syspath.insert(0, py_main_import::get_py_path().to_str())?;
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
         py.run(&c_code, Some(&globals), None)
     })
@@ -39,7 +44,7 @@ pub fn run_python(payload: StringRequest) -> PyResult<()> {
     })
 }
 pub fn register_function(payload: RegisterRequest) -> PyResult<()> {
-    let fn_name = payload.function_name;
+    let fn_name = payload.python_function_call;
     // TODO, check actual function signature
     if INIT_BLOCKED.load(std::sync::atomic::Ordering::Relaxed) {
         return Err(pyo3::exceptions::PyException::new_err(
@@ -48,14 +53,20 @@ pub fn register_function(payload: RegisterRequest) -> PyResult<()> {
     }
     marker::Python::with_gil(|py| -> PyResult<()> {
         let globals = GLOBALS.lock().unwrap().clone_ref(py).into_bound(py);
-        let app = globals.get_item(&fn_name)?;
+
+        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
             )));
         }
-        let app = app.unwrap();
+        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!(
                 "{} not a callable function",

src/py_main_import.rs

@@ -2,10 +2,14 @@
 //  © Copyright 2024, by Marco Mengelkoch
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/tauri-plugin-python
-use std::env;
+use std::{env, path::PathBuf};
+
+pub fn get_py_path() -> PathBuf {
+    env::current_dir().unwrap().join("src-python")
+}
 
 pub fn read_at_startup<'a>() -> String {
-    let py_file_path = env::current_dir().unwrap().join("src-python/main.py");
+    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")) 
+    // include_str!(concat!(env!("PWD"),  "/src-tauri/src-python/main.py"))
 }