fix GIL deadlock when setting up a custom embedding function in python (

#1929)

* fix GIL deadlock when setting up a custom embedding function in python

* turn tracing back on for vector operations

* fix docstrings

* add comment with some clarification

* revert change on pometry-sotre-private commit

raphtory-graphql/src/python/server/server.rs

@@ -362,7 +362,11 @@ impl PyGraphServer {
         let mut server = PyRunningGraphServer::new(join_handle, sender, port)?;
         if let Some(_server_handler) = &server.server_handler {
             let url = format!("http://localhost:{port}");
-            match PyRunningGraphServer::wait_for_server_online(&url, timeout_ms) {
+            // we need to release the GIL, otherwise the server will deadlock when trying to use python function as the embedding function
+            // and wait_for_server_online will never return
+            let result =
+                py.allow_threads(|| PyRunningGraphServer::wait_for_server_online(&url, timeout_ms));
+            match result {
                 Ok(_) => return Ok(server),
                 Err(e) => {
                     PyRunningGraphServer::stop_server(&mut server, py)?;

raphtory-graphql/src/server.rs

@@ -176,14 +176,11 @@ impl GraphServer {
 
     /// Start the server on the port `port` and return a handle to it.
     pub async fn start_with_port(self, port: u16) -> IoResult<RunningGraphServer> {
-        self.data.vectorise_all_graphs_that_are_not().await?;
-
-        let work_dir = self.data.work_dir.clone();
+        // set up opentelemetry first of all
         let config = self.config.clone();
         let filter = config.logging.get_log_env();
         let tracer_name = config.tracing.otlp_tracing_service_name.clone();
         let tp = config.tracing.tracer_provider();
-
         // Create the base registry
         let registry = Registry::default().with(filter).with(
             fmt::layer().pretty().with_span_events(FmtSpan::NONE), //(FULL, NEW, ENTER, EXIT, CLOSE)
@@ -202,6 +199,10 @@ impl GraphServer {
                 registry.try_init().ok();
             }
         };
+
+        self.data.vectorise_all_graphs_that_are_not().await?;
+        let work_dir = self.data.work_dir.clone();
+
         // it is important that this runs after algorithms have been pushed to PLUGIN_ALGOS static variable
         let app: CorsEndpoint<CookieJarManagerEndpoint<Route>> = self
             .generate_endpoint(tp.clone().map(|tp| tp.tracer(tracer_name)))
@@ -266,6 +267,7 @@ impl GraphServer {
 }
 
 /// A Raphtory server handler
+#[derive(Debug)]
 pub struct RunningGraphServer {
     signal_sender: Sender<()>,
     server_result: JoinHandle<IoResult<()>>,

raphtory/src/python/packages/vectors.rs

@@ -287,6 +287,18 @@ impl PyVectorisedGraph {
         self.0.empty_selection()
     }
 
+    /// Return all the graph level documents
+    ///
+    /// Returns:
+    ///   list[Document]: list of graph level documents
+    pub fn get_graph_documents(&self, py: Python) -> PyResult<Vec<PyDocument>> {
+        self.0
+            .get_graph_documents()
+            .into_iter()
+            .map(|doc| into_py_document(doc, &self.0, py))
+            .collect()
+    }
+
     /// Search the top scoring documents according to `query` with no more than `limit` documents
     ///
     /// Args:

raphtory/src/vectors/embedding_cache.rs

@@ -10,6 +10,7 @@ use std::{
 
 pub type CacheStore = HashMap<u64, Embedding>;
 
+#[derive(Debug)]
 pub struct EmbeddingCache {
     cache: RwLock<CacheStore>, // TODO: double check that we really need a RwLock !!
     path: PathBuf,

raphtory/src/vectors/template.rs

@@ -157,7 +157,7 @@ impl From<Prop> for Value {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct DocumentTemplate {
     pub graph_template: Option<String>,
     pub node_template: Option<String>,

raphtory/src/vectors/vectorised_graph.rs

@@ -21,6 +21,7 @@ use super::{
     similarity_search_utils::score_document_groups_by_highest,
     vector_selection::VectorSelection,
     vectorisable::{vectorise_edge, vectorise_graph, vectorise_node},
+    Document,
 };
 
 pub struct VectorisedGraph<G: StaticGraphViewOps> {
@@ -151,6 +152,15 @@ impl<G: StaticGraphViewOps> VectorisedGraph<G> {
         VectorSelection::new(self.clone())
     }
 
+    /// Return all the graph level documents
+    pub fn get_graph_documents(&self) -> Vec<Document> {
+        self.graph_documents
+            .read()
+            .iter()
+            .map(|doc| doc.regenerate(&self.source_graph, &self.template))
+            .collect_vec()
+    }
+
     /// Search the top scoring documents according to `query` with no more than `limit` documents
     ///
     /// # Arguments