Struct Parser

Source

pub struct Parser;

Implementations§

Source §

impl Parser

Source

pub fn parse_events( db: &Connection, option: ParseOption, ) -> Result<EventAnalysis>

Examples found in repository ?

examples/inspect.rs (line 18)

6fn main() -> Result<(), Box<dyn Error>> {
7    let db_path = env::args().nth(1).or_else(|| env::var("KOBO_DB_PATH").ok());
8    let db_path = db_path.ok_or_else(|| {
9        "Usage: cargo run --example inspect -- /path/to/KoboReader.sqlite (or set KOBO_DB_PATH)"
10            .to_string()
11    })?;
12
13    let uri = format!("file:{}?immutable=1", db_path);
14    let conn = Connection::open_with_flags(
15        uri,
16        OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_URI,
17    )?;
18    let analysis = Parser::parse_events(&conn, ParseOption::All)?;
19
20    if let Some(sessions) = &analysis.sessions {
21        println!("sessions: {}", sessions.sessions_count());
22        println!("sessions avg seconds: {:.2}", sessions.avg());
23    } else {
24        println!("sessions: none");
25    }
26
27    if let Some(terms) = &analysis.terms {
28        println!("dictionary terms: {}", terms.len());
29    } else {
30        println!("dictionary terms: none");
31    }
32
33    if let Some(history) = &analysis.brightness_history {
34        println!("brightness events: {}", history.events.len());
35        println!("brightness avg: {:.2}", history.avg());
36    } else {
37        println!("brightness events: none");
38    }
39
40    if let Some(history) = &analysis.natural_light_history {
41        println!("natural light events: {}", history.events.len());
42        println!("natural light avg: {:.2}", history.avg());
43    } else {
44        println!("natural light events: none");
45    }
46
47    if let Some(bookmarks) = &analysis.bookmarks {
48        println!("bookmarks: {}", bookmarks.len());
49    } else {
50        println!("bookmarks: none");
51    }
52
53    if let Some(books) = &analysis.books {
54        println!("books: {}", books.len());
55    } else {
56        println!("books: none");
57    }
58
59    if let Some(app_events) = &analysis.app_events {
60        let app_starts = app_events
61            .iter()
62            .filter(|event| event.kind == AppEventKind::AppStart)
63            .count();
64        let plugged_in = app_events
65            .iter()
66            .filter(|event| event.kind == AppEventKind::PluggedIn)
67            .count();
68        println!("app starts: {}", app_starts);
69        println!("plugged in: {}", plugged_in);
70    } else {
71        println!("app events: none");
72    }
73
74    Ok(())
75}

Source

pub fn parse_correlated(db: &Connection) -> Result<CorrelatedAnalysis>

Examples found in repository ?

examples/correlated.rs (line 18)

6fn main() -> Result<(), Box<dyn Error>> {
7    let db_path = env::args().nth(1).or_else(|| env::var("KOBO_DB_PATH").ok());
8    let db_path = db_path.ok_or_else(|| {
9        "Usage: cargo run --example correlated -- /path/to/KoboReader.sqlite (or set KOBO_DB_PATH)"
10            .to_string()
11    })?;
12
13    let uri = format!("file:{}?immutable=1", db_path);
14    let conn = Connection::open_with_flags(
15        uri,
16        OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_URI,
17    )?;
18    let analysis = Parser::parse_correlated(&conn)?;
19
20    println!("correlated sessions: {}", analysis.sessions.len());
21    if let Some(session) = analysis.sessions.first() {
22        println!(
23            "sample session: {} -> {:?}",
24            session.session.time_start.to_rfc3339(),
25            session.session.time_end.map(|end| end.to_rfc3339())
26        );
27        println!("  dictionary events: {}", session.dictionary.len());
28        println!(
29            "  brightness events: {}",
30            session.brightness.len() + session.natural_light.len()
31        );
32        println!("  app events: {}", session.app_events.len());
33    }
34
35    println!(
36        "orphans: dict {} brightness {} natural {} app {}",
37        analysis.orphans.dictionary.len(),
38        analysis.orphans.brightness.len(),
39        analysis.orphans.natural_light.len(),
40        analysis.orphans.app_events.len()
41    );
42
43    println!("charge cycles: {}", analysis.cycles.len());
44    for (index, cycle) in analysis.cycles.iter().take(3).enumerate() {
45        let end = cycle
46            .end
47            .map(|ts| ts.to_rfc3339())
48            .unwrap_or_else(|| "open".to_string());
49        println!(
50            "cycle {}: {} -> {} | sessions {} | app starts {}",
51            index + 1,
52            cycle.start.to_rfc3339(),
53            end,
54            cycle.sessions.len(),
55            cycle.metrics.app_starts
56        );
57    }
58
59    if !analysis.app_start_counts_by_day.is_empty() {
60        let mut days: Vec<_> = analysis.app_start_counts_by_day.iter().collect();
61        days.sort_by_key(|(day, _)| **day);
62        println!("app starts by day (first 5):");
63        for (day, count) in days.into_iter().take(5) {
64            println!("  {}: {}", day, count);
65        }
66    }
67
68    Ok(())
69}