def Search(item):
    filename = '.'.join(
        os.path.basename(item["file_original_path"]).split(".")[:-1])
    helper = NapiProjektKatalog()
    results = helper.search(item)

    for result in results:
        listitem = xbmcgui.ListItem(
            label=xbmc.convertLanguage(result["language"], xbmc.ENGLISH_NAME),
            # language name for the found subtitle
            label2=result['label'],  # file name for the found subtitle
            iconImage="5",  # rating for the subtitle, string 0-5
            thumbnailImage=xbmc.convertLanguage(result["language"],
                                                xbmc.ISO_639_1)
            # language flag, ISO_639_1 language + gif extention, e.g - "en.gif"
        )

        # # below arguments are optional, it can be used to pass any info needed in download function
        # # anything after "action=download&" will be sent to addon once user clicks listed subtitle to download
        url = "plugin://%s/?action=download&l=%s&f=%s&filename=%s" % (
            __scriptid__, result["language"], result['link_hash'], filename)
        # # add it to list, this can be done as many times as needed for all subtitles found
        xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
                                    url=url,
                                    listitem=listitem,
                                    isFolder=False)
 def _retrive_subtitles(self, page, item):
     ret = []
     total_downloads = 0
     if page is not None:
         found_subtitles = re.findall(
             "downloadsubtitle\.php\?id=(?P<fid>\d*).*?subt_lang.*?title=\"(?P<language>.*?)\".*?subtitle_title.*?title=\"(?P<title>.*?)\">.*?>(?P<downloads>[^ ]+) הורדות",
             page)
         for (subtitle_id, language, title, downloads) in found_subtitles:
             if xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2) in item[
                 "3let_language"]:
                 subtitle_rate = self._calc_rating(title, item["file_original_path"])
                 total_downloads += int(downloads.replace(",", ""))
                 ret.append(
                     {'lang_index': item["3let_language"].index(
                         xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2)),
                      'filename': title,
                      'link': subtitle_id,
                      'language_name': xbmc.convertLanguage(heb_to_eng(language),
                                                            xbmc.ENGLISH_NAME),
                      'language_flag': xbmc.convertLanguage(heb_to_eng(language),
                                                            xbmc.ISO_639_1),
                      'id': subtitle_id,
                      'rating': int(downloads.replace(",", "")),
                      'sync': subtitle_rate >= 3.8,
                      'hearing_imp': 0,
                      'is_preferred':
                          xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2) == item['preferredlanguage']
                     })
     return ret, total_downloads
Ejemplo n.º 3
0
 def _retrive_subtitles(self, page, item):
     ret = []
     total_downloads = 0
     if page is not None:
         found_subtitles = re.findall(
             'downloadsubtitle\.php\?id=(?P<fid>\d*).*?subt_lang.*?title="(?P<language>.*?)".*?subtitle_title.*?title="(?P<title>.*?)">.*?>(?P<downloads>[^ ]+) הורדות',
             page,
         )
         for (subtitle_id, language, title, downloads) in found_subtitles:
             if xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2) in item["3let_language"]:
                 subtitle_rate = self._calc_rating(title, item["file_original_path"])
                 total_downloads += int(downloads.replace(",", ""))
                 ret.append(
                     {
                         "lang_index": item["3let_language"].index(
                             xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2)
                         ),
                         "filename": title,
                         "link": subtitle_id,
                         "language_name": xbmc.convertLanguage(heb_to_eng(language), xbmc.ENGLISH_NAME),
                         "language_flag": xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_1),
                         "ID": subtitle_id,
                         "rating": int(downloads.replace(",", "")),
                         "sync": subtitle_rate >= 4,
                         "hearing_imp": 0,
                     }
                 )
     return ret, total_downloads
Ejemplo n.º 4
0
    def _build_subtitle_list(self, search_results, item):
        results = []
        total_downloads = 0

        for result in search_results:
            lang3 = xbmc.convertLanguage(result["language"], xbmc.ISO_639_2)

            if lang3 in item["3let_language"]:
                total_downloads += result["downloads"]
                results.append({
                    'lang_index': item["3let_language"].index(lang3),
                    'filename': result["release"],
                    'language_name': xbmc.convertLanguage(result["language"], xbmc.ENGLISH_NAME),
                    'language_flag': result["language"],
                    'id': result["id"],
                    'rating': result["downloads"],
                    'sync': self._is_synced(item, result["video_file_size"], result["release"]),
                    'hearing_imp': False,
                    'is_preferred': lang3 == item['preferredlanguage']
                })

        # Fix the rating
        if total_downloads:
            for it in results:
                it["rating"] = min(int(round(it["rating"] / float(total_downloads), 1) * 8), 5)

        return sorted(results, key=lambda x: (x['is_preferred'], x['lang_index'], x['sync'], x['rating']), reverse=True)
 def _retrive_subtitles(self, page, item):
     ret = []
     total_downloads = 0
     if page is not None:
         found_subtitles = re.findall(
             "downloadsubtitle\.php\?id=(?P<fid>\d*).*?subt_lang.*?title=\"(?P<language>.*?)\".*?subtitle_title.*?title=\"(?P<title>.*?)\">.*?>(?P<downloads>[^ ]+) הורדות",
             page)
         for (subtitle_id, language, title, downloads) in found_subtitles:
             if xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2) in item["3let_language"]:
                 subtitle_rate = self._calc_rating(title, item["file_original_path"])
                 total_downloads += int(downloads.replace(",", ""))
                 ret.append(
                     {'lang_index': item["3let_language"].index(
                         xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2)),
                         'filename': title,
                         'link': subtitle_id,
                         'language_name': xbmc.convertLanguage(heb_to_eng(language),
                                                               xbmc.ENGLISH_NAME),
                         'language_flag': xbmc.convertLanguage(heb_to_eng(language),
                                                               xbmc.ISO_639_1),
                         'id': subtitle_id,
                         'rating': int(downloads.replace(",", "")),
                         'sync': subtitle_rate >= 3.8,
                         'hearing_imp': 0,
                         'is_preferred':
                             xbmc.convertLanguage(heb_to_eng(language), xbmc.ISO_639_2) == item[
                                 'preferredlanguage']
                     })
     return ret, total_downloads
Ejemplo n.º 6
0
def get_languages(params, lang_format = 2):
    """
    Get the requested languages the user want to search (3 letter format)

    Args:
        params: The passed parameters dict.
        lang_format: 0 to get full language name
            1 to get two letter code (ISO 639-1)
            2 to get three letter code (ISO 639-2/T or ISO 639-2/B) (default)

    Returns:
        An array with the requested languages, e.g. ['scc','eng']
    """
    langs = []  # ['scc','eng']
    for lang in urllib.unquote(params['languages']).decode('utf-8').split(","):
        if lang_format == 0:
            # Full language name
            langs.append(lang)
        elif lang_format == 1:
            # 2 letter format
            langs.append(xbmc.convertLanguage(lang, xbmc.ISO_639_1))
        else:
            # 3 letter format
            langs.append(xbmc.convertLanguage(lang, xbmc.ISO_639_2))
    return langs
def Search(item):
    d = timeout(set_filehash, args=(item["file_original_path"], item["rar"]), timeout_duration=15)
    md5hash = d.hexdigest()
    t = f(md5hash)
    filename = '.'.join(os.path.basename(item["file_original_path"]).split(".")[:-1])
    helper = NapiProjektHelper(filename, md5hash)
    results = helper.search(item, t)

    for result in results:
        listitem = xbmcgui.ListItem(label=xbmc.convertLanguage(result["language"], xbmc.ENGLISH_NAME),
                                    # language name for the found subtitle
                                    label2=filename,  # file name for the found subtitle
                                    iconImage="5",  # rating for the subtitle, string 0-5
                                    thumbnailImage=xbmc.convertLanguage(result["language"], xbmc.ISO_639_1)
                                    # language flag, ISO_639_1 language + gif extention, e.g - "en.gif"
                                    )
        listitem.setProperty("sync", '{0}'.format("true").lower())  # set to "true" if subtitle is matched by hash,
        # indicates that sub is 100 Comaptible
        listitem.setProperty("hearing_imp",
                             '{0}'.format("false").lower())  # set to "true" if subtitle is for hearing impared

        ## below arguments are optional, it can be used to pass any info needed in download function
        ## anything after "action=download&" will be sent to addon once user clicks listed subtitle to download
        url = "plugin://%s/?action=download&l=%s&f=%s&filename=%s" % (
            __scriptid__, result["language"], md5hash, filename)
        ## add it to list, this can be done as many times as needed for all subtitles found
        xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=listitem, isFolder=False)
def main():
    """Main entry point of the script when it is invoked by XBMC."""

    # Get parameters from XBMC and launch actions
    params = get_params()

    if params['action'] == 'search':
        item = {}
        item['temp']               = False
        item['rar']                = False
        item['year']               = xbmc.getInfoLabel("VideoPlayer.Year")
        item['season']             = str(xbmc.getInfoLabel("VideoPlayer.Season"))
        item['episode']            = str(xbmc.getInfoLabel("VideoPlayer.Episode"))
        item['tvshow']             = normalizeString(xbmc.getInfoLabel("VideoPlayer.TVshowtitle"))
        # Try to get original title
        item['title']              = normalizeString(xbmc.getInfoLabel("VideoPlayer.OriginalTitle"))
        # Full path of a playing file
        item['file_original_path'] = urllib.unquote(xbmc.Player().getPlayingFile().decode('utf-8'))
        item['3let_language']      = []
        item['2let_language']      = []

        for lang in urllib.unquote(params['languages']).decode('utf-8').split(","):
            item['3let_language'].append(xbmc.convertLanguage(lang, xbmc.ISO_639_2))
            item['2let_language'].append(xbmc.convertLanguage(lang, xbmc.ISO_639_1))

        if not item['title']:
            # No original title, get just Title
            item['title'] = normalizeString(xbmc.getInfoLabel("VideoPlayer.Title"))

        if "s" in item['episode'].lower():
            # Check if season is "Special"
            item['season'] = "0"
            item['episode'] = item['episode'][-1:]

        if "http" in item['file_original_path']:
            item['temp'] = True

        elif "rar://" in item['file_original_path']:
            item['rar'] = True
            item['file_original_path'] = os.path.dirname(item['file_original_path'][6:])

        elif "stack://" in item['file_original_path']:
            stackPath = item['file_original_path'].split(" , ")
            item['file_original_path'] = stackPath[0][8:]

        Search(item)

    elif params['action'] == 'download':
        # We pickup all our arguments sent from def Search()
        subs = Download(params["id"], params["filename"])
        # We can return more than one subtitle for multi CD versions, for now
        # we are still working out how to handle that in XBMC core
        for sub in subs:
            listitem = xbmcgui.ListItem(label=sub)
            xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sub,
                                        listitem=listitem, isFolder=False)

    # Send end of directory to XBMC
    xbmcplugin.endOfDirectory(int(sys.argv[1]))
