def _common_menu_builder(self, trakt_list, content_type, action="getSources", **params): if len(trakt_list) == 0: g.log("We received no titles to build a list", "warning") g.cancel_directory() return list_items = [] smart_play = params.pop("smart_play", False) no_paging = params.pop("no_paging", False) sort = params.pop("sort", False) prepend_date = params.pop("prepend_date", False) mixed_list = params.pop("mixed_list", False) next_args = params.pop("next_args", None) params.pop("hide_unaired", None) params.pop("hide_watched", None) try: params["bulk_add"] = True list_items = [ g.add_directory_item(item.get("name"), action=action, menu_item=item, action_args=item.get("args"), **params) for item in self._post_process_list(trakt_list, prepend_date, mixed_list) if item is not None ] if smart_play: return list_items else: xbmcplugin.addDirectoryItems(g.PLUGIN_HANDLE, list_items, len(list_items)) except Exception as e: g.log_stacktrace() if not smart_play: g.cancel_directory() raise e finally: if not smart_play: if (not (g.FROM_WIDGET and g.get_bool_setting("general.widget.hide_next")) and not no_paging and len(list_items) >= self.page_limit): g.REQUEST_PARAMS["page"] = g.PAGE + 1 if next_args: g.REQUEST_PARAMS["action_args"] = next_args elif g.REQUEST_PARAMS.get("action_args") is not None: g.REQUEST_PARAMS["action_args"] = g.REQUEST_PARAMS.get( "action_args") params = g.REQUEST_PARAMS params.update({"special_sort": "bottom"}) g.add_directory_item(g.get_language_string(30016), **params) g.close_directory(content_type, sort=sort)
def get_json(self, **params): from resources.lib.third_party import xml_to_dict from xml.parsers.expat import ExpatError # pylint: disable=no-name-in-module response = self.get(**params) if response is None: return None try: if not response.content: return None elif xml_to_dict.parse(response.text).get("root", {}).get("@response", {}) == "False": return None elif xml_to_dict.parse(response.text).get("root", {}).get("error", {}): return None return self._handle_response( xml_to_dict.parse(response.text).get("root", {}).get("movie")) except (ValueError, AttributeError, ExpatError): g.log_stacktrace() g.log( "Failed to receive JSON from OMDb response - response: {}". format(response), "error", ) return None
def _trakt_stop_watching(self): if (not self.trakt_enabled or not self.scrobbling_enabled or self.scrobbled or g.get_global_setting("marked_watched_dialog_open") or self.current_time < self.ignoreSecondsAtStart): return post_data = self._build_trakt_object() if (post_data["progress"] >= self.playCountMinimumPercent or self._force_marked_watched): post_data["progress"] = (80 if post_data["progress"] < 80 else post_data["progress"]) try: scrobble_response = self._trakt_api.post( "scrobble/stop", post_data) except: g.log_stacktrace() return if scrobble_response.status_code in (201, 409): self._trakt_mark_playing_item_watched() self.scrobbled = True elif self.current_time > self.ignoreSecondsAtStart: try: scrobble_response = self._trakt_api.post( "scrobble/pause", post_data) except: g.log_stacktrace() return else: return if not scrobble_response.status_code == 201: g.log("Error scrobbling item to Trakt")
def background_tasks(self): """ Runs background watcher tasks :return: None :rtype: none """ try: try: progress_bar = self.getControlProgress(3014) except: progress_bar = None while (int(self.getTotalTime()) - int(self.getTime()) > 2 and not self.closed and self.playing_file == self.getPlayingFile() and not g.abort_requested()): xbmc.sleep(500) if progress_bar is not None: progress_bar.setPercent(self.calculate_percent()) if self.skip_intro_activated_time + self.skip_intro_open_time == int( self.getTime()): self.close() except: import traceback g.log_stacktrace() self.close()
def run(self): """ Executes the workload :return: :rtype: """ while not self.tasks.empty() and not self.stop_flag.is_set(): try: func, result_callback, args, kwargs = self.tasks.get( timeout=0.1) self.name = g.UNICODE(func) result_callback(func(*args, **kwargs)) except Empty: break except BaseException as ex: g.log_stacktrace() self.exception_handler(ex) break finally: try: self.tasks.task_done() except Exception as e: print("task done error: {}".format(repr(e))) pass
def get_hoster_list(): """ Fetche :return: """ thread_pool = ThreadPool() hosters = {"premium": {}, "free": []} try: if g.get_bool_setting("premiumize.enabled") and g.get_bool_setting( "premiumize.hosters"): thread_pool.put(Premiumize().get_hosters, hosters) if g.get_bool_setting("realdebrid.enabled") and g.get_bool_setting( "rd.hosters"): thread_pool.put(RealDebrid().get_hosters, hosters) if g.get_bool_setting("alldebrid.enabled") and g.get_bool_setting( "alldebrid.hosters"): thread_pool.put(AllDebrid().get_hosters, hosters) thread_pool.wait_completion() except ValueError: g.log_stacktrace() xbmcgui.Dialog().notification(g.ADDON_NAME, g.get_language_string(30513)) return hosters return hosters
def wrapper(*args, **kwarg): try: response = func(*args, **kwarg) if response.status_code in [200, 201]: return response if response.status_code == 404: g.log('FanartTv failed to find {}'.format(response.url), 'debug') return None else: g.log( 'FanartTv returned a {} ({}): while requesting {}'.format( response.status_code, FanartTv.http_codes[response.status_code], response.url), 'error') return response except requests.exceptions.ConnectionError: return None except Exception: xbmcgui.Dialog().notification( g.ADDON_NAME, g.get_language_string(30025).format('Fanart')) if g.get_runtime_setting("run.mode") == "test": raise else: g.log_stacktrace() return None
def wrapper(*args, **kwarg): try: response = func(*args, **kwarg) if response.status_code in [200, 201, 204]: return response g.log( "OMDb returned a {} ({}): while requesting {}".format( response.status_code, OMDB_STATUS_CODES[response.status_code], "&".join(x for x in response.url.split('&') if not x.lower().startswith("apikey")), ), "error", ) return None except requests.exceptions.ConnectionError as e: g.log("Connection Error to OMDb: {} - {}".format(args, kwarg), "error") g.log(e, "error") return None except Exception: xbmcgui.Dialog().notification( g.ADDON_NAME, g.get_language_string(30025).format("OMDb")) if g.get_runtime_setting("run.mode") == "test": raise else: g.log_stacktrace() return None
def _handle_bookmark(self): if g.get_runtime_setting("marked_watched_dialog_open"): return try: g.clear_kodi_bookmarks() except Exception: g.log_stacktrace() pass if self.current_time == 0 or self.total_time == 0: self.bookmark_sync.remove_bookmark(self.trakt_id) return if ( self.watched_percentage < self.playCountMinimumPercent and self.current_time >= self.ignoreSecondsAtStart and not self._force_marked_watched ): self.bookmark_sync.set_bookmark( self.trakt_id, int(self.current_time), self.mediatype, self.watched_percentage, ) else: self.bookmark_sync.remove_bookmark(self.trakt_id)
def background_tasks(self): """ Runs background watcher tasks :return: None :rtype: none """ try: try: progress_bar = self.getControlProgress(3014) except Exception: progress_bar = None while ( (int(self.player.getTotalTime()) - int(self.player.getTime())) > 1 and not self.closed and self.playing_file == self.player.getPlayingFile() and not g.abort_requested() ): xbmc.sleep(500) if progress_bar is not None: progress_bar.setPercent(self.calculate_percent()) if not self.closed: self.player.pause() except Exception: g.log_stacktrace() self.close()
def build_playlist(self, season_id=None, minimum_episode=None): """ Uses available information to add relevant episodes to the current playlist :param season_id: Trakt ID of season to build :type season_id: int :param minimum_episode: Minimum episodes to add from :type minimum_episode: int :return: :rtype: """ if season_id is None: season_id = self.item_information["info"]["trakt_season_id"] if minimum_episode is None: minimum_episode = int(self.item_information["info"]["episode"]) + 1 try: [ g.PLAYLIST.add(url=i[0], listitem=i[1]) for i in self.list_builder.episode_list_builder( self.show_trakt_id, season_id, minimum_episode=minimum_episode, smart_play=True, hide_unaired=True, ) ] except TypeError: g.log_stacktrace() g.log( "Unable to add more episodes to the playlist, they may not be available for the requested season", "error", ) return
def wrapper(*args, **kwarg): import requests try: response = func(*args, **kwarg) if response.status_code in [200, 201]: return response g.log( "TMDb returned a {} ({}): while requesting {}".format( response.status_code, TMDBAPI.http_codes[response.status_code], "&".join(x for x in response.url.split('&') if not x.lower().startswith("api_key")), ), "warning" if not response.status_code == 404 else "debug") return None except requests.exceptions.ConnectionError: return None except Exception: xbmcgui.Dialog().notification( g.ADDON_NAME, g.get_language_string(30024).format("TMDb")) if g.get_runtime_setting("run.mode") == "test": raise else: g.log_stacktrace() return None
def get_hosters(self, hosters): host_list = self.update_relevant_hosters() if host_list is not None: hosters["premium"]["all_debrid"] = [ (d, d.split(".")[0]) for l in host_list["hosts"].values() if "status" in l and l["status"] for d in l["domains"] ] else: g.log_stacktrace() hosters["premium"]["all_debrid"] = []
def doModal(self): """ Call to display window in an interactive fashion :return: None :rtype: none """ try: super(StillWatching, self).doModal() except Exception: g.log_stacktrace()
def doModal(self): """ Call to display window in an interactive fashion :return: None :rtype: none """ try: super(PlayingNext, self).doModal() except: g.log_stacktrace()
def __init__(self, xml_file, xml_location, item_information=None): try: self.player = xbmc.Player() self.playing_file = self.player.getPlayingFile() self.closed = False self.duration = self.player.getTotalTime() - self.player.getTime() super(StillWatching, self).__init__( xml_file, xml_location, item_information=item_information ) except Exception: g.log_stacktrace()
def _decorated(*args, **kwargs): method_class = args[0] for a in args[1:]: if isinstance(a, types.GeneratorType): raise UnsupportedCacheParamException("generator") for k, v in kwargs.items(): if isinstance(v, types.GeneratorType): raise UnsupportedCacheParamException("generator") if func.__name__ == "get_sources": overwrite_cache = kwargs.get("overwrite_cache", False) kwargs_cache_value = { k: v for k, v in kwargs.items() if not k == "overwrite_cache" } else: overwrite_cache = kwargs.pop("overwrite_cache", False) kwargs_cache_value = kwargs hours = kwargs.pop("cache_hours", cache_hours) global_cache_ignore = g.get_bool_runtime_setting( "ignore.cache", False) ignore_cache = kwargs.pop("ignore_cache", False) if ignore_cache or global_cache_ignore: return func(*args, **kwargs) checksum = _get_checksum(method_class.__class__.__name__, func.__name__) cache_str = "{}.{}.{}.{}".format( method_class.__class__.__name__, func.__name__, tools.md5_hash(args[1:]), tools.md5_hash(kwargs_cache_value)) cached_data = g.CACHE.get( cache_str, checksum=checksum ) if not overwrite_cache else CacheBase.NOT_CACHED if cached_data == CacheBase.NOT_CACHED: fresh_result = func(*args, **kwargs) if func.__name__ == "get_sources" and (not fresh_result or len( fresh_result[1]) == 0): return fresh_result try: g.CACHE.set( cache_str, fresh_result, expiration=datetime.timedelta(hours=hours), checksum=checksum, ) except TypeError: g.log_stacktrace() pass return fresh_result else: return cached_data
def __init__(self, xml_file, xml_location, item_information=None): try: super(PlayingNext, self).__init__( xml_file, xml_location, item_information=item_information ) self.playing_file = self.getPlayingFile() self.duration = self.getTotalTime() - self.getTime() self.closed = False self.default_action = g.get_int_setting("playingnext.defaultaction") except Exception: g.log_stacktrace()
def __init__(self, xml_file, xml_location, item_information=None): try: super(PlayingNext, self).__init__(xml_file, xml_location, item_information=item_information) self.playing_file = self.getPlayingFile() self.duration = self.getTotalTime() - self.getTime() self.closed = False except: g.log_stacktrace()
def __init__(self, xml_file, xml_location, item_information=None): try: self.player = xbmc.Player() self.playing_file = self.player.getPlayingFile() self.closed = False self.duration = 30 self.dialog_opened_time = int(self.player.getTime()) self.is_paused = False super(StillWatching, self).__init__(xml_file, xml_location, item_information=item_information) except: g.log_stacktrace()
def _premiumize_worker(self, torrent_list): try: hash_list = [i['hash'] for i in torrent_list] if len(hash_list) == 0: return premiumize_cache = premiumize.Premiumize().hash_check(hash_list) premiumize_cache = premiumize_cache['response'] count = 0 for i in torrent_list: if premiumize_cache[count] is True: i['debrid_provider'] = 'premiumize' self.store_torrent(i) count += 1 except Exception: g.log_stacktrace()
def __init__(self, xml_file, xml_location, item_information=None): try: super(SkipIntro, self).__init__(xml_file, xml_location, item_information=item_information) self.playing_file = self.getPlayingFile() self.duration = g.get_int_setting("skip.intro.open.time") self.closed = False self.skip_intro = g.get_bool_setting("skip.intro.dialog") self.skip_intro_open_time = g.get_int_setting( "skip.intro.open.time") self.skip_intro_time = g.get_int_setting("skip.intro.time") self.skip_intro_activated_time = 0 except: g.log_stacktrace()
def get_json(self, **params): response = self.get(**params) if response is None: return None try: if not response.content: return None return self._handle_response( xml_to_dict.parse(response.text).get("root", {}).get("movie")) except (ValueError, AttributeError): g.log_stacktrace() g.log( "Failed to receive JSON from OMDb response - response: {}". format(response), "error", ) return None
def _trakt_start_watching(self, offset=None, re_scrobble=False): if (not self.trakt_enabled or not self.scrobbling_enabled or (self.scrobbled and not re_scrobble) or (self.scrobble_started and not re_scrobble)): return if (self.watched_percentage >= self.playCountMinimumPercent or self.current_time < self.ignoreSecondsAtStart): return try: post_data = self._build_trakt_object(offset=offset) self._trakt_api.post("scrobble/start", post_data) except: g.log_stacktrace() self.scrobble_started = True
def download(self, request, **extra): """ Downloads requested subtitle :param request: Selected subtitle from search results :type request: dict :param extra: Kwargs, set settings to settings to request to use :type extra: dict :return: Path to subtitle :rtype: str """ try: settings = extra.pop("settings", None) return self.service.download(request, settings) except (OSError, IOError): g.log("Unable to download subtitle, file already exists", "error") except Exception as e: g.log("Unknown error acquiring subtitle: {}".format(e), "error") g.log_stacktrace()
def _realdebrid_worker(self, torrent_list, info): try: hash_list = [i['hash'] for i in torrent_list] api = real_debrid.RealDebrid() real_debrid_cache = api.check_hash(hash_list) for i in torrent_list: try: if 'rd' not in real_debrid_cache.get(i['hash'], {}): continue if len(real_debrid_cache[i['hash']]['rd']) >= 1: if self.scraper_class.media_type == 'episode': self._handle_episode_rd_worker(i, real_debrid_cache, info) else: self._handle_movie_rd_worker(i, real_debrid_cache) except KeyError: pass except Exception: g.log_stacktrace()
def wrapper(*args, **kwarg): method_class = args[0] try: response = func(*args, **kwarg) if response.status_code in [200, 201]: return response if response.status_code == 401: try: with GlobalLock("tvdb.oauth", run_once=True, check_sum=method_class.jwToken) as lock: if method_class.jwToken is not None: method_class.try_refresh_token(True) except RanOnceAlready: pass if method_class.refresh_token is not None: return func(*args, **kwarg) g.log( "TVDB returned a {} ({}): while requesting {}".format( response.status_code, TVDBAPI.http_codes[response.status_code] if not response.status_code == 404 else response.json()["Error"], response.url, ), "warning" if not response.status_code == 404 else "debug", ) return None except requests.exceptions.ConnectionError: return None except Exception: xbmcgui.Dialog().notification( g.ADDON_NAME, g.get_language_string(30025).format("TVDB")) if g.get_runtime_setting("run.mode") == "test": raise else: g.log_stacktrace() return None
def wrapper(*args, **kwarg): try: response = func(*args, **kwarg) if response.status_code in [200, 201]: return response if "Retry-After" in response.headers: # API REQUESTS Are not being throttled anymore but we leave it here for if the re-enable it again throttle_time = response.headers["Retry-After"] g.log( "TMDb Throttling Applied, Sleeping for {} seconds".format( throttle_time), "", ) xbmc.sleep((int(throttle_time) * 1000) + 1) return wrapper(*args, **kwarg) g.log( "TMDb returned a {} ({}): while requesting {}".format( response.status_code, TMDBAPI.http_codes[response.status_code], response.url, ), "warning", ) return None except requests.exceptions.ConnectionError: return None except Exception: xbmcgui.Dialog().notification( g.ADDON_NAME, g.get_language_string(30025).format("TMDb")) if g.get_global_setting("run.mode") == "test": raise else: g.log_stacktrace() return None
def _all_debrid_worker(self, torrent_list): try: api = all_debrid.AllDebrid() if len(torrent_list) == 0: return cache_check = api.check_hash([i['hash'] for i in torrent_list]) if not cache_check: return for idx, i in enumerate(torrent_list): try: if cache_check['magnets'][idx]['instant'] is True: i['debrid_provider'] = 'all_debrid' self.store_torrent(i) except KeyError: g.log('KeyError in AllDebrid Cache check worker. ' 'Failed to walk AllDebrid cache check response, check your auth and account status', 'error') return except Exception: g.log_stacktrace()
def background_tasks(self): """ Runs background watcher tasks :return: """ try: try: progress_bar = self.getControlProgress(3014) except RuntimeError: progress_bar = None while (int(self.getTotalTime()) - int(self.getTime()) > 2 and not self.closed and self.playing_file == self.getPlayingFile() and not g.abort_requested()): xbmc.sleep(500) if progress_bar is not None: progress_bar.setPercent(self.calculate_percent()) self.smart_play_action() except Exception: g.log_stacktrace() self.close()