Merge branch 'feature/python_list'

Merging updated python lib
Added support for latest pyo3
Fixed zip reading from cli
Improved crate context handling for rocraters
Added basic validation dict for rocraters

Author: Matt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ro-crate-rs-cli"
-version = "0.4.11"
+version = "0.4.12"
 edition = "2021"
 repository = "https://github.com/intbio-ncl/ro-crate-rs"
 authors = ["Matt Burridge <m.burridge1@newcastle.ac.uk>"]

cli/Cargo.toml

@@ -226,6 +226,8 @@ pub struct ZipCrateCommand {
 
 #[derive(Debug, Subcommand)]
 pub enum ReadCommand {
+    /// Read full crate from zip archive
+    Zip(ReadZipCommand),
     /// Read full crate
     Crate(ReadCrateCommand),
     /// Read entity of crate
@@ -257,6 +259,25 @@ pub struct ReadCrateCommand {
     pub json: bool,
 }
 
+#[derive(Debug, Args)]
+pub struct ReadZipCommand {
+    /// Target zip archive
+    #[clap(short, long, required = true)]
+    pub target_zip: String,
+    /// Validation level for schema checks (0-2)
+    #[clap(short = 'l', long, default_value_t = 0)]
+    pub validation_level: i8,
+    /// Raw struct data
+    #[clap(short, long)]
+    pub raw_struct: bool,
+    /// Prints full view without trimming
+    #[clap(short, long)]
+    pub fit: bool,
+    /// Prints as json
+    #[clap(short, long)]
+    pub json: bool,
+}
+
 /// TODO: Add a field to recursively show all linked ids
 #[derive(Debug, Args)]
 pub struct ReadEntityCommand {

cli/src/args.rs

@@ -155,6 +155,34 @@ fn main() {
             }
         },
         CrateAction::Read(read_command) => match read_command {
+            ReadCommand::Zip(read_zip_command) => {
+                let rocrate = open_and_load_zip_crate(
+                    &read_zip_command.target_zip,
+                    read_zip_command.validation_level,
+                );
+
+                if read_zip_command.raw_struct {
+                    println!("{:#?}", rocrate);
+                    return;
+                }
+                if read_zip_command.json {
+                    println!("{}", to_string_pretty(&rocrate).unwrap());
+                } else {
+                    match to_string_pretty(&rocrate) {
+                        Ok(_json_ld) => {
+                            let mut table = json_to_table(&json!(&rocrate.graph)).into_table();
+                            table.with(Style::modern_rounded());
+                            if read_zip_command.fit {
+                                table.modify(Rows::new(1..), Width::truncate(200).suffix("..."));
+                            } else {
+                                table.modify(Rows::new(1..), Width::truncate(79).suffix("..."));
+                            }
+                            println!("{}", table)
+                        }
+                        Err(e) => eprintln!("Failed to display crate: {}", e),
+                    }
+                }
+            }
             ReadCommand::Crate(read_crate_command) => {
                 let rocrate = open_and_load_crate(&read_crate_command.target_crate);
 
@@ -286,13 +314,7 @@ fn main() {
 /// Input requires target_crate file string
 fn open_and_load_crate(input: &str) -> RoCrate {
     if input.ends_with(".zip") {
-        match parse_zip(input, 0) {
-            Ok(ro_crate) => ro_crate,
-            Err(e) => {
-                eprintln!("Error processing crate: {:?}", e);
-                std::process::exit(1)
-            }
-        }
+        open_and_load_zip_crate(input, 0)
     } else {
         let target_crate = crate_path(input);
         match read_crate(&target_crate, 1) {
@@ -305,6 +327,26 @@ fn open_and_load_crate(input: &str) -> RoCrate {
     }
 }
 
+fn open_and_load_zip_crate(input: &str, validation_level: i8) -> RoCrate {
+    if !input.ends_with(".zip") {
+        eprintln!("Target archive must end with .zip");
+        std::process::exit(1)
+    }
+
+    if !(0..=2).contains(&validation_level) {
+        eprintln!("Validation level must be between 0 and 2");
+        std::process::exit(1)
+    }
+
+    match parse_zip(input, validation_level) {
+        Ok(ro_crate) => ro_crate,
+        Err(e) => {
+            eprintln!("Error processing zip crate: {:?}", e);
+            std::process::exit(1)
+        }
+    }
+}
+
 fn create_rocrate_with_context(context_type: ContextType) -> RoCrate {
     match context_type {
         ContextType::Reference => {