Adds functionality to recover broken or incompatible models

Cargo.toml

@@ -26,6 +26,8 @@ url = "2.5.2"
 uuid = "1.10.0"
 http = "1.1.0"
 sha2 = "0.10.9"
+aspartial = { version="0.0.4", features = ["iso8601"] }
+unic = "0.9.0"
 
 
 # FIXME: this is from the egui example app

bioimg_codegen/Cargo.toml

@@ -14,3 +14,4 @@ proc-macro = true
 proc-macro2 = "1.0.78"
 quote = "1.0.35"
 syn = { version = "2.0.52", features = ["full"] }
+heck = { version = "0.5.0" }

bioimg_codegen/src/lib.rs

@@ -7,6 +7,7 @@ use proc_macro::TokenStream;
 mod str_marker;
 mod syn_extensions;
 mod restore;
+mod serde_attributes;
 
 ////////////////////////////////////////////
 

bioimg_codegen/src/syn_extensions/mod.rs

@@ -1,3 +1,8 @@
+// pub trait IFieldExt{
+//     fn to_partial_field()
+// }
+
+
 // use quote::quote;
 
 // pub trait AttributeExt {
@@ -20,3 +25,4 @@
 //         syn::LitStr::new(&quote!(#self).to_string(), self.span())
 //     }
 // }
+// 

bioimg_gui/Cargo.toml

@@ -13,6 +13,7 @@ bioimg_runtime = {path = "../bioimg_runtime"}
 bioimg_zoo = {path = "../bioimg_zoo"}
 
 serde = { workspace = true, features = ["derive"] }
+serde_yaml = { workspace = true }
 image = { workspace = true }
 url = { workspace=true, features = ["serde"] }
 uuid = { workspace = true, features = ["v4"] }
@@ -22,6 +23,7 @@ ndarray = { workspace = true }
 ndarray-npy = { workspace = true }
 thiserror = { workspace = true }
 strum = { workspace = true }
+aspartial = { workspace = true }
 
 egui = { version = "0.31.0", features = ["serde"] }
 eframe = { version = "0.31.0" }
@@ -35,6 +37,7 @@ bson = "2.11.0"
 indoc = "2.0.5"
 itertools = "0.14.0"
 sha2 = { workspace = true }
+serde_path_to_error = "0.1.17"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

bioimg_gui/src/app.rs

@@ -3,6 +3,8 @@ use std::path::Path;
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
+use bioimg_runtime::zip_archive_ext::SharedZipArchive;
+use bioimg_spec::rdf::model::model_rdf_0_5::PartialModelRdfV0_5;
 use bioimg_spec::rdf::model::ModelRdfName;
 use bioimg_zoo::collection::ZooNickname;
 use indoc::indoc;
@@ -14,20 +16,19 @@ use bioimg_spec::rdf::ResourceId;
 use bioimg_spec::rdf::bounded_string::BoundedString;
 use bioimg_spec::rdf::non_empty_list::NonEmptyList;
 
-use crate::project_data::{AppStateRawData, ProjectLoadError};
+use crate::project_data::{AppState1RawData, AppStateRawData, ProjectLoadError};
 use crate::result::{GuiError, Result, VecResultExt};
 use crate::widgets::attachments_widget::AttachmentsWidget;
 
 use crate::widgets::code_editor_widget::MarkdwownLang;
 use crate::widgets::collapsible_widget::SummarizableWidget;
 use crate::widgets::cover_image_widget::CoverImageItemConf;
-// use crate::widgets::cover_image_widget::CoverImageWidget;
 use crate::widgets::icon_widget::IconWidgetValue;
 use crate::widgets::image_widget_2::SpecialImageWidget;
 use crate::widgets::json_editor_widget::JsonObjectEditorWidget;
 use crate::widgets::model_interface_widget::ModelInterfaceWidget;
 use crate::widgets::model_links_widget::ModelLinksWidget;
-use crate::widgets::notice_widget::NotificationsWidget;
+use crate::widgets::notice_widget::{Notification, NotificationsWidget};
 use crate::widgets::pipeline_widget::PipelineWidget;
 use crate::widgets::search_and_pick_widget::SearchAndPickWidget;
 use crate::widgets::staging_opt::StagingOpt;
@@ -46,10 +47,16 @@ use crate::widgets::{
     util::group_frame, StatefulWidget,
 };
 
+pub struct AppStateFromPartial{
+    state: AppState1RawData,
+    warnings: String,
+}
+
 #[must_use]
 pub enum TaskResult{
     Notification(Result<String, String>),
     ModelImport(Box<rt::zoo_model::ZooModel>),
+    PartialModelLoad(AppStateFromPartial),
 }
 
 impl TaskResult{
@@ -61,6 +68,14 @@ impl TaskResult{
     }
 }
 
