cameo 0.2.0

Unified movie/TV show database SDK for Rust
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Unified provider-trait implementations for [`AniListClient`].
//!
//! AniList supports search, details, and discovery. It does not implement the
//! recommendation, season, or watch-availability traits, so the facade reports
//! those capabilities as [`Unsupported`](crate::unified::CameoClientError::Unsupported)
//! when AniList is the only configured provider.

use async_trait::async_trait;

use super::client::AniListClient;
use crate::{
    core::{config::TimeWindow, error::ProviderError, pagination::Page},
    unified::{
        media_id::{MediaId, NativeId},
        models::{
            UnifiedMovie, UnifiedMovieDetails, UnifiedPerson, UnifiedPersonDetails,
            UnifiedSearchResult, UnifiedTvShow, UnifiedTvShowDetails,
        },
        traits::{Capability, DetailProvider, DiscoveryProvider, Provider, SearchProvider},
    },
};

const ANILIST_CAPABILITIES: &[Capability] = &[
    Capability::Search,
    Capability::Details,
    Capability::Discovery,
];

impl Provider for AniListClient {
    fn id(&self) -> &str {
        "anilist"
    }

    fn capabilities(&self) -> &[Capability] {
        ANILIST_CAPABILITIES
    }
}

/// Extract the numeric AniList id from a [`MediaId`], handling namespaced staff
/// ids (`anilist:staff:95061`) as well as plain media ids (`anilist:1`).
fn anilist_id(id: &MediaId) -> Result<i32, ProviderError> {
    if id.provider() != "anilist" {
        return Err(ProviderError::InvalidInput(format!(
            "expected an anilist id, got {id}"
        )));
    }
    let numeric = match id.native() {
        NativeId::Num(n) => *n,
        // e.g. "staff:95061" -> 95061
        NativeId::Text(s) => s
            .rsplit(':')
            .next()
            .and_then(|part| part.parse::<u64>().ok())
            .ok_or_else(|| {
                ProviderError::InvalidInput(format!("not a numeric AniList id: {id}"))
            })?,
    };
    i32::try_from(numeric)
        .map_err(|_| ProviderError::InvalidInput(format!("AniList id out of range: {id}")))
}

#[async_trait]
impl SearchProvider for AniListClient {
    async fn search_movies(
        &self,
        query: &str,
        page: Option<u32>,
    ) -> Result<Page<UnifiedMovie>, ProviderError> {
        Ok(AniListClient::search_movies(self, query, page).await?)
    }

    async fn search_tv_shows(
        &self,
        query: &str,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, ProviderError> {
        Ok(AniListClient::search_tv_shows(self, query, page).await?)
    }

    async fn search_people(
        &self,
        query: &str,
        page: Option<u32>,
    ) -> Result<Page<UnifiedPerson>, ProviderError> {
        Ok(AniListClient::search_people(self, query, page).await?)
    }

    async fn search_multi(
        &self,
        query: &str,
        page: Option<u32>,
    ) -> Result<Page<UnifiedSearchResult>, ProviderError> {
        Ok(AniListClient::search_multi(self, query, page).await?)
    }
}

#[async_trait]
impl DetailProvider for AniListClient {
    async fn movie_details(&self, id: &MediaId) -> Result<UnifiedMovieDetails, ProviderError> {
        Ok(AniListClient::movie_details(self, anilist_id(id)?).await?)
    }

    async fn tv_show_details(&self, id: &MediaId) -> Result<UnifiedTvShowDetails, ProviderError> {
        Ok(AniListClient::tv_show_details(self, anilist_id(id)?).await?)
    }

    async fn person_details(&self, id: &MediaId) -> Result<UnifiedPersonDetails, ProviderError> {
        Ok(AniListClient::person_details(self, anilist_id(id)?).await?)
    }
}

#[async_trait]
impl DiscoveryProvider for AniListClient {
    async fn trending_movies(
        &self,
        time_window: TimeWindow,
        page: Option<u32>,
    ) -> Result<Page<UnifiedMovie>, ProviderError> {
        Ok(AniListClient::trending_movies(self, time_window, page).await?)
    }

    async fn trending_tv_shows(
        &self,
        time_window: TimeWindow,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, ProviderError> {
        Ok(AniListClient::trending_tv(self, time_window, page).await?)
    }

    async fn popular_movies(&self, page: Option<u32>) -> Result<Page<UnifiedMovie>, ProviderError> {
        Ok(AniListClient::popular_movies(self, page).await?)
    }

    async fn top_rated_movies(
        &self,
        page: Option<u32>,
    ) -> Result<Page<UnifiedMovie>, ProviderError> {
        Ok(AniListClient::top_rated_movies(self, page).await?)
    }

    async fn popular_tv_shows(
        &self,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, ProviderError> {
        Ok(AniListClient::popular_tv_shows(self, page).await?)
    }

    async fn top_rated_tv_shows(
        &self,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, ProviderError> {
        Ok(AniListClient::top_rated_tv_shows(self, page).await?)
    }
}