maplib 0.18.14__tar.gz → 0.18.18__tar.gz

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

@@ -2451,10 +2451,11 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.18.14"
+version = "0.18.18"
 dependencies = [
  "chrono",
  "cimxml",
+ "datalog",
  "maplib",
  "mimalloc",
  "oxrdf",

{maplib-0.18.14 → 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"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maplib
-Version: 0.18.14
+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.14 → 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.14 → 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.14 → 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.14 → 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.14 → 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.14 → 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.14/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.14/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;

{maplib-0.18.14/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.14/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.14/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::{

maplib-0.18.14/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,7 +149,7 @@ 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() {
@@ -179,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,
@@ -208,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,
@@ -215,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())
     }
 
@@ -227,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())
     }
 
@@ -343,6 +383,7 @@ impl Model {
             only_shapes,
             deactivate_shapes,
             dry_run,
+            Some(self.prefixes.clone()),
         );
         res.map_err(|x| x.into())
     }
@@ -396,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);
@@ -419,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.14 → 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.14 → 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.14 → 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 {

{maplib-0.18.14 → maplib-0.18.18}/lib/report_mapping/src/lib.rs

@@ -1,4 +1,4 @@
-use maplib::mapping::Model;
+use maplib::model::Model;
 use shacl::errors::ShaclError;
 use shacl::ValidationReport;
 use triplestore::Triplestore;

{maplib-0.18.14 → maplib-0.18.18}/lib/representation/src/cats/encode.rs

@@ -1,6 +1,4 @@
-use super::{
-    CatEncs, CatType, Cats, EncodedTriples
-};
+use super::{CatEncs, CatType, Cats, EncodedTriples};
 use crate::cats::LockedCats;
 use crate::solution_mapping::{BaseCatState, EagerSolutionMappings};
 use crate::{BaseRDFNodeType, RDFNodeState, OBJECT_COL_NAME, SUBJECT_COL_NAME};
@@ -10,7 +8,6 @@ use polars::prelude::{col, lit, IntoLazy, Series};
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::sync::Arc;
-use rayon::iter::ParallelIterator;
 
 impl CatEncs {
     pub fn new_empty() -> CatEncs {
@@ -305,7 +302,7 @@ pub fn encode_triples(
     };
 
     let enc_trip = EncodedTriples {
-        df:sm.mappings,
+        df: sm.mappings,
         subject,
         subject_local_cat_uuid: subject_local_cat_uuid.clone(),
         object,

{maplib-0.18.14 → maplib-0.18.18}/lib/representation/src/cats/re_encode.rs

@@ -6,10 +6,10 @@ use nohash_hasher::NoHashHasher;
 use polars::datatypes::PlSmallStr;
 use polars::error::PolarsResult;
 use polars::prelude::{col, Column, IntoColumn, IntoLazy, LazyFrame, Series};
+use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::sync::Arc;
-use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 
 #[derive(Debug, Clone)]
 pub struct CatReEnc {
@@ -181,48 +181,48 @@ pub fn re_encode(
         .into_par_iter()
         .map(|mut x| {
             let mut enc = x.encoded_triples;
-                let subj_encs = if let Some(s_uuid) = &enc.subject_local_cat_uuid {
-                    if let Some(s_map) = re_enc_map.get(s_uuid) {
-                        if let Some(s) = &enc.subject {
-                            s_map.get(s)
-                        } else {
-                            None
-                        }
+            let subj_encs = if let Some(s_uuid) = &enc.subject_local_cat_uuid {
+                if let Some(s_map) = re_enc_map.get(s_uuid) {
+                    if let Some(s) = &enc.subject {
+                        s_map.get(s)
                     } else {
                         None
                     }
                 } else {
                     None
-                };
-                if let Some(subj_encs) = subj_encs {
-                    let mut renc_col = subj_encs
-                        .clone()
-                        .re_encode_column(enc.df.column(SUBJECT_COL_NAME).unwrap().clone(), false)
-                        .unwrap();
-                    renc_col.rename(PlSmallStr::from_str(SUBJECT_COL_NAME));
-                    enc.df.with_column(renc_col).unwrap();
                 }
-                let obj_encs = if let Some(o_uuid) = &enc.object_local_cat_uuid {
-                    if let Some(o_map) = re_enc_map.get(o_uuid) {
-                        if let Some(o) = &enc.object {
-                            o_map.get(o)
-                        } else {
-                            None
-                        }
+            } else {
+                None
+            };
+            if let Some(subj_encs) = subj_encs {
+                let mut renc_col = subj_encs
+                    .clone()
+                    .re_encode_column(enc.df.column(SUBJECT_COL_NAME).unwrap().clone(), false)
+                    .unwrap();
+                renc_col.rename(PlSmallStr::from_str(SUBJECT_COL_NAME));
+                enc.df.with_column(renc_col).unwrap();
+            }
+            let obj_encs = if let Some(o_uuid) = &enc.object_local_cat_uuid {
+                if let Some(o_map) = re_enc_map.get(o_uuid) {
+                    if let Some(o) = &enc.object {
+                        o_map.get(o)
                     } else {
                         None
                     }
                 } else {
                     None
-                };
-                if let Some(obj_encs) = obj_encs {
-                    let mut renc_col = obj_encs
-                        .clone()
-                        .re_encode_column(enc.df.column(OBJECT_COL_NAME).unwrap().clone(), false)
-                        .unwrap();
-                    renc_col.rename(PlSmallStr::from_str(OBJECT_COL_NAME));
-                    enc.df.with_column(renc_col).unwrap();
                 }
+            } else {
+                None
+            };
+            if let Some(obj_encs) = obj_encs {
+                let mut renc_col = obj_encs
+                    .clone()
+                    .re_encode_column(enc.df.column(OBJECT_COL_NAME).unwrap().clone(), false)
+                    .unwrap();
+                renc_col.rename(PlSmallStr::from_str(OBJECT_COL_NAME));
+                enc.df.with_column(renc_col).unwrap();
+            }
 
             x.encoded_triples = enc;
             x