javelin-tui 0.10.0

Display and work with Lance matrices
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
117
118
119
120
121
122

use anyhow::{Error, anyhow};
use clap::Parser;
use tokio::runtime::Runtime;

use javelin_tui::functions::{
    display::cmd_display, generate::cmd_generate, head::cmd_head, info::cmd_info,
    sample::cmd_sample, stats::cmd_stats, tui::run_tui,
};

// #[cfg(feature = "search")]
// use javelin_tui::functions::{search::search_cmd, vector_space::vector_space_cmd};

use javelin_tui::{Cli, Command};

#[derive(Debug)]
#[allow(unused)]
enum AppError {
    Info(Error),
    Head(Error),
    Sample(Error),
    Stats(Error),
    Display(Error),
    Tui(Error),
    Generate(Error),
    Other(Error),
}

use std::fmt;

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::Info(e) => write!(f, "info command failed: {e}"),
            AppError::Head(e) => write!(f, "head command failed: {e}"),
            AppError::Sample(e) => write!(f, "sample command failed: {e}"),
            AppError::Stats(e) => write!(f, "stats command failed: {e}"),
            AppError::Display(e) => write!(f, "display command failed: {e}"),
            AppError::Tui(e) => write!(f, "tui command failed: {e}"),
            AppError::Generate(e) => write!(f, "generate command failed: {e}"),
            AppError::Other(e) => write!(f, "command failed: {e}"),
        }
    }
}

fn main() -> anyhow::Result<()> {
    use std::process::exit;

    javelin_tui::init();
    let args = Cli::parse();

    let rt = Runtime::new().expect("failed to create Tokio runtime");

    // Default to Tui when no subcommand is supplied
    let cmd = args.cmd.unwrap_or(Command::Tui);

    let result = match cmd {
        Command::Info => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                cmd_info(&filepath).await
            })
            .map_err(AppError::Info),
        Command::Head { n } => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                cmd_head(&filepath, n).await
            })
            .map_err(AppError::Head),
        Command::Sample { n } => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                cmd_sample(&filepath, n).await
            })
            .map_err(AppError::Sample),
        Command::Stats => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                cmd_stats(&filepath).await
            })
            .map_err(AppError::Stats),
        Command::Tui => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                run_tui(filepath).await
            })
            .map_err(AppError::Tui),
        Command::Display => rt
            .block_on(async {
                let filepath = args
                    .filepath
                    .ok_or_else(|| anyhow!("--filepath is required for this command"))?;
                cmd_display(&filepath).await
            })
            .map_err(AppError::Display),
        Command::Generate {
            n_items,
            n_dims,
            seed,
        } => rt
            .block_on(async {
                println!("Generating sample dataset in ./test_javelin");
                cmd_generate(n_items, n_dims, seed).await
            })
            .map_err(AppError::Generate),
    };

    if let Err(e) = result {
        eprintln!("Error: {e:?}");
        exit(1);
    }
    Ok(())
}