tabiew 0.16.0

A lightweight TUI application to view and query tabular data files, such as CSV, TSV, and parquet.
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

use polars::datatypes::DataType;
use serde::{Deserialize, Serialize};

use crate::tui;

#[derive(Debug, Serialize, Deserialize)]
pub struct Tabs {
    tabs: Vec<Pane>,
    selected: usize,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Pane {
    table_stack: Vec<Table>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Table {
    schema: Vec<Field>,
    offset: usize,
    rendered_rows: usize,
    description: Description,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Field {
    name: String,
    dtype: DataType,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Description {
    key: String,
    val: String,
}

impl From<&tui::tabs::Tabs> for Tabs {
    fn from(value: &tui::tabs::Tabs) -> Self {
        Self {
            tabs: value.iter().map(Pane::from).collect(),
            selected: value.idx(),
        }
    }
}

impl From<&tui::Pane> for Pane {
    fn from(value: &tui::Pane) -> Self {
        Self {
            table_stack: value
                .iter_tables()
                .zip(value.iter_descriptions())
                .map(|(table, description)| Table::new(table, description))
                .collect(),
        }
    }
}

impl Table {
    fn new(table: &tui::table::Table, description: &tui::pane::TableDescription) -> Self {
        Self {
            schema: table
                .data_frame()
                .schema()
                .iter()
                .map(|(name, dtype)| Field {
                    name: name.to_string(),
                    dtype: dtype.clone(),
                })
                .collect(),
            offset: table.offset(),
            rendered_rows: table.rendered_rows(),
            description: description.into(),
        }
    }
}

impl From<&tui::pane::TableDescription> for Description {
    fn from(value: &tui::pane::TableDescription) -> Self {
        Self {
            key: value.variant().to_owned(),
            val: value.description().to_owned(),
        }
    }
}