Ejemplo n.º 9
0
    def _build_subtitle_list(self, search_results, item):
        ret = []
        for result in search_results:
            total_downloads = 0
            counter = 0
            subs_list = result["subs"]

            if subs_list is not None:
                for language in subs_list.keys():
                    if xbmc.convertLanguage(
                            language, xbmc.ISO_639_2) in item["3let_language"]:
                        for current in subs_list[language]:
                            counter += 1
                            title = current["version"]
                            subtitle_rate = self._calc_rating(
                                title, item["file_original_path"])
                            total_downloads += int(current["downloads"])
                            ret.append({
                                'lang_index':
                                item["3let_language"].index(
                                    xbmc.convertLanguage(
                                        language, xbmc.ISO_639_2)),
                                'filename':
                                title,
                                'link':
                                current["key"],
                                'language_name':
                                xbmc.convertLanguage(language,
                                                     xbmc.ENGLISH_NAME),
                                'language_flag':
                                language,
                                'id':
                                current["id"],
                                'rating':
                                current["downloads"],
                                'sync':
                                subtitle_rate >= 3.8,
                                'hearing_imp':
                                False,
                                'is_preferred':
                                xbmc.convertLanguage(language, xbmc.ISO_639_2)
                                == item['preferredlanguage']
                            })
            # Fix the rating
            if total_downloads:
                for it in ret[-1 * counter:]:
                    it["rating"] = str(
                        min(
                            int(
                                round(
                                    float(it["rating"]) /
                                    float(total_downloads), 1) * 8), 5))

        return sorted(
            ret,
            key=lambda x:
            (x['is_preferred'], x['lang_index'], x['sync'], x['rating']),
            reverse=True)
    def _set_languages(self):
        """Set accepted languages."""

        self._languages = []
        self._languages_codes = []
        if 'languages' in self._parameters:
            for language in urllib.unquote(
                    self._parameters['languages']).decode('utf-8').split(','):
                self._languages.append(
                    xbmc.convertLanguage(language, xbmc.ENGLISH_NAME))
                self._languages_codes.append(
                    xbmc.convertLanguage(language, xbmc.ISO_639_1))
Ejemplo n.º 11
0
def parse_argv(argv: list) -> dict:
    log(parse_argv.__name__, f"Parsing arguments: {argv}")

    param = dict(parse.parse_qsl(sys.argv[2].lstrip('?')))

    if 'languages' in param:
        param['languages'] = param['languages'] \
            .replace('original',
                     xbmc.convertLanguage(xbmc.getInfoLabel("VideoPlayer.AudioLanguage"), xbmc.ENGLISH_NAME)) \
            .replace('default',
                     xbmc.convertLanguage(xbmc.getInfoLabel("System.Language"), xbmc.ENGLISH_NAME)).split(',')

    log(parse_argv.__name__, f"Parsed arguments: {param}")
    return param
def search():
    log( __name__, "action 'search' called")
    item = {}
    item['temp']               = False
    item['rar']                = False
    item['year']               = xbmc.getInfoLabel("VideoPlayer.Year")                           # Year
    item['season']             = str(xbmc.getInfoLabel("VideoPlayer.Season"))                    # Season
    item['episode']            = str(xbmc.getInfoLabel("VideoPlayer.Episode"))                   # Episode
    item['tvshow']             = normalizeString(xbmc.getInfoLabel("VideoPlayer.TVshowtitle"))   # Show
    item['title']              = normalizeString(xbmc.getInfoLabel("VideoPlayer.OriginalTitle")) # try to get original title
    item['file_original_path'] = urllib.unquote(xbmc.Player().getPlayingFile().decode('utf-8'))  # Full path of a playing file
    item['3let_language']      = []                                                              # ['scc','eng']
    for lang in urllib.unquote(params['languages']).decode('utf-8').split(","):
        item['3let_language'].append(xbmc.convertLanguage(lang,xbmc.ISO_639_2))
    if item['title'] == "":
        log( __name__, "VideoPlayer.OriginalTitle not found")
        item['title']  = normalizeString(xbmc.getInfoLabel("VideoPlayer.Title"))      # no original title, get just Title
    if item['episode'].lower().find("s") > -1:                                        # Check if season is "Special"
        item['season'] = "0"
        item['episode'] = item['episode'][-1:]
    if ( item['file_original_path'].find("http") > -1 ):
        item['temp'] = True
    elif ( item['file_original_path'].find("rar://") > -1 ):
        item['rar']  = True
        item['file_original_path'] = os.path.dirname(item['file_original_path'][6:])
    log( __name__, item)
    search_subtitles( item['file_original_path'], item['title'], item['tvshow'], item['year'], item['season'], item['episode'], item['3let_language'])
Ejemplo n.º 13
0
def parse_profiles(data):
    """Parse profile information from Netflix response"""
    profiles_list = jgraph_get_list('profilesList', data)
    try:
        if not profiles_list:
            raise InvalidProfilesError('It has not been possible to obtain the list of profiles.')
        sort_order = 0
        current_guids = []
        for index, profile_data in iteritems(profiles_list):  # pylint: disable=unused-variable
            summary = jgraph_get('summary', profile_data)
            guid = summary['guid']
            current_guids.append(guid)
            LOG.debug('Parsing profile {}', summary['guid'])
            avatar_url = _get_avatar(profile_data, data, guid)
            is_active = summary.pop('isActive')
            G.LOCAL_DB.set_profile(guid, is_active, sort_order)
            G.SHARED_DB.set_profile(guid, sort_order)
            # Add profile language description translated from locale
            summary['language_desc'] = G.py2_decode(xbmc.convertLanguage(summary['language'][:2], xbmc.ENGLISH_NAME))
            if LOG.level == LOG.LEVEL_VERBOSE:
                for key, value in iteritems(summary):
                    if key in PROFILE_DEBUG_INFO:
                        LOG.debug('Profile info {}', {key: value})
            # Translate the profile name, is coded as HTML
            summary['profileName'] = parse_html(summary['profileName'])
            summary['avatar'] = avatar_url
            G.LOCAL_DB.insert_profile_configs(summary, guid)
            sort_order += 1
        _delete_non_existing_profiles(current_guids)
    except Exception as exc:  # pylint: disable=broad-except
        import traceback
        LOG.error(G.py2_decode(traceback.format_exc(), 'latin-1'))
        LOG.error('Profile list data: {}', profiles_list)
        raise_from(InvalidProfilesError, exc)
    def search(self, item, t, langs):

        fulllang = xbmc.convertLanguage(item['preferredlanguage'], xbmc.ENGLISH_NAME)
        if fulllang == "Persian": fulllang = "Farsi/Persian"
        #xbmc.executebuiltin("Notification(Title," + item['mansearchstr'] + ")")
        QueryString = self.filename;

        if item['mansearch']:
            QueryString = item['mansearchstr'];

        addon = xbmcaddon.Addon();

        if len(QueryString) < 6:
            xbmc.executebuiltin("Notification(" + addon.getLocalizedString(32003) + "," + addon.getLocalizedString(32002) + ")")
            return

        url = "http://www.subtitool.com/api/?query=" + QueryString + "&Lang=" + langs
        subs = urllib.urlopen(url).read()
        DOMTree = minidom.parseString(subs)
        if DOMTree.getElementsByTagName('Subtitle').length == 0:
           try:
            url = "http://www.subtitool.com/api/?query=" + QueryString + "&Lang=" + langs + "&OR=1"
            subs = urllib.urlopen(url).read()
            DOMTree = minidom.parseString(subs)
           except Exception, e:
                log("Subtitool","Not Found OR")

           try:
            url = "http://www.subtitool.com/api/?query=" + QueryString + "&Lang=" + langs
            subs = urllib.urlopen(url).read()
            DOMTree = minidom.parseString(subs)
           except Exception, e:
                log("Subtitool","Not Found")
 def _add_subtitle(self, action, path, label, language):
     list_item = xbmcgui.ListItem(label=xbmc.convertLanguage(
         language, xbmc.ENGLISH_NAME),
                                  label2=label)
     list_item.setArt({
         "icon":
         "0",
         "thumb":
         xbmc.convertLanguage(language, xbmc.ISO_639_1)
     })
     # list_item.setProperty("sync", "false")
     # list_item.setProperty("hearing_imp", "false")
     url = "plugin://{}/?{}".format(
         self._id,
         urlencode(dict(action=action, path=path, language=language)))
     xbmcplugin.addDirectoryItem(self._handle, url, list_item)
    def on_subtitle_found(self, subtitle):
        """Event handler called when a matching subtitle has been found.

        :param subtitle: Subtitle details
        :type subtitle: dict of [str, unicode]
        """

        self.info(u'Found {0} subtitle {1}:{2}'.format(subtitle['language'],
                                                       subtitle['url'],
                                                       subtitle['filename']))

        list_item = xbmcgui.ListItem(
            label=subtitle['language'],
            label2=os.path.basename(subtitle['filename']),
            iconImage=subtitle['rating'],
            thumbnailImage=xbmc.convertLanguage(subtitle['language'],
                                                xbmc.ISO_639_1),
        )

        list_item.setProperty('sync', 'false')
        list_item.setProperty('hearing_imp', 'false')

        url = u'plugin://{0}/?action=download&url={1}&filename={2}'.format(
            __scriptid__, subtitle['url'], subtitle['filename'])

        xbmcplugin.addDirectoryItem(handle=self._handle,
                                    url=url,
                                    listitem=list_item,
                                    isFolder=False)
