def root(self, pathitems=None): # pylint: disable=unused-argument """Show profiles or home listing when profile auto-selection is enabled""" # Get the URL parent path of the navigation: xbmc.getInfoLabel('Container.FolderPath') # it can be found in Kodi log as "ParentPath = [xyz]" but not always return the exact value is_parent_root_path = xbmc.getInfoLabel( 'Container.FolderPath') == g.BASE_URL + '/' # Fetch initial page to refresh all session data if is_parent_root_path: common.make_call('fetch_initial_page') # Note when the profiles are updated to the database (by fetch_initial_page call), # the update sanitize also relative settings to profiles (see _delete_non_existing_profiles in website.py) autoselect_profile_guid = g.LOCAL_DB.get_value( 'autoselect_profile_guid', '') if autoselect_profile_guid: if is_parent_root_path: common.info('Performing auto-selection of profile {}', autoselect_profile_guid) # Do not perform the profile switch if navigation come from a page that is not the root url, # prevents profile switching when returning to the main menu from one of the sub-menus if not is_parent_root_path or activate_profile( autoselect_profile_guid): self.home(None, False, True) return list_data, extra_data = common.make_call('get_profiles', {'request_update': False}) self._profiles(list_data, extra_data)
def _login(self, modal_error_message=False): """Perform account login""" # If exists get the current esn value before extract a new session data current_esn = g.get_esn() try: # First we get the authentication url without logging in, required for login API call react_context = website.extract_json(self._get('profiles'), 'reactContext') auth_url = website.extract_api_data(react_context)['auth_url'] common.debug('Logging in...') login_response = self._post('login', data=_login_payload( common.get_credentials(), auth_url)) validate_msg = website.validate_login(login_response) if validate_msg: self.session.cookies.clear() common.purge_credentials() if modal_error_message: ui.show_ok_dialog(common.get_local_string(30008), validate_msg) else: ui.show_notification(common.get_local_string(30009)) return False website.extract_session_data(login_response) except Exception as exc: common.error(traceback.format_exc()) self.session.cookies.clear() raise exc common.info('Login successful') ui.show_notification(common.get_local_string(30109)) self.update_session_data(current_esn) return True
def resolveOPENLOAD(l): mediaid = l.split("/") #//openload.co/embed/T46sXRDbTos/ mediaid = mediaid[len(mediaid) - 2] status = requests.get('https://api.openload.co/1/file/info?file=' + mediaid) if status: if status.json().get('status') == 200: status = requests.get( 'https://api.openload.co/1/streaming/get?file=' + mediaid) if status: if status.json().get('status') == 200: link = status.json().get('result').get('url') if link: xbmcplugin.setResolvedUrl(common.addon_handle, True, xbmcgui.ListItem(path=link)) else: common.info('OPENLOAD - link not found', '', 200) else: common.info(status.json().get('msg')) else: common.info('openload - request error', '', 200) else: common.info(status.json().get('msg')) else: common.info('openload - request error', '', 200) return 0
def _activate_profile(self, guid, ignore_update_lolomo_data=False): """Set the profile identified by guid as active""" common.debug('Switching to profile {}', guid) current_active_guid = g.LOCAL_DB.get_active_profile_guid() if self.is_profile_session_active and guid == current_active_guid: common.info( 'The profile session of guid {} is still active, activation not needed.', guid) if not self.is_profile_session_active or ( self.is_profile_session_active and guid != current_active_guid): common.info('Activating profile {}', guid) # 20/05/2020 - The method 1 not more working for switching PIN locked profiles # INIT Method 1 - HTTP mode # response = self._get('switch_profile', params={'tkn': guid}) # self.auth_url = self.website_extract_session_data(response)['auth_url'] # END Method 1 # INIT Method 2 - API mode import time self._get(endpoint='activate_profile', params={ 'switchProfileGuid': guid, '_': int(time.time()), 'authURL': self.auth_url }) # Retrieve browse page to update authURL response = self._get('browse') self.auth_url = website.extract_session_data(response)['auth_url'] # END Method 2 self.is_profile_session_active = True g.LOCAL_DB.switch_active_profile(guid) g.CACHE_MANAGEMENT.identifier_prefix = guid self.update_session_data() if not ignore_update_lolomo_data: self.update_lolomo_data()
def play(p): xbmcplugin.setContent(common.addon_handle, 'movie') u = p.get('url', '') l = common.solveCFP(u) if not l == None: t = re.compile('<table class=\"table\">(.*?)<\/table>', re.DOTALL).findall(l.text.encode('utf-8'))[0] rows = re.compile('(<tr.*?)<\/tr>', re.DOTALL).findall(t) players = [] selList = [] for r1 in range(len(rows)): tds = re.compile('(<td.*?<\/td>)', re.DOTALL).findall(rows[r1]) pl = re.compile('> (.*?)<\/td>', re.DOTALL).findall(tds[0])[0] link = re.compile('<a href=\"(.*?)\" ', re.DOTALL).findall(tds[1])[0] kind = re.compile('<td.*?>(.*?)<\/td>', re.DOTALL).findall(tds[3])[0] players.append([pl, link]) selList.append("%s [COLOR lime]%s[/COLOR] | %s" % (pl, kind, link)) playfrom = xbmcgui.Dialog().select('Wybor zrodla', selList) if playfrom >= 0: common.log("Wybrano :" + players[playfrom][0] + " - link: " + players[playfrom][1]) player(players[playfrom]) else: common.info("LINK FEATCHING FAILED", "E404", time=5000) xbmcplugin.endOfDirectory(common.addon_handle)
def _activate_profile(self, guid): """Set the profile identified by guid as active""" common.debug('Switching to profile {}', guid) current_active_guid = g.LOCAL_DB.get_active_profile_guid() if self.is_profile_session_active and guid == current_active_guid: common.info( 'The profile session of guid {} is still active, activation not needed.', guid) import time timestamp = time.time() common.info('Activating profile {}', guid) # 20/05/2020 - The method 1 not more working for switching PIN locked profiles # INIT Method 1 - HTTP mode # response = self._get('switch_profile', params={'tkn': guid}) # self.auth_url = self.website_extract_session_data(response)['auth_url'] # END Method 1 # INIT Method 2 - API mode self._get(endpoint='activate_profile', params={ 'switchProfileGuid': guid, '_': int(timestamp * 1000), 'authURL': self.auth_url }) # Retrieve browse page to update authURL response = self._get('browse') self.auth_url = website.extract_session_data(response)['auth_url'] # END Method 2 self.is_profile_session_active = True # Update the session profile cookie (only a test, see 'Profile idle timeout' in website.py) # expires = int(timestamp) + (g.LOCAL_DB.get_value('profile_gate_idle_timer', 30, TABLE_SESSION) * 60) # self.session.cookies.set('profilesNewSession', '0', domain='.netflix.com', path='/', expires=expires) g.LOCAL_DB.switch_active_profile(guid) g.CACHE_MANAGEMENT.identifier_prefix = guid cookies.save(self.account_hash, self.session.cookies)
def playEpizod(params): xbmcplugin.setContent(common.addon_handle, 'movie') u=MURL+params.get('url','') l=common.solveCFP(u) if not l==None: m=re.compile('<table class=\"data-view-table-strips data-view-table-big data-view-hover\">(.*?)<\/table>',re.DOTALL).findall(l.text.encode('utf-8'))[0] m1=re.compile('<tbody>(.*?)<\/tbody>',re.DOTALL).findall(m) rows=re.compile('<tr>(.*?)<\/tr>',re.DOTALL).findall(m1[0]) KEY=re.compile("_Storage\.basic = '(.*?)';",re.DOTALL).findall(l.text.encode('utf-8'))[0] XHR=re.compile("_Storage\.XHRService = '\/\/(.*?)';",re.DOTALL).findall(l.text.encode('utf-8'))[0] players=[] selList=[] for r in range(len(rows)): pl=re.compile('<td class=\"ep-pl-name\">.*?([\w\s\d]*?)<\/td>',re.DOTALL).findall(rows[r])[0] or 0 audio=re.compile('<td class=\"ep-pl-alang\">.*?<span class=\"mobile-hidden\">(.*?)<\/span>',re.DOTALL).findall(rows[r])[0] or 0 subs=re.compile('<td class=\"ep-pl-slang\">.*?<span class=\"mobile-hidden\">(.*?)<\/span>',re.DOTALL).findall(rows[r])[0] or 0 res=re.compile('<td class=\"ep-pl-res\">.*?<\/span>(.*?)<\/td>',re.DOTALL).findall(rows[r])[0] or 0 id=re.compile('\"online_id\":\"(.*?)\"',re.DOTALL).findall(rows[r])[0] or 0 players.append([pl,id]) selList.append("%s [COLOR blue]%s[/COLOR] A:%s N:%s" % (pl,res,audio,subs)) playfrom=xbmcgui.Dialog().select('Wybor zrodla',selList) if playfrom>=0: player(players[playfrom],KEY,XHR) else: common.info("LINK FEATCHING FAILED","E404", time=5000) xbmcplugin.endOfDirectory(common.addon_handle)
def _compute_next_schedule(): try: if g.ADDON.getSettingBool('use_mysql'): client_uuid = g.LOCAL_DB.get_value('client_uuid') uuid = g.SHARED_DB.get_value('auto_update_device_uuid') if client_uuid != uuid: common.debug( 'The auto update has been disabled because another device ' 'has been set as the main update manager') return None time = g.ADDON.getSetting('lib_auto_upd_start') or '00:00' last_run = g.SHARED_DB.get_value('library_auto_update_last_start', datetime.utcfromtimestamp(0)) update_frequency = g.ADDON.getSettingInt('lib_auto_upd_freq') last_run = last_run.replace(hour=int(time[0:2]), minute=int(time[3:5])) next_run = last_run + timedelta(days=[1, 2, 5, 7][update_frequency]) if next_run >= datetime.now(): common.info('Next library auto update is scheduled for {}', next_run) return next_run except Exception: # pylint: disable=broad-except # If settings.xml was not created yet, as at first service run # g.ADDON.getSettingBool('use_mysql') will thrown a TypeError # If any other error appears, we don't want the service to crash, # let's return None in all case # import traceback # common.debug(g.py2_decode(traceback.format_exc(), 'latin-1')) common.warn('Managed error at _compute_next_schedule') return None
def run(argv): # pylint: disable=broad-except,ungrouped-imports # Initialize globals right away to avoid stale values from the last addon invocation. # Otherwise Kodi's reuseLanguageInvoker will cause some really quirky behavior! # PR: https://github.com/xbmc/xbmc/pull/13814 g.init_globals(argv) reset_log_level_global_var() info('Started (Version {})'.format(g.VERSION_RAW)) info('URL is {}'.format(g.URL)) success = True window_cls = Window(10000) # Kodi home window # If you use multiple Kodi profiles you need to distinguish the property of current profile prop_nf_service_status = g.py2_encode('nf_service_status_' + get_current_kodi_profile_name()) is_external_call = _check_addon_external_call(window_cls, prop_nf_service_status) service_status = _get_service_status(window_cls, prop_nf_service_status) if service_status.get('status') != 'running': if not is_external_call: if service_status.get('status') == 'error': # The services are not started due to an error exception from resources.lib.kodi.ui import show_error_info show_error_info( get_local_string(30105), get_local_string(30240).format( service_status.get('message')), False, False) else: # The services are not started yet from resources.lib.kodi.ui import show_backend_not_ready show_backend_not_ready() success = False if success: try: if _check_valid_credentials(): if g.IS_ADDON_FIRSTRUN: if check_addon_upgrade(): from resources.lib.config_wizard import run_addon_configuration run_addon_configuration() route([part for part in g.PATH.split('/') if part]) else: success = False except BackendNotReady: from resources.lib.kodi.ui import show_backend_not_ready show_backend_not_ready() success = False except Exception as exc: import traceback from resources.lib.kodi.ui import show_addon_error_info error(g.py2_decode(traceback.format_exc(), 'latin-1')) show_addon_error_info(exc) success = False if not success: _handle_endofdirectory() log_time_trace()
def _home_autoselect_profile(self): """ Show home listing if profile auto-selection is enabled :return: True when the auto-selection is done correctly """ autoselect_profile_guid = g.LOCAL_DB.get_value( 'autoselect_profile_guid', '') if autoselect_profile_guid: # Check if the GUID still exists in the profile list if autoselect_profile_guid not in g.LOCAL_DB.get_guid_profiles(): common.warn( 'Auto-selection of profile not performed, the GUID {} not exist', autoselect_profile_guid) g.LOCAL_DB.set_value('autoselect_profile_guid', '') g.settings_monitor_suspend(True) g.ADDON.setSetting('autoselect_profile_name', '') g.ADDON.setSettingBool('autoselect_profile_enabled', False) g.settings_monitor_suspend(False) else: common.info('Performing auto-selection of profile {}', autoselect_profile_guid) api.activate_profile(autoselect_profile_guid) self.home(None, False) return True return False
def _login(self, modal_error_message=False): """Perform account login""" # If exists get the current esn value before extract a new session data current_esn = g.get_esn() try: # First we get the authentication url without logging in, required for login API call react_context = website.extract_json(self._get('login'), 'reactContext') auth_url = website.extract_api_data(react_context)['auth_url'] common.debug('Logging in...') login_response = self._post( 'login', data=_login_payload(common.get_credentials(), auth_url)) try: website.extract_session_data(login_response, validate=True, update_profiles=True) common.info('Login successful') ui.show_notification(common.get_local_string(30109)) self.update_session_data(current_esn) return True except (LoginValidateError, LoginValidateErrorIncorrectPassword) as exc: self.session.cookies.clear() common.purge_credentials() if not modal_error_message: raise ui.show_ok_dialog(common.get_local_string(30008), unicode(exc)) except InvalidMembershipStatusError: ui.show_error_info(common.get_local_string(30008), common.get_local_string(30180), False, True) except Exception: # pylint: disable=broad-except import traceback common.error(g.py2_decode(traceback.format_exc(), 'latin-1')) self.session.cookies.clear() raise return False
def request(l, d): s = requests.Session() head = { 'authority': 'shinden.pl', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36 OPR/54.0.2952.71', 'X-Requested-With': 'XMLHttpRequest', 'Host': 'shinden.pl', 'contentType': 'application/x-www-form-urlencoded; charset=UTF-8', 'Referer': 'https://shinden.pl', 'pragma': 'no-cache', 'cache-control': 'no-cache', 'upgrade-insecure-requests': '1', 'dnt': '1', 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'accept-encoding': 'identity', 'accept-language': 'pl-PL,pl;q=0.9,en-US;q=0.8,en;q=0.7' } #try: r = s.get(l + "player_load", params=d) #, headers=head,timeout=10) r.close() common.info('Pobieram dane playera', '') time.sleep(int(r.text)) d['width'] = "800" r = s.get(l + "player_show", params=d) #, headers=head,timeout=10) r.close() text = r.text.encode('utf-8') #except: # log('nieudane request') # text='' return text
def logout(self, url): """Logout of the current account and reset the session""" common.debug('Logging out of current account') g.settings_monitor_suspend(True) # Disable and reset auto-update / auto-sync features g.ADDON.setSettingInt('lib_auto_upd_mode', 0) g.ADDON.setSettingBool('lib_sync_mylist', False) g.SHARED_DB.delete_key('sync_mylist_profile_guid') # Disable and reset the auto-select profile g.LOCAL_DB.set_value('autoselect_profile_guid', '') g.ADDON.setSetting('autoselect_profile_name', '') g.ADDON.setSettingBool('autoselect_profile_enabled', False) g.settings_monitor_suspend(False) # Delete cookie and credentials cookies.delete(self.account_hash) self._get('logout') common.purge_credentials() common.info('Logout successful') ui.show_notification(common.get_local_string(30113)) self._init_session() xbmc.executebuiltin('Container.Update(path,replace)' ) # Go to a fake page to clear screen # Open root page xbmc.executebuiltin('Container.Update({},replace)'.format( url)) # replace=reset history
def _process_event_request(self, event): """Do the event post request""" event.status = Event.STATUS_REQUESTED # Request attempts can be made up to a maximum of 3 times per event while event.is_attempts_granted(): common.info('EVENT [{}] - Executing request (attempt {})', event, event.req_attempt) params = {'reqAttempt': event.req_attempt, 'reqPriority': 20 if event.event_type == EVENT_START else 0, 'reqName': 'events/{}'.format(event)} url = ENDPOINTS['events'] + '?' + urlencode(params).replace('%2F', '/') try: response = self.chunked_request(url, event.request_data, g.get_esn(), disable_msl_switch=False) event.set_response(response) break except Exception as exc: # pylint: disable=broad-except common.error('EVENT [{}] - The request has failed: {}', event, exc) if event.event_type == EVENT_STOP: self.clear_queue() if event.event_data['is_in_mylist']: # If video is in my list, invalidate the continueWatching list (update lolomo context data) api.update_lolomo_context('continueWatching') else: # Else invalidate the 'queue' list (update lolomo context data) # Todo: get 'queue' lolomo id/index # api.update_lolomo_context('queue') pass api.update_videoid_bookmark(event.get_video_id()) # Below commented lines: let future requests continue to be sent, unstable connections like wi-fi cause problems # if not event.is_response_success(): # The event request is unsuccessful then there is some problem, # no longer make any future requests from this event id # return False return True
def activate_profile(self, guid): """Set the profile identified by guid as active""" common.debug('Switching to profile {}', guid) current_active_guid = g.LOCAL_DB.get_active_profile_guid() if self.is_profile_session_active and guid == current_active_guid: common.info( 'The profile session of guid {} is still active, activation not needed.', guid) if not self.is_profile_session_active or ( self.is_profile_session_active and guid != current_active_guid): common.info('Activating profile {}', guid) # INIT Method 1 - HTTP mode response = self._get('switch_profile', params={'tkn': guid}) self.auth_url = self.website_extract_session_data( response)['auth_url'] # END Method 1 # INIT Method 2 - API mode # import time # self._get(component='activate_profile', # params={'switchProfileGuid': guid, # '_': int(time.time()), # 'authURL': self.auth_url}) # # Retrieve browse page to update authURL # response = self._get('browse') # self.auth_url = website.extract_session_data(response)['auth_url'] # END Method 2 self.is_profile_session_active = True g.LOCAL_DB.switch_active_profile(guid) g.CACHE_MANAGEMENT.identifier_prefix = guid self.update_session_data()
def _verify_session_cookies(self): """Verify that the session cookies have not expired""" # pylint: disable=broad-except fallback_to_validate = False if not self.session.cookies: return False for cookie_name in LOGIN_COOKIES: if cookie_name not in self.session.cookies.keys(): common.error( 'The cookie "{}" do not exist. It is not possible to check expiration. ' 'Fallback to old validate method.'.format(cookie_name)) fallback_to_validate = True break for cookie in list(self.session.cookies): if cookie.name != cookie_name: continue if cookie.expires <= time.time(): common.info('Login is expired') return False if fallback_to_validate: # Old method, makes a request at every time an user change page on Kodi # and try to re-extract all, working but slows down navigation. # If we can get session data, cookies are still valid try: website.validate_session_data(self._get('profiles')) self.update_session_data() except Exception: common.debug(traceback.format_exc()) common.info( 'Failed to validate session data, login is expired') self.session.cookies.clear() return False return True
def resolveOTHER(l): link='' try: link=urlresolve.resolve("https://"+l) except: common.info('cos wiecej w logu','Blad resolveurl') if link: xbmcplugin.setResolvedUrl(common.addon_handle, True, xbmcgui.ListItem(path=link))
def play(videoid): """Play an episode or movie as specified by the path""" common.info('Playing {}', videoid) is_up_next_enabled = g.ADDON.getSettingBool('UpNextNotifier_enabled') metadata = [{}, {}] try: metadata = api.metadata(videoid) common.debug('Metadata is {}', metadata) except MetadataNotAvailable: common.warn('Metadata not available for {}', videoid) # Parental control PIN pin_result = _verify_pin(metadata[0].get('requiresPin', False)) if not pin_result: if pin_result is not None: ui.show_notification(common.get_local_string(30106), time=10000) xbmcplugin.endOfDirectory(g.PLUGIN_HANDLE, succeeded=False) return list_item = get_inputstream_listitem(videoid) infos, art = infolabels.add_info_for_playback(videoid, list_item, is_up_next_enabled) # Workaround for resuming strm files from library resume_position = infos.get('resume', {}).get('position') \ if g.IS_SKIN_CALL and g.ADDON.getSettingBool('ResumeManager_enabled') else None if resume_position: index_selected = ui.ask_for_resume( resume_position) if g.ADDON.getSettingBool( 'ResumeManager_dialog') else None if index_selected == -1: xbmcplugin.setResolvedUrl(handle=g.PLUGIN_HANDLE, succeeded=False, listitem=list_item) return if index_selected == 1: resume_position = None xbmcplugin.setResolvedUrl(handle=g.PLUGIN_HANDLE, succeeded=True, listitem=list_item) upnext_info = get_upnext_info(videoid, (infos, art), metadata) if is_up_next_enabled else None common.debug('Sending initialization signal') common.send_signal(common.Signals.PLAYBACK_INITIATED, { 'videoid': videoid.to_dict(), 'infos': infos, 'art': art, 'timeline_markers': get_timeline_markers(metadata[0]), 'upnext_info': upnext_info, 'resume_position': resume_position }, non_blocking=True) xbmcplugin.setResolvedUrl(handle=g.PLUGIN_HANDLE, succeeded=True, listitem=list_item)
def logout(self): """Logout of the current account and reset the session""" common.debug('Logging out of current account') cookies.delete(self.account_hash) self._get('logout') common.purge_credentials() common.info('Logout successful') ui.show_notification(common.get_local_string(30113)) self._init_session()
def update_library(): """ Update the local Kodi library with new episodes of exported shows """ if not _update_running(): common.info('Triggering library update') xbmc.executebuiltin( ('XBMC.RunPlugin(plugin://{}/?action=export-new-episodes' '&inbackground=True)').format(g.ADDON_ID))
def _sync_mylist(videoid, task_handler, enabled): """Add or remove exported items to My List, if enabled in settings""" operation = { 'export_item': 'add', 'remove_item': 'remove' }.get(task_handler.__name__) if enabled and operation and g.ADDON.getSettingBool('lib_sync_mylist'): common.info('Syncing my list due to change of Kodi library') api.update_my_list(videoid, operation)
def _init_msl_handler(self): self.msl_requests = None try: msl_data = json.loads(common.load_file(MSL_DATA_FILENAME)) common.info('Loaded MSL data from disk') except Exception: # pylint: disable=broad-except msl_data = None self.msl_requests = MSLRequests(msl_data) self.switch_events_handler()
def sync_library_with_mylist(self): """ Perform a full sync of Kodi library with Netflix "My List", by deleting everything that was previously exported """ common.info('Performing sync of Kodi library with My list') # Clear all the library self.clear_library() # Start the sync self.auto_update_library(True, show_nfo_dialog=True, clear_on_cancel=True)
def on_tick(self, player_state): # Stops playback when paused for more than one hour. # Some users leave the playback paused also for more than 12 hours, # this complicates things to resume playback, because the manifest data expires and with it also all # the streams urls are no longer guaranteed, so we force the stop of the playback. if self.is_player_in_pause and (time.time() - self.start_time) > 3600: common.info( 'The playback has been stopped because it has been exceeded 1 hour of pause' ) common.stop_playback()
def opis(params): u=MURL+params.get('url','') l=common.solveCFP(u) if not l==None: try: m=re.compile('<section class=\"info-top\">(.*?)<\/section>',re.DOTALL).findall(l.text.encode('utf-8'))[0] opis=re.compile('<div.*?>(.*?)<\/div>',re.DOTALL).findall(m)[0] xbmcgui.Dialog().textviewer('Opis',opis) except: common.log("brak informacji o serii") common.info("Problem z pobraniem opisu","BRAK OPISU", time=5000)
def logout(self): """Logout of the current account and reset the session""" common.debug('Logging out of current account') cookies.delete(self.account_hash) self._get('logout') common.purge_credentials() common.info('Logout successful') ui.show_notification(common.get_local_string(30113)) self._init_session() xbmc.executebuiltin('XBMC.Container.Update(path,replace)') # Clean path history xbmc.executebuiltin('XBMC.ActivateWindow(Home)')
def shutdown(self): """ Stop the background services """ for server in self.SERVERS: server['instance'].server_close() server['instance'].shutdown() server['instance'] = None server['thread'].join() server['thread'] = None common.info('Stopped MSL Service')
def root(self, pathitems=None): """Show profiles or home listing is autologin es enabled""" # pylint: disable=unused-argument autologin = g.ADDON.getSettingBool('autologin_enable') profile_id = g.ADDON.getSetting('autologin_id') if autologin and profile_id: common.info('Performing auto-login for selected profile {}', profile_id) api.activate_profile(profile_id) self.home(None, False) else: self.profiles()
def _prefetch_login(self): """Check if we have stored credentials. If so, do the login before the user requests it""" try: common.get_credentials() if not self._is_logged_in(): self._login() except MissingCredentialsError: common.info('Login prefetch: No stored credentials are available') except LoginFailedError: ui.show_notification(common.get_local_string(30009))
def invalidate(self, on_disk=False, bucket_names=None): """Clear cache buckets""" if not bucket_names: bucket_names = BUCKET_NAMES for bucket in bucket_names: self.window.clearProperty(self._window_property(bucket)) if bucket in self.buckets: del self.buckets[bucket] if on_disk: self._invalidate_on_disk(bucket_names) common.info('Cache invalidated')