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 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 _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 _trakt_stop_watching(self): if (not self.trakt_enabled or not self.scrobbling_enabled or self.scrobbled or g.get_runtime_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 Exception: 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 Exception: g.log_stacktrace() return else: return if not scrobble_response.status_code == 201: g.log("Error scrobbling item to Trakt")
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_download_index(self): """ Refreshes download IDS from window index :return: """ index = g.get_runtime_setting("SDMIndex") self.download_ids = [i for i in index.split(",") if i] if index is not None else []
def __init__(self): self.limiter = g.get_runtime_setting("threadpool.limiter") self.workers = self.scaled_workers[g.get_int_setting("general.threadpoolScale", -1) + 1] self.tasks = ClearableQueue(2 * self.workers) self.stop_event = threading.Event() self.results = None self.worker_pool = [] self.max_workers = 1 if self.limiter else self.workers self.exception = None self.result_threading_lock = threading.Lock() self.workers_threading_lock = threading.Lock()
def get(self, cache_id, checksum=None): cached = g.get_runtime_setting(cache_id) cur_time = self._get_timestamp() if cached: cached = pickle.loads(codecs.decode(cached.encode(), "base64")) if cached[0] > cur_time: if not checksum or checksum == cached[2]: return cached[1] else: g.clear_runtime_setting(cache_id) return self.NOT_CACHED
def get_task_info(self, url_hash): """ Takes a task hash and returns the information stored in the Window property :param url_hash: Sting :return: dict """ try: return tools.deconstruct_action_args( g.get_runtime_setting("sdm.{}".format(url_hash))) except Exception: raise TaskDoesNotExist(url_hash)
def do_cleanup(self): if self._exit or g.abort_requested(): return cur_time = datetime.datetime.utcnow() if g.get_runtime_setting(self._create_key("cache.db.clean.busy")): return g.set_runtime_setting(self._create_key("cache.db.clean.busy"), "busy") query = "DELETE FROM {} where expires < ?".format( self.cache_table_name) self.execute_sql(query, (self._get_timestamp(), )) g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), repr(cur_time)) g.clear_runtime_setting(self._create_key("cache.mem.clean.busy"))
def _mark_watched_dialog(self): if g.get_runtime_setting("marked_watched_dialog_open"): return if (self.getPlayingFile() and self._running_path and self._running_path != self.getPlayingFile() and self.watched_percentage < self.playCountMinimumPercent and (time.time() - self.playback_timestamp) > 600): xbmc.sleep(10000) g.set_runtime_setting("marked_watched_dialog_open", True) if xbmcgui.Dialog().yesno(g.ADDON_NAME, g.get_language_string(30526)): self._force_marked_watched = True g.set_runtime_setting("marked_watched_dialog_open", False)
def check_cleanup(self): """ Check if a cleanup should be run according to auto_clean_interval and process if required :return: :rtype: """ cur_time = datetime.datetime.utcnow() lastexecuted = g.get_runtime_setting( self._create_key("clean.lastexecuted")) if not lastexecuted: g.set_runtime_setting(self._create_key("clean.lastexecuted"), repr(cur_time)) elif self._cleanup_required_check(lastexecuted, cur_time): self.do_cleanup()
def do_cleanup(self): if self._exit or g.abort_requested(): return if g.get_runtime_setting(self._create_key("clean.busy")): return g.set_runtime_setting(self._create_key("clean.busy"), "busy") cur_time = datetime.datetime.utcnow() self._db_cache.do_cleanup() self._mem_cache.do_cleanup() g.set_runtime_setting(self._create_key("clean.lastexecuted"), repr(cur_time)) g.clear_runtime_setting(self._create_key("clean.busy"))
def do_cleanup(self): if self._exit or g.abort_requested(): return cur_time = datetime.datetime.utcnow() cur_timestamp = self._get_timestamp() if g.get_runtime_setting(self._create_key("cache.mem.clean.busy")): return g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), "busy") self._get_index() for cache_id, expires in self._index: if expires < cur_timestamp: g.clear_runtime_setting(cache_id) g.set_runtime_setting(self._create_key("cache.mem.clean.busy"), repr(cur_time)) g.clear_runtime_setting(self._create_key("cache.mem.clean.busy"))
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") try: global_cache_ignore = g.get_runtime_setting("ignore.cache") except Exception: global_cache_ignore = False checksum = _get_checksum(method_class.__class__.__name__, func.__name__) ignore_cache = kwargs.pop("ignore_cache", False) if ignore_cache or global_cache_ignore: return func(*args, **kwargs) overwrite_cache = kwargs.pop("overwrite_cache", False) hours = kwargs.pop("cache_hours", cache_hours) cache_str = "{}.{}.{}.{}".format(method_class.__class__.__name__, func.__name__, tools.md5_hash(args[1:]), tools.md5_hash(kwargs)) cached_data = g.CACHE.get(cache_str, checksum=checksum) if cached_data == CacheBase.NOT_CACHED or overwrite_cache: 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 _get_sort_methods(self): """ Get Seren settings for sort methods """ sort_methods = [] sort_method_settings = { 0: None, 1: self._get_quality_sort_key, 2: self._get_type_sort_key, 3: self._get_debrid_priority_key, 4: self._get_size_sort_key, 5: self._get_low_cam_sort_key, 6: self._get_hevc_sort_key, 7: self._get_hdr_sort_key, 8: self._get_audio_channels_sort_key } if self.mediatype == g.MEDIA_EPISODE and g.get_bool_setting("general.lastreleasenamepriority"): self.last_release_name = g.get_runtime_setting( "last_resolved_release_title.{}".format(self.item_information['info']['trakt_show_id']) ) if self.last_release_name: sort_methods.append((self._get_last_release_name_sort_key, False)) for i in range(1, 9): sm = g.get_int_setting("general.sortmethod.{}".format(i)) reverse = g.get_bool_setting("general.sortmethod.{}.reverse".format(i)) if sort_method_settings[sm] is None: break if sort_method_settings[sm] == self._get_type_sort_key: self._get_type_sort_order() if sort_method_settings[sm] == self._get_debrid_priority_key: self._get_debrid_sort_order() if sort_method_settings[sm] == self._get_hdr_sort_key: self._get_hdr_sort_order() sort_methods.append((sort_method_settings[sm], reverse)) self.sort_methods = sort_methods
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], "&".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_index(self): index = g.get_runtime_setting(self._index_key) if index: self._index = set(index)
def _check_ran_once_already(self): if g.get_bool_runtime_setting(self._create_key("RunOnce")) and \ g.get_runtime_setting(self._create_key("CheckSum")) == self._check_sum: g.clear_runtime_setting(self._create_key("Running")) raise RanOnceAlready("Lock name: {}, Checksum: {}".format(self._lock_name, self._check_sum))