def get_matches(self, video):
matches = set()
if video.year == self.year:
matches.add('year')
# episode
if isinstance(video, Episode):
info = guessit(self.version, {"type": "episode"})
# other properties
matches |= guess_matches(video, info, partial=True)
# add year to matches if video doesn't have a year but series, season and episode are matched
if not video.year and all(
item in matches
for item in ['series', 'season', 'episode']):
matches |= {'year'}
# movie
elif isinstance(video, Movie):
# other properties
matches |= guess_matches(video,
guessit(self.version, {"type": "movie"}),
partial=True)
return matches
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# series
if video.series and sanitize(self.series) == sanitize(video.series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# imdb_id
if video.series_imdb_id and self.imdb_id == video.series_imdb_id:
matches.add('series_imdb_id')
# guess
for release in self.releases:
matches |= guess_matches(video, guessit(release, {'type': 'episode'}))
# movie
elif isinstance(video, Movie):
# guess
for release in self.releases:
matches |= guess_matches(video, guessit(release, {'type': 'movie'}))
# title
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
return matches
def get_matches(self, video):
matches = set()
video_filename = video.name
video_filename = os.path.basename(video_filename)
video_filename, _ = os.path.splitext(video_filename)
video_filename = re.sub(r'\[\w+\]$', '',
video_filename).strip().upper()
subtitle_filename = self.filename
subtitle_filename = os.path.basename(subtitle_filename)
subtitle_filename, _ = os.path.splitext(subtitle_filename)
subtitle_filename = re.sub(r'\[\w+\]$', '',
subtitle_filename).strip().upper()
if ((video_filename == subtitle_filename)
or (self.single_file is True
and video_filename in self.notes.upper())):
matches.add('hash')
if video.year and self.year == video.year:
matches.add('year')
matches |= guess_matches(video, guessit(self.title,
{'type': self.type}))
matches |= guess_matches(video,
guessit(self.filename, {'type': self.type}))
return matches
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# series
if video.series and sanitize(self.series) == sanitize(
video.series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# guess
for release in self.releases:
matches |= guess_matches(video,
guessit(release, {'type': 'episode'}))
# movie
elif isinstance(video, Movie):
# guess
for release in self.releases:
matches |= guess_matches(video,
guessit(release, {'type': 'movie'}))
# title
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
return matches
def get_matches(self, video):
matches = set()
video_filename = video.name
video_filename = os.path.basename(video_filename)
video_filename, _ = os.path.splitext(video_filename)
video_filename = sanitize_release_group(video_filename)
subtitle_filename = self.filename
subtitle_filename = os.path.basename(subtitle_filename)
subtitle_filename, _ = os.path.splitext(subtitle_filename)
subtitle_filename = sanitize_release_group(subtitle_filename)
if video_filename == subtitle_filename:
matches.add('hash')
if video.year and self.year == video.year:
matches.add('year')
matches |= guess_matches(
video,
guessit(self.title, {
'type': self.type,
'allowed_countries': [None]
}))
matches |= guess_matches(
video,
guessit(self.filename, {
'type': self.type,
'allowed_countries': [None]
}))
return matches
def get_matches(self, video):
matches = set()
video_filename = video.name
video_filename = os.path.basename(video_filename)
video_filename, _ = os.path.splitext(video_filename)
video_filename = re.sub(r'\[\w+\]$', '',
video_filename).strip().upper()
subtitle_filename = self.filename
subtitle_filename = os.path.basename(subtitle_filename)
subtitle_filename, _ = os.path.splitext(subtitle_filename)
subtitle_filename = re.sub(r'\[\w+\]$', '',
subtitle_filename).strip().upper()
if ((video_filename == subtitle_filename)
or (self.single_file is True
and video_filename in self.notes.upper())):
matches.add('hash')
if video.year and self.year == video.year:
matches.add('year')
matches |= guess_matches(video, guessit(self.title,
{'type': self.type}))
guess_filename = guessit(self.filename, video.hints)
matches |= guess_matches(video, guess_filename)
if isinstance(video, Movie) and (self.num_cds > 1
or 'cd' in guess_filename):
# reduce score of subtitles for multi-disc movie releases
return set()
return matches
def get_matches(self, video):
"""
patch: set guessit to single_value
:param video:
:return:
"""
matches = set()
# episode
if isinstance(video, Episode):
# series
if video.series and (sanitize(self.title) in (
sanitize(name)
for name in [video.series] + video.alternative_series)):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# guess
for release in self.releases:
matches |= guess_matches(
video,
guessit(release, {
'type': 'episode',
"single_value": True
}))
# movie
elif isinstance(video, Movie):
# title
if video.title and (sanitize(self.title) in (
sanitize(name)
for name in [video.title] + video.alternative_titles)):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# guess
for release in self.releases:
matches |= guess_matches(
video,
guessit(release, {
'type': 'movie',
"single_value": True
}))
self.matches = matches
return matches
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# other properties
matches |= guess_matches(video, guessit(self.version, {'type': 'episode'}), partial=True)
# movie
elif isinstance(video, Movie):
# other properties
matches |= guess_matches(video, guessit(self.version, {'type': 'movie'}), partial=True)
return matches
def get_matches(self, video):
matches = set()
# series name
if video.series and sanitize(self.series) in (
sanitize(name) for name in [video.series] + video.alternative_series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# title of the episode
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# release_group
if (video.release_group and self.version and
any(r in sanitize_release_group(self.version)
for r in get_equivalent_release_groups(sanitize_release_group(video.release_group)))):
matches.add('release_group')
# resolution
if video.resolution and self.version and video.resolution in self.version.lower():
matches.add('resolution')
# source
if video.source and self.version and video.source.lower() in self.version.lower():
matches.add('source')
# other properties
matches |= guess_matches(video, guessit(self.version), partial=True)
return matches
def get_matches(self, video):
matches = set()
# series
if video.series and sanitize(self.series) == sanitize(video.series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# title
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# release_group
if (video.release_group and self.version and
any(r in sanitize_release_group(self.version)
for r in get_equivalent_release_groups(sanitize_release_group(video.release_group)))):
matches.add('release_group')
# resolution
if video.resolution and self.version and video.resolution in self.version.lower():
matches.add('resolution')
# format
if video.format and self.version and video.format.lower() in self.version.lower():
matches.add('format')
# other properties
matches |= guess_matches(video, guessit(self.version), partial=True)
return matches
def get_matches(self, video):
matches = set()
if isinstance(video, Movie):
# title
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# imdb id
if video.imdb_id and self.imdb_id == video.imdb_id:
matches.add('imdb_id')
# fps
if video.fps and self.fps and not framerate_equal(
video.fps, self.fps):
logger.warning("nekur: Wrong FPS (expected: %s, got: %s)",
video.fps, self.fps)
# guess additional info from notes
matches |= guess_matches(video,
guessit(self.notes, {'type': 'movie'}),
partial=True)
self.matches = matches
return matches
def test_guess_matches_movie(movies):
video = movies['man_of_steel']
guess = {'title': video.title.upper(), 'year': video.year, 'releaseGroup': video.release_group.upper(),
'screenSize': video.resolution, 'format': video.format.upper(), 'videoCodec': video.video_codec,
'audioCodec': video.audio_codec}
expected = {'title', 'year', 'release_group', 'resolution', 'format', 'video_codec', 'audio_codec'}
assert guess_matches(video, guess) == expected
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# series name
if video.series and sanitize(self.series) in (
sanitize(name)
for name in [video.series] + video.alternative_series):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# release_group
if (video.release_group and self.version
and any(r in sanitize_release_group(self.version)
for r in get_equivalent_release_groups(
sanitize_release_group(video.release_group)))):
matches.add('release_group')
# other properties
matches |= guess_matches(video,
guessit(self.version, {'type': 'episode'}),
partial=True)
return matches
def get_matches(self, video):
matches = set()
# movie
if isinstance(video, Movie):
# title
if video.title and (sanitize(self.title) in (
sanitize(name)
for name in [video.title] + video.alternative_titles)):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# release_group
if (video.release_group and self.version
and any(r in sanitize_release_group(self.version)
for r in get_equivalent_release_groups(
sanitize_release_group(video.release_group)))):
matches.add('release_group')
# other properties
matches |= guess_matches(video,
guessit(self.version, {'type': 'movie'}),
partial=True)
return matches
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# already matched in search query
matches.update(["title", "series", "season", "episode", "year"])
# movie
elif isinstance(video, Movie):
# already matched in search query
matches.update(["title", "year"])
# Special string comparisons are unnecessary. Guessit can match keys
# from any string and find even more keywords.
matches |= guess_matches(
video,
guessit(
self.description,
{"type": "episode" if isinstance(video, Episode) else "movie"},
),
)
# Don't lowercase; otherwise it will match a lot of false positives
if video.release_group and video.release_group in self.description:
matches.add("release_group")
return matches
def test_guess_matches_movie(movies):
video = movies['man_of_steel']
guess = {'title': video.title.upper(), 'year': video.year, 'releaseGroup': video.release_group.upper(),
'screenSize': video.resolution, 'format': video.format.upper(), 'videoCodec': video.video_codec,
'audioCodec': video.audio_codec}
expected = {'title', 'year', 'release_group', 'resolution', 'format', 'video_codec', 'audio_codec'}
assert guess_matches(video, guess) == expected
def test_guess_matches_episode(episodes):
video = episodes['bbt_s07e05']
guess = {'series': video.series, 'season': video.season, 'episodeNumber': video.episode, 'year': video.year,
'title': video.title.upper(), 'releaseGroup': video.release_group.upper(), 'screenSize': video.resolution,
'format': video.format.upper(), 'videoCodec': video.video_codec, 'audioCodec': video.audio_codec}
expected = {'series', 'season', 'episode', 'title', 'year', 'release_group', 'resolution', 'format', 'video_codec',
'audio_codec'}
assert guess_matches(video, guess) == expected
def test_guess_matches_episode(episodes):
video = episodes['bbt_s07e05']
guess = {'series': video.series, 'season': video.season, 'episodeNumber': video.episode, 'year': video.year,
'title': video.title.upper(), 'releaseGroup': video.release_group.upper(), 'screenSize': video.resolution,
'format': video.format.upper(), 'videoCodec': video.video_codec, 'audioCodec': video.audio_codec}
expected = {'series', 'season', 'episode', 'title', 'year', 'release_group', 'resolution', 'format', 'video_codec',
'audio_codec'}
assert guess_matches(video, guess) == expected
def test_guess_matches_episode_no_year(episodes):
video = episodes['dallas_s01e03']
guess = {
'series': video.series,
'season': video.season,
'episodeNumber': video.episode
}
expected = {'series', 'season', 'episode', 'year'}
assert guess_matches(video, guess) == expected
def get_matches(self, video):
self.found_matches |= guess_matches(
video,
guessit(
self.release_info,
{"type": "episode"},
),
)
return self.found_matches
def get_matches(self, video):
matches = set()
# episode
if isinstance(video, Episode):
# always make year a match
info = guessit(self.version, {"type": "episode"})
info["year"] = video.year
# other properties
matches |= guess_matches(video, info, partial=True)
# movie
elif isinstance(video, Movie):
# other properties
matches |= guess_matches(video,
guessit(self.version, {"type": "movie"}),
partial=True)
return matches
def _get_subtitle_from_archive(archive, subtitle):
_valid_names = []
for name in archive.namelist():
# discard hidden files
# discard non-subtitle files
if not os.path.split(name)[-1].startswith(".") and name.lower().endswith(
SUBTITLE_EXTENSIONS
):
_valid_names.append(name)
# archive with only 1 subtitle
if len(_valid_names) == 1:
logger.debug(
f"returning from archive: {_valid_names[0]} (single subtitle file)"
)
return archive.read(_valid_names[0])
# in archives with more than 1 subtitle (season pack) we try to guess the best subtitle file
_scores = get_scores(subtitle.video)
_max_score = 0
_max_name = ""
for name in _valid_names:
_guess = guessit(name)
if "season" not in _guess:
_guess["season"] = -1
if "episode" not in _guess:
_guess["episode"] = -1
if isinstance(subtitle.video, Episode):
logger.debug("guessing %s" % name)
logger.debug(
f"subtitle S{_guess['season']}E{_guess['episode']} video "
f"S{subtitle.video.season}E{subtitle.video.episode}"
)
if (
subtitle.video.episode != _guess["episode"]
or subtitle.video.season != _guess["season"]
):
logger.debug("subtitle does not match video, skipping")
continue
matches = set()
matches |= guess_matches(subtitle.video, _guess)
_score = sum((_scores.get(match, 0) for match in matches))
logger.debug("srt matches: %s, score %d" % (matches, _score))
if _score > _max_score:
_max_score = _score
_max_name = name
logger.debug(f"new max: {name} {_score}")
if _max_score > 0:
logger.debug(f"returning from archive: {_max_name} scored {_max_score}")
return archive.read(_max_name)
raise APIThrottled("Can not find the subtitle in the compressed file")
def get_matches(self, video):
matches = set()
if video.year == self.year:
matches.add('year')
# episode
if isinstance(video, Episode):
info = guessit(self.version, {"type": "episode"})
# other properties
matches |= guess_matches(video, info, partial=True)
# movie
elif isinstance(video, Movie):
# other properties
matches |= guess_matches(
video, guessit(self.version, {"type": "movie"}), partial=True
)
return matches
def get_matches(self, video):
matches = set()
# handle movies and series separately
if isinstance(video, Episode):
# series
if video.series and sanitize(
self.title) == fix_inconsistent_naming(
video.series) or sanitize(
self.alt_title) == fix_inconsistent_naming(
video.series):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# movie
elif isinstance(video, Movie):
# title
if video.title and sanitize(self.title) == fix_inconsistent_naming(
video.title) or sanitize(
self.alt_title) == fix_inconsistent_naming(
video.title):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# rest is same for both groups
# release_group
if (video.release_group and self.releases
and any(r in sanitize_release_group(self.releases)
for r in get_equivalent_release_groups(
sanitize_release_group(video.release_group)))):
matches.add('release_group')
# resolution
if video.resolution and self.releases and video.resolution in self.releases.lower(
):
matches.add('resolution')
# source
if video.source and self.releases and video.source.lower(
) in self.releases.lower():
matches.add('source')
# other properties
matches |= guess_matches(video, guessit(self.releases))
self.matches = matches
return matches
def get_matches(self, video):
"""
patch: set guessit to single_value
:param video:
:return:
"""
matches = set()
# episode
if isinstance(video, Episode):
# series
if video.series and (fix_inconsistent_naming(self.title) in (
fix_inconsistent_naming(name) for name in [video.series] + video.alternative_series)):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# guess
for release in self.releases:
matches |= guess_matches(video, guessit(release, {'type': 'episode', "single_value": True}))
# movie
elif isinstance(video, Movie):
# title
if video.title and (sanitize(self.title) in (
sanitize(name) for name in [video.title] + video.alternative_titles)):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# guess
for release in self.releases:
matches |= guess_matches(video, guessit(release, {'type': 'movie', "single_value": True}))
self.matches = matches
return matches
def _get_subtitle_from_archive(archive, subtitle):
_valid_names = []
for name in archive.namelist():
# discard hidden files
# discard non-subtitle files
if not os.path.split(name)[-1].startswith('.') and name.lower(
).endswith(SUBTITLE_EXTENSIONS):
_valid_names.append(name)
# archive with only 1 subtitle
if len(_valid_names) == 1:
logger.debug(
"returning from archive: {} (single subtitle file)".format(
_valid_names[0]))
return archive.read(_valid_names[0])
# in archives with more than 1 subtitle (season pack) we try to guess the best subtitle file
_scores = get_scores(subtitle.video)
_max_score = 0
_max_name = ""
for name in _valid_names:
_guess = guessit(name)
if 'season' not in _guess:
_guess['season'] = -1
if 'episode' not in _guess:
_guess['episode'] = -1
if isinstance(subtitle.video, Episode):
logger.debug("guessing %s" % name)
logger.debug("subtitle S{}E{} video S{}E{}".format(
_guess['season'], _guess['episode'], subtitle.video.season,
subtitle.video.episode))
if subtitle.video.episode != _guess[
'episode'] or subtitle.video.season != _guess['season']:
logger.debug('subtitle does not match video, skipping')
continue
matches = set()
matches |= guess_matches(subtitle.video, _guess)
_score = sum((_scores.get(match, 0) for match in matches))
logger.debug('srt matches: %s, score %d' % (matches, _score))
if _score > _max_score:
_max_score = _score
_max_name = name
logger.debug("new max: {} {}".format(name, _score))
if _max_score > 0:
logger.debug("returning from archive: {} scored {}".format(
_max_name, _max_score))
return archive.read(_max_name)
raise APIThrottled('Can not find the subtitle in the compressed file')
def get_matches(self, video):
matches = set()
matches |= guess_matches(video, guessit(self.filename))
subtitle_filename = self.filename
# episode
if isinstance(video, Episode):
# already matched in search query
matches.update(['title', 'series', 'season', 'episode', 'year'])
# movie
elif isinstance(video, Movie):
# already matched in search query
matches.update(['title', 'year'])
# release_group
if video.release_group and video.release_group.lower(
) in subtitle_filename:
matches.add('release_group')
# resolution
if video.resolution and video.resolution.lower() in subtitle_filename:
matches.add('resolution')
# source
formats = []
if video.source:
formats = [video.source.lower()]
if formats[0] == "web":
formats.append("webdl")
formats.append("webrip")
formats.append("web ")
for frmt in formats:
if frmt.lower() in subtitle_filename:
matches.add('source')
break
# video_codec
if video.video_codec:
video_codecs = [video.video_codec.lower()]
if video_codecs[0] == "H.264":
formats.append("x264")
elif video_codecs[0] == "H.265":
formats.append("x265")
for vc in formats:
if vc.lower() in subtitle_filename:
matches.add('video_codec')
break
matches.add('hash')
return matches
def _get_subtitle_from_archive(self, archive, subtitle):
# some files have a non subtitle with .txt extension
_tmp = list(SUBTITLE_EXTENSIONS)
_tmp.remove('.txt')
_subtitle_extensions = tuple(_tmp)
_max_score = 0
_scores = get_scores(subtitle.video)
for name in archive.namelist():
# discard hidden files
if os.path.split(name)[-1].startswith('.'):
continue
# discard non-subtitle files
if not name.lower().endswith(_subtitle_extensions):
continue
_guess = guessit(name)
if isinstance(subtitle.video, Episode):
logger.debug("Legendasdivx.pt :: guessing %s", name)
logger.debug("Legendasdivx.pt :: subtitle S%sE%s video S%sE%s",
_guess['season'], _guess['episode'],
subtitle.video.season, subtitle.video.episode)
if subtitle.video.episode != _guess[
'episode'] or subtitle.video.season != _guess['season']:
logger.debug(
'Legendasdivx.pt :: subtitle does not match video, skipping'
)
continue
matches = set()
matches |= guess_matches(subtitle.video, _guess)
logger.debug('Legendasdivx.pt :: sub matches: %s', matches)
_score = sum((_scores.get(match, 0) for match in matches))
if _score > _max_score:
_max_name = name
_max_score = _score
logger.debug("Legendasdivx.pt :: new max: %s %s", name, _score)
if _max_score > 0:
logger.debug(
"Legendasdivx.pt :: returning from archive: %s scored %s",
_max_name, _max_score)
return archive.read(_max_name)
logger.error(
"Legendasdivx.pt :: No subtitle found on compressed file. Max score was 0"
)
return None
def get_matches(self, video):
matches = set()
if self.is_perfect_match:
if isinstance(video, Episode):
matches.add('series')
else:
matches.add('title')
# guess additional info from data
matches |= guess_matches(video, self.data)
self.matches = matches
self.data = None # removing this make the subtitles object unpickable
return matches
def get_matches(self, video):
matches = set()
video_type = None
# episode
if isinstance(video, Episode):
video_type = 'episode'
# series name
if video.series and sanitize(self.series) in (
sanitize(name)
for name in [video.series] + video.alternative_series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# title of the episode
if video.title and sanitize(self.title) == sanitize(video.title):
matches.add('title')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# movie
elif isinstance(video, Movie):
video_type = 'movie'
# title
if video.title and (sanitize(self.title) in (
sanitize(name)
for name in [video.title] + video.alternative_titles)):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# release_group
if (video.release_group and self.version
and any(r in sanitize_release_group(self.version)
for r in get_equivalent_release_groups(
sanitize_release_group(video.release_group)))):
matches.add('release_group')
# other properties
matches |= guess_matches(video,
guessit(self.version, {'type': video_type}),
partial=True)
return matches
def get_matches(self, video):
matches = set()
# handle movies and series separately
if isinstance(video, Episode):
# series
if video.series and sanitize(self.title) == fix_inconsistent_naming(video.series) or sanitize(
self.alt_title) == fix_inconsistent_naming(video.series):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# movie
elif isinstance(video, Movie):
# title
if video.title and sanitize(self.title) == fix_inconsistent_naming(video.title) or sanitize(
self.alt_title) == fix_inconsistent_naming(video.title):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# rest is same for both groups
# release_group
if (video.release_group and self.releases and
any(r in sanitize_release_group(self.releases)
for r in get_equivalent_release_groups(sanitize_release_group(video.release_group)))):
matches.add('release_group')
# resolution
if video.resolution and self.releases and video.resolution in self.releases.lower():
matches.add('resolution')
# format
if video.format and self.releases and video.format.lower() in self.releases.lower():
matches.add('format')
# other properties
matches |= guess_matches(video, guessit(self.releases))
self.matches = matches
return matches
def get_matches(self, video):
matches = set()
matches |= guess_matches(video, guessit(self.filename))
# episode
if isinstance(video, Episode):
# already matched in search query
matches.update(["title", "series", "season", "episode", "year"])
# movie
elif isinstance(video, Movie):
# already matched in search query
matches.update(["title", "year"])
matches.add("hash")
return matches
def _get_subtitle_from_archive(self, archive, subtitle):
# some files have a non subtitle with .txt extension
_tmp = list(SUBTITLE_EXTENSIONS)
_tmp.remove('.txt')
_subtitle_extensions = tuple(_tmp)
_max_score = 0
_scores = get_scores(subtitle.video)
for name in archive.namelist():
# discard hidden files
if os.path.split(name)[-1].startswith('.'):
continue
# discard non-subtitle files
if not name.lower().endswith(_subtitle_extensions):
continue
_guess = guessit(name)
if isinstance(subtitle.video, Episode):
logger.debug("guessing %s" % name)
logger.debug("subtitle S{}E{} video S{}E{}".format(
_guess['season'], _guess['episode'], subtitle.video.season,
subtitle.video.episode))
if subtitle.video.episode != _guess[
'episode'] or subtitle.video.season != _guess['season']:
logger.debug('subtitle does not match video, skipping')
continue
matches = set()
matches |= guess_matches(subtitle.video, _guess)
logger.debug('srt matches: %s' % matches)
_score = sum((_scores.get(match, 0) for match in matches))
if _score > _max_score:
_max_name = name
_max_score = _score
logger.debug("new max: {} {}".format(name, _score))
if _max_score > 0:
logger.debug("returning from archive: {} scored {}".format(
_max_name, _max_score))
return archive.read(_max_name)
raise ParseResponseError(
'Can not find the subtitle in the compressed file')
def get_matches(self, video):
matches = set()
video_filename = video.name
video_filename = os.path.basename(video_filename)
video_filename, _ = os.path.splitext(video_filename)
video_filename = sanitize_release_group(video_filename)
subtitle_filename = self.filename
subtitle_filename = os.path.basename(subtitle_filename)
subtitle_filename, _ = os.path.splitext(subtitle_filename)
subtitle_filename = sanitize_release_group(subtitle_filename)
if video_filename == subtitle_filename:
matches.add('hash')
matches |= guess_matches(video,
guessit(self.filename, {'type': self.type}))
return matches
def _get_subtitle_from_archive(self, archive, video):
subtitles = []
# some files have a non subtitle with .txt extension
_tmp = list(SUBTITLE_EXTENSIONS)
_tmp.remove('.txt')
_subtitle_extensions = tuple(_tmp)
_scores = get_scores(video)
for name in archive.namelist():
# discard hidden files
if os.path.split(name)[-1].startswith('.'):
continue
# discard non-subtitle files
if not name.lower().endswith(_subtitle_extensions):
continue
# get subtitles language
if '.en.' in name.lower():
language = Language.fromopensubtitles('eng')
else:
language = Language.fromopensubtitles('fre')
release = name[:-4].lower().rstrip('tag').rstrip('en').rstrip('fr')
_guess = guessit(release)
if isinstance(video, Episode):
if video.episode != _guess[
'episode'] or video.season != _guess['season']:
continue
matches = set()
matches |= guess_matches(video, _guess)
_score = sum((_scores.get(match, 0) for match in matches))
content = archive.read(name)
subtitles.append(
SoustitreseuSubtitle(language, video, name, _guess, content,
self.is_perfect_match))
return subtitles
def get_matches(self, video, hearing_impaired=False):
matches = set()
# episode
if isinstance(video, Episode) and self.type == 'episode':
# series
if video.series and (sanitize(self.title) in (
sanitize(name)
for name in [video.series] + video.alternative_series)):
matches.add('series')
# year
if video.original_series and self.year is None or video.year and video.year == self.year:
matches.add('year')
# imdb_id
if video.series_imdb_id and self.imdb_id == video.series_imdb_id:
matches.add('series_imdb_id')
# movie
elif isinstance(video, Movie) and self.type == 'movie':
# title
if video.title and (sanitize(self.title) in (
sanitize(name)
for name in [video.title] + video.alternative_titles)):
matches.add('title')
# year
if video.year and self.year == video.year:
matches.add('year')
# imdb_id
if video.imdb_id and self.imdb_id == video.imdb_id:
matches.add('imdb_id')
# name
matches |= guess_matches(video, guessit(self.name,
{'type': self.type}))
return matches
def get_matches(self, video, hearing_impaired=False):
matches = set()
# series
if video.series and sanitize(self.series) == sanitize(video.series):
matches.add('series')
# season
if video.season and self.season == video.season:
matches.add('season')
# episode
if video.episode and self.episode == video.episode:
matches.add('episode')
# format
if video.format and video.format.lower() in self.format.lower():
matches.add('format')
if video.year and self.year == video.year:
matches.add('year')
if video.series_tvdb_id and self.tvdb_id == video.series_tvdb_id:
matches.add('series_tvdb_id')
# other properties
matches |= guess_matches(video, guessit(self.full_data), partial=True)
return matches
def test_guess_matches_episode_no_year(episodes):
video = episodes['dallas_s01e03']
guess = {'series': video.series, 'season': video.season, 'episodeNumber': video.episode}
expected = {'series', 'season', 'episode', 'year'}
assert guess_matches(video, guess) == expected
