dply 0.3.5

A command line data manipulation tool inspired by the dplyr grammar.
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
123

// Copyright (C) 2023 Vince Vasta
// SPDX-License-Identifier: Apache-2.0
use anyhow::Result;
use comfy_table::presets;
use comfy_table::{ColumnConstraint, ContentArrangement, Width};
use comfy_table::{Row, Table};
use polars::prelude::*;
use std::{env, io::Write};

/// Prints a dataframe in test format, used for test comparisons.
pub fn df_test(out: &mut dyn Write, df: DataFrame) -> Result<()> {
    env::set_var("POLARS_FMT_TABLE_CELL_LIST_LEN", "6");

    let height = df.height();

    let (row, cols) = df.shape();
    writeln!(out, "shape: ({}, {})", row, cols)?;

    // Write columns
    let row = df
        .fields()
        .into_iter()
        .map(|f| f.name().to_string())
        .collect::<Vec<_>>()
        .join("|");
    writeln!(out, "{row}")?;

    // Write columns types
    let row = df
        .fields()
        .into_iter()
        .map(|f| f.dtype.to_string())
        .collect::<Vec<_>>()
        .join("|");
    writeln!(out, "{row}")?;

    // Header separator
    writeln!(out, "---")?;

    // Write values
    for i in 0..height {
        let row = df
            .get_columns()
            .iter()
            .map(|s| s.get(i).unwrap().str_value())
            .collect::<Vec<_>>()
            .join("|");
        writeln!(out, "{row}")?;
    }

    // Data separator
    writeln!(out, "---")?;

    Ok(())
}

/// Prints a dataframe in glimpse format.
pub fn glimpse(w: &mut dyn Write, df: LazyFrame) -> Result<()> {
    let num_rows = df
        .clone()
        .count()
        .collect()?
        .max_horizontal()?
        .unwrap_or_default()
        .u32()?
        .max()
        .unwrap_or_default() as usize;

    let df = df.fetch(100)?;
    let num_cols = df.get_columns().len();

    let mut table = Table::new();
    table.set_content_arrangement(ContentArrangement::DynamicFullWidth);
    table.load_preset(presets::UTF8_FULL_CONDENSED);

    let info = format!(
        "Rows: {}\nCols: {}",
        fmt_usize(num_rows),
        fmt_usize(num_cols)
    );
    table.set_header(vec![info, "Type".into(), "Values".into()]);

    if let Ok(slen) = std::env::var("POLARS_FMT_STR_LEN") {
        table.set_width(slen.parse()?);
    }

    for col in df.get_columns() {
        let mut row = Row::new();
        row.add_cell(col.name().into());
        row.add_cell(format!("{}", col.dtype()).into());

        let mut values = Vec::with_capacity(10);
        for idx in 0..col.len() {
            let value = col.get(idx).unwrap().str_value();
            values.push(value);
        }

        row.add_cell(values.join(", ").into());
        row.max_height(1);

        table.add_row(row);
    }

    table.set_constraints(vec![
        ColumnConstraint::LowerBoundary(Width::Fixed(10)),
        ColumnConstraint::LowerBoundary(Width::Fixed(8)),
        ColumnConstraint::UpperBoundary(Width::Percentage(90)),
    ]);

    writeln!(w, "{table}")?;
    Ok(())
}

fn fmt_usize(n: usize) -> String {
    // Colon separated groups of 3.
    let mut s = n.to_string();

    for idx in (1..s.len().max(2) - 2).rev().step_by(3) {
        s.insert(idx, ',');
    }

    s
}