Ejemplo n.º 17
0
def append_subtitle(subname,
                    lang_name,
                    language,
                    params,
                    sync=False,
                    h_impaired=False):
    listitem = xbmcgui.ListItem(
        # Languange name to display under the lang logo (for example english)
        label=lang_name,
        # Subtitle name (for example 'Lost 1x01 720p')
        label2=subname,
        # Languange 2 letter name (for example en)
        thumbnailImage=xbmc.convertLanguage(language, xbmc.ISO_639_1))

    # Subtitles synced with the video
    listitem.setProperty("sync", 'true' if sync else 'false')
    # Hearing impaired subs
    listitem.setProperty("hearing_imp", 'true' if h_impaired else 'false')

    # Create the url to the plugin that will handle the subtitle download
    url = "plugin://{url}/?{params}".format(url=SCRIPT_ID,
                                            params=urllib.urlencode(params))
    # Add the subtitle to the list
    xbmcplugin.addDirectoryItem(handle=HANDLE,
                                url=url,
                                listitem=listitem,
                                isFolder=False)
Ejemplo n.º 18
0
def search_by_language(string, language):
  results     = []
  html_parser = HTMLParser.HTMLParser()

  if language in SUBTITLE_LANGUAGES:
    log('Searching for %s subtitles: %s' % (language, string))

    # Language specific stuff
    search_url    = SUBTITLE_LANGUAGES[language]['search_url']
    regex_pattern = SUBTITLE_LANGUAGES[language]['regex_pattern']
    priority      = SUBTITLE_LANGUAGES[language]['priority']

    # Get content
    content = get_content_from_url(search_url % urllib.quote(string.encode('latin')))

    # Parse results
    pattern = re.compile(regex_pattern)
    matches = pattern.finditer(content)

    # Loop through all matches
    for match in matches:
      results.append({
        'name'          : html_parser.unescape(match.group(2)).decode('latin'),
        'language'      : language,
        'language_code' : xbmc.convertLanguage(language, xbmc.ISO_639_1),
        'download_url'  : match.group(1),
        'priority'      : priority
      })
  else:
    log('Unsupported language: %s' % language)

  return results
Ejemplo n.º 19
0
    def onPlayBackStarted(self):
        check_for_specific = (__addon__.getSetting('check_for_specific').lower() == 'true')
        specific_language = (__addon__.getSetting('selected_language'))
        specific_language = xbmc.convertLanguage(specific_language, xbmc.ISO_639_2)

        if self.run:
            movieFullPath = xbmc.Player().getPlayingFile()
            Debug("movieFullPath '%s'" % movieFullPath)
            xbmc.sleep(1000)
            availableLangs = xbmc.Player().getAvailableSubtitleStreams()
            Debug("availableLangs '%s'" % availableLangs)
            totalTime = xbmc.Player().getTotalTime()
            Debug("totalTime '%s'" % totalTime)
            videoclipAlbum = ''			
            if getSettingAsBool('ExcludeVideoClip'):
                videoclipAlbum = xbmc.InfoTagMusic.getAlbum()
                Debug("videoclipAlbum '%s'" % videoclipAlbum)
			
            if (xbmc.Player().isPlayingVideo() and totalTime > ExcludeTime and (not videoclipAlbum) and ((not xbmc.getCondVisibility("VideoPlayer.HasSubtitles")) or (check_for_specific and not specific_language in availableLangs)) and all(movieFullPath.find (v) <= -1 for v in ignore_words) and (isExcluded(movieFullPath)) ):
                self.run = False
                xbmc.sleep(1000)
                Debug('Started: AutoSearching for Subs')
                xbmc.executebuiltin('XBMC.ActivateWindow(SubtitleSearch)')
            else:
                Debug('Started: Subs found or Excluded')
                self.run = False
Ejemplo n.º 20
0
    def onPlayBackStarted(self):
        check_for_specific = (
            __addon__.getSetting('check_for_specific').lower() == 'true')
        specific_language = (__addon__.getSetting('selected_language'))
        specific_language = xbmc.convertLanguage(specific_language,
                                                 xbmc.ISO_639_2)

        if self.run:
            movieFullPath = xbmc.Player().getPlayingFile()
            Debug("movieFullPath '%s'" % movieFullPath)
            xbmc.sleep(1000)
            availableLangs = xbmc.Player().getAvailableSubtitleStreams()
            Debug("availableLangs '%s'" % availableLangs)
            totalTime = xbmc.Player().getTotalTime()
            Debug("totalTime '%s'" % totalTime)

            if (xbmc.Player().isPlayingVideo() and totalTime > ExcludeTime and
                ((not xbmc.getCondVisibility("VideoPlayer.HasSubtitles")) or
                 (check_for_specific
                  and not specific_language in availableLangs))
                    and all(movieFullPath.find(v) <= -1 for v in ignore_words)
                    and (isExcluded(movieFullPath))):
                self.run = False
                xbmc.sleep(1000)
                Debug('Started: Procura automatica de legendas')
                xbmc.executebuiltin('XBMC.ActivateWindow(SubtitleSearch)')
            else:
                Debug('Started: Legendas nao encontradas ou excluidas')
                self.run = False
Ejemplo n.º 21
0
def collect_initial_data():
    item_data = {
        'temp': False,
        'rar': False,
        '3let_language': [],
        'preferredlanguage': unquote(params.get('preferredlanguage', ''))
    }

    item_data['preferredlanguage'] = xbmc.convertLanguage(item_data['preferredlanguage'], xbmc.ISO_639_2)

    if xbmc.Player().isPlaying():
        item_data['year'] = xbmc.getInfoLabel("VideoPlayer.Year")  # Year
        item_data['season'] = str(xbmc.getInfoLabel("VideoPlayer.Season"))  # Season
        item_data['episode'] = str(xbmc.getInfoLabel("VideoPlayer.Episode"))  # Episode
        item_data['tvshow'] = normalizeString(xbmc.getInfoLabel("VideoPlayer.TVshowtitle"))  # Show
        item_data['title'] = normalizeString(
            xbmc.getInfoLabel("VideoPlayer.OriginalTitle"))  # try to get original title
        item_data['file_original_path'] = unquote(xbmc.Player().getPlayingFile())  # Full path of a playing file

        if item_data['title'] == "":
            log("VideoPlayer.OriginalTitle not found")
            item_data['title'] = normalizeString(
                xbmc.getInfoLabel("VideoPlayer.Title"))  # no original title, get just Title

    else:
        item_data['year'] = xbmc.getInfoLabel("ListItem.Year")
        item_data['season'] = xbmc.getInfoLabel("ListItem.Season")
        item_data['episode'] = xbmc.getInfoLabel("ListItem.Episode")
        item_data['tvshow'] = xbmc.getInfoLabel("ListItem.TVShowTitle")
        item_data['title'] = title_from_focused_item(item_data)
        item_data['file_original_path'] = ""

    return item_data
Ejemplo n.º 22
0
def _get_default_audio_language(manifest):
    channelList = {'1.0': '1', '2.0': '2'}
    channelListDolby = {'5.1': '6', '7.1': '8'}

    # Read language in kodi settings
    audio_language = common.json_rpc('Settings.GetSettingValue', {'setting': 'locale.audiolanguage'})
    audio_language = xbmc.convertLanguage(audio_language['value'], xbmc.ISO_639_1)
    audio_language = audio_language if audio_language else xbmc.getLanguage(xbmc.ISO_639_1, False)
    audio_language = audio_language if audio_language else 'en'

    # Try to find the preferred language with the right channels
    if g.ADDON.getSettingBool('enable_dolby_sound'):
        for index, audio_track in enumerate(manifest['audio_tracks']):
            if audio_track['language'] == audio_language and audio_track['channels'] in channelListDolby:
                return index
                break
    # If dolby audio track not exists check other channels list
    for index, audio_track in enumerate(manifest['audio_tracks']):
        if audio_track['language'] == audio_language and audio_track['channels'] in channelList:
            return index
            break

    # If there is no matches to preferred language, try to sets the original language track as default
        # Check if the dolby audio track in selected language exists
    if g.ADDON.getSettingBool('enable_dolby_sound'):
        for index, audio_track in enumerate(manifest['audio_tracks']):
            if audio_track['isNative'] and audio_track['channels'] in channelListDolby:
                return index
                break
    # If dolby audio track not exists check other channels list
    for index, audio_track in enumerate(manifest['audio_tracks']):
        if audio_track['isNative'] and audio_track['channels'] in channelList:
            return index
            break
    return 0
