xls-rs 0.1.1

A powerful CLI tool and library for spreadsheet manipulation with pandas-style operations. Supports CSV, Excel (XLSX, XLS, ODS), Parquet, and Avro formats with formula evaluation, data transformation, and comprehensive analytics capabilities.
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Advanced command handlers
//!
//! Implements advanced features like validation, charting, encryption, batch processing, etc.

use crate::cli::commands::advanced;
use anyhow::Result;

/// Advanced command handler
#[derive(Default)]
pub struct AdvancedCommandHandler;

impl AdvancedCommandHandler {
    /// Create a new advanced command handler
    pub fn new() -> Self {
        Self::default()
    }

    /// Handle the profile command
    pub fn handle_profile(&self, input: String, output: Option<String>) -> Result<()> {
        advanced::handle_profile(input, output)
    }

    /// Handle the schema command
    pub fn handle_schema(&self, input: String, output: Option<String>) -> Result<()> {
        advanced::handle_schema(input, output)
    }

    /// Handle the to-sql command
    pub fn handle_to_sql(
        &self,
        input: String,
        table: String,
        output: Option<String>,
        batch_size: Option<usize>,
    ) -> Result<()> {
        advanced::handle_to_sql(input, table, output, batch_size)
    }

    /// Handle the validate command
    pub fn handle_validate(
        &self,
        input: String,
        rules: String,
        output: Option<String>,
        report: Option<String>,
    ) -> Result<()> {
        advanced::handle_validate(input, rules, output, report)
    }

    /// Handle the chart command
    pub fn handle_chart(
        &self,
        input: String,
        output: String,
        chart_type: String,
        title: Option<String>,
        x_column: Option<String>,
        y_column: Option<String>,
    ) -> Result<()> {
        advanced::handle_chart(input, output, chart_type, title, x_column, y_column)
    }

    /// Handle the encrypt command
    pub fn handle_encrypt(
        &self,
        input: String,
        output: String,
        algorithm: String,
        key_file: Option<String>,
    ) -> Result<()> {
        advanced::handle_encrypt(input, output, algorithm, key_file)
    }

    /// Handle the decrypt command
    pub fn handle_decrypt(
        &self,
        input: String,
        output: String,
        key_file: Option<String>,
    ) -> Result<()> {
        advanced::handle_decrypt(input, output, key_file)
    }

    /// Handle the batch command
    pub fn handle_batch(
        &self,
        inputs: String,
        output_dir: String,
        operation: String,
        args: Vec<String>,
    ) -> Result<()> {
        advanced::handle_batch(inputs, output_dir, operation, args)
    }

    /// Handle the plugin command
    pub fn handle_plugin(
        &self,
        function: String,
        input: String,
        output: String,
        args: Vec<String>,
    ) -> Result<()> {
        advanced::handle_plugin(function, input, output, args)
    }

    /// Handle the stream command
    pub fn handle_stream(&self, input: String, output: String, chunk_size: usize) -> Result<()> {
        advanced::handle_stream(input, output, chunk_size)
    }

    /// Handle the completions command
    pub fn handle_completions(&self, shell: String) -> Result<()> {
        advanced::handle_completions(shell)
    }

    /// Handle the config_init command
    pub fn handle_config_init(&self) -> Result<()> {
        advanced::handle_config_init()
    }

    /// Handle the watch command
    pub fn handle_watch(&self, input: String, command: String) -> Result<()> {
        advanced::handle_watch(input, command)
    }

    /// Handle the export_styled command
    pub fn handle_export_styled(
        &self,
        input: String,
        output: String,
        style: Option<String>,
    ) -> Result<()> {
        advanced::handle_export_styled(input, output, style)
    }

    /// Handle the examples_generate command
    pub fn handle_examples_generate(&self) -> Result<()> {
        advanced::handle_examples_generate()
    }
}