maplib 0.18.13__tar.gz → 0.18.18__tar.gz

{maplib-0.18.13 → maplib-0.18.18}/Cargo.lock

@@ -1478,12 +1478,6 @@ dependencies = [
  "libmimalloc-sys",
 ]
 
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -1526,16 +1520,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
 [[package]]
 name = "now"
 version = "0.1.3"
@@ -2467,10 +2451,11 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.18.13"
+version = "0.18.18"
 dependencies = [
  "chrono",
  "cimxml",
+ "datalog",
  "maplib",
  "mimalloc",
  "oxrdf",
@@ -3529,13 +3514,15 @@ checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
 name = "templates"
 version = "0.1.0"
 dependencies = [
- "nom",
+ "oxilangtag",
+ "oxiri",
  "oxrdf",
+ "peg",
  "pyo3",
  "representation",
+ "spargebra",
  "thiserror",
  "tracing",
- "unic-char-range",
  "walkdir",
 ]
 
@@ -3842,12 +3829,6 @@ version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
-[[package]]
-name = "unic-char-range"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.19"

{maplib-0.18.13 → maplib-0.18.18}/Cargo.toml

@@ -8,7 +8,7 @@ rust-version = "1.88.0"
 [workspace.dependencies]
 pyo3 = {version = "0.25", features = ["py-clone"] }
 #Moment is there to work around a feature toggle bug
-polars = { version = "0.52.0", features = ["simd", "nightly", "new_streaming", "performant", "cse", "fmt", "parquet", "moment"] }
+polars = { version = "0.52.0", features = ["simd", "nightly", "new_streaming", "performant", "cse", "fmt", "parquet", "moment", "timezones"] }
 polars-core = { version = "0.52.0" }
 rayon = "1.10.0"
 regex = "1.11.1"
@@ -25,7 +25,6 @@ uuid = { version = "1.16.0", features = [
     "fast-rng", # Use a faster (but still sufficiently random) RNG
 ] }
 thiserror = "2.0.12"
-nom = { version = "7.1.3" }
 peg = "0.8"
 rand = "0.9.1"
 oxilangtag = "0.1.5"

{maplib-0.18.13 → maplib-0.18.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maplib
-Version: 0.18.13
+Version: 0.18.18
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only

{maplib-0.18.13 → maplib-0.18.18}/lib/datalog/src/inference.rs

@@ -1,8 +1,5 @@
 use crate::ast::DatalogRuleset;
-use oxrdf::NamedNode;
 use representation::dataset::NamedGraph;
-use representation::solution_mapping::EagerSolutionMappings;
-use std::collections::HashMap;
 use thiserror::*;
 use triplestore::sparql::errors::SparqlError;
 use triplestore::Triplestore;
@@ -13,6 +10,10 @@ pub enum DatalogError {
     SparqlError(SparqlError),
 }
 
+#[derive(Clone)]
+pub struct InferenceResult {
+}
+
 pub fn infer(
     _triplestore: &mut Triplestore,
     _graph: Option<&NamedGraph>,
@@ -21,6 +22,7 @@ pub fn infer(
     _max_results: Option<usize>,
     _include_transient: bool,
     _max_rows: Option<usize>,
-) -> Result<Option<HashMap<NamedNode, EagerSolutionMappings>>, DatalogError> {
+    _debug_no_results: bool,
+) -> Result<InferenceResult, DatalogError> {
     unimplemented!("Contact data treehouse to try")
 }

{maplib-0.18.13 → maplib-0.18.18}/lib/datalog/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod ast;
 pub mod inference;
 pub mod parser;
+pub mod python;

{maplib-0.18.13 → maplib-0.18.18}/lib/datalog/src/parser.rs

@@ -1,9 +1,12 @@
+use std::collections::HashMap;
+use oxrdf::NamedNode;
 use crate::ast::DatalogRuleset;
 use thiserror::*;
 
 pub fn parse_datalog_ruleset(
     _datalog_ruleset: &str,
     _base_iri: Option<&str>,
+    _prefixes: Option<&HashMap<String, NamedNode>>,
 ) -> Result<DatalogRuleset, DatalogSyntaxError> {
     unimplemented!("Contact Data Treehouse to try")
 }

maplib-0.18.18/lib/datalog/src/python.rs

@@ -0,0 +1,19 @@
+use pyo3::{pyclass, pymethods, PyResult};
+use crate::inference::InferenceResult;
+
+#[derive(Clone)]
+#[pyclass(name = "InferenceResult")]
+pub struct PyInferenceResult {
+   pub inner: InferenceResult,
+}
+
+#[pymethods]
+impl PyInferenceResult {
+   fn __repr__(&self) -> PyResult<String> {
+      Ok("Contact Data Treehouse to try".to_string())
+   }
+
+   fn __str__(&self) -> PyResult<String> {
+      Ok("Contact Data Treehouse to try".to_string())
+   }
+}

{maplib-0.18.13 → maplib-0.18.18}/lib/fts/src/lib.rs

@@ -14,7 +14,7 @@ pub enum FtsError {}
 pub struct FtsIndex {}
 
 impl FtsIndex {
-    pub fn new(_path: &Path, uuid:&str) -> Result<FtsIndex, FtsError> {
+    pub fn new(_path: &Path, _uuid:&str) -> Result<FtsIndex, FtsError> {
         unimplemented!("Contact Data Treehouse to enable full text search")
     }
 

{maplib-0.18.13 → maplib-0.18.18}/lib/maplib/src/errors.rs

@@ -1,4 +1,4 @@
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use cimxml::export::CIMXMLError;
 use datalog::inference::DatalogError;
 use oxiri::IriParseError;

{maplib-0.18.13 → maplib-0.18.18}/lib/maplib/src/lib.rs

@@ -2,4 +2,5 @@ extern crate chrono;
 extern crate chrono_tz;
 
 pub mod errors;
-pub mod mapping;
+pub mod model;
+mod prefixes;

{maplib-0.18.13/lib/maplib/src/mapping → maplib-0.18.18/lib/maplib/src/model}/constant_terms.rs

@@ -1,5 +1,5 @@
-use crate::mapping::errors::MappingError;
-use crate::mapping::{MappingColumnType, RDFNodeState};
+use crate::model::errors::MappingError;
+use crate::model::{MappingColumnType, RDFNodeState};
 use templates::ast::{ConstantTerm, ConstantTermOrList, PType};
 
 use oxrdf::{NamedNode, Term};

{maplib-0.18.13/lib/maplib/src/mapping → maplib-0.18.18/lib/maplib/src/model}/default.rs

@@ -1,6 +1,6 @@
 use super::Model;
-use crate::mapping::errors::MappingError;
-use crate::mapping::MapOptions;
+use crate::model::errors::MappingError;
+use crate::model::MapOptions;
 use std::collections::HashMap;
 use templates::ast::{
     Argument, ConstantTerm, ConstantTermOrList, Instance, ListExpanderType, PType, Parameter,
@@ -10,7 +10,7 @@ use templates::constants::{DEFAULT_PREFIX, OTTR_IRI, OTTR_TRIPLE};
 use tracing::warn;
 
 use crate::errors::MaplibError;
-use crate::mapping::expansion::validation::infer_type_from_column;
+use crate::model::expansion::validation::infer_type_from_column;
 use oxrdf::{NamedNode, Variable};
 use polars::prelude::{col, DataFrame, DataType, IntoLazy};
 use templates::MappingColumnType;
@@ -111,8 +111,7 @@ impl Model {
 
                 patterns.push(Instance {
                     list_expander: list_expander.clone(),
-                    template_name: NamedNode::new_unchecked(OTTR_TRIPLE),
-                    prefixed_template_name: Some("ottr:Triple".to_string()),
+                    template_iri: NamedNode::new_unchecked(OTTR_TRIPLE),
                     argument_list: vec![
                         Argument {
                             list_expand: false,
@@ -143,8 +142,7 @@ impl Model {
         self.default_template_counter += 1;
         let template = Template {
             signature: Signature {
-                template_name: NamedNode::new(template_name.clone()).unwrap(),
-                template_prefixed_name: None,
+                iri: NamedNode::new(template_name.clone()).unwrap(),
                 parameter_list: params,
                 annotation_list: None,
             },

{maplib-0.18.13/lib/maplib/src/mapping → maplib-0.18.18/lib/maplib/src/model}/errors.rs

@@ -133,7 +133,7 @@ impl Display for MappingError {
                 write!(f, "Template error: {x}")
             }
             MappingError::TriplestoreError(x) => {
-                write!(f, "Error storing mapping results in triplestore: {x}")
+                write!(f, "Error storing model results in triplestore: {x}")
             }
             MappingError::IriParseError(x) => {
                 write!(f, "IRI parse error: {x}")

{maplib-0.18.13/lib/maplib/src/mapping → maplib-0.18.18/lib/maplib/src/model}/expansion/validation.rs

@@ -1,4 +1,4 @@
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use oxiri::Iri;
 use oxrdf::vocab::{rdfs, xsd};
 use oxrdf::NamedNode;

{maplib-0.18.13/lib/maplib/src/mapping → maplib-0.18.18/lib/maplib/src/model}/expansion.rs

@@ -2,9 +2,9 @@ pub mod validation;
 
 use super::{MapOptions, Model, OTTRTripleInstance, StaticColumn};
 use crate::errors::MaplibError;
-use crate::mapping::constant_terms::{constant_blank_node_to_series, constant_to_expr};
-use crate::mapping::errors::MappingError;
-use crate::mapping::expansion::validation::validate;
+use crate::model::constant_terms::{constant_blank_node_to_series, constant_to_expr};
+use crate::model::errors::MappingError;
+use crate::model::expansion::validation::validate;
 use oxrdf::vocab::rdf;
 use oxrdf::{NamedNode, Variable};
 use polars::prelude::{
@@ -22,8 +22,7 @@ use std::collections::{HashMap, HashSet};
 use std::ops::Sub;
 use std::time::Instant;
 use templates::ast::{
-    ConstantTerm, ConstantTermOrList, DefaultValue, Instance, ListExpanderType, PType, Signature,
-    StottrTerm,
+    ConstantTerm, ConstantTermOrList, Instance, ListExpanderType, PType, Signature, StottrTerm,
 };
 use templates::constants::OTTR_TRIPLE;
 use templates::MappingColumnType;
@@ -69,7 +68,7 @@ impl Model {
         let now = Instant::now();
 
         let target_template = self.resolve_template(template)?.clone();
-        let target_template_name = target_template.signature.template_name.as_str().to_string();
+        let target_template_name = target_template.signature.iri.as_str().to_string();
         let MapOptions {
             graph,
             validate_iris,
@@ -130,7 +129,7 @@ impl Model {
             ));
         }
         if let Some(template) = self.template_dataset.get(name) {
-            if template.signature.template_name.as_str() == OTTR_TRIPLE {
+            if template.signature.iri.as_str() == OTTR_TRIPLE {
                 if let Some(df) = df {
                     Ok((
                         vec![OTTRTripleInstance {
@@ -173,12 +172,12 @@ impl Model {
                     .enumerate()
                     .map(|(i, (instance, series_vec))| {
                         let target_template = if let Some(target_template) =
-                            self.template_dataset.get(instance.template_name.as_str())
+                            self.template_dataset.get(instance.template_iri.as_str())
                         {
                             target_template
                         } else {
                             return Err(MappingError::TemplateNotFound(
-                                instance.template_name.to_string(),
+                                instance.template_iri.to_string(),
                             ));
                         };
                         if let Some(RemapResult {
@@ -202,7 +201,7 @@ impl Model {
                                 layer + 1,
                                 i,
                                 blank_node_counter,
-                                instance.template_name.as_str(),
+                                instance.template_iri.as_str(),
                                 Some(instance_df),
                                 &target_template.signature,
                                 instance_dynamic_columns,
@@ -327,9 +326,9 @@ fn fill_nulls_with_defaults(
     mut lf: LazyFrame,
     current_types: &mut HashMap<String, MappingColumnType>,
     c: &str,
-    default: &DefaultValue,
+    default: &ConstantTermOrList,
 ) -> Result<LazyFrame, MappingError> {
-    if default.constant_term.has_blank_node() {
+    if default.has_blank_node() {
         let df = lf.collect().unwrap();
         if df.column(c).unwrap().is_null().any() {
             todo!();
@@ -337,7 +336,7 @@ fn fill_nulls_with_defaults(
             return Ok(df.lazy());
         }
     }
-    let (expr, _, mct) = constant_to_expr(&default.constant_term, &None)?;
+    let (expr, _, mct) = constant_to_expr(&default, &None)?;
     let is_none = if let MappingColumnType::Flat(inner) = current_types.get(c).unwrap() {
         inner.is_none()
     } else {
@@ -835,13 +834,13 @@ fn create_remapped(
 fn add_default_value(
     static_columns: &mut HashMap<String, StaticColumn>,
     name: &str,
-    default: &DefaultValue,
+    default: &ConstantTermOrList,
 ) {
     static_columns.insert(
         name.to_string(),
         StaticColumn {
-            constant_term: default.constant_term.clone(),
-            ptype: Some(default.constant_term.ptype()),
+            constant_term: default.clone(),
+            ptype: Some(default.ptype()),
         },
     );
 }

maplib-0.18.13/lib/maplib/src/mapping.rs → maplib-0.18.18/lib/maplib/src/model.rs

@@ -4,9 +4,9 @@ pub mod errors;
 pub mod expansion;
 
 use crate::errors::MaplibError;
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use cimxml::export::{cim_xml_write, FullModelDetails};
-use datalog::inference::infer;
+use datalog::inference::{infer, InferenceResult};
 use datalog::parser::parse_datalog_ruleset;
 use oxrdf::NamedNode;
 use oxrdfio::RdfFormat;
@@ -22,9 +22,10 @@ use templates::dataset::TemplateDataset;
 use templates::document::document_from_str;
 use templates::MappingColumnType;
 use triplestore::sparql::errors::SparqlError;
-use triplestore::sparql::{QueryResult, QuerySettings};
+use triplestore::sparql::{QueryResult, QuerySettings, UpdateResult};
 use triplestore::{IndexingOptions, NewTriples, Triplestore};
 
+use crate::prefixes::get_default_prefixes;
 use datalog::ast::DatalogRuleset;
 use representation::dataset::NamedGraph;
 use tracing::instrument;
@@ -35,6 +36,7 @@ pub struct Model {
     pub blank_node_counter: usize,
     pub default_template_counter: usize,
     pub indexing: IndexingOptions,
+    pub prefixes: HashMap<String, NamedNode>,
 }
 
 #[derive(Clone, Default)]
@@ -70,6 +72,7 @@ impl Model {
         template_dataset: Option<&TemplateDataset>,
         storage_folder: Option<String>,
         indexing: Option<IndexingOptions>,
+        prefixes: Option<HashMap<String, NamedNode>>,
     ) -> Result<Model, MaplibError> {
         let use_disk = storage_folder.is_some();
         let indexing = if use_disk {
@@ -86,6 +89,10 @@ impl Model {
         } else {
             TemplateDataset::new_empty()?
         };
+        let mut use_prefixes = get_default_prefixes();
+        if let Some(prefixes) = prefixes {
+            use_prefixes.extend(prefixes)
+        };
         Ok(Model {
             template_dataset,
             triplestore: Triplestore::new(storage_folder, Some(indexing.clone()))
@@ -93,6 +100,7 @@ impl Model {
             blank_node_counter: 0,
             default_template_counter: 0,
             indexing,
+            prefixes: use_prefixes,
         })
     }
 
@@ -101,34 +109,35 @@ impl Model {
         recursive: bool,
         storage_folder: Option<String>,
     ) -> Result<Model, MaplibError> {
-        let dataset =
-            TemplateDataset::from_folder(path, recursive).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        let dataset = TemplateDataset::from_folder(path, recursive, Some(&get_default_prefixes()))
+            .map_err(MaplibError::TemplateError)?;
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_file<P: AsRef<Path>>(
         path: P,
         storage_folder: Option<String>,
     ) -> Result<Model, MaplibError> {
-        let dataset = TemplateDataset::from_file(path).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        let dataset = TemplateDataset::from_file(path, Some(&get_default_prefixes()))
+            .map_err(MaplibError::TemplateError)?;
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_str(s: &str, storage_folder: Option<String>) -> Result<Model, MaplibError> {
-        let doc = document_from_str(s)?;
+        let doc = document_from_str(s, Some(&get_default_prefixes()))?;
         let dataset =
             TemplateDataset::from_documents(vec![doc]).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_strs(ss: Vec<&str>, storage_folder: Option<String>) -> Result<Model, MaplibError> {
         let mut docs = vec![];
         for s in ss {
-            let doc = document_from_str(s)?;
+            let doc = document_from_str(s, Some(&get_default_prefixes()))?;
             docs.push(doc);
         }
         let dataset = TemplateDataset::from_documents(docs).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn add_template(&mut self, template: Template) -> Result<(), MaplibError> {
@@ -140,19 +149,11 @@ impl Model {
 
     #[instrument(skip_all)]
     pub fn add_templates_from_string(&mut self, s: &str) -> Result<Option<NamedNode>, MaplibError> {
-        let doc = document_from_str(s).map_err(MaplibError::TemplateError)?;
+        let doc = document_from_str(s, Some(&self.prefixes)).map_err(MaplibError::TemplateError)?;
         let mut dataset =
             TemplateDataset::from_documents(vec![doc]).map_err(MaplibError::TemplateError)?;
         let return_template_iri = if !dataset.templates.is_empty() {
-            Some(
-                dataset
-                    .templates
-                    .first()
-                    .unwrap()
-                    .signature
-                    .template_name
-                    .clone(),
-            )
+            Some(dataset.templates.first().unwrap().signature.iri.clone())
         } else {
             None
         };
@@ -187,6 +188,19 @@ impl Model {
             .map_err(MaplibError::TriplestoreError)
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn read_template(&mut self, p: &Path) -> Result<(), MaplibError> {
+        let mut dataset = TemplateDataset::from_file(p, Some(&self.prefixes))
+            .map_err(MaplibError::TemplateError)?;
+        self.template_dataset
+            .prefix_map
+            .extend(dataset.prefix_map.drain());
+        for t in dataset.templates {
+            self.add_template(t)?
+        }
+        Ok(())
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn reads(
         &mut self,
@@ -216,6 +230,7 @@ impl Model {
         streaming: bool,
         include_transient: bool,
         max_rows: Option<usize>,
+        debug_no_results: bool,
     ) -> Result<QueryResult, MaplibError> {
         let query_settings = QuerySettings {
             include_transient,
@@ -223,7 +238,15 @@ impl Model {
             strict_project: false,
         };
         self.triplestore
-            .query(query, parameters, streaming, &query_settings, graph)
+            .query(
+                query,
+                parameters,
+                streaming,
+                &query_settings,
+                graph,
+                Some(&self.prefixes),
+                debug_no_results,
+            )
             .map_err(|x| x.into())
     }
 
@@ -235,14 +258,23 @@ impl Model {
         streaming: bool,
         include_transient: bool,
         max_rows: Option<usize>,
-    ) -> Result<(), MaplibError> {
+        debug_no_results: bool,
+    ) -> Result<UpdateResult, MaplibError> {
         let query_settings = QuerySettings {
             include_transient,
             max_rows,
             strict_project: false,
         };
         self.triplestore
-            .update(update, parameters, streaming, &query_settings, graph)
+            .update(
+                update,
+                parameters,
+                streaming,
+                &query_settings,
+                graph,
+                Some(&self.prefixes),
+                debug_no_results,
+            )
             .map_err(|x| x.into())
     }
 
@@ -351,6 +383,7 @@ impl Model {
             only_shapes,
             deactivate_shapes,
             dry_run,
+            Some(self.prefixes.clone()),
         );
         res.map_err(|x| x.into())
     }
@@ -404,13 +437,14 @@ impl Model {
         graph: Option<&NamedGraph>,
         include_transient: bool,
         max_rows: Option<usize>,
-    ) -> Result<Option<HashMap<NamedNode, EagerSolutionMappings>>, MaplibError> {
+        debug_no_results: bool,
+    ) -> Result<InferenceResult, MaplibError> {
         if rulesets.is_empty() {
             return Err(MaplibError::MissingDatalogRuleset);
         }
         let mut ruleset: Option<DatalogRuleset> = None;
         for r in rulesets {
-            let new_ruleset = parse_datalog_ruleset(&r, None)
+            let new_ruleset = parse_datalog_ruleset(&r, None, Some(&self.prefixes))
                 .map_err(|x| MaplibError::DatalogSyntaxError(x.to_string()))?;
             if let Some(orig_ruleset) = &mut ruleset {
                 orig_ruleset.extend(new_ruleset);
@@ -427,6 +461,7 @@ impl Model {
             max_results,
             include_transient,
             max_rows,
+            debug_no_results,
         );
         Ok(res.map_err(|x| MaplibError::DatalogError(x))?)
     }

maplib-0.18.18/lib/maplib/src/prefixes.rs

@@ -0,0 +1,22 @@
+use oxrdf::NamedNode;
+use std::collections::HashMap;
+use templates::constants::{
+    OTTR_PREFIX, OTTR_PREFIX_IRI, OWL_PREFIX, OWL_PREFIX_IRI, RDFS_PREFIX, RDFS_PREFIX_IRI,
+    RDF_PREFIX, RDF_PREFIX_IRI, SHACL_PREFIX, SHACL_PREFIX_IRI, XSD_PREFIX, XSD_PREFIX_IRI,
+};
+
+pub fn get_default_prefixes() -> HashMap<String, NamedNode> {
+    let predefined = [
+        (RDFS_PREFIX, RDFS_PREFIX_IRI),
+        (RDF_PREFIX, RDF_PREFIX_IRI),
+        (XSD_PREFIX, XSD_PREFIX_IRI),
+        (OTTR_PREFIX, OTTR_PREFIX_IRI),
+        (OWL_PREFIX, OWL_PREFIX_IRI),
+        (SHACL_PREFIX, SHACL_PREFIX_IRI),
+    ];
+    HashMap::from_iter(
+        predefined
+            .into_iter()
+            .map(|(x, y)| (x.to_string(), NamedNode::new_unchecked(y))),
+    )
+}

{maplib-0.18.13 → maplib-0.18.18}/lib/pydf_io/src/to_python.rs

@@ -12,6 +12,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyList;
 use pyo3::IntoPyObjectExt;
 use representation::cats::LockedCats;
+use representation::debug::DebugOutputs;
 use representation::formatting::{format_columns, format_native_columns};
 use representation::multitype::compress_actual_multitypes;
 use representation::python::PySolutionMappings;
@@ -84,6 +85,7 @@ pub fn to_py_df(
 pub fn df_to_py_df(
     mut df: DataFrame,
     rdf_node_states: HashMap<String, RDFNodeState>,
+    debug_outputs: Option<DebugOutputs>,
     pushdown_paths: Option<Vec<Context>>,
     include_datatypes: bool,
     py: Python,
@@ -102,11 +104,12 @@ pub fn df_to_py_df(
     let pyarrow = PyModule::import(py, "pyarrow")?;
     let polars = PyModule::import(py, "polars")?;
     let py_df = to_py_df(&chunk, names.as_slice(), py, &pyarrow, &polars)?;
-    if include_datatypes {
+    if include_datatypes || debug_outputs.is_some() {
         Py::new(
             py,
             PySolutionMappings {
                 mappings: py_df.into_any(),
+                debug: debug_outputs,
                 rdf_node_states,
                 pushdown_paths,
             },

{maplib-0.18.13 → maplib-0.18.18}/lib/query_processing/src/pushdowns.rs

@@ -5,7 +5,7 @@ use crate::type_constraints::{
 use oxrdf::vocab::rdfs;
 use oxrdf::{Term, Variable};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use representation::cats::{LockedCats};
+use representation::cats::LockedCats;
 use representation::polars_to_rdf::column_as_terms;
 use representation::solution_mapping::SolutionMappings;
 use spargebra::algebra::{Expression, Function, GraphPattern};

{maplib-0.18.13 → maplib-0.18.18}/lib/query_processing/src/type_constraints.rs

@@ -4,7 +4,7 @@ use representation::subtypes::{is_literal_subtype, OWL_REAL};
 use representation::BaseRDFNodeType;
 use spargebra::algebra::{Expression, Function};
 use std::cmp::PartialEq;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum ConstraintBaseRDFNodeType {
@@ -41,9 +41,7 @@ impl ConstraintExpr {
             ConstraintExpr::Bottom => false,
             ConstraintExpr::Top => true,
             ConstraintExpr::Constraint(c) => match c.as_ref() {
-                ConstraintBaseRDFNodeType::IRI => {
-                    t == &ConstraintBaseRDFNodeType::IRI
-                }
+                ConstraintBaseRDFNodeType::IRI => t == &ConstraintBaseRDFNodeType::IRI,
                 ConstraintBaseRDFNodeType::BlankNode => t == &ConstraintBaseRDFNodeType::BlankNode,
                 ConstraintBaseRDFNodeType::Literal(l_ctr) => {
                     if let ConstraintBaseRDFNodeType::Literal(l) = t {