Ejemplo n.º 23
0
def parse_profiles(data):
    """Parse profile information from Netflix response"""
    profiles_list = jgraph_get_list('profilesList', data)
    try:
        if not profiles_list:
            raise InvalidProfilesError('It has not been possible to obtain the list of profiles.')
        sort_order = 0
        current_guids = []
        for index, profile_data in iteritems(profiles_list):  # pylint: disable=unused-variable
            summary = jgraph_get('summary', profile_data)
            guid = summary['guid']
            current_guids.append(guid)
            common.debug('Parsing profile {}', summary['guid'])
            avatar_url = _get_avatar(profile_data, data, guid)
            is_active = summary.pop('isActive')
            g.LOCAL_DB.set_profile(guid, is_active, sort_order)
            g.SHARED_DB.set_profile(guid, sort_order)
            # Add profile language description translated from locale
            summary['language_desc'] = g.py2_decode(xbmc.convertLanguage(summary['language'][:2], xbmc.ENGLISH_NAME))
            for key, value in iteritems(summary):
                if key in PROFILE_DEBUG_INFO:
                    common.debug('Profile info {}', {key: value})
                if key == 'profileName':  # The profile name is coded as HTML
                    value = parse_html(value)
                g.LOCAL_DB.set_profile_config(key, value, guid)
            g.LOCAL_DB.set_profile_config('avatar', avatar_url, guid)
            sort_order += 1
        _delete_non_existing_profiles(current_guids)
    except Exception:
        import traceback
        common.error(g.py2_decode(traceback.format_exc(), 'latin-1'))
        common.error('Profile list data: {}', profiles_list)
        raise InvalidProfilesError
Ejemplo n.º 24
0
def search(info, languages):
    """Add subtitles to the list using information gathered with get_info and get_languages"""
    logging.debug("---TUCAN---")
    logging.debug(info)
    url = addictedutils.build_show_url(
        addictedutils.get_show_id(info['tvshow']),
        info['season'],
        addictedutils.build_language_code_string(languages))
    logging.debug(url)
    subs = addictedutils.subs_array(url, info)
    #logging.debug(subs)
    for sub in subs:
        sub_name = sub['showTitle'] + " " + sub['season'] + "x" + sub['episode'] + " " + sub['version']
        sub_params = {
            "action": "download-addicted",
            "link": sub['link'],
            "name": sub_name
        }
        append_subtitle(
            sub_name,
            sub['lang'],
            xbmc.convertLanguage(sub['lang'], xbmc.ISO_639_2),
            sub_params,
            sub['sync'],
            sub['himp'])
Ejemplo n.º 25
0
    def _action_search(self):
        self.search()
        sorter = sublib.sub.sorter(self.item.languages[0])
        self._subs.sort(key=sorter.method, reverse=True)
        for sub in self._subs:
            if sub.iso not in self.item.languages and len(sub.iso) == 2:
                continue
            listitem = xbmcgui.ListItem(
                        label=xbmc.convertLanguage(sub.iso, xbmc.ENGLISH_NAME),
                        label2=sub.label,
                        iconImage=str(sub.rating),
                        thumbnailImage=sub.iso
                        )
            listitem.setProperty("sync", '{0}'.format(sub.sync).lower())
            listitem.setProperty("hearing_imp", '{0}'.format(sub.cc).lower())
            args = {
                    "action": "download",
                    "args": sub.args,
                    "kwargs": sub.kwargs,
                    "languages": self._params['languages'],
                    "prefferedlanguage": self._params['preferredlanguage']
                    }
            url = urllib.urlencode(sublib.utils.dformat(args, json.dumps))
            url = "plugin://%s/?%s" % (self._sid, url)

            xbmcplugin.addDirectoryItem(
                                        handle=int(sys.argv[1]),
                                        url=url,
                                        listitem=listitem,
                                        isFolder=False
                                        )
    def search(self, item):

        if item['mansearch']:
            title = item['mansearchstr']
        elif item['tvshow']:
            title = "%s S%02dE%02d" % (self.normalize_input_title(
                item['tvshow']), int(item['season']), int(item['episode'])
                                       )  # Searching TV Show
        else:  # Searching movie
            title = item['title'] if item['year'] else xbmc.getCleanMovieTitle(
                item['title'])[0]
            title = self.normalize_input_title(title)

        log(__name__, "Search pattern: " + title)

        found_subtitles = self.search_subtitle(title)
        log(__name__, "Parsed subtitles: %s" % found_subtitles)

        lang_filetred_found_subtitles = self.filter_subtitles_by_language(
            item['3let_language'], found_subtitles)
        log(__name__, ["Language filter", lang_filetred_found_subtitles])
        if not lang_filetred_found_subtitles:
            return results_with_stats(None, self.addon, title, item)

        file_size = get_file_size(item['file_original_path'], item['rar'])
        if not (file_size == -1):
            file_size = round(float(file_size) / (1024 * 1024), 2)
        log(__name__, "File size: %s" % file_size)

        max_down_count = self.detect_max_download_stats(
            lang_filetred_found_subtitles)

        result_subtitles = []
        for found_subtitle in lang_filetred_found_subtitles:
            print_out_filename = (
                found_subtitle['version'],
                found_subtitle['title'])[found_subtitle['version'] == ''
                                         or found_subtitle['version'] == None]
            if not found_subtitle['author'] == None:
                print_out_filename += " by " + found_subtitle['author']
            result_subtitles.append({
                'filename':
                HTMLParser.HTMLParser().unescape(print_out_filename),
                'id':
                found_subtitle['id'],
                'lang':
                found_subtitle['lang'],
                'rating':
                str(found_subtitle['down_count'] * 5 /
                    max_down_count) if max_down_count > 0 else "0",
                'sync': (found_subtitle['size'] == file_size
                         and file_size > 0),
                'lang_flag':
                xbmc.convertLanguage(found_subtitle['lang'], xbmc.ISO_639_1),
            })

        log(__name__, ["Search result", result_subtitles])

        return results_with_stats(result_subtitles, self.addon, title, item)
Ejemplo n.º 27
0
def get_language(abbrev):    
    try:
        lang_string = (key for key,value in LANGUAGES.items() if value == abbrev).next()
    except:
        lang_string = xbmc.convertLanguage(abbrev, xbmc.ENGLISH_NAME)
    if not lang_string:
        lang_string = 'n/a'
    return lang_string
    def _build_subtitle_list(self, search_results, item):
        language = 'he'
        lang3 = xbmc.convertLanguage(language, xbmc.ISO_639_2)
        total_downloads = 0
        ret = []
        for result in search_results:
            title = result["rls"]
            subtitle_rate = self._calc_rating(title,
                                              item["file_original_path"])
            total_downloads += result['downloads']

            ret.append({
                'lang_index':
                item["3let_language"].index(lang3),
                'filename':
                title,
                'language_name':
                xbmc.convertLanguage(language, xbmc.ENGLISH_NAME),
                'language_flag':
                language,
                'id':
                result["id"],
                'sub_id':
                result["sub_id"],
                'rating':
                result['downloads'],
                'sync':
                subtitle_rate >= 3.8,
                'hearing_imp':
                False,
                'is_preferred':
                lang3 == item['preferredlanguage']
            })

        # Fix the rating
        if total_downloads:
            for it in ret:
                log('rating %s totals %s' % (it['rating'], total_downloads))
                it["rating"] = str(
                    int(round(it["rating"] / float(total_downloads), 1) * 5))

        return sorted(
            ret,
            key=lambda x:
            (x['is_preferred'], x['lang_index'], x['sync'], x['rating']),
            reverse=True)
Ejemplo n.º 29
0
def get_kodi_audio_language():
    """
    Return the audio language from Kodi settings
    """
    audio_language = json_rpc('Settings.GetSettingValue', {'setting': 'locale.audiolanguage'})
    audio_language = xbmc.convertLanguage(audio_language['value'].encode('utf-8'), xbmc.ISO_639_1)
    audio_language = audio_language if audio_language else xbmc.getLanguage(xbmc.ISO_639_1, False)
    return audio_language if audio_language else 'en'
	def search(self,item):

		if item['mansearch']:
			title = item['mansearchstr']
			dialog = xbmcgui.Dialog()
			item['season'] = dialog.numeric(0, self._t(32111), item['season'])
			item['episode'] = dialog.numeric(0, self._t(32112), item['episode'])
		else:
			title = self.normalize_input_title(item['tvshow'])
			if self.addon.getSetting("ignore_articles") == "true" and re.match(r'^The ',title,re.IGNORECASE):
				log(__name__, "Ignoring The in Title")
				title = re.sub(r'(?i)^The ',"", title)

		if not title or not item['season'] or not item['episode']:
			xbmc.executebuiltin("XBMC.Notification(%s,%s,5000,%s)" % (
						self.addon.getAddonInfo('name'), self._t(32110),
						os.path.join(xbmc.translatePath(self.addon.getAddonInfo('path')).decode("utf-8"),'icon.png')
			))
			log(__name__, ["Input validation error", title, item['season'], item['episode']])
			return results_with_stats(None, self.addon, title, item)

		tvshow_url = self.search_show_url(title)
		if tvshow_url == None: return results_with_stats(None, self.addon, title, item)

		file_size = get_file_size(item['file_original_path'], item['rar'])
		log(__name__, "File size: %s" % file_size)

		found_season_subtitles = self.search_season_subtitles(tvshow_url,item['season'])
		log(__name__, ["Season filter", found_season_subtitles])

		episode_subtitle_list = self.filter_episode_from_season_subtitles(found_season_subtitles,item['season'],item['episode'])
		log(__name__, ["Episode filter", episode_subtitle_list])
		if episode_subtitle_list == None: return results_with_stats(None, self.addon, title, item)

		lang_filetred_episode_subtitle_list = self.filter_subtitles_by_language(item['3let_language'], episode_subtitle_list)
		log(__name__, ["Language filter", lang_filetred_episode_subtitle_list])
		if lang_filetred_episode_subtitle_list == None: return results_with_stats(None, self.addon, title, item)

		max_down_count = self.detect_max_download_stats(lang_filetred_episode_subtitle_list)

		result_subtitles = []
		for episode_subtitle in lang_filetred_episode_subtitle_list['versions']:

			print_out_filename = episode_subtitle['rip'] + " by " + episode_subtitle['author']
			if episode_subtitle['notes']: print_out_filename += " (" + episode_subtitle['notes'] + ")"

			result_subtitles.append({
				'filename': HTMLParser.HTMLParser().unescape(print_out_filename),
				'link': episode_subtitle['link'],
				'lang': episode_subtitle['lang'],
				'rating': str(episode_subtitle['down_count']*5/max_down_count) if max_down_count > 0 else "0",
				'sync': (episode_subtitle['file_size'] == file_size and file_size > 0),
				'lang_flag': xbmc.convertLanguage(episode_subtitle['lang'],xbmc.ISO_639_1),
			})

		log(__name__,["Search result", result_subtitles])

		return results_with_stats(result_subtitles, self.addon, title, item)
