maplib 0.18.12__tar.gz → 0.18.14__tar.gz

{maplib-0.18.12 → maplib-0.18.14}/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,7 +2451,7 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.18.12"
+version = "0.18.14"
 dependencies = [
  "chrono",
  "cimxml",
@@ -3529,13 +3513,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 +3828,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.12 → maplib-0.18.14}/Cargo.toml

@@ -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.12 → maplib-0.18.14}/PKG-INFO

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

{maplib-0.18.12 → maplib-0.18.14}/lib/maplib/src/mapping/default.rs

@@ -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.12 → maplib-0.18.14}/lib/maplib/src/mapping/expansion.rs

@@ -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.12 → maplib-0.18.14}/lib/maplib/src/mapping.rs

@@ -144,15 +144,7 @@ impl Model {
         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
         };

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/Cargo.toml

@@ -6,11 +6,13 @@ rust-version.workspace = true
 
 [dependencies]
 representation = { path = "../representation" }
+spargebra = {path = "../spargebra"}
 
 oxrdf = { workspace = true }
-unic-char-range = "0.9.0"
 tracing = { workspace = true }
 thiserror = { workspace = true }
-nom = { workspace = true, features = ["alloc"] }
 pyo3.workspace = true
 walkdir.workspace = true
+oxiri.workspace = true
+oxilangtag.workspace = true
+peg = {workspace = true }

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/src/ast.rs

