change initialization semantics (again)

Author: gtfierro

lib/src/api.rs

@@ -222,6 +222,37 @@ impl OntoEnv {
         }
     }
 
+    /// Opens an existing environment rooted at `config.root`, or initializes a new one using
+    /// the provided configuration when none exists yet.
+    pub fn open_or_init(config: Config, read_only: bool) -> Result<Self> {
+        if config.temporary {
+            return Self::init(config, false);
+        }
+
+        let root = config.root.clone();
+
+        if let Some(found_root) = find_ontoenv_root_from(&root) {
+            let ontoenv_dir = found_root.join(".ontoenv");
+            if ontoenv_dir.exists() {
+                return Self::load_from_directory(found_root, read_only);
+            }
+        }
+
+        let ontoenv_dir = root.join(".ontoenv");
+        if ontoenv_dir.exists() {
+            return Self::load_from_directory(root, read_only);
+        }
+
+        if read_only {
+            return Err(anyhow::anyhow!(
+                "OntoEnv directory not found at {} and read_only=true",
+                ontoenv_dir.display()
+            ));
+        }
+
+        Self::init(config, false)
+    }
+
     /// Creates a new online OntoEnv that searches for ontologies in the current directory.
     /// If an environment already exists, it will be loaded.
     /// The environment will be persisted to disk in the `.ontoenv` directory.
@@ -1642,3 +1673,36 @@ impl OntoEnv {
         self.config.resolution_policy = policy;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn open_or_init_initializes_when_missing() {
+        let tmp = tempdir().unwrap();
+        let root = tmp.path().join("env");
+        std::fs::create_dir_all(&root).unwrap();
+
+        let config = Config::builder()
+            .root(root.clone())
+            .offline(true)
+            .temporary(false)
+            .no_search(true)
+            .build()
+            .unwrap();
+
+        {
+            let env = OntoEnv::open_or_init(config.clone(), false).unwrap();
+            assert!(root.join(".ontoenv").is_dir());
+            drop(env);
+        }
+
+        {
+            let env = OntoEnv::open_or_init(config, false).unwrap();
+            assert!(root.join(".ontoenv").is_dir());
+            drop(env);
+        }
+    }
+}

lib/tests/test_ontoenv.rs

@@ -44,7 +44,7 @@ macro_rules! setup {
             }
 
             copy_file(&source_path, &dest_path).expect(format!("Failed to copy file from {} to {}", source_path.display(), dest_path.display()).as_str());
-            
+
             // modify the 'last modified' time to the current time.
             // We must open with .write(true) to get permissions
             // to set metadata on Windows.
@@ -53,7 +53,7 @@ macro_rules! setup {
                 .write(true) // Request write access
                 .open(&dest_path)
                 .expect(format!("Failed to open file {} with write perms", dest_path.display()).as_str());
-            
+
             dest_file.set_modified(current_time)
                 .expect(format!("Failed to set modified time for file {}", dest_path.display()).as_str());
         )*

python/example.py

@@ -1,8 +1,9 @@
 from ontoenv import OntoEnv, version
 from rdflib import Graph
-print(version)
 
 
+print(version)
+
 print("Make env")
 env = OntoEnv(search_directories=["../brick"], strict=False, offline=False)
 print(env)
@@ -25,7 +26,7 @@
 print(env2.store_path())
 
 print("get brick again from URL")
-brick = env2.get("https://brickschema.org/schema/1.4/Brick")
+brick = env2.get_graph("https://brickschema.org/schema/1.4/Brick")
 print(len(brick))
 print(brick)
 print(type(brick))
@@ -35,10 +36,9 @@
 env2.import_graph(brick, "https://w3id.org/rec")
 brick.serialize("test.ttl", format="turtle")
 
-print("qudtqk deps", env2.get_dependents('http://qudt.org/2.1/vocab/quantitykind'))
+print("qudtqk deps", env2.get_importers("http://qudt.org/2.1/vocab/quantitykind"))
 
 # get an rdflib.Dataset (https://rdflib.readthedocs.io/en/stable/apidocs/rdflib.html#rdflib.Dataset)
 ds = env2.to_rdflib_dataset()
-for graphname in ds.graphs():
-    graph = ds.graph(graphname)
-    print(f"Graph {graphname} has {len(graph)} triples")
+for graph in list(ds.contexts()):
+    print(f"Graph {graph.identifier} has {len(graph)} triples")

python/src/lib.rs

@@ -9,28 +9,23 @@ use anyhow::Error;
 #[cfg(feature = "cli")]
 use ontoenv_cli;
 use oxigraph::model::{BlankNode, Literal, NamedNode, NamedOrBlankNodeRef, Term};
+#[cfg(not(feature = "cli"))]
+use pyo3::exceptions::PyRuntimeError;
 use pyo3::{
     prelude::*,
     types::{IntoPyDict, PyString, PyTuple},
-    exceptions::PyValueError,
 };
-#[cfg(not(feature = "cli"))]
-use pyo3::exceptions::PyRuntimeError;
 use std::borrow::Borrow;
 use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
 use std::ffi::OsStr;
+use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
 fn anyhow_to_pyerr(e: Error) -> PyErr {
     PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string())
 }
 
 // Helper function to format paths with forward slashes for cross-platform error messages
