def test_language(self):
with create_temporary_file() as f:
f.file.close()
s1 = Settings(f.name)
s1.set_language(('section3', 'langprop'), Language.from_xxx('dut'))
s1.write()
del s1
s2 = Settings(f.name)
s2.reload()
self.assertEqual(Language.from_xxx('dut'),
s2.get_language(('section3', 'langprop')))
self.assertEqual(None, s2.get_language(('s', 'k')))
def do_languages(self, arg):
if arg:
try:
if int(arg) == 0:
self.state.set_download_languages([])
self.echo(_('Filter languages cleared'))
return
except ValueError:
pass
try:
langs = [Language.from_unknown(l_str, xx=True, xxx=True, name=True, locale=True)
for l_str in self.shlex_parse_argstr(arg)]
except NotALanguageException as e:
self.echo(_('"{}" is not a valid language').format(e.value))
return
self.state.set_download_languages(langs)
self.echo(ngettext('New filter language:', 'New filter languages:',
len(self.state.get_download_languages())))
for language in self.state.get_download_languages():
self.echo('- {}'.format(language.name()))
return
else:
self.echo(ngettext('Current filter language:', 'Current filter languages:',
len(self.state.get_download_languages())))
if self.state.get_download_languages():
for language in self.state.get_download_languages():
self.echo('- {}'.format(language.name()))
else:
self.echo(_('(None)'))
def setup_ui(self):
self.ui.setupUi(self)
self.ui.buttonSearchByName.clicked.connect(self.onButtonSearchByTitle)
self.ui.movieNameText.returnPressed.connect(self.onButtonSearchByTitle)
self.ui.buttonDownloadByTitle.clicked.connect(self.onButtonDownloadByTitle)
self.ui.buttonIMDBByTitle.clicked.connect(self.onViewOnlineInfo)
self.ui.buttonIMDBByTitle.setEnabled(False)
self.moviesModel = VideoTreeModel(self)
self.moviesModel.connect_treeview(self.ui.moviesView)
self.moviesModel.node_clicked.connect(self.on_item_clicked)
self.moviesModel.dataChanged.connect(self.subtitlesMovieCheckedChanged)
# FIXME: load settings from general place
upload_language = Language.from_xxx(
QSettings().value('options/uploadLanguage', UnknownLanguage.create_generic()))
self.ui.filterLanguage.selected_language_changed.connect(self.on_language_combobox_filter_change)
self.language_filter_change.connect(self.moviesModel.on_filter_languages_change)
self.ui.moviesView.setContextMenuPolicy(Qt.CustomContextMenu)
self.ui.moviesView.customContextMenuRequested.connect(self.onContext)
self.retranslate()
def get_language(self, key, default=None):
# FIXME: test parsing language settings (+invalid)
try:
xxx = self._load_str(key)
return Language.from_xxx(xxx)
except KeyError:
return default
def get_permanent_language_filter(self):
settings = QSettings()
languages_str = settings.value('options/filterSearchLang', '')
if languages_str:
languages = [Language.from_xxx(lang_str) for lang_str in languages_str.split(',')]
return languages
else:
return []
def get_system_language():
locale = i18n_system_locale()
for lc_fallback in i18n_locale_fallbacks_calculate(locale):
try:
language = Language.from_unknown(lc_fallback, locale=True)
return language
except NotALanguageException:
continue
return UnknownLanguage.create_generic()
def get_languages(self, key, default=None):
try:
xxxs = self._load_str(key)
return [
Language.from_xxx(lang_str) for lang_str in xxxs.split(',')
if lang_str
]
except KeyError:
return default
def test_languages(self):
with create_temporary_file() as f:
f.file.close()
s1 = Settings(f.name)
s1.set_languages(
('section4', 'langsprop'),
[Language.from_xxx('spa'),
Language.from_xxx('eng')])
s1.write()
del s1
s2 = Settings(f.name)
s2.reload()
self.assertListEqual(
[Language.from_xxx('spa'),
Language.from_xxx('eng')],
s2.get_languages(('section4', 'langsprop')))
self.assertEqual(None, s2.get_languages(('s', 'k')))
def __call__(self, parser, namespace, values, option_string=None):
try:
languages = [
Language.from_unknown(value,
xx=True,
xxx=True,
locale=True,
name=True) for value in values
]
setattr(namespace, self.dest, languages)
except NotALanguageException as e:
parser.error(
_('{lang_str} is an unknown language.').format(
lang_str=e.value))
def matches_video_filename(self, video):
"""
Detect whether the filename of videofile matches with this SubtitleFile.
:param video: VideoFile instance
:return: True if match
"""
vid_fn = video.get_filename()
vid_stem, _ = os.path.splitext(vid_fn)
vid_stem = vid_stem.lower()
sub_fn = self.get_filename()
sub_stem, _ = os.path.splitext(sub_fn)
sub_stem = sub_stem.lower()
log.debug(
'matches_filename(subtitle="{sub_filename}", video="{vid_filename}") ...'
.format(sub_filename=sub_fn, vid_filename=vid_fn))
matches = sub_stem == vid_stem
lang = None
if not matches:
if sub_stem.startswith(vid_stem):
sub_rest = sub_stem[len(vid_stem):]
rests = sub_rest.split('.')
rest_matches = True
for rest in rests:
if not rest:
continue
try:
int(rest)
continue
except ValueError:
pass
try:
lang = Language.from_unknown(rest, xx=True, xxx=True)
continue
except NotALanguageException:
pass
rest_matches = False
break
matches = rest_matches
if matches:
log.debug(
'... matches (language={language})'.format(language=lang))
else:
log.debug('... does not match')
return matches
def do_upload_set_language(self, arg):
args = self.shlex_parse_argstr(arg)
if len(args) == 0:
self._upload_movie.set_language(UnknownLanguage.create_generic())
return
if len(args) != 1:
self.echo('Need 1 argument')
return
try:
lang = Language.from_unknown(args[0], xx=True, xxx=True, name=True, locale=True)
self.echo(_('Upload language set to {}.').format(lang.name()))
self._upload_movie.set_language(lang)
except NotALanguageException:
self.echo(_('Unknown language'))
return
def matches_videofile_filename(self, videofile):
"""
Detect whether the filename of videofile matches with this SubtitleFile.
:param videofile: VideoFile instance
:return: True if match
"""
vid_fn = videofile.get_filename()
vid_base, _ = os.path.splitext(vid_fn)
vid_base = vid_base.lower()
sub_fn = self.get_filename()
sub_base, _ = os.path.splitext(sub_fn)
sub_base = sub_base.lower()
log.debug(
'matches_filename(subtitle="{sub_filename}", video="{vid_filename}") ...'
.format(sub_filename=sub_fn, vid_filename=vid_fn))
matches = sub_base == vid_base
lang = None
if not matches:
if sub_base.startswith(vid_base):
sub_rest = sub_base[len(vid_base):]
while len(sub_rest) > 0:
if sub_rest[0].isalnum():
break
sub_rest = sub_rest[1:]
try:
lang = Language.from_unknown(sub_rest,
locale=False,
name=False)
matches = True
except NotALanguageException:
matches = False
if matches:
log.debug(
'... matches (language={language})'.format(language=lang))
else:
log.debug('... does not match')
return matches
def detect_language_filename(cls, filename):
"""
Detect the language of a subtitle filename
:param filename: filename of a subtitle
:return: Language object, None if language could not be detected.
"""
log.debug('detect_language(filename="{}") ...'.format(filename))
root, _ = os.path.splitext(filename)
fn_lang = cls.DETECT_LANGUAGE_REGEX.findall(root)
if fn_lang:
language_part = fn_lang[0]
try:
lang = Language.from_unknown(language_part, xx=True, xxx=True)
log.debug('... SUCCESS: detected from filename: {lang}'.format(
lang=lang))
return lang
except NotALanguageException:
pass
else:
log.debug('... FAIL: could not detect from filename')
return UnknownLanguage.create_generic()
def do_languages(self, arg):
if arg:
langs = None
if langs is None:
try:
if int(arg) == 0:
langs = []
except ValueError:
pass
if langs is None:
try:
langs = [
Language.from_unknown(l_str,
xx=True,
xxx=True,
name=True,
locale=True)
for l_str in shlex.split(arg)
]
except NotALanguageException as e:
self.print(
_('"{}" is not a valid language').format(e.value))
return
self.state.set_download_languages(langs)
if arg:
self.print(
ngettext('New filter language:', 'New filter languages:',
len(self.state.get_download_languages())))
else:
self.print(
ngettext('Current filter language:',
'Current filter languages:',
len(self.state.get_download_languages())))
if self.state.get_download_languages():
for language in self.state.get_download_languages():
self.print('- {}'.format(language.name()))
else:
self.print(_('(None)'))
def readSettings(self):
log.debug('readSettings: start')
self.settings.sync()
# 1. Search tab
checked_languages_str = self.settings.value('options/filterSearchLang',
[])
if checked_languages_str:
for lang_xxx in checked_languages_str.split(','):
lang = Language.from_xxx(lang_xxx)
if isinstance(lang, UnknownLanguage):
continue
self._filterLanguageComboBoxes[lang].setChecked(True)
# 2. Download tab
# - Download Destination
optionWhereToDownload = self.settings.value(
'options/whereToDownload', self.DLDESTINATIONTYPE_SAMEFOLDER)
if optionWhereToDownload == self.DLDESTINATIONTYPE_ASKUSER:
self.ui.optionDlDestinationAsk.setChecked(True)
elif optionWhereToDownload == self.DLDESTINATIONTYPE_SAMEFOLDER:
self.ui.optionDlDestinationSame.setChecked(True)
elif optionWhereToDownload == self.DLDESTINATIONTYPE_PREDEFINEDFOLDER:
self.ui.optionDlDestinationUser.setChecked(True)
dlDestination = self.settings.value('options/whereToDownloadFolder',
'')
#self._dlDestinationPredefined = dlDestination if os.path.isdir(dlDestination) else ''
self.ui.inputDlDestinationUser.setText(dlDestination)
self.ui.inputDlDestinationUser.editingFinished.emit()
# - Subtitle Filename
optionSubtitleName = self.settings.value('options/subtitleName',
self.DLSUBFN_SAME)
if optionSubtitleName == self.DLSUBFN_SAME:
self.ui.optionSubFnSame.setChecked(True)
elif optionSubtitleName == self.DLSUBFN_SAMELANG:
self.ui.optionSubFnSameLang.setChecked(True)
elif optionSubtitleName == self.DLSUBFN_SAMELANGUPLOADER:
self.ui.optionSubFnSameLangUploader.setChecked(True)
elif optionSubtitleName == self.DLSUBFN_ONLINE:
self.ui.optionSubFnOnline.setChecked(True)
# 3. Upload tab
# - Default Subtitle Language
optionUploadLanguage = self.settings.value('options/uploadLanguage',
self.DEFAULT_UL_LANG.xxx())
self._uploadLanguage = Language.from_xxx(optionUploadLanguage)
self.ui.optionUlDefaultLanguage.set_selected_language(
self._uploadLanguage)
# 4. Network tab
self.ui.inputProxyHost.setText(
self.settings.value("options/ProxyHost", ""))
self.ui.inputProxyPort.setValue(
int(self.settings.value("options/ProxyPort", 8080)))
# 5. Others tab
# - Interface Language
optionInterfaceLanguage = self.settings.value(
'options/interfaceLang', self.DEFAULT_INTERFACE_LANG.locale())
self._original_interface_language = Language.from_locale(
optionInterfaceLanguage)
self.ui.optionInterfaceLanguage.set_selected_language(
self._original_interface_language)
optionIntegrationExplorer = self.settings.value(
"options/IntegrationExplorer", False)
self.ui.optionIntegrationExplorer.setChecked(optionIntegrationExplorer)
programPath = self.settings.value("options/VideoPlayerPath", "")
parameters = self.settings.value("options/VideoPlayerParameters", "")
self.ui.inputVideoAppLocation.setText(programPath)
self.ui.inputVideoAppParams.setText(parameters)
# Context menu for Explorer
if platform.system() == "Linux":
self.ui.optionIntegrationExplorer.setText(
_("Enable in your Konqueror/Dolphin/Nautilus"))
self.ui.optionIntegrationExplorer.setEnabled(False)
elif platform.system() == "Windows":
self.ui.optionIntegrationExplorer.setText(
_("Enable in your Windows Explorer"))
self.ui.optionIntegrationExplorer.setEnabled(False)
else:
self.ui.optionIntegrationExplorer.setText(
_("Enable in your File Manager"))
self.ui.optionIntegrationExplorer.setEnabled(False)
log.debug('readSettings: finish')
def parse_results(self, raw_xml):
"""Parse the xml and return a list of dictionaries like:
[ {'IDSubtitle': 'foo',
'LinkUseNext': 'foo',
'MovieName': 'foo_movie',
...
},
{'IDSubtitle': 'foo',
'LinkUseNext': 'foo',
'MovieName': 'foo_movie',
...
},
...]
"""
dom = minidom.parseString(raw_xml) # Make the dom from raw xml
entries = dom.getElementsByTagName(
'opensubtitles') # Pull out all entry's
result_entries = [] # Make an empty container to fill up and return
data = None
# fetch the wanted result xml node
for entry in entries:
if len(entry.getElementsByTagName('results')) > 0:
for result in entry.getElementsByTagName('results'):
if len(result.getElementsByTagName('subtitle')) > 0:
data = result.getElementsByTagName('subtitle')
break
break
# print "data=", data
if not data:
return []
# catch all subtitles information
for entry in data:
try:
sub_obj = subtitlefile.SubtitleFile(online=True)
sub = {}
if entry.getElementsByTagName('EpisodeName'):
return
if entry.getElementsByTagName('IDSubtitle'):
sub['IDSubtitle'] = {'IDSubtitle': entry.getElementsByTagName('IDSubtitle')[0].firstChild.data,
'Link': entry.getElementsByTagName('IDSubtitle')[0].getAttribute('Link'),
'LinkImdb': entry.getElementsByTagName('IDSubtitle')[0].getAttribute('LinkImdb'),
'DownloadLink': entry.getElementsByTagName('IDSubtitle')[0].getAttribute('DownloadLink'),
'uuid': entry.getElementsByTagName('IDSubtitle')[0].getAttribute('uuid'),
}
sub_obj.setIdOnline(sub['IDSubtitle']['IDSubtitle'])
if entry.getElementsByTagName('IDSubtitleFile'):
sub['IDSubtitleFile'] = {'IDSubtitleFile': entry.getElementsByTagName('IDSubtitleFile')[0].firstChild.data,
}
sub_obj.setIdFileOnline(sub['IDSubtitleFile']['IDSubtitleFile'])
if entry.getElementsByTagName('UserID'):
sub['UserID'] = {'UserID': entry.getElementsByTagName('UserID')[0].firstChild.data,
'Link': entry.getElementsByTagName('UserID')[0].getAttribute('Link'),
}
if entry.getElementsByTagName('UserNickName') and entry.getElementsByTagName('UserNickName')[0].firstChild:
sub['UserNickName'] = entry.getElementsByTagName(
'UserNickName')[0].firstChild.data
sub_obj._uploader = sub['UserNickName']
if entry.getElementsByTagName('MovieID'):
#sub['MovieID'] = entry.getElementsByTagName('MovieID')[0].firstChild.data
sub['MovieID'] = {'MovieID': entry.getElementsByTagName('MovieID')[0].firstChild.data,
'Link': entry.getElementsByTagName('MovieID')[0].getAttribute('Link'),
'LinkImdb': entry.getElementsByTagName('MovieID')[0].getAttribute('LinkImdb'),
}
if entry.getElementsByTagName('MovieThumb') and entry.getElementsByTagName('MovieThumb')[0].firstChild:
sub['MovieThumb'] = entry.getElementsByTagName(
'MovieThumb')[0].firstChild.data
if entry.getElementsByTagName('LinkUseNext') and entry.getElementsByTagName('LinkUseNext')[0].firstChild:
sub['LinkUseNext'] = entry.getElementsByTagName(
'LinkUseNext')[0].firstChild.data
if entry.getElementsByTagName('LinkZoozle') and entry.getElementsByTagName('LinkZoozle')[0].firstChild:
sub['LinkZoozle'] = entry.getElementsByTagName(
'LinkZoozle')[0].firstChild.data
if entry.getElementsByTagName('LinkTorrentbar') and entry.getElementsByTagName('LinkTorrentbar')[0].firstChild:
sub['LinkTorrentbar'] = entry.getElementsByTagName(
'LinkTorrentbar')[0].firstChild.data
if entry.getElementsByTagName('LinkBoardreader') and entry.getElementsByTagName('LinkBoardreader')[0].firstChild:
sub['LinkBoardreader'] = entry.getElementsByTagName(
'LinkBoardreader')[0].firstChild.data
if entry.getElementsByTagName('MovieName') and entry.getElementsByTagName('MovieName')[0].firstChild:
sub['MovieName'] = entry.getElementsByTagName(
'MovieName')[0].firstChild.data
if entry.getElementsByTagName('MovieYear') and entry.getElementsByTagName('MovieYear')[0].firstChild:
sub['MovieYear'] = entry.getElementsByTagName(
'MovieYear')[0].firstChild.data
if entry.getElementsByTagName('MovieImdbRating') and entry.getElementsByTagName('MovieImdbRating')[0].firstChild:
sub['MovieImdbRating'] = entry.getElementsByTagName(
'MovieImdbRating')[0].firstChild.data
elif not entry.getElementsByTagName('MovieImdbRating')[0].firstChild:
sub['MovieImdbRating'] = 0
if entry.getElementsByTagName('MovieImdbID') and entry.getElementsByTagName('MovieImdbID')[0].firstChild:
sub['MovieImdbID'] = entry.getElementsByTagName(
'MovieImdbID')[0].firstChild.data
if entry.getElementsByTagName('SubAuthorComment'):
try:
sub['SubAuthorComment'] = entry.getElementsByTagName(
'SubAuthorComment')[0].firstChild.data
except AttributeError:
sub['SubAuthorComment'] = entry.getElementsByTagName(
'SubAuthorComment')[0].firstChild
if entry.getElementsByTagName('ISO639'):
sub['ISO639'] = {'ISO639': entry.getElementsByTagName('ISO639')[0].firstChild.data,
'LinkSearch': entry.getElementsByTagName('ISO639')[0].getAttribute('LinkSearch'),
'flag': entry.getElementsByTagName('ISO639')[0].getAttribute('flag'),
}
sub_obj.setLanguage(Language.from_xx(sub['ISO639']['ISO639']))
#sub_obj._onlineId = sub['IDSubtitle']['IDSubtitle']
# It does require the Subtitle ID to downlad, not the
# Subtitle File Id
sub_obj.setExtraInfo(
'downloadLink', "http://www.opensubtitles.org/download/sub/%s" % sub_obj.getIdOnline())
if entry.getElementsByTagName('LanguageName') and entry.getElementsByTagName('LanguageName')[0].firstChild:
sub['LanguageName'] = entry.getElementsByTagName(
'LanguageName')[0].firstChild.data
if entry.getElementsByTagName('SubFormat') and entry.getElementsByTagName('SubFormat')[0].firstChild:
sub['SubFormat'] = entry.getElementsByTagName(
'SubFormat')[0].firstChild.data
sub_obj.setExtraInfo('format', sub['SubFormat'])
if entry.getElementsByTagName('SubSumCD') and entry.getElementsByTagName('SubSumCD')[0].firstChild:
sub['SubSumCD'] = entry.getElementsByTagName(
'SubSumCD')[0].firstChild.data
sub_obj.setExtraInfo('totalCDs', sub['SubSumCD'])
if entry.getElementsByTagName('SubAddDate') and entry.getElementsByTagName('SubAddDate')[0].firstChild:
sub['SubAddDate'] = entry.getElementsByTagName(
'SubAddDate')[0].firstChild.data
if entry.getElementsByTagName('SubBad') and entry.getElementsByTagName('SubBad')[0].firstChild:
sub['SubBad'] = entry.getElementsByTagName(
'SubBad')[0].firstChild.data
if entry.getElementsByTagName('SubRating') and entry.getElementsByTagName('SubRating')[0].firstChild:
sub['SubRating'] = entry.getElementsByTagName(
'SubRating')[0].firstChild.data
sub_obj.setRating(sub['SubRating'])
if entry.getElementsByTagName('SubDownloadsCnt') and entry.getElementsByTagName('SubDownloadsCnt')[0].firstChild:
sub['SubDownloadsCnt'] = entry.getElementsByTagName(
'SubDownloadsCnt')[0].firstChild.data
sub_obj.setExtraInfo(
'totalDownloads', sub['SubDownloadsCnt'])
if entry.getElementsByTagName('SubMovieAka') and entry.getElementsByTagName('SubMovieAka')[0].firstChild:
sub['SubMovieAka'] = entry.getElementsByTagName(
'SubMovieAka')[0].firstChild.data
if entry.getElementsByTagName('SubDate') and entry.getElementsByTagName('SubDate')[0].firstChild:
sub['SubDate'] = entry.getElementsByTagName(
'SubDate')[0].firstChild.data
if entry.getElementsByTagName('SubComments') and entry.getElementsByTagName('SubComments')[0].firstChild:
sub['SubComments'] = entry.getElementsByTagName(
'SubComments')[0].firstChild.data
if entry.getElementsByTagName('TotalSubs') and entry.getElementsByTagName('TotalSubs')[0].firstChild:
sub['TotalSubs'] = entry.getElementsByTagName(
'TotalSubs')[0].firstChild.data
if entry.getElementsByTagName('Newest') and entry.getElementsByTagName('Newest')[0].firstChild:
sub['Newest'] = entry.getElementsByTagName(
'Newest')[0].firstChild.data
if sub:
# result_entries.append(sub)
temp_movie = Movie(sub)
movie_exists = False
for movie in result_entries:
if movie.MovieId == temp_movie.MovieId:
movie_exists = True
if hasattr(sub_obj, "_extraInfo") and sub_obj._extraInfo:
movie.subtitles.append(sub_obj)
# already_movie = result_entries.pop(result_entries.index(movie))
# temp_movie.subtitles = already_movie.subtitles
if not movie_exists:
if hasattr(sub_obj, "_extraInfo") and sub_obj._extraInfo:
temp_movie.subtitles.append(sub_obj)
result_entries.append(temp_movie)
except IndexError as e:
pass
return result_entries
def subtitle_info(self, raw_xml):
dom = minidom.parseString(raw_xml) # Make the dom from raw xml
entries = dom.getElementsByTagName(
'opensubtitles') # Pull out all entry's
subtitle_entries = [] # Make an empty container to fill up and return
data = None
for entry in entries:
if entry.getElementsByTagName('SubBrowse'):
for result in entry.getElementsByTagName('SubBrowse'):
if result.getElementsByTagName('Subtitle'):
data = result.getElementsByTagName('Subtitle')
break
break
# print "data=", data
if not data:
return []
# catch subtitle information
for entry in data:
sub_obj = subtitlefile.SubtitleFile(online=True)
sub = {}
if entry.getElementsByTagName('LinkDetails') and entry.getElementsByTagName('LinkDetails')[0].firstChild:
sub['LinkDetails'] = entry.getElementsByTagName(
'LinkDetails')[0].firstChild.data
if entry.getElementsByTagName('IDSubtitle'):
sub['IDSubtitle'] = {'IDSubtitle': entry.getElementsByTagName('IDSubtitle')[0].firstChild.data,
'Link': entry.getElementsByTagName('IDSubtitle')[0].getAttribute('Link'),
}
sub_obj._onlineId = sub['IDSubtitle']['IDSubtitle']
if entry.getElementsByTagName('MovieReleaseName') and entry.getElementsByTagName('MovieReleaseName')[0].firstChild:
sub['MovieReleaseName'] = entry.getElementsByTagName(
'MovieReleaseName')[0].firstChild.data
if entry.getElementsByTagName('SubFormat') and entry.getElementsByTagName('SubFormat')[0].firstChild:
sub['SubFormat'] = entry.getElementsByTagName(
'SubFormat')[0].firstChild.data
sub_obj.setExtraInfo('format', sub['SubFormat'])
if entry.getElementsByTagName('SubSumCD') and entry.getElementsByTagName('SubSumCD')[0].firstChild:
sub['SubSumCD'] = entry.getElementsByTagName(
'SubSumCD')[0].firstChild.data
sub_obj.setExtraInfo('totalCDs', sub['SubSumCD'])
if entry.getElementsByTagName('SubAuthorComment') and entry.getElementsByTagName('SubAuthorComment')[0].firstChild:
sub['SubAuthorComment'] = entry.getElementsByTagName(
'SubAuthorComment')[0].firstChild.data
if entry.getElementsByTagName('SubAddDate') and entry.getElementsByTagName('SubAddDate')[0].firstChild:
sub['SubAddDate'] = entry.getElementsByTagName(
'SubAddDate')[0].firstChild.data
if entry.getElementsByTagName('SubSumVotes') and entry.getElementsByTagName('SubSumVotes')[0].firstChild:
sub['SubSumVotes'] = entry.getElementsByTagName(
'SubSumVotes')[0].firstChild.data
if entry.getElementsByTagName('SubRating') and entry.getElementsByTagName('SubRating')[0].firstChild:
sub['SubRating'] = entry.getElementsByTagName(
'SubRating')[0].firstChild.data
sub_obj.setRating(sub['SubRating'])
if entry.getElementsByTagName('SubDownloadsCnt') and entry.getElementsByTagName('SubDownloadsCnt')[0].firstChild:
sub['SubDownloadsCnt'] = entry.getElementsByTagName(
'SubDownloadsCnt')[0].firstChild.data
sub_obj.setExtraInfo('totalDownloads', sub['SubDownloadsCnt'])
if entry.getElementsByTagName('UserNickName') and entry.getElementsByTagName('UserNickName')[0].firstChild:
sub['UserNickName'] = entry.getElementsByTagName(
'UserNickName')[0].firstChild.data
sub_obj._uploader = sub['UserNickName']
if entry.getElementsByTagName('LanguageName') and entry.getElementsByTagName('LanguageName')[0].firstChild:
sub['LanguageName'] = entry.getElementsByTagName(
'LanguageName')[0].firstChild.data
sub_obj.setLanguage(Language.from_xx(
entry.getElementsByTagName('LanguageName')[0].getAttribute('ISO639')))
if entry.getElementsByTagName('SubtitleFile'):
SubtitleFile = {}
_SubtitleFile = entry.getElementsByTagName('SubtitleFile')[0]
_File = _SubtitleFile.getElementsByTagName('File')[0]
SubtitleFile['File'] = {'ID': _SubtitleFile.getElementsByTagName('File')[0].getAttribute('ID'),
'SubActualCD': {'SubActualCD': _File.getElementsByTagName('SubActualCD')[0].firstChild.data,
'SubSize': _File.getElementsByTagName('SubActualCD')[0].getAttribute('Link'),
'MD5': _File.getElementsByTagName('SubActualCD')[0].getAttribute('MD5'),
'SubFileName': _File.getElementsByTagName('SubActualCD')[0].getAttribute('SubFileName'),
'DownloadLink': _File.getElementsByTagName('SubActualCD')[0].getAttribute('DownloadLink'),
}
}
SubtitleFile['Download'] = {'Download': _SubtitleFile.getElementsByTagName('Download')[0].firstChild.data,
'DownloadLink': _SubtitleFile.getElementsByTagName('Download')[0].getAttribute('LinkDownloadBundle'),
}
sub['SubtitleFile'] = SubtitleFile
global OnlyLink
OnlyLink = _SubtitleFile.getElementsByTagName(
'Download')[0].getAttribute('LinkDownloadBundle')
OnlyLink = ((OnlyLink.replace('dl', 'www')).replace(
'org/en', 'com')).replace('subb', 'sub')
if entry.getElementsByTagName('Movie'):
_Movie = entry.getElementsByTagName('Movie')[0]
#sub['MovieName'] = _Movie.getElementsByTagName('MovieName')[0].firstChild.data
sub['MovieID'] = {'MovieID': _Movie.getElementsByTagName('MovieName')[0].getAttribute('MovieID'),
'Link': _Movie.getElementsByTagName('MovieName')[0].getAttribute('Link'),
}
for section in _Movie.getElementsByTagName('section'):
if section.getAttribute('type') == u"about":
for info in section.getElementsByTagName("info"):
if info.getElementsByTagName("web_url")[0].firstChild.data == u"http://www.imdb.com":
sub['MovieID']['LinkImdb'] = info.getElementsByTagName(
"link_detail")[0].firstChild.data
if entry.getElementsByTagName('FullName') and entry.getElementsByTagName('FullName')[0].firstChild:
sub['FullName'] = entry.getElementsByTagName(
'FullName')[0].firstChild.data
if entry.getElementsByTagName('ReportLink') and entry.getElementsByTagName('ReportLink')[0].firstChild:
sub['ReportLink'] = entry.getElementsByTagName(
'ReportLink')[0].firstChild.data
# just a shortcut
sub['DownloadLink'] = sub['SubtitleFile']['File']['SubActualCD']['DownloadLink']
Link().OneLink(OnlyLink)
if sub:
subtitle_entries.append(sub)
return (subtitle_entries, sub_obj)
if entry.getElementsByTagName('Newest') and entry.getElementsByTagName('Newest')[0].firstChild:
sub['Newest'] = entry.getElementsByTagName(
'Newest')[0].firstChild.data
if sub:
# result_entries.append(sub)
temp_movie = Movie(sub)
movie_exists = False
for movie in result_entries:
if movie.MovieId == temp_movie.MovieId:
movie_exists = True
if hasattr(sub_obj, "_extraInfo") and sub_obj._extraInfo:
movie.subtitles.append(sub_obj)
# already_movie = result_entries.pop(result_entries.index(movie))
# temp_movie.subtitles = already_movie.subtitles
if not movie_exists:
if hasattr(sub_obj, "_extraInfo") and sub_obj._extraInfo:
temp_movie.subtitles.append(sub_obj)
result_entries.append(temp_movie)
except IndexError as e:
pass
return result_entries
# For testing purposes
if __name__ == "__main__":
s = SearchByName()
res = s.search_movie(languages=[Language.from_xxx("por"), Language.from_xxx("pob")], moviename="anamorph")
for movie in res:
print(movie)
print(len(movie.subtitles))
def legal_languages(self):
return [
Language.from_locale(locale)
for locale in i18n_get_supported_locales()
]
def search_videos(self, videos, callback, languages=None):
log.debug('search_videos(#videos={})'.format(len(videos)))
if not self.logged_in():
raise ProviderNotConnectedError()
lang_str = self._languages_to_str(languages)
window_size = 5
callback.set_range(0, (len(videos) + (window_size - 1)) // window_size)
remote_subtitles = []
for window_i, video_window in enumerate(
window_iterator(videos, window_size)):
callback.update(window_i)
if callback.canceled():
break
queries = []
hash_video = {}
for video in video_window:
query = {
'sublanguageid': lang_str,
'moviehash': video.get_osdb_hash(),
'moviebytesize': str(video.get_size()),
}
queries.append(query)
hash_video[video.get_osdb_hash()] = video
def run_query():
return self._xmlrpc.SearchSubtitles(
self._token, queries, {'limit': self.SEARCH_LIMIT})
result = self._safe_exec(run_query, None)
self.check_result(result)
if result is None:
continue
for rsub_raw in result['data']:
try:
remote_filename = rsub_raw['SubFileName']
remote_file_size = int(rsub_raw['SubSize'])
remote_id = rsub_raw['IDSubtitleFile']
remote_md5_hash = rsub_raw['SubHash']
remote_download_link = rsub_raw['SubDownloadLink']
remote_link = rsub_raw['SubtitlesLink']
remote_uploader = rsub_raw['UserNickName'].strip()
remote_language_raw = rsub_raw['SubLanguageID']
try:
remote_language = Language.from_unknown(
remote_language_raw, xx=True, xxx=True)
except NotALanguageException:
remote_language = UnknownLanguage(remote_language_raw)
remote_rating = float(rsub_raw['SubRating'])
remote_date = datetime.datetime.strptime(
rsub_raw['SubAddDate'], '%Y-%m-%d %H:%M:%S')
remote_subtitle = OpenSubtitlesSubtitleFile(
filename=remote_filename,
file_size=remote_file_size,
md5_hash=remote_md5_hash,
id_online=remote_id,
download_link=remote_download_link,
link=remote_link,
uploader=remote_uploader,
language=remote_language,
rating=remote_rating,
age=remote_date,
)
movie_hash = '{:>016}'.format(rsub_raw['MovieHash'])
video = hash_video[movie_hash]
imdb_id = rsub_raw['IDMovieImdb']
imdb_identity = ImdbIdentity(imdb_id=imdb_id,
imdb_rating=None)
identity = ProviderIdentities(imdb_identity=imdb_identity,
provider=self)
video.add_subtitle(remote_subtitle)
video.add_identity(identity)
remote_subtitles.append(remote_subtitle)
except (KeyError, ValueError):
log.exception(
'Error parsing result of SearchSubtitles(...)')
log.error('Offending query is: {queries}'.format(
queries=queries))
log.error('Offending result is: {remote_sub}'.format(
remote_sub=rsub_raw))
callback.finish()
return remote_subtitles
def get_language(self, section, option):
xxx = self.get_str(section, option, UnknownLanguage.create_generic())
return Language.from_xxx(xxx)
def get_languages(self, section, option):
xxxs = self.get_str(section, option, None)
if xxxs is None:
return []
return [Language.from_xxx(lang_str) for lang_str in xxxs.split(',') if lang_str]
def _xml_to_subtitles(self, xml):
subtitle_entries, nb_so_far, nb_provider = self._extract_subtitle_entries(
xml)
if subtitle_entries is None:
return None, None, None
subtitles = []
for subtitle_entry in subtitle_entries:
try:
ads_entries = subtitle_entry.getElementsByTagName(
'ads1') or subtitle_entry.getElementsByTagName('ads2')
if ads_entries:
continue
def try_get_first_child_data(key, default):
try:
return subtitle_entry.getElementsByTagName(
key)[0].firstChild.data
except (AttributeError, IndexError):
return default
subtitle_id_entry = subtitle_entry.getElementsByTagName(
'IDSubtitle')[0]
subtitle_id = subtitle_id_entry.firstChild.data
subtitle_link = 'http://www.opensubtitles.org' + subtitle_id_entry.getAttribute(
'Link')
subtitle_uuid = subtitle_id_entry.getAttribute('uuid')
subtitlefile_id = subtitle_entry.getElementsByTagName(
'IDSubtitleFile')[0].firstChild.data
user_entry = subtitle_entry.getElementsByTagName('UserID')[0]
user_id = int(user_entry.firstChild.data)
# user_link = 'http://www.opensubtitles.org' + user_entry.getAttribute('Link')
user_nickname = try_get_first_child_data('UserNickName', None)
# comment = try_get_first_child_data(''SubAuthorComment', None)
language_entry = subtitle_entry.getElementsByTagName(
'ISO639')[0]
language_iso639 = language_entry.firstChild.data
# language_link_search = 'http://www.opensubtitles.org' + language_entry.getAttribute('LinkSearch')
# language_flag = 'http:' + language_entry.getAttribute('flag')
# language_name = try_get_first_child_data('LanguageName', None)
subtitle_format = try_get_first_child_data('SubFormat', 'srt')
# subtitle_nbcds = int(try_get_first_child_data('SubSumCD', -1))
subtitle_add_date_locale = subtitle_entry.getElementsByTagName(
'SubAddDate')[0].getAttribute('locale')
subtitle_add_date = datetime.datetime.strptime(
subtitle_add_date_locale, '%d/%m/%Y %H:%M:%S')
# subtitle_bad = int(subtitle_entry.getElementsByTagName('SubBad')[0].firstChild.data)
subtitle_rating = float(
subtitle_entry.getElementsByTagName('SubRating')
[0].firstChild.data)
# download_count = int(try_get_first_child_data('SubDownloadsCnt', -1))
# subtitle_movie_aka = try_get_first_child_data('SubMovieAka', None)
# subtitle_comments = int(try_get_first_child_data('SubComments', -1))
# subtitle_total = int(try_get_first_child_data('TotalSubs', -1)) #PRESENT?
# subtitle_newest = try_get_first_child_data('Newest', None) #PRESENT?
language = Language.from_xx(language_iso639)
movie_release_name = subtitle_entry.getElementsByTagName(
'MovieReleaseName')[0].firstChild.data
filename = '{}.{}'.format(movie_release_name, subtitle_format)
download_link = 'http://www.opensubtitles.org/download/sub/{}'.format(
subtitle_id)
if user_nickname:
uploader = user_nickname
elif user_id != 0:
uploader = str(user_id)
else:
uploader = None
subtitle = OpenSubtitlesSubtitleFile(
filename=filename,
file_size=None,
md5_hash=subtitle_uuid,
id_online=subtitlefile_id,
download_link=download_link,
link=subtitle_link,
uploader=uploader,
language=language,
rating=subtitle_rating,
age=subtitle_add_date)
subtitles.append(subtitle)
except (AttributeError, IndexError, ValueError):
log.warning('subtitle_entry={}'.format(subtitle_entry.toxml()))
log.warning('XML entry has invalid format.',
exc_info=sys.exc_info())
return subtitles, nb_so_far, nb_provider
def search_videos(self, videos, callback, languages=None):
limit = 500
if languages:
lang_str = ','.join([language.xxx() for language in languages])
else:
lang_str = 'all'
window_size = 5
callback.set_range(0, (len(videos) + (window_size - 1)) // window_size)
remote_subtitles = []
for window_i, video_window in enumerate(window_iterator(videos, window_size)):
callback.update(window_i)
if callback.canceled():
break
queries = []
hash_video = {}
for video in video_window:
query = {
'sublanguageid': lang_str,
'moviehash': video.get_osdb_hash(),
'moviebytesize': str(video.get_size()),
}
queries.append(query)
hash_video[video.get_osdb_hash()] = video
def run_query():
return self._xmlrpc_server.SearchSubtitles(self._token, queries, {'limit': limit})
result = self._safe_exec(run_query, None)
if result is None:
return remote_subtitles
self.check_result(result)
for rsub_raw in result['data']:
try:
remote_filename = rsub_raw['SubFileName']
remote_file_size = int(rsub_raw['SubSize'])
remote_id = rsub_raw['IDSubtitleFile']
remote_md5_hash = rsub_raw['SubHash']
remote_download_link = rsub_raw['SubDownloadLink']
remote_link = rsub_raw['SubtitlesLink']
remote_uploader = rsub_raw['UserNickName']
remote_language_raw = rsub_raw['SubLanguageID']
try:
remote_language = Language.from_unknown(remote_language_raw,
locale=False, name=False)
except NotALanguageException:
remote_language = UnknownLanguage(remote_language_raw)
remote_rating = float(rsub_raw['SubRating'])
remote_subtitle = OpenSubtitles_SubtitleFile(
filename=remote_filename,
file_size=remote_file_size ,
md5_hash=remote_md5_hash,
id_online=remote_id,
download_link=remote_download_link,
link=remote_link,
uploader=remote_uploader,
language=remote_language,
rating=remote_rating,
)
movie_hash = '{:>016}'.format(rsub_raw['MovieHash'])
hash_video[movie_hash].add_subtitle(remote_subtitle)
remote_subtitles.append(remote_subtitle)
except (KeyError, ValueError):
log.exception('Error parsing result of SearchSubtitles(...)')
log.error('Offending query is: {queries}'.format(queries=queries))
log.error('Offending result is: {remote_sub}'.format(remote_sub=rsub_raw))
callback.finish()
return remote_subtitles
def _SearchSubtitles(self, language="all", videos=None, imdb_ids=None):
"""
Search subtitles for the given video(s).
@language: language code - string
@videos: video objects - list
@imdb_id: IMDB movie id's - list
Note:Max results is 250. When nothing is found, 'data' is empty.
"""
self.log.debug("----------------")
self.log.debug("SearchSubtitles RPC method starting...")
search_array = []
if videos:
self.log.debug("Building search array with video objects info")
for video in videos:
array = {'sublanguageid': language, 'moviehash':
video.get_hash(), 'moviebytesize': str(video.get_size())}
self.log.debug(" - adding: %s" % array)
search_array.append(array)
elif imdb_ids:
self.log.debug("Building search array with IMDB id's")
for id in imdb_ids:
array = {'sublanguageid': language, 'imdbid': id}
self.log.debug(" - adding: %s" % array)
search_array.append(array)
self.log.debug("Communicating with server...")
result = self._xmlrpc_server.SearchSubtitles(
self._token, search_array)
if result is not None and result['data'] != False:
self.log.debug("Collecting downloaded data")
moviehashes = {}
for i in result['data']:
moviehash = i['MovieHash']
if moviehash not in moviehashes:
moviehashes[moviehash] = []
moviehashes[moviehash].append(i)
self.log.debug("Movie hashes: %i" % len(moviehashes.keys()))
if videos:
videos_result = []
for video in videos:
if video.get_hash() in moviehashes:
osdb_info = moviehashes[video.get_hash()]
subtitles = []
self.log.debug("- %s (%s)" %
(video.get_filepath(), video.get_hash()))
for i in osdb_info:
sub = subtitlefile.SubtitleFile(
online=True, id=i["IDSubtitle"])
sub.setHash(i["SubHash"])
sub.setIdFileOnline(i["IDSubtitleFile"])
sub.setFileName(i["SubFileName"])
# This method will autogenerate the XX and the
# LanguageName
sub.setLanguage(Language.from_xxx(i["SubLanguageID"]))
# sub.setLanguageXX(i["ISO639"])
# sub.setLanguageName(i["LanguageName"])
sub.setRating(i["SubRating"])
sub.setUploader(i["UserNickName"])
sub.setDownloadLink(i["SubDownloadLink"])
sub.setVideo(video)
self.log.debug(
" [%s] - %s" % (sub.getLanguage().xxx(), sub.get_filepath()))
subtitles.append(sub)
# Let's get the IMDB info which is majority in the
# subtitles
video.setMovieInfo(self.getBestImdbInfo(osdb_info))
video.setOsdbInfo(osdb_info)
video.setSubtitles(subtitles)
videos_result.append(video)
return videos_result
elif imdb_ids:
# TODO: search with IMDB id's
pass
else:
self.log.info("No subtitles were found on Opensubtitles.org")
return []
def detect_language_contents(self):
return Language.from_file(self._filepath)
def upload_subtitles(self, local_movie):
log.debug('upload_subtitles()')
if not self.logged_in():
raise ProviderNotConnectedError()
video_subtitles = list(local_movie.iter_video_subtitles())
if not video_subtitles:
return UploadResult(
type=UploadResult.Type.MISSINGDATA,
reason=_('Need at least one subtitle to upload'))
query_try = dict()
for sub_i, (video, subtitle) in enumerate(video_subtitles):
if not video:
return UploadResult(
type=UploadResult.Type.MISSINGDATA,
reason=_('Each subtitle needs an accompanying video'))
query_try['cd{}'.format(sub_i + 1)] = {
'subhash':
subtitle.get_md5_hash(),
'subfilename':
subtitle.get_filename(),
'moviehash':
video.get_osdb_hash(),
'moviebytesize':
str(video.get_size()),
'moviefps':
str(video.get_fps()) if video.get_fps() else None,
'movieframes':
str(video.get_framecount())
if video.get_framecount() else None,
'moviefilename':
video.get_filename(),
}
def run_query_try_upload():
return self._xmlrpc.TryUploadSubtitles(self._token, query_try)
try_result = self._safe_exec(run_query_try_upload, None)
self.check_result(try_result)
if int(try_result['alreadyindb']):
return UploadResult(type=UploadResult.Type.DUPLICATE,
reason=_('Subtitle is already in database'))
if local_movie.get_imdb_id() is None:
return UploadResult(type=UploadResult.Type.MISSINGDATA,
reason=_('Need IMDb id'))
upload_base_info = {
'idmovieimdb': local_movie.get_imdb_id(),
}
if local_movie.get_comments() is not None:
upload_base_info['subauthorcomment'] = local_movie.get_comments()
if not local_movie.get_language().is_generic():
upload_base_info['sublanguageid'] = local_movie.get_language().xxx(
)
if local_movie.get_release_name() is not None:
upload_base_info[
'moviereleasename'] = local_movie.get_release_name()
if local_movie.get_movie_name() is not None:
upload_base_info['movieaka'] = local_movie.get_movie_name()
if local_movie.is_hearing_impaired() is not None:
upload_base_info[
'hearingimpaired'] = local_movie.is_hearing_impaired()
if local_movie.is_high_definition() is not None:
upload_base_info[
'highdefinition'] = local_movie.is_high_definition()
if local_movie.is_automatic_translation() is not None:
upload_base_info[
'automatictranslation'] = local_movie.is_automatic_translation(
)
if local_movie.get_author() is not None:
upload_base_info['subtranslator'] = local_movie.get_author()
if local_movie.is_foreign_only() is not None:
upload_base_info['foreignpartsonly'] = local_movie.is_foreign_only(
)
query_upload = {
'baseinfo': upload_base_info,
}
for sub_i, (video, subtitle) in enumerate(video_subtitles):
sub_bytes = subtitle.get_filepath().open(mode='rb').read()
sub_tx_data = base64.b64encode(zlib.compress(sub_bytes)).decode()
query_upload['cd{}'.format(sub_i + 1)] = {
'subhash':
subtitle.get_md5_hash(),
'subfilename':
subtitle.get_filename(),
'moviehash':
video.get_osdb_hash(),
'moviebytesize':
str(video.get_size()),
'movietimems':
str(video.get_time_ms()) if video.get_time_ms() else None,
'moviefps':
str(video.get_fps()) if video.get_fps() else None,
'movieframes':
str(video.get_framecount())
if video.get_framecount() else None,
'moviefilename':
video.get_filename(),
'subcontent':
sub_tx_data,
}
def run_query_upload():
return self._xmlrpc.UploadSubtitles(self._token, query_upload)
result = self._safe_exec(run_query_upload, None)
self.check_result(result)
rsubs = []
for sub_data in result['data']:
filename = sub_data['SubFileName']
file_size = sub_data['SubSize']
md5_hash = sub_data['SubHash']
id_online = sub_data['IDSubMOvieFile']
download_link = sub_data['SubDownloadLink']
link = None
uploader = sub_data['UserNickName']
language = Language.from_xxx(sub_data['SubLanguageID'])
rating = float(sub_data['SubRating'])
add_date = datetime.datetime.strptime(sub_data['SubAddDate'],
'%Y-%m-%d %H:%M:%S')
sub = OpenSubtitlesSubtitleFile(filename=filename,
file_size=file_size,
md5_hash=md5_hash,
id_online=id_online,
download_link=download_link,
link=link,
uploader=uploader,
language=language,
rating=rating,
date=add_date)
rsubs.append(sub)
return UploadResult(type=UploadResult.Type.OK, rsubs=rsubs)
def translators_get():
from subdownloader.languages.language import Language
return (Translator('Sylvestre Ledru', '*****@*****.**',
(Language.from_xx('fr'), )), )
