Python generic_utility.log函数代码示例

    def get_launch_script(self, type):
        path = addon_path + '/resources/scripts/'+type+'/'
        browser_name = None
        double_quotes=''
        bash = ''
        if generic_utility.windows():
            path += 'windows/'
            ending = '.cmd'
            double_quotes = '"'
        elif generic_utility.darwin():
            path += 'darwin/'
            ending = '.sh'
            bash = 'sh '
        else:
            path += 'linux/'
            ending = '.sh'
            bash = 'sh '
        browser_name = self.get_browser_scriptname(browser_name)

        script = path+browser_name+ending
        custom_script = path+browser_name+"_custom"+ending
		
        if generic_utility.windows():
            script = script.replace('/','\\')
            custom_script = custom_script.replace('/','\\')
        
        if os.path.isfile(custom_script):
            script = custom_script
        elif not os.path.isfile(script):
            generic_utility.log('Script: '+script+' not found!')
            script = ''
        return bash + double_quotes+script+double_quotes

def cache():
    try:
        xbmcvfs.rmdir(generic_utility.cache_dir(), force=True)
        generic_utility.log('Cache folder deleted.')
        generic_utility.notification(generic_utility.get_string(30309))
    except Exception:
        pass

def add_or_remove(video_id, is_add):
    root_list = get_root_list()

    my_list = get_mylist(root_list)[0]
    auth = generic_utility.get_setting('authorization_url')
    track_id = get.track_id_list(my_list)

    if is_add:
        add_or_remove_str = 'addToList'
        add_or_remove_msg = 'added'
    else:
        add_or_remove_str = 'removeFromList'
        add_or_remove_msg = 'removed'

    post = ('{"callPath":["lolomos","%s","%s"],"params":["%s",2,["videos",%s],%s,null,null],' +
            '"authURL":"%s"}') % (root_list, add_or_remove_str, my_list, video_id, track_id, auth)

    content = connect.load_netflix_site(generic_utility.evaluator()+'&method=call', post, options=True)

    jsn = json.loads(content)

    generic_utility.log('mylist: '+my_list)
    generic_utility.log(str(jsn))
    if '"invalidated"' in content:
        generic_utility.notification('Successfully '+add_or_remove_msg)
    elif 'already exists' in content:
        generic_utility.notification('already exists')

    generic_utility.debug('add to mylist content: '+content)

def load_match(thread_id, lock, rets, metadata, is_episode = False, viewing_activity = False):
#    utility.log('loading '+unicode(video_id))
    ret = None

    custom_title = None
    series_title = None
    if viewing_activity==True:
        video_id = metadata['id']
        custom_title = metadata['title']
        series_title = metadata['series_title']
    else:
        video_id = metadata
    success = False
    while (success == False):
        try:
            ret = video(video_id, is_episode, lock, custom_title = custom_title, series_title = series_title)
            success = True
        except requests.exceptions.HTTPError, e:
            if e.response.status_code == 429:
                time.sleep(2)
            else:
                generic_utility.log('error loading video ' + unicode(video_id) + '\n' + traceback.format_exc(), xbmc.LOGERROR)
                break
        except Exception as e:
            generic_utility.log('error loading video ' + unicode(video_id) + '\n' + traceback.format_exc(), xbmc.LOGERROR)
            break

