cooklang-import 0.9.9

A tool for importing recipes into Cooklang format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Advanced builder API usage
//!
//! This example demonstrates advanced features like:
//! - Custom LLM provider configuration
//! - Timeout settings
//! - Error handling
//!
//! Note: Custom providers require a config.toml file with provider settings.
//! See config.toml.example in the repository root.

use cooklang_import::{ImportResult, RecipeImporter};
use std::time::Duration;

// LlmProvider is available for use when you have config.toml configured
#[allow(unused_imports)]
use cooklang_import::LlmProvider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example 1: Custom timeout
    println!("=== Builder with Custom Timeout ===");
    let result = RecipeImporter::builder()
        .url("https://www.bbcgoodfood.com/recipes/classic-cottage-pie")
        .timeout(Duration::from_secs(60))
        .build()
        .await?;

    match result {
        ImportResult::Cooklang {
            content,
            conversion_metadata,
        } => {
            println!("Successfully imported recipe with custom timeout:");
            println!("Recipe length: {} bytes", content.len());
            if let Some(meta) = conversion_metadata {
                println!("Model: {:?}", meta.model_version);
                println!("Latency: {}ms", meta.latency_ms);
            }
        }
        ImportResult::Components(_) => unreachable!(),
    }

    // Example 2: Custom provider (requires config.toml)
    println!("\n=== Builder with Custom Provider ===");
    println!("Note: This requires a config.toml with Anthropic configuration");

    // Uncomment if you have Anthropic configured:
    // let result = RecipeImporter::builder()
    //     .url("https://www.bbcgoodfood.com/recipes/classic-cottage-pie")
    //     .provider(LlmProvider::Anthropic)
    //     .build()
    //     .await?;
    //
    // match result {
    //     ImportResult::Cooklang(cooklang) => {
    //         println!("Successfully imported recipe with Anthropic:");
    //         println!("{}", cooklang);
    //     }
    //     ImportResult::Components(_) => unreachable!(),
    // }

    // Example 2: Error handling
    println!("\n=== Error Handling Example ===");

    // This will fail because no source is specified
    let result = RecipeImporter::builder().build().await;

    match result {
        Ok(_) => println!("Unexpected success"),
        Err(e) => println!("Expected error: {}", e),
    }

    // This will fail because markdown + extract_only is invalid
    let result = RecipeImporter::builder()
        .text("ingredients\n\ninstructions")
        .extract_only()
        .build()
        .await;

    match result {
        Ok(_) => println!("Unexpected success"),
        Err(e) => println!("Expected error: {}", e),
    }

    // Example 3: Method chaining with multiple options
    println!("\n=== Method Chaining ===");
    let result = RecipeImporter::builder()
        .url("https://www.bbcgoodfood.com/recipes/classic-cottage-pie")
        .timeout(Duration::from_secs(90))
        .build()
        .await?;

    println!("Successfully chained methods and imported recipe");

    if let ImportResult::Cooklang { content, .. } = result {
        println!("Recipe length: {} bytes", content.len());
    }

    // Example 4: Using Ollama (local LLM)
    println!("\n=== Using Ollama (Local LLM) ===");
    println!("Note: This requires Ollama running locally with config.toml");

    // Uncomment if you have Ollama configured:
    // let result = RecipeImporter::builder()
    //     .text("2 eggs\n1 cup flour", "Mix and bake at 350°F")
    //     .provider(LlmProvider::Ollama)
    //     .build()
    //     .await?;
    //
    // if let ImportResult::Cooklang(cooklang) = result {
    //     println!("Converted with Ollama:");
    //     println!("{}", cooklang);
    // }

    Ok(())
}