animedb 0.4.0

Local-first anime and manga metadata catalog for Rust media servers
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

use animedb::{
    AnimeDb, ImdbProvider, MediaKind, RemoteApi, SearchOptions, SourceName, SyncRequest,
    TvmazeProvider,
};
use std::env;
use std::path::PathBuf;

fn main() -> animedb::Result<()> {
    let args: Vec<String> = env::args().collect();
    let db_path = args
        .get(1)
        .map(PathBuf::from)
        .unwrap_or_else(|| env::temp_dir().join("animedb-e2e-test.sqlite"));

    let mode = args.get(2).map(|s| s.as_str()).unwrap_or("--run-all");

    match mode {
        "--create-only" => {
            println!("Creating database at {}", db_path.display());
            let _db = AnimeDb::open(&db_path)?;
            println!("Database created successfully");
        }
        "--sync-tvmaze" => {
            let pages = args
                .iter()
                .position(|a| a == "--pages")
                .and_then(|i| args.get(i + 1)?.parse::<usize>().ok())
                .unwrap_or(2);
            let page_size = args
                .iter()
                .position(|a| a == "--page-size")
                .and_then(|i| args.get(i + 1)?.parse::<usize>().ok())
                .unwrap_or(10);

            println!("Syncing TVmaze: {} pages, {} per page", pages, page_size);

            let mut db = AnimeDb::open(&db_path)?;
            let provider = TvmazeProvider::default();

            let outcome = db.sync_from(
                &provider,
                SyncRequest::new(SourceName::Tvmaze)
                    .with_media_kind(MediaKind::Show)
                    .with_page_size(page_size)
                    .with_max_pages(pages),
            )?;

            println!(
                "TVmaze sync complete: {} records, {} pages",
                outcome.upserted_records, outcome.fetched_pages
            );
        }
        "--sync-imdb" => {
            let media_kind_str = args
                .iter()
                .position(|a| a == "--media-kind")
                .and_then(|i| args.get(i + 1)?.parse::<MediaKind>().ok())
                .unwrap_or(MediaKind::Movie);
            let pages = args
                .iter()
                .position(|a| a == "--pages")
                .and_then(|i| args.get(i + 1)?.parse::<usize>().ok())
                .unwrap_or(1);
            let page_size = args
                .iter()
                .position(|a| a == "--page-size")
                .and_then(|i| args.get(i + 1)?.parse::<usize>().ok())
                .unwrap_or(50);

            println!(
                "Syncing IMDb: {} pages, {} per page, kind: {:?}",
                pages, page_size, media_kind_str
            );

            let mut db = AnimeDb::open(&db_path)?;
            let provider = ImdbProvider::default();

            let outcome = db.sync_from(
                &provider,
                SyncRequest::new(SourceName::Imdb)
                    .with_media_kind(media_kind_str)
                    .with_page_size(page_size)
                    .with_max_pages(pages),
            )?;

            println!(
                "IMDb sync complete: {} records, {} pages",
                outcome.upserted_records, outcome.fetched_pages
            );
        }
        "--remote-search" => {
            let default_query = "breaking bad".to_string();
            let query = args.get(3).unwrap_or(&default_query);
            println!("Remote searching TVmaze for: {}", query);

            let api = RemoteApi::tvmaze();
            let results = api.search(
                query,
                SearchOptions::default().with_media_kind(MediaKind::Show),
            )?;

            println!("Found {} results:", results.len());
            for media in results.iter().take(5) {
                println!("  - {} (kind: {:?})", media.title_display, media.media_kind);
            }
        }
        _ => {
            println!("Usage:");
            println!("  e2e_test_runner <db_path> --create-only");
            println!("  e2e_test_runner <db_path> --sync-tvmaze [--pages N] [--page-size N]");
            println!(
                "  e2e_test_runner <db_path> --sync-imdb [--media-kind movie|show] [--pages N] [--page-size N]"
            );
            println!("  e2e_test_runner <db_path> --remote-search <query>");
        }
    }

    Ok(())
}