From 8578eabe6843d4c0aa0425d2fd9a58d735ade60d Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Tue, 12 May 2026 13:11:41 +0200 Subject: [PATCH 01/19] Added Support for default prefixes in SPARQL queries (#647) --- nemo/src/io/format_builder.rs | 49 ++++++++- nemo/src/io/formats/dsv.rs | 15 ++- nemo/src/io/formats/json.rs | 5 +- nemo/src/io/formats/rdf.rs | 16 ++- nemo/src/io/formats/sparql.rs | 104 +++++++++++++++--- .../rule_model/components/import_export.rs | 43 +++++++- .../translation/directive/import_export.rs | 17 ++- 7 files changed, 218 insertions(+), 31 deletions(-) diff --git a/nemo/src/io/format_builder.rs b/nemo/src/io/format_builder.rs index 3df710229..3b94ad018 100644 --- a/nemo/src/io/format_builder.rs +++ b/nemo/src/io/format_builder.rs @@ -13,6 +13,7 @@ use nemo_physical::{ resource::{Resource, ResourceBuilder, ResourceValidationError}, tabular::filters::FilterTransformPattern, }; +use oxiri::{Iri, IriRef}; use strum::IntoEnumIterator; use crate::{ @@ -47,7 +48,12 @@ pub(crate) trait FormatParameter: FromStr + Debug + ToString + IntoEnumIterator + Copy + Eq + Hash { fn required_for(&self, tag: Tag) -> bool; - fn is_value_valid(&self, value: AnyDataValue) -> Result<(), ValidationError>; + fn is_value_valid( + &self, + value: AnyDataValue, + base: Option>, + prefixes: HashMap>, + ) -> Result<(), ValidationError>; } pub(super) fn value_type_matches( @@ -234,7 +240,12 @@ impl FormatParameter for StandardParameter { false } - fn is_value_valid(&self, value: AnyDataValue) -> Result<(), ValidationError> { + fn is_value_valid( + &self, + value: AnyDataValue, + _base: Option>, + _prefixes: HashMap>, + ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { @@ -269,6 +280,8 @@ pub(crate) trait FormatBuilder: Debug + Sized + Into { tag: Self::Tag, parameters: &Parameters, direction: Direction, + base: Option>, + prefixes: HashMap>, ) -> Result; fn expected_arity(&self) -> Option; @@ -357,6 +370,8 @@ impl Parameters { _filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, + base: Option>, + prefixes: HashMap>, ) -> Option { let Ok(format_tag) = B::Tag::from_str(spec.format().name()) else { report.add( @@ -420,7 +435,9 @@ impl Parameters { } }; - if let Err(error) = parameter.is_value_valid(value.clone()) { + if let Err(error) = + parameter.is_value_valid(value.clone(), base.clone(), prefixes.clone()) + { report.add(value_term, error); has_errors = true; continue; @@ -513,10 +530,20 @@ impl ImportExportBuilder { filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, + base: Option>, + prefixes: HashMap>, ) -> Option { let origin = spec.origin(); - let parameters = - Parameters::::validate(predicate, spec, bindings, filter_rules, direction, report)?; + let parameters = Parameters::::validate( + predicate, + spec, + bindings, + filter_rules, + direction, + report, + base.clone(), + prefixes.clone(), + )?; let resource_builder = if let Some(value) = parameters.get_optional(StandardParameter::Resource.into()) { @@ -538,7 +565,7 @@ impl ImportExportBuilder { }) .unwrap_or_else(|| CompressionFormat::from_resource_builder(&resource_builder)); - let inner = match B::new(tag, ¶meters, direction) { + let inner = match B::new(tag, ¶meters, direction, base.clone(), prefixes.clone()) { Ok(b) => b, Err(error) => { report.add_source(origin.clone(), error); @@ -629,6 +656,8 @@ impl ImportExportBuilder { filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, + base: Option>, + prefixes: HashMap>, ) -> Option { let format_tag = spec.format().name().to_owned(); let Ok(tag) = format_tag.parse::() else { @@ -651,6 +680,8 @@ impl ImportExportBuilder { filter_rules, direction, report, + base, + prefixes, ), SupportedFormatTag::Rdf(tag) => Self::new_with_tag::( predicate, @@ -660,6 +691,8 @@ impl ImportExportBuilder { filter_rules, direction, report, + base, + prefixes, ), SupportedFormatTag::Json(tag) => Self::new_with_tag::( predicate, @@ -669,6 +702,8 @@ impl ImportExportBuilder { filter_rules, direction, report, + base, + prefixes, ), SupportedFormatTag::Sparql(tag) => Self::new_with_tag::( predicate, @@ -678,6 +713,8 @@ impl ImportExportBuilder { filter_rules, direction, report, + base, + prefixes, ), } } diff --git a/nemo/src/io/formats/dsv.rs b/nemo/src/io/formats/dsv.rs index 7338fd2f2..cd6a48921 100644 --- a/nemo/src/io/formats/dsv.rs +++ b/nemo/src/io/formats/dsv.rs @@ -5,6 +5,7 @@ pub mod value_format; pub(crate) mod writer; use std::{ + collections::HashMap, io::{BufReader, Read, Write}, sync::Arc, }; @@ -14,6 +15,7 @@ use nemo_physical::{ datavalues::{AnyDataValue, DataValue}, tabular::filters::FilterTransformPattern, }; +use oxiri::{Iri, IriRef}; use reader::DsvReader; use strum_macros::EnumIter; use value_format::DsvValueFormats; @@ -178,12 +180,17 @@ impl FormatParameter for DsvParameter { } } - fn is_value_valid(&self, value: AnyDataValue) -> Result<(), ValidationError> { + fn is_value_valid( + &self, + value: AnyDataValue, + base: Option>, + prefixes: HashMap>, + ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { - DsvParameter::BaseParamType(base) => { - FormatParameter::::is_value_valid(base, value) + DsvParameter::BaseParamType(base_param) => { + FormatParameter::::is_value_valid(base_param, value, base, prefixes) } DsvParameter::Limit => value .to_u64() @@ -238,6 +245,8 @@ impl FormatBuilder for DsvBuilder { tag: Self::Tag, parameters: &Parameters, _direction: Direction, + _base: Option>, + _prefixes: HashMap>, ) -> Result { let value_formats = parameters.get_optional(DsvParameter::Format).map(|value| { DsvValueFormats::try_from(value).expect("value formats have already been validated") diff --git a/nemo/src/io/formats/json.rs b/nemo/src/io/formats/json.rs index 9ba653a40..c77f5f491 100644 --- a/nemo/src/io/formats/json.rs +++ b/nemo/src/io/formats/json.rs @@ -2,11 +2,12 @@ pub(crate) mod reader; -use std::{io::Read, sync::Arc}; +use std::{collections::HashMap, io::Read, sync::Arc}; use nemo_physical::{ datasources::table_providers::TableProvider, tabular::filters::FilterTransformPattern, }; +use oxiri::{Iri, IriRef}; use reader::JsonReader; use crate::{ @@ -71,6 +72,8 @@ impl FormatBuilder for JsonHandler { _tag: Self::Tag, _parameters: &Parameters, direction: Direction, + _base: Option>, + _prefixes: HashMap>, ) -> Result { if matches!(direction, Direction::Export) { return Err(ValidationError::UnsupportedJsonExport); diff --git a/nemo/src/io/formats/rdf.rs b/nemo/src/io/formats/rdf.rs index 04d0acf24..b8b218ce5 100644 --- a/nemo/src/io/formats/rdf.rs +++ b/nemo/src/io/formats/rdf.rs @@ -8,6 +8,7 @@ pub(crate) mod value_format; pub(crate) mod writer; use std::{ + collections::HashMap, io::{Read, Write}, sync::Arc, }; @@ -19,7 +20,7 @@ use nemo_physical::{ tabular::filters::FilterTransformPattern, }; -use oxiri::Iri; +use oxiri::{Iri, IriRef}; use reader::RdfReader; use strum::VariantArray; use strum_macros::VariantArray; @@ -187,12 +188,17 @@ impl FormatParameter for RdfParameter { ) } - fn is_value_valid(&self, value: AnyDataValue) -> Result<(), ValidationError> { + fn is_value_valid( + &self, + value: AnyDataValue, + base: Option>, + prefixes: HashMap>, + ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { - RdfParameter::BaseParamType(base) => { - FormatParameter::::is_value_valid(base, value) + RdfParameter::BaseParamType(base_param) => { + FormatParameter::::is_value_valid(base_param, value, base, prefixes) } RdfParameter::Limit => value .to_u64() @@ -222,6 +228,8 @@ impl FormatBuilder for RdfHandler { tag: Self::Tag, parameters: &Parameters, _direction: Direction, + _base: Option>, + _prefixes: HashMap>, ) -> Result { let variant = match tag { RdfTag::Rdf => { diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index 4f85a53a5..b548c0868 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -6,7 +6,7 @@ pub(crate) mod reader; use reader::SparqlReader; use spargebra::{Query, SparqlParser}; -use std::sync::Arc; +use std::{collections::HashMap, str::FromStr, sync::Arc}; use nemo_physical::{ datasources::table_providers::TableProvider, @@ -14,7 +14,7 @@ use nemo_physical::{ resource::{ResourceBuilder, ResourceValidationError}, tabular::filters::FilterTransformPattern, }; -use oxiri::Iri; +use oxiri::{Iri, IriRef}; use crate::{ io::format_builder::{ @@ -67,12 +67,17 @@ impl FormatParameter for SparqlParameter { matches!(tag, SparqlTag::Sparql) && matches!(self, Self::Endpoint) } - fn is_value_valid(&self, value: AnyDataValue) -> Result<(), ValidationError> { + fn is_value_valid( + &self, + value: AnyDataValue, + base: Option>, + prefixes: HashMap>, + ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { - SparqlParameter::BaseParamType(base) => { - FormatParameter::::is_value_valid(base, value) + SparqlParameter::BaseParamType(base_param) => { + FormatParameter::::is_value_valid(base_param, value, base, prefixes) } SparqlParameter::Base => Ok(()), SparqlParameter::Format => DsvValueFormats::try_from(value).and(Ok(())).map_err(|_| { @@ -93,13 +98,36 @@ impl FormatParameter for SparqlParameter { } SparqlParameter::Query => { let query = value.to_plain_string_unchecked(); - SparqlParser::new() // TODO(mam): inject prefixes and base here, cf. #647 - .parse_query(query.as_str()) - .and(Ok(())) - .map_err(|e| ValidationError::InvalidSparqlQuery { + + let mut parser = SparqlParser::new(); + + let resolved_prefixes: Vec<(String, Iri)> = prefixes + .iter() + .map(|(key, value)| { + ( + key.clone(), + Iri::from_str(&value.to_string()) + .unwrap_or_else(|_| base.clone().unwrap().resolve(value).unwrap()), + ) + }) + .collect(); + + if let Some(base) = base { + parser = parser.with_base_iri(base.to_string()).unwrap(); + } + + for (prefix_name, prefix_iri) in resolved_prefixes { + parser = parser + .with_prefix(prefix_name, prefix_iri.to_string()) + .unwrap(); + } + + parser.parse_query(query.as_str()).and(Ok(())).map_err(|e| { + ValidationError::InvalidSparqlQuery { query, oxi_error: e.to_string(), - }) + } + }) } } } @@ -144,6 +172,8 @@ impl FormatBuilder for SparqlBuilder { _tag: Self::Tag, parameters: &Parameters, _direction: Direction, + base: Option>, + prefixes: HashMap>, ) -> Result { let value_formats = parameters .get_optional(SparqlParameter::Format) @@ -164,7 +194,31 @@ impl FormatBuilder for SparqlBuilder { .map(|value| value.to_plain_string_unchecked()) .unwrap_or(QUERY_DEFAULT.to_string()); - let query = SparqlParser::new() // TODO(mam): inject prefixes and base here, cf. #647 + let mut parser = SparqlParser::new(); + + // SparqlParser only accepts absolute (resolved) iri's + let resolved_prefixes: Vec<(String, Iri)> = prefixes + .iter() + .map(|(key, value)| { + ( + key.clone(), + Iri::from_str(&value.to_string()) + .unwrap_or_else(|_| base.clone().unwrap().resolve(value).unwrap()), + ) + }) + .collect(); + + if let Some(base) = base { + parser = parser.with_base_iri(base.to_string()).unwrap(); + } + + for (prefix_name, prefix_iri) in resolved_prefixes { + parser = parser + .with_prefix(prefix_name, prefix_iri.to_string()) + .unwrap(); + } + + let query = parser .parse_query(query.as_str()) .expect("query has already been validated"); @@ -268,12 +322,15 @@ impl ImportHandler for SparqlHandler { #[cfg(test)] mod test { + use std::{collections::HashMap, str::FromStr}; + use crate::parser::{ ParserState, ast::{ProgramAST, directive::import::Import}, input::ParserInput, }; use nom::combinator::all_consuming; + use oxiri::{Iri, IriRef}; use crate::io::format_builder::FormatParameter; use nemo_physical::datavalues::AnyDataValue; @@ -282,10 +339,20 @@ mod test { #[test] fn parse_query() { + let base = Some(Iri::from_str("http://www.wikidata.org/").unwrap()); + let prefixes: HashMap> = HashMap::from([ + // PREFIX wikibase: + ( + "wikibase".to_string(), + IriRef::from_str("http://wikiba.se/ontology#").unwrap(), + ), + // PREFIX wdt: + ("wdt".to_string(), IriRef::from_str("prop/direct/").unwrap()), + ]); + let valid_query = AnyDataValue::new_plain_string(String::from(" - PREFIX wikibase: + PREFIX wikibase: PREFIX bd: - PREFIX wdt: PREFIX wd: PREFIX ps: PREFIX p: @@ -300,8 +367,14 @@ mod test { ); let query_param = SparqlParameter::Query; - let result = query_param.is_value_valid(valid_query); + let result = query_param.is_value_valid(valid_query, base, prefixes); assert!(result.is_ok()); + } + + #[test] + fn parse_invalid_query() { + let base = None; + let prefixes = HashMap::new(); // Invalid because no prefixes are specified let invalid_query = AnyDataValue::new_plain_string(String::from(" @@ -313,7 +386,8 @@ mod test { } LIMIT 10") ); - let result = query_param.is_value_valid(invalid_query); + let query_param = SparqlParameter::Query; + let result = query_param.is_value_valid(invalid_query, base, prefixes); assert!(result.is_err()); } diff --git a/nemo/src/rule_model/components/import_export.rs b/nemo/src/rule_model/components/import_export.rs index 0ba301cde..fe22b2f26 100644 --- a/nemo/src/rule_model/components/import_export.rs +++ b/nemo/src/rule_model/components/import_export.rs @@ -5,6 +5,7 @@ use std::collections::{HashMap, HashSet}; use attribute::ImportExportAttribute; use nemo_physical::datavalues::AnyDataValue; +use oxiri::{Iri, IriRef}; use specification::ImportExportSpec; use crate::{ @@ -78,6 +79,10 @@ pub(crate) struct ImportExportDirective { bindings: Vec, /// Sub-rules for filtered import/export filter_rules: Vec, + /// + base: Option>, + /// + prefixes: HashMap>, } impl std::fmt::Display for ImportExportDirective { @@ -167,7 +172,13 @@ pub struct ImportDirective(pub(crate) ImportExportDirective); impl ImportDirective { /// Create a new [ImportDirective]. - pub fn new(predicate: Tag, spec: ImportExportSpec, bindings: Vec) -> Self { + pub fn new( + predicate: Tag, + spec: ImportExportSpec, + bindings: Vec, + base: Option>, + prefixes: HashMap>, + ) -> Self { Self(ImportExportDirective { origin: Origin::default(), id: ProgramComponentId::default(), @@ -175,6 +186,8 @@ impl ImportDirective { spec, bindings, filter_rules: Vec::new(), + base, + prefixes, }) } @@ -374,6 +387,8 @@ impl ImportDirective { self.filter_rules(), Direction::Import, report, + self.base().clone(), + self.prefixes().clone(), ) } @@ -387,9 +402,20 @@ impl ImportDirective { self.filter_rules(), Direction::Import, &mut report, + self.base().clone(), + self.prefixes().clone(), ) } + /// Return the base + pub fn base(&self) -> &Option> { + &self.0.base + } + /// Return the prefixes + pub fn prefixes(&self) -> &HashMap> { + &self.0.prefixes + } + /// Return the predicate. pub fn predicate(&self) -> &Tag { &self.0.predicate @@ -565,6 +591,8 @@ impl ExportDirective { spec, bindings, filter_rules: Vec::new(), + base: None, + prefixes: HashMap::new(), }) } @@ -596,6 +624,8 @@ impl ExportDirective { self.filter_rules(), Direction::Export, report, + self.base().clone(), + self.prefixes().clone(), ) } @@ -609,9 +639,20 @@ impl ExportDirective { self.filter_rules(), Direction::Export, &mut report, + self.base().clone(), + self.prefixes().clone(), ) } + /// Return the predicate. + pub fn base(&self) -> &Option> { + &self.0.base + } + + pub fn prefixes(&self) -> &HashMap> { + &self.0.prefixes + } + /// Return the predicate. pub fn predicate(&self) -> &Tag { &self.0.predicate diff --git a/nemo/src/rule_model/translation/directive/import_export.rs b/nemo/src/rule_model/translation/directive/import_export.rs index 129ffa902..e23f11033 100644 --- a/nemo/src/rule_model/translation/directive/import_export.rs +++ b/nemo/src/rule_model/translation/directive/import_export.rs @@ -1,5 +1,9 @@ //! This module contains a function for handling import/export statements. +use std::str::FromStr; + +use oxiri::{Iri, IriRef}; + use crate::{ parser::{ ast::{self, ProgramAST, tag::structure::StructureTag}, @@ -119,8 +123,19 @@ impl TranslationComponent for ImportDirective { let bindings = import_export_bindings(translation, import.guards())?; + let base = translation + .base + .clone() + .map(|x| Iri::from_str(&x.0).unwrap()); + + let prefixes = translation + .prefix_mapping + .iter() + .map(|(key, value)| (key.clone(), IriRef::from_str(&value.0).unwrap())) + .collect(); + Some(Origin::ast( - ImportDirective::new(predicate, spec, bindings), + ImportDirective::new(predicate, spec, bindings, base, prefixes), import, )) } From bcb6eee9153dc6ce151109b3fcbde8b6ea1a4130 Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Wed, 10 Jun 2026 15:30:15 +0200 Subject: [PATCH 02/19] Added FormatContext as wrapper for base and prefixes --- nemo/src/io/format_builder.rs | 40 +++----- nemo/src/io/formats/dsv.rs | 11 +-- nemo/src/io/formats/json.rs | 11 ++- nemo/src/io/formats/rdf.rs | 9 +- nemo/src/io/formats/sparql.rs | 98 +++++++------------ .../rule_model/components/import_export.rs | 49 +++------- nemo/src/rule_model/translation/directive.rs | 76 +++++++++++++- .../translation/directive/import_export.rs | 22 ++--- 8 files changed, 167 insertions(+), 149 deletions(-) diff --git a/nemo/src/io/format_builder.rs b/nemo/src/io/format_builder.rs index 3b94ad018..cd353de93 100644 --- a/nemo/src/io/format_builder.rs +++ b/nemo/src/io/format_builder.rs @@ -28,6 +28,7 @@ use crate::{ }, error::{ValidationReport, hint::Hint, info::Info, validation_error::ValidationError}, substitution::Substitution, + translation::directive::FormatContext, }, syntax::import_export::attribute, }; @@ -51,8 +52,7 @@ pub(crate) trait FormatParameter: fn is_value_valid( &self, value: AnyDataValue, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result<(), ValidationError>; } @@ -243,8 +243,7 @@ impl FormatParameter for StandardParameter { fn is_value_valid( &self, value: AnyDataValue, - _base: Option>, - _prefixes: HashMap>, + format_context: FormatContext, ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; @@ -280,8 +279,7 @@ pub(crate) trait FormatBuilder: Debug + Sized + Into { tag: Self::Tag, parameters: &Parameters, direction: Direction, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result; fn expected_arity(&self) -> Option; @@ -370,8 +368,7 @@ impl Parameters { _filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, - base: Option>, - prefixes: HashMap>, + formate_context: FormatContext, ) -> Option { let Ok(format_tag) = B::Tag::from_str(spec.format().name()) else { report.add( @@ -435,9 +432,7 @@ impl Parameters { } }; - if let Err(error) = - parameter.is_value_valid(value.clone(), base.clone(), prefixes.clone()) - { + if let Err(error) = parameter.is_value_valid(value.clone(), formate_context.clone()) { report.add(value_term, error); has_errors = true; continue; @@ -530,8 +525,7 @@ impl ImportExportBuilder { filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Option { let origin = spec.origin(); let parameters = Parameters::::validate( @@ -541,8 +535,7 @@ impl ImportExportBuilder { filter_rules, direction, report, - base.clone(), - prefixes.clone(), + format_context.clone(), )?; let resource_builder = @@ -565,7 +558,7 @@ impl ImportExportBuilder { }) .unwrap_or_else(|| CompressionFormat::from_resource_builder(&resource_builder)); - let inner = match B::new(tag, ¶meters, direction, base.clone(), prefixes.clone()) { + let inner = match B::new(tag, ¶meters, direction, format_context.clone()) { Ok(b) => b, Err(error) => { report.add_source(origin.clone(), error); @@ -656,8 +649,7 @@ impl ImportExportBuilder { filter_rules: &[Rule], direction: Direction, report: &mut ValidationReport, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Option { let format_tag = spec.format().name().to_owned(); let Ok(tag) = format_tag.parse::() else { @@ -680,8 +672,7 @@ impl ImportExportBuilder { filter_rules, direction, report, - base, - prefixes, + format_context, ), SupportedFormatTag::Rdf(tag) => Self::new_with_tag::( predicate, @@ -691,8 +682,7 @@ impl ImportExportBuilder { filter_rules, direction, report, - base, - prefixes, + format_context, ), SupportedFormatTag::Json(tag) => Self::new_with_tag::( predicate, @@ -702,8 +692,7 @@ impl ImportExportBuilder { filter_rules, direction, report, - base, - prefixes, + format_context, ), SupportedFormatTag::Sparql(tag) => Self::new_with_tag::( predicate, @@ -713,8 +702,7 @@ impl ImportExportBuilder { filter_rules, direction, report, - base, - prefixes, + format_context, ), } } diff --git a/nemo/src/io/formats/dsv.rs b/nemo/src/io/formats/dsv.rs index cd6a48921..b0e43ef4a 100644 --- a/nemo/src/io/formats/dsv.rs +++ b/nemo/src/io/formats/dsv.rs @@ -5,7 +5,6 @@ pub mod value_format; pub(crate) mod writer; use std::{ - collections::HashMap, io::{BufReader, Read, Write}, sync::Arc, }; @@ -15,7 +14,6 @@ use nemo_physical::{ datavalues::{AnyDataValue, DataValue}, tabular::filters::FilterTransformPattern, }; -use oxiri::{Iri, IriRef}; use reader::DsvReader; use strum_macros::EnumIter; use value_format::DsvValueFormats; @@ -30,6 +28,7 @@ use crate::{ rule_model::{ components::{import_export::Direction, term::value_type::ValueType}, error::validation_error::ValidationError, + translation::directive::FormatContext, }, syntax::import_export::{attribute, file_format}, }; @@ -183,14 +182,13 @@ impl FormatParameter for DsvParameter { fn is_value_valid( &self, value: AnyDataValue, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { DsvParameter::BaseParamType(base_param) => { - FormatParameter::::is_value_valid(base_param, value, base, prefixes) + FormatParameter::::is_value_valid(base_param, value, format_context) } DsvParameter::Limit => value .to_u64() @@ -245,8 +243,7 @@ impl FormatBuilder for DsvBuilder { tag: Self::Tag, parameters: &Parameters, _direction: Direction, - _base: Option>, - _prefixes: HashMap>, + _format_context: FormatContext, ) -> Result { let value_formats = parameters.get_optional(DsvParameter::Format).map(|value| { DsvValueFormats::try_from(value).expect("value formats have already been validated") diff --git a/nemo/src/io/formats/json.rs b/nemo/src/io/formats/json.rs index c77f5f491..827d2428c 100644 --- a/nemo/src/io/formats/json.rs +++ b/nemo/src/io/formats/json.rs @@ -2,12 +2,11 @@ pub(crate) mod reader; -use std::{collections::HashMap, io::Read, sync::Arc}; +use std::{io::Read, sync::Arc}; use nemo_physical::{ datasources::table_providers::TableProvider, tabular::filters::FilterTransformPattern, }; -use oxiri::{Iri, IriRef}; use reader::JsonReader; use crate::{ @@ -15,7 +14,10 @@ use crate::{ AnyImportExportBuilder, FormatBuilder, Parameters, StandardParameter, SupportedFormatTag, format_tag, }, - rule_model::{components::import_export::Direction, error::validation_error::ValidationError}, + rule_model::{ + components::import_export::Direction, error::validation_error::ValidationError, + translation::directive::FormatContext, + }, syntax::import_export::file_format, }; @@ -72,8 +74,7 @@ impl FormatBuilder for JsonHandler { _tag: Self::Tag, _parameters: &Parameters, direction: Direction, - _base: Option>, - _prefixes: HashMap>, + _format_context: FormatContext, ) -> Result { if matches!(direction, Direction::Export) { return Err(ValidationError::UnsupportedJsonExport); diff --git a/nemo/src/io/formats/rdf.rs b/nemo/src/io/formats/rdf.rs index b8b218ce5..a795eb3e9 100644 --- a/nemo/src/io/formats/rdf.rs +++ b/nemo/src/io/formats/rdf.rs @@ -39,6 +39,7 @@ use crate::{ rule_model::{ components::{import_export::Direction, term::value_type::ValueType}, error::validation_error::ValidationError, + translation::directive::FormatContext, }, syntax::import_export::{attribute, file_format}, }; @@ -191,14 +192,13 @@ impl FormatParameter for RdfParameter { fn is_value_valid( &self, value: AnyDataValue, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { RdfParameter::BaseParamType(base_param) => { - FormatParameter::::is_value_valid(base_param, value, base, prefixes) + FormatParameter::::is_value_valid(base_param, value, format_context) } RdfParameter::Limit => value .to_u64() @@ -228,8 +228,7 @@ impl FormatBuilder for RdfHandler { tag: Self::Tag, parameters: &Parameters, _direction: Direction, - _base: Option>, - _prefixes: HashMap>, + _format_context: FormatContext, ) -> Result { let variant = match tag { RdfTag::Rdf => { diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index b548c0868..75b00f23b 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -21,9 +21,11 @@ use crate::{ AnyImportExportBuilder, FormatParameter, Parameters, StandardParameter, SupportedFormatTag, format_parameter, format_tag, value_type_matches, }, + parser::ast::directive::{Directive::Base, base}, rule_model::{ components::{import_export::Direction, term::value_type::ValueType}, error::validation_error::ValidationError, + translation::directive::FormatContext, }, syntax::import_export::{ attribute, @@ -70,14 +72,13 @@ impl FormatParameter for SparqlParameter { fn is_value_valid( &self, value: AnyDataValue, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; match self { SparqlParameter::BaseParamType(base_param) => { - FormatParameter::::is_value_valid(base_param, value, base, prefixes) + FormatParameter::::is_value_valid(base_param, value, format_context) } SparqlParameter::Base => Ok(()), SparqlParameter::Format => DsvValueFormats::try_from(value).and(Ok(())).map_err(|_| { @@ -101,25 +102,22 @@ impl FormatParameter for SparqlParameter { let mut parser = SparqlParser::new(); - let resolved_prefixes: Vec<(String, Iri)> = prefixes - .iter() - .map(|(key, value)| { - ( - key.clone(), - Iri::from_str(&value.to_string()) - .unwrap_or_else(|_| base.clone().unwrap().resolve(value).unwrap()), - ) - }) - .collect(); - - if let Some(base) = base { - parser = parser.with_base_iri(base.to_string()).unwrap(); + if let Some(base) = format_context.base() { + parser = parser.with_base_iri(base.to_string()).map_err(|e| { + ValidationError::InvalidSparqlQuery { + query: query.clone(), + oxi_error: e.to_string(), + } + })? } - for (prefix_name, prefix_iri) in resolved_prefixes { + for (prefix_name, prefix_iri) in format_context.prefixes() { parser = parser .with_prefix(prefix_name, prefix_iri.to_string()) - .unwrap(); + .map_err(|e| ValidationError::InvalidSparqlQuery { + query: query.clone(), + oxi_error: e.to_string(), + })? } parser.parse_query(query.as_str()).and(Ok(())).map_err(|e| { @@ -172,8 +170,7 @@ impl FormatBuilder for SparqlBuilder { _tag: Self::Tag, parameters: &Parameters, _direction: Direction, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Result { let value_formats = parameters .get_optional(SparqlParameter::Format) @@ -194,29 +191,7 @@ impl FormatBuilder for SparqlBuilder { .map(|value| value.to_plain_string_unchecked()) .unwrap_or(QUERY_DEFAULT.to_string()); - let mut parser = SparqlParser::new(); - - // SparqlParser only accepts absolute (resolved) iri's - let resolved_prefixes: Vec<(String, Iri)> = prefixes - .iter() - .map(|(key, value)| { - ( - key.clone(), - Iri::from_str(&value.to_string()) - .unwrap_or_else(|_| base.clone().unwrap().resolve(value).unwrap()), - ) - }) - .collect(); - - if let Some(base) = base { - parser = parser.with_base_iri(base.to_string()).unwrap(); - } - - for (prefix_name, prefix_iri) in resolved_prefixes { - parser = parser - .with_prefix(prefix_name, prefix_iri.to_string()) - .unwrap(); - } + let parser = format_context.as_sparql_parser(); let query = parser .parse_query(query.as_str()) @@ -324,10 +299,13 @@ impl ImportHandler for SparqlHandler { mod test { use std::{collections::HashMap, str::FromStr}; - use crate::parser::{ - ParserState, - ast::{ProgramAST, directive::import::Import}, - input::ParserInput, + use crate::{ + parser::{ + ParserState, + ast::{ProgramAST, directive::import::Import}, + input::ParserInput, + }, + rule_model::translation::directive::FormatContext, }; use nom::combinator::all_consuming; use oxiri::{Iri, IriRef}; @@ -340,15 +318,16 @@ mod test { #[test] fn parse_query() { let base = Some(Iri::from_str("http://www.wikidata.org/").unwrap()); - let prefixes: HashMap> = HashMap::from([ - // PREFIX wikibase: - ( - "wikibase".to_string(), - IriRef::from_str("http://wikiba.se/ontology#").unwrap(), - ), - // PREFIX wdt: - ("wdt".to_string(), IriRef::from_str("prop/direct/").unwrap()), - ]); + + let mut format_context = FormatContext::default(); + format_context.add_base("http://www.wikidata.org/".to_string()); + // PREFIX wikibase: + format_context.add_prefix( + "wikibase".to_string(), + "http://wikiba.se/ontology#".to_string(), + ); + // PREFIX wdt: + format_context.add_prefix("wdt".to_string(), "prop/direct/".to_string()); let valid_query = AnyDataValue::new_plain_string(String::from(" PREFIX wikibase: @@ -367,15 +346,12 @@ mod test { ); let query_param = SparqlParameter::Query; - let result = query_param.is_value_valid(valid_query, base, prefixes); + let result = query_param.is_value_valid(valid_query, format_context); assert!(result.is_ok()); } #[test] fn parse_invalid_query() { - let base = None; - let prefixes = HashMap::new(); - // Invalid because no prefixes are specified let invalid_query = AnyDataValue::new_plain_string(String::from(" SELECT ?item ?itemLabel @@ -387,7 +363,7 @@ mod test { LIMIT 10") ); let query_param = SparqlParameter::Query; - let result = query_param.is_value_valid(invalid_query, base, prefixes); + let result = query_param.is_value_valid(invalid_query, FormatContext::default()); assert!(result.is_err()); } diff --git a/nemo/src/rule_model/components/import_export.rs b/nemo/src/rule_model/components/import_export.rs index fe22b2f26..3c8a29943 100644 --- a/nemo/src/rule_model/components/import_export.rs +++ b/nemo/src/rule_model/components/import_export.rs @@ -17,7 +17,7 @@ use crate::{ }, rule_model::{ components::rule::Rule, error::ValidationReport, origin::Origin, - pipeline::id::ProgramComponentId, + pipeline::id::ProgramComponentId, translation::directive::FormatContext, }, syntax::{self, import_export::attribute::QUERY}, }; @@ -79,10 +79,8 @@ pub(crate) struct ImportExportDirective { bindings: Vec, /// Sub-rules for filtered import/export filter_rules: Vec, - /// - base: Option>, - /// - prefixes: HashMap>, + /// Base IRI (if any is set) and Hashmap of any Prefixes + format_context: FormatContext, } impl std::fmt::Display for ImportExportDirective { @@ -176,8 +174,7 @@ impl ImportDirective { predicate: Tag, spec: ImportExportSpec, bindings: Vec, - base: Option>, - prefixes: HashMap>, + format_context: FormatContext, ) -> Self { Self(ImportExportDirective { origin: Origin::default(), @@ -186,8 +183,7 @@ impl ImportDirective { spec, bindings, filter_rules: Vec::new(), - base, - prefixes, + format_context, }) } @@ -387,8 +383,7 @@ impl ImportDirective { self.filter_rules(), Direction::Import, report, - self.base().clone(), - self.prefixes().clone(), + self.format_context().clone(), ) } @@ -402,18 +397,13 @@ impl ImportDirective { self.filter_rules(), Direction::Import, &mut report, - self.base().clone(), - self.prefixes().clone(), + self.format_context().clone(), ) } - /// Return the base - pub fn base(&self) -> &Option> { - &self.0.base - } - /// Return the prefixes - pub fn prefixes(&self) -> &HashMap> { - &self.0.prefixes + /// Return the FormatContext + pub fn format_context(&self) -> &FormatContext { + &self.0.format_context } /// Return the predicate. @@ -591,8 +581,7 @@ impl ExportDirective { spec, bindings, filter_rules: Vec::new(), - base: None, - prefixes: HashMap::new(), + format_context: FormatContext::default(), }) } @@ -624,8 +613,7 @@ impl ExportDirective { self.filter_rules(), Direction::Export, report, - self.base().clone(), - self.prefixes().clone(), + self.format_context().clone(), ) } @@ -639,18 +627,13 @@ impl ExportDirective { self.filter_rules(), Direction::Export, &mut report, - self.base().clone(), - self.prefixes().clone(), + self.format_context().clone(), ) } - /// Return the predicate. - pub fn base(&self) -> &Option> { - &self.0.base - } - - pub fn prefixes(&self) -> &HashMap> { - &self.0.prefixes + /// Return the FormatContext + pub fn format_context(&self) -> &FormatContext { + &self.0.format_context } /// Return the predicate. diff --git a/nemo/src/rule_model/translation/directive.rs b/nemo/src/rule_model/translation/directive.rs index d4a80a702..655f29171 100644 --- a/nemo/src/rule_model/translation/directive.rs +++ b/nemo/src/rule_model/translation/directive.rs @@ -1,6 +1,10 @@ //! This module contains functions for translating directive ast nodes. -use std::collections::hash_map::Entry; +use core::panic; +use std::collections::{HashMap, hash_map::Entry}; + +use oxiri::{Iri, IriParseError, IriRef}; +use spargebra::SparqlParser; use crate::{ parser::ast::{self}, @@ -141,3 +145,73 @@ fn handle_prefix<'a>( } } } + +/// Wrapper for IRI base and prefixes +/// Automatically attempts to resolve all relative prefixes on the base +#[derive(Clone, Debug, Default)] +pub struct FormatContext { + base: Option>, + prefixes: HashMap>, +} + +impl FormatContext { + pub fn base(&self) -> &Option> { + &self.base + } + + pub fn prefixes(&self) -> &HashMap> { + &self.prefixes + } + + /// adds a base if None was set before + /// panics if a base is already set + pub fn add_base(&mut self, base: String) { + match self.base { + None => self.base = Some(Iri::parse(base).expect("not a valid IRI")), + Some(_) => panic!("attempted to set existing base"), + } + } + + /// adds an absolute prefix + /// if the prefix given is relative attempts to resolve it on the base + /// panics if + /// - the iri is invalid + /// - the prefix cannot be resolved + /// - a relative prefix is given but no base is set + pub fn add_prefix(&mut self, prefix: String, iri: String) { + let rel_prefix = IriRef::parse(iri.clone()).expect("not a valid Iri"); + let abs_prefix; + if rel_prefix.is_absolute() { + abs_prefix = Iri::parse(iri.clone()).expect("absolute IRI is not absolute"); + } else { + if let Some(base) = &self.base { + abs_prefix = base + .resolve(&rel_prefix.clone()) + .expect("relative prefix not resolvable on base"); + } else { + panic!("attempted to resolve relative prefix without base") + } + } + + self.prefixes.insert(prefix, abs_prefix); + } + + /// + pub fn as_sparql_parser(&self) -> SparqlParser { + let mut parser = SparqlParser::new(); + + if let Some(base) = &self.base { + parser = parser + .with_base_iri(base.to_string()) + .expect("valid base is invalid"); + } + + for (prefix_name, prefix_iri) in &self.prefixes { + parser = parser + .with_prefix(prefix_name, prefix_iri.to_string()) + .expect("valid prefix is invalid"); + } + + parser + } +} diff --git a/nemo/src/rule_model/translation/directive/import_export.rs b/nemo/src/rule_model/translation/directive/import_export.rs index e23f11033..8d0be6f86 100644 --- a/nemo/src/rule_model/translation/directive/import_export.rs +++ b/nemo/src/rule_model/translation/directive/import_export.rs @@ -1,6 +1,6 @@ //! This module contains a function for handling import/export statements. -use std::str::FromStr; +use std::{mem::transmute, str::FromStr}; use oxiri::{Iri, IriRef}; @@ -22,6 +22,7 @@ use crate::{ origin::Origin, translation::{ ASTProgramTranslation, TranslationComponent, complex::infix::InfixOperation, + directive::FormatContext, }, }, }; @@ -123,19 +124,18 @@ impl TranslationComponent for ImportDirective { let bindings = import_export_bindings(translation, import.guards())?; - let base = translation - .base - .clone() - .map(|x| Iri::from_str(&x.0).unwrap()); + let mut format_context = FormatContext::default(); - let prefixes = translation - .prefix_mapping - .iter() - .map(|(key, value)| (key.clone(), IriRef::from_str(&value.0).unwrap())) - .collect(); + if let Some(base) = &translation.base { + format_context.add_base(base.0.clone()); + } + + for (prefix, iri) in &translation.prefix_mapping { + format_context.add_prefix(prefix.clone(), iri.0.clone()); + } Some(Origin::ast( - ImportDirective::new(predicate, spec, bindings, base, prefixes), + ImportDirective::new(predicate, spec, bindings, format_context), import, )) } From eba8b5685cd5c431aa575d1821e87ff1b8808ba0 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 17:55:51 +0200 Subject: [PATCH 03/19] Factor out trace handling into a module --- nemo-cli/src/main.rs | 122 ++----------------------------------- nemo-cli/src/tracing.rs | 132 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+), 116 deletions(-) create mode 100644 nemo-cli/src/tracing.rs diff --git a/nemo-cli/src/main.rs b/nemo-cli/src/main.rs index 85ddd39fc..d79f1f227 100644 --- a/nemo-cli/src/main.rs +++ b/nemo-cli/src/main.rs @@ -18,12 +18,9 @@ pub mod cli; pub mod error; +pub mod tracing; -use std::{ - fs::{File, read_to_string}, - io::Write, - io::stdout, -}; +use std::{io::Write, io::stdout}; use clap::Parser; use colored::Colorize; @@ -35,16 +32,15 @@ use nemo::{ datavalues::AnyDataValue, error::Error, execution::{ - DefaultExecutionEngine, ExecutionEngine, - execution_parameters::ExecutionParameters, + DefaultExecutionEngine, ExecutionEngine, execution_parameters::ExecutionParameters, planning::normalization::program::NormalizedProgram, - tracing::{node_query::TableEntriesForTreeNodesQuery, tree_query::TreeForTableQuery}, }, io::{ImportManager, resource_providers::ResourceProviders}, meta::timing::{TimedCode, TimedDisplay}, rule_file::RuleFile, - rule_model::components::{ComponentBehavior, fact::Fact, tag::Tag, term::Term}, + rule_model::components::{fact::Fact, tag::Tag, term::Term}, }; +use tracing::handle_tracing; fn print_facts_for_table( writer: &mut W, @@ -154,110 +150,6 @@ fn print_memory_details(engine: &DefaultExecutionEngine) { println!("\nMemory report:\n\n{}", engine.memory_usage()); } -/// Retrieve all facts that need to be traced from the cli arguments. -fn parse_trace_facts(cli: &CliApp) -> Result, Error> { - let mut facts = cli.tracing.facts.clone().unwrap_or_default(); - - if let Some(input_files) = &cli.tracing.input_file { - for input_file in input_files { - let file_content = read_to_string(input_file)?; - facts.extend(file_content.split(';').map(str::to_string)); - } - } - - Ok(facts) -} - -/// Deal with tracing -async fn handle_tracing(cli: &CliApp, engine: &mut DefaultExecutionEngine) -> Result<(), CliError> { - let tracing_facts = parse_trace_facts(cli)?; - if !tracing_facts.is_empty() { - log::info!("Starting tracing of {} facts...", tracing_facts.len()); - let mut facts = Vec::::with_capacity(tracing_facts.len()); - for fact_string in &tracing_facts { - let fact = Fact::parse(fact_string).map_err(|_| CliError::TracingInvalidFact { - fact: fact_string.clone(), - })?; - if fact.validate().is_err() { - return Err(CliError::TracingInvalidFact { - fact: fact_string.clone(), - }); - } - - facts.push(fact); - } - - let (trace, handles) = engine.trace(facts).await?; - - match &cli.tracing.output_file { - Some(output_file) => { - let filename = output_file.to_string_lossy().to_string(); - let trace_json = trace.json(&handles); - - let mut json_file = File::create(output_file)?; - if serde_json::to_writer(&mut json_file, &trace_json).is_err() { - return Err(CliError::SerializationError { filename }); - } - } - None => { - for (fact, handle) in tracing_facts.into_iter().zip(handles) { - if let Some(tree) = trace.tree(handle) { - println!("\n{}", tree.to_ascii_art()); - } else { - println!("\n{fact} was not derived"); - } - } - } - } - } - - Ok(()) -} - -async fn handle_tracing_tree( - cli: &CliApp, - engine: &mut DefaultExecutionEngine, -) -> Result<(), CliError> { - if let Some(query_file) = &cli.tracing_tree.trace_tree_json { - let query_string = read_to_string(query_file)?; - - let tree_query: TreeForTableQuery = - serde_json::from_str(&query_string).map_err(|error| { - CliError::TracingInvalidJsonInput { - error: error.to_string(), - } - })?; - - let result = engine.trace_tree(tree_query).await?; - - let json = serde_json::to_string_pretty(&result).expect("json serialization failed"); - println!("{json}"); - } - - Ok(()) -} - -async fn handle_tracing_node( - cli: &CliApp, - engine: &mut DefaultExecutionEngine, -) -> Result<(), CliError> { - if let Some(query_file) = &cli.tracing_node.trace_node_json { - let query_string = read_to_string(query_file)?; - - let node_query: TableEntriesForTreeNodesQuery = serde_json::from_str(&query_string) - .map_err(|error| CliError::TracingInvalidJsonInput { - error: error.to_string(), - })?; - - let result = engine.trace_node(&node_query).await?; - - let json = serde_json::to_string_pretty(&result).expect("json serialization failed"); - println!("{json}"); - } - - Ok(()) -} - async fn run(mut cli: CliApp) -> Result<(), CliError> { TimedCode::instance().start(); TimedCode::instance().sub("Reading & Preprocessing").start(); @@ -369,9 +261,7 @@ async fn run(mut cli: CliApp) -> Result<(), CliError> { print_memory_details(&engine); } - handle_tracing(&cli, &mut engine).await?; - handle_tracing_tree(&cli, &mut engine).await?; - handle_tracing_node(&cli, &mut engine).await + handle_tracing(&cli, &mut engine).await } #[tokio::main(flavor = "current_thread")] diff --git a/nemo-cli/src/tracing.rs b/nemo-cli/src/tracing.rs new file mode 100644 index 000000000..7f8656178 --- /dev/null +++ b/nemo-cli/src/tracing.rs @@ -0,0 +1,132 @@ +//! Code related to tracing of facts + +use std::fs::{File, read_to_string}; + +use nemo::{ + error::Error, + execution::{ + DefaultExecutionEngine, + tracing::{node_query::TableEntriesForTreeNodesQuery, tree_query::TreeForTableQuery}, + }, + rule_model::components::{ComponentBehavior, fact::Fact}, +}; + +use crate::{cli::CliApp, error::CliError}; + +/// Retrieve all facts that need to be traced from the cli arguments. +pub(crate) fn parse_trace_facts(cli: &CliApp) -> Result, Error> { + let mut facts = cli.tracing.facts.clone().unwrap_or_default(); + + if let Some(input_files) = &cli.tracing.input_file { + for input_file in input_files { + let file_content = read_to_string(input_file)?; + facts.extend(file_content.split(';').map(str::to_string)); + } + } + + Ok(facts) +} + +pub(crate) async fn handle_tracing( + cli: &CliApp, + engine: &mut DefaultExecutionEngine, +) -> Result<(), CliError> { + trace_selected_facts(cli, engine).await?; + trace_tree_query(cli, engine).await?; + trace_node_query(cli, engine).await +} + +/// Trace selected facts, if given on the command line +pub(crate) async fn trace_selected_facts( + cli: &CliApp, + engine: &mut DefaultExecutionEngine, +) -> Result<(), CliError> { + let tracing_facts = parse_trace_facts(cli)?; + if !tracing_facts.is_empty() { + log::info!("Starting tracing of {} facts...", tracing_facts.len()); + let mut facts = Vec::::with_capacity(tracing_facts.len()); + for fact_string in &tracing_facts { + let fact = Fact::parse(fact_string).map_err(|_| CliError::TracingInvalidFact { + fact: fact_string.clone(), + })?; + if fact.validate().is_err() { + return Err(CliError::TracingInvalidFact { + fact: fact_string.clone(), + }); + } + + facts.push(fact); + } + + let (trace, handles) = engine.trace(facts).await?; + + match &cli.tracing.output_file { + Some(output_file) => { + let filename = output_file.to_string_lossy().to_string(); + let trace_json = trace.json(&handles); + + let mut json_file = File::create(output_file)?; + if serde_json::to_writer(&mut json_file, &trace_json).is_err() { + return Err(CliError::SerializationError { filename }); + } + } + None => { + for (fact, handle) in tracing_facts.into_iter().zip(handles) { + if let Some(tree) = trace.tree(handle) { + println!("\n{}", tree.to_ascii_art()); + } else { + println!("\n{fact} was not derived"); + } + } + } + } + } + + Ok(()) +} + +/// Produce a trace for a tree query, if given on the command line. +pub(crate) async fn trace_tree_query( + cli: &CliApp, + engine: &mut DefaultExecutionEngine, +) -> Result<(), CliError> { + if let Some(query_file) = &cli.tracing_tree.trace_tree_json { + let query_string = read_to_string(query_file)?; + + let tree_query: TreeForTableQuery = + serde_json::from_str(&query_string).map_err(|error| { + CliError::TracingInvalidJsonInput { + error: error.to_string(), + } + })?; + + let result = engine.trace_tree(tree_query).await?; + + let json = serde_json::to_string_pretty(&result).expect("json serialization failed"); + println!("{json}"); + } + + Ok(()) +} + +/// Produce a trace for a node query, if given on the command line. +pub(crate) async fn trace_node_query( + cli: &CliApp, + engine: &mut DefaultExecutionEngine, +) -> Result<(), CliError> { + if let Some(query_file) = &cli.tracing_node.trace_node_json { + let query_string = read_to_string(query_file)?; + + let node_query: TableEntriesForTreeNodesQuery = serde_json::from_str(&query_string) + .map_err(|error| CliError::TracingInvalidJsonInput { + error: error.to_string(), + })?; + + let result = engine.trace_node(&node_query).await?; + + let json = serde_json::to_string_pretty(&result).expect("json serialization failed"); + println!("{json}"); + } + + Ok(()) +} From ee0e126398ee5871d8a4432f679c4f37533221a3 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 18:09:28 +0200 Subject: [PATCH 04/19] Factor out tracing of ground facts --- nemo-cli/src/tracing.rs | 2 +- nemo-python/src/lib.rs | 2 +- .../execution_engine/tracing/simple.rs | 39 ++++++++++++------- 3 files changed, 28 insertions(+), 15 deletions(-) diff --git a/nemo-cli/src/tracing.rs b/nemo-cli/src/tracing.rs index 7f8656178..db8a1cb81 100644 --- a/nemo-cli/src/tracing.rs +++ b/nemo-cli/src/tracing.rs @@ -58,7 +58,7 @@ pub(crate) async fn trace_selected_facts( facts.push(fact); } - let (trace, handles) = engine.trace(facts).await?; + let (trace, handles) = engine.trace_facts(facts).await?; match &cli.tracing.output_file { Some(output_file) => { diff --git a/nemo-python/src/lib.rs b/nemo-python/src/lib.rs index 82122f992..413a37cde 100644 --- a/nemo-python/src/lib.rs +++ b/nemo-python/src/lib.rs @@ -444,7 +444,7 @@ impl NemoEngine { let fact = Fact::parse(&fact_string).ok()?; fact.validate().ok()?; - let (trace, handles) = rt.block_on(self.engine.trace(vec![fact])).ok()?; + let (trace, handles) = rt.block_on(self.engine.trace_facts(vec![fact])).ok()?; let handle = *handles .first() .expect("Function trace always returns a handle for each input fact"); diff --git a/nemo/src/execution/execution_engine/tracing/simple.rs b/nemo/src/execution/execution_engine/tracing/simple.rs index 9871aada3..62e086ad6 100644 --- a/nemo/src/execution/execution_engine/tracing/simple.rs +++ b/nemo/src/execution/execution_engine/tracing/simple.rs @@ -30,12 +30,14 @@ use crate::{ pub(crate) mod storage; +const TRACING_PROGRESS_INCREMENT: usize = 500; + impl ExecutionEngine { /// Recursive part of `trace`. async fn trace_recursive( &mut self, trace: &mut ExecutionTrace, - fact: GroundAtom, + fact: &GroundAtom, program: &NormalizedProgram, ) -> Result { let trace_handle = trace.register_fact(fact.clone()); @@ -148,7 +150,7 @@ impl ExecutionEngine { let next_fact = GroundAtom::new(next_fact_predicate, next_fact_terms); let next_handle = - Box::pin(self.trace_recursive(trace, next_fact, program)).await?; + Box::pin(self.trace_recursive(trace, &next_fact, program)).await?; if trace.status(next_handle).is_success() { subtraces.push(next_handle); @@ -184,9 +186,9 @@ impl ExecutionEngine { Ok(trace_handle) } - /// Build an `ExecutionTrace` for a list of facts. - /// Also returns a list containing a `TraceFactHandle` for each fact. - pub async fn trace( + /// Build an [ExecutionTrace] for a list of [fact](Fact)s. Also + /// return a list containing the [TraceFactHandle] for each fact. + pub async fn trace_facts( &mut self, facts: Vec, ) -> Result<(ExecutionTrace, Vec), Error> { @@ -201,31 +203,42 @@ impl ExecutionEngine { let program = self.program.clone(); - let chase_facts: Vec<_> = facts + let ground_facts: Vec<_> = facts .into_iter() .filter_map(|fact| GroundAtom::normalize_fact(&fact)) .collect(); + self.trace_ground_facts(&program, &ground_facts).await + } + + /// Build an `ExecutionTrace` for a list of [ground + /// facts](GroundAtom). Also return a list with the + /// [TraceFactHandle] for each fact. + pub async fn trace_ground_facts( + &mut self, + program: &NormalizedProgram, + ground_facts: &[GroundAtom], + ) -> Result<(ExecutionTrace, Vec), Error> { let mut trace = ExecutionTrace::new(self.program_handle.clone()); let mut handles = Vec::new(); - let num_chase_facts = chase_facts.len(); + let num_ground_facts = ground_facts.len(); - for (i, chase_fact) in chase_facts.into_iter().enumerate() { - if i > 0 && i.is_multiple_of(500) { + for (i, ground_fact) in ground_facts.into_iter().enumerate() { + if i > 0 && i.is_multiple_of(TRACING_PROGRESS_INCREMENT) { log::info!( - "{i}/{num_chase_facts} facts traced. ({}%)", - i * 100 / num_chase_facts + "{i}/{num_ground_facts} facts traced. ({}%)", + i * 100 / num_ground_facts ); } handles.push( - self.trace_recursive(&mut trace, chase_fact, &program) + self.trace_recursive(&mut trace, ground_fact, &program) .await?, ); } - log::info!("{num_chase_facts}/{num_chase_facts} facts traced. (100%)"); + log::info!("{num_ground_facts}/{num_ground_facts} facts traced. (100%)"); Ok((trace, handles)) } From 4deb273840e63884b83201cd64a6d1eaa4df8809 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 19:21:31 +0200 Subject: [PATCH 05/19] Add --trace-all-idb-facts CLI option Outputs traces for all IDB facts after reasoning. Fixes #783. --- nemo-cli/src/cli.rs | 3 + nemo-cli/src/tracing.rs | 65 ++++++++++++++----- .../execution_engine/tracing/simple.rs | 56 ++++++++++++---- 3 files changed, 94 insertions(+), 30 deletions(-) diff --git a/nemo-cli/src/cli.rs b/nemo-cli/src/cli.rs index 1a73d0506..43ab95881 100644 --- a/nemo-cli/src/cli.rs +++ b/nemo-cli/src/cli.rs @@ -157,6 +157,9 @@ impl OutputArgs { /// Cli arguments related to tracing #[derive(Debug, clap::Args)] pub(crate) struct TracingArgs { + /// Trace all IDB facts + #[arg(long = "trace-all-idb-facts", group = "trace-input")] + pub(crate) trace_all_idb_facts: bool, /// Facts for which a derivation trace should be computed; /// multiple facts can be separated by a semicolon, e.g. "P(a, b);Q(c)". #[arg(long = "trace", value_delimiter = ';', group = "trace-input")] diff --git a/nemo-cli/src/tracing.rs b/nemo-cli/src/tracing.rs index db8a1cb81..7a886cc54 100644 --- a/nemo-cli/src/tracing.rs +++ b/nemo-cli/src/tracing.rs @@ -41,8 +41,36 @@ pub(crate) async fn trace_selected_facts( cli: &CliApp, engine: &mut DefaultExecutionEngine, ) -> Result<(), CliError> { - let tracing_facts = parse_trace_facts(cli)?; - if !tracing_facts.is_empty() { + let (trace, handles) = if cli.tracing.trace_all_idb_facts { + let predicates = engine + .chase_program() + .derived_predicates() + .iter() + .filter_map(|predicate| { + let count = engine + .count_facts_in_memory_for_predicate(predicate) + .unwrap_or_default(); + (count > 0).then_some((predicate, count)) + }) + .collect::>(); + let total_facts = predicates.iter().map(|(_, count)| count).sum::(); + log::info!( + "Starting tracing of {total_facts} for {} predicates", + predicates.len() + ); + + let predicates = predicates + .iter() + .map(|&(predicate, _)| predicate.clone()) + .collect::>(); + + engine.trace_predicates(&predicates).await? + } else { + let tracing_facts = parse_trace_facts(cli)?; + if tracing_facts.is_empty() { + return Ok(()); + } + log::info!("Starting tracing of {} facts...", tracing_facts.len()); let mut facts = Vec::::with_capacity(tracing_facts.len()); for fact_string in &tracing_facts { @@ -58,25 +86,26 @@ pub(crate) async fn trace_selected_facts( facts.push(fact); } - let (trace, handles) = engine.trace_facts(facts).await?; + engine.trace_facts(facts).await? + }; - match &cli.tracing.output_file { - Some(output_file) => { - let filename = output_file.to_string_lossy().to_string(); - let trace_json = trace.json(&handles); + match &cli.tracing.output_file { + Some(output_file) => { + let filename = output_file.to_string_lossy().to_string(); + let trace_json = trace.json(&handles); - let mut json_file = File::create(output_file)?; - if serde_json::to_writer(&mut json_file, &trace_json).is_err() { - return Err(CliError::SerializationError { filename }); - } + let mut json_file = File::create(output_file)?; + if serde_json::to_writer(&mut json_file, &trace_json).is_err() { + return Err(CliError::SerializationError { filename }); } - None => { - for (fact, handle) in tracing_facts.into_iter().zip(handles) { - if let Some(tree) = trace.tree(handle) { - println!("\n{}", tree.to_ascii_art()); - } else { - println!("\n{fact} was not derived"); - } + } + None => { + for handle in handles { + if let Some(tree) = trace.tree(handle) { + println!("\n{}", tree.to_ascii_art()); + } else { + let fact = trace.get_fact(handle).fact(); + println!("\n{fact} was not derived"); } } } diff --git a/nemo/src/execution/execution_engine/tracing/simple.rs b/nemo/src/execution/execution_engine/tracing/simple.rs index 62e086ad6..ff829fa85 100644 --- a/nemo/src/execution/execution_engine/tracing/simple.rs +++ b/nemo/src/execution/execution_engine/tracing/simple.rs @@ -22,6 +22,7 @@ use crate::{ components::{ ComponentBehavior, fact::Fact, + tag::Tag, term::primitive::{Primitive, ground::GroundTerm, variable::Variable}, }, substitution::Substitution, @@ -186,8 +187,8 @@ impl ExecutionEngine { Ok(trace_handle) } - /// Build an [ExecutionTrace] for a list of [fact](Fact)s. Also - /// return a list containing the [TraceFactHandle] for each fact. + /// Build an `ExecutionTrace` for a list of [fact](Fact)s. Also + /// return a list containing the `TraceFactHandle` for each fact. pub async fn trace_facts( &mut self, facts: Vec, @@ -201,25 +202,56 @@ impl ExecutionEngine { } } - let program = self.program.clone(); - let ground_facts: Vec<_> = facts .into_iter() .filter_map(|fact| GroundAtom::normalize_fact(&fact)) .collect(); + let mut trace = ExecutionTrace::new(self.program_handle.clone()); + let handles = self.trace_ground_facts(&mut trace, &ground_facts).await?; - self.trace_ground_facts(&program, &ground_facts).await + Ok((trace, handles)) + } + + /// Build an `ExecutionTrace` for a list of [predicates](Tag)s. Also + /// return a list containing the `TraceFactHandle` for each fact. + pub async fn trace_predicates( + &mut self, + predicates: impl IntoIterator, + ) -> Result<(ExecutionTrace, Vec), Error> { + let mut trace = ExecutionTrace::new(self.program_handle.clone()); + let mut handles = Vec::new(); + + for predicate in predicates { + let count = self + .count_facts_in_memory_for_predicate(&predicate) + .unwrap_or_default(); + + if count > 0 { + log::info!("Starting tracing of {count} facts for predicate {predicate}"); + + let ground_facts = self + .predicate_rows(predicate) + .await? + .expect("predicate should have facts") + .map(|values| { + GroundAtom::new(predicate.clone(), values.into_iter().map(GroundTerm::new)) + }) + .collect::>(); + handles.append(&mut self.trace_ground_facts(&mut trace, &ground_facts).await?); + } + } + + Ok((trace, handles)) } /// Build an `ExecutionTrace` for a list of [ground /// facts](GroundAtom). Also return a list with the - /// [TraceFactHandle] for each fact. - pub async fn trace_ground_facts( + /// `TraceFactHandle` for each fact. + async fn trace_ground_facts( &mut self, - program: &NormalizedProgram, + trace: &mut ExecutionTrace, ground_facts: &[GroundAtom], - ) -> Result<(ExecutionTrace, Vec), Error> { - let mut trace = ExecutionTrace::new(self.program_handle.clone()); + ) -> Result, Error> { let mut handles = Vec::new(); let num_ground_facts = ground_facts.len(); @@ -233,13 +265,13 @@ impl ExecutionEngine { } handles.push( - self.trace_recursive(&mut trace, ground_fact, &program) + self.trace_recursive(trace, ground_fact, &self.program.clone()) .await?, ); } log::info!("{num_ground_facts}/{num_ground_facts} facts traced. (100%)"); - Ok((trace, handles)) + Ok(handles) } } From 4eb855b8d6673a7d788e1ef27ad9c9816ecce1ed Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 19:26:16 +0200 Subject: [PATCH 06/19] flake.lock: Update MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Flake lock file updates: • Updated input 'crane': 'github:ipetkov/crane/dc7496d8ea6e526b1254b55d09b966e94673750f' (2026-04-19) → 'github:ipetkov/crane/edb38893982a3338972bb4a2ec7ce7c29ba10fd9' (2026-05-18) • Updated input 'nemo-web': 'github:knowsys/nemo-web/f45b5648b26baa35ac1b3a6234dd39bc48bbe2cb' (2026-04-22) → 'github:knowsys/nemo-web/c8c3b8f55a092d4046ea729b14a29f0b9f033b14' (2026-05-18) • Updated input 'nixpkgs': 'github:NixOS/nixpkgs/e07580dae39738e46609eaab8b154de2488133ce' (2026-04-19) → 'github:NixOS/nixpkgs/687f05a9184cad4eaf905c48b63649e3a86f5433' (2026-05-18) • Updated input 'rust-overlay': 'github:oxalica/rust-overlay/40e6ccc06e1245a4837cbbd6bdda64e21cc67379' (2026-04-22) → 'github:oxalica/rust-overlay/8cd592658d4448c57326aaa819e1c2f91086eb40' (2026-05-19) --- flake.lock | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/flake.lock b/flake.lock index 1d03896ab..ad3b88cdc 100644 --- a/flake.lock +++ b/flake.lock @@ -2,11 +2,11 @@ "nodes": { "crane": { "locked": { - "lastModified": 1776635034, - "narHash": "sha256-OEOJrT3ZfwbChzODfIH4GzlNTtOFuZFWPtW7jIeR8xU=", + "lastModified": 1779130139, + "narHash": "sha256-BLrtr42azquO7MdGFU5a7KiMl3YpFlTeIXqy1fT5GlQ=", "owner": "ipetkov", "repo": "crane", - "rev": "dc7496d8ea6e526b1254b55d09b966e94673750f", + "rev": "edb38893982a3338972bb4a2ec7ce7c29ba10fd9", "type": "github" }, "original": { @@ -5871,11 +5871,11 @@ ] }, "locked": { - "lastModified": 1776848421, - "narHash": "sha256-zUXgvn+CRkBitoJuFC24ZXWR5B39Wdwoxdzi+u7O4Ac=", + "lastModified": 1779107993, + "narHash": "sha256-CqFEJfxKjbN0VsmOKBN4mvnSo2tA1/VnsDhXx2v/L8Y=", "owner": "knowsys", "repo": "nemo-web", - "rev": "f45b5648b26baa35ac1b3a6234dd39bc48bbe2cb", + "rev": "c8c3b8f55a092d4046ea729b14a29f0b9f033b14", "type": "github" }, "original": { @@ -8014,11 +8014,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1776560675, - "narHash": "sha256-p68udKWWh7+V4ZPpcMDq0gTHWNZJnr4JPI+kHPPE40o=", + "lastModified": 1779102034, + "narHash": "sha256-vZJZjLo513IeI8hjzHFc6TDezUd4uCE2Eq4SNO3DNNg=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "e07580dae39738e46609eaab8b154de2488133ce", + "rev": "687f05a9184cad4eaf905c48b63649e3a86f5433", "type": "github" }, "original": { @@ -9554,11 +9554,11 @@ ] }, "locked": { - "lastModified": 1776827647, - "narHash": "sha256-sYixYhp5V8jCajO8TRorE4fzs7IkL4MZdfLTKgkPQBk=", + "lastModified": 1779160702, + "narHash": "sha256-frUihZLlBLdcFN95mq5QiQmxF2M16nxtmw1GH4rhZmg=", "owner": "oxalica", "repo": "rust-overlay", - "rev": "40e6ccc06e1245a4837cbbd6bdda64e21cc67379", + "rev": "8cd592658d4448c57326aaa819e1c2f91086eb40", "type": "github" }, "original": { From 6f7474aa5d3eba9e09becb6853843ef1a7053fc1 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 19:25:48 +0200 Subject: [PATCH 07/19] Placate clippy Signed-off-by: Maximilian Marx --- nemo-physical/src/datavalues/boolean_datavalue.rs | 4 ++-- nemo-physical/src/management/database/order.rs | 2 +- nemo-physical/src/util/mapping/ordered_choice.rs | 2 +- nemo/src/execution/execution_engine/tracing/simple.rs | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/nemo-physical/src/datavalues/boolean_datavalue.rs b/nemo-physical/src/datavalues/boolean_datavalue.rs index 759d5aac6..ea0053eaf 100644 --- a/nemo-physical/src/datavalues/boolean_datavalue.rs +++ b/nemo-physical/src/datavalues/boolean_datavalue.rs @@ -49,12 +49,12 @@ impl DataValue for BooleanDataValue { if self.0 { format!( "\"{TRUE}\"{RDF_DATATYPE_INDICATOR}<{}>", - &self.datatype_iri() + self.datatype_iri() ) } else { format!( "\"{FALSE}\"{RDF_DATATYPE_INDICATOR}<{}>", - &self.datatype_iri() + self.datatype_iri() ) } } diff --git a/nemo-physical/src/management/database/order.rs b/nemo-physical/src/management/database/order.rs index a8c950113..828e07457 100644 --- a/nemo-physical/src/management/database/order.rs +++ b/nemo-physical/src/management/database/order.rs @@ -65,7 +65,7 @@ impl OrderedReferenceManager { self.reference_map .retain(|existing_id, _| *existing_id < table_id); - for (_, map) in self.storage_map.iter_mut() { + for map in self.storage_map.values_mut() { map.retain(|_, existing_id| *existing_id < storage_id); } } diff --git a/nemo-physical/src/util/mapping/ordered_choice.rs b/nemo-physical/src/util/mapping/ordered_choice.rs index c699853b9..4586585bd 100644 --- a/nemo-physical/src/util/mapping/ordered_choice.rs +++ b/nemo-physical/src/util/mapping/ordered_choice.rs @@ -123,7 +123,7 @@ impl NatMapping for SortedChoice { fn chain_permutation(&self, permutation: &Permutation) -> Self { let mut result_map = self.map.clone(); - for (_, value) in result_map.iter_mut() { + for value in result_map.values_mut() { *value = permutation.get(*value); } diff --git a/nemo/src/execution/execution_engine/tracing/simple.rs b/nemo/src/execution/execution_engine/tracing/simple.rs index ff829fa85..e875a9988 100644 --- a/nemo/src/execution/execution_engine/tracing/simple.rs +++ b/nemo/src/execution/execution_engine/tracing/simple.rs @@ -223,7 +223,7 @@ impl ExecutionEngine { for predicate in predicates { let count = self - .count_facts_in_memory_for_predicate(&predicate) + .count_facts_in_memory_for_predicate(predicate) .unwrap_or_default(); if count > 0 { @@ -256,7 +256,7 @@ impl ExecutionEngine { let num_ground_facts = ground_facts.len(); - for (i, ground_fact) in ground_facts.into_iter().enumerate() { + for (i, ground_fact) in ground_facts.iter().enumerate() { if i > 0 && i.is_multiple_of(TRACING_PROGRESS_INCREMENT) { log::info!( "{i}/{num_ground_facts} facts traced. ({}%)", From ad58bf725de52a2400d4803e9959388c79f97144 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Tue, 19 May 2026 19:54:28 +0200 Subject: [PATCH 08/19] Expand documentation --- nemo-cli/src/tracing.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/nemo-cli/src/tracing.rs b/nemo-cli/src/tracing.rs index 7a886cc54..46b4c6252 100644 --- a/nemo-cli/src/tracing.rs +++ b/nemo-cli/src/tracing.rs @@ -27,6 +27,7 @@ pub(crate) fn parse_trace_facts(cli: &CliApp) -> Result, Error> { Ok(facts) } +/// Handle all tracing-related options specified on the command line. pub(crate) async fn handle_tracing( cli: &CliApp, engine: &mut DefaultExecutionEngine, @@ -36,7 +37,7 @@ pub(crate) async fn handle_tracing( trace_node_query(cli, engine).await } -/// Trace selected facts, if given on the command line +/// Trace selected facts, if given on the command line. pub(crate) async fn trace_selected_facts( cli: &CliApp, engine: &mut DefaultExecutionEngine, From 19bd857625dd599cf70c4b8f199d2ad89f2a8282 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Wed, 3 Jun 2026 15:03:37 +0200 Subject: [PATCH 09/19] Bump flake to nixpkgs-26.05 --- flake.lock | 17 +++++++---------- flake.nix | 2 +- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/flake.lock b/flake.lock index ad3b88cdc..d3c967879 100644 --- a/flake.lock +++ b/flake.lock @@ -8014,18 +8014,15 @@ }, "nixpkgs": { "locked": { - "lastModified": 1779102034, - "narHash": "sha256-vZJZjLo513IeI8hjzHFc6TDezUd4uCE2Eq4SNO3DNNg=", - "owner": "NixOS", - "repo": "nixpkgs", - "rev": "687f05a9184cad4eaf905c48b63649e3a86f5433", - "type": "github" + "lastModified": 1780203844, + "narHash": "sha256-0LbzRbwKOIae/V/p/wDALlUWZ5ZF41vtH05PYdKhh5I=", + "rev": "b51242d7d43689db2f3be91bd05d5b24fbb469c4", + "type": "tarball", + "url": "https://releases.nixos.org/nixos/26.05/nixos-26.05.889.b51242d7d436/nixexprs.tar.xz?lastModified=1780203844&rev=b51242d7d43689db2f3be91bd05d5b24fbb469c4" }, "original": { - "owner": "NixOS", - "ref": "nixos-25.11", - "repo": "nixpkgs", - "type": "github" + "type": "tarball", + "url": "https://channels.nixos.org/nixos-26.05/nixexprs.tar.xz" } }, "purescript-overlay": { diff --git a/flake.nix b/flake.nix index 3309da632..aa108f883 100644 --- a/flake.nix +++ b/flake.nix @@ -2,7 +2,7 @@ description = "nemo, a datalog-based rule engine for fast and scalable analytic data processing in memory"; inputs = { - nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11"; + nixpkgs.url = "https://channels.nixos.org/nixos-26.05/nixexprs.tar.xz"; rust-overlay = { url = "github:oxalica/rust-overlay"; From 73367d4cadafd08d64b47d24239b2847a5e12b48 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Wed, 3 Jun 2026 15:04:25 +0200 Subject: [PATCH 10/19] Fix python package --- flake.nix | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/flake.nix b/flake.nix index aa108f883..c2cfce366 100644 --- a/flake.nix +++ b/flake.nix @@ -391,8 +391,14 @@ nemo-wasm-web = wasmPack { target = "web"; }; nemo-wasm = self.packages.${system}.nemo-wasm-bundler; - python3 = pkgs.python3.withPackages (ps: [ self.packages.${system}.nemo-python ]); - python = python3; + python3 = + (pkgs.python3.override { + packageOverrides = pyfinal: pyprev: { + nemo-python = pyfinal.toPythonModule self.packages.${system}.nemo-python; + }; + }).withPackages + (ps: [ ps.nemo-python ]); + python = self.packages.${system}.python3; nodejs = pkgs.writeShellApplication { name = "node"; From 42f11ae822f7a7571c48456fff777fd038554db6 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Thu, 4 Jun 2026 11:37:15 +0200 Subject: [PATCH 11/19] Fix overlay --- flake.nix | 5 ----- 1 file changed, 5 deletions(-) diff --git a/flake.nix b/flake.nix index c2cfce366..4144950e1 100644 --- a/flake.nix +++ b/flake.nix @@ -665,11 +665,6 @@ nemo-wasm-node nemo-web nemo-vscode-extension - - nemo-no-incremental - nemo-only-incremental - nemo-no-merge - nemo-no-cartesian ; nodePackages = lib.makeExtensible (lib.extends pkgs.nodePackages prev.nodePackages); From 2588f8fed95e8b16f7d2782c8d111aa8ab0859ca Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Thu, 4 Jun 2026 16:57:55 +0200 Subject: [PATCH 12/19] flake.lock: Update MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Flake lock file updates: • Updated input 'nemo-vscode-extension': 'github:knowsys/nemo-vscode-extension/1df3577049b0f6f4a86da0e2ae6f289027a6ed01' (2026-06-04) → 'github:knowsys/nemo-vscode-extension/0b5d43bff010ea3c614f5d2fd4bfb9995fcbe436' (2026-06-04) • Updated input 'nemo-web': 'github:knowsys/nemo-web/8a863710cc1b959c38a1001755424fd118251cdb' (2026-06-04) → 'github:knowsys/nemo-web/dec1dea448ad8115901d18e4f7dffc568fe4b5ed' (2026-06-04) • Updated input 'nemo-web/nemo-vscode-extension': 'github:knowsys/nemo-vscode-extension/1df3577049b0f6f4a86da0e2ae6f289027a6ed01' (2026-06-04) → 'github:knowsys/nemo-vscode-extension/0b5d43bff010ea3c614f5d2fd4bfb9995fcbe436' (2026-06-04) --- flake.lock | 1841 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 1394 insertions(+), 447 deletions(-) diff --git a/flake.lock b/flake.lock index d3c967879..2eff17fac 100644 --- a/flake.lock +++ b/flake.lock @@ -2,11 +2,11 @@ "nodes": { "crane": { "locked": { - "lastModified": 1779130139, - "narHash": "sha256-BLrtr42azquO7MdGFU5a7KiMl3YpFlTeIXqy1fT5GlQ=", + "lastModified": 1780532242, + "narHash": "sha256-D+BsdpxmtUwtqGoY0IXPhHgTlmqgcZKCEo1oMyn7ep0=", "owner": "ipetkov", "repo": "crane", - "rev": "edb38893982a3338972bb4a2ec7ce7c29ba10fd9", + "rev": "59a82a1222dd3b2080b5cc52a1a2e8d5f1b77f37", "type": "github" }, "original": { @@ -46,6 +46,21 @@ } }, "crane_12": { + "locked": { + "lastModified": 1760924934, + "narHash": "sha256-tuuqY5aU7cUkR71sO2TraVKK2boYrdW3gCSXUkF4i44=", + "owner": "ipetkov", + "repo": "crane", + "rev": "c6b4d5308293d0d04fcfeee92705017537cad02f", + "type": "github" + }, + "original": { + "owner": "ipetkov", + "repo": "crane", + "type": "github" + } + }, + "crane_13": { "locked": { "lastModified": 1758758545, "narHash": "sha256-NU5WaEdfwF6i8faJ2Yh+jcK9vVFrofLcwlD/mP65JrI=", @@ -60,7 +75,7 @@ "type": "github" } }, - "crane_13": { + "crane_14": { "locked": { "lastModified": 1751562746, "narHash": "sha256-smpugNIkmDeicNz301Ll1bD7nFOty97T79m4GUMUczA=", @@ -75,7 +90,7 @@ "type": "github" } }, - "crane_14": { + "crane_15": { "locked": { "lastModified": 1751562746, "narHash": "sha256-smpugNIkmDeicNz301Ll1bD7nFOty97T79m4GUMUczA=", @@ -90,7 +105,7 @@ "type": "github" } }, - "crane_15": { + "crane_16": { "locked": { "lastModified": 1751562746, "narHash": "sha256-smpugNIkmDeicNz301Ll1bD7nFOty97T79m4GUMUczA=", @@ -105,7 +120,7 @@ "type": "github" } }, - "crane_16": { + "crane_17": { "locked": { "lastModified": 1748047550, "narHash": "sha256-t0qLLqb4C1rdtiY8IFRH5KIapTY/n3Lqt57AmxEv9mk=", @@ -120,7 +135,7 @@ "type": "github" } }, - "crane_17": { + "crane_18": { "locked": { "lastModified": 1747587869, "narHash": "sha256-Zay3WJdSvC2VQmNqWSVLBOg/1iS/0/Q0c9JOBsB+3qw=", @@ -137,11 +152,11 @@ }, "crane_2": { "locked": { - "lastModified": 1773857772, - "narHash": "sha256-5xsK26KRHf0WytBtsBnQYC/lTWDhQuT57HJ7SzuqZcM=", + "lastModified": 1779130139, + "narHash": "sha256-BLrtr42azquO7MdGFU5a7KiMl3YpFlTeIXqy1fT5GlQ=", "owner": "ipetkov", "repo": "crane", - "rev": "b556d7bbae5ff86e378451511873dfd07e4504cd", + "rev": "edb38893982a3338972bb4a2ec7ce7c29ba10fd9", "type": "github" }, "original": { @@ -182,11 +197,11 @@ }, "crane_5": { "locked": { - "lastModified": 1773189535, - "narHash": "sha256-E1G/Or6MWeP+L6mpQ0iTFLpzSzlpGrITfU2220Gq47g=", + "lastModified": 1773857772, + "narHash": "sha256-5xsK26KRHf0WytBtsBnQYC/lTWDhQuT57HJ7SzuqZcM=", "owner": "ipetkov", "repo": "crane", - "rev": "6fa2fb4cf4a89ba49fc9dd5a3eb6cde99d388269", + "rev": "b556d7bbae5ff86e378451511873dfd07e4504cd", "type": "github" }, "original": { @@ -212,11 +227,11 @@ }, "crane_7": { "locked": { - "lastModified": 1762538466, - "narHash": "sha256-8zrIPl6J+wLm9MH5ksHcW7BUHo7jSNOu0/hA0ohOOaM=", + "lastModified": 1773189535, + "narHash": "sha256-E1G/Or6MWeP+L6mpQ0iTFLpzSzlpGrITfU2220Gq47g=", "owner": "ipetkov", "repo": "crane", - "rev": "0cea393fffb39575c46b7a0318386467272182fe", + "rev": "6fa2fb4cf4a89ba49fc9dd5a3eb6cde99d388269", "type": "github" }, "original": { @@ -242,11 +257,11 @@ }, "crane_9": { "locked": { - "lastModified": 1760924934, - "narHash": "sha256-tuuqY5aU7cUkR71sO2TraVKK2boYrdW3gCSXUkF4i44=", + "lastModified": 1762538466, + "narHash": "sha256-8zrIPl6J+wLm9MH5ksHcW7BUHo7jSNOu0/hA0ohOOaM=", "owner": "ipetkov", "repo": "crane", - "rev": "c6b4d5308293d0d04fcfeee92705017537cad02f", + "rev": "0cea393fffb39575c46b7a0318386467272182fe", "type": "github" }, "original": { @@ -264,11 +279,11 @@ "pyproject-nix": "pyproject-nix" }, "locked": { - "lastModified": 1765953015, - "narHash": "sha256-5FBZbbWR1Csp3Y2icfRkxMJw/a/5FGg8hCXej2//bbI=", + "lastModified": 1779999259, + "narHash": "sha256-aLAG+TG7stjp0AOI2uvn4agxrrws2Q+fXMDS8ZuHYmo=", "owner": "nix-community", "repo": "dream2nix", - "rev": "69eb01fa0995e1e90add49d8ca5bcba213b0416f", + "rev": "dd8a3ebbbfcfafc139dba1323a6c443ec034c9f5", "type": "github" }, "original": { @@ -436,11 +451,11 @@ "pyproject-nix": "pyproject-nix_13" }, "locked": { - "lastModified": 1752547840, - "narHash": "sha256-T6wYez5urMcY8oUetwOIqPcqj77Ey3qka7wQsi6YCd4=", + "lastModified": 1754978539, + "narHash": "sha256-nrDovydywSKRbWim9Ynmgj8SBm8LK3DI2WuhIqzOHYI=", "owner": "nix-community", "repo": "dream2nix", - "rev": "667ba5ee25c95cf63ace92307db270e235dce66e", + "rev": "fbec3263cb4895ac86ee9506cdc4e6919a1a2214", "type": "github" }, "original": { @@ -586,11 +601,11 @@ "pyproject-nix": "pyproject-nix_16" }, "locked": { - "lastModified": 1747658429, - "narHash": "sha256-qZWuEdxmPx818qR61t3mMozJOvZSmTRUDPU4L3JeGgE=", + "lastModified": 1752547840, + "narHash": "sha256-T6wYez5urMcY8oUetwOIqPcqj77Ey3qka7wQsi6YCd4=", "owner": "nix-community", "repo": "dream2nix", - "rev": "6fd6d9188f32efd1e1656b3c3e63a67f9df7b636", + "rev": "667ba5ee25c95cf63ace92307db270e235dce66e", "type": "github" }, "original": { @@ -653,6 +668,62 @@ "type": "github" } }, + "dream2nix_18": { + "inputs": { + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ], + "purescript-overlay": "purescript-overlay_18", + "pyproject-nix": "pyproject-nix_18" + }, + "locked": { + "lastModified": 1747658429, + "narHash": "sha256-qZWuEdxmPx818qR61t3mMozJOvZSmTRUDPU4L3JeGgE=", + "owner": "nix-community", + "repo": "dream2nix", + "rev": "6fd6d9188f32efd1e1656b3c3e63a67f9df7b636", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "dream2nix", + "type": "github" + } + }, "dream2nix_2": { "inputs": { "nixpkgs": [ @@ -814,11 +885,11 @@ "pyproject-nix": "pyproject-nix_7" }, "locked": { - "lastModified": 1763413832, - "narHash": "sha256-dkqBwDXiv8MPoFyIvOuC4bVubAP+TlVZUkVMB78TTSg=", + "lastModified": 1765953015, + "narHash": "sha256-5FBZbbWR1Csp3Y2icfRkxMJw/a/5FGg8hCXej2//bbI=", "owner": "nix-community", "repo": "dream2nix", - "rev": "5658fba3a0b6b7d5cb0460b949651f64f644a743", + "rev": "69eb01fa0995e1e90add49d8ca5bcba213b0416f", "type": "github" }, "original": { @@ -888,11 +959,11 @@ "pyproject-nix": "pyproject-nix_9" }, "locked": { - "lastModified": 1754978539, - "narHash": "sha256-nrDovydywSKRbWim9Ynmgj8SBm8LK3DI2WuhIqzOHYI=", + "lastModified": 1763413832, + "narHash": "sha256-dkqBwDXiv8MPoFyIvOuC4bVubAP+TlVZUkVMB78TTSg=", "owner": "nix-community", "repo": "dream2nix", - "rev": "fbec3263cb4895ac86ee9506cdc4e6919a1a2214", + "rev": "5658fba3a0b6b7d5cb0460b949651f64f644a743", "type": "github" }, "original": { @@ -1045,6 +1116,22 @@ "type": "github" } }, + "flake-compat_18": { + "flake": false, + "locked": { + "lastModified": 1696426674, + "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", + "type": "github" + }, + "original": { + "owner": "edolstra", + "repo": "flake-compat", + "type": "github" + } + }, "flake-compat_2": { "flake": false, "locked": { @@ -1197,19 +1284,19 @@ "dream2nix": "dream2nix_2", "nemo-doc": "nemo-doc_2", "nemo-vscode-extension": "nemo-vscode-extension_2", - "nemo-web": "nemo-web_16", + "nemo-web": "nemo-web_17", "nixpkgs": [ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_17" + "rust-overlay": "rust-overlay_18" }, "locked": { - "lastModified": 1774047520, - "narHash": "sha256-sQR9GC+mvywdSLTlIcvvm6Z/eixQ3p0/s4ama73UM00=", + "lastModified": 1779263830, + "narHash": "sha256-+sCGcgA0dRilDEKe/Xn9XgSbBROWWlXuqOl3Vbqy6dk=", "owner": "knowsys", "repo": "nemo", - "rev": "ad95cd43c0ace02ce7dcd372d11e6c143bbfd470", + "rev": "6dba2d592afab51b1f0889602c7f8aa0e31e931a", "type": "github" }, "original": { @@ -1486,11 +1573,11 @@ ] }, "locked": { - "lastModified": 1756902760, - "narHash": "sha256-ZqiyqkNf3oKdz/fjoD2q8y/jsKSNunLtREudX2qNRl4=", + "lastModified": 1761030255, + "narHash": "sha256-Y7swuWmT5mvTbqaHSPBREOR5gVp0UoNLtJMpaHl+5Vw=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "8797365c8fe842f5a21256b59d8aaa76c87cf6a0", + "rev": "4abbf81fa852f220e5d29de99cfd91d17ff38dea", "type": "github" }, "original": { @@ -1584,11 +1671,11 @@ ] }, "locked": { - "lastModified": 1752606379, - "narHash": "sha256-JZwtVHKS93/fTHCzijpit+bI6B21n0Aag5vkSqa25JM=", + "lastModified": 1756902760, + "narHash": "sha256-ZqiyqkNf3oKdz/fjoD2q8y/jsKSNunLtREudX2qNRl4=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "499f3c124cb2e34754d3de4eb4011db172d57733", + "rev": "8797365c8fe842f5a21256b59d8aaa76c87cf6a0", "type": "github" }, "original": { @@ -1688,11 +1775,11 @@ ] }, "locked": { - "lastModified": 1747815494, - "narHash": "sha256-HS5ZaTKly8aqck7/XoFX7orkOvwJcU9V1DJ84QsOSy4=", + "lastModified": 1752606379, + "narHash": "sha256-JZwtVHKS93/fTHCzijpit+bI6B21n0Aag5vkSqa25JM=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "8635cf463bd257cf475e4df8bc87741d51ccf0a9", + "rev": "499f3c124cb2e34754d3de4eb4011db172d57733", "type": "github" }, "original": { @@ -2036,11 +2123,11 @@ ] }, "locked": { - "lastModified": 1747305769, - "narHash": "sha256-89hPChBD7BHVnKWcZyUsVRvbXkIykAYC/xHvaGX/7nI=", + "lastModified": 1747815494, + "narHash": "sha256-HS5ZaTKly8aqck7/XoFX7orkOvwJcU9V1DJ84QsOSy4=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "1a75e8b66f500978be7adefc140f74cf7a29e068", + "rev": "8635cf463bd257cf475e4df8bc87741d51ccf0a9", "type": "github" }, "original": { @@ -2049,102 +2136,35 @@ "type": "github" } }, - "nemo-doc_2": { + "nemo-doc_18": { "inputs": { "dream2nix": [ "nemo-vscode-extension", "nemo", - "dream2nix" - ], - "nixpkgs": [ "nemo-vscode-extension", "nemo", - "nixpkgs" - ] - }, - "locked": { - "lastModified": 1774035470, - "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", - "owner": "knowsys", - "repo": "nemo-doc", - "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", - "type": "github" - }, - "original": { - "owner": "knowsys", - "repo": "nemo-doc", - "type": "github" - } - }, - "nemo-doc_3": { - "inputs": { - "dream2nix": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", - "dream2nix" - ], - "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", - "nixpkgs" - ] - }, - "locked": { - "lastModified": 1774035470, - "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", - "owner": "knowsys", - "repo": "nemo-doc", - "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", - "type": "github" - }, - "original": { - "owner": "knowsys", - "repo": "nemo-doc", - "type": "github" - } - }, - "nemo-doc_4": { - "inputs": { - "dream2nix": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", - "dream2nix" - ], - "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", - "nixpkgs" - ] - }, - "locked": { - "lastModified": 1774035470, - "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", - "owner": "knowsys", - "repo": "nemo-doc", - "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", - "type": "github" - }, - "original": { - "owner": "knowsys", - "repo": "nemo-doc", - "type": "github" - } - }, - "nemo-doc_5": { - "inputs": { - "dream2nix": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -2164,15 +2184,78 @@ "nemo", "nemo-vscode-extension", "nemo", - "nixpkgs" - ] - }, - "locked": { - "lastModified": 1773786552, - "narHash": "sha256-ZP/zIRl2KFVNMoZPspjpk9RvcCxvDxqnyr1yEfXCJIM=", - "owner": "knowsys", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ], + "utils": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "utils" + ] + }, + "locked": { + "lastModified": 1747305769, + "narHash": "sha256-89hPChBD7BHVnKWcZyUsVRvbXkIykAYC/xHvaGX/7nI=", + "owner": "knowsys", "repo": "nemo-doc", - "rev": "a331159c2e6f83775ccae0459c7debd48b4d63dc", + "rev": "1a75e8b66f500978be7adefc140f74cf7a29e068", "type": "github" }, "original": { @@ -2181,13 +2264,67 @@ "type": "github" } }, - "nemo-doc_6": { + "nemo-doc_2": { + "inputs": { + "dream2nix": [ + "nemo-vscode-extension", + "nemo", + "dream2nix" + ], + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1774035470, + "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", + "owner": "knowsys", + "repo": "nemo-doc", + "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-doc", + "type": "github" + } + }, + "nemo-doc_3": { "inputs": { "dream2nix": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", + "dream2nix" + ], + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1774035470, + "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", + "owner": "knowsys", + "repo": "nemo-doc", + "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-doc", + "type": "github" + } + }, + "nemo-doc_4": { + "inputs": { + "dream2nix": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -2199,6 +2336,41 @@ "nixpkgs": [ "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1774035470, + "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", + "owner": "knowsys", + "repo": "nemo-doc", + "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-doc", + "type": "github" + } + }, + "nemo-doc_5": { + "inputs": { + "dream2nix": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix" + ], + "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -2208,8 +2380,38 @@ "nemo-vscode-extension", "nemo", "nixpkgs" + ] + }, + "locked": { + "lastModified": 1774035470, + "narHash": "sha256-VvwzbZGRqHwROQmNeToMM2QKf7HOXRvh0VkRB2iAObo=", + "owner": "knowsys", + "repo": "nemo-doc", + "rev": "a2e1704f044e66ff4c013071c7c9f14d37c635d0", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-doc", + "type": "github" + } + }, + "nemo-doc_6": { + "inputs": { + "dream2nix": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix" ], - "utils": [ + "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -2220,16 +2422,15 @@ "nemo", "nemo-vscode-extension", "nemo", - "nemo-web", - "utils" + "nixpkgs" ] }, "locked": { - "lastModified": 1761217151, - "narHash": "sha256-/UZUAC7fPzwm6XLQ6r9/IOQ/FaR5wse9bY0o3tQLjws=", + "lastModified": 1773786552, + "narHash": "sha256-ZP/zIRl2KFVNMoZPspjpk9RvcCxvDxqnyr1yEfXCJIM=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "8e44e654a311425085de7e92c16e67a28659846e", + "rev": "a331159c2e6f83775ccae0459c7debd48b4d63dc", "type": "github" }, "original": { @@ -2283,6 +2484,7 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-web", "utils" ] }, @@ -2429,11 +2631,11 @@ ] }, "locked": { - "lastModified": 1761030255, - "narHash": "sha256-Y7swuWmT5mvTbqaHSPBREOR5gVp0UoNLtJMpaHl+5Vw=", + "lastModified": 1761217151, + "narHash": "sha256-/UZUAC7fPzwm6XLQ6r9/IOQ/FaR5wse9bY0o3tQLjws=", "owner": "knowsys", "repo": "nemo-doc", - "rev": "4abbf81fa852f220e5d29de99cfd91d17ff38dea", + "rev": "8e44e654a311425085de7e92c16e67a28659846e", "type": "github" }, "original": { @@ -2453,11 +2655,11 @@ ] }, "locked": { - "lastModified": 1774047664, - "narHash": "sha256-szcUmET4c5PxMlal0xGGLcNWV/enSPxyojhRImlKaWo=", + "lastModified": 1780580537, + "narHash": "sha256-TAS5z9fts3kCQOtwhTZCw3s9PHq0T6hmgoY1tMf3ACs=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "dc20c51ba99a208a40200ca7a885ce82b3411775", + "rev": "0b5d43bff010ea3c614f5d2fd4bfb9995fcbe436", "type": "github" }, "original": { @@ -2534,11 +2736,11 @@ ] }, "locked": { - "lastModified": 1761041597, - "narHash": "sha256-npEyTMgnmJTZM+lpLWdTcMmi/akyB51tcc0mG/8r7wg=", + "lastModified": 1761172214, + "narHash": "sha256-/1QJgvcWwE5Mux+GsNA3VL9WGAwk0Pbop8gZHrAz+uc=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "6f578f30398b41e0fe0476a68acbb2d4ae15e644", + "rev": "b4cfccacc02c6287e8db8a413f9641aa7781371f", "type": "github" }, "original": { @@ -2621,11 +2823,11 @@ ] }, "locked": { - "lastModified": 1761038594, - "narHash": "sha256-KmoDTuDkn+0pSFi6h7ZoUK/gl5+UfYb06elgbaB3BDs=", + "lastModified": 1761041597, + "narHash": "sha256-npEyTMgnmJTZM+lpLWdTcMmi/akyB51tcc0mG/8r7wg=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "0d3cfa4ed924807c828c0ec7dc630696fd5656e4", + "rev": "6f578f30398b41e0fe0476a68acbb2d4ae15e644", "type": "github" }, "original": { @@ -2714,11 +2916,11 @@ ] }, "locked": { - "lastModified": 1758632847, - "narHash": "sha256-/BJTeCsBMx20S+N+V4aOd1O/LlKhr8BzpXuY6lfoTfs=", + "lastModified": 1761038594, + "narHash": "sha256-KmoDTuDkn+0pSFi6h7ZoUK/gl5+UfYb06elgbaB3BDs=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "3f4a199b334eafc61ac26e5e423187ada00887bf", + "rev": "0d3cfa4ed924807c828c0ec7dc630696fd5656e4", "type": "github" }, "original": { @@ -2813,11 +3015,11 @@ ] }, "locked": { - "lastModified": 1752608788, - "narHash": "sha256-rmiSN6V1S4Sey9a8ujyF/DmlK5MIAb0AhwhzPaX79AY=", + "lastModified": 1758632847, + "narHash": "sha256-/BJTeCsBMx20S+N+V4aOd1O/LlKhr8BzpXuY6lfoTfs=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "a5781ef9f270709242ae5db45cfa241c703e1bc1", + "rev": "3f4a199b334eafc61ac26e5e423187ada00887bf", "type": "github" }, "original": { @@ -2918,11 +3120,11 @@ ] }, "locked": { - "lastModified": 1752598510, - "narHash": "sha256-9DTIctvwNsrgJ3odNiqX7Jnq6AB250yahtMKo+RBrps=", + "lastModified": 1752608788, + "narHash": "sha256-rmiSN6V1S4Sey9a8ujyF/DmlK5MIAb0AhwhzPaX79AY=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "613f2f229e6300b1146428099d047d725931f59e", + "rev": "a5781ef9f270709242ae5db45cfa241c703e1bc1", "type": "github" }, "original": { @@ -3029,11 +3231,11 @@ ] }, "locked": { - "lastModified": 1748474348, - "narHash": "sha256-LnRs9SqiFUTr5aDPVKdSPSiWDxcTqSE73z4GkH4EXcI=", + "lastModified": 1752598510, + "narHash": "sha256-9DTIctvwNsrgJ3odNiqX7Jnq6AB250yahtMKo+RBrps=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "7c28283cc646fcde2f9cde86880baf4404348c8b", + "rev": "613f2f229e6300b1146428099d047d725931f59e", "type": "github" }, "original": { @@ -3146,11 +3348,11 @@ ] }, "locked": { - "lastModified": 1748355656, - "narHash": "sha256-YN/hBnywEvoCSOg5N1Wz6WNV08H1/pJNFcvnbcA5fVw=", + "lastModified": 1748474348, + "narHash": "sha256-LnRs9SqiFUTr5aDPVKdSPSiWDxcTqSE73z4GkH4EXcI=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "cdfee81fe495586d68110ed555c11885d7f939b7", + "rev": "7c28283cc646fcde2f9cde86880baf4404348c8b", "type": "github" }, "original": { @@ -3269,11 +3471,11 @@ ] }, "locked": { - "lastModified": 1738170133, - "narHash": "sha256-O7XgGgxrhg5j2p8KgHa88yWozJcO6sIdCEN1U8eAMWA=", + "lastModified": 1748355656, + "narHash": "sha256-YN/hBnywEvoCSOg5N1Wz6WNV08H1/pJNFcvnbcA5fVw=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "83580d47218b2e6d3ea30280d0004aa7ce670662", + "rev": "cdfee81fe495586d68110ed555c11885d7f939b7", "type": "github" }, "original": { @@ -3287,40 +3489,6 @@ "dream2nix": [ "nemo-vscode-extension", "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-web", - "dream2nix" - ], - "nemo": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -3353,9 +3521,9 @@ "nemo", "nemo-vscode-extension", "nemo", - "nemo-web", - "nemo" + "dream2nix" ], + "nemo": "nemo_18", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -3389,7 +3557,8 @@ "nemo", "nemo-vscode-extension", "nemo", - "nemo-web", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -3425,7 +3594,8 @@ "nemo", "nemo-vscode-extension", "nemo", - "nemo-web", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -3476,6 +3646,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -3510,6 +3684,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -3544,6 +3722,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -3578,16 +3760,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1748355656, - "narHash": "sha256-YN/hBnywEvoCSOg5N1Wz6WNV08H1/pJNFcvnbcA5fVw=", + "lastModified": 1738170133, + "narHash": "sha256-O7XgGgxrhg5j2p8KgHa88yWozJcO6sIdCEN1U8eAMWA=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "cdfee81fe495586d68110ed555c11885d7f939b7", + "rev": "83580d47218b2e6d3ea30280d0004aa7ce670662", "type": "github" }, "original": { @@ -3611,11 +3797,11 @@ ] }, "locked": { - "lastModified": 1774036016, - "narHash": "sha256-xsp9y9ADdBrkDaADwB+m+Zh+uVvma43Av65QMpsV39A=", + "lastModified": 1774047664, + "narHash": "sha256-szcUmET4c5PxMlal0xGGLcNWV/enSPxyojhRImlKaWo=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "81e400902309c9ad09dd2ae1b023d2cfe7bc3b4c", + "rev": "dc20c51ba99a208a40200ca7a885ce82b3411775", "type": "github" }, "original": { @@ -3655,6 +3841,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -3687,6 +3877,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -3719,6 +3913,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -3751,16 +3949,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1748474348, - "narHash": "sha256-LnRs9SqiFUTr5aDPVKdSPSiWDxcTqSE73z4GkH4EXcI=", + "lastModified": 1748355656, + "narHash": "sha256-YN/hBnywEvoCSOg5N1Wz6WNV08H1/pJNFcvnbcA5fVw=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "7c28283cc646fcde2f9cde86880baf4404348c8b", + "rev": "cdfee81fe495586d68110ed555c11885d7f939b7", "type": "github" }, "original": { @@ -3798,6 +4000,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -3828,6 +4034,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -3858,6 +4068,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -3888,16 +4102,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1752598510, - "narHash": "sha256-9DTIctvwNsrgJ3odNiqX7Jnq6AB250yahtMKo+RBrps=", + "lastModified": 1748474348, + "narHash": "sha256-LnRs9SqiFUTr5aDPVKdSPSiWDxcTqSE73z4GkH4EXcI=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "613f2f229e6300b1146428099d047d725931f59e", + "rev": "7c28283cc646fcde2f9cde86880baf4404348c8b", "type": "github" }, "original": { @@ -3933,6 +4151,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -3961,6 +4183,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -3989,6 +4215,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4017,16 +4247,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1752608788, - "narHash": "sha256-rmiSN6V1S4Sey9a8ujyF/DmlK5MIAb0AhwhzPaX79AY=", + "lastModified": 1752598510, + "narHash": "sha256-9DTIctvwNsrgJ3odNiqX7Jnq6AB250yahtMKo+RBrps=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "a5781ef9f270709242ae5db45cfa241c703e1bc1", + "rev": "613f2f229e6300b1146428099d047d725931f59e", "type": "github" }, "original": { @@ -4060,6 +4294,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4086,6 +4324,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4112,6 +4354,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4138,16 +4384,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1752613317, - "narHash": "sha256-SPS/iE8RdqmlWeREDa9/k2dgziiaAJU3kDknuHYdGZk=", + "lastModified": 1752608788, + "narHash": "sha256-rmiSN6V1S4Sey9a8ujyF/DmlK5MIAb0AhwhzPaX79AY=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "3cf4f338c86d29667bda2f79f2cc7a040978f9c2", + "rev": "a5781ef9f270709242ae5db45cfa241c703e1bc1", "type": "github" }, "original": { @@ -4179,6 +4429,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4203,6 +4457,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4227,6 +4485,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4251,16 +4513,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1761038594, - "narHash": "sha256-KmoDTuDkn+0pSFi6h7ZoUK/gl5+UfYb06elgbaB3BDs=", + "lastModified": 1752613317, + "narHash": "sha256-SPS/iE8RdqmlWeREDa9/k2dgziiaAJU3kDknuHYdGZk=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "0d3cfa4ed924807c828c0ec7dc630696fd5656e4", + "rev": "3cf4f338c86d29667bda2f79f2cc7a040978f9c2", "type": "github" }, "original": { @@ -4290,6 +4556,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4312,6 +4582,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4334,6 +4608,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4356,16 +4634,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1761041597, - "narHash": "sha256-npEyTMgnmJTZM+lpLWdTcMmi/akyB51tcc0mG/8r7wg=", + "lastModified": 1761038594, + "narHash": "sha256-KmoDTuDkn+0pSFi6h7ZoUK/gl5+UfYb06elgbaB3BDs=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "6f578f30398b41e0fe0476a68acbb2d4ae15e644", + "rev": "0d3cfa4ed924807c828c0ec7dc630696fd5656e4", "type": "github" }, "original": { @@ -4393,6 +4675,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4413,6 +4699,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4433,6 +4723,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4453,16 +4747,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1761172214, - "narHash": "sha256-/1QJgvcWwE5Mux+GsNA3VL9WGAwk0Pbop8gZHrAz+uc=", + "lastModified": 1761041597, + "narHash": "sha256-npEyTMgnmJTZM+lpLWdTcMmi/akyB51tcc0mG/8r7wg=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "b4cfccacc02c6287e8db8a413f9641aa7781371f", + "rev": "6f578f30398b41e0fe0476a68acbb2d4ae15e644", "type": "github" }, "original": { @@ -4488,6 +4786,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4506,6 +4808,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4524,6 +4830,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4542,6 +4852,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] @@ -4575,6 +4889,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4591,6 +4909,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4607,7 +4929,11 @@ "nemo", "nemo-vscode-extension", "nemo", - "nemo-web", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-web", "nixpkgs" ], "utils": [ @@ -4623,16 +4949,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1763463589, - "narHash": "sha256-EFT/kdptNvv66RH27XWEB0nUvIzlpsQJAI8uaLsn+C0=", + "lastModified": 1761172214, + "narHash": "sha256-/1QJgvcWwE5Mux+GsNA3VL9WGAwk0Pbop8gZHrAz+uc=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "0c5cab6dc126688ae1fccfa3be0f62f2c1bf56a0", + "rev": "b4cfccacc02c6287e8db8a413f9641aa7781371f", "type": "github" }, "original": { @@ -4654,6 +4984,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4668,6 +5002,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4682,6 +5020,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ], @@ -4696,16 +5038,20 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "utils" ] }, "locked": { - "lastModified": 1763463908, - "narHash": "sha256-wxGJ4hmVxB7D3VnMBYAWSlAGrj7p7tx+p1WxRCtoLq8=", + "lastModified": 1763463589, + "narHash": "sha256-EFT/kdptNvv66RH27XWEB0nUvIzlpsQJAI8uaLsn+C0=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "98c4cf12bdbb5e6b5fffa0aa95d762bdbb70ad27", + "rev": "0c5cab6dc126688ae1fccfa3be0f62f2c1bf56a0", "type": "github" }, "original": { @@ -4733,11 +5079,11 @@ ] }, "locked": { - "lastModified": 1774035774, - "narHash": "sha256-JJ680tC+TYj4rPVasnzgve3SstvHtZRHaQhsw2rDmco=", + "lastModified": 1774036016, + "narHash": "sha256-xsp9y9ADdBrkDaADwB+m+Zh+uVvma43Av65QMpsV39A=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "f89332f1c2e74514ab90b127ce27d28ac8231803", + "rev": "81e400902309c9ad09dd2ae1b023d2cfe7bc3b4c", "type": "github" }, "original": { @@ -4757,6 +5103,10 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4769,10 +5119,93 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-web", + "nixpkgs" + ], + "utils": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-web", + "utils" + ] + }, + "locked": { + "lastModified": 1763463908, + "narHash": "sha256-wxGJ4hmVxB7D3VnMBYAWSlAGrj7p7tx+p1WxRCtoLq8=", + "owner": "knowsys", + "repo": "nemo-vscode-extension", + "rev": "98c4cf12bdbb5e6b5fffa0aa95d762bdbb70ad27", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-vscode-extension", + "type": "github" + } + }, + "nemo-vscode-extension_31": { + "inputs": { + "dream2nix": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-web", + "dream2nix" + ], + "nemo": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-web", + "nemo" + ], + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -4799,7 +5232,7 @@ "type": "github" } }, - "nemo-vscode-extension_31": { + "nemo-vscode-extension_32": { "inputs": { "dream2nix": [ "nemo-vscode-extension", @@ -4808,6 +5241,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4818,6 +5253,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4828,6 +5265,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ] @@ -4846,13 +5285,15 @@ "type": "github" } }, - "nemo-vscode-extension_32": { + "nemo-vscode-extension_33": { "inputs": { "dream2nix": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], @@ -4861,6 +5302,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], @@ -4869,6 +5312,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ] @@ -4887,21 +5332,27 @@ "type": "github" } }, - "nemo-vscode-extension_33": { + "nemo-vscode-extension_34": { "inputs": { "dream2nix": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-web", "dream2nix" ], "nemo": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-web", "nemo" ], "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-web", @@ -4922,17 +5373,23 @@ "type": "github" } }, - "nemo-vscode-extension_34": { + "nemo-vscode-extension_35": { "inputs": { "dream2nix": [ + "nemo-vscode-extension", + "nemo", "nemo-web", "dream2nix" ], "nemo": [ + "nemo-vscode-extension", + "nemo", "nemo-web", "nemo" ], "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nemo-web", "nixpkgs" ] @@ -4951,6 +5408,35 @@ "type": "github" } }, + "nemo-vscode-extension_36": { + "inputs": { + "dream2nix": [ + "nemo-web", + "dream2nix" + ], + "nemo": [ + "nemo-web", + "nemo" + ], + "nixpkgs": [ + "nemo-web", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1780580537, + "narHash": "sha256-TAS5z9fts3kCQOtwhTZCw3s9PHq0T6hmgoY1tMf3ACs=", + "owner": "knowsys", + "repo": "nemo-vscode-extension", + "rev": "0b5d43bff010ea3c614f5d2fd4bfb9995fcbe436", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-vscode-extension", + "type": "github" + } + }, "nemo-vscode-extension_4": { "inputs": { "dream2nix": [ @@ -4974,11 +5460,11 @@ ] }, "locked": { - "lastModified": 1774035610, - "narHash": "sha256-j5mgLLpXSYIhFgpgn3eLIlwBTPEiI79kKQizVLsqH2E=", + "lastModified": 1774035774, + "narHash": "sha256-JJ680tC+TYj4rPVasnzgve3SstvHtZRHaQhsw2rDmco=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "6a99acb6a45d15c5939ecf5fdd58b9e68c318320", + "rev": "f89332f1c2e74514ab90b127ce27d28ac8231803", "type": "github" }, "original": { @@ -5014,11 +5500,11 @@ ] }, "locked": { - "lastModified": 1773778782, - "narHash": "sha256-ik5kOIdq7vXM49/eSQxzG7ri8ngDBYxQDQ+rnrXp9Js=", + "lastModified": 1774035610, + "narHash": "sha256-j5mgLLpXSYIhFgpgn3eLIlwBTPEiI79kKQizVLsqH2E=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "02e58297e53c0baf08357e473fa5bfbd415a2adb", + "rev": "6a99acb6a45d15c5939ecf5fdd58b9e68c318320", "type": "github" }, "original": { @@ -5055,28 +5541,14 @@ "nemo-vscode-extension", "nemo", "nixpkgs" - ], - "utils": [ - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-web", - "utils" ] }, "locked": { - "lastModified": 1763463908, - "narHash": "sha256-wxGJ4hmVxB7D3VnMBYAWSlAGrj7p7tx+p1WxRCtoLq8=", + "lastModified": 1773778782, + "narHash": "sha256-ik5kOIdq7vXM49/eSQxzG7ri8ngDBYxQDQ+rnrXp9Js=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "98c4cf12bdbb5e6b5fffa0aa95d762bdbb70ad27", + "rev": "02e58297e53c0baf08357e473fa5bfbd415a2adb", "type": "github" }, "original": { @@ -5131,15 +5603,16 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-web", "utils" ] }, "locked": { - "lastModified": 1763463589, - "narHash": "sha256-EFT/kdptNvv66RH27XWEB0nUvIzlpsQJAI8uaLsn+C0=", + "lastModified": 1763463908, + "narHash": "sha256-wxGJ4hmVxB7D3VnMBYAWSlAGrj7p7tx+p1WxRCtoLq8=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "0c5cab6dc126688ae1fccfa3be0f62f2c1bf56a0", + "rev": "98c4cf12bdbb5e6b5fffa0aa95d762bdbb70ad27", "type": "github" }, "original": { @@ -5204,11 +5677,11 @@ ] }, "locked": { - "lastModified": 1761173395, - "narHash": "sha256-+XXPGDE52cZbHf9iDERDl1Fk2/NCFJcc22eoYCRiDw0=", + "lastModified": 1763463589, + "narHash": "sha256-EFT/kdptNvv66RH27XWEB0nUvIzlpsQJAI8uaLsn+C0=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "dfc37af5cc408f235e3283792d23ab80525d4ccc", + "rev": "0c5cab6dc126688ae1fccfa3be0f62f2c1bf56a0", "type": "github" }, "original": { @@ -5279,11 +5752,11 @@ ] }, "locked": { - "lastModified": 1761172214, - "narHash": "sha256-/1QJgvcWwE5Mux+GsNA3VL9WGAwk0Pbop8gZHrAz+uc=", + "lastModified": 1761173395, + "narHash": "sha256-+XXPGDE52cZbHf9iDERDl1Fk2/NCFJcc22eoYCRiDw0=", "owner": "knowsys", "repo": "nemo-vscode-extension", - "rev": "b4cfccacc02c6287e8db8a413f9641aa7781371f", + "rev": "dfc37af5cc408f235e3283792d23ab80525d4ccc", "type": "github" }, "original": { @@ -5327,6 +5800,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5363,9 +5838,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_18", + "nemo-vscode-extension": "nemo-vscode-extension_19", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -5399,6 +5876,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -5434,6 +5913,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -5468,6 +5949,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5486,9 +5969,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_27", + "nemo-vscode-extension": "nemo-vscode-extension_28", "nev": "nev_2", "nixpkgs": [ "nemo-vscode-extension", @@ -5505,6 +5990,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -5522,6 +6009,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -5554,6 +6043,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5570,9 +6061,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_28", + "nemo-vscode-extension": "nemo-vscode-extension_29", "nev": "nev_3", "nixpkgs": [ "nemo-vscode-extension", @@ -5587,6 +6080,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -5602,6 +6097,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -5632,6 +6129,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5646,9 +6145,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_29", + "nemo-vscode-extension": "nemo-vscode-extension_30", "nev": "nev_4", "nixpkgs": [ "nemo-vscode-extension", @@ -5661,6 +6162,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": "utils" @@ -5690,6 +6193,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5702,9 +6207,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_30", + "nemo-vscode-extension": "nemo-vscode-extension_31", "nev": "nev_5", "nixpkgs": [ "nemo-vscode-extension", @@ -5715,6 +6222,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -5741,6 +6250,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5751,9 +6262,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_31", + "nemo-vscode-extension": "nemo-vscode-extension_32", "nev": "nev_6", "nixpkgs": [ "nemo-vscode-extension", @@ -5762,6 +6275,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -5786,6 +6301,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5794,15 +6311,19 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_32", + "nemo-vscode-extension": "nemo-vscode-extension_33", "nev": "nev_7", "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -5823,19 +6344,25 @@ "nemo-web_16": { "inputs": { "dream2nix": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "dream2nix" ], "nemo": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_33", + "nemo-vscode-extension": "nemo-vscode-extension_34", "nev": "nev_8", "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nixpkgs" @@ -5858,15 +6385,21 @@ "nemo-web_17": { "inputs": { "dream2nix": [ + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_34", + "nemo-vscode-extension": "nemo-vscode-extension_35", "nev": "nev_9", "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -5884,6 +6417,35 @@ "type": "github" } }, + "nemo-web_18": { + "inputs": { + "dream2nix": [ + "dream2nix" + ], + "nemo": [ + "nemo-vscode-extension", + "nemo" + ], + "nemo-vscode-extension": "nemo-vscode-extension_36", + "nev": "nev_10", + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1780581053, + "narHash": "sha256-8j2MJPeFI/1ogHpiH3rXCTrFuOaMttQJ1VoknKpTwbo=", + "owner": "knowsys", + "repo": "nemo-web", + "rev": "dec1dea448ad8115901d18e4f7dffc568fe4b5ed", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-web", + "type": "github" + } + }, "nemo-web_2": { "inputs": { "dream2nix": [ @@ -5917,6 +6479,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -5951,9 +6515,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_19", + "nemo-vscode-extension": "nemo-vscode-extension_20", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -5985,6 +6551,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -6018,6 +6586,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -6066,6 +6636,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -6098,9 +6670,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_20", + "nemo-vscode-extension": "nemo-vscode-extension_21", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6130,6 +6704,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -6161,6 +6737,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -6207,6 +6785,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -6237,9 +6817,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_21", + "nemo-vscode-extension": "nemo-vscode-extension_22", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6267,6 +6849,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -6296,6 +6880,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -6340,6 +6926,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -6368,9 +6956,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_22", + "nemo-vscode-extension": "nemo-vscode-extension_23", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6396,6 +6986,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -6423,6 +7015,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -6465,6 +7059,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "dream2nix" ], "nemo": [ @@ -6491,9 +7087,11 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_23", + "nemo-vscode-extension": "nemo-vscode-extension_24", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6517,6 +7115,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ], "utils": [ @@ -6542,6 +7142,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "utils" ] }, @@ -6550,7 +7152,126 @@ "narHash": "sha256-Ne/VAqd9oIvwT7KChbou8gh6Of816xtMrCuGIg1v4Vw=", "owner": "knowsys", "repo": "nemo-web", - "rev": "cfdc5edbb07dc08480ea4ee0d8b5c3539d6266ba", + "rev": "cfdc5edbb07dc08480ea4ee0d8b5c3539d6266ba", + "type": "github" + }, + "original": { + "owner": "knowsys", + "repo": "nemo-web", + "type": "github" + } + }, + "nemo-web_7": { + "inputs": { + "dream2nix": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix" + ], + "nemo": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo" + ], + "nemo-vscode-extension": "nemo-vscode-extension_25", + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nixpkgs" + ], + "utils": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "utils" + ] + }, + "locked": { + "lastModified": 1761038713, + "narHash": "sha256-A3b1OPdMHVBoSjfNP08uprkPvlTZSj4yKCX8Y5zstQc=", + "owner": "knowsys", + "repo": "nemo-web", + "rev": "f15bc3e112aac146433cabc8d8a30d2e027a5ff5", "type": "github" }, "original": { @@ -6559,7 +7280,7 @@ "type": "github" } }, - "nemo-web_7": { + "nemo-web_8": { "inputs": { "dream2nix": [ "nemo-vscode-extension", @@ -6608,7 +7329,7 @@ "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_24", + "nemo-vscode-extension": "nemo-vscode-extension_26", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6657,11 +7378,11 @@ ] }, "locked": { - "lastModified": 1761038713, - "narHash": "sha256-A3b1OPdMHVBoSjfNP08uprkPvlTZSj4yKCX8Y5zstQc=", + "lastModified": 1761041671, + "narHash": "sha256-23QpV8pwgWjxhV+tEVOIBP6mEzlQOCZbpAHHi2/a0Yo=", "owner": "knowsys", "repo": "nemo-web", - "rev": "f15bc3e112aac146433cabc8d8a30d2e027a5ff5", + "rev": "70159dccc0e2f09c6861dfce4bb2041723802cf7", "type": "github" }, "original": { @@ -6670,7 +7391,7 @@ "type": "github" } }, - "nemo-web_8": { + "nemo-web_9": { "inputs": { "dream2nix": [ "nemo-vscode-extension", @@ -6715,7 +7436,8 @@ "nemo-vscode-extension", "nemo" ], - "nemo-vscode-extension": "nemo-vscode-extension_25", + "nemo-vscode-extension": "nemo-vscode-extension_27", + "nev": "nev", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -6760,11 +7482,11 @@ ] }, "locked": { - "lastModified": 1761041671, - "narHash": "sha256-23QpV8pwgWjxhV+tEVOIBP6mEzlQOCZbpAHHi2/a0Yo=", + "lastModified": 1761172269, + "narHash": "sha256-wFrcua+RnKhOlcaJ8EE6hZmylvGvNeIzEf+Xs2WatLk=", "owner": "knowsys", "repo": "nemo-web", - "rev": "70159dccc0e2f09c6861dfce4bb2041723802cf7", + "rev": "a5291b25b6efb67ac817163c1e8915faea451ba7", "type": "github" }, "original": { @@ -6773,28 +7495,16 @@ "type": "github" } }, - "nemo-web_9": { + "nemo_10": { "inputs": { - "dream2nix": [ - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", + "crane": "crane_11", + "dream2nix": "dream2nix_11", + "nemo-doc": "nemo-doc_11", + "nemo-vscode-extension": "nemo-vscode-extension_11", + "nemo-web": "nemo-web_8", + "nixpkgs": [ "nemo-vscode-extension", "nemo", - "dream2nix" - ], - "nemo": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -6812,30 +7522,14 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", - "nemo" + "nixpkgs" ], - "nemo-vscode-extension": "nemo-vscode-extension_26", - "nev": "nev", - "nixpkgs": [ - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", + "rust-overlay": "rust-overlay_9", + "utils": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nemo", - "nixpkgs" - ], - "utils": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", @@ -6851,30 +7545,29 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", - "nemo", "utils" ] }, "locked": { - "lastModified": 1761172269, - "narHash": "sha256-wFrcua+RnKhOlcaJ8EE6hZmylvGvNeIzEf+Xs2WatLk=", + "lastModified": 1761142295, + "narHash": "sha256-C0nxfsjfP4IcUvmOReOWMGpdjn9y41yH7vdRaC7iDhY=", "owner": "knowsys", - "repo": "nemo-web", - "rev": "a5291b25b6efb67ac817163c1e8915faea451ba7", + "repo": "nemo", + "rev": "b752f2a54ba97a8d97c968d0838866d5af323712", "type": "github" }, "original": { "owner": "knowsys", - "repo": "nemo-web", + "repo": "nemo", "type": "github" } }, - "nemo_10": { + "nemo_11": { "inputs": { - "crane": "crane_11", - "dream2nix": "dream2nix_11", - "nemo-doc": "nemo-doc_11", - "nemo-vscode-extension": "nemo-vscode-extension_11", + "crane": "crane_12", + "dream2nix": "dream2nix_12", + "nemo-doc": "nemo-doc_12", + "nemo-vscode-extension": "nemo-vscode-extension_12", "nemo-web": "nemo-web_7", "nixpkgs": [ "nemo-vscode-extension", @@ -6896,6 +7589,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_8", @@ -6919,6 +7614,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -6936,12 +7633,12 @@ "type": "github" } }, - "nemo_11": { + "nemo_12": { "inputs": { - "crane": "crane_12", - "dream2nix": "dream2nix_12", - "nemo-doc": "nemo-doc_12", - "nemo-vscode-extension": "nemo-vscode-extension_12", + "crane": "crane_13", + "dream2nix": "dream2nix_13", + "nemo-doc": "nemo-doc_13", + "nemo-vscode-extension": "nemo-vscode-extension_13", "nemo-web": "nemo-web_6", "nixpkgs": [ "nemo-vscode-extension", @@ -6965,6 +7662,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_7", @@ -6990,6 +7689,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7007,12 +7708,12 @@ "type": "github" } }, - "nemo_12": { + "nemo_13": { "inputs": { - "crane": "crane_13", - "dream2nix": "dream2nix_13", - "nemo-doc": "nemo-doc_13", - "nemo-vscode-extension": "nemo-vscode-extension_13", + "crane": "crane_14", + "dream2nix": "dream2nix_14", + "nemo-doc": "nemo-doc_14", + "nemo-vscode-extension": "nemo-vscode-extension_14", "nemo-web": "nemo-web_5", "nixpkgs": [ "nemo-vscode-extension", @@ -7038,6 +7739,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_6", @@ -7065,6 +7768,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7082,12 +7787,12 @@ "type": "github" } }, - "nemo_13": { + "nemo_14": { "inputs": { - "crane": "crane_14", - "dream2nix": "dream2nix_14", - "nemo-doc": "nemo-doc_14", - "nemo-vscode-extension": "nemo-vscode-extension_14", + "crane": "crane_15", + "dream2nix": "dream2nix_15", + "nemo-doc": "nemo-doc_15", + "nemo-vscode-extension": "nemo-vscode-extension_15", "nemo-web": "nemo-web_4", "nixpkgs": [ "nemo-vscode-extension", @@ -7115,6 +7820,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_5", @@ -7144,6 +7851,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7161,12 +7870,12 @@ "type": "github" } }, - "nemo_14": { + "nemo_15": { "inputs": { - "crane": "crane_15", - "dream2nix": "dream2nix_15", - "nemo-doc": "nemo-doc_15", - "nemo-vscode-extension": "nemo-vscode-extension_15", + "crane": "crane_16", + "dream2nix": "dream2nix_16", + "nemo-doc": "nemo-doc_16", + "nemo-vscode-extension": "nemo-vscode-extension_16", "nemo-web": "nemo-web_3", "nixpkgs": [ "nemo-vscode-extension", @@ -7196,6 +7905,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_4", @@ -7227,6 +7938,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7244,12 +7957,12 @@ "type": "github" } }, - "nemo_15": { + "nemo_16": { "inputs": { - "crane": "crane_16", - "dream2nix": "dream2nix_16", - "nemo-doc": "nemo-doc_16", - "nemo-vscode-extension": "nemo-vscode-extension_16", + "crane": "crane_17", + "dream2nix": "dream2nix_17", + "nemo-doc": "nemo-doc_17", + "nemo-vscode-extension": "nemo-vscode-extension_17", "nemo-web": "nemo-web_2", "nixpkgs": [ "nemo-vscode-extension", @@ -7281,6 +7994,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_3", @@ -7314,6 +8029,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7331,12 +8048,12 @@ "type": "github" } }, - "nemo_16": { + "nemo_17": { "inputs": { - "crane": "crane_17", - "dream2nix": "dream2nix_17", - "nemo-doc": "nemo-doc_17", - "nemo-vscode-extension": "nemo-vscode-extension_17", + "crane": "crane_18", + "dream2nix": "dream2nix_18", + "nemo-doc": "nemo-doc_18", + "nemo-vscode-extension": "nemo-vscode-extension_18", "nemo-web": "nemo-web", "nixpkgs": [ "nemo-vscode-extension", @@ -7370,6 +8087,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay_2", @@ -7405,6 +8124,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7422,7 +8143,7 @@ "type": "github" } }, - "nemo_17": { + "nemo_18": { "inputs": { "nixpkgs": [ "nemo-vscode-extension", @@ -7458,6 +8179,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "nixpkgs" ], "rust-overlay": "rust-overlay", @@ -7495,6 +8218,8 @@ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", "utils" ] }, @@ -7518,21 +8243,21 @@ "dream2nix": "dream2nix_3", "nemo-doc": "nemo-doc_3", "nemo-vscode-extension": "nemo-vscode-extension_3", - "nemo-web": "nemo-web_15", + "nemo-web": "nemo-web_16", "nixpkgs": [ "nemo-vscode-extension", "nemo", "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_16" + "rust-overlay": "rust-overlay_17" }, "locked": { - "lastModified": 1774036004, - "narHash": "sha256-vhdZk+D9tqYkGrhZF6aPToI73l9P6ZtieAi236jbMcQ=", + "lastModified": 1774047520, + "narHash": "sha256-sQR9GC+mvywdSLTlIcvvm6Z/eixQ3p0/s4ama73UM00=", "owner": "knowsys", "repo": "nemo", - "rev": "d346a95376eacffeda4027021f00bb31e5da1398", + "rev": "ad95cd43c0ace02ce7dcd372d11e6c143bbfd470", "type": "github" }, "original": { @@ -7547,7 +8272,7 @@ "dream2nix": "dream2nix_4", "nemo-doc": "nemo-doc_4", "nemo-vscode-extension": "nemo-vscode-extension_4", - "nemo-web": "nemo-web_14", + "nemo-web": "nemo-web_15", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7556,14 +8281,14 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_15" + "rust-overlay": "rust-overlay_16" }, "locked": { - "lastModified": 1774035746, - "narHash": "sha256-VHU50BgZjsoAS/nOCrAk8h9sF2MqXL1I+2rM992is2M=", + "lastModified": 1774036004, + "narHash": "sha256-vhdZk+D9tqYkGrhZF6aPToI73l9P6ZtieAi236jbMcQ=", "owner": "knowsys", "repo": "nemo", - "rev": "03afc4c23db41079e057c89d167499f5985d0726", + "rev": "d346a95376eacffeda4027021f00bb31e5da1398", "type": "github" }, "original": { @@ -7578,7 +8303,7 @@ "dream2nix": "dream2nix_5", "nemo-doc": "nemo-doc_5", "nemo-vscode-extension": "nemo-vscode-extension_5", - "nemo-web": "nemo-web_13", + "nemo-web": "nemo-web_14", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7589,14 +8314,14 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_14" + "rust-overlay": "rust-overlay_15" }, "locked": { - "lastModified": 1774035582, - "narHash": "sha256-33PfRlOb9EPpG8xDpzhVw6ML4PJgsfb0pFZZaQ5u4yM=", + "lastModified": 1774035746, + "narHash": "sha256-VHU50BgZjsoAS/nOCrAk8h9sF2MqXL1I+2rM992is2M=", "owner": "knowsys", "repo": "nemo", - "rev": "3f8ee7cd970c4295e7465fcb63cdb06fd6b1f232", + "rev": "03afc4c23db41079e057c89d167499f5985d0726", "type": "github" }, "original": { @@ -7611,7 +8336,7 @@ "dream2nix": "dream2nix_6", "nemo-doc": "nemo-doc_6", "nemo-vscode-extension": "nemo-vscode-extension_6", - "nemo-web": "nemo-web_12", + "nemo-web": "nemo-web_13", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7624,14 +8349,14 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_13" + "rust-overlay": "rust-overlay_14" }, "locked": { - "lastModified": 1773758130, - "narHash": "sha256-m2uos3KImuVkWyPUx73KY/I/4+BiUkQuaIRAqiuMB8I=", + "lastModified": 1774035582, + "narHash": "sha256-33PfRlOb9EPpG8xDpzhVw6ML4PJgsfb0pFZZaQ5u4yM=", "owner": "knowsys", "repo": "nemo", - "rev": "eb131cf73f8ee956f8b3d5224b0a7264d3352463", + "rev": "3f8ee7cd970c4295e7465fcb63cdb06fd6b1f232", "type": "github" }, "original": { @@ -7646,7 +8371,7 @@ "dream2nix": "dream2nix_7", "nemo-doc": "nemo-doc_7", "nemo-vscode-extension": "nemo-vscode-extension_7", - "nemo-web": "nemo-web_11", + "nemo-web": "nemo-web_12", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7661,28 +8386,14 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_12", - "utils": [ - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "nemo", - "nemo-vscode-extension", - "utils" - ] + "rust-overlay": "rust-overlay_13" }, "locked": { - "lastModified": 1763463881, - "narHash": "sha256-sGbc2RiYAa+Qx8pedFZdKfG54AmG4QN/fnSbIKVwWQQ=", + "lastModified": 1773758130, + "narHash": "sha256-m2uos3KImuVkWyPUx73KY/I/4+BiUkQuaIRAqiuMB8I=", "owner": "knowsys", "repo": "nemo", - "rev": "fc2029dfd877d22868eea78f6dd6b8df3b273751", + "rev": "eb131cf73f8ee956f8b3d5224b0a7264d3352463", "type": "github" }, "original": { @@ -7697,7 +8408,7 @@ "dream2nix": "dream2nix_8", "nemo-doc": "nemo-doc_8", "nemo-vscode-extension": "nemo-vscode-extension_8", - "nemo-web": "nemo-web_10", + "nemo-web": "nemo-web_11", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7714,7 +8425,7 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_11", + "rust-overlay": "rust-overlay_12", "utils": [ "nemo-vscode-extension", "nemo", @@ -7733,11 +8444,11 @@ ] }, "locked": { - "lastModified": 1763463543, - "narHash": "sha256-5Ic6K2EKjoAvOVI0ii24qLiZ1aK0zI7W4Wn74jS2yZk=", + "lastModified": 1763463881, + "narHash": "sha256-sGbc2RiYAa+Qx8pedFZdKfG54AmG4QN/fnSbIKVwWQQ=", "owner": "knowsys", "repo": "nemo", - "rev": "78b76f85f7d8a0a455f815dc7f6c6decf37a5dd8", + "rev": "fc2029dfd877d22868eea78f6dd6b8df3b273751", "type": "github" }, "original": { @@ -7752,7 +8463,7 @@ "dream2nix": "dream2nix_9", "nemo-doc": "nemo-doc_9", "nemo-vscode-extension": "nemo-vscode-extension_9", - "nemo-web": "nemo-web_9", + "nemo-web": "nemo-web_10", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7771,7 +8482,7 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_10", + "rust-overlay": "rust-overlay_11", "utils": [ "nemo-vscode-extension", "nemo", @@ -7792,11 +8503,11 @@ ] }, "locked": { - "lastModified": 1761173289, - "narHash": "sha256-jAh6NbG4kMjLkyQzCy+0GlB4tH4NIGvejqwrOYq8e7U=", + "lastModified": 1763463543, + "narHash": "sha256-5Ic6K2EKjoAvOVI0ii24qLiZ1aK0zI7W4Wn74jS2yZk=", "owner": "knowsys", "repo": "nemo", - "rev": "d15d7b543e02dc00400e89440b343d2a07080134", + "rev": "78b76f85f7d8a0a455f815dc7f6c6decf37a5dd8", "type": "github" }, "original": { @@ -7811,7 +8522,7 @@ "dream2nix": "dream2nix_10", "nemo-doc": "nemo-doc_10", "nemo-vscode-extension": "nemo-vscode-extension_10", - "nemo-web": "nemo-web_8", + "nemo-web": "nemo-web_9", "nixpkgs": [ "nemo-vscode-extension", "nemo", @@ -7832,7 +8543,7 @@ "nemo-vscode-extension", "nixpkgs" ], - "rust-overlay": "rust-overlay_9", + "rust-overlay": "rust-overlay_10", "utils": [ "nemo-vscode-extension", "nemo", @@ -7855,11 +8566,11 @@ ] }, "locked": { - "lastModified": 1761142295, - "narHash": "sha256-C0nxfsjfP4IcUvmOReOWMGpdjn9y41yH7vdRaC7iDhY=", + "lastModified": 1761173289, + "narHash": "sha256-jAh6NbG4kMjLkyQzCy+0GlB4tH4NIGvejqwrOYq8e7U=", "owner": "knowsys", "repo": "nemo", - "rev": "b752f2a54ba97a8d97c968d0838866d5af323712", + "rev": "d15d7b543e02dc00400e89440b343d2a07080134", "type": "github" }, "original": { @@ -7884,6 +8595,22 @@ "type": "github" } }, + "nev_10": { + "flake": false, + "locked": { + "lastModified": 1770629495, + "narHash": "sha256-4KSodNCwkiuSXtB5p+zJ6z3NJno7zfoUOEBYxhdpbFc=", + "owner": "imldresden", + "repo": "nev", + "rev": "ae37e4dabec5988e7a2221d763b8c356f9ebfa5c", + "type": "github" + }, + "original": { + "owner": "imldresden", + "repo": "nev", + "type": "github" + } + }, "nev_2": { "flake": false, "locked": { @@ -8014,11 +8741,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1780203844, - "narHash": "sha256-0LbzRbwKOIae/V/p/wDALlUWZ5ZF41vtH05PYdKhh5I=", - "rev": "b51242d7d43689db2f3be91bd05d5b24fbb469c4", + "lastModified": 1780453794, + "narHash": "sha256-hhAl/iKiurXPn7rdzDgiSuRB8tqOB6f0buWkh8Y9mkY=", + "rev": "6b316287bae2ee04c9b93c8c858d930fd07d7338", "type": "tarball", - "url": "https://releases.nixos.org/nixos/26.05/nixos-26.05.889.b51242d7d436/nixexprs.tar.xz?lastModified=1780203844&rev=b51242d7d43689db2f3be91bd05d5b24fbb469c4" + "url": "https://releases.nixos.org/nixos/26.05/nixos-26.05.1183.6b316287bae2/nixexprs.tar.xz?lastModified=1780453794&rev=6b316287bae2ee04c9b93c8c858d930fd07d7338" }, "original": { "type": "tarball", @@ -8432,6 +9159,63 @@ "type": "github" } }, + "purescript-overlay_18": { + "inputs": { + "flake-compat": "flake-compat_18", + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix", + "nixpkgs" + ], + "slimlock": "slimlock_18" + }, + "locked": { + "lastModified": 1728546539, + "narHash": "sha256-Sws7w0tlnjD+Bjck1nv29NjC5DbL6nH5auL9Ex9Iz2A=", + "owner": "thomashoneyman", + "repo": "purescript-overlay", + "rev": "4ad4c15d07bd899d7346b331f377606631eb0ee4", + "type": "github" + }, + "original": { + "owner": "thomashoneyman", + "repo": "purescript-overlay", + "type": "github" + } + }, "purescript-overlay_2": { "inputs": { "flake-compat": "flake-compat_2", @@ -8974,6 +9758,57 @@ } }, "pyproject-nix_16": { + "inputs": { + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1752481895, + "narHash": "sha256-luVj97hIMpCbwhx3hWiRwjP2YvljWy8FM+4W9njDhLA=", + "owner": "pyproject-nix", + "repo": "pyproject.nix", + "rev": "16ee295c25107a94e59a7fc7f2e5322851781162", + "type": "github" + }, + "original": { + "owner": "pyproject-nix", + "repo": "pyproject.nix", + "type": "github" + } + }, + "pyproject-nix_17": { "flake": false, "locked": { "lastModified": 1702448246, @@ -8990,7 +9825,7 @@ "type": "github" } }, - "pyproject-nix_17": { + "pyproject-nix_18": { "flake": false, "locked": { "lastModified": 1702448246, @@ -9162,11 +9997,11 @@ ] }, "locked": { - "lastModified": 1752481895, - "narHash": "sha256-luVj97hIMpCbwhx3hWiRwjP2YvljWy8FM+4W9njDhLA=", + "lastModified": 1763017646, + "narHash": "sha256-Z+R2lveIp6Skn1VPH3taQIuMhABg1IizJd8oVdmdHsQ=", "owner": "pyproject-nix", "repo": "pyproject.nix", - "rev": "16ee295c25107a94e59a7fc7f2e5322851781162", + "rev": "47bd6f296502842643078d66128f7b5e5370790c", "type": "github" }, "original": { @@ -9253,9 +10088,9 @@ "dream2nix": "dream2nix", "nemo-doc": "nemo-doc", "nemo-vscode-extension": "nemo-vscode-extension", - "nemo-web": "nemo-web_17", + "nemo-web": "nemo-web_18", "nixpkgs": "nixpkgs", - "rust-overlay": "rust-overlay_18" + "rust-overlay": "rust-overlay_19" } }, "rust-overlay": { @@ -9295,6 +10130,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9331,6 +10168,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9365,6 +10204,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9397,6 +10238,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9427,6 +10270,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9455,6 +10300,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9481,6 +10328,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9505,6 +10354,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9525,6 +10376,8 @@ "rust-overlay_17": { "inputs": { "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nemo-vscode-extension", "nemo", "nixpkgs" @@ -9547,6 +10400,8 @@ "rust-overlay_18": { "inputs": { "nixpkgs": [ + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9564,6 +10419,26 @@ "type": "github" } }, + "rust-overlay_19": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1780543271, + "narHash": "sha256-oPJ7eJN1sM37v92Rp/eyQL7/rUm0BOvXEBAoq/zN0cM=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "c30ca201c5093540cf792f6982f81ba1aa0f3514", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, "rust-overlay_2": { "inputs": { "nixpkgs": [ @@ -9599,6 +10474,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9649,6 +10526,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9697,6 +10576,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9743,6 +10624,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9787,6 +10670,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9829,6 +10714,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9869,6 +10756,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -9907,6 +10796,8 @@ "nemo", "nemo-vscode-extension", "nemo", + "nemo-vscode-extension", + "nemo", "nixpkgs" ] }, @@ -10322,6 +11213,62 @@ "type": "github" } }, + "slimlock_18": { + "inputs": { + "nixpkgs": [ + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "nemo-vscode-extension", + "nemo", + "dream2nix", + "purescript-overlay", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1688756706, + "narHash": "sha256-xzkkMv3neJJJ89zo3o2ojp7nFeaZc2G0fYwNXNJRFlo=", + "owner": "thomashoneyman", + "repo": "slimlock", + "rev": "cf72723f59e2340d24881fd7bf61cb113b4c407c", + "type": "github" + }, + "original": { + "owner": "thomashoneyman", + "repo": "slimlock", + "type": "github" + } + }, "slimlock_2": { "inputs": { "nixpkgs": [ From fffd2e5d2a3e1ab481ff8dc462f6a91c7dd9b26a Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Thu, 4 Jun 2026 17:12:15 +0200 Subject: [PATCH 13/19] Placate clippy Signed-off-by: Maximilian Marx --- nemo-physical/src/management/database/execution_series.rs | 4 ++-- nemo/src/rule_model/error/info.rs | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/nemo-physical/src/management/database/execution_series.rs b/nemo-physical/src/management/database/execution_series.rs index a38a3a396..7d01f1de8 100644 --- a/nemo-physical/src/management/database/execution_series.rs +++ b/nemo-physical/src/management/database/execution_series.rs @@ -109,10 +109,10 @@ impl ExecutionTree { match node { ExecutionTreeOperation::Leaf(leaf) => match leaf { ExecutionTreeLeaf::LoadTable(_) => { - ascii_tree::Tree::Leaf(vec![format!("Permanent Table")]) + ascii_tree::Tree::Leaf(vec!["Permanent Table".to_string()]) } ExecutionTreeLeaf::FetchComputedTable(_) => { - ascii_tree::Tree::Leaf(vec![format!("New Table")]) + ascii_tree::Tree::Leaf(vec!["New Table".to_string()]) } }, ExecutionTreeOperation::Node { diff --git a/nemo/src/rule_model/error/info.rs b/nemo/src/rule_model/error/info.rs index 530271bb6..d0c113037 100644 --- a/nemo/src/rule_model/error/info.rs +++ b/nemo/src/rule_model/error/info.rs @@ -8,19 +8,19 @@ use enum_assoc::Assoc; #[func(pub fn message(&self) -> String)] pub enum Info { /// Value was defined externally - #[assoc(message = format!("value was defined externally"))] + #[assoc(message = "value was defined externally".to_string())] DefinedExternally, /// First definition occurred somewhere - #[assoc(message = format!("first definition occurred here"))] + #[assoc(message = "first definition occurred here".to_string())] FirstDefinition, /// First use occurred somewhere - #[assoc(message = format!("first use occurred here"))] + #[assoc(message = "first use occurred here".to_string())] FirstUse, /// Predicate different arity #[assoc(message = format!("predicate was used here with arity {}", _arity))] PredicateArity { arity: usize }, /// Value was defined here - #[assoc(message = format!("value was defined here"))] + #[assoc(message = "value was defined here".to_string())] ValueDefined, } From 85209b309e73e8f7f3e6a68d70b7562d690436d8 Mon Sep 17 00:00:00 2001 From: Maximilian Marx Date: Wed, 10 Jun 2026 19:17:51 +0200 Subject: [PATCH 14/19] Don't auto-optimise the nix store Work around a bug in cache-nix-action, cf. https://github.com/nix-community/cache-nix-action/issues/170 --- .github/workflows/nix-and-docker.yml | 3 +++ .github/workflows/release.yml | 3 +++ 2 files changed, 6 insertions(+) diff --git a/.github/workflows/nix-and-docker.yml b/.github/workflows/nix-and-docker.yml index 00a02b5b7..f9c68e956 100644 --- a/.github/workflows/nix-and-docker.yml +++ b/.github/workflows/nix-and-docker.yml @@ -17,6 +17,9 @@ jobs: steps: - uses: actions/checkout@v6 - uses: cachix/install-nix-action@v31 + with: + extra_nix_config: | + auto-optimise-store = false - uses: jlumbroso/free-disk-space@v1.3.1 with: swap-storage: false diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index dbe08ebd7..63a23f2a7 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -93,6 +93,9 @@ jobs: - name: Check out repository uses: actions/checkout@v6 - uses: cachix/install-nix-action@v31 + with: + extra_nix_config: | + auto-optimise-store = false - uses: jlumbroso/free-disk-space@v1.3.1 with: swap-storage: false From e431b7c62f6fdd8a8082d13e7d61b7c0ae59ce71 Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Wed, 24 Jun 2026 15:21:35 +0200 Subject: [PATCH 15/19] added IRI verification to program translator --- .../src/rule_model/error/translation_error.rs | 11 ++++ nemo/src/rule_model/translation/directive.rs | 50 ++++++++++++++----- 2 files changed, 49 insertions(+), 12 deletions(-) diff --git a/nemo/src/rule_model/error/translation_error.rs b/nemo/src/rule_model/error/translation_error.rs index f631dba83..ecfafcee4 100644 --- a/nemo/src/rule_model/error/translation_error.rs +++ b/nemo/src/rule_model/error/translation_error.rs @@ -126,6 +126,17 @@ pub enum TranslationError { #[assoc(note = "parameter names must have the form `$name'")] #[assoc(code = 130)] ParamDeclarationNotGlobal, + /// Base is not a valid IRI + #[error(r#"base is not a valid IRI"#)] + #[assoc(note = "base must be a valid IRI (RFC 3987)")] + #[assoc(code = 131)] + BaseInvalid, + /// Prefix is not a valid IRI + // should this be split into 2 (invalid ref/ not resolvable)? + #[error(r#"prefix is not a valid IRI"#)] + #[assoc(note = "prefix must be a valid IRI (RFC 3987)")] + #[assoc(code = 132)] + PrefixInvalid, /// Unsupported: Declare statements #[error(r#"declare statements are currently unsupported"#)] diff --git a/nemo/src/rule_model/translation/directive.rs b/nemo/src/rule_model/translation/directive.rs index 655f29171..d57644d75 100644 --- a/nemo/src/rule_model/translation/directive.rs +++ b/nemo/src/rule_model/translation/directive.rs @@ -1,9 +1,9 @@ //! This module contains functions for translating directive ast nodes. - use core::panic; use std::collections::{HashMap, hash_map::Entry}; +use std::result::Result; -use oxiri::{Iri, IriParseError, IriRef}; +use oxiri::{Iri, IriRef}; use spargebra::SparqlParser; use crate::{ @@ -100,6 +100,12 @@ fn handle_base<'a>(translation: &mut ASTProgramTranslation, base: &ast::directiv .add_context_source(first_base.clone(), Info::FirstDefinition); } + // check if base is a valid iri + if let Err(_) = Iri::parse(base.iri().content()) { + translation.report.add(base, TranslationError::BaseInvalid); + // TODO add parse error as context + } + translation.base = Some((base.iri().content(), base.origin())); } @@ -131,6 +137,24 @@ fn handle_prefix<'a>( translation: &mut ASTProgramTranslation, prefix: &ast::directive::prefix::Prefix<'a>, ) { + if let Err(_) = (|| { + let rel_prefix = IriRef::parse(prefix.iri().content())?; + if rel_prefix.is_absolute() { + return Ok::<(), Box>(()); + } else if let Some(base) = &translation.base { + Iri::parse(base.0.to_string()) + .expect("base is not a valid IRI") + .resolve(&rel_prefix)?; + return Ok::<(), Box>(()); + } + Err(Box::new(TranslationError::PrefixInvalid)) + })() { + // parsing not successful + translation + .report + .add(prefix.prefix_token(), TranslationError::PrefixInvalid); + } + match translation.prefix_mapping.entry(prefix.prefix()) { Entry::Occupied(entry) => { let (_, prefix_first) = entry.get(); @@ -155,10 +179,12 @@ pub struct FormatContext { } impl FormatContext { + /// Returns an optional base IRI pub fn base(&self) -> &Option> { &self.base } + /// returns a Hashmap of all prefixes and their related IRIs pub fn prefixes(&self) -> &HashMap> { &self.prefixes } @@ -180,24 +206,24 @@ impl FormatContext { /// - a relative prefix is given but no base is set pub fn add_prefix(&mut self, prefix: String, iri: String) { let rel_prefix = IriRef::parse(iri.clone()).expect("not a valid Iri"); - let abs_prefix; - if rel_prefix.is_absolute() { - abs_prefix = Iri::parse(iri.clone()).expect("absolute IRI is not absolute"); + let abs_prefix = if rel_prefix.is_absolute() { + Iri::parse(iri.clone()).expect("absolute IRI is not absolute") } else { if let Some(base) = &self.base { - abs_prefix = base - .resolve(&rel_prefix.clone()) - .expect("relative prefix not resolvable on base"); + base.resolve(&rel_prefix.clone()) + .expect("relative prefix not resolvable on base") } else { - panic!("attempted to resolve relative prefix without base") + panic!( + "Relative base without prefixes! This should have been cought by the translator!" + ) } - } + }; self.prefixes.insert(prefix, abs_prefix); } - /// - pub fn as_sparql_parser(&self) -> SparqlParser { + /// prepares and returns a SparqlParser with the base and prefixes + pub fn into_sparql_parser(&self) -> SparqlParser { let mut parser = SparqlParser::new(); if let Some(base) = &self.base { From 39481a1a04a105ed814e51fabd7905dc79030c57 Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Wed, 24 Jun 2026 15:23:01 +0200 Subject: [PATCH 16/19] added IRI verification to program translator --- nemo/src/io/formats/sparql.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index 75b00f23b..bf7cfca2d 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -191,7 +191,7 @@ impl FormatBuilder for SparqlBuilder { .map(|value| value.to_plain_string_unchecked()) .unwrap_or(QUERY_DEFAULT.to_string()); - let parser = format_context.as_sparql_parser(); + let parser = format_context.into_sparql_parser(); let query = parser .parse_query(query.as_str()) From a76aff43b5667264dd4edd601cd8b4417ef05f0c Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Wed, 24 Jun 2026 15:27:57 +0200 Subject: [PATCH 17/19] stylistic fixes --- nemo/src/io/format_builder.rs | 3 +-- nemo/src/io/formats/rdf.rs | 3 +-- nemo/src/io/formats/sparql.rs | 5 ++--- nemo/src/rule_model/components/import_export.rs | 1 - nemo/src/rule_model/translation/directive.rs | 11 ++++++----- .../rule_model/translation/directive/import_export.rs | 2 -- 6 files changed, 10 insertions(+), 15 deletions(-) diff --git a/nemo/src/io/format_builder.rs b/nemo/src/io/format_builder.rs index cd353de93..27fa502ea 100644 --- a/nemo/src/io/format_builder.rs +++ b/nemo/src/io/format_builder.rs @@ -13,7 +13,6 @@ use nemo_physical::{ resource::{Resource, ResourceBuilder, ResourceValidationError}, tabular::filters::FilterTransformPattern, }; -use oxiri::{Iri, IriRef}; use strum::IntoEnumIterator; use crate::{ @@ -243,7 +242,7 @@ impl FormatParameter for StandardParameter { fn is_value_valid( &self, value: AnyDataValue, - format_context: FormatContext, + _format_context: FormatContext, ) -> Result<(), ValidationError> { value_type_matches(self, &value, self.supported_types())?; diff --git a/nemo/src/io/formats/rdf.rs b/nemo/src/io/formats/rdf.rs index a795eb3e9..97c5bd5a7 100644 --- a/nemo/src/io/formats/rdf.rs +++ b/nemo/src/io/formats/rdf.rs @@ -8,7 +8,6 @@ pub(crate) mod value_format; pub(crate) mod writer; use std::{ - collections::HashMap, io::{Read, Write}, sync::Arc, }; @@ -20,7 +19,7 @@ use nemo_physical::{ tabular::filters::FilterTransformPattern, }; -use oxiri::{Iri, IriRef}; +use oxiri::Iri; use reader::RdfReader; use strum::VariantArray; use strum_macros::VariantArray; diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index bf7cfca2d..3d3948211 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -6,7 +6,7 @@ pub(crate) mod reader; use reader::SparqlReader; use spargebra::{Query, SparqlParser}; -use std::{collections::HashMap, str::FromStr, sync::Arc}; +use std::sync::Arc; use nemo_physical::{ datasources::table_providers::TableProvider, @@ -14,14 +14,13 @@ use nemo_physical::{ resource::{ResourceBuilder, ResourceValidationError}, tabular::filters::FilterTransformPattern, }; -use oxiri::{Iri, IriRef}; +use oxiri::Iri; use crate::{ io::format_builder::{ AnyImportExportBuilder, FormatParameter, Parameters, StandardParameter, SupportedFormatTag, format_parameter, format_tag, value_type_matches, }, - parser::ast::directive::{Directive::Base, base}, rule_model::{ components::{import_export::Direction, term::value_type::ValueType}, error::validation_error::ValidationError, diff --git a/nemo/src/rule_model/components/import_export.rs b/nemo/src/rule_model/components/import_export.rs index 3c8a29943..500afe20f 100644 --- a/nemo/src/rule_model/components/import_export.rs +++ b/nemo/src/rule_model/components/import_export.rs @@ -5,7 +5,6 @@ use std::collections::{HashMap, HashSet}; use attribute::ImportExportAttribute; use nemo_physical::datavalues::AnyDataValue; -use oxiri::{Iri, IriRef}; use specification::ImportExportSpec; use crate::{ diff --git a/nemo/src/rule_model/translation/directive.rs b/nemo/src/rule_model/translation/directive.rs index d57644d75..d51464f89 100644 --- a/nemo/src/rule_model/translation/directive.rs +++ b/nemo/src/rule_model/translation/directive.rs @@ -1,7 +1,6 @@ //! This module contains functions for translating directive ast nodes. use core::panic; use std::collections::{HashMap, hash_map::Entry}; -use std::result::Result; use oxiri::{Iri, IriRef}; use spargebra::SparqlParser; @@ -101,7 +100,7 @@ fn handle_base<'a>(translation: &mut ASTProgramTranslation, base: &ast::directiv } // check if base is a valid iri - if let Err(_) = Iri::parse(base.iri().content()) { + if Iri::parse(base.iri().content()).is_err() { translation.report.add(base, TranslationError::BaseInvalid); // TODO add parse error as context } @@ -137,7 +136,7 @@ fn handle_prefix<'a>( translation: &mut ASTProgramTranslation, prefix: &ast::directive::prefix::Prefix<'a>, ) { - if let Err(_) = (|| { + if (|| { let rel_prefix = IriRef::parse(prefix.iri().content())?; if rel_prefix.is_absolute() { return Ok::<(), Box>(()); @@ -148,7 +147,9 @@ fn handle_prefix<'a>( return Ok::<(), Box>(()); } Err(Box::new(TranslationError::PrefixInvalid)) - })() { + })() + .is_err() + { // parsing not successful translation .report @@ -223,7 +224,7 @@ impl FormatContext { } /// prepares and returns a SparqlParser with the base and prefixes - pub fn into_sparql_parser(&self) -> SparqlParser { + pub fn into_sparql_parser(self) -> SparqlParser { let mut parser = SparqlParser::new(); if let Some(base) = &self.base { diff --git a/nemo/src/rule_model/translation/directive/import_export.rs b/nemo/src/rule_model/translation/directive/import_export.rs index 8d0be6f86..3119f2fe1 100644 --- a/nemo/src/rule_model/translation/directive/import_export.rs +++ b/nemo/src/rule_model/translation/directive/import_export.rs @@ -1,8 +1,6 @@ //! This module contains a function for handling import/export statements. -use std::{mem::transmute, str::FromStr}; -use oxiri::{Iri, IriRef}; use crate::{ parser::{ From 6bb83969edc87537c9414869e5e448b3a114f4f9 Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Tue, 7 Jul 2026 19:18:05 +0200 Subject: [PATCH 18/19] fixed code styling --- nemo/src/io/format_builder.rs | 1 + nemo/src/io/formats/sparql.rs | 6 ++---- nemo/src/rule_model/error/translation_error.rs | 5 ++--- nemo/src/rule_model/translation/directive.rs | 18 ++++++++---------- .../translation/directive/import_export.rs | 2 -- 5 files changed, 13 insertions(+), 19 deletions(-) diff --git a/nemo/src/io/format_builder.rs b/nemo/src/io/format_builder.rs index 27fa502ea..55ad42e4f 100644 --- a/nemo/src/io/format_builder.rs +++ b/nemo/src/io/format_builder.rs @@ -516,6 +516,7 @@ impl ImportExportBuilder { self.resource.clone() } + #[allow(clippy::too_many_arguments)] fn new_with_tag( predicate: Tag, tag: B::Tag, diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index 3d3948211..6eefe2ebb 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -296,7 +296,7 @@ impl ImportHandler for SparqlHandler { #[cfg(test)] mod test { - use std::{collections::HashMap, str::FromStr}; + use std::str::FromStr; use crate::{ parser::{ @@ -307,7 +307,7 @@ mod test { rule_model::translation::directive::FormatContext, }; use nom::combinator::all_consuming; - use oxiri::{Iri, IriRef}; + use oxiri::Iri; use crate::io::format_builder::FormatParameter; use nemo_physical::datavalues::AnyDataValue; @@ -316,8 +316,6 @@ mod test { #[test] fn parse_query() { - let base = Some(Iri::from_str("http://www.wikidata.org/").unwrap()); - let mut format_context = FormatContext::default(); format_context.add_base("http://www.wikidata.org/".to_string()); // PREFIX wikibase: diff --git a/nemo/src/rule_model/error/translation_error.rs b/nemo/src/rule_model/error/translation_error.rs index ecfafcee4..4606e1e23 100644 --- a/nemo/src/rule_model/error/translation_error.rs +++ b/nemo/src/rule_model/error/translation_error.rs @@ -128,13 +128,12 @@ pub enum TranslationError { ParamDeclarationNotGlobal, /// Base is not a valid IRI #[error(r#"base is not a valid IRI"#)] - #[assoc(note = "base must be a valid IRI (RFC 3987)")] + #[assoc(note = "base must be a valid absolute IRI (RFC 3987)")] #[assoc(code = 131)] BaseInvalid, /// Prefix is not a valid IRI - // should this be split into 2 (invalid ref/ not resolvable)? #[error(r#"prefix is not a valid IRI"#)] - #[assoc(note = "prefix must be a valid IRI (RFC 3987)")] + #[assoc(note = "prefix must be a valid IRI either absolute or relative to base (RFC 3987)")] #[assoc(code = 132)] PrefixInvalid, diff --git a/nemo/src/rule_model/translation/directive.rs b/nemo/src/rule_model/translation/directive.rs index d51464f89..cca94eec3 100644 --- a/nemo/src/rule_model/translation/directive.rs +++ b/nemo/src/rule_model/translation/directive.rs @@ -136,7 +136,7 @@ fn handle_prefix<'a>( translation: &mut ASTProgramTranslation, prefix: &ast::directive::prefix::Prefix<'a>, ) { - if (|| { + let parse_prefix = || { let rel_prefix = IriRef::parse(prefix.iri().content())?; if rel_prefix.is_absolute() { return Ok::<(), Box>(()); @@ -147,9 +147,9 @@ fn handle_prefix<'a>( return Ok::<(), Box>(()); } Err(Box::new(TranslationError::PrefixInvalid)) - })() - .is_err() - { + }; + + if parse_prefix().is_err() { // parsing not successful translation .report @@ -180,7 +180,7 @@ pub struct FormatContext { } impl FormatContext { - /// Returns an optional base IRI + /// Returns the base IRI if set pub fn base(&self) -> &Option> { &self.base } @@ -208,15 +208,13 @@ impl FormatContext { pub fn add_prefix(&mut self, prefix: String, iri: String) { let rel_prefix = IriRef::parse(iri.clone()).expect("not a valid Iri"); let abs_prefix = if rel_prefix.is_absolute() { - Iri::parse(iri.clone()).expect("absolute IRI is not absolute") + Iri::parse(iri.clone()).expect("IRI is absolute") } else { if let Some(base) = &self.base { base.resolve(&rel_prefix.clone()) - .expect("relative prefix not resolvable on base") + .expect("relative prefix can be resolved on base") } else { - panic!( - "Relative base without prefixes! This should have been cought by the translator!" - ) + unreachable!() } }; diff --git a/nemo/src/rule_model/translation/directive/import_export.rs b/nemo/src/rule_model/translation/directive/import_export.rs index 3119f2fe1..85123b5d8 100644 --- a/nemo/src/rule_model/translation/directive/import_export.rs +++ b/nemo/src/rule_model/translation/directive/import_export.rs @@ -1,7 +1,5 @@ //! This module contains a function for handling import/export statements. - - use crate::{ parser::{ ast::{self, ProgramAST, tag::structure::StructureTag}, From 2a327a6dcb36dda829fde1323983e3d1ae52a492 Mon Sep 17 00:00:00 2001 From: Friedemann Weickert Date: Tue, 7 Jul 2026 19:19:26 +0200 Subject: [PATCH 19/19] placate clippy --- nemo/src/io/formats/sparql.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/nemo/src/io/formats/sparql.rs b/nemo/src/io/formats/sparql.rs index 6eefe2ebb..e6e939041 100644 --- a/nemo/src/io/formats/sparql.rs +++ b/nemo/src/io/formats/sparql.rs @@ -296,7 +296,6 @@ impl ImportHandler for SparqlHandler { #[cfg(test)] mod test { - use std::str::FromStr; use crate::{ parser::{ @@ -307,7 +306,6 @@ mod test { rule_model::translation::directive::FormatContext, }; use nom::combinator::all_consuming; - use oxiri::Iri; use crate::io::format_builder::FormatParameter; use nemo_physical::datavalues::AnyDataValue;