lace 0.9.1

A probabilistic cross-categorization engine
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

use std::fs::File;
use std::num::NonZero;
use std::path::Path;

use polars::prelude::CsvReadOptions;
use polars::prelude::DataFrame;
use polars::prelude::IpcReader;
use polars::prelude::JsonFormat;
use polars::prelude::JsonReader;
use polars::prelude::ParquetReader;
use polars::prelude::SerReader;

use super::ReadError;

pub fn read_parquet<P: AsRef<Path>>(path: P) -> Result<DataFrame, ReadError> {
    let mut file = File::open(path)?;
    let df = ParquetReader::new(&mut file).finish()?;
    Ok(df)
}

pub fn read_ipc<P: AsRef<Path>>(path: P) -> Result<DataFrame, ReadError> {
    let mut file = File::open(path)?;
    let df = IpcReader::new(&mut file).finish()?;
    Ok(df)
}

pub fn read_json<P: AsRef<Path>>(path: P) -> Result<DataFrame, ReadError> {
    let ext: String = path.as_ref().extension().map_or_else(
        || String::from(""),
        |ext| ext.to_string_lossy().to_lowercase(),
    );

    let format = match ext.as_str() {
        "json" => JsonFormat::Json,
        "jsonl" => JsonFormat::JsonLines,
        _ => JsonFormat::JsonLines,
    };

    let mut file = File::open(path)?;

    let df = JsonReader::new(&mut file)
        .infer_schema_len(NonZero::new(1000))
        .with_json_format(format)
        .finish()?;

    Ok(df)
}

pub fn read_csv<P: AsRef<Path>>(path: P) -> Result<DataFrame, ReadError> {
    let df = CsvReadOptions::default()
        .with_infer_schema_length(Some(1000))
        .with_has_header(true)
        .try_into_reader_with_file_path(Some(path.as_ref().into()))?
        .finish()?;
    Ok(df)
}

macro_rules! codebook_from_fn {
    ($fn_name: ident, $reader: ident) => {
        pub fn $fn_name<P: AsRef<Path>>(
            path: P,
            cat_cutoff: Option<u32>,
            state_prior_process: Option<$crate::codebook::PriorProcess>,
            view_prior_process: Option<$crate::codebook::PriorProcess>,
            no_hypers: bool,
        ) -> Result<
            $crate::codebook::Codebook,
            $crate::codebook::error::CodebookError,
        > {
            let df = $reader(path).unwrap();
            $crate::codebook::data::df_to_codebook(
                &df,
                cat_cutoff,
                state_prior_process,
                view_prior_process,
                no_hypers,
            )
        }
    };
}

codebook_from_fn!(codebook_from_csv, read_csv);
codebook_from_fn!(codebook_from_parquet, read_parquet);
codebook_from_fn!(codebook_from_ipc, read_ipc);
codebook_from_fn!(codebook_from_json, read_json);