can someone please help me how to solve this problem so that I don't get this error

[AriBermeki]

My Planning

I have developed an implementation in Rust that allows Python developers to create webview-based desktop applications, including system tray integration. When I am told that libraries like eel or pywebview already exist, I would like to point out that these libraries use an additional micro web server (bottle) and may not have all the required methods and do not provide access to the system tray. My solution does not need an additional server as it communicates directly with the operating system's webview engine and has over 150 methods. I have not listed this multitude of methods further to keep the code clear.

Currently I am encountering a problem related to Rust and PyO3 where the Rust analyzer is showing an error.

I do not know how to solve this problem using pyo3.

the trait bound `WebViewFrame: PyFunctionArgument<'_, '_>` is not satisfied
the following other types implement trait `PyFunctionArgument<'a, 'py>`:
  &'a PyFrame
  &'a WebViewFrame
  &'a WindowFrame
  &'a mut PyFrame
  &'a mut WebViewFrame
  &'a mut WindowFrame
  &'a pyo3::Bound<'py, T>
  Option<&'a pyo3::Bound<'py, T>>
required for `WebViewFrame` to implement `FromPyObject<'_>`
required for `WebViewFrame` to implement `FromPyObjectBound<'_, '_>`
required for `WebViewFrame` to implement `PyFunctionArgument<'_, '_>`rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B7%5D?7#file%3A%2F%2F%2Fc%253A%2FUsers%2FMalekAli%2FOneDrive%2520-%2520The%2520Yellow%2520SiC%2520Holding%2520GmbH%2FDesktop%2Fpyo_p%2Fpyframe%2Fsrc%2Flib.rs)
extract_argument.rs(119, 8): required by a bound in `extract_argument`

use pyo3::prelude::*;
use wry::{WebView, WebViewAttributes, WebViewBuilder};
use tao::{event_loop::{EventLoop, EventLoopBuilder}, window::{Window, WindowAttributes, WindowBuilder}};
use pyo3::types::PyAny;
use pyo3::FromPyObject;
use std::sync::Arc;
pub enum NexiumEventAPI {}

#[pyclass]
#[derive(Default,Clone)]
struct WindowFrame {
    win_attrs: WindowAttributes,
}

#[pymethods]

impl WindowFrame {
    #[new]
    pub fn new() -> WindowFrame {
        Self {
            win_attrs: Default::default(),
        }
    }
}

#[pyclass]
#[derive(Default)]
struct WebViewFrame {
    webview_attrs: WebViewAttributes,
}

#[pymethods]
impl WebViewFrame {
    #[new]
    pub fn new() -> WebViewFrame {
        Self {
            webview_attrs:Default::default(),
        }
    }
}



#[pyclass]
struct PyFrame {
    event_loop: EventLoop<NexiumEventAPI>,
    window: Window,
    webview: WebView,
}

#[pymethods]
impl PyFrame {
    #[new]
    #[pyo3(signature = (window_attribute, webview_attribute, _web_context=None))]
    pub fn new(
        window_attribute: WindowFrame,
        webview_attribute: WebViewFrame,
        _web_context: Option<bool>,
    ) -> PyFrame {
        
        let event_loop = EventLoopBuilder::<NexiumEventAPI>::with_user_event().build();
        let mut window_builder = WindowBuilder::new();

        // We need the Python class instance to set the WindowBuilder methods
      
        window_builder.window = window_attribute.win_attrs;

        let main_window = window_builder.build(&event_loop).unwrap();

        #[cfg(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        ))]
        let mut webview_builder = WebViewBuilder::new(&main_window);

        #[cfg(not(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        )))]
        let mut webview_builder = {
            use tao::platform::unix::WindowExtUnix;
            use wry::WebViewBuilderExtUnix;
            let vbox = main_window.default_vbox().unwrap();
            WebViewBuilder::new_gtk(vbox)
        };

        let attributes = webview_attribute.webview_attrs;
          // We need the Python class instance to set the WebViewBuilder methods
        webview_builder.attrs = attributes;

        let main_webview = webview_builder.build().unwrap();

        Self {
            event_loop: event_loop,
            window: main_window,
            webview: main_webview,
        }
    }
}









// Implement `Send` for `WebViewFrame` if it is necessary and safe
unsafe impl Send for WebViewFrame {}
// Implement `Send` for `PyFrame` if it is necessary and safe
unsafe impl Send for PyFrame {}



#[pymodule]
fn pyframe(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<WindowFrame>()?;
    m.add_class::<WebViewFrame>()?;
    m.add_class::<PyFrame>()?;
    Ok(())
}

# python example


from pyframe import (
PyFrame,
WebViewFrame,
WindowFrame
)






window = WindowFrame()
webview = WebViewFrame()

app = PyFrame(window,webview)









if __name__ == "__main__":
    app.run()

[AriBermeki]

Old version