def add_series(series_id, series_title, season, single_update=True):
    series_file = get_series_dir(series_title)
    if not xbmcvfs.exists(series_file+os.sep):
        xbmcvfs.mkdir(series_file+os.sep)
    content = get.series_info(series_id)
    generic_utility.log(str(content))
    content = json.loads(content)['video']['seasons']
    for test in content:
        episode_season = unicode(test['seq'])
        if episode_season == season or season == '':
            season_dir = generic_utility.create_pathname(series_file.decode('utf-8'), test['title'])
            if not xbmcvfs.exists(season_dir+os.sep):
                xbmcvfs.mkdir(season_dir+os.sep)
            for item in test['episodes']:
                episode_id = unicode(item['episodeId'])
                episode_nr = unicode(item['seq'])
                episode_title = item['title']
                if len(episode_nr) == 1:
                    episode_nr = '0' + episode_nr
                season_nr = episode_season
                if len(season_nr) == 1:
                    season_nr = '0' + season_nr
                filename = 'S' + season_nr + 'E' + episode_nr + ' - ' + episode_title + '.V' + episode_id + 'V'+ '.strm'
                filename = generic_utility.clean_filename(filename, ' .')
                file_handler = xbmcvfs.File(generic_utility.create_pathname(season_dir, filename), 'w')
                file_handler.write(
                    generic_utility.encode('plugin://%s/?mode=play_video&url=%s' % (
                    generic_utility.addon_id, episode_id)))
                file_handler.close()
    if generic_utility.get_setting('update_db') and single_update:
        xbmc.executebuiltin('UpdateLibrary(video)')

def clear_netflix_cookies(conn):
    try:
        sql = 'DELETE FROM cookies where host_key = ?'
        cur = conn.cursor()
        cur.execute(sql, ('.netflix.com',))
        conn.commit()
    except: generic_utility.log('Error clearing Chrome-Cookie: ' +traceback.format_exc(), xbmc.LOGERROR)

    def playInternal (self, video_id, series_id):
        xbmc.audioSuspend()
        self.disable_screensaver()

        if generic_utility.get_setting('disable_lirc') == 'true':
            xbmc.executebuiltin('LIRC.Stop')

        try:
            self.launch_browser('http://netflix.com/watch/%s' % video_id)
        except:
            generic_utility.log(traceback.format_exc(), xbmc.LOGERROR)
            generic_utility.notification('Error launching browser. See logfile')

        self.enable_screensaver()
        xbmc.audioResume()
        if generic_utility.get_setting('disable_lirc') == 'true':
            xbmc.executebuiltin('LIRC.Start')

        if generic_utility.get_setting('sync_viewstate') == 'true':
            try:
                self.update_playcount(video_id)
            except:
                generic_utility.log(traceback.format_exc(), xbmc.LOGERROR)
                generic_utility.notification('Cannot update playcount. See logfile')
        self.close()

    def onAction(self, action):
        ACTION_NAV_BACK = 92
        ACTION_PREVIOUS_MENU = 10
        ACTION_STOP = 13

        ACTION_SELECT_ITEM = 7
        ACTION_PLAYER_PLAY = 79
        ACTION_PLAYER_PLAYPAUSE = 229
        ACTION_PAUSE = 12

        ACTION_PLAYER_REWIND = 78
        ACTION_MOVE_LEFT = 1
        ACTION_REWIND = 17

        ACTION_PLAYER_FORWARD = 77
        ACTION_MOVE_RIGHT = 2
        ACTION_FORWARD = 16

        ACTION_MOVE_UP = 3
        ACTION_MOVE_DOWN = 4

        if action.getId() in(ACTION_NAV_BACK, ACTION_PREVIOUS_MENU, ACTION_STOP):
            self.control('close')
        elif action.getId() in(ACTION_SELECT_ITEM, ACTION_PLAYER_PLAY, ACTION_PLAYER_PLAYPAUSE, ACTION_PAUSE):
            self.control('pause')
        elif action.getId() in(ACTION_PLAYER_REWIND, ACTION_MOVE_LEFT, ACTION_REWIND):
            self.control('backward')
        elif action.getId() in(ACTION_PLAYER_FORWARD, ACTION_MOVE_RIGHT, ACTION_FORWARD):
            self.control('forward')
        elif action.getId() == ACTION_MOVE_UP:
            self.control('up')
        elif action.getId() == ACTION_MOVE_DOWN:
            self.control('down')
        else:
            generic_utility.log('unknown action: ' + str(action.getId()))

def get_root_list_id_from_cookie():
    from resources import connect
    profile = generic_utility.get_setting('selected_profile')

    session = connect.get_netflix_session(False)

    root_list_id = None
    if not profile:
        generic_utility.log('kein profil!')
        for cur_cookie in session.cookies:
            if 'lhpuuidh-browse-' in cur_cookie.name:
