allow failure when init ontoenv in Python. more flexibility

Author: gtfierro

cli/src/main.rs

@@ -138,7 +138,11 @@ fn main() -> Result<()> {
             env.save_to_directory()?;
         }
         Commands::Version => {
-            println!("ontoenv {} @ {}", env!("CARGO_PKG_VERSION"), env!("GIT_HASH"));
+            println!(
+                "ontoenv {} @ {}",
+                env!("CARGO_PKG_VERSION"),
+                env!("GIT_HASH")
+            );
         }
         Commands::Status => {
             // load env from .ontoenv/ontoenv.json

lib/src/config.rs

@@ -25,7 +25,7 @@ where
     patterns.map_err(serde::de::Error::custom)
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct Config {
     pub root: PathBuf,
     #[serde(default)]
@@ -165,7 +165,7 @@ impl Config {
         let file = std::fs::File::open(file)?;
         let reader = BufReader::new(file);
         let mut config: Config = serde_json::from_reader(reader)?;
-        
+
         if config.search_directories.is_empty() {
             config.search_directories = vec![config.root.clone()];
         }

lib/src/lib.rs

@@ -110,15 +110,36 @@ impl OntoEnv {
         // create the config.root/.ontoenv directory so it exists before the store
         // is created
         let ontoenv_dir = config.root.join(".ontoenv");
+        let config_path = ontoenv_dir.join("ontoenv.json");
 
-        // if recreate is False, raise an error if the directory already exists
-        if ontoenv_dir.exists() && !recreate {
-            return Err(anyhow::anyhow!(
-                "OntoEnv directory already exists: {:?}. Run 'refresh' or use the --recreate flag to recreate the environment.",
+        // test if the config in the ontoenv_dir is different from the current config.
+        // If it is, replace the config with the current config and turn 'recreate' on
+        if ontoenv_dir.exists() && config_path.exists() {
+            println!(
+                "OntoEnv directory exists: {:?}. Checking config",
                 ontoenv_dir
-            ));
+            );
+            let file = std::fs::File::open(&config_path)?;
+            let reader = BufReader::new(file);
+            let env: OntoEnv = serde_json::from_reader(reader)?;
+            // print old and new config
+            println!("Old config: {:?}", env.config);
+            println!("New config: {:?}", config);
+            if env.config != config {
+                info!("OntoEnv configuration has changed. Recreating environment.");
+                fs::remove_dir_all(&ontoenv_dir)?;
+                return Self::new(config, true);
+            }
         }
 
+        // if recreate is False, raise an error if the directory already exists
+        //if ontoenv_dir.exists() && !recreate {
+        //    return Err(anyhow::anyhow!(
+        //        "OntoEnv directory already exists: {:?}. Run 'refresh' or use the --recreate flag to recreate the environment.",
+        //        ontoenv_dir
+        //    ));
+        //}
+
         std::fs::create_dir_all(&ontoenv_dir)?;
 
         // create the store in the root/.ontoenv/store.db directory

python/src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(once_cell_try)]
 use ::ontoenv as ontoenvrs;
 use ::ontoenv::consts::{ONTOLOGY, TYPE};
 use ::ontoenv::ontology::OntologyLocation;
@@ -124,7 +125,7 @@ struct Config {
 #[pymethods]
 impl Config {
     #[new]
-    #[pyo3(signature = (search_directories, require_ontology_names=false, strict=false, offline=false, resolution_policy="default".to_owned(), root=".".to_owned(), includes=vec![], excludes=vec![]))]
+    #[pyo3(signature = (search_directories=None, require_ontology_names=false, strict=false, offline=false, resolution_policy="default".to_owned(), root=".".to_owned(), includes=vec![], excludes=vec![]))]
     fn new(
         search_directories: Option<Vec<String>>,
         require_ontology_names: bool,
@@ -185,23 +186,34 @@ impl OntoEnv {
             env_logger::init();
         });
 
-        let env = ONTOENV_SINGLETON.get_or_init(|| {
-            let inner = if let Some(p) = path {
-                let config_path = p.join(".ontoenv").join("ontoenv.json");
-                if let Ok(env) = ontoenvrs::OntoEnv::from_file(&config_path, read_only) {
+        let config_path = path
+            .as_ref()
+            .map(|p| p.join(".ontoenv").join("ontoenv.json"));
+        println!("Config path: {:?}", config_path);
+
+        let env = ONTOENV_SINGLETON.get_or_try_init(|| {
+            // if no Config provided, but there is a path, load the OntoEnv from file
+            // otherwise, create a new OntoEnv
+            if config.is_none() && config_path.is_some() && config_path.as_ref().unwrap().exists(){
+                if let Ok(env) = ontoenvrs::OntoEnv::from_file(&config_path.unwrap(), read_only) {
                     println!("Loaded OntoEnv from file");
-                    env
-                } else {
-                    println!("Creating new OntoEnv");
-                    ontoenvrs::OntoEnv::new(config.unwrap().borrow().cfg.clone(), recreate)
-                        .expect("Failed to create OntoEnv")
+                    return Ok(Arc::new(Mutex::new(env)));
                 }
-            } else {
-                ontoenvrs::OntoEnv::new(config.unwrap().borrow().cfg.clone(), recreate)
-                    .expect("Failed to create OntoEnv")
-            };
-            Arc::new(Mutex::new(inner))
-        });
+            }
+
+            // if config is provided, create a new OntoEnv with the provided config
+            if let Some(c) = config {
+                println!("Creating new OntoEnv with provided config");
+                let inner = ontoenvrs::OntoEnv::new(c.cfg.clone(), recreate)
+                    .map_err(anyhow_to_pyerr)?;
+                return Ok(Arc::new(Mutex::new(inner)));
+            }
+
+            Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                "Either a Config or a path must be provided. If path provided, there must be a valid OntoEnv directory at the path",
+            ))
+
+        })?;
 
         {
             let mut env = env.lock().unwrap();