make sure to load store when loading environment from file. Add get_dependents method

Author: gtfierro

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.1.10-a8"
+version = "0.1.10-a9"
 authors = ["Gabe Fierro <[email protected]>"]
 license = "BSD-3-Clause"
 edition = "2021"
@@ -35,7 +35,7 @@ clap = { version = "4.4.18", features = ["derive"] }
 derive_builder = "0.20"
 oxigraph = "0.4.4"
 
-ontoenv = { version = "0.1.10-a8", path = "lib" }
+ontoenv = { version = "0.1.10-a9", path = "lib" }
 
 [profile.profiling]
 inherits = "release"

Cargo.toml

@@ -108,6 +108,11 @@ enum Commands {
         #[clap(long, short)]
         output: Option<String>,
     },
+    /// Lists all ontologies which depend on the given ontology
+    Dependents {
+        /// The name (URI) of the ontology to find dependents for
+        ontologies: Vec<String>,
+    },
     /// Run the doctor to check the environment for issues
     Doctor,
     /// Reset the ontology environment by removing the .ontoenv directory
@@ -294,6 +299,19 @@ fn main() -> Result<()> {
                 ));
             }
         }
+        Commands::Dependents { ontologies } => {
+            // load env from .ontoenv/ontoenv.json
+            let path = current_dir()?.join(".ontoenv/ontoenv.json");
+            let env = OntoEnv::from_file(&path, true)?;
+            for ont in ontologies {
+                let iri = NamedNode::new(ont).map_err(|e| anyhow::anyhow!(e.to_string()))?;
+                let dependents = env.get_dependents(&iri)?;
+                println!("Dependents of {}: ", iri);
+                for dep in dependents {
+                    println!("{}", dep);
+                }
+            }
+        }
         Commands::Doctor => {
             // load env from .ontoenv/ontoenv.json
             let path = current_dir()?.join(".ontoenv/ontoenv.json");

cli/src/main.rs

@@ -201,7 +201,7 @@ impl OntoEnv {
             how_created,
             inner_store: None,
         };
-        env.inner_store = Some(env.get_store()?);
+        env.inner_store = Some(env.get_store(env.read_only)?);
         Ok(env)
     }
 
@@ -215,10 +215,10 @@ impl OntoEnv {
     }
 
     // TODO: add a read-only version? make this thread-safe?
-    fn get_store(&self) -> Result<Store> {
+    fn get_store(&self, read_only: bool) -> Result<Store> {
         let ontoenv_dir = self.config.root.join(".ontoenv");
         std::fs::create_dir_all(&ontoenv_dir)?;
-        if self.read_only {
+        if read_only {
             return Store::open_read_only(ontoenv_dir.join("store.db"))
                 .map_err(|e| anyhow::anyhow!("Could not open store: {}", e));
         }
@@ -330,7 +330,8 @@ impl OntoEnv {
 
         let file = std::fs::File::open(path)?;
         let reader = BufReader::new(file);
-        let env: OntoEnv = serde_json::from_reader(reader)?;
+        let mut env: OntoEnv = serde_json::from_reader(reader)?;
+        env.inner_store = Some(env.get_store(read_only)?);
         Ok(Self { read_only, ..env })
     }
 
@@ -961,6 +962,17 @@ impl OntoEnv {
         }
     }
 
+    /// Returns a list of all ontologies that depend on the given ontology
+    pub fn get_dependents(&self, id: &NamedNode) -> Result<Vec<GraphIdentifier>> {
+        let mut dependents = vec![];
+        for ontology in self.ontologies.values() {
+            if ontology.imports.contains(&id) {
+                dependents.push(ontology.id().clone());
+            }
+        }
+        Ok(dependents)
+    }
+
     /// Outputs a human-readable dump of the environment, including all ontologies
     /// and their metadata and imports
     pub fn dump(&self, contains: Option<&str>) {

lib/src/lib.rs

@@ -18,7 +18,7 @@ features = ["pyo3/extension-module"]
 
 [tool.poetry]
 name = "ontoenv"
-version = "0.1.10a8"
+version = "0.1.10a9"
 description = "Python bindings for the OntoEnv Rust library. Manages ontology-based environments for building knowledge graphs."
 license = "bsd-3-clause"
 authors = ["Gabe Fierro <[email protected]>"]

python/pyproject.toml

@@ -401,6 +401,7 @@ impl OntoEnv {
 
     /// Import the dependencies of the given graph into the graph. Removes the owl:imports
     /// of all imported ontologies.
+    #[pyo3(signature = (graph))]
     fn import_dependencies<'a>(
         &self,
         py: Python<'a>,
@@ -443,6 +444,19 @@ impl OntoEnv {
         Ok(())
     }
 
+    /// Get the names of all ontologies that depend on the given ontology
+    fn get_dependents(&self, uri: &str) -> PyResult<Vec<String>> {
+        let iri = NamedNode::new(uri)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))?;
+        let inner = self.inner.clone();
+        let env = inner.lock().unwrap();
+        let dependents = env
+            .get_dependents(&iri)
+            .map_err(anyhow_to_pyerr)?;
+        let names: Vec<String> = dependents.iter().map(|ont| ont.name().to_string()).collect();
+        Ok(names)
+    }
+
     /// Export the graph with the given URI to an rdflib.Graph
     fn get_graph(&self, py: Python, uri: &Bound<'_, PyString>) -> PyResult<Py<PyAny>> {
         let rdflib = py.import("rdflib")?;

python/src/lib.rs

@@ -33,6 +33,8 @@
 env2.import_graph(brick, "https://w3id.org/rec")
 brick.serialize("test.ttl", format="turtle")
 
+print(env2.get_dependents('https://brickschema.org/schema/1.4-rc1/Brick'))
+
 # 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():