#                generic_utility.log('found cookie: '+cur_cookie.value)
                root_list_id = cur_cookie.value
                break
            elif 'lhpuuid-kid-' in cur_cookie.name:
                root_list_id = cur_cookie.value
    else:
        for cur_cookie in session.cookies:
            if 'lhpuuidh-browse-'+profile in cur_cookie.name:
                root_list_id = cur_cookie.value
                break
            elif 'lhpuuid-kid-'+profile in cur_cookie.name:
                root_list_id = cur_cookie.value

    if not root_list_id:
        raise ValueError('root_list_id not found in cookies!')

    splt = root_list_id.split('%3A')
    if(len(splt) != 3):
        raise ValueError('Invalid split: '+root_list_id)

#    generic_utility.log('root: '+str(splt[2]))
    return splt[2]

def addon():
    dialog = xbmcgui.Dialog()
    if dialog.yesno(generic_utility.addon_name + ':', generic_utility.get_string(30307)):
        try:
            xbmcvfs.rmdir(generic_utility.data_dir(), force=True)
            generic_utility.log('Addon userdata folder deleted.')
            generic_utility.notification(generic_utility.get_string(30308))
        except Exception:
            pass

def read_headers():
    if test == False:
        headers_file = generic_utility.headers_file()
    else:
        headers_file = 'headers'
    content = file_utility.read(headers_file)
    if len(content) > 0:
        return pickle.loads(content)
    else:
        generic_utility.log('warning, read empty headers-file')
        return None

def read_cookies():
    if test == False:
        file_name = generic_utility.cookies_file()
    else:
        file_name = 'cookies'
    content = file_utility.read(file_name)
    if len(content) > 0:
        return requests.utils.cookiejar_from_dict(pickle.loads(content))
    else:
        generic_utility.log('warning, read empty cookies-file')
        return None

def parse_duration_playcount(match):
    duration = get_value(match, 'runtime', 0)

    playcount = 0
    try:
        offset = match['bookmarkPosition']
#        generic_utility.log('duration: ' + str(duration)+' offset: '+str(offset))
        if (duration > 0 and float(offset) / float(duration)) >= 0.8:
            playcount = 1
    except Exception:
        generic_utility.log('cannot parse playcount. match: '+str(match))
        pass
    return duration, playcount

def add_movie(movie_id, title, single_update=True):
    generic_utility.log(title)
    movie_dir, title = get_movie_dir(title)
    if not xbmcvfs.exists(movie_dir+os.sep):
        xbmcvfs.mkdir(movie_dir+os.sep)

    movie_file = generic_utility.clean_filename(title + '.V' + movie_id + 'V' + '.strm', ' .').strip(' .')
    file_handler = xbmcvfs.File(generic_utility.create_pathname(movie_dir.decode('utf-8'), movie_file), 'w')
    file_handler.write(
        generic_utility.encode('plugin://%s/?mode=play_video&url=%s' % (generic_utility.addon_id, movie_id)))
    file_handler.close()
    if generic_utility.get_setting('update_db') and single_update:
        xbmc.executebuiltin('UpdateLibrary(video)')

def load_tmdb_cover_fanart(title, video_id, video_type_temp, year):
    year_temp = year
    title_temp = title
    if ' - ' in title_temp:
        title_temp = title_temp[title_temp.index(' - '):]
    filename = video_id + '.jpg'
    filename_none = video_id + '.none'
    cover_file = xbmc.translatePath(generic_utility.cover_cache_dir() + filename)
    cover_file_none = xbmc.translatePath(generic_utility.cover_cache_dir() + filename_none)
    if not (xbmcvfs.exists(cover_file) or xbmcvfs.exists(cover_file_none)):
        generic_utility.log('Downloading cover art. type: %s, video_id: %s, title: %s, year: %s' % (video_type_temp,
                                                                                                    video_id, title_temp,
                                                                                                    year_temp), xbmc.LOGDEBUG)
        get.cover_and_fanart(video_type_temp, video_id, title_temp, year_temp)