update python init logic

Author: gtfierro

python/pyproject.toml

@@ -18,4 +18,9 @@ features = ["pyo3/extension-module"]
 
 [build-system]
 requires = ["maturin>=1.5,<2.0"]
-build-backend = "maturin"
+build-backend = "maturin"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+]

python/src/lib.rs

@@ -189,25 +189,23 @@ impl OntoEnv {
             env_logger::init();
         });
 
-        let config_path = path;
-
-        let env = if config.is_none() && config_path.as_ref().map_or(false, |p| p.exists()) {
+        let config_path = path.unwrap_or_else(|| PathBuf::from("."));
+        let env =  if let Some(c) = config {
+            // if temporary is true, create a new OntoEnv
+            if c.cfg.temporary {
+                OntoEnvRs::init(c.cfg, recreate).map_err(anyhow_to_pyerr)
+            } else if !recreate {
+                // if temporary is false, load from the directory
+                OntoEnvRs::load_from_directory(config_path, read_only)
+                    .map_err(anyhow_to_pyerr)
+            } else {
+                // if temporary is false and recreate is true, create a new OntoEnv
+                OntoEnvRs::init(c.cfg, recreate).map_err(anyhow_to_pyerr)
+            }
+        } else {
             // If no config but a valid path is given, attempt to load from the directory
-            OntoEnvRs::load_from_directory(config_path.as_ref().unwrap().clone(), read_only)
+            OntoEnvRs::load_from_directory(config_path, read_only)
                 .map_err(anyhow_to_pyerr)
-        } else if !recreate {
-            // if recreate is 'false', try to load from the directory
-            OntoEnvRs::load_from_directory(config_path.as_ref().unwrap().clone(), read_only)
-                .map_err(anyhow_to_pyerr)
-        } else if let Some(c) = config {
-            // If a config is provided, initialize a new OntoEnv. 'recreate' will be true here
-            // (else it would have been loaded from the directory in the previous step)
-            OntoEnvRs::init(c.cfg, recreate).map_err(anyhow_to_pyerr)
-        } else {
-            // Return an error if neither a valid path nor a config is provided
-            Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
-                "Either a Config or a valid path must be provided.",
-            ))
         }?;
 
         let inner = Arc::new(Mutex::new(env));

python/tests/test_ontoenv.py

@@ -5,13 +5,15 @@
 import shutil
 import os
 
+
 # Fixture to create a temporary directory for each test
 @pytest.fixture
 def temp_dir(tmp_path):
     """Provides a temporary directory path for tests."""
     yield tmp_path
     # Cleanup happens automatically via pytest's tmp_path fixture
 
+
 # Fixture to create a temporary directory with a pre-initialized OntoEnv
 @pytest.fixture
 def existing_env_dir(tmp_path):
@@ -23,11 +25,12 @@ def existing_env_dir(tmp_path):
     env = OntoEnv(config=cfg, path=env_path, recreate=True)
     # Add a dummy file to ensure the env is not empty if needed later
     # For now, just initializing is enough to create the .ontoenv structure
-    env.flush() # Ensure data is written if not temporary
+    env.flush()  # Ensure data is written if not temporary
     del env
     yield env_path
     # Cleanup happens automatically via pytest's tmp_path fixture
 
+
 def test_init_with_config_new_dir(temp_dir):
     """Test initializing OntoEnv with a Config in a new directory."""
     env_path = temp_dir / "new_env"
@@ -36,7 +39,10 @@ def test_init_with_config_new_dir(temp_dir):
     cfg = Config(root=str(env_path), temporary=False)
     env = OntoEnv(config=cfg, path=env_path, recreate=True)
     assert (env_path / ".ontoenv").is_dir()
-    assert env.store_path() is not None # Assuming store_path handles non-temporary envs
+    assert (
+        env.store_path() is not None
+    )  # Assuming store_path handles non-temporary envs
+
 
 def test_init_with_config_existing_empty_dir(temp_dir):
     """Test initializing OntoEnv with a Config in an existing empty directory."""