from pycore import PyNexium
from pathlib import Path



path = Path(__file__).parent / "out"
icon_path = Path(__file__).parent / "logo.png"



app =  PyNexium()
app.with_theme(theme="light")
app.with_title(title="Nextjs Application with Python")
app.with_custom_protocol(index_page="index.html", path=str(path))
app.with_window_icon(icon=str(icon_path))
app.with_set_cursor_icon(cursor_type="Crosshair")
app.with_evaluate_script(eval_code="console.log('Hallo')")

def page(url:str):
    import json
    if url.startswith("#PYWRY_RESULT"):
        d = url.split(':')
        data = json.load(d[1])
        print(data)

app.with_ipc_handler(ipc_handler=page)

def on_startup_event():
    print("application startup")


def on_shutdown_event():
    print("application shutdown")




if __name__ == "__main__":
    app.run(json_data="",on_startup_event=on_startup_event,on_shutdown_event=on_shutdown_event)

[davidhewitt]

The solution is to take arguments by-reference instead of by-value:

#[pyo3(signature = (window_attribute, webview_attribute, _web_context=None))]
    pub fn new(
        window_attribute: &WindowFrame,  // <-- added & here
        webview_attribute: &WebViewFrame,  // <-- and here
        _web_context: Option<bool>,
    ) -> PyFrame {

... this is probably a case where we can now emit improved diagnostics, cc @mejrs

[AriBermeki]

This functionality is only available for window frames, as cloning is implemented by default for window attributes, but not for WebView frames. Cloning is not provided for WebView frames. If you try to implement cloning for WebView frames, you will get an error message that there is no clone implementation for some attributes within the WebView attribute either.

@davidhewitt

 use tao::{
    event_loop::{EventLoop, EventLoopBuilder},
    window::{Window, WindowAttributes, WindowBuilder},
};
use wry::{WebView, WebViewAttributes, WebViewBuilder};




pub enum PyEventAPI {}




#[pyclass]
struct WindowFrame {
    win_attrs: WindowAttributes,
}


#[pymethods]
impl WindowFrame{
    #[new]
    pub fn new() -> WindowFrame {
        Self {
            win_attrs: Default::default(),
        }
    }
    pub fn with_title(&mut self, title:&str){
        self.win_attrs.title = title.into();
    }
}



#[pyclass]
pub struct WebViewFrame {
    pub webview_attrs: WebViewAttributes,
}

#[pymethods]
impl WebViewFrame {
    #[new]
    pub fn new() -> WebViewFrame {
        Self {
            webview_attrs: Default::default(),
        }
    }

    pub fn with_url(&mut self, url: &str) {
        self.webview_attrs.url = Some(url.into());
    }
}

 
#[pyclass]
 struct PyFrame {
     event_loop: EventLoop<PyEventAPI>,
     window: Window,
     webview: WebView,
 }
 
 #[pymethods]
 impl PyFrame {
    #[new]
    pub fn new(
        window:&WindowFrame,
        webview:&WebViewFrame,
        _web_context: Option<bool>,
    ) -> PyFrame {
        
        let event_loop = EventLoopBuilder::<PyEventAPI>::with_user_event().build();
        let mut window_builder = WindowBuilder::new();

        // We need the Python class instance to set the WindowBuilder methods
      
        window_builder.window = window.win_attrs.clone();

        let main_window = window_builder.build(&event_loop).unwrap();

        #[cfg(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        ))]
        let mut webview_builder = WebViewBuilder::new(&main_window);

        #[cfg(not(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        )))]
        let mut webview_builder = {
            use tao::platform::unix::WindowExtUnix;
            use wry::WebViewBuilderExtUnix;
            let vbox = main_window.default_vbox().unwrap();
            WebViewBuilder::new_gtk(vbox)
        };
    // Set webview attributes
    let attributes = webview.clone();
    webview_builder.attrs = attributes.webview_attrs;  // Error
    let main_webview = webview_builder.build().unwrap();

        Self {
            event_loop: event_loop,
            window: main_window,
            webview: main_webview,
        }
    }
}

 
 // Implement `Send` for `WebViewFrame` if it is necessary and safe
 unsafe impl Send for WebViewFrame {}
 // Implement `Send` for `PyFrame` if it is necessary and safe
 unsafe impl Send for PyFrame {}
 



fn main() {
    // Initialize WindowFrame and WebViewFrame
    let window_frame = WindowFrame::new();
    let webview_frame = WebViewFrame::new();

    // Create PyFrame
    let py_frame = PyFrame::new(&window_frame, &webview_frame, None);

    // Run the event loop (if needed)
    py_frame.event_loop.run(|event, _, control_flow| {});
}




#[pymodule]
fn pyframe(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<WindowFrame>()?;
    m.add_class::<WebViewFrame>()?;
    m.add_class::<PyFrame>()?;
    Ok(())
}