Ejemplo n.º 31
0
def get_language(abbrev):
    try:
        lang_string = (key for key, value in LANGUAGES.items()
                       if value == abbrev).next()
    except:
        lang_string = xbmc.convertLanguage(abbrev, xbmc.ENGLISH_NAME)
    if not lang_string:
        lang_string = 'n/a'
    return lang_string
Ejemplo n.º 32
0
def display_movie(title, movieurl):
    divpname = re.search(r"/title/(.*.)", movieurl).group(1)
    log('MOVIE ID: %s' % divpname)
    (req, page) = load_url(movieurl)
    subtitles_list = []

    tb = page.find(id='subtable')
    links = tb.findAll('a', class_='download-btn')
    for link in links:
        addr = link['href']
        s_tr = link.find_parent('tr')
        tr_id = re.sub('row_id', '', s_tr['id'])
        s_tr2 = page.find('tr', id="row_id_alt%s" % tr_id)
        s_tr3 = page.find('tr', id="row_id_note%s" % tr_id)
        lantext = s_tr.find('img')['src']
        if lantext:
            if "en.png" in lantext:
                language = "English"
                lan_short = "en"
            elif "tr.png" in lantext:
                language = "Turkish"
                lan_short = "tr"
            else:
                raise ValueError("unsupported language: %s" % lantext)
            filename = u"%s.%s" % (title, lan_short)
            dtd = s_tr3.find('td').text
            description = dtd[dtd.index(' :') + 2:dtd.index(' - ')]
            log('description and filename:'),
            log(description)
            log(filename)
            l_item = xbmcgui.ListItem(
                label=language,  # language name for the found subtitle
                label2=description,  # file name for the found subtitle
                iconImage="0",  # rating for the subtitle, string 0-5
                thumbnailImage=xbmc.convertLanguage(language, xbmc.ISO_639_1)
            )

            # set to "true" if subtitle is for hearing impared
            l_item.setProperty("hearing_imp", '{0}'.format("false").lower())

            subtitles_list.append(l_item)

            url = "plugin://%s/?action=download&link=%s&lang=%s&description=%s&season=%s" % (
                __scriptid__,
                addr,
                lan_short,
                normalize_filename(filename),
                ""
            )

            xbmcplugin.addDirectoryItem(
                handle=int(sys.argv[1]),
                url=url,
                listitem=l_item,
                isFolder=False
            )
    log("PlanetDP: found %d subtitles from %s" % (len(subtitles_list), len(links)))
    def _build_subtitle_list(self, search_results, item):
        ret = []
        for result in search_results:
            subs_list = result["subs"]

            if subs_list is not None:
                for language in subs_list.keys():
                    if xbmc.convertLanguage(
                            language, xbmc.ISO_639_2) in item["3let_language"]:
                        for current in subs_list[language]:
                            title = current["SubtitleName"]
                            subtitle_rate = self._calc_rating(
                                title, item["file_original_path"])

                            ret.append({
                                'lang_index':
                                item["3let_language"].index(
                                    xbmc.convertLanguage(
                                        language, xbmc.ISO_639_2)),
                                'filename':
                                title,
                                'language_name':
                                xbmc.convertLanguage(language,
                                                     xbmc.ENGLISH_NAME),
                                'language_flag':
                                language,
                                'id':
                                current["Identifier"],
                                'rating':
                                '5',
                                'sync':
                                subtitle_rate >= 3.8,
                                'hearing_imp':
                                False,
                                'is_preferred':
                                xbmc.convertLanguage(language, xbmc.ISO_639_2)
                                == item['preferredlanguage']
                            })

        return sorted(
            ret,
            key=lambda x:
            (x['is_preferred'], x['lang_index'], x['sync'], x['rating']),
            reverse=True)
Ejemplo n.º 34
0
    def onInit(self):
        self.getControl(1).setLabel(
            "Artwork Beef: " +
            L(CHOOSE_ART_HEADER).format(self.arttype, self.medialabel))
        self.getControl(3).setVisible(False)
        self.getControl(5).setVisible(self.multi)
        self.getControl(5).setLabel('$LOCALIZE[186]')
        self.guilist = self.getControl(6)

        for image in self.artlist:
            provider = image['provider'].display
            if isinstance(provider, int):
                provider = L(provider)
            secondprovider = image.get('second provider')
            if secondprovider:
                if isinstance(secondprovider, int):
                    secondprovider = L(secondprovider)
                provider = '{0}, {1}'.format(provider, secondprovider)
            title = image.get('title')
            if not title and 'subtype' in image:
                title = image['subtype'].display
            language = xbmc.convertLanguage(
                image['language'],
                xbmc.ENGLISH_NAME) if image.get('language') else None
            if not title:
                title = language
            if title and len(title) < 20 and not secondprovider:
                label = '{0} from {1}'.format(title, provider)
                summary = language if language and language != title else ''
            else:
                label = provider
                if language and language != title:
                    title = language + ' ' + title
                summary = title if title else ''
            rating = image.get('rating')
            size = image.get('size')
            if (rating or size) and summary:
                summary += '\n'
            if size:
                summary += image['size'].display
            if rating and size:
                summary += '   '
            if rating:
                summary += image['rating'].display
            listitem = xbmcgui.ListItem(label)
            listitem.setLabel2(summary)
            # DEPRECATED: Above Krypton and higher (only), below Jarvis and lower (only)
            listitem.setProperty('Addon.Summary', summary)
            listitem.setIconImage(image['preview'])
            # DEPRECATED: Above is deprecated in Jarvis, but still works through Krypton (at least)
            # listitem.setArt({'icon': image['preview']})
            listitem.setPath(image['url'])
            if image.get('existing'):
                listitem.select(True)
            self.guilist.addItem(listitem)
        self.setFocus(self.guilist)
Ejemplo n.º 35
0
def get_languages_dict(languages_param):
    langs = {}
    for lang in languages_param.split(','):
        if lang == "Portuguese (Brazil)":
            langs["pob"] = lang
        elif lang == "Greek":
            langs["ell"] = lang
        else:
            langs[xbmc.convertLanguage(lang, xbmc.ISO_639_2)] = lang
    return langs
Ejemplo n.º 36
0
def get_languages_dict(languages_param):
    langs = {}
    for lang in languages_param.split(','):
        if lang == "Portuguese (Brazil)":
            langs["pob"] = lang
        elif lang == "Greek":
            langs["ell"] = lang
        else:
            langs[xbmc.convertLanguage(lang, xbmc.ISO_639_2)] = lang
    return langs
Ejemplo n.º 37
0
def get_language(language_format=xbmc.ENGLISH_NAME, region=False):
    language = xbmc.getLanguage(language_format, region)
    if not language or region and language.startswith('-'):
        engname = xbmc.getLanguage(xbmc.ENGLISH_NAME)
        regiontag = language
        if ' (' in engname:
            language = engname[:engname.rfind(' (')]
        if language_format != xbmc.ENGLISH_NAME:
            language = xbmc.convertLanguage(language, language_format) + regiontag
    return language
Ejemplo n.º 38
0
def get_abbrev(lang_string):
    try:
        language_abbrev = xbmc.convertLanguage(lang_string, xbmc.ISO_639_1)
    except:
        language_abbrev = REAL_SETTINGS.getSetting('limit_preferred_language')
    if language_abbrev in LANGUAGES:
        return LANGUAGES[language_abbrev]
    else:
        language_abbrev = 'en' ### Default to English if conversion fails
    return language_abbrev
    def _build_subtitle_list(self, search_results, item):
        ret = []
        for result in search_results:
            total_downloads = 0
            counter = 0
            url = self.BASE_URL + "cinemast/data/" + result["type"] + "/sb/" + result["slug"]
            url += "/" + item["season"] + "/" + item["episode"] + "/" if result["type"] == "series" else "/"
            subs_list = self.urlHandler.request(url)

            if subs_list is not None:
                if not isinstance(subs_list, dict):
                    subs_list = json.loads(subs_list, encoding="utf-8")
                for language in subs_list:
                    if xbmc.convertLanguage(language, xbmc.ISO_639_2) in item["3let_language"]:
                        for translator in subs_list[language]:
                            for quality in subs_list[language][translator]:
                                for current in subs_list[language][translator][quality]:
                                    current = subs_list[language][translator][quality][current]
                                    counter += 1
                                    title = current["subtitle_version"]
                                    subtitle_rate = self._calc_rating(title, item["file_original_path"])
                                    total_downloads += current["downloaded"]
                                    ret.append(
                                        {'lang_index': item["3let_language"].index(
                                            xbmc.convertLanguage(language, xbmc.ISO_639_2)),
                                            'filename': title,
                                            'link': current["key"],
                                            'language_name': xbmc.convertLanguage(language, xbmc.ENGLISH_NAME),
                                            'language_flag': language,
                                            'id': current["id"],
                                            'rating': current["downloaded"],
                                            'sync': subtitle_rate >= 3.8,
                                            'hearing_imp': current["hearing_impaired"] > 0,
                                            'is_preferred':
                                                xbmc.convertLanguage(language, xbmc.ISO_639_2) == item[
                                                    'preferredlanguage']
                                        })
            # Fix the rating
            if total_downloads:
                for it in ret[-1 * counter:]:
                    it["rating"] = str(min(int(round(float(it["rating"]) / float(total_downloads), 1) * 8), 5))

        return sorted(ret, key=lambda x: (x['is_preferred'], x['lang_index'], x['sync'], x['rating']), reverse=True)
Ejemplo n.º 40
0
def convert_language_iso_639_2(name):
    """
    Returns the given language converted to the ISO 639-2 format as a string.
    """
    try:
        language = iso_639_2_languages[name]
    except KeyError:
        language = xbmc.convertLanguage(name, xbmc.ISO_639_2)

    return language
Ejemplo n.º 41
0
def get_abbrev(lang_string):
    try:
        language_abbrev = xbmc.convertLanguage(lang_string, xbmc.ISO_639_1)
    except:
        language_abbrev = REAL_SETTINGS.getSetting('limit_preferred_language')
    if language_abbrev in LANGUAGES:
        return LANGUAGES[language_abbrev]
    else:
        language_abbrev = 'en'  ### Default to English if conversion fails
    return language_abbrev
Ejemplo n.º 42
0
def get(name, imdb, season, episode):
    try:
        langs = []
        try: langs.append(langDict[control.setting('sublang1')])
        except: pass
        try: langs.append(langDict[control.setting('sublang2')])
        except: pass

        try: subLang = xbmc.Player().getSubtitles()
        except: subLang = ''
        if subLang == langs[0]: raise Exception()

        server = xmlrpclib.Server('http://api.opensubtitles.org/xml-rpc', verbose=0)
        token = server.LogIn('', '', 'en', 'XBMC_Subtitles_v1')['token']

        sublanguageid = ','.join(langs) ; imdbid = re.sub('[^0-9]', '', imdb)

        if not (season == '' or episode == ''):
            result = server.SearchSubtitles(token, [{'sublanguageid': sublanguageid, 'imdbid': imdbid, 'season': season, 'episode': episode}])['data']
            fmt = ['hdtv']
        else:
            result = server.SearchSubtitles(token, [{'sublanguageid': sublanguageid, 'imdbid': imdbid}])['data']
            try: vidPath = xbmc.Player().getPlayingFile()
            except: vidPath = ''
            fmt = re.split('\.|\(|\)|\[|\]|\s|\-', vidPath)
            fmt = [i.lower() for i in fmt]
            fmt = [i for i in fmt if i in quality]

        filter = []
        result = [i for i in result if i['SubSumCD'] == '1']

        for lang in langs:
            filter += [i for i in result if i['SubLanguageID'] == lang and any(x in i['MovieReleaseName'].lower() for x in fmt)]
            filter += [i for i in result if i['SubLanguageID'] == lang and any(x in i['MovieReleaseName'].lower() for x in quality)]
            filter += [i for i in result if i['SubLanguageID'] == lang]

        try: lang = xbmc.convertLanguage(filter[0]['SubLanguageID'], xbmc.ISO_639_1)
        except: lang = filter[0]['SubLanguageID']

        content = [filter[0]['IDSubtitleFile'],]
        content = server.DownloadSubtitles(token, content)
        content = base64.b64decode(content['data'][0]['data'])
        content = zlib.decompressobj(16+zlib.MAX_WBITS).decompress(content)

        subtitle = xbmc.translatePath('special://temp/')
        subtitle = os.path.join(subtitle, 'TemporarySubs.%s.srt' % lang)
        
        file = control.openFile(subtitle, 'w')
        file.write(str(content))
        file.close()

        xbmc.sleep(1000)
        xbmc.Player().setSubtitles(subtitle)
    except:
        pass
Ejemplo n.º 43
0
def check_active_player():
    global videofilename
    if xbmc.Player().isPlayingVideo():
        current_subs = xbmc.Player().getAvailableSubtitleStreams()
        playingfile = xbmc.Player().getPlayingFile()
        if any(current_subs):
            active_sub_lang = xbmc.Player().getSubtitles()
            lang = xbmc.convertLanguage(active_sub_lang, xbmc.ISO_639_1)

            if not lang:
                filename = os.path.splitext(playingfile)[0] + ".srt"
            else:
                filename = os.path.splitext(
                    playingfile)[0] + "." + lang + ".srt"
            if xbmcvfs.exists(filename):
                subtitlefile, filename = load_subtitle(False, filename)
                videofilename = playingfile
                if len(os.path.basename(playingfile)) < 50:
                    playbase = os.path.basename(playingfile)
                    subbase = os.path.basename(filename)
                else:
                    playbase = os.path.basename(
                        playingfile)[:35] + "(...)" + os.path.basename(
                            playingfile)[-10:]
                    subbase = os.path.basename(
                        filename)[:35] + "(...)" + os.path.basename(
                            filename)[-10:]
                result = xbmcgui.Dialog().yesno(
                    _(31001),
                    _(35003) + "\n" + _(35006).ljust(11) + playbase + "\n" +
                    _(35007).ljust(11) + subbase + "\n" + _(35004),
                    yeslabel=_(35000),
                    nolabel=_(35001))
                if not result:
                    xbmc.Player().stop()
                    show_dialog(subtitlefile, filename)
                else:
                    sys.exit()
        res = xbmcgui.Dialog().yesno(_(31001),
                                     _(35005) + "\n" + _(35004),
                                     nolabel=_(35000),
                                     yeslabel=_(35002))
        if not res:
            sys.exit()
        playing_dir = os.path.dirname(playingfile) + "/"
        filename = xbmcgui.Dialog().browse(1, _(32035), 'files', ".srt|.sub",
                                           False, False, playing_dir)
        if filename == playing_dir:
            sys.exit()
        videofilename = playingfile
        subtitlefile, filename = load_subtitle(False, filename)
        xbmc.Player().stop()
        show_dialog(subtitlefile, filename)
    show_dialog()
Ejemplo n.º 44
0
def get_kodi_subtitle_language():
    """
    Return the subtitle language from Kodi settings
    """
    subtitle_language = json_rpc('Settings.GetSettingValue', {'setting': 'locale.subtitlelanguage'})
    if subtitle_language['value'] == 'forced_only':
        return subtitle_language['value']
    subtitle_language = xbmc.convertLanguage(subtitle_language['value'].encode('utf-8'), xbmc.ISO_639_1)
    subtitle_language = subtitle_language if subtitle_language else xbmc.getLanguage(xbmc.ISO_639_1, False)
    subtitle_language = subtitle_language if subtitle_language else 'en'
    return subtitle_language
Ejemplo n.º 45
0
def convert_language_iso(from_value, use_fallback=True):
    """
    Convert language code from an English name or three letter code (ISO 639-2) to two letter code (ISO 639-1)

    :param use_fallback: if True when the conversion fails, is returned the current Kodi active language
    """
    converted_lang = xbmc.convertLanguage(g.py2_encode(from_value), xbmc.ISO_639_1)
    if not use_fallback:
        return converted_lang
    converted_lang = converted_lang if converted_lang else xbmc.getLanguage(xbmc.ISO_639_1, False)
    return converted_lang if converted_lang else 'en'
Ejemplo n.º 46
0
def create_subs_list(subs):
  for sub in subs:
    filename = "[" + str(sub["version"].encode('utf8')) + "]" + str(sub["showTitle"].encode('utf8')) + " - " + str(sub["episodeTitle"].encode('utf8')) + " " + "S" + str(sub["season"]) + "E" + str(format(int(sub["episode"]), "02d"))
    listitem = xbmcgui.ListItem(label = sub["lang"],
    							label2	= filename,
    							iconImage = "",
    							thumbnailImage = xbmc.convertLanguage(sub['lang'], xbmc.ISO_639_1))
    listitem.setProperty("hearing_imp", sub["hi"])
    url = u'plugin://' + __scriptid__ + u'/?action=download&link=' + sub["link"] + u'&filename=' + filename.decode('utf8')
    # url = u'plugin://%s/?action=download&link=%s&filename=%s' % (__scriptid__.encode('utf8'), sub["link"].encode('utf8'), str(filename.encode('utf8')))
    xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),url=url,listitem=listitem,isFolder=False)
Ejemplo n.º 47
0
def getsubtitles(name, tag, season, episode,lang1=None,lang2=None):
	quality = ['bluray', 'hdrip', 'brrip', 'bdrip', 'dvdrip', 'webrip', 'hdtv']
	langDict = {'Afrikaans': 'afr', 'Albanian': 'alb', 'Arabic': 'ara', 'Armenian': 'arm', 'Basque': 'baq', 'Bengali': 'ben', 'Bosnian': 'bos', 'Breton': 'bre', 'Bulgarian': 'bul', 'Burmese': 'bur', 'Catalan': 'cat', 'Chinese': 'chi', 'Croatian': 'hrv', 'Czech': 'cze', 'Danish': 'dan', 'Dutch': 'dut', 'English': 'eng', 'Esperanto': 'epo', 'Estonian': 'est', 'Finnish': 'fin', 'French': 'fre', 'Galician': 'glg', 'Georgian': 'geo', 'German': 'ger', 'Greek': 'ell', 'Hebrew': 'heb', 'Hindi': 'hin', 'Hungarian': 'hun', 'Icelandic': 'ice', 'Indonesian': 'ind', 'Italian': 'ita', 'Japanese': 'jpn', 'Kazakh': 'kaz', 'Khmer': 'khm', 'Korean': 'kor', 'Latvian': 'lav', 'Lithuanian': 'lit', 'Luxembourgish': 'ltz', 'Macedonian': 'mac', 'Malay': 'may', 'Malayalam': 'mal', 'Manipuri': 'mni', 'Mongolian': 'mon', 'Montenegrin': 'mne', 'Norwegian': 'nor', 'Occitan': 'oci', 'Persian': 'per', 'Polish': 'pol', 'Portuguese': 'por,pob', 'Portuguese(Brazil)': 'pob,por', 'Romanian': 'rum', 'Russian': 'rus', 'Serbian': 'scc', 'Sinhalese': 'sin', 'Slovak': 'slo', 'Slovenian': 'slv', 'Spanish': 'spa', 'Swahili': 'swa', 'Swedish': 'swe', 'Syriac': 'syr', 'Tagalog': 'tgl', 'Tamil': 'tam', 'Telugu': 'tel', 'Thai': 'tha', 'Turkish': 'tur', 'Ukrainian': 'ukr', 'Urdu': 'urd'}
	print '##name',name
	print '##tag',tag	
	langs = []
	try: langs.append(langDict[lang1])
	except: pass
	try: langs.append(langDict[lang2])
	except: pass
	langs = ','.join(langs)

	import xmlrpclib
	counterloop = 0
	result = []
	while not result and counterloop <=5 :
		try:
			server = xmlrpclib.Server('http://api.opensubtitles.org/xml-rpc', verbose=0)
			token = server.LogIn('', '', 'en', 'XBMC_Subtitles_v1')['token']
			if not (season == '' or episode == ''): result = server.SearchSubtitles(token, [{'query': name, 'sublanguageid': langs, 'season': season, 'episode': episode}])['data']
			else: result = server.SearchSubtitles(token, [{'query': name, 'sublanguageid': langs }])['data']
			result = [i for i in result if i['SubSumCD'] == '1']
		except: pass
		counterloop = counterloop + 1
		print '##counterloop',counterloop
	#print '#all',result
	
	subtitles = []
	for lang in langs.split(','):
		filter = [i for i in result if lang == i['SubLanguageID']]
		if filter == []: continue
		print tag
		subtitles += [i for i in filter if tag.lower() in i['MovieReleaseName'].lower()]	
		print '#tagresult',subtitles
		for q in quality: subtitles += [i for i in filter if q in i['MovieReleaseName'].lower()]
		subtitles += [i for i in filter if not any(x in i['MovieReleaseName'].lower() for x in quality)]
		try: lang = xbmc.convertLanguage(lang, xbmc.ISO_639_1)
		except: pass
		break
		
	import zlib, base64
	content = [subtitles[0]["IDSubtitleFile"],]
	content = server.DownloadSubtitles(token, content)
	content = base64.b64decode(content['data'][0]['data'])
	content = zlib.decompressobj(16+zlib.MAX_WBITS).decompress(content)

	subtitle = xbmc.translatePath('special://temp/')
	subtitle = os.path.join(subtitle, 'TemporarySubs.%s.srt' % lang)
	file = open(subtitle, 'wb')
	file.write(content)
	file.close()

	return subtitle
Ejemplo n.º 48
0
def convert(item):
    ret = {'filename': item['fnev'], 'name': item['nev'].strip(), 'language_hun': item['language'], 'id': item['felirat'],
           'uploader': item['feltolto'].strip(), 'hearing': False, 'language_eng': lang_hun2eng(item['language'])}

    score = int(item['pontos_talalat'], 2)
    ret['score'] = score
    ret['rating'] = str(score * 5 / 7)
    ret['sync'] = score >= 6
    ret['flag'] = xbmc.convertLanguage(ret['language_eng'], xbmc.ISO_639_1)
    ret['seasonpack'] = item['evadpakk'] == '1'

    return ret
Ejemplo n.º 49
0
    def _build_subtitle_list(self, search_results, item):
        ret = []
        total_downloads = 0
        for result in search_results:
            url = self.BASE_URL + "/he/cinemast/data/" + result["type"] + "/sb/" + result["slug"]
            url += "/" + item["season"] + "/" + item["episode"] + "/" if result["type"] == "series" else "/"
            subs_list = self.urlHandler.request(url)

            if subs_list is not None:
                subs_list = json.loads(subs_list, encoding="utf-8")
                for language in subs_list.keys():
                    if xbmc.convertLanguage(language, xbmc.ISO_639_2) in item["3let_language"]:
                        for translator_group in subs_list[language]:
                            for quality in subs_list[language][translator_group]:
                                for index in subs_list[language][translator_group][quality]:
                                    current = subs_list[language][translator_group][quality][index]
                                    title = current["subtitle_version"]
                                    subtitle_rate = self._calc_rating(title, item["file_original_path"])
                                    total_downloads += current["downloaded"]
                                    ret.append(
                                            {'lang_index': item["3let_language"].index(
                                                    xbmc.convertLanguage(language, xbmc.ISO_639_2)),
                                                'filename': title,
                                                'link': current["key"],
                                                'language_name': xbmc.convertLanguage(language, xbmc.ENGLISH_NAME),
                                                'language_flag': language,
                                                'id': current["id"],
                                                'rating': str(current["downloaded"]),
                                                'sync': subtitle_rate >= 3.8,
                                                'hearing_imp': current["hearing_impaired"] > 0,
                                                'is_preferred':
                                                    xbmc.convertLanguage(language, xbmc.ISO_639_2) == item[
                                                        'preferredlanguage']
                                            })
        # Fix the rating
        if total_downloads:
            for it in ret:
                it["rating"] = str(int(round(float(it["rating"]) / float(total_downloads), 1) * 5))

        return sorted(ret, key=lambda x: (x['is_preferred'], x['lang_index'], x['sync'], x['rating']), reverse=True)
    def onInit(self):
        self.getControl(1).setLabel(L(CHOOSE_ART_HEADER).format(self.arttype, self.medialabel))
        self.getControl(3).setVisible(False)
        self.getControl(5).setVisible(self.multi)
        self.getControl(5).setLabel('$LOCALIZE[186]')
        self.guilist = self.getControl(6)

        for image in self.artlist:
            provider = image['provider'].display
            if isinstance(provider, int):
                provider = L(provider)
            secondprovider = image.get('second provider')
            if secondprovider:
                if isinstance(secondprovider, int):
                    secondprovider = L(secondprovider)
                provider = '{0}, {1}'.format(provider, secondprovider)
            title = image.get('title')
            if not title and 'subtype' in image:
                title = image['subtype'].display
            language = xbmc.convertLanguage(image['language'], xbmc.ENGLISH_NAME) if image.get('language') else None
            if not title:
                title = language
            if title and len(title) < 20 and not secondprovider:
                label = '{0} from {1}'.format(title, provider)
                summary = language if language and language != title else ''
            else:
                label = provider
                if language and language != title:
                    title = language + ' ' + title
                summary = title if title else ''
            rating = image.get('rating')
            size = image.get('size')
            if (rating or size) and summary:
                summary += '\n'
            if size:
                summary += image['size'].display
            if rating and size:
                summary += '   '
            if rating:
                summary += image['rating'].display
            listitem = xbmcgui.ListItem(label)
            listitem.setLabel2(summary)
            # DEPRECATED: Above Krypton and higher (only), below Jarvis and lower (only)
            listitem.setProperty('Addon.Summary', summary)
            listitem.setIconImage(image['url'] if self.hqpreview else image['preview'])
            # DEPRECATED: Above is deprecated in Jarvis, but still works through Krypton (at least)
            # listitem.setArt({'icon': image['url'] if self.hqpreview else image['preview']})
            listitem.setPath(image['url'])
            if image.get('existing'):
                listitem.select(True)
            self.guilist.addItem(listitem)
        self.setFocus(self.guilist)
	def search(self, item):

		if item['mansearch']:
			title = item['mansearchstr']
			dialog = xbmcgui.Dialog()
			item['season'] = dialog.numeric(0, self._t(32111), item['season'])
			item['episode'] = dialog.numeric(0, self._t(32112), item['episode'])
		else:
			title = self.normalize_input_title(item['tvshow'])

		if not title or not item['season'] or not item['episode']:
			xbmc.executebuiltin("XBMC.Notification(%s,%s,5000,%s)" % (
						self.addon.getAddonInfo('name'), self._t(32110),
						os.path.join(xbmc.translatePath(self.addon.getAddonInfo('path')).decode("utf-8"),'icon.png')
			))
			log(__name__, ["Input validation error", title, item['season'], item['episode']])
			return results_with_stats(None, self.addon, title, item)

		if item['3let_language'] and "cze" not in item['3let_language']:
			dialog = xbmcgui.Dialog()
			if dialog.yesno(self.addon.getAddonInfo('name'), self._t(32100), self._t(32101)):
				xbmc.executebuiltin("Dialog.Close(subtitlesearch)")
				xbmc.executebuiltin("PlayerControl(Stop)")
				xbmc.executebuiltin("ActivateWindowAndFocus(playersettings,-96,0,-67,0)")
			return results_with_stats(None, self.addon, title, item)

		all_tv_show_list = self.get_tv_show_list()
		if not all_tv_show_list: return results_with_stats(None, self.addon, title, item)

		tvshow_url = self.search_show_url(title, all_tv_show_list)
		if tvshow_url == None: return results_with_stats(None, self.addon, title, item)

		found_season_subtitles = self.search_season_subtitles(tvshow_url,item['season'])
		log(__name__, ["Season filter", found_season_subtitles])
		if found_season_subtitles == None: return results_with_stats(None, self.addon, title, item)

		episode_subtitle = self.filter_episode_from_season_subtitles(found_season_subtitles,item['season'],item['episode'])
		log(__name__, ["Episode filter", episode_subtitle])
		if episode_subtitle == None: return results_with_stats(None, self.addon, title, item)

		result_subtitles = [{
			'filename': HTMLParser.HTMLParser().unescape(episode_subtitle['full_title']),
			'link': self.server_url + episode_subtitle['link'],
			'lang': episode_subtitle['lang'],
			'rating': "0",
			'sync': False,
			'lang_flag': xbmc.convertLanguage(episode_subtitle['lang'],xbmc.ISO_639_1),
		}]

		log(__name__,["Search result", result_subtitles])

		return results_with_stats(result_subtitles, self.addon, title, item)
def Search(item):
    d = timeout(set_filehash, args=(item["file_original_path"], item["rar"]), timeout_duration=15)

    for language in item["3let_language"]:
        language = "pl" if language == "pol" else language
        params = {
            "l": language.upper(),
            "f": d.hexdigest(),
            "t": f(d.hexdigest()),
            "v": "dreambox",
            "kolejka": "false",
            "nick": "",
            "pass": "",
            "napios": os.name
        }

        url = "http://napiprojekt.pl/unit_napisy/dl.php?" + urllib.urlencode(params)
        subs = urllib.urlopen(url).read()

        if subs[0:4] != 'NPc0':
            file_name = '.'.join(os.path.basename(item["file_original_path"]).split(".")[:-1])
            listitem = xbmcgui.ListItem(label=xbmc.convertLanguage(language, xbmc.ENGLISH_NAME),
                                        # language name for the found subtitle
                                        label2=file_name,  # file name for the found subtitle
                                        iconImage="5",  # rating for the subtitle, string 0-5
                                        thumbnailImage=xbmc.convertLanguage(language, xbmc.ISO_639_1)
                                        # language flag, ISO_639_1 language + gif extention, e.g - "en.gif"
            )
            listitem.setProperty("sync", '{0}'.format("true").lower())  # set to "true" if subtitle is matched by hash,
            # indicates that sub is 100 Comaptible
            listitem.setProperty("hearing_imp",
                                 '{0}'.format("false").lower())  # set to "true" if subtitle is for hearing impared

            ## below arguments are optional, it can be used to pass any info needed in download function
            ## anything after "action=download&" will be sent to addon once user clicks listed subtitle to download
            url = "plugin://%s/?action=download&l=%s&f=%s&t=%s&filename=%s" % (
            __scriptid__, params["l"], params["f"], params["t"], file_name)
            ## add it to list, this can be done as many times as needed for all subtitles found
            xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=listitem, isFolder=False)
    def from_english(self, language):
        if language in EXCEPTIONS:
            return Language.fromietf(EXCEPTIONS[language])

        language_match = re.search('(\w[\w\s]*\w)', language)
        if not language_match:
            return

        language_english = language_match.group(1)
        language_alpha3 = xbmc.convertLanguage(language_english, format=xbmc.ISO_639_2)
        if not language_alpha3:
            return

        result = Language.fromcode(language_alpha3, 'alpha3b')
        result.country = self.get_country(language)
        return result
Ejemplo n.º 54
0
	def search(self, item):

		if item['mansearch']:
			title = item['mansearchstr']
			dialog = xbmcgui.Dialog()
			item['season'] = dialog.numeric(0, self._t(32111), item['season'])
			item['episode'] = dialog.numeric(0, self._t(32112), item['episode'])
		else:
			title = self.normalize_input_title(item['tvshow'])

		if not title or not item['season'] or not item['episode']:
			xbmc.executebuiltin("XBMC.Notification(%s,%s,5000,%s)" % (
						self.addon.getAddonInfo('name'), self._t(32110),
						os.path.join(xbmc.translatePath(self.addon.getAddonInfo('path')).decode("utf-8"),'icon.png')
			))
			log(__name__, ["Input validation error", title, item['season'], item['episode']])
			return results_with_stats(None, self.addon, title, item)

		tvshow_url = self.search_show_url(title)
		if tvshow_url == None: return results_with_stats(None, self.addon, title, item)

		found_season_subtitles = self.search_season_subtitles(tvshow_url,item['season'])
		log(__name__, ["Season filter", found_season_subtitles])

		episode_subtitle_list = self.filter_episode_from_season_subtitles(found_season_subtitles,item['season'],item['episode'])
		log(__name__, ["Episode filter", episode_subtitle_list])
		if episode_subtitle_list == None: return results_with_stats(None, self.addon, title, item)

		lang_filetred_episode_subtitle_list = self.filter_subtitles_by_language(item['3let_language'], episode_subtitle_list)
		log(__name__, ["Language filter", lang_filetred_episode_subtitle_list])
		if lang_filetred_episode_subtitle_list == None: return results_with_stats(None, self.addon, title, item)

		result_subtitles = []
		for episode_subtitle in lang_filetred_episode_subtitle_list['versions']:

			result_subtitles.append({
				'filename': HTMLParser.HTMLParser().unescape(lang_filetred_episode_subtitle_list['full_title']),
				'link': self.server_url + episode_subtitle['link'],
				'lang': episode_subtitle['lang'],
				'rating': "0",
				'sync': False,
				'lang_flag': xbmc.convertLanguage(episode_subtitle['lang'],xbmc.ISO_639_1),
			})

		log(__name__,["Search result", result_subtitles])

		return results_with_stats(result_subtitles, self.addon, title, item)
Ejemplo n.º 55
0
    def onPlayBackStarted(self):
        check_for_specific = (__addon__.getSetting('check_for_specific').lower() == 'true')
        specific_language = (__addon__.getSetting('selected_language'))
        specific_language = xbmc.convertLanguage(specific_language, xbmc.ISO_639_2)

        if self.run:
            movieFullPath = xbmc.Player().getPlayingFile()
            availableLangs = xbmc.Player().getAvailableSubtitleStreams()

            if (xbmc.Player().isPlayingVideo() and ((not xbmc.getCondVisibility("VideoPlayer.HasSubtitles")) or (check_for_specific and not specific_language in availableLangs)) and all(movieFullPath.find (v) <= -1 for v in ignore_words) and (isExcluded(movieFullPath)) ):
                self.run = False
                xbmc.sleep(1000)
                Debug('[AutoSubsPlayer] Started: AutoSearching for Subs')
                xbmc.executebuiltin('XBMC.ActivateWindow(SubtitleSearch)')
            else:
                Debug('[AutoSubsPlayer] Started: Subs found or Excluded')
                self.run = False
Ejemplo n.º 56
0
    def settings(self, settings):
        self.id_teamwatch = settings['twid']
        self.id_playerctl = settings['pcid']
        self.nickname = settings['nickname']
        
        self.twitter_enabled = settings['twitter_enabled']
        self.twitter_language = settings['language']
        self.twitter_language = xbmc.convertLanguage(self.twitter_language, xbmc.ISO_639_1)
        self.twitter_result_type = settings['result_type']

        self.facebook_enabled = settings['facebook_enabled']
        self.facebook_email = settings['facebook_email']
        self.facebook_password = settings['facebook_password']

        if settings['imdb_lang'] == 'Italian':    
            self.imdb_translate = 'it'
        elif settings['imdb_lang'] == 'French':    
            self.imdb_translate = 'fr'
        elif settings['imdb_lang'] == 'German':    
            self.imdb_translate = 'de'
        else:
            self.imdb_translate = None
        
        self.email_enabled = settings['email_enabled']
        self.email = settings['email']
        self.email_password = settings['email_password']
        self.email_imap = settings['email_imap']
        self.facebook = settings['facebook']
        
        self.show_allways = not (settings['showallways'] == "true")
        
        self.screen_height = settings['screen_height']
        if self.screen_height == "" or self.screen_height == None: 
            self.screen_height = xbmcgui.getScreenHeight()
        else:
            self.screen_height = int(settings['screen_height'])
            
        self.screen_width = settings['screen_width']
        if self.screen_width == "" or self.screen_width == None: 
            self.screen_width = xbmcgui.getScreenWidth()
        else:
            self.screen_width = int(settings['screen_width'])
        
        self.bartop = self.screen_height - 75
	def filter_subtitles_by_language(self, set_languages, subtitles_list):
		if not set_languages: return subtitles_list

		log(__name__, ['Filter by languages', set_languages])
		filter_subtitles_list = []
		for subtitle in subtitles_list:
			if xbmc.convertLanguage(subtitle['lang'],xbmc.ISO_639_2) in set_languages:
				filter_subtitles_list.append(subtitle)

		if not filter_subtitles_list:
			if "cze" not in set_languages and "slo" not in set_languages:
				dialog = xbmcgui.Dialog()
				if dialog.yesno(self.addon.getAddonInfo('name'), self._t(32100), self._t(32101)):
					xbmc.executebuiltin("Dialog.Close(subtitlesearch)")
					xbmc.executebuiltin("PlayerControl(Stop)")
					xbmc.executebuiltin("ActivateWindowAndFocus(playersettings,-96,0,-67,0)")
			return None
		else:
			return filter_subtitles_list
	def search(self,item):

		if item['mansearch']:
			title = item['mansearchstr']
		elif item['tvshow']:
			title = "%s S%02dE%02d" % (self.normalize_input_title(item['tvshow']), int(item['season']), int(item['episode'])) # Searching TV Show
		else: # Searching movie
			title = item['title'] if item['year'] else xbmc.getCleanMovieTitle(item['title'])[0]
			title = self.normalize_input_title(title)

		log(__name__, "Search pattern: " + title)

		found_subtitles = self.search_subtitle(title)
		log(__name__, "Parsed subtitles: %s" % found_subtitles )

		lang_filetred_found_subtitles = self.filter_subtitles_by_language(item['3let_language'], found_subtitles)
		log(__name__, ["Language filter", lang_filetred_found_subtitles])
		if not lang_filetred_found_subtitles: return results_with_stats(None, self.addon, title, item)

		file_size = get_file_size(item['file_original_path'], item['rar'])
		if not (file_size == -1): file_size = round(float(file_size)/(1024*1024),2)
		log(__name__, "File size: %s" % file_size)

		max_down_count = self.detect_max_download_stats(lang_filetred_found_subtitles)

		result_subtitles = []
		for found_subtitle in lang_filetred_found_subtitles:
			print_out_filename = (found_subtitle['version'], found_subtitle['title'])[found_subtitle['version'] == '' or found_subtitle['version'] == None]
			if not found_subtitle['author'] == None: print_out_filename += " by " + found_subtitle['author']
			result_subtitles.append({
				'filename': HTMLParser.HTMLParser().unescape(print_out_filename),
				'id': found_subtitle['id'],
				'lang': found_subtitle['lang'],
				'rating': str(found_subtitle['down_count']*5/max_down_count) if max_down_count > 0 else "0",
				'sync': (found_subtitle['size'] == file_size and file_size > 0),
				'lang_flag': xbmc.convertLanguage(found_subtitle['lang'],xbmc.ISO_639_1),
			})

		log(__name__,["Search result", result_subtitles])

		return results_with_stats(result_subtitles, self.addon, title, item)