maplib 0.19.10__tar.gz → 0.19.11__tar.gz

{maplib-0.19.10 → maplib-0.19.11}/Cargo.lock

@@ -2452,7 +2452,7 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.19.10"
+version = "0.19.11"
 dependencies = [
  "chrono",
  "cimxml",

{maplib-0.19.10 → maplib-0.19.11}/PKG-INFO

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

{maplib-0.19.10 → maplib-0.19.11}/lib/maplib/src/model.rs

@@ -13,7 +13,7 @@ use oxrdfio::RdfFormat;
 use polars::prelude::DataFrame;
 use representation::solution_mapping::EagerSolutionMappings;
 use representation::RDFNodeState;
-use shacl::{validate, ValidationReport};
+use shacl::{infer_shacl, validate, ShaclInferenceResult, ValidationReport};
 use std::collections::HashMap;
 use std::fs;
 use std::io::Write;
@@ -27,6 +27,7 @@ use triplestore::sparql::{QueryResult, QuerySettings, UpdateResult};
 use triplestore::{IndexingOptions, NewTriples, Triplestore};
 
 use datalog::ast::DatalogRuleset;
+use representation::constants::{FX_PREFIX, FX_PREFIX_IRI, XYZ_PREFIX, XYZ_PREFIX_IRI};
 use representation::dataset::NamedGraph;
 use representation::prefixes::get_default_prefixes;
 use tracing::instrument;
@@ -173,15 +174,15 @@ impl Model {
     pub fn map_json_path(
         &mut self,
         path: &Path,
-        prefix: &NamedNode,
         graph: &NamedGraph,
         transient: bool,
     ) -> Result<(), MaplibError> {
+        self.add_json_prefixes();
         let mut u8s =
             fs::read(path).map_err(|x| TriplestoreError::ReadJSONFileError(x.to_string()))?;
 
         self.triplestore
-            .map_json(&mut u8s, prefix, graph, transient)
+            .map_json(&mut u8s, graph, transient)
             .map_err(MaplibError::TriplestoreError)
     }
 
@@ -189,14 +190,14 @@ impl Model {
     pub fn map_json_string(
         &mut self,
         mut p: String,
-        prefix: &NamedNode,
         graph: &NamedGraph,
         transient: bool,
     ) -> Result<(), MaplibError> {
+        self.add_json_prefixes();
         //Safety: we are never reading this vec back to a string
         let u8s = unsafe { p.as_mut_vec() };
         self.triplestore
-            .map_json(u8s, prefix, graph, transient)
+            .map_json(u8s, graph, transient)
             .map_err(MaplibError::TriplestoreError)
     }
 
@@ -524,6 +525,31 @@ impl Model {
         Ok(res.map_err(|x| MaplibError::DatalogError(x))?)
     }
 
+    pub fn infer_shacl(
+        &mut self,
+        data_graph: &NamedGraph,
+        shape_graph: &NamedGraph,
+        streaming: bool,
+        include_transient: bool,
+        max_iterations: Option<usize>,
+        max_results: Option<usize>,
+        max_rows: Option<usize>,
+        debug_no_results: bool,
+    ) -> Result<ShaclInferenceResult, MaplibError> {
+        let res = infer_shacl(
+            &mut self.triplestore,
+            data_graph,
+            shape_graph,
+            streaming,
+            max_iterations,
+            max_results,
+            include_transient,
+            max_rows,
+            debug_no_results,
+        );
+        Ok(res.map_err(|x| MaplibError::ShaclError(x))?)
+    }
+
     pub fn detach_graph(
         &mut self,
         graph: &NamedGraph,
@@ -539,4 +565,15 @@ impl Model {
             prefixes: self.prefixes.clone(),
         })
     }
+
+    fn add_json_prefixes(&mut self) {
+        self.prefixes.insert(
+            XYZ_PREFIX.to_string(),
+            NamedNode::new_unchecked(XYZ_PREFIX_IRI),
+        );
+        self.prefixes.insert(
+            FX_PREFIX.to_string(),
+            NamedNode::new_unchecked(FX_PREFIX_IRI),
+        );
+    }
 }

{maplib-0.19.10 → maplib-0.19.11}/lib/representation/src/constants.rs

@@ -1,6 +1,10 @@
 pub const LANG_LANG_FIELD_ALT_NAME: &str = "language";
 pub const LANG_VALUE_FIELD_ALT_NAME: &str = "value";
 
+pub const XYZ_PREFIX: &str = "xyz";
+pub const XYZ_PREFIX_IRI: &str = "http://sparql.xyz/facade-x/data/";
+pub const FX_PREFIX: &str = "fx";
+pub const FX_PREFIX_IRI: &str = "http://sparql.xyz/facade-x/ns/";
 pub const OTTR_TRIPLE: &str = "http://ns.ottr.xyz/0.4/Triple";
 pub const OTTR_PREFIX: &str = "ottr";
 pub const OTTR_PREFIX_IRI: &str = "http://ns.ottr.xyz/0.4/";

{maplib-0.19.10 → maplib-0.19.11}/lib/shacl/src/lib.rs

@@ -7,12 +7,24 @@ use oxrdf::{NamedNode, NamedOrBlankNode};
 use polars::prelude::DataFrame;
 use representation::solution_mapping::SolutionMappings;
 use std::collections::HashMap;
+use std::fmt::Display;
 use std::time::Duration;
 use triplestore::Triplestore;
 
 use representation::cats::LockedCats;
 use representation::dataset::NamedGraph;
 
+#[derive(Clone)]
+pub struct ShaclInferenceResult {
+
+}
+
+impl Display for ShaclInferenceResult {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ShapeTargets {
     pub shape_node: NamedOrBlankNode,
@@ -72,3 +84,18 @@ pub fn validate(
 ) -> Result<ValidationReport, ShaclError> {
     unimplemented!("Contact Data Treehouse to try")
 }
+
+
+pub fn infer_shacl(
+    _triplestore: &mut Triplestore,
+    _data_graph: &NamedGraph,
+    _shapes_graph: &NamedGraph,
+    _streaming: bool,
+    _max_iterations: Option<usize>,
+    _max_results: Option<usize>,
+    _include_transient: bool,
+    _max_rows: Option<usize>,
+    _debug_no_results: bool,
+) -> Result<ShaclInferenceResult, ShaclError> {
+    unimplemented!("Contact Data Treehouse to try")
+}

{maplib-0.19.10 → maplib-0.19.11}/lib/triplestore/src/map_json.rs

@@ -12,6 +12,8 @@ use oxrdf::vocab::{rdf, xsd};
 use oxrdf::NamedNode;
 use polars::prelude::PlSmallStr;
 use polars_core::prelude::{AnyValue, Column, DataFrame};
+use query_processing::expressions::named_node;
+use representation::constants::RDF_PREFIX_IRI;
 use representation::dataset::NamedGraph;
 use representation::{BaseRDFNodeType, OBJECT_COL_NAME, SUBJECT_COL_NAME};
 use serde_json::Value;
@@ -25,18 +27,12 @@ const FLOAT: u8 = 3;
 const BLANK: u8 = 4;
 const IRI: u8 = 5;
 
-const JSON_CONTAINS: &str = "urn:maplib_json:contains";
-const JSON_ROOT: &str = "urn:maplib_json:Root";
-const JSON_NODE: &str = "urn:maplib_json:Node";
-const JSON_ARRAY: &str = "urn:maplib_json:Array";
-const JSON_ARRAY_ELEMENT: &str = "urn:maplib_json:ArrayElement";
-const JSON_ELEMENT_PROPERTY: &str = "urn:maplib_json:element";
-const JSON_ELEMENT_SEQUENCE: &str = "urn:maplib_json:sequence";
-const JSON_ELEMENT_VALUE: &str = "urn:maplib_json:value";
+const JSON_ROOT: &str = "http://sparql.xyz/facade-x/ns/root";
+const JSON_NULL: &str = "http://sparql.xyz/facade-x/ns/null";
 
-const JSON_NULL: &str = "urn:maplib_json:Null";
-const JSON_KEY: &str = "urn:maplib_json:Key";
-const JSON_KEY_STRING: &str = "urn:maplib_json:keyString";
+const DEFAULT_JSON_KEYS_PREFIX: &str = "http://sparql.xyz/facade-x/data/";
+
+const ROOT_ELEMENT_PROPERTY: &str = "urn:maplib_json:rootElement";
 
 struct TripleTableBuilder<'a> {
     map: HashMap<(u8, u8), TypedSubjectObjectBuilder<'a>>,
@@ -178,45 +174,28 @@ impl Triplestore {
     pub fn map_json(
         &mut self,
         u8s: &mut Vec<u8>,
-        prefix: &NamedNode,
         named_graph: &NamedGraph,
         transient: bool,
     ) -> Result<(), TriplestoreError> {
-        NamedNode::new(format!("{}a", prefix.as_str()))
-            .map_err(|_| TriplestoreError::InvalidPrefixIRI(prefix.as_str().to_string()))?;
-
+        let prefix = NamedNode::new_unchecked(DEFAULT_JSON_KEYS_PREFIX);
         let v: Value = simd_json::serde::from_slice(u8s).unwrap();
 
         let mut pred_map = HashMap::new();
         let rdf_type = rdf::TYPE.into_owned();
         pred_map.insert(rdf_type.clone(), TripleTableBuilder::new());
 
-        let doc_subject = new_blank_subject(JSON_ROOT, &rdf_type, &mut pred_map);
-
-        let json_contains = NamedNode::new_unchecked(JSON_CONTAINS);
-        pred_map.insert(json_contains.clone(), TripleTableBuilder::new());
+        let doc_subject = new_blank_typed_subject(JSON_ROOT, &rdf_type, &mut pred_map);
 
-        let element_property = NamedNode::new_unchecked(JSON_ELEMENT_PROPERTY);
-        pred_map.insert(element_property.clone(), TripleTableBuilder::new());
-        let sequence_property = NamedNode::new_unchecked(JSON_ELEMENT_SEQUENCE);
-        pred_map.insert(sequence_property.clone(), TripleTableBuilder::new());
-        let value_property = NamedNode::new_unchecked(JSON_ELEMENT_VALUE);
-        pred_map.insert(value_property.clone(), TripleTableBuilder::new());
-
-        pred_map.insert(
-            NamedNode::new_unchecked(JSON_KEY_STRING),
-            TripleTableBuilder::new(),
-        );
+        let root_elem_property = NamedNode::new_unchecked(ROOT_ELEMENT_PROPERTY);
+        pred_map.insert(root_elem_property.clone(), TripleTableBuilder::new());
 
         process_value(
             &doc_subject,
-            &json_contains,
-            prefix,
+            None,
+            &prefix,
             v,
             &rdf_type,
-            &element_property,
-            &sequence_property,
-            &value_property,
+            &root_elem_property,
             &mut pred_map,
         );
         let mut triples_to_add = Vec::new();
@@ -252,22 +231,20 @@ impl Triplestore {
 
 fn process_value(
     subject: &str,
-    property: &NamedNode,
+    property: Option<&NamedNode>,
     prefix: &NamedNode,
     value: Value,
     rdf_type: &NamedNode,
-    element_property: &NamedNode,
-    sequence_property: &NamedNode,
-    value_property: &NamedNode,
+    root_elem_property: &NamedNode,
     map: &mut HashMap<NamedNode, TripleTableBuilder>,
 ) {
     match value {
         Value::Bool(b) => {
-            let builder = map.get_mut(property).unwrap();
+            let builder = map.get_mut(property.unwrap_or(root_elem_property)).unwrap();
             builder.push_blank_bool(subject, b);
         }
         Value::Number(num) => {
-            let builder = map.get_mut(property).unwrap();
+            let builder = map.get_mut(property.unwrap_or(root_elem_property)).unwrap();
             if let Some(i) = num.as_i64() {
                 builder.push_blank_int(subject, i);
             } else if let Some(f) = num.as_f64() {
@@ -277,63 +254,57 @@ fn process_value(
             }
         }
         Value::String(s) => {
-            let builder = map.get_mut(property).unwrap();
+            let builder = map.get_mut(property.unwrap_or(root_elem_property)).unwrap();
             builder.push_blank_string(subject, s);
         }
         Value::Null => {
-            let builder = map.get_mut(property).unwrap();
+            let builder = map.get_mut(property.unwrap_or(root_elem_property)).unwrap();
             builder.push_blank_iri(subject, JSON_NULL);
         }
         Value::Object(obj) => {
-            let new_subject = new_blank_subject(JSON_NODE, rdf_type, map);
-            let builder = map.get_mut(property).unwrap();
-            builder.push_blank_blank(subject, &new_subject);
+            let new_subject = if let Some(property) = property {
+                let new_subject = new_blank_subject();
+                let builder = map.get_mut(property).unwrap();
+                builder.push_blank_blank(subject, &new_subject);
+                new_subject
+            } else {
+                subject.to_string()
+            };
 
             for (key, val) in obj {
-                let property = new_property(key, prefix, map);
+                let property = new_key_property(key, prefix, map);
                 process_value(
                     &new_subject,
-                    &property,
+                    Some(&property),
                     prefix,
                     val,
                     rdf_type,
-                    element_property,
-                    sequence_property,
-                    value_property,
+                    root_elem_property,
                     map,
                 );
             }
         }
         Value::Array(arr) => {
-            let array_subject = new_blank_subject(JSON_ARRAY, rdf_type, map);
-            let builder = map.get_mut(property).unwrap();
-            builder.push_blank_blank(subject, &array_subject);
-
-            let element_subjects: Vec<_> = arr
-                .iter()
-                .map(|_| new_blank_subject(JSON_ARRAY_ELEMENT, rdf_type, map))
-                .collect();
-
-            let builder = map.get_mut(element_property).unwrap();
-            for element_subject in &element_subjects {
-                builder.push_blank_blank(&array_subject, &element_subject);
-            }
-
-            let builder = map.get_mut(sequence_property).unwrap();
-            for (i, element_subject) in element_subjects.iter().enumerate() {
-                builder.push_blank_int(&element_subject, i as i64);
-            }
+            let array_subject = if let Some(property) = property {
+                let array_subject = new_blank_subject();
+                let builder = map.get_mut(property).unwrap();
+                builder.push_blank_blank(subject, &array_subject);
+                array_subject
+            } else {
+                subject.to_string()
+            };
 
-            for (value, element_subject) in arr.into_iter().zip(element_subjects.into_iter()) {
+            for (i, value) in arr.into_iter().enumerate() {
+                let rdfi_property =
+                    NamedNode::new(format!("{}_{}", RDF_PREFIX_IRI, i + 1)).unwrap();
+                add_new_property(&rdfi_property, map);
                 process_value(
-                    &element_subject,
-                    value_property,
+                    &array_subject,
+                    Some(&rdfi_property),
                     prefix,
                     value,
                     rdf_type,
-                    element_property,
-                    sequence_property,
-                    value_property,
+                    root_elem_property,
                     map,
                 );
             }
@@ -341,17 +312,22 @@ fn process_value(
     }
 }
 
-fn new_blank_subject(
+fn new_blank_typed_subject(
     t: &str,
     rdf_type: &NamedNode,
     map: &mut HashMap<NamedNode, TripleTableBuilder>,
 ) -> String {
-    let bstr = format!("b{}", uuid::Uuid::new_v4());
+    let bstr = new_blank_subject();
     map.get_mut(rdf_type).unwrap().push_blank_iri(&bstr, t);
     bstr
 }
 
-fn new_property(
+fn new_blank_subject() -> String {
+    let bstr = format!("b{}", uuid::Uuid::new_v4());
+    bstr
+}
+
+fn new_key_property(
     key: String,
     prefix: &NamedNode,
     map: &mut HashMap<NamedNode, TripleTableBuilder>,
@@ -371,18 +347,12 @@ fn new_property(
     }
     let keep_key: String = keep_chars.into_iter().collect();
     let key_nn = NamedNode::new(format!("{}{}", prefix.as_str(), keep_key)).unwrap();
-    if !map.contains_key(&key_nn) {
-        {
-            let type_ttb = map.get_mut(&rdf::TYPE.into_owned()).unwrap();
-            type_ttb.push_iri_iri(key_nn.as_str(), JSON_KEY);
-        }
-        {
-            let s_ttb = map
-                .get_mut(&NamedNode::new_unchecked(JSON_KEY_STRING))
-                .unwrap();
-            s_ttb.push_iri_string(key_nn.as_str(), &key);
-        }
-        map.insert(key_nn.clone(), TripleTableBuilder::new());
-    }
+    add_new_property(&key_nn, map);
     key_nn
 }
+
+fn add_new_property(property: &NamedNode, map: &mut HashMap<NamedNode, TripleTableBuilder>) {
+    if !map.contains_key(&property) {
+        map.insert(property.clone(), TripleTableBuilder::new());
+    }
+}