veloxx 0.4.0

Veloxx: High-performance, lightweight Rust library for in-memory data processing and analytics. Features DataFrames, Series, advanced I/O (CSV, JSON, Parquet), machine learning (linear regression, K-means, logistic regression), time-series analysis, data visualization, parallel processing, and multi-platform bindings (Python, WebAssembly). Designed for minimal dependencies, optimal memory usage, and blazing speed - ideal for data science, analytics, and performance-critical applications.
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

#[cfg(target_arch = "wasm32")]
#[derive(Debug, Clone, PartialEq)]
pub enum VeloxxError {
    ColumnNotFound(String),
    InvalidOperation(String),
    DataTypeMismatch(String),
    FileIO(String),
    Parsing(String),
    Unsupported(String),
    MemoryError(String),
    ExecutionError(String),
    Other(String),
}

#[cfg(target_arch = "wasm32")]
impl std::fmt::Display for VeloxxError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            VeloxxError::ColumnNotFound(msg) => write!(f, "Column not found: {}", msg),
            VeloxxError::InvalidOperation(msg) => write!(f, "Invalid operation: {}", msg),
            VeloxxError::DataTypeMismatch(msg) => write!(f, "Data type mismatch: {}", msg),
            VeloxxError::FileIO(msg) => write!(f, "File I/O error: {}", msg),
            VeloxxError::Parsing(msg) => write!(f, "Parsing error: {}", msg),
            VeloxxError::Unsupported(msg) => write!(f, "Unsupported operation: {}", msg),
            VeloxxError::MemoryError(msg) => write!(f, "Memory error: {}", msg),
            VeloxxError::ExecutionError(msg) => write!(f, "Execution error: {}", msg),
            VeloxxError::Other(msg) => write!(f, "Error: {}", msg),
        }
    }
}

#[cfg(target_arch = "wasm32")]
impl std::error::Error for VeloxxError {}
// This file handles error types for the Veloxx library.
// Ensure that any error handling that uses non-WASM-compatible dependencies
// is feature gated and excluded from WASM builds.
#[cfg(not(target_arch = "wasm32"))]
use thiserror::Error;

/// Custom error type for the Veloxx library.
///
/// This enum unifies error handling across the library, providing specific error variants
/// for common issues like column not found, invalid operations, data type mismatches,
/// and I/O errors.
///
/// # Examples
///
/// ```rust
/// use veloxx::error::VeloxxError;
///
/// // Example of creating a ColumnNotFound error
/// let err = VeloxxError::ColumnNotFound("my_column".to_string());
/// println!("Error: {}", err);
/// // Output: Error: Column not found: my_column
///
/// // Example of creating an InvalidOperation error
/// let err = VeloxxError::InvalidOperation("Cannot divide by zero".to_string());
/// println!("Error: {}", err);
/// // Output: Error: Invalid operation: Cannot divide by zero
/// ```
#[cfg(not(target_arch = "wasm32"))]
#[derive(Error, Debug, PartialEq)]
pub enum VeloxxError {
    #[error("Column not found: {0}")]
    ColumnNotFound(String),
    #[error("Invalid operation: {0}")]
    InvalidOperation(String),
    #[error("Data type mismatch: {0}")]
    DataTypeMismatch(String),
    #[error("File I/O error: {0}")]
    FileIO(String),
    #[error("Parsing error: {0}")]
    Parsing(String),
    #[error("Unsupported feature: {0}")]
    Unsupported(String),
    #[error("Memory error: {0}")]
    MemoryError(String),
    #[error("Execution error: {0}")]
    ExecutionError(String),
    #[error("Other error: {0}")]
    Other(String),
}

#[cfg(not(target_arch = "wasm32"))]
impl From<std::io::Error> for VeloxxError {
    fn from(err: std::io::Error) -> Self {
        VeloxxError::FileIO(err.to_string())
    }
}

#[cfg(not(target_arch = "wasm32"))]
impl From<std::string::FromUtf8Error> for VeloxxError {
    fn from(err: std::string::FromUtf8Error) -> Self {
        VeloxxError::Parsing(err.to_string())
    }
}

#[cfg(all(feature = "advanced_io", not(target_arch = "wasm32")))]
impl From<parquet::errors::ParquetError> for VeloxxError {
    fn from(err: parquet::errors::ParquetError) -> Self {
        VeloxxError::FileIO(err.to_string())
    }
}

#[cfg(all(feature = "arrow", not(target_arch = "wasm32")))]
impl From<arrow::error::ArrowError> for VeloxxError {
    fn from(err: arrow::error::ArrowError) -> Self {
        VeloxxError::Parsing(err.to_string())
    }
}

#[cfg(all(feature = "python", not(target_arch = "wasm32")))]
impl From<VeloxxError> for pyo3::PyErr {
    fn from(err: VeloxxError) -> Self {
        pyo3::exceptions::PyValueError::new_err(err.to_string())
    }
}