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

[AriBermeki]

Error

error[E0507]: cannot move out of `self.window` which is behind a shared reference
  --> src\lib.rs:20:9
   |
20 |         self.window.run(json_data.into());
   |         ^^^^^^^^^^^ move occurs because `self.window` has type `Nexium`, which does not implement the `Copy` trait

For more information about this error, try `rustc --explain E0507`.
error: could not compile `pycore` (lib) due to 1 previous error
💥 maturin failed
  Caused by: Failed to build a native library through cargo
  Caused by: Cargo build finished with "exit code: 101": `"cargo" "rustc" "--features" "pyo3/extension-module" "--message-format" "json-render-diagnostics

app.rs

use std::{
    borrow::Cow, collections::HashMap, fs::read, path::{Path, PathBuf}, rc::Rc
};
use crate::app::builder::webview_sys;
use serde_json::Value;
use wry::{WebView, WebViewAttributes, WebViewBuilder};

use image::ImageFormat;
use mime_guess::from_path;
use tao::{
    dpi::{
        LogicalPosition, 
        LogicalSize, 
        LogicalUnit, 
        PhysicalPosition, 
        PhysicalSize, 
        PhysicalUnit, 
        PixelUnit, 
        Position, 
        Size
    }, 
    event::{Event, WindowEvent}, 
    event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy}, 
    monitor::{MonitorHandle, VideoMode}, 
    window::{
        Fullscreen, Icon, Theme, Window, WindowAttributes, WindowBuilder, WindowId, WindowSizeConstraints,
    },
    
};
use wry::{
    http::{
        header::CONTENT_TYPE, 
        HeaderMap, 
        Request, 
        Response
    }, 
    DragDropEvent, 
    PageLoadEvent, 
    ProxyConfig, 
    Rect
    
};

#[allow(dead_code)]
enum UserEvent {
    CloseWindow(WindowId),
    NewTitle(WindowId, String),
    NewWindow,
  }
 
fn get_nexium_response_protocol(
    request: Request<Vec<u8>>,
    index_page: &str,
    root_path: &PathBuf
) -> Result<Response<Vec<u8>>, Box<dyn std::error::Error>> {
    let path = request.uri().path();
    // Read the file content from file path

    let path = if path == "/" {
        index_page
    } else {
        // Removing leading slash
        &path[1..]
    };
    let full_path = std::fs::canonicalize(root_path.join(path))?;
    let content = std::fs::read(&full_path)?;
    #[cfg(target_os = "windows")]
    let headers = "https://wry.localhost".to_string();
    #[cfg(not(target_os = "windows"))]
    let headers = "wry://localhost".to_string();
    // Determine MIME type using `mime_guess`
    let mime_type = from_path(&full_path).first_or_octet_stream();

    Response::builder()
        .header(CONTENT_TYPE, mime_type.as_ref())
        .header("Access-Control-Allow-Origin", headers)
        .header("Cache-Control", "no-cache, no-store, must-revalidate")
        .header("Pragma", "no-cache")
        .header("Expires", "0")
        .header("Accept-Encoding", "gzip, compress, br, deflate")
        .body(content)
        .map_err(Into::into)
}




#[allow(dead_code)]
pub(self) fn prompt_for_monitor(event_loop: &EventLoop<UserEvent>, num:usize) ->  MonitorHandle {
    let monitor = event_loop
      .available_monitors()
      .nth(num)
      .expect("Please enter a valid ID");
  
    println!("Using {:?}", monitor.name());
  
    monitor
  }
  
pub fn prompt_for_video_mode(monitor: &MonitorHandle,num:usize) -> VideoMode {
    let video_mode = monitor
      .video_modes()
      .nth(num)
      .expect("Please enter a valid ID");
  
    println!("Using {}", video_mode);
  
    video_mode
  }



pub struct Nexium {
    event_loop: EventLoop<UserEvent>,
    proxy:Option<EventLoopProxy<UserEvent>>,
    webview_core: WebViewAttributes,
    window_core: WindowAttributes,
    webview:Option<WebView>,
    window:Option<Window>,
    config:HashMap<String,Value>
}

impl Nexium {
    pub fn new() -> Self {
        Self {
            event_loop: EventLoopBuilder::with_user_event().build(),
            proxy:None,
            webview_core: Default::default(),
            window_core: Default::default(),
            webview:None,
            window:None,
            config:HashMap::new()
        }
    }


   
    pub fn set_app_configurations(&mut self, host: Option<String>, port: Option<i32>, path: Option<String>) {
        let host = host.unwrap_or_else(|| "localhost".to_string());
        let port = port.unwrap_or(8080);
        let path = path.unwrap_or_else(|| "../../".to_string());
        let app_pth = PathBuf::from(path).to_string_lossy().to_string();
        
        self.config.insert("host".to_string(), Value::String(host));
        self.config.insert("port".to_string(), Value::Number(port.into()));
        self.config.insert("path".to_string(), Value::String(app_pth));
    }
   
    pub fn get_config(&self, key: &str) -> Option<&Value> {
        self.config.get(key)
    }

   
    pub fn use_html(&mut self, html: impl Into<String>){
        self.webview_core.html = Some(html.into());
       
    }


   
    pub fn use_accept_first_mouse(&mut self, accept_first_mouse:bool){
        self.webview_core.accept_first_mouse = accept_first_mouse;
    
    }



   
    pub fn use_autoplay(&mut self, autoplay:bool){
        self.webview_core.autoplay = autoplay;
    
    }


   
    pub fn use_back_forward_navigation_gestures(&mut self, gesture:bool){
        self.webview_core.back_forward_navigation_gestures = gesture;
    
    }


   
    pub fn use_background_color(&mut self, r:u8,g:u8,b:u8,a:u8){
        self.webview_core.background_color = Some((r, g, b, a));

    }


   
    pub fn use_bounds(&mut self,  x: i32, y: i32, width: i32, height: i32, position_type: &str, size_type: &str) {
        let position = match position_type {
            "physical" => Position::Physical(PhysicalPosition::new(x, y)),
            "logical" => Position::Logical(LogicalPosition::new(x as f64, y as f64)),
            _ => {
                println!("Invalid position type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
    
        let size = match size_type {
            "physical" => Size::Physical(PhysicalSize::new(width as u32, height as u32)),
            "logical" => Size::Logical(LogicalSize::new(width as f64, height as f64)),
            _ => {
                println!("Invalid size type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
        self.webview_core.bounds = Some(Rect {
            position,
            size
        });

    }


   
    pub fn use_clipboard(&mut self, clipboard:bool){
        self.webview_core.clipboard = clipboard;
    
    }


    

   
    pub fn use_devtools(&mut self, devtools: bool){
        self.webview_core.devtools  = devtools;
    
    }


   
    pub fn use_document_title_changed_handler(&mut self, func:String){
        self.webview_core.document_title_changed_handler = Some(Box::new(move|_|{
            println!("{}",func)
        }));
    
    }


   
    pub fn use_download_completed_handler(&mut self,  func: String) {
        self.webview_core.download_completed_handler = Some(Rc::new(move |url: String, path: Option<PathBuf>, success: bool| {
            println!("{}, {:?}, {}, {}", url, path, success, func);
            // You can also use url, path, and success here if needed
        }));
    }

   
    pub fn use_download_started_handler(&mut self,  func: String, allow_all:bool) {
        self.webview_core.download_started_handler = Some(Box::new(move |url: String, path: &mut PathBuf| {
            println!("{}, {:?}, {}", url, path, func);
            allow_all
        }));
    
    }


   
    fn use_drag_drop_handler(&mut self,  allow_all:bool) {
        self.webview_core.drag_drop_handler = Some(Box::new(move |event: DragDropEvent| {
            match event {
                DragDropEvent::Enter { paths, position } => {
                    println!("Drag entered with paths: {:?} at position: {:?}", paths, position);
                    // Handle the paths and position as needed
                }
                DragDropEvent::Leave {..} => {
                    println!("Leave");
                    // Handle the paths and position as needed
                }
                DragDropEvent::Over { position } => {
                    println!("Drag over with  position: {:?}",position);
                    // Handle the paths and position as needed
                }
                DragDropEvent::Drop { paths, position } => {
                    println!("Drag dropped with paths: {:?} at position: {:?}", paths, position);
                    // Handle the paths and position as needed
                }
           
                _ => (),
            }

            // Example: Allow all drag and drop events
            allow_all
        }));
    
    }


   
    pub fn use_focused(&mut self,  focused: bool){
        self.webview_core.focused = focused;
    
    }


   
    pub fn use_headers(&mut self, headers:HeaderMap){
        self.webview_core.headers = Some(headers);
    
    }


   
    pub fn use_hotkeys_zoom(&mut self,  zoom: bool){
        self.webview_core.zoom_hotkeys_enabled = zoom;
    
    }


   
    pub fn use_incognito(&mut self, incognito:bool){
        self.webview_core.incognito = incognito;
    
    }


   
    pub fn use_initialization_script(&mut self, js_code:&str){
        if !js_code.is_empty() {
            self.webview_core.initialization_scripts.push(js_code.to_string());
        }
    }



   
    pub fn use_ipc_handler<F>(&mut self,  handler: F) 
    where
      F: Fn(Request<String>) + 'static,
    {
      self.webview_core.ipc_handler = Some(Box::new(handler));
      
    }
  

   
    pub fn use_navigation_handler(&mut self,  all_navigation:bool){
        self.webview_core.navigation_handler = Some(Box::new(move|url: String| {
            println!("Navigating to: {}", url);
            all_navigation
        }));
    
    }


   
    pub fn use_new_window_req_handler(&mut self,all_navigation:bool){
        self.webview_core.new_window_req_handler = Some(Box::new(move|url: String| {
            println!("Navigating to: {}", url);
            all_navigation
        }));
    
    }


   
    pub fn use_on_page_load_handler(mut self) {
        self.webview_core.on_page_load_handler = Some(Box::new(move |event: PageLoadEvent, url: String| {
            match event {
                PageLoadEvent::Started => println!("Page load started at: {}", url),
                PageLoadEvent::Finished => println!("Page load finished at: {}", url),
              
            }
        }))
    }


   
    pub fn use_proxy_config(&mut self,  proxy_config:ProxyConfig){
        self.webview_core.proxy_config = Some(proxy_config);
    
    }


   
    pub fn use_transparent(&mut self,  transparent:bool){
        self.webview_core.transparent = transparent;
    
    }


   
    pub fn use_url(&mut self,  url: String){
        self.webview_core.url = Some(url.into());
        self.webview_core.headers = None;
      
    
    }


   
    pub fn use_url_and_headers(&mut self, url:String, header:HeaderMap){
        self.webview_core.url = Some(url.into());
        self.webview_core.headers = Some(header);
        
    
    }


   
    pub fn use_user_agent(&mut self,  user_agen:String){
        self.webview_core.user_agent = Some(user_agen);

    
    }


   
    pub fn use_visible(&mut self,  visible:bool){
        self.webview_core.visible= visible;
    
    }

    
    pub fn use_custom_protocol<F>(&mut self,  name: String, handler: F) 
    where
      F: Fn(Request<Vec<u8>>) -> Response<Cow<'static, [u8]>> + 'static,
    {
      self.webview_core.custom_protocols.push((
        name,
        Box::new(move |request, responder| {
          let http_response = handler(request);
          responder.respond(http_response);
        }),
      ));
     
    }



   
    pub fn use_always_on_bottom(&mut self, always_on_bottom: bool){
        self.window_core.always_on_bottom = always_on_bottom;
    
    }


   
    pub fn use_always_on_top(&mut self, always_on_top:bool){
        self.window_core.always_on_top = always_on_top;
    
    }


   
    pub fn use_closable(&mut self,closable:bool){
        self.window_core.closable = closable;
    
    }


   
    pub fn use_content_protection(&mut self,protected:bool){
        self.window_core.content_protection = protected;
    
    }


   
    pub fn use_decorations(&mut self,decorations:bool){
        self.window_core.decorations = decorations;
    
    }


   
    pub fn use_fullscreen(&mut self, fullscreen_type: &str) {
        let monitors: Vec<_> = self.event_loop.available_monitors().collect();
        
        if monitors.is_empty() {
            println!("No monitors available.");
            return;
        }
    
        //let num = monitors.len();
    
        let fullscreen = match fullscreen_type {
            "exclusive" => {
                let monitor = prompt_for_monitor(&self.event_loop, 0);
                let video_mode = prompt_for_video_mode(&monitor, 0);
                Some(Fullscreen::Exclusive(video_mode))
            }
            "borderless" => {
                let monitor = prompt_for_monitor(&self.event_loop, 0);
                Some(Fullscreen::Borderless(Some(monitor)))
            }
            "default" => Some(Fullscreen::Borderless(None)),
            _ => {
                println!("Invalid fullscreen type provided. Use 'exclusive' or 'borderless'.");
                return;
            },
        };
    
        self.window_core.fullscreen = fullscreen;
    }


   
    pub fn use_inner_size(&mut self,width:i32,height:i32, size_type:&str){
        let size = match size_type {
            "physical" => Size::Physical(PhysicalSize::new(width as u32, height as u32)),
            "logical" => Size::Logical(LogicalSize::new(width as f64, height as f64)),
            _ => {
                println!("Invalid size type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
        self.window_core.inner_size = Some(size);
    
    }


   
    pub fn use_inner_size_constraints(
        &mut self,
        min_width: i32,
        min_height: i32,
        max_width: i32,
        max_height: i32,
        constraints_type: &str
    ) {
        let (min_width, min_height, max_width, max_height) = match constraints_type {
            "logical" => (
                PixelUnit::Logical(LogicalUnit(min_width as f64)),
                PixelUnit::Logical(LogicalUnit(min_height as f64)),
                PixelUnit::Logical(LogicalUnit(max_width as f64)),
                PixelUnit::Logical(LogicalUnit(max_height as f64)),
            ),
            "physical" => (
                PixelUnit::Physical(PhysicalUnit(min_width)),
                PixelUnit::Physical(PhysicalUnit(min_height)),
                PixelUnit::Physical(PhysicalUnit(max_width)),
                PixelUnit::Physical(PhysicalUnit(max_height)),
            ),
            "mix_left" => (
                PixelUnit::Logical(LogicalUnit(min_width as f64)),
                PixelUnit::Logical(LogicalUnit(min_height as f64)),
                PixelUnit::Physical(PhysicalUnit(max_width)),
                PixelUnit::Physical(PhysicalUnit(max_height)),
            ),
            "mix_right" => (
                PixelUnit::Physical(PhysicalUnit(min_width)),
                PixelUnit::Physical(PhysicalUnit(min_height)),
                PixelUnit::Logical(LogicalUnit(max_width as f64)),
                PixelUnit::Logical(LogicalUnit(max_height as f64)),
            ),
            "mix_top_left" => (
                PixelUnit::Physical(PhysicalUnit(min_width)),
                PixelUnit::Logical(LogicalUnit(min_height as f64)),
                PixelUnit::Physical(PhysicalUnit(max_width)),
                PixelUnit::Logical(LogicalUnit(max_height as f64)),
            ),
            "mix_top_right" => (
                PixelUnit::Logical(LogicalUnit(min_width as f64)),
                PixelUnit::Physical(PhysicalUnit(min_height)),
                PixelUnit::Logical(LogicalUnit(max_width as f64)),
                PixelUnit::Physical(PhysicalUnit(max_height)),
            ),
            _ => {
                eprintln!("Error: Invalid constraints_type '{}'", constraints_type);
                return; // Early return on invalid constraints_type
            }
        };
    
        self.window_core.inner_size_constraints = WindowSizeConstraints::new(
            Some(min_width), Some(min_height), Some(max_width), Some(max_height)
        );
    }
    



   
    pub fn use_maximizable(&mut self,maximizable: bool){
        self.window_core.maximizable = maximizable;
    
    }


   
    pub fn use_maximized(&mut self,maximized: bool){
        self.window_core.maximized = maximized;
    
    }


   
    pub fn use_max_inner_size(&mut self, width: i32, height: i32, min_size_type: &str) {
        let size = match min_size_type {
            "physical" => Size::Physical(PhysicalSize::new(width as u32, height as u32)),
            "logical" => Size::Logical(LogicalSize::new(width as f64, height as f64)),
            _ => {
                println!("Invalid size type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
        
        match size {
            Size::Physical(physical_size) => {
                self.window_core.inner_size_constraints.max_width = Some(PixelUnit::Physical(physical_size.width.into()));
                self.window_core.inner_size_constraints.max_height = Some(PixelUnit::Physical(physical_size.height.into()));
            }
            Size::Logical(logical_size) => {
                self.window_core.inner_size_constraints.max_width = Some(PixelUnit::Logical(logical_size.width.into()));
                self.window_core.inner_size_constraints.max_height = Some(PixelUnit::Logical(logical_size.height.into()));
            }
        }
    }
   
    pub fn use_min_inner_size(&mut self, width: i32, height: i32, min_size_type: &str) {
        let size = match min_size_type {
            "physical" => Size::Physical(PhysicalSize::new(width as u32, height as u32)),
            "logical" => Size::Logical(LogicalSize::new(width as f64, height as f64)),
            _ => {
                println!("Invalid size type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
        
        match size {
            Size::Physical(physical_size) => {
                self.window_core.inner_size_constraints.min_width = Some(PixelUnit::Physical(physical_size.width.into()));
                self.window_core.inner_size_constraints.min_height = Some(PixelUnit::Physical(physical_size.height.into()));
            }
            Size::Logical(logical_size) => {
                self.window_core.inner_size_constraints.min_width = Some(PixelUnit::Logical(logical_size.width.into()));
                self.window_core.inner_size_constraints.min_height = Some(PixelUnit::Logical(logical_size.height.into()));
            }
        }
    }
   
    pub fn use_minimizable(&mut self,minimizable: bool){
        self.window_core.maximizable = minimizable;
    
    }


   
    pub fn use_position(&mut self, x:i32, y:i32, position_type:&str){
        let position = match position_type {
            "physical" => Position::Physical(PhysicalPosition::new(x, y)),
            "logical" => Position::Logical(LogicalPosition::new(x as f64, y as f64)),
            _ => {
                println!("Invalid position type provided. Use 'physical' or 'logical'.");
                return;
            }
        };
        self.window_core.position = Some(position);
    
    }


   
    pub fn use_resizable(&mut self,resizable: bool){
        self.window_core.resizable = resizable;
        
    
    }


   
    pub fn use_theme(&mut self, theme: String){
        match theme.as_str() {
            "dark" => self.window_core.preferred_theme = Some(Theme::Dark),
            "light" => self.window_core.preferred_theme = Some(Theme::Light),
            "system" => self.window_core.preferred_theme = Some(Theme::default()),
            _ => println!("Invalid theme. Please use 'dark', 'light', or 'system'"),
        }
    }


    

   
    pub fn use_title(&mut self,title:&str){
        self.window_core.title = title.to_string();
    
    }


   
    pub fn use_visible_on_all_workspaces(&mut self,visible: bool){
        self.window_core.visible_on_all_workspaces = visible;
    
    }


   
    pub fn use_window_icon(&mut self, icon: &str) {
        // Holen des Basispfads aus der Konfiguration
        if let Some(base_path) = self.config.get("path").and_then(|v| v.as_str()) {
            let icon_path = Path::new(base_path).join(icon);
            
            let icon_object = match read(&icon_path) {
                Err(_) => None,
                Ok(bytes) => {
                    let imagebuffer = match image::load_from_memory_with_format(&bytes, ImageFormat::Png) {
                        Err(_) => None,
                        Ok(loaded) => {
                            let imagebuffer = loaded.to_rgba8();
                            let (icon_width, icon_height) = imagebuffer.dimensions();
                            let icon_rgba = imagebuffer.into_raw();
                            match Icon::from_rgba(icon_rgba, icon_width, icon_height) {
                                Err(_) => None,
                                Ok(icon) => Some(icon),
                            }
                        }
                    };
                    imagebuffer
                }
            };
            self.window_core.window_icon = icon_object;
        } else {
            println!("Base path is not set in the configuration.");
        }
    }


   
    pub fn on_applications_startup_event(self, _func:String){}

   
    pub fn on_applications_shutdown_event(self, _func:String){}

   
    pub fn run(mut self, json_data:Value) {

        let  proxy = self.event_loop.create_proxy();

        self.proxy = Some(proxy);

        let mut window_builder = WindowBuilder::new();

        window_builder.window = self.window_core;

        let main_window = window_builder.build(&self.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 = window.default_vbox().unwrap();
            WebViewBuilder::new_gtk(vbox)
          };

        webview_builder.attrs = self.webview_core;
        let mwebview = webview_builder.build().unwrap();
        let webview = webview_sys(mwebview, json_data);

        self.webview = Some(webview);

        self.window = Some(main_window);

        main_window_loop(self.event_loop);
    }
}





pub(self) fn main_window_loop(event_loop:EventLoop<UserEvent>){
    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Wait;

        if let Event::WindowEvent {
            event: WindowEvent::CloseRequested,
            ..
        } = event
        {
            *control_flow = ControlFlow::Exit
        }
    });
}



unsafe impl Send for Nexium {}

lib.rs

use pyo3::prelude::*;
mod app;
use crate::app::Nexium;


#[pyclass]
pub struct PyNexium {
    window: Nexium,
}

#[pymethods]
impl PyNexium {
    #[new]
    pub fn new() -> PyNexium {
        let main_window = Nexium::new();
        PyNexium { window: main_window }
    }

    pub fn start(&self, json_data: &str) {
        self.window.run(json_data.into());
    }
}

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

[birkenfeld]

Since run() takes a self reference, it will make the Nexium struct unavailable, which is not possible in a pyclass (references to the Python object can be shared anywhere to Python code).

To do this safely, you can for example use an Option to ensure that start is called only once:

#[pyclass]
pub struct PyNexium {
    window: Option<Nexium>,
}

#[pymethods]
impl PyNexium {
    #[new]
    pub fn new() -> PyNexium {
        let main_window = Nexium::new();
        PyNexium { window: Some(main_window) }
    }

    pub fn start(&mut self, json_data: &str) -> PyResult<()> {
        if let Some(win) = self.window.take() {
            win.run(json_data.into());
            Ok(())
        } else {
            Err(PyRuntimeError::new_err("already started"))
        }
    }
}

[AriBermeki]

Is it possible to call one Python function before starting the application and one before stopping the application(on_startup_event, on_shutdown_event) ? and the both functions must be optional and not mandatory.

use pyo3::{exceptions::PyRuntimeError, prelude::*};
mod app;
use crate::app::Nexium;


#[pyclass]
pub struct PyNexium {
    window: Option<Nexium>,
}

#[pymethods]
impl PyNexium {
    #[new]
    pub fn new() -> PyNexium {
        let main_window = Nexium::new();
        PyNexium { window: Some(main_window) }
    }

       #[pyo3(signature = (json_data, on_startup_event=None, on_shutdown_event=None))]
    pub fn start(&mut self, py: Python, json_data: &str, on_startup_event: Option<PyObject>, on_shutdown_event: Option<PyObject>) -> PyResult<()> {
        Python::with_gil(|py|{
                // Call the on_startup_event if it's provided
            if let Some(ref startup_event) = on_startup_event {
                startup_event.call0(py).map_err(|e| {
                    PyErr::new::<PyRuntimeError, _>(format!("Error in on_startup_event: {:?}", e))
                })?;
            }

            if let Some(win) = self.window.take() {
                win.run(json_data.into());

                // Call the on_shutdown_event if it's provided
                if let Some(ref shutdown_event) = on_shutdown_event {
                    shutdown_event.call0(py).map_err(|e| {
                        PyErr::new::<PyRuntimeError, _>(format!("Error in on_shutdown_event: {:?}", e))
                    })?;
                }
                
                Ok(())
            } else {
                Err(PyRuntimeError::new_err("already started"))
            }
        });
}

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

[birkenfeld]

Doesn't look bad, what's the concrete problem you have with that code? (Except that I wouldn't run the startup code if self.window is already taken)

[AriBermeki]

That was something different but I'm using what you said. My idea was that when the app starts, a python callback is called and also when it stops. and that's what I achieved. Thanks again