Struct EnrichEngine 

pub struct EnrichEngine<'a> { /* private fields */ }

Enrichment workflow engine.

Implementations

impl<'a> EnrichEngine<'a>

pub async fn find_candidates( &self, query: &EnrichQuery, ) -> Result<Vec<EnrichCandidate>>

Find notes that have empty fields matching the query criteria.

Returns a list of candidates with information about which fields need enrichment.

Arguments

• query - Query parameters specifying search filter and fields to check

Example

let engine = Engine::new();

let query = EnrichQuery {
    search: "deck:\"My Deck\" note:Basic".to_string(),
    empty_fields: vec!["Example".to_string(), "Pronunciation".to_string()],
};

let candidates = engine.enrich().find_candidates(&query).await?;
for candidate in &candidates {
    println!("Note {} needs: {:?}", candidate.note_id, candidate.empty_fields);
}

pub async fn update_note( &self, note_id: i64, fields: &HashMap<String, String>, ) -> Result<()>

Update a single note with new field values.

Arguments

• note_id - The note to update
• fields - Map of field name to new value

Example

let engine = Engine::new();

let mut fields = HashMap::new();
fields.insert("Example".to_string(), "This is an example sentence.".to_string());

engine.enrich().update_note(12345, &fields).await?;

pub async fn update_notes( &self, updates: &[(i64, HashMap<String, String>)], ) -> Result<EnrichReport>

Update multiple notes with new field values.

Arguments

• updates - List of (note_id, fields) pairs to update

Example

let engine = Engine::new();

let updates: Vec<(i64, HashMap<String, String>)> = vec![
    (12345, [("Example".to_string(), "Example 1".to_string())].into_iter().collect()),
    (12346, [("Example".to_string(), "Example 2".to_string())].into_iter().collect()),
];

let report = engine.enrich().update_notes(&updates).await?;
println!("Updated: {}, Failed: {}", report.updated, report.failed);

pub async fn tag_enriched(&self, note_ids: &[i64], tag: &str) -> Result<()>

Add a tag to notes after enrichment.

Useful for marking notes as processed.

Arguments

• note_ids - Notes to tag
• tag - Tag to add

pub async fn pipeline(&self, query: &EnrichQuery) -> Result<EnrichmentPipeline>

Create an enrichment pipeline for batch processing.

The pipeline finds candidates and provides helpers for grouping, updating, and committing changes.

Arguments

• query - Query parameters specifying search filter and fields to check

Example

let engine = Engine::new();

let query = EnrichQuery {
    search: "deck:Japanese".to_string(),
    empty_fields: vec!["Example".to_string(), "Pronunciation".to_string()],
};

let mut pipeline = engine.enrich().pipeline(&query).await?;

// Process by missing field for efficient batching
for (field, candidates) in pipeline.by_missing_field() {
    println!("Field '{}' needs {} notes enriched", field, candidates.len());
}

// Buffer updates - collect IDs first to avoid borrow issues
let note_ids: Vec<i64> = pipeline.candidates().iter().map(|c| c.note_id).collect();
for note_id in note_ids {
    pipeline.update(note_id, [
        ("Example".to_string(), "Generated example".to_string())
    ].into_iter().collect());
}

// Commit all updates
let report = pipeline.commit(&engine).await?;
println!("Updated {} notes", report.updated);

Trait Implementations

impl<'a> Debug for EnrichEngine<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.