-fn format_path_for_error(path: &std::path::Path) -> String {
-    path.to_string_lossy().replace('\\', "/")
-}
-
 #[allow(dead_code)]
 struct MyTerm(Term);
 impl From<Result<Bound<'_, PyAny>, pyo3::PyErr>> for MyTerm {
@@ -232,15 +227,6 @@ impl OntoEnv {
         temporary: bool,
         no_search: bool,
     ) -> PyResult<Self> {
-
-        // Check if OntoEnv() is called without any meaningful arguments
-        // This implements the behavior expected by the tests
-        if path.is_none() && root == "." && !recreate && !temporary {
-            // Use forward slashes for cross-platform compatibility in error messages
-            return Err(PyValueError::new_err(
-                "OntoEnv directory not found at \"./.ontoenv\". You must provide a valid path or set recreate=True or temporary=True to create a new OntoEnv.",
-            ));
-        }
         let mut root_path = path.clone().unwrap_or_else(|| PathBuf::from(root));
         // If the provided path points to a '.ontoenv' directory, treat its parent as the root
         if root_path
@@ -284,34 +270,11 @@ impl OntoEnv {
             .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))?;
 
         let env = if cfg.temporary {
-            // Explicit in-memory env
             OntoEnvRs::init(cfg, false).map_err(anyhow_to_pyerr)?
         } else if recreate {
-            // Explicit create/overwrite at root_path
             OntoEnvRs::init(cfg, true).map_err(anyhow_to_pyerr)?
         } else {
-            // Discover upward from root_path; load if found. If not found and not read-only,
-            // initialize a new environment at the requested root.
-            match ::ontoenv::api::find_ontoenv_root_from(&root_path) {
-                Some(found_root) => OntoEnvRs::load_from_directory(found_root, read_only)
-                    .map_err(anyhow_to_pyerr)?,
-                None => {
-                    // If a specific path was provided but no .ontoenv exists, raise error
-                    if path.is_some() {
-                        return Err(PyValueError::new_err(format!(
-                            "OntoEnv directory not found at: \"{}\"",
-                            format_path_for_error(&root_path.join(".ontoenv"))
-                        )));
-                    }
-                    if read_only {
-                        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
-                            "OntoEnv directory not found at: \"{}\" and read_only=True",
-                            format_path_for_error(&root_path.join(".ontoenv"))
-                        )));
-                    }
-                    OntoEnvRs::init(cfg, false).map_err(anyhow_to_pyerr)?
-                }
-            }
+            OntoEnvRs::open_or_init(cfg, read_only).map_err(anyhow_to_pyerr)?
         };
 
         let inner = Arc::new(Mutex::new(Some(env)));

python/tests/test_ontoenv_api.py

@@ -37,9 +37,7 @@ def tearDown(self):
 
     def test_constructor_default(self):
         """Test default OntoEnv() constructor respects git-style discovery."""
-        with self.assertRaises(ValueError):
-            OntoEnv()
-        self.env = OntoEnv(temporary=True)
+        self.env = OntoEnv()
         self.assertIn("OntoEnv", repr(self.env))
 
     def test_constructor_path(self):

python/tests/test_ontoenv_init.py

@@ -2,7 +2,6 @@
 import shutil
 import os
 import tempfile
-import re
 from pathlib import Path
 from ontoenv import OntoEnv
 
@@ -68,25 +67,24 @@ def test_init_read_only(self):
             with self.assertRaisesRegex(ValueError, "Cannot add to read-only store"):
                 env.add("file:///dummy.ttl")
 
-    def test_init_no_config_no_path_error(self):
-        # Clean up potential leftover .ontoenv in cwd just in case
-        if os.path.exists(".ontoenv"):
-            if os.path.isfile(".ontoenv"):
-                os.remove(".ontoenv")
-            else:
-                shutil.rmtree(".ontoenv")
-        with self.assertRaisesRegex(ValueError, "OntoEnv directory not found at \"./.ontoenv\". You must provide a valid path or set recreate=True or temporary=True to create a new OntoEnv."):
-            OntoEnv()  # No args
+    def test_init_no_config_creates_environment(self):
+        original_cwd = Path.cwd()
+        with tempfile.TemporaryDirectory() as td:
+            os.chdir(td)
+            try:
+                env = OntoEnv()  # No args; should auto-create
+                self.assertTrue(Path(".ontoenv").is_dir())
+                env.close()
+            finally:
+                os.chdir(original_cwd)
 
-    def test_init_path_no_env_error(self):
+    def test_init_path_auto_initializes(self):
         with tempfile.TemporaryDirectory() as td:
             env_path = Path(td) / "no_env_here"
             env_path.mkdir()
-            self.assertFalse((env_path / ".ontoenv").exists())
-            # Be tolerant of macOS /private prefix differences by matching only the tail.
-            tail_pattern = rf'OntoEnv directory not found at: "(.*/)?{re.escape(env_path.name)}/\.ontoenv"'
-            with self.assertRaisesRegex(ValueError, tail_pattern):
-                OntoEnv(path=env_path)
+            env = OntoEnv(path=env_path)
+            self.assertTrue((env_path / ".ontoenv").is_dir())
+            env.close()
 
     def test_init_temporary(self):
         with tempfile.TemporaryDirectory() as td: