added debug option to methods that work via queries

Author: proycon

src/annotation.rs

@@ -960,6 +960,7 @@ impl PyAnnotations {
     where
         F: FnOnce(Query, &AnnotationStore) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|annotations, store| {
             let query = Query::new(QueryType::Select, Some(Type::Annotation), Some("main"))
                 .with_constraint(Constraint::Annotations(
@@ -979,6 +980,9 @@ impl PyAnnotations {
                         StamError::QuerySyntaxError(format!("{}", e), "(python to query)")
                     })?,
                 );
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(query, store)
         })
     }
@@ -1070,6 +1074,7 @@ impl PyAnnotation {
     where
         F: FnOnce(ResultItem<Annotation>, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|annotation| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -1080,6 +1085,9 @@ impl PyAnnotation {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_annotationvar("main", &annotation);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(annotation, query)
         })
     }

src/annotationdata.rs

@@ -191,6 +191,7 @@ impl PyDataKey {
     where
         F: FnOnce(ResultItem<DataKey>, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|key| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -201,6 +202,9 @@ impl PyDataKey {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_keyvar("main", &key);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(key, query)
         })
     }
@@ -537,6 +541,7 @@ impl PyAnnotationData {
     where
         F: FnOnce(ResultItem<AnnotationData>, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|data| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -547,6 +552,9 @@ impl PyAnnotationData {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_datavar("main", &data);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(data, query)
         })
     }

src/annotationdataset.rs

@@ -297,6 +297,7 @@ impl PyAnnotationDataSet {
     where
         F: FnOnce(ResultItem<AnnotationDataSet>, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|dataset| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -307,6 +308,9 @@ impl PyAnnotationDataSet {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_datasetvar("main", &dataset);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(dataset, query)
         })
     }

src/annotationstore.rs

@@ -739,6 +739,7 @@ impl PyAnnotationStore {
     where
         F: FnOnce(Query, &AnnotationStore) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map_store(|store| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), None),
@@ -747,6 +748,9 @@ impl PyAnnotationStore {
                 store,
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?;
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(query, store)
         })
     }

src/query.rs

@@ -421,6 +421,17 @@ pub(crate) fn get_limit(kwargs: Option<&PyDict>) -> Option<usize> {
     None
 }
 
+pub(crate) fn get_debug(kwargs: Option<&PyDict>) -> bool {
+    if let Some(kwargs) = kwargs {
+        if let Ok(Some(debug)) = kwargs.get_item("debug") {
+            if let Ok(debug) = debug.extract::<bool>() {
+                return debug;
+            }
+        }
+    }
+    false
+}
+
 pub(crate) fn get_substore(kwargs: Option<&PyDict>) -> Option<bool> {
     if let Some(kwargs) = kwargs {
         if let Ok(Some(substore)) = kwargs.get_item("substore") {

src/resources.rs

@@ -588,6 +588,7 @@ impl PyTextResource {
     where
         F: FnOnce(ResultItem<TextResource>, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|resource| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -598,6 +599,9 @@ impl PyTextResource {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_resourcevar("main", &resource);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(resource, query)
         })
     }

src/textselection.rs

@@ -607,6 +607,7 @@ impl PyTextSelection {
     where
         F: FnOnce(ResultTextSelection, Query) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|textselection| {
             let query = build_query(
                 Query::new(QueryType::Select, Some(resulttype), Some("result"))
@@ -617,6 +618,9 @@ impl PyTextSelection {
             )
             .map_err(|e| StamError::QuerySyntaxError(format!("{}", e), "(python to query)"))?
             .with_textvar("main", &textselection);
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(textselection, query)
         })
     }
@@ -952,6 +956,7 @@ impl PyTextSelections {
     where
         F: FnOnce(Query, &AnnotationStore) -> Result<T, StamError>,
     {
+        let debug = get_debug(kwargs);
         self.map(|textselections, store| {
             let query = Query::new(QueryType::Select, Some(Type::Annotation), Some("main"))
                 .with_constraint(Constraint::TextSelections(
@@ -970,6 +975,9 @@ impl PyTextSelections {
                         StamError::QuerySyntaxError(format!("{}", e), "(python to query)")
                     })?,
                 );
+            if debug {
+                eprintln!("[STAM DEBUG]: {}", query.to_string()?);
+            }
             f(query, store)
         })
     }