+#[derive(Default, Copy, Clone)]
+enum ExitingStatus{
+    #[default]
+    NotExiting,
+    Confirming,
+    Exiting,
+}
+
 #[derive(Restore)]
 pub struct AppState1 {
     pub staging_name: StagingString<ModelRdfName>,
@@ -103,9 +118,7 @@ pub struct AppState1 {
     #[restore_default]
     pub notifications_channel: TaskChannel<TaskResult>,
     #[restore_default]
-    close_confirmed: bool,
-    #[restore_default]
-    show_confirmation_dialog: bool,
+    exiting_status: ExitingStatus,
 }
 
 impl ValueWidget for AppState1{
@@ -193,8 +206,7 @@ impl Default for AppState1 {
             zoo_model_creation_task: Default::default(),
             pipeline_widget: Default::default(),
 
-            close_confirmed: false,
-            show_confirmation_dialog: false,
+            exiting_status: Default::default(),
         }
     }
 }
@@ -401,6 +413,30 @@ impl AppState1{
         #[cfg(not(target_arch="wasm32"))]
         std::thread::spawn(move || smol::block_on(fut));
     }
+
+    fn load_partial_model(archive: &SharedZipArchive) -> Result<AppStateFromPartial>{
+        let model_rdf_bytes: Vec<u8> = 'model_rdf: {
+            for file_name in ["rdf.yaml", "bioimageio.yaml"]{
+                match archive.read_full_entry(file_name) {
+                    Ok(bytes) => break 'model_rdf bytes,
+                    Err(zip_err) => match zip_err{
+                        zip::result::ZipError::FileNotFound => continue,
+                        err => return Err(GuiError::new(format!("Could not read rdf file: {err}")))
+                    }
+                };
+            }
+            return Err(GuiError::new("Could not find rdf file inside archive"))
+        };
+        let yaml_deserializer = serde_yaml::Deserializer::from_slice(&model_rdf_bytes);
+        let partial: PartialModelRdfV0_5 = ::serde_path_to_error::deserialize(yaml_deserializer)?;
+        let mut warnings = String::with_capacity(16 * 1024);
+        let state = AppState1RawData::from_partial(&archive, partial, &mut warnings); //FIXME: retrieve errors and notify
+        warnings += indoc!("
+            PLEASE BE AWARE THAT RECOVERING AND THEN RE-EXPORTING A MODEL MIGHT PRODUCE A NEW, VALID MODEL THAT DOES NOT
+            BEHAVE LIKE THE ORIGINAL\n"
+        );
+        Ok(AppStateFromPartial { state, warnings})
+    }
 }
 
 
@@ -430,7 +466,7 @@ impl eframe::App for AppState1 {
                         let model = match self.create_model(){
                             Ok(model) => model,
                             Err(err) => {
-                                self.notifications_widget.push_message(Err(err.to_string()));
+                                self.notifications_widget.push(Notification::error(err.to_string(), None));
                                 return;
                             }
                         };
@@ -452,11 +488,11 @@ impl eframe::App for AppState1 {
                         return;
                     }
                     match packing_task.join().unwrap(){
-                        Ok(nickname) => self.notifications_widget.push_message(
-                            Ok(format!("Model successfully uploaded: {nickname}"))
+                        Ok(nickname) => self.notifications_widget.push(
+                            Notification::info(format!("Model successfully uploaded: {nickname}"), None)
                         ),
-                        Err(upload_err) => self.notifications_widget.push_message(
-                            Err(format!("Could not upload model: {upload_err}"))
+                        Err(upload_err) => self.notifications_widget.push(
+                            Notification::error(format!("Could not upload model: {upload_err}"), None)
                         ),
                     };
                 })});
@@ -493,6 +529,43 @@ impl eframe::App for AppState1 {
                             sender.send(message).unwrap();
                         }
                     }
+                    if ui.button("♻📦⤴ Recover Model")
+                        .on_hover_text(
+                            "Import data from a model .zip archive that is potentially broken or incompatible with this application"
+                        )
+                        .clicked()
+                    {
+                        ui.close_menu();
+                        let sender = self.notifications_channel.sender().clone();
+                        let fut = async move {
+                            // On web, file picker is always async, so we make a future.
+                            // Also, we don't want to pass in an entire Arc<Mutex<App>> to the future,
+                            // so it gets a sender: Sender<TaskResult> instead to report its result back.
+                            let Some(handle) = rfd::AsyncFileDialog::new().add_filter("bioimage model", &["zip"]).pick_file().await else {
+                                return
+                            };
+                            // #[cfg(target_arch="wasm32")]
+                            let archive = SharedZipArchive::from_raw_data(handle.read().await, handle.file_name());
+                            // #[cfg(not(target_arch="wasm32"))]
+                            // let archive = match SharedZipArchive::open(handle.path()){
+                            //     Ok(archive) => archive,
+                            //     Err(e) => {
+                            //         let err = Err(format!("Could not open {}: {e}", handle.path().to_string_lossy()));
+                            //         _ = sender.send(TaskResult::Notification(err));
+                            //         return
+                            //     }
+                            // };
+                            let message = match Self::load_partial_model(&archive) {
+                                Err(err) => TaskResult::Notification(Err(format!("Could not recover model: {err}"))),
+                                Ok(state_from_partial) => TaskResult::PartialModelLoad(state_from_partial),
+                            };
+                            sender.send(message).unwrap();
+                        };
+                        #[cfg(target_arch="wasm32")]
+                        wasm_bindgen_futures::spawn_local(fut);
+                        #[cfg(not(target_arch="wasm32"))]
+                        std::thread::spawn(move || smol::block_on(fut));
+                    }
                     #[cfg(not(target_arch="wasm32"))]
                     if ui.button("🗊⤵ Save Draft ")
                         .on_hover_text("Save your current work as-is, even with unresolved errors")
