imdb-async 0.1.0

Opinionated and unopinionated async wrappers to efficiently retrieve and parse IMDB's dataset
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

use std::collections::HashMap;

use futures::stream::StreamExt;

use crate::EpisodeLink;
use crate::Error;
use crate::Title;
use crate::TitleType;
use crate::get_episodes_filtered;
use crate::stream_titles_filtered;

pub async fn get_shows_filtered(ids: &[u64]) -> Result<Vec<Show>, Error> {
	let mut episode_links = get_episodes_filtered(ids).await?;
	let all_ids = {
		let mut v = Vec::from(ids);
		v.extend(episode_links.iter().map(|(id, _)| id));
		v
	};
	let mut episodes_by_show = HashMap::new();
	let mut shows = Vec::with_capacity(ids.len());
	let mut stream = stream_titles_filtered(&all_ids).await?;
	while let Some(result) = stream.next().await {
		let title = result?;
		if let Some(link) = episode_links.remove(&title.imdb_id) {
			let series_id = link.series_imdb_id;
			if let Some(result) = Episode::from_title_and_link(title, link) {
				let episode = result?;
				let episodes = episodes_by_show.entry(series_id).or_insert_with(|| Vec::new());
				episodes.push(episode);
			}
			continue;
		}
		shows.push(match Show::from_title(&title) {
			Some(Ok(v)) => v,
			Some(Err(e)) => return Err(e),
			None => continue
		});
	}
	for show in shows.iter_mut() {
		show.episodes = match episodes_by_show.remove(&show.imdb_id) {
			Some(v) => v,
			None => Vec::new()
		};
	}
	Ok(shows)
}

#[derive(Debug)]
pub struct Show {
	pub imdb_id: u64,
	pub title: String,
	pub is_adult: bool,
	pub start_year: u16,
	pub end_year: Option<u16>,
	pub runtime_minutes: Option<u16>,
	pub genres: Vec<String>,
	pub episodes: Vec<Episode>
}

impl Show {
	pub(crate) fn from_title(input: &Title) -> Option<Result<Self, Error>> {
		match input.title_type {
			TitleType::TVSeries => Some(Ok(Self{
				imdb_id: input.imdb_id,
				title: input.primary_title.clone(),
				is_adult: input.is_adult != 0,
				start_year: match input.start_year {
					Some(v) => v,
					None => return Some(Err(Error::YearMissing.into()))
				},
				end_year: input.end_year,
				runtime_minutes: input.runtime_minutes,
				genres: input.genres.clone(),
				episodes: Vec::new()
			})),
			_ => None
		}
	}

	fn from_wrapped_title(input: Result<Title, Error>) -> Option<Result<Self, Error>> {
		match input {
			Ok(t) => Self::from_title(&t),
			Err(e) => Some(Err(e))
		}
	}
}

#[derive(Debug)]
pub struct Episode {
	pub season: u16,
	pub episode: u16,
	pub imdb_id: u64,
	pub title: String,
	pub runtime_minutes: Option<u16>
}

impl Episode {
	pub(crate) fn from_title_and_link(title: Title, link: EpisodeLink) -> Option<Result<Self, Error>> {
		match title.title_type {
			TitleType::Episode => Some(Ok(Self{
				season: match link.season {
					Some(v) => v,
					None => return Some(Err(Error::SeasonMissing.into()))
				},
				episode: match link.episode {
					Some(v) => v,
					None => return Some(Err(Error::EpisodeMissing.into()))
				},
				imdb_id: title.imdb_id,
				title: title.primary_title,
				runtime_minutes: title.runtime_minutes
			})),
			_ => None
		}
	}
}