@@ -48,6 +54,7 @@ def test_init_with_config_existing_empty_dir(temp_dir):
     assert (env_path / ".ontoenv").is_dir()
     assert env.store_path() is not None
 
+
 def test_init_load_from_existing_dir(existing_env_dir):
     """Test initializing OntoEnv by loading from an existing directory."""
     assert (existing_env_dir / ".ontoenv").is_dir()
@@ -57,6 +64,7 @@ def test_init_load_from_existing_dir(existing_env_dir):
     assert env.store_path() == str(existing_env_dir / ".ontoenv" / "store.db")
     # Add more checks if the fixture pre-populates data
 
+
 def test_init_recreate_existing_dir(existing_env_dir):
     """Test initializing OntoEnv with recreate=True on an existing directory."""
     assert (existing_env_dir / ".ontoenv").is_dir()
@@ -73,6 +81,7 @@ def test_init_recreate_existing_dir(existing_env_dir):
     assert not (existing_env_dir / ".ontoenv" / "dummy.txt").exists()
     assert len(env.get_ontology_names()) == 0
 
+
 # Note: This test assumes add() raises an error for read-only mode.
 # The Rust ReadOnlyPersistentGraphIO::add returns Err, which should map to PyErr.
 def test_init_read_only(existing_env_dir):
@@ -82,39 +91,43 @@ def test_init_read_only(existing_env_dir):
 
     # Attempting to modify should fail
     with pytest.raises(ValueError, match="Cannot add to read-only store"):
-         # Use a dummy file path or URL
+        # Use a dummy file path or URL
         env.add("file:///dummy.ttl")
 
+
 def test_init_no_config_no_path_error():
     """Test initializing OntoEnv without config or valid path fails."""
     # Assuming current dir '.' does not contain a valid .ontoenv
     # 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")
+        if os.path.isfile(".ontoenv"):
+            os.remove(".ontoenv")
+        else:
+            shutil.rmtree(".ontoenv")
 
     # Expecting failure because '.' likely doesn't contain a valid .ontoenv
-    with pytest.raises(ValueError, match="OntoEnv directory not found at ."):
-        OntoEnv() # No args
+    with pytest.raises(ValueError, match="OntoEnv directory not found at: \"./.ontoenv\""):
+        OntoEnv()  # No args
+
 
 def test_init_path_no_env_error(temp_dir):
     """Test initializing OntoEnv with a path to a dir without .ontoenv fails."""
     env_path = temp_dir / "no_env_here"
     env_path.mkdir()
     assert not (env_path / ".ontoenv").exists()
     # Expecting failure because the specified path doesn't contain a .ontoenv dir
-    with pytest.raises(ValueError, match=f"OntoEnv directory not found at {env_path}"):
+    absolute_path = (env_path / ".ontoenv").resolve()
+    with pytest.raises(ValueError, match=f"OntoEnv directory not found at: \"{absolute_path}\""):
         # This fails because load_from_directory expects .ontoenv unless recreate=True
-         OntoEnv(path=env_path)
+        OntoEnv(path=env_path)
+
 
 def test_init_temporary(temp_dir):
     """Test initializing OntoEnv with temporary=True."""
     env_path = temp_dir / "temp_env_root"
     # temporary envs don't persist to disk relative to root
     cfg = Config(root=str(env_path), temporary=True, strict=False)
-    env = OntoEnv(config=cfg) # Path shouldn't matter for temporary
+    env = OntoEnv(config=cfg)  # Path shouldn't matter for temporary
 
     # .ontoenv directory should NOT be created at the root
     assert not (env_path / ".ontoenv").exists()
@@ -137,4 +150,5 @@ def test_init_temporary(temp_dir):
         # Catch other potential errors (like network) during add
         pass
 
+
 # TODO: Add tests for offline mode, different resolution policies, includes/excludes etc.