def __init__(self):
self.apiKey = g.get_setting("tmdb.apikey",
"9f3ca569aa46b6fb13931ec96ab8ae7e")
self.lang_code = g.get_language_code()
self.lang_full_code = g.get_language_code(True)
self.lang_region_code = self.lang_full_code.split("-")[1]
if self.lang_region_code == "":
self.lang_full_code = self.lang_full_code.strip("-")
self.include_languages = [
self.lang_code, "en", "null"
] if not self.lang_code == "en" else ["en", "null"]
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize")
self.artwork_size = {}
self._set_artwork()
self.art_normalization = [
("backdrops", "fanart", None),
(
"posters",
"poster",
lambda x: x["iso_639_1"] != "xx" and x["iso_639_1"] is
not None,
),
(
"posters",
"keyart",
lambda x: x["iso_639_1"] == "xx" or x["iso_639_1"] is None,
),
("stills", "fanart", None),
]
def __init__(self):
self.apiKey = g.get_setting("tmdb.apikey",
"9f3ca569aa46b6fb13931ec96ab8ae7e")
self.lang_code = g.get_language_code()
self.lang_full_code = g.get_language_code(True)
self.lang_region_code = self.lang_full_code.split("-")[1]
if self.lang_region_code == "":
self.lang_full_code = self.lang_full_code.strip("-")
self.include_languages = OrderedDict.fromkeys(
[self.lang_code, "en", "null"])
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize")
self.artwork_size = {}
self._set_artwork()
self.art_normalization = [
("backdrops", "fanart", None),
(
"posters",
"poster",
lambda x: x["iso_639_1"] != "xx" and x["iso_639_1"] is
not None,
),
(
"posters",
"keyart",
lambda x: x["iso_639_1"] == "xx" or x["iso_639_1"] is None,
),
("stills", "fanart", None),
]
self.meta_hash = tools.md5_hash((
self.lang_code,
self.lang_full_code,
self.lang_region_code,
self.include_languages,
self.preferred_artwork_size,
self.append_to_response,
self.baseUrl,
self.imageBaseUrl,
))
self.session = requests.Session()
retries = Retry(total=5,
backoff_factor=0.1,
status_forcelist=[500, 502, 503, 504])
self.session.mount("https://",
HTTPAdapter(max_retries=retries, pool_maxsize=100))
def __init__(self):
self.session = requests.Session()
self.session.mount("https://", HTTPAdapter(max_retries=self.retries))
self._load_settings()
self.lang_code = g.get_language_code(False)
self.languages = ([None, self.lang_code] if self.lang_code != "en"
and any(self.lang_code == i["abbreviation"]
for i in self.supported_languages) else
[None])
if not self.jwToken:
self.init_token()
else:
self.try_refresh_token()
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize")
self.meta_hash = tools.md5_hash((
self.lang_code,
self.art_map,
self.baseUrl,
self.imageBaseUrl,
self.preferred_artwork_size,
))
def __init__(self):
self.apiKey = g.get_setting("tvdb.apikey", "43VPI0R8323FB7TI")
self.jwToken = g.get_setting("tvdb.jw")
self.tokenExpires = g.get_float_setting("tvdb.expiry")
self.lang_code = g.get_language_code(False)
self.languages = ([None, self.lang_code] if self.lang_code != "en"
and any(self.lang_code == i["abbreviation"]
for i in self.supported_languages) else
[None])
if not self.jwToken:
self.init_token()
else:
self.try_refresh_token()
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize")
self.meta_hash = tools.md5_hash((
self.lang_code,
self.art_map,
self.baseUrl,
self.imageBaseUrl,
self.preferred_artwork_size,
))
def __init__(self):
self.trakt = TraktAPI()
self.language_code = g.get_language_code()
self.trakt_database = TraktSyncDatabase()
self.hidden_database = hidden.TraktSyncDatabase()
self.bookmark_database = bookmark.TraktSyncDatabase()
self.shows_database = shows.TraktSyncDatabase()
self.list_builder = ListBuilder()
self.page_limit = g.get_int_setting("item.limit")
def _pull_show_seasons(self, show_id, mill_episodes=False):
return {
show_id:
self.trakt_api.get_json(
"/shows/{}/seasons".format(show_id),
extended="full,episodes" if mill_episodes else "full",
translations=g.get_language_code(),
)
}
def __init__(self):
self.language = g.get_language_code()
self.client_key = g.get_setting('fanart.apikey')
self.fanart_support = False if not self.client_key else True
self.headers = {'client-key': self.client_key, 'api-key': self.api_key}
self.meta_hash = tools.md5_hash([
self.language, self.fanart_support, self.normalization,
self.show_normalization, self.meta_objects, self.base_url
])
def __init__(self):
self.apiKey = g.get_setting("tmdb.apikey",
"9f3ca569aa46b6fb13931ec96ab8ae7e")
self.lang_code = g.get_language_code()
self.lang_full_code = g.get_language_code(True)
self.lang_region_code = self.lang_full_code.split("-")[1]
if self.lang_region_code == "":
self.lang_full_code = self.lang_full_code.strip("-")
self.include_languages = OrderedDict.fromkeys(
[self.lang_code, "en", "null"])
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize")
self.artwork_size = {}
self._set_artwork()
self.art_normalization = [
("backdrops", "fanart", None),
(
"posters",
"poster",
lambda x: x["iso_639_1"] != "xx" and x["iso_639_1"] is
not None,
),
(
"posters",
"keyart",
lambda x: x["iso_639_1"] == "xx" or x["iso_639_1"] is None,
),
("stills", "fanart", None),
]
self.meta_hash = tools.md5_hash((
self.lang_code,
self.lang_full_code,
self.lang_region_code,
self.include_languages,
self.preferred_artwork_size,
self.append_to_response,
self.baseUrl,
self.imageBaseUrl,
))
def __init__(self):
self.language = g.get_language_code()
self.client_key = g.get_setting('fanart.apikey')
self.fanart_support = False if not self.client_key else True
self.headers = {'client-key': self.client_key, 'api-key': self.api_key}
self.meta_hash = tools.md5_hash(
[self.language, self.fanart_support, self.normalization, self.show_normalization, self.meta_objects,
self.base_url])
self.session = requests.Session()
retries = Retry(total=5,
backoff_factor=0.1,
status_forcelist=[500, 502, 503, 504])
self.session.mount('https://', HTTPAdapter(max_retries=retries))
def shows_new(self):
hidden_items = self.hidden_database.get_hidden_items(
"recommendations", "shows")
date_string = datetime.datetime.today() - datetime.timedelta(days=29)
trakt_list = self.shows_database.extract_trakt_page(
"calendars/all/shows/new/{}/30".format(
date_string.strftime("%d-%m-%Y")),
languages=','.join({'en', g.get_language_code()}),
extended="full",
pull_all=True,
no_paging=True,
ignore_cache=True,
hide_watched=False,
hide_unaired=False)
trakt_list = [
i for i in trakt_list if i["trakt_id"] not in hidden_items
][:self.page_limit]
self.list_builder.show_list_builder(trakt_list, no_paging=True)
def __init__(self):
self._load_settings()
self.lang_code = g.get_language_code(False)
self.languages = (
[None, self.lang_code]
if self.lang_code != "en"
and any(
self.lang_code == i["abbreviation"] for i in self.supported_languages
)
else [None]
)
if not self.jwToken:
self.init_token()
else:
self.try_refresh_token()
self.preferred_artwork_size = g.get_int_setting("artwork.preferredsize")
def __init__(
self,
tmdb_api=None,
tvdb_api=None,
fanarttv_api=None,
trakt_api=None,
omdb_api=None,
):
self.tmdb_api = tmdb_api if tmdb_api else TMDBAPI()
self.tvdb_api = tvdb_api if tvdb_api else TVDBAPI()
self.fanarttv_api = fanarttv_api if fanarttv_api else FanartTv()
self.trakt_api = trakt_api if trakt_api else TraktAPI()
self.omdb_api = omdb_api if omdb_api else OmdbApi()
self.lang_code = g.get_language_code()
self.lang_full_code = g.get_language_code(True)
self.lang_region_code = self.lang_full_code.split("-")[:1]
self.allowed_artwork_languages = {None, "en", self.lang_code}
self.movies_poster_limit = g.get_int_setting("movies.poster_limit", 1)
self.movies_fanart_limit = g.get_int_setting("movies.fanart_limit", 1)
self.movies_keyart_limit = g.get_int_setting("movies.keyart_limit", 1)
self.movies_characterart_limit = g.get_int_setting(
"movies.characterart_limit", 1)
self.movies_banner = g.get_bool_setting("movies.banner", "true")
self.movies_clearlogo = g.get_bool_setting("movies.clearlogo", "true")
self.movies_landscape = g.get_bool_setting("movies.landscape", "true")
self.movies_clearart = g.get_bool_setting("movies.clearart", "true")
self.movies_discart = g.get_bool_setting("movies.discart", "true")
self.tvshows_poster_limit = g.get_int_setting("tvshows.poster_limit",
1)
self.tvshows_fanart_limit = g.get_int_setting("tvshows.fanart_limit",
1)
self.tvshows_keyart_limit = g.get_int_setting("tvshows.keyart_limit",
1)
self.tvshows_characterart_limit = g.get_int_setting(
"tvshows.characterart_limit", 1)
self.tvshows_banner = g.get_bool_setting("tvshows.banner", "true")
self.tvshows_clearlogo = g.get_bool_setting("tvshows.clearlogo",
"true")
self.tvshows_landscape = g.get_bool_setting("tvshows.landscape",
"true")
self.tvshows_clearart = g.get_bool_setting("tvshows.clearart", "true")
self.season_poster = g.get_bool_setting("season.poster", "true")
self.season_banner = g.get_bool_setting("season.banner", "true")
self.season_landscape = g.get_bool_setting("season.landscape", "true")
self.season_fanart = g.get_bool_setting("season.fanart", "true")
self.episode_fanart = g.get_bool_setting("episode.fanart", "true")
self.tvshows_preferred_art_source = g.get_int_setting(
"tvshows.preferedsource", 1)
self.movies_preferred_art_source = g.get_int_setting(
"movies.preferedsource", 1)
self.metadata_location = g.get_int_setting("general.metalocation", 1)
self.preferred_artwork_size = g.get_int_setting(
"artwork.preferredsize", 1)
self.show_original_title = g.get_bool_setting(
"general.meta.showoriginaltitle", False)
self.genres = {
"action": g.get_language_string(30534),
"adventure": g.get_language_string(30535),
"animation": g.get_language_string(30536),
"anime": g.get_language_string(30537),
"biography": g.get_language_string(30538),
"children": g.get_language_string(30539),
"comedy": g.get_language_string(30540),
"crime": g.get_language_string(30541),
"documentary": g.get_language_string(30542),
"drama": g.get_language_string(30543),
"family": g.get_language_string(30544),
"fantasy": g.get_language_string(30545),
"game-show": g.get_language_string(30546),
"history": g.get_language_string(30547),
"holiday": g.get_language_string(30548),
"home-and-garden": g.get_language_string(30549),
"horror": g.get_language_string(30550),
"mini-series": g.get_language_string(30551),
"music": g.get_language_string(30552),
"musical": g.get_language_string(30553),
"mystery": g.get_language_string(30554),
"news": g.get_language_string(30555),
"none": g.get_language_string(30556),
"reality": g.get_language_string(30557),
"romance": g.get_language_string(30558),
"science-fiction": g.get_language_string(30559),
"sci-fi": g.get_language_string(30559),
"short": g.get_language_string(30560),
"soap": g.get_language_string(30561),
"special-interest": g.get_language_string(30562),
"sporting-event": g.get_language_string(30563),
"superhero": g.get_language_string(30564),
"suspense": g.get_language_string(30565),
"talk-show": g.get_language_string(30566),
"talkshow": g.get_language_string(30566),
"thriller": g.get_language_string(30567),
"tv-movie": g.get_language_string(30568),
"war": g.get_language_string(30569),
"western": g.get_language_string(30570),
}
self.meta_hash = tools.md5_hash([
self.lang_code,
self.movies_poster_limit,
self.movies_fanart_limit,
self.movies_keyart_limit,
self.movies_characterart_limit,
self.movies_banner,
self.movies_clearlogo,
self.movies_landscape,
self.movies_clearart,
self.movies_discart,
self.tvshows_poster_limit,
self.tvshows_fanart_limit,
self.tvshows_keyart_limit,
self.tvshows_characterart_limit,
self.tvshows_banner,
self.tvshows_clearlogo,
self.tvshows_landscape,
self.tvshows_clearart,
self.season_poster,
self.season_banner,
self.season_landscape,
self.season_fanart,
self.episode_fanart,
self.tvshows_preferred_art_source,
self.tvshows_preferred_art_source,
self.metadata_location,
self.fanarttv_api.fanart_support,
self.preferred_artwork_size,
self.show_original_title,
])
def __init__(self):
self.language = g.get_language_code()
self.client_key = g.get_setting('fanart.apikey')
self.fanart_support = False if not self.client_key else True
self.headers = {'client-key': self.client_key, 'api-key': self.api_key}
def __init__(self):
self.access_token = None
self.refresh_token = None
self.token_expires = 0
self.username = None
self._load_settings()
self.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
self.try_refresh_token()
self.language = g.get_language_code()
self.country = g.get_language_code(True).split("-")[-1].lower()
self.TranslationNormalization = [
("title", ("title", "originaltitle", "sorttitle"), None),
("language", "language", None),
("overview", ("plot", "plotoutline"), None),
]
self.UserRatingNormalization = [(
"rating",
"user_rating",
lambda t: tools.safe_round(tools.get_clean_number(t), 2),
), ("rated_at", "rated_at", lambda t: g.validate_date(t))]
self.PlayBackNormalization = [("progress", "percentplayed", None),
("paused_at", "paused_at",
lambda t: g.validate_date(t)),
("id", "playback_id", None)]
self.PlayBackHistoryNormalization = [("action", "action", None),
("watched_at", "watched_at",
lambda t: g.validate_date(t)),
("id", "playback_id", None)]
self.CalendarNormalization = [("first_aired", "first_aired",
lambda t: g.validate_date(t))]
self.Normalization = tools.extend_array(
[("certification", "mpaa", None), ("genres", "genre", None),
(("ids", "imdb"), ("imdbnumber", "imdb_id"), None),
(("ids", "trakt"), "trakt_id", None),
(("ids", "slug"), "trakt_slug", None),
(("ids", "tvdb"), "tvdb_id", None),
(("ids", "tmdb"), "tmdb_id", None),
("playback_id", "playback_id", None),
(("show", "ids", "trakt"), "trakt_show_id", None),
("network", "studio", lambda n: [n]),
("runtime", "duration", lambda d: d * 60),
("progress", "percentplayed", None),
("percentplayed", "percentplayed", None),
("updated_at", "dateadded", lambda t: g.validate_date(t)),
("last_updated_at", "dateadded", lambda t: g.validate_date(t)),
("last_watched_at", "last_watched_at",
lambda t: g.validate_date(t)),
("watched_at", "watched_at", lambda t: g.validate_date(t)),
("paused_at", "paused_at", lambda t: g.validate_date(t)),
(
"rating",
"rating",
lambda t: tools.safe_round(tools.get_clean_number(t), 2),
), ("votes", "votes", lambda t: tools.get_clean_number(t)),
(
None,
"rating.trakt",
(
("rating", "votes"),
lambda r, v: {
"rating": tools.safe_round(tools.get_clean_number(r),
2),
"votes": tools.get_clean_number(v),
},
),
), ("tagline", "tagline", None),
(
"trailer",
"trailer",
lambda t: tools.youtube_url.format(t.split("?v=")[-1])
if t else None,
),
("type", "mediatype", lambda t: t
if "show" not in t else "tvshow"),
("available_translations", "available_translations", None),
("score", "score", None), ("action", "action", None),
("added", "added", None), ("rank", "rank", None),
("listed_at", "listed_at", None),
(
"country",
"country_origin",
lambda t: t.upper() if t is not None else None,
), ("user_rating", "user_rating", None),
("rated_at", "rated_at", None)],
self.TranslationNormalization,
)
self.MoviesNormalization = tools.extend_array(
[
("plays", "playcount", None),
("year", "year", None),
("released",
("premiered", "aired"), lambda t: g.validate_date(t)),
("collected_at", "collected_at", lambda t: g.validate_date(t)),
],
self.Normalization,
)
self.ShowNormalization = tools.extend_array(
[("status", "status", None),
("status", "is_airing", lambda t: not t == "ended"),
("title", "tvshowtitle", None),
("first_aired", "year", lambda t: g.validate_date(t)[:4]
if g.validate_date(t) else None),
(
"first_aired",
("premiered", "aired"),
lambda t: g.validate_date(t),
),
("last_collected_at", "last_collected_at",
lambda t: g.validate_date(t))], self.Normalization)
self.SeasonNormalization = tools.extend_array(
[("number", ("season", "sortseason"), None),
("episode_count", "episode_count", None),
("aired_episodes", "aired_episodes", None),
("first_aired", "year", lambda t: g.validate_date(t)[:4]
if g.validate_date(t) else None),
(
"first_aired",
("premiered", "aired"),
lambda t: g.validate_date(t),
),
("last_collected_at", "last_collected_at",
lambda t: g.validate_date(t))],
self.Normalization,
)
self.EpisodeNormalization = tools.extend_array(
[("number", ("episode", "sortepisode"), None),
("season", ("season", "sortseason"), None),
("collected_at", "collected", lambda t: 1),
("plays", "playcount", None),
("first_aired", "year", lambda t: g.validate_date(t)[:4]
if g.validate_date(t) else None),
(
"first_aired",
("premiered", "aired"),
lambda t: g.validate_date(t),
),
("collected_at", "collected_at", lambda t: g.validate_date(t))],
self.Normalization,
)
self.ListNormalization = [
("updated_at", "dateadded", lambda t: g.validate_date(t)),
(("ids", "trakt"), "trakt_id", None),
(("ids", "slug"), "slug", None),
("sort_by", "sort_by", None),
("sort_how", "sort_how", None),
(("user", "ids", "slug"), "username", None),
("name", ("name", "title"), None),
("type", "mediatype", None),
]
self.MixedEpisodeNormalization = [
(("show", "ids", "trakt"), "trakt_show_id", None),
(("episode", "ids", "trakt"), "trakt_id", None)
]
self.MixedSeasonNormalization = [
(("show", "ids", "trakt"), "trakt_show_id", None),
(("season", "ids", "trakt"), "trakt_id", None)
]
self.MetaNormalization = {
"movie": self.MoviesNormalization,
"list": self.ListNormalization,
"show": self.ShowNormalization,
"season": self.SeasonNormalization,
"episode": self.EpisodeNormalization,
"mixedepisode": self.MixedEpisodeNormalization,
"mixedseason": self.MixedSeasonNormalization,
"playback": self.PlayBackNormalization,
"playbackhistory": self.PlayBackHistoryNormalization,
"user_rating": self.UserRatingNormalization,
"calendar": self.CalendarNormalization
}
self.MetaObjects = ("movie", "tvshow", "show", "season", "episode",
"list")
self.MetaCollections = ("movies", "shows", "seasons", "episodes",
"cast")