@@ -503,7 +576,7 @@ impl eframe::App for AppState1 {
                             break 'save_project;
                         };
                         let result = self.save_project(&path);
-                        self.notifications_widget.push_message(result);
+                        self.notifications_widget.push(result.into());
                     }}
                     #[cfg(not(target_arch="wasm32"))]
                     if ui.button("🗊⤴ Load Draft")
@@ -515,7 +588,7 @@ impl eframe::App for AppState1 {
                             break 'load_project;
                         };
                         if let Err(err) = self.load_project(&path){
-                            self.notifications_widget.push_message(Err(err));
+                            self.notifications_widget.push(Notification::error(err, None));
                         }
                     }}
                 });
@@ -530,8 +603,12 @@ impl eframe::App for AppState1 {
         egui::CentralPanel::default().show(ctx, |ui| {
             while let Ok(msg) = self.notifications_channel.receiver().try_recv(){
                 match msg{
-                    TaskResult::Notification(msg) => self.notifications_widget.push_message(msg),
+                    TaskResult::Notification(msg) => self.notifications_widget.push(msg.into()),
                     TaskResult::ModelImport(model) => self.set_value(*model),
+                    TaskResult::PartialModelLoad(AppStateFromPartial{state, warnings}) => {
+                        self.restore(state);
+                        self.notifications_widget.push(Notification::warning(warnings, None));
+                    }
                 }
             }
             if let Some(error_rect) = self.notifications_widget.draw(ui, egui::Id::from("messages_widget")){
@@ -766,50 +843,59 @@ impl eframe::App for AppState1 {
                 if save_button_clicked {
                     match self.create_model(){
                         Ok(zoo_model) => self.launch_model_saving(zoo_model),
-                        Err(err) => self.notifications_widget.push_gui_error(
-                            GuiError::new(format!("Could not create zoo model: {err}"))
+                        Err(err) => self.notifications_widget.push(
+                            Notification::error(format!("Could not create zoo model: {err}"), None)
                         ),
                     }
                 }
             });
         });
 
-        if ctx.input(|i| i.viewport().close_requested()) {
-            if self.close_confirmed {
-                // do nothing - we will close
-            } else {
-                ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-                self.show_confirmation_dialog = true;
-            }
-        }
+        let close_requested = ctx.input(|i| i.viewport().close_requested());
+        self.exiting_status = match self.exiting_status {
+            ExitingStatus::NotExiting => {
+                if close_requested {
+                    ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+                    ExitingStatus::Confirming
+                } else {
+                    ExitingStatus::NotExiting
+                }
+            },
+            ExitingStatus::Confirming => {
+                if close_requested {
+                    ExitingStatus::Exiting
+                } else {
+                    ExitingStatus::Confirming
+                }
+            },
+            ExitingStatus::Exiting => {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+                ExitingStatus::Exiting
+            },
+        };
 
         #[cfg(not(target_arch="wasm32"))]
-        if self.show_confirmation_dialog {
+        if matches!(self.exiting_status, ExitingStatus::Confirming) {
             egui::Modal::new(egui::Id::from("confirmation dialog"))
                 .show(ctx, |ui| {
                     ui.label("Save draft before quitting?");
                     ui.horizontal(|ui| {
                         if ui.button("Yes 💾").clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)){ 'save_draft: {
-                            self.show_confirmation_dialog = false;
                             let Some(path) = rfd::FileDialog::new().set_file_name("MyDraft.bmb").save_file() else {
+                                self.exiting_status = ExitingStatus::NotExiting;
                                 break 'save_draft;
                             };
                             let result = self.save_project(&path);
                             if result.is_ok(){
-                                self.show_confirmation_dialog = false;
-                                self.close_confirmed = true;
-                                ui.ctx().send_viewport_cmd(egui::ViewportCommand::Close);
+                                self.exiting_status = ExitingStatus::Exiting;
                             }
-                            self.notifications_widget.push_message(result);
+                            self.notifications_widget.push(result.into());
                         }}
                         if ui.button("No 🗑").clicked() {
-                            self.show_confirmation_dialog = false;
-                            self.close_confirmed = true;
-                            ui.ctx().send_viewport_cmd(egui::ViewportCommand::Close);
+                            self.exiting_status = ExitingStatus::Exiting;
                         }
                         if ui.button("Cancel 🗙").clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-                            self.show_confirmation_dialog = false;
-                            self.close_confirmed = false;
+                            self.exiting_status = ExitingStatus::NotExiting;
                         }
                     });
                 });