venus 0.1.1

Reactive notebook environment for Rust
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

//! Run command implementation for Venus CLI.
//!
//! Executes a notebook headlessly, compiling and running all cells.

use std::time::Instant;

use crate::colors;
use crate::executor::NotebookExecutor;
use crate::output::print_output;

/// Execute a notebook.
pub fn execute(
    notebook_path: &str,
    cell_filter: Option<&str>,
    release: bool,
) -> anyhow::Result<()> {
    let start = Instant::now();

    // Create executor (handles parsing, graph building, universe)
    let executor = NotebookExecutor::new(notebook_path, release)?;
    executor.print_header("Running");

    // Handle empty notebooks
    if executor.cells.is_empty() {
        println!(
            "\n{}No cells found in notebook.{}",
            colors::YELLOW,
            colors::RESET
        );
        println!("Cells are functions marked with #[venus::cell]");
        return Ok(());
    }

    // Compile cells
    let compilation = executor.compile()?;

    // Execute cells
    let execution = executor.execute(&compilation, cell_filter)?;

    // Print outputs
    println!("\n{}Outputs:{}", colors::BOLD, colors::RESET);
    println!("{}", "─".repeat(50));

    for &cell_id in &execution.executed_cells {
        if let Some(cell) = executor.cell_by_id(cell_id)
            && let Some(output) = execution.outputs.get(&cell_id)
        {
            print_output(&cell.name, &cell.return_type, output.bytes());
        }
    }

    // Summary
    let total_time = start.elapsed();
    println!("\n{}", "─".repeat(50));
    println!(
        "{}Completed{} {} cells in {:.2}s (execution: {:.2}s)",
        colors::GREEN,
        colors::RESET,
        execution.executed_cells.len(),
        total_time.as_secs_f64(),
        execution.execution_time.as_secs_f64()
    );

    Ok(())
}