@@ -52,19 +52,14 @@ impl Display for Template {
 
 #[derive(PartialEq, Debug, Clone)]
 pub struct Signature {
-    pub template_name: NamedNode,
-    pub template_prefixed_name: Option<String>,
+    pub iri: NamedNode,
     pub parameter_list: Vec<Parameter>,
     pub annotation_list: Option<Vec<Annotation>>,
 }
 
 impl Display for Signature {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if let Some(template_prefixed_name) = &self.template_prefixed_name {
-            write!(f, "{template_prefixed_name}")?;
-        } else {
-            write!(f, "{}", &self.template_name)?;
-        }
+        write!(f, "{}", &self.iri)?;
         write!(f, " [")?;
         for (idx, p) in self.parameter_list.iter().enumerate() {
             write!(f, "\n    ")?;
@@ -86,7 +81,7 @@ pub struct Parameter {
     pub non_blank: bool,
     pub ptype: Option<PType>,
     pub variable: Variable,
-    pub default_value: Option<DefaultValue>,
+    pub default_value: Option<ConstantTermOrList>,
 }
 
 impl Display for Parameter {
@@ -217,17 +212,6 @@ impl Display for PType {
     }
 }
 
-#[derive(PartialEq, Debug, Clone)]
-pub struct DefaultValue {
-    pub constant_term: ConstantTermOrList,
-}
-
-impl Display for DefaultValue {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.constant_term, f)
-    }
-}
-
 #[derive(PartialEq, Debug, Clone)]
 pub enum ConstantTermOrList {
     ConstantTerm(ConstantTerm),
@@ -324,8 +308,7 @@ impl Display for ConstantTerm {
 #[derive(PartialEq, Debug, Clone)]
 pub struct Instance {
     pub list_expander: Option<ListExpanderType>,
-    pub template_name: NamedNode,
-    pub prefixed_template_name: Option<String>,
+    pub template_iri: NamedNode,
     pub argument_list: Vec<Argument>,
 }
 
@@ -335,11 +318,7 @@ impl Display for Instance {
             std::fmt::Display::fmt(le, f)?;
             write!(f, " | ")?;
         }
-        if let Some(prefixed_template_name) = &self.prefixed_template_name {
-            write!(f, "{prefixed_template_name}")?;
-        } else {
-            write!(f, "{}", &self.template_name)?;
-        }
+        write!(f, "{}", &self.template_iri)?;
         write!(f, "(")?;
         for (idx, a) in self.argument_list.iter().enumerate() {
             std::fmt::Display::fmt(a, f)?;

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/src/dataset/errors.rs

@@ -1,4 +1,4 @@
-use crate::resolver::ResolutionError;
+use crate::parsing::ParseErrorKind;
 use oxrdf::Variable;
 use std::fmt::{Display, Formatter};
 use std::io;
@@ -10,8 +10,7 @@ pub enum TemplateError {
     IncompatibleTypes(String, Variable, String, String),
     ReadTemplateFileError(io::Error),
     ResolveDirectoryEntryError(walkdir::Error),
-    ParsingError(crate::parsing::errors::ParsingError),
-    ResolutionError(ResolutionError),
+    ParsingError(ParseErrorKind),
     TemplateNotFound(String, String),
 }
 
@@ -39,9 +38,6 @@ impl Display for TemplateError {
             TemplateError::ParsingError(p) => {
                 write!(f, "Template parsing error: {p}")
             }
-            TemplateError::ResolutionError(r) => {
-                write!(f, "Template resolution error {r}")
-            }
             TemplateError::TemplateNotFound(container, inner) => {
                 write!(
                     f,

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/src/dataset.rs

@@ -97,8 +97,7 @@ impl TemplateDataset {
 
         let ottr_template = Template {
             signature: Signature {
-                template_name: NamedNode::new_unchecked(OTTR_TRIPLE),
-                template_prefixed_name: Some("ottr:Triple".to_string()),
+                iri: NamedNode::new_unchecked(OTTR_TRIPLE),
                 parameter_list: vec![
                     ottr_triple_subject,
                     ottr_triple_predicate,
@@ -145,29 +144,29 @@ impl TemplateDataset {
     pub fn get(&self, template: &str) -> Option<&Template> {
         self.templates
             .iter()
-            .find(|&t| t.signature.template_name.as_str() == template)
+            .find(|&t| t.signature.iri.as_str() == template)
     }
 
     pub fn infer_types(&mut self) -> Result<(), TemplateError> {
         let template_names: Vec<_> = self
             .templates
             .iter()
-            .map(|x| x.signature.template_name.as_str().to_string())
+            .map(|x| x.signature.iri.as_str().to_string())
             .collect();
         let mut template_map: HashMap<String, Template> = self
             .templates
             .drain(..)
-            .map(|x| (x.signature.template_name.as_str().to_string(), x))
+            .map(|x| (x.signature.iri.as_str().to_string(), x))
             .collect();
         let mut affects_map: HashMap<String, Vec<String>> = HashMap::new();
         for t in template_map.values() {
             for i in &t.pattern_list {
-                if let Some(v) = affects_map.get_mut(i.template_name.as_str()) {
-                    v.push(t.signature.template_name.as_str().to_string());
+                if let Some(v) = affects_map.get_mut(i.template_iri.as_str()) {
+                    v.push(t.signature.iri.as_str().to_string());
                 } else {
                     affects_map.insert(
-                        i.template_name.as_str().to_string(),
-                        vec![t.signature.template_name.as_str().to_string()],
+                        i.template_iri.as_str().to_string(),
+                        vec![t.signature.iri.as_str().to_string()],
                     );
                 }
             }
@@ -218,7 +217,7 @@ impl TemplateDataset {
         if let Some(pos) = self
             .templates
             .iter()
-            .position(|x| x.signature.template_name == template.signature.template_name)
+            .position(|x| x.signature.iri == template.signature.iri)
         {
             self.templates.remove(pos);
         }
@@ -234,18 +233,18 @@ fn infer_template_types(
 ) -> Result<bool, TemplateError> {
     let mut changed = false;
     for i in &mut template.pattern_list {
-        let other = if let Some(t) = templates.get(i.template_name.as_str()) {
+        let other = if let Some(t) = templates.get(i.template_iri.as_str()) {
             t
         } else {
             return Err(TemplateError::TemplateNotFound(
-                template.signature.template_name.to_string().clone(),
-                i.template_name.to_string().clone(),
+                template.signature.iri.to_string().clone(),
+                i.template_iri.to_string().clone(),
             ));
         };
         if i.argument_list.len() != other.signature.parameter_list.len() {
             return Err(TemplateError::InconsistentNumberOfArguments(
-                template.signature.template_name.as_str().to_string(),
-                other.signature.template_name.as_str().to_string(),
+                template.signature.iri.as_str().to_string(),
+                other.signature.iri.as_str().to_string(),
                 i.argument_list.len(),
                 other.signature.parameter_list.len(),
             ));
@@ -264,7 +263,7 @@ fn infer_template_types(
                                     if !other_parameter.optional {
                                         changed = changed
                                             || lub_update(
-                                                &template.signature.template_name,
+                                                &template.signature.iri,
                                                 v,
                                                 my_parameter,
                                                 &PType::NEList(Box::new(other_ptype.clone())),
@@ -272,7 +271,7 @@ fn infer_template_types(
                                     } else {
                                         changed = changed
                                             || lub_update(
-                                                &template.signature.template_name,
+                                                &template.signature.iri,
                                                 v,
                                                 my_parameter,
                                                 &PType::List(Box::new(other_ptype.clone())),
@@ -281,7 +280,7 @@ fn infer_template_types(
                                 } else {
                                     changed = changed
                                         || lub_update(
-                                            &template.signature.template_name,
+                                            &template.signature.iri,
                                             v,
                                             my_parameter,
                                             other_ptype,

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/src/document.rs

@@ -1,13 +1,12 @@
 use crate::ast::StottrDocument;
 use crate::dataset::errors::TemplateError;
-use crate::parsing::whole_stottr_doc;
-use crate::resolver::resolve_document;
+use crate::parsing::parse_stottr;
 use std::fs::read_to_string;
 use std::path::Path;
 
 pub fn document_from_str(s: &str) -> Result<StottrDocument, TemplateError> {
-    let unresolved = whole_stottr_doc(s).map_err(TemplateError::ParsingError)?;
-    resolve_document(unresolved).map_err(TemplateError::ResolutionError)
+    let doc = parse_stottr(s)?;
+    Ok(doc)
 }
 
 pub fn document_from_file<P: AsRef<Path>>(p: P) -> Result<StottrDocument, TemplateError> {

{maplib-0.18.12 → maplib-0.18.14}/lib/templates/src/lib.rs

@@ -1,6 +1,3 @@
-#[cfg(test)]
-#[macro_use]
-extern crate unic_char_range;
 use crate::ast::PType;
 use representation::RDFNodeState;
 
@@ -11,7 +8,6 @@ pub mod dataset;
 pub mod document;
 mod parsing;
 pub mod python;
-mod resolver;
 pub mod subtypes_ext;
 
 #[derive(Clone, Debug)]