def _get_episode_search_strings(self, ep_obj):
search_string = []
if not ep_obj:
return []
if ep_obj.show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
search_string.append(
"{0} {1}".format(
show_name_helpers.sanitizeSceneName(show_name),
str(ep_obj.airdate).replace('-', '.')
)
)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
search_string.append(
"{0} {1}".format(
show_name_helpers.sanitizeSceneName(show_name),
sickbeard.config.naming_ep_type[2] % {
'seasonnumber': ep_obj.season,
'episodenumber': ep_obj.episode
}
)
)
return search_string
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
if self.show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = show_name + " " + str(ep_obj.airdate).replace("-", "|")
search_string["Episode"].append(ep_string)
elif self.show.sports:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = (
show_name + " " + str(ep_obj.airdate).replace("-", "|") + "|" + ep_obj.airdate.strftime("%b")
)
search_string["Episode"].append(ep_string)
elif self.show.anime:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = show_name + " " + "%i" % int(ep_obj.scene_absolute_number)
search_string["Episode"].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = (
show_name
+ " "
+ sickbeard.config.naming_ep_type[2]
% {"seasonnumber": ep_obj.scene_season, "episodenumber": ep_obj.scene_episode}
)
if add_string:
ep_string = ep_string + " %s" % add_string
search_string["Episode"].append(ep_string)
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=''):
search_string = {'Episode': []}
if self.show.air_by_date:
for show_name in set(allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(ep_obj.airdate).replace('-','|')
search_string['Episode'].append(ep_string)
elif self.show.sports:
for show_name in set(allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(ep_obj.airdate).replace('-', '|') + '|' + \
ep_obj.airdate.strftime('%b')
search_string['Episode'].append(ep_string)
else:
for show_name in set(allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode} + '|' + \
sickbeard.config.naming_ep_type[0] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode} + '|' + \
sickbeard.config.naming_ep_type[3] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode} + ' %s category:tv' % add_string
search_string['Episode'].append(re.sub('\s+', ' ', ep_string))
return [search_string]
def _get_episode_search_strings(self, show, season, episode, abd=False, add_string=""):
search_string = {"Episode": []}
if not episode:
return []
if abd:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = (
sanitizeSceneName(show_name)
+ " "
+ str(episode).replace("-", "|")
+ "|"
+ helpers.custom_strftime("%b", episode)
)
search_string["Episode"].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = (
show_name_helpers.sanitizeSceneName(show_name)
+ " "
+ sickbeard.config.naming_ep_type[2] % {"seasonnumber": season, "episodenumber": episode}
)
search_string["Episode"].append(re.sub("\s+", " ", ep_string))
return [search_string]
def _get_season_search_strings(self, show, season=None):
search_string = []
if not show:
return []
myDB = db.DBConnection()
if show.air_by_date:
(min_date, max_date) = self._get_airbydate_season_range(season)
sqlResults = myDB.select("SELECT * FROM tv_episodes WHERE showid = ? AND airdate >= ? AND airdate <= ?", [show.tvdbid, min_date.toordinal(), max_date.toordinal()])
else:
sqlResults = myDB.select("SELECT * FROM tv_episodes WHERE showid = ? AND season = ?", [show.tvdbid, season])
for sqlEp in sqlResults:
if show.getOverview(int(sqlEp["status"])) in (Overview.WANTED, Overview.QUAL):
if show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = show_name_helpers.sanitizeSceneName(show_name) +' '+ str(datetime.date.fromordinal(sqlEp["airdate"])).replace('-', '.')
search_string.append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = show_name_helpers.sanitizeSceneName(show_name) +' '+ sickbeard.config.naming_ep_type[2] % {'seasonnumber': season, 'episodenumber': int(sqlEp["episode"])}
search_string.append(ep_string)
return search_string
def _get_episode_search_strings(self, show, season, episode, add_string=''):
search_string = {'Episode': []}
if not episode:
return []
if show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(episode).replace('-', '|') + '|' + \
episode.strftime('%b')
search_string['Episode'].append(ep_string)
elif show.sports:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(episode).replace('-', '|') + '|' + \
episode.strftime('%b')
search_string['Episode'].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = show_name_helpers.sanitizeSceneName(show_name) + ' ' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': season,
'episodenumber': episode}
search_string['Episode'].append(re.sub('\s+', ' ', ep_string))
return [search_string]
def _get_episode_search_strings(self, show, season, episode, abd=False, add_string=''):
search_string = {'Episode': []}
if not show:
return []
self.show = show
if abd:
for show_name in set(allPossibleShowNames(show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(episode).replace('-','|') + '|' + \
helpers.custom_strftime('%b', episode)
search_string['Episode'].append(ep_string)
else:
for show_name in set(allPossibleShowNames(show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': season,
'episodenumber': episode} + '|' + \
sickbeard.config.naming_ep_type[0] % {'seasonnumber': season,
'episodenumber': episode} + '|' + \
sickbeard.config.naming_ep_type[3] % {'seasonnumber': season,
'episodenumber': episode} + ' %s category:tv' % add_string
search_string['Episode'].append(re.sub('\s+', ' ', ep_string))
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
self.show = ep_obj.show
if ep_obj.show.air_by_date:
for show_name in set(allPossibleShowNames(ep_obj.show)):
ep_string = sanitizeSceneName(show_name) + " " + str(ep_obj.airdate)
search_string["Episode"].append(ep_string)
else:
for show_name in set(allPossibleShowNames(ep_obj.show)):
ep_string = (
sanitizeSceneName(show_name)
+ " "
+ sickbeard.config.naming_ep_type[2]
% {"seasonnumber": ep_obj.season, "episodenumber": ep_obj.episode}
)
for x in add_string.split("|"):
to_search = re.sub("\s+", " ", ep_string + " %s" % x)
search_string["Episode"].append(to_search)
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=''):
search_string = {'Episode': []}
if not ep_obj:
return []
if self.show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + '.' + \
str(ep_obj.airdate).replace('-', '|')
search_string['Episode'].append(ep_string)
elif self.show.sports:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + '.' + \
str(ep_obj.airdate).replace('-', '|') + '|' + \
ep_obj.airdate.strftime('%b')
search_string['Episode'].append(ep_string)
elif self.show.anime:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + '.' + \
"%i" % int(ep_obj.scene_absolute_number)
search_string['Episode'].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = show_name_helpers.sanitizeSceneName(show_name) + '.' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode} + ' %s' % add_string
search_string['Episode'].append(re.sub('\s+', '.', ep_string))
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=''):
search_string = {'Episode': []}
if not ep_obj:
return []
self.show = ep_obj.show
if ep_obj.show.air_by_date:
for show_name in set(allPossibleShowNames(ep_obj.show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
str(ep_obj.airdate) + '|' + \
helpers.custom_strftime('%Y %b {S}', ep_obj.airdate)
search_string['Episode'].append(ep_string)
else:
for show_name in set(allPossibleShowNames(ep_obj.show)):
ep_string = sanitizeSceneName(show_name) + ' ' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.season,
'episodenumber': ep_obj.episode} + '|' + \
sickbeard.config.naming_ep_type[0] % {'seasonnumber': ep_obj.season,
'episodenumber': ep_obj.episode} + '|' + \
sickbeard.config.naming_ep_type[3] % {'seasonnumber': ep_obj.season,
'episodenumber': ep_obj.episode} + ' %s category:tv' % add_string
search_string['Episode'].append(re.sub('\s+', ' ', ep_string))
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
if self.show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + " " + str(ep_obj.airdate).replace("-", "|")
search_string["Episode"].append(ep_string)
elif self.show.sports:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = (
sanitizeSceneName(show_name)
+ " "
+ str(ep_obj.airdate).replace("-", "|")
+ "|"
+ ep_obj.airdate.strftime("%b")
)
search_string["Episode"].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
ep_string = (
show_name_helpers.sanitizeSceneName(show_name)
+ " "
+ sickbeard.config.naming_ep_type[2]
% {"seasonnumber": ep_obj.scene_season, "episodenumber": ep_obj.scene_episode}
)
search_string["Episode"].append(re.sub("\s+", " ", ep_string))
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
if ep_obj.show.air_by_date:
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
ep_string = (
show_name_helpers.sanitizeSceneName(show_name)
+ " "
+ str(ep_obj.airdate)
+ "|"
+ helpers.custom_strftime("%Y %b {S}", ep_obj.airdate)
)
search_string["Episode"].append(ep_string)
else:
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
ep_string = (
show_name_helpers.sanitizeSceneName(show_name)
+ " "
+ sickbeard.config.naming_ep_type[2]
% {"seasonnumber": ep_obj.season, "episodenumber": ep_obj.episode}
+ " %s" % add_string
)
search_string["Episode"].append(re.sub("\s+", " ", ep_string))
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
for sep in " ", " - ":
ep_string = sanitizeSceneName(show_name) + sep
if self.show.air_by_date:
ep_string += str(ep_obj.airdate).replace("-", "|")
elif self.show.sports:
ep_string += str(ep_obj.airdate).replace("-", "|") + "|" + ep_obj.airdate.strftime("%b")
elif self.show.anime:
ep_string += "%i" % int(ep_obj.scene_absolute_number)
else:
ep_string += sickbeard.config.naming_ep_type[2] % {
"seasonnumber": ep_obj.scene_season,
"episodenumber": ep_obj.scene_episode,
}
if add_string:
ep_string += " %s" % add_string
search_string["Episode"].append(re.sub(r"\s+", " ", ep_string.replace(".", " ").strip()))
return [search_string]
def _retrieve_show_images_from_tmdb(self, show, backdrop=False, poster=False):
# get TMDB configuration info
tmdb = TMDB(sickbeard.TMDB_API_KEY)
config = tmdb.Configuration()
response = config.info()
base_url = response['images']['base_url']
sizes = response['images']['poster_sizes']
def size_str_to_int(x):
return float("inf") if x == 'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
search = tmdb.Search()
for show_name in set(allPossibleShowNames(show)):
for result in search.collection({'query': show_name})['results'] + search.tv({'query': show_name})[
'results']:
if backdrop and result['backdrop_path']:
return "{0}{1}{2}".format(base_url, max_size, result['backdrop_path'])
elif poster and result['poster_path']:
return "{0}{1}{2}".format(base_url, max_size, result['poster_path'])
except Exception, e:
pass
def _get_season_search_strings(self, show, season, wantedEp, searchSeason=False):
search_string = {'Episode': []}
if not show:
return []
self.show = show
if searchSeason:
search_string = {'Season': [], 'Episode': []}
for show_name in set(allPossibleShowNames(show)):
ep_string = show_name + ' S%02d' % int(season) #1) ShowName SXX
search_string['Season'].append(ep_string)
ep_string = show_name + ' Season ' + str(season) + ' -Ep*' #2) ShowName Season X
search_string['Season'].append(ep_string)
for ep_obj in wantedEp:
search_string['Episode'] += self._get_episode_search_strings(ep_obj)[0]['Episode']
if not search_string['Episode']:
return []
return [search_string]
def _get_season_search_strings(self, show, season=None):
search_string = {'Episode': []}
if not show:
return []
seasonEp = show.getAllEpisodes(season)
wantedEp = [x for x in seasonEp if show.getOverview(x.status) in (Overview.WANTED, Overview.QUAL)]
#If Every episode in Season is a wanted Episode then search for Season first
if wantedEp == seasonEp and not show.air_by_date:
search_string = {'Season': [], 'Episode': []}
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
ep_string = show_name +' S%02d' % int(season) #1) ShowName SXX
search_string['Season'].append(ep_string)
ep_string = show_name+' Season '+str(season)+' -Ep*' #2) ShowName Season X
search_string['Season'].append(ep_string)
#Building the search string with the episodes we need
for ep_obj in wantedEp:
search_string['Episode'] += self._get_episode_search_strings(ep_obj)[0]['Episode']
#If no Episode is needed then return an empty list
if not search_string['Episode']:
return []
return [search_string]
def _get_episode_search_strings(self, episode, add_string=''):
if not episode:
return []
search_string = {
'Episode': []
}
for show_name in set(allPossibleShowNames(episode.show)):
episode_string = show_name + ' '
if episode.show.air_by_date:
episode_string += str(episode.airdate).replace('-', ' ')
elif episode.show.sports:
episode_string += str(episode.airdate).replace('-', ' ')
episode_string += ('|', ' ')[len(self.proper_strings) > 1]
episode_string += episode.airdate.strftime('%b')
elif episode.show.anime:
episode_string += '%02d' % int(episode.scene_absolute_number)
else:
episode_string += sickbeard.config.naming_ep_type[2] % {
'seasonnumber': episode.scene_season,
'episodenumber': episode.scene_episode,
}
if add_string:
episode_string += ' ' + add_string
search_string['Episode'].append(episode_string.encode('utf-8').strip())
return [search_string]
def _get_season_search_strings(self, show, season):
showNames = show_name_helpers.allPossibleShowNames(show)
result = []
for showName in showNames:
result.append( showName + " S%02d" % season )
return result
def _get_season_search_strings(self, ep_obj):
search_string = {'Season': [], 'Langcat' : ''}
if ep_obj.show.audio_lang=='fr':
langtext=' french'
else:
langtext=''
for show_name in set(allPossibleShowNames(self.show)):
if ep_obj.show.air_by_date or ep_obj.show.sports:
ep_string = show_name + ' ' + str(ep_obj.airdate).split('-')[0]+langtext
search_string['Season'].append(ep_string)
ep_string = show_name + ' Season ' + str(ep_obj.airdate).split('-')[0]+langtext
search_string['Season'].append(ep_string)
elif ep_obj.show.anime:
ep_string = show_name + ' ' + "%02d" % ep_obj.scene_absolute_number+langtext
search_string['Season'].append(ep_string)
else:
ep_string = show_name + ' S%02d' % int(ep_obj.scene_season) + ' -S%02d' % int(
ep_obj.scene_season) + 'E' + ' category:tv' #1) showName SXX -SXXE
search_string['Season'].append(ep_string)
ep_string = show_name + ' Season ' + str(
ep_obj.scene_season) + ' -Ep*' +langtext+ ' category:tv' # 2) showName Season X
search_string['Season'].append(ep_string)
search_string['Langcat']=ep_obj.show.audio_lang
return [search_string]
def _get_season_search_strings(self, show, season=None):
search_string = {"Episode": []}
if not show:
return []
self.show = show
seasonEp = show.getAllEpisodes(season)
wantedEp = [x for x in seasonEp if show.getOverview(x.status) in (Overview.WANTED, Overview.QUAL)]
# If Every episode in Season is a wanted Episode then search for Season first
if wantedEp == seasonEp and not show.air_by_date:
search_string = {"Season": [], "Episode": []}
for show_name in set(allPossibleShowNames(show)):
ep_string = show_name + " S%02d" % int(season) # 1) ShowName SXX -SXXE
search_string["Season"].append(ep_string)
ep_string = show_name + " Season " + str(season) # 2) ShowName Season X
search_string["Season"].append(ep_string)
# Building the search string with the episodes we need
for ep_obj in wantedEp:
search_string["Episode"] += self._get_episode_search_strings(ep_obj)[0]["Episode"]
# If no Episode is needed then return an empty list
if not search_string["Episode"]:
return []
return [search_string]
def _get_season_search_strings(self, show, season=None):
search_string = []
if not (show and season):
return []
myDB = db.DBConnection()
if show.air_by_date:
(min_date, max_date) = self._get_airbydate_season_range(season)
sqlResults = myDB.select(
"SELECT DISTINCT airdate FROM tv_episodes WHERE showid = ? AND airdate >= ? AND airdate <= ? AND status = ?",
[show.tvdbid, min_date.toordinal(), max_date.toordinal(), WANTED],
)
else:
sqlResults = myDB.select(
"SELECT DISTINCT season FROM tv_episodes WHERE showid = ? AND season = ? AND status = ?",
[show.tvdbid, season, WANTED],
)
for sqlEp in sqlResults:
for show_name in set(show_name_helpers.allPossibleShowNames(show)):
if show.air_by_date:
ep_string = (
sanitizeSceneName(show_name)
+ " "
+ str(datetime.date.fromordinal(sqlEp["airdate"])).replace("-", ".")
)
search_string.append(ep_string)
else:
ep_string = sanitizeSceneName(show_name) + " S%02d" % sqlEp["season"]
search_string.append(ep_string)
return search_string
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
for show_name in set(allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + " "
if self.show.air_by_date:
ep_string += str(ep_obj.airdate).replace("-", " ")
elif self.show.sports:
ep_string += str(ep_obj.airdate).replace("-", " ") + "|" + ep_obj.airdate.strftime("%b")
elif self.show.anime:
ep_string += "%02d" % ep_obj.scene_absolute_number
else:
ep_string += (
sickbeard.config.naming_ep_type[2]
% {"seasonnumber": ep_obj.scene_season, "episodenumber": ep_obj.scene_episode}
+ "|"
+ sickbeard.config.naming_ep_type[0]
% {"seasonnumber": ep_obj.scene_season, "episodenumber": ep_obj.scene_episode}
+ " category:tv"
)
if add_string:
ep_string += " " + add_string
search_string["Episode"].append(re.sub("\s+", " ", ep_string))
return [search_string]
def _get_season_search_strings(self, ep_obj):
search_string = {"Season": []}
for show_name in set(allPossibleShowNames(self.show)):
ep_string = sanitizeSceneName(show_name) + " "
if ep_obj.show.air_by_date or ep_obj.show.sports:
ep_string += str(ep_obj.airdate).split("-")[0]
search_string["Season"].append(ep_string)
elif ep_obj.show.anime:
ep_string += "%02d" % ep_obj.scene_absolute_number
search_string["Season"].append(ep_string)
else:
ep_string = "%s S%02d -S%02dE category:tv" % (
sanitizeSceneName(show_name),
ep_obj.scene_season,
ep_obj.scene_season,
) # 1) showName SXX -SXXE
search_string["Season"].append(ep_string)
ep_string = '%s "Season %d" -Ep* category:tv' % (
sanitizeSceneName(show_name),
ep_obj.scene_season,
) # 2) showName "Season X"
search_string["Season"].append(ep_string)
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=""):
search_string = {"Episode": []}
if not ep_obj:
return []
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
ep_string = show_name + " "
if ep_obj.show.air_by_date:
ep_string += str(ep_obj.airdate).replace("-", " ")
elif ep_obj.show.sports:
ep_string += (
str(ep_obj.airdate).replace("-", " ")
+ ("|", " ")[len(self.proper_strings) > 1]
+ ep_obj.airdate.strftime("%b")
)
elif ep_obj.show.anime:
ep_string += "%02d" % int(ep_obj.scene_absolute_number)
else:
ep_string += sickbeard.config.naming_ep_type[2] % {
"seasonnumber": ep_obj.scene_season,
"episodenumber": ep_obj.scene_episode,
}
if add_string:
ep_string = ep_string + " %s" % add_string
search_string["Episode"].append(ep_string.encode("utf-8").strip())
return [search_string]
def _get_episode_search_strings(self, ep_obj, add_string=''):
search_string = {'Episode': []}
if not ep_obj:
return []
for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
ep_string = show_name + ' '
if ep_obj.show.air_by_date:
ep_string += str(ep_obj.airdate).replace('-', '|')
elif ep_obj.show.sports:
ep_string += str(ep_obj.airdate).replace('-', '|') + '|' + \
ep_obj.airdate.strftime('%b')
elif ep_obj.show.anime:
ep_string += "%02d" % int(ep_obj.scene_absolute_number)
else:
ep_string += sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode}
if add_string:
ep_string = ep_string + ' %s' % add_string
search_string['Episode'].append(ep_string)
return [search_string]
def _get_episode_search_strings(self, ep_obj, french=None):
strings = []
showNam = show_name_helpers.allPossibleShowNames(ep_obj.show)
showNames = list(set(showNam))
global globepid
myDB = db.DBConnection()
epidr = myDB.select("SELECT episode_id from tv_episodes where tvdbid=?", [ep_obj.tvdbid])
globepid = epidr[0][0]
for showName in showNames:
strings.append("%s S%02dE%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02dE%d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%dE%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s %dx%d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d E%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d E%d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%d E%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02dEp%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02dEp%d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%dEp%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d Ep%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d Ep%d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%d Ep%02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d Ep %02d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%02d Ep %d" % (showName, ep_obj.season, ep_obj.episode))
strings.append("%s S%d Ep %02d" % (showName, ep_obj.season, ep_obj.episode))
return strings
def _retrieve_show_images_from_tmdb(self, show, type):
types = {
"poster": "poster_path",
"banner": None,
"fanart": "backdrop_path",
"poster_thumb": "poster_path",
"banner_thumb": None,
}
# get TMDB configuration info
tmdb = TMDB(sickbeard.TMDB_API_KEY)
config = tmdb.Configuration()
response = config.info()
base_url = response["images"]["base_url"]
sizes = response["images"]["poster_sizes"]
def size_str_to_int(x):
return float("inf") if x == "original" else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
search = tmdb.Search()
for show_name in set(allPossibleShowNames(show)):
for result in (
search.collection({"query": show_name})["results"] + search.tv({"query": show_name})["results"]
):
if types[type] and getattr(result, types[type]):
return "{0}{1}{2}".format(base_url, max_size, result[types[type]])
except Exception as e:
pass
logger.log(u"Could not find any " + type + " images on TMDB for " + show.name, logger.DEBUG)
def _get_episode_search_strings(self, ep_obj, add_string=''):
search_strings = []
if not ep_obj:
return []
for show_name in set(show_name_helpers.allPossibleShowNames(self.show)):
if self.show.air_by_date:
ep_string = sanitizeSceneName(show_name) + ' ' + str(ep_obj.airdate).replace('-', '.')
elif self.show.sports:
ep_string = sanitizeSceneName(show_name) + ' ' + str(ep_obj.airdate).replace('-', '.') + '|' + \
ep_obj.airdate.strftime('%b')
elif self.show.anime:
ep_string = sanitizeSceneName(show_name) + ' %i' % int(ep_obj.scene_absolute_number)
else:
ep_string = sanitizeSceneName(show_name) + ' ' + \
sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.scene_season,
'episodenumber': ep_obj.scene_episode}
if len(add_string):
ep_string += ' %s' % add_string
search_strings.append(ep_string)
return search_strings
def _retrieve_show_images_from_tmdb(self, show, img_type):
types = {'poster': 'poster_path',
'banner': None,
'fanart': 'backdrop_path',
'poster_thumb': 'poster_path',
'banner_thumb': None}
# get TMDB configuration info
tmdb = TMDB(sickbeard.TMDB_API_KEY)
config = tmdb.Configuration()
response = config.info()
base_url = response['images']['base_url']
sizes = response['images']['poster_sizes']
def size_str_to_int(x):
return float("inf") if x == 'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
search = tmdb.Search()
for show_name in set(allPossibleShowNames(show)):
for result in search.collection({'query': show_name})['results'] + search.tv({'query': show_name})['results']:
if types[img_type] and getattr(result, types[img_type]):
return "{0}{1}{2}".format(base_url, max_size, result[types[img_type]])
except Exception:
pass
logger.log(u"Could not find any " + img_type + " images on TMDB for " + show.name, logger.INFO)
def _doSearch(self, search_params, epcount=0, age=0):
results = []
items = {'Season': [], 'Episode': [], 'RSS': []}
for mode in search_params.keys():
for search_string in search_params[mode]:
if mode != 'RSS':
searchURL = self.proxy._buildURL(self.searchurl % (urllib.quote(unidecode(search_string))))
else:
searchURL = self.proxy._buildURL(self.url + 'tv/latest/')
logger.log(u"Search string: " + searchURL, logger.DEBUG)
data = self.getURL(searchURL)
if not data:
continue
re_title_url = self.proxy._buildRE(self.re_title_url)
#Extracting torrent information from data returned by searchURL
match = re.compile(re_title_url, re.DOTALL).finditer(urllib.unquote(data))
for torrent in match:
title = torrent.group('title').replace('_',
'.') #Do not know why but SickBeard skip release with '_' in name
url = torrent.group('url')
id = int(torrent.group('id'))
seeders = int(torrent.group('seeders'))
leechers = int(torrent.group('leechers'))
#Filter unseeded torrent
if mode != 'RSS' and seeders == 0:
continue
#Accept Torrent only from Good People for every Episode Search
if self.confirmed and re.search('(VIP|Trusted|Helper)', torrent.group(0)) is None:
logger.log(u"ThePirateBay Provider found result " + torrent.group(
'title') + " but that doesn't seem like a trusted result so I'm ignoring it", logger.DEBUG)
continue
#Check number video files = episode in season and find the real Quality for full season torrent analyzing files in torrent
if mode == 'Season':
ep_number = int(epcount / len(set(allPossibleShowNames(self.show))))
title = self._find_season_quality(title, id, ep_number)
if not title or not url:
continue
item = title, url, id, seeders, leechers
items[mode].append(item)
#For each search mode sort all the items by seeders
items[mode].sort(key=lambda tup: tup[3], reverse=True)
results += items[mode]
return results
def _search_provider(self, search_params, search_mode='eponly', epcount=0, **kwargs):
results = []
items = {'Cache': [], 'Season': [], 'Episode': [], 'Propers': []}
rc = dict((k, re.compile('(?i)' + v)) for (k, v) in {'link': 'normal', 'get': '^magnet', 'verif': 'verif'}.items())
url = 0
for mode in search_params.keys():
search_show = mode in ['Season', 'Episode']
if not search_show and has_anime():
search_params[mode] *= (1, 2)['Cache' == mode]
'Propers' == mode and search_params[mode].append('v1|v2|v3|v4|v5')
for enum, search_string in enumerate(search_params[mode]):
search_string = isinstance(search_string, unicode) and unidecode(search_string) or search_string
self.url = self.urls['base'][url]
search_url = self.url + (self.urls['search'] % urllib.quote('%scategory:%s' % (
('', '%s ' % search_string)['Cache' != mode],
('tv', 'anime')[(search_show and bool(self.show and self.show.is_anime)) or bool(enum)])))
self.session.headers.update({'Referer': search_url})
html = self.get_url(search_url + self.urls['sorted'])
cnt = len(items[mode])
try:
if not html or 'kastatic' not in html or self._has_no_results(html) or re.search(r'(?is)<(?:h\d)[^>]*>.*?(?:did\snot\smatch)', html):
if html and 'kastatic' not in html:
url += (1, 0)[url == len(self.urls['base'])]
raise generic.HaltParseException
with BS4Parser(html, features=['html5lib', 'permissive']) as soup:
torrent_table = soup.find('table', attrs={'class': 'data'})
torrent_rows = [] if not torrent_table else torrent_table.find_all('tr')
if 2 > len(torrent_rows):
raise generic.HaltParseException
for tr in torrent_rows[1:]:
try:
seeders, leechers, size = [tryInt(n, n) for n in [
tr.find_all('td')[x].get_text().strip() for x in (-2, -1, -5)]]
if self._peers_fail(mode, seeders, leechers):
continue
info = tr.find('div', {'class': 'torrentname'})
title = (info.find_all('a')[1].get_text() or info.find('a', 'cellMainLink').get_text())\
.strip()
link = self.url + info.find('a', {'class': rc['link']})['href'].lstrip('/')
download_magnet = tr.find('a', href=rc['get'])['href']
except (AttributeError, TypeError, ValueError):
continue
if self.confirmed and not (tr.find('a', title=rc['verif']) or tr.find('i', title=rc['verif'])):
logger.log(u'Skipping untrusted non-verified result: %s' % title, logger.DEBUG)
continue
# Check number video files = episode in season and find the real Quality for full season torrent analyzing files in torrent
if 'Season' == mode and 'sponly' == search_mode:
ep_number = int(epcount / len(set(show_name_helpers.allPossibleShowNames(self.show))))
title = self._find_season_quality(title, link, ep_number)
if title and download_magnet:
items[mode].append((title, download_magnet, seeders, self._bytesizer(size)))
except generic.HaltParseException:
pass
except Exception:
logger.log(u'Failed to parse. Traceback: %s' % traceback.format_exc(), logger.ERROR)
self._log_search(mode, len(items[mode]) - cnt, search_url)
self._sort_seeders(mode, items)
results = list(set(results + items[mode]))
return results
def _get_episode_search_strings(self, ep_obj, french=None):
showNam = show_name_helpers.allPossibleShowNames(ep_obj.show)
showNames = list(set(showNam))
results = []
for showName in showNames:
results.append(
self.getSearchParams(
"%s S%02dE%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 433, french))
if (int(ep_obj.scene_season) < 31
and int(ep_obj.scene_episode) < 61):
results.append(
self.getSearchParams(showName, ep_obj.show.audio_lang, 433,
french) + "&" +
urllib.urlencode({
'term[46][]':
self.episodeValue(ep_obj.scene_episode),
'term[45][]':
self.seasonValue(ep_obj.scene_season)
}))
#results.append( self.getSearchParams( "%s %dx%d" % ( showName, ep_obj.season, ep_obj.episode ), ep_obj.show.audio_lang , 433 )) MAY RETURN 1x12 WHEN SEARCHING 1x1
results.append(
self.getSearchParams(
"%s %dx%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 433, french))
results.append(
self.getSearchParams(
"%s S%02dE%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 637, french))
if (int(ep_obj.scene_season) < 31
and int(ep_obj.scene_episode) < 61):
results.append(
self.getSearchParams(showName, ep_obj.show.audio_lang, 637,
french) + "&" +
urllib.urlencode({
'term[46][]':
self.episodeValue(ep_obj.scene_episode),
'term[45][]':
self.seasonValue(ep_obj.scene_season)
}))
#results.append( self.getSearchParams( "%s %dx%d" % ( showName, ep_obj.season, ep_obj.episode ), ep_obj.show.audio_lang, 637 ))
results.append(
self.getSearchParams(
"%s %dx%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 637, french))
results.append(
self.getSearchParams(
"%s S%02dE%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 634, french))
#results.append( self.getSearchParams( "%s %dx%d" % ( showName, ep_obj.season, ep_obj.episode ), ep_obj.show.audio_lang, 634 ))
results.append(
self.getSearchParams(
"%s %dx%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 634, french))
results.append(
self.getSearchParams(
"%s S%02dE%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 639, french))
#results.append( self.getSearchParams( "%s %dx%d" % ( showName, ep_obj.season, ep_obj.episode ), ep_obj.show.audio_lang, 634 ))
results.append(
self.getSearchParams(
"%s %dx%02d" %
(showName, ep_obj.scene_season, ep_obj.scene_episode),
ep_obj.show.audio_lang, 639, french))
return results
def _doSearch(self, search_params, search_mode='eponly', epcount=0, age=0):
results = []
items = {'Season': [], 'Episode': [], 'RSS': []}
for mode in search_params.keys():
for search_string in search_params[mode]:
for url in self.urls:
if mode != 'RSS':
searchURL = url + 'usearch/%s/?field=seeders&sorder=desc' % (
urllib.quote(unidecode(search_string)))
logger.log(u"Search string: " + searchURL,
logger.DEBUG)
else:
searchURL = url + 'tv/?field=time_add&sorder=desc'
logger.log(u"KAT cache update URL: " + searchURL,
logger.DEBUG)
html = self.getURL(searchURL)
if html:
self.url = url
break
if not html:
continue
try:
with BS4Parser(html, features=["html5lib",
"permissive"]) as soup:
torrent_table = soup.find('table',
attrs={'class': 'data'})
torrent_rows = torrent_table.find_all(
'tr') if torrent_table else []
#Continue only if one Release is found
if len(torrent_rows) < 2:
logger.log(
u"The data returned from " + self.name +
" does not contain any torrents",
logger.WARNING)
continue
for tr in torrent_rows[1:]:
try:
link = urlparse.urljoin(
self.url, (tr.find('div', {
'class': 'torrentname'
}).find_all('a')[1])['href'])
id = tr.get('id')[-7:]
title = (tr.find('div', {'class': 'torrentname'}).find_all('a')[1]).text \
or (tr.find('div', {'class': 'torrentname'}).find_all('a')[2]).text
url = tr.find('a', 'imagnet')['href']
verified = True if tr.find(
'a', 'iverify') else False
trusted = True if tr.find(
'img', {'alt': 'verified'}) else False
seeders = int(tr.find_all('td')[-2].text)
leechers = int(tr.find_all('td')[-1].text)
except (AttributeError, TypeError):
continue
if mode != 'RSS' and (seeders < self.minseed
or leechers < self.minleech):
continue
if self.confirmed and not verified:
logger.log(
u"KAT Provider found result " + title +
" but that doesn't seem like a verified result so I'm ignoring it",
logger.DEBUG)
continue
#Check number video files = episode in season and find the real Quality for full season torrent analyzing files in torrent
if mode == 'Season' and search_mode == 'sponly':
ep_number = int(
epcount /
len(set(allPossibleShowNames(self.show))))
title = self._find_season_quality(
title, link, ep_number)
if not title or not url:
continue
item = title, url, id, seeders, leechers
items[mode].append(item)
except Exception, e:
logger.log(
u"Failed to parsing " + self.name + " Traceback: " +
traceback.format_exc(), logger.ERROR)
#For each search mode sort all the items by seeders
items[mode].sort(key=lambda tup: tup[3], reverse=True)
results += items[mode]
def _doSearch(self, search_params, show=None, age=None):
results = []
items = {'Season': [], 'Episode': [], 'RSS': []}
for mode in search_params.keys():
for search_string in search_params[mode]:
if mode != 'RSS':
searchURL = self.proxy._buildURL(
self.searchurl %
(urllib.quote(unidecode(search_string))))
else:
searchURL = self.proxy._buildURL(self.url + 'tv/latest/')
logger.log(u"Search string: " + searchURL, logger.DEBUG)
data = self.getURL(searchURL)
if not data:
continue
re_title_url = self.proxy._buildRE(self.re_title_url)
#Extracting torrent information from data returned by searchURL
match = re.compile(re_title_url,
re.DOTALL).finditer(urllib.unquote(data))
for torrent in match:
title = torrent.group('title').replace(
'_', '.'
) #Do not know why but SickBeard skip release with '_' in name
url = torrent.group('url')
id = int(torrent.group('id'))
seeders = int(torrent.group('seeders'))
leechers = int(torrent.group('leechers'))
#Filter unseeded torrent
if mode != 'RSS' and seeders == 0:
continue
#Accept Torrent only from Good People for every Episode Search
if sickbeard.THEPIRATEBAY_TRUSTED and re.search(
'(VIP|Trusted|Helper)', torrent.group(0)) is None:
logger.log(
u"ThePirateBay Provider found result " +
torrent.group('title') +
" but that doesn't seem like a trusted result so I'm ignoring it",
logger.DEBUG)
continue
#Check number video files = episode in season and find the real Quality for full season torrent analyzing files in torrent
if mode == 'Season':
ep_number = int(
len(search_params['Episode']) /
len(set(allPossibleShowNames(self.show))))
title = self._find_season_quality(title, id, ep_number)
if not title or not url:
continue
item = title, url, id, seeders, leechers
items[mode].append(item)
#For each search mode sort all the items by seeders
items[mode].sort(key=lambda tup: tup[3], reverse=True)
results += items[mode]
return results
def _test_allPossibleShowNames(self, name, tvdbid=0, tvrname=None, expected=[]):
result = show_name_helpers.allPossibleShowNames(Show(name, tvdbid, tvrname))
self.assertTrue(len(set(expected).intersection(set(result))) == len(expected))
