def __init__(self, download_path, prebuffer_seconds=0, prebuffer_percent=0): self.video_player = None self.session = None self.istreamed = None # where we want to save download self.download_path = download_path # where is gstreamer downloading self.gst_download_path = None # pre-buffering self.prebuffer_percent = prebuffer_percent self.prebuffer_seconds = prebuffer_seconds self.prebufferred_seconds = 0 self.prebuffered_percent = 0 self.prebuffering = (self.prebuffer_percent != 0 or self.prebuffer_seconds != 0) # seek-limit percent self.seek_limit_percent = 2 # download/buffer state self.download_percent = 0 self.download_speed = 0 self.download_finished = False self.buffered_percent = 0 self.buffer_size = 0 self.temp_length = 0 log.debug("GstreamerDownloadController started") # register download/buffer events self.__event_tracker = None
def hideList(self): try: log.debug('hiding list') self["menu"].hide() except: log.logError("Action [hideList] failed.\n%s"%traceback.format_exc()) pass
def refreshList(self, restoreLastPosition=True): log.debug("refreshing screen of %s item" , self.parent_it.name) self.refreshing = True if restoreLastPosition: self.contentHandler.open_item(self.parent_it, position=self.getSelectedIndex()) else: self.contentHandler.open_item(self.parent_it)
def info_item(self, item, mode=None, *args, **kwargs): """opens info about item according to defined mode""" self.item = item if mode in INFO_HANDLERS and mode in self.info_modes: self._init_info(item) log.debug("%s opening info of %s", repr(self), repr(item)) INFO_HANDLERS[mode](self.session, item)
def __init__(self, addon, languages_dir): self.addon = addon self._languages_dir = languages_dir self._language_filename = 'strings.xml' self.current_language = {} self.default_language_id = 'en' self.current_language_id = 'en' self.languages = {} log.debug("initializing %s - languages", addon) if not os.path.isdir(languages_dir): log.error("%s cannot load languages, missing %s directory", self, os.path.basename(languages_dir)) return for language_dir in os.listdir(languages_dir): language_id = self.get_language_id(language_dir) if language_id is None: log.error("%s unknown language %s, you need to update Language map to use it, skipping..", self, language_dir) continue language_dir_path = os.path.join(languages_dir, language_dir) language_file_path = os.path.join(language_dir_path, self._language_filename) if os.path.isfile(language_file_path): self.languages[language_id] = None else: log.error("%s cannot find language file %s, skipping %s language..", self, language_file_path, language_dir)
def __init__(self, addon, languages_dir): self.addon = addon self._languages_dir = languages_dir self._language_filename = 'strings.xml' self.current_language = {} self.default_language_id = 'en' self.current_language_id = 'en' self.languages = {} log.debug("initializing %s - languages", addon) if not os.path.isdir(languages_dir): log.error("%s cannot load languages, missing %s directory", self, os.path.basename(languages_dir)) return for language_dir in os.listdir(languages_dir): language_id = self.get_language_id(language_dir) if language_id is None: log.error( "%s unknown language %s, you need to update Language map to use it, skipping..", self, language_dir) continue language_dir_path = os.path.join(languages_dir, language_dir) language_file_path = os.path.join(language_dir_path, self._language_filename) if os.path.isfile(language_file_path): self.languages[language_id] = None else: log.error( "%s cannot find language file %s, skipping %s language..", self, language_file_path, language_dir)
def _download_update_xml(self): """downloads update xml of repository""" # hack for https github urls # since some receivers have have problems with https if self.update_xml_url.find('{commit}') != -1: from Plugins.Extensions.archivCZSK.settings import PLUGIN_PATH try: commit = open(os.path.join(PLUGIN_PATH, 'commit')).readline()[:-1] except Exception: commit = '4ff9ac15d461a885f13125125ea501f3b12eb05d' self.update_xml_url = self.update_xml_url.replace( '{commit}', commit) if self.update_xml_url.find('https://raw.github.com') == 0: update_xml_url = self.update_xml_url.replace( 'https://raw.github.com', 'http://rawgithub.com') else: update_xml_url = self.update_xml_url try: util.download_to_file(update_xml_url, self.update_xml_file, debugfnc=log.debug) except Exception: log.debug('cannot download %s update xml', self.repository.name) raise UpdateXMLVersionError()
def remove_download(self, item): if item is not None and isinstance(item, PDownload): log.debug('removing item %s from disk' % item.name) os.remove(item.path.encode('utf-8')) else: log.info('cannot remove item %s from disk, not PDownload instance', str(item))
def download(self, item, startCB, finishCB, playDownload=False, mode="", overrideCB=None): """Downloads item PVideo itemem calls startCB when download starts and finishCB when download finishes """ quiet = False headers = item.settings['extra-headers'] log.debug("Download headers %s", headers) downloadManager = DownloadManager.getInstance() d = downloadManager.createDownload(name=item.name, url=item.url, stream=item.stream, filename=item.filename, live=item.live, destination=self.downloads_path, startCB=startCB, finishCB=finishCB, quiet=quiet, playDownload=playDownload, headers=headers, mode=mode) if item.subs is not None and item.subs != '': log.debug('subtitles link: %s', item.subs) subs_file_path = os.path.splitext(d.local)[0] + '.srt' util.download_to_file(item.subs, subs_file_path) downloadManager.addDownload(d, overrideCB)
def __del__(self): log.debug("PosterImageHandler.__del__") self.retry_timer.stop() del self.retry_timer_conn del self.retry_timer del self.picload_conn del self.picload
def _get_root_content(self): log.debug("%s getting root content", str(self)) content_provider = self.content_provider if content_provider: parent_item = PRoot() list_items = content_provider.get_content() return {'lst_items':list_items, 'parent_it':parent_item, 'index':0, 'refresh':False}
def menu_item(self, item, global_context=None, *args, **kwargs): self.item = item self.global_context = global_context self._init_menu(item) if item.context or global_context: log.debug("%s opening context menu of %s", repr(self), repr(item)) context.showContextMenu(self.session, item.name, item.thumb, item.context, global_context, self._menu_item_cb)
def removePyOC(pyfile): if os.path.isfile(pyfile + 'c'): log.debug('removing %s', (pyfile + 'c')) os.remove(pyfile + 'c') elif os.path.isfile(pyfile + 'o'): log.debug('removing %s', (pyfile + 'o')) os.remove(pyfile + 'o')
def showList(self): try: log.debug('showing list') self["menu"].show() except: log.logError("Action [showList] failed.\n%s"%traceback.format_exc()) pass
def start_video_check(self): log.debug('starting video_checking') self.check_timer.start(self.video_check_interval) self.check_timer_running = True self.download_interval_check = self.video_check_interval self.check_position()
def create_xml_item(self, item): log.logDebug("%s create xml item - %s" % (self, item)) log.debug("{0} create xml item - {1}".format(self, toString(item))) import time from datetime import datetime t = datetime.now() t1 = t.timetuple() uid = int(time.mktime(t1)) if item.id: item.id = uid #log.logDebug("%s create xml item - %s already exists, skipping"%(self,item)) #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item))) #return item_id = item.get_id() if self.find_item_by_id(item_id): item_id = uid item.id = uid #log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item)) #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item))) #return addon_id = item.addon_id xml_item = SubElement(self.xml_root_element.find('items'), 'item') xml_item.set('id', toUnicode(item_id)) xml_item.set('ctime', str(datetime.now())) if addon_id: xml_item.set('addon_id', toUnicode(addon_id)) name = SubElement(xml_item, 'name') name.text = toUnicode(item.name) params = SubElement(xml_item, 'params') for key, value in item.params.iteritems(): params.set(toUnicode(key), toUnicode(value)) item.id = item_id return xml_item
def create_xml_item(self, item): log.logDebug("%s create xml item - %s"%(self,item)) log.debug("{0} create xml item - {1}".format(self, toString(item))) import time from datetime import datetime t = datetime.now() t1 = t.timetuple() uid = int(time.mktime(t1)) if item.id: item.id = uid #log.logDebug("%s create xml item - %s already exists, skipping"%(self,item)) #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item))) #return item_id = item.get_id() if self.find_item_by_id(item_id): item_id = uid item.id = uid #log.logDebug("%s create xml item - %s already exists (2), skipping"%(self,item)) #log.debug('{0} create xml item - {1} already exists, skipping'.format(self, toString(item))) #return addon_id = item.addon_id xml_item = SubElement(self.xml_root_element.find('items'), 'item') xml_item.set('id', toUnicode(item_id)) xml_item.set('ctime', str(datetime.now())) if addon_id: xml_item.set('addon_id', toUnicode(addon_id)) name = SubElement(xml_item, 'name') name.text = toUnicode(item.name) params = SubElement(xml_item, 'params') for key, value in item.params.iteritems(): params.set(toUnicode(key), toUnicode(value)) item.id = item_id return xml_item
def load(self, params): """ Loads content of screen from params params = {'lst_items': list of GUI items which will be loaded in menulist, 'parent_it': parent item from which was this content retrieved, 'refresh' : if we want to refresh menulist from parent item, 'index' : position which will be selected in menulist after load } """ self.refresh = False self.input = None self.lst_items = params['lst_items'] self.parent_it = params['parent_it'] if params['refresh']: self.refreshList() else: log.debug("loading screen of %s item", repr(self.parent_it)) index = 'index' in params and params['index'] or 0 if self.enabled_path and not self.refreshing: self.updatePath() self.updateMenuList(index)
def _evUpdatedBufferInfo(self): if self.playAndDownload: return streamed = self.session.nav.getCurrentService().streamed() bufferInfo = getBufferInfo(streamed) if (bufferInfo['percentage'] > 95): self.bufferFull() if (bufferInfo['percentage'] == 0 and (bufferInfo['avg_in_rate'] != 0 and bufferInfo['avg_out_rate'] != 0)): self.bufferEmpty() info = { 'bitrate': 0, 'buffer_percent': bufferInfo['percentage'], 'buffer_secondsleft': bufferInfo['space'], 'buffer_size': bufferInfo['size'], 'download_speed': bufferInfo['avg_in_rate'], 'buffer_slider': 0 } log.debug( "BufferPercent %d\nAvgInRate %d\nAvgOutRate %d\nBufferingLeft %d\nBufferSize %d", bufferInfo['percentage'], bufferInfo['avg_in_rate'], bufferInfo['avg_out_rate'], bufferInfo['space'], bufferInfo['size']) self.updateInfobar(info)
def load(self, params): """ Loads content of screen from params params = {'lst_items': list of GUI items which will be loaded in menulist, 'parent_it': parent item from which was this content retrieved, 'refresh' : if we want to refresh menulist from parent item, 'index' : position which will be selected in menulist after load } """ self.refresh = False self.input = None self.lst_items = params['lst_items'] self.parent_it = params['parent_it'] if params['refresh']: self.refreshList() else: log.debug("loading screen of %s item" , repr(self.parent_it)) index = 'index' in params and params['index'] or 0 if self.enabled_path and not self.refreshing: self.updatePath() self.updateMenuList(index)
def setBufferMode(self, mode=None): if self.playAndDownload: return if mode == 3: log.debug("manual buffer control") self.useBufferControl = True
def _get_handler(self, item): for handler in self._handlers: if handler.can_handle(item): log.debug("found handler %s" % (handler)) return handler else: log.debug("%s cannot handle %s" % (handler, item))
def check_addon(self, addon, update_xml=True): """ check if addon needs update and if its broken """ try: log.debug("checking updates for %s", addon.name) self._get_server_addon(addon, update_xml) broken = self.remote_addons_dict[addon.id]['broken'] remote_version = self.remote_addons_dict[addon.id]['version'] local_version = addon.version if util.check_version(local_version, remote_version): log.logDebug("Addon '%s' need update (local %s < remote %s)." % (addon.name, local_version, remote_version)) log.debug("%s local version %s < remote version %s", addon.name, local_version, remote_version) log.debug("%s is not up to date", addon.name) return True, broken else: log.logDebug("Addon '%s' (%s) is up to date." % (addon.name, local_version)) log.debug("%s local version %s >= remote version %s", addon.name, local_version, remote_version) log.debug("%s is up to date", addon.name) return False, broken except: log.logError("Check addon '%s' update failed.\n%s" % (addon.name, traceback.format_exc())) raise
def save(self): """saves current screen to stack""" log.debug("saving current screen to stack") self.stack.append({'lst_items':self.lst_items, 'parent_it':copy.copy(self.parent_it), 'refresh':self.refresh, 'index':self["menu"].index})
def showList(self): try: log.debug("<%s>: showList"%(self.__class__.__name__)) self.__listboxRenderer.show() except: log.logError("Action [showList] failed.\n%s"%traceback.format_exc()) pass
def __init__(self, info_file): log.info("initializing info of addon from %s" , info_file) pars = parser.XBMCAddonXMLParser(info_file) addon_dict = pars.parse() self.id = addon_dict['id'] self.name = addon_dict['name'] self.version = addon_dict['version'] self.author = addon_dict['author'] self.type = addon_dict['type'] self.broken = addon_dict['broken'] self.path = os.path.dirname(info_file) self.library = addon_dict['library'] self.script = addon_dict['script'] self.tmp_path = settings.TMP_PATH self.data_path = os.path.join(config.plugins.archivCZSK.dataPath.getValue(), self.id) self.profile = self.data_path # create data_path(profile folder) util.make_path(self.data_path) if settings.LANGUAGE_SETTINGS_ID in addon_dict['description']: self.description = addon_dict['description'][settings.LANGUAGE_SETTINGS_ID] elif settings.LANGUAGE_SETTINGS_ID == 'sk' and 'cs' in addon_dict['description']: self.description = addon_dict['description']['cs'] else: if not 'en' in addon_dict['description']: self.description = u'' else: self.description = addon_dict['description']['en'] self.requires = addon_dict['requires'] self.image = os.path.join(self.path, 'icon.png') #changelog changelog_path = None if os.path.isfile(os.path.join(self.path, 'changelog.txt')): changelog_path = os.path.join(self.path, 'changelog.txt') elif os.path.isfile(os.path.join(self.path, 'Changelog.txt')): changelog_path = os.path.join(self.path, 'Changelog.txt') else: changelog_path = None if changelog_path is not None: with open(changelog_path, 'r') as f: text = f.read() try: self.changelog = text.decode('windows-1250') except Exception: log.debug('cannot decode c[C]angleog.txt') self.changelog = u'' pass else: log.debug('c[C]hangelog.txt missing') self.changelog = u''
def _resolve_video_items(self, result): def all_done(result_list): for __, (data, item) in result_list: tmp_list = [] for stream_dict in get_streams_from_manifest(item.url, data): video_item = PVideoResolved() video_item.subs = item.subs video_item.settings = item.settings.copy() video_item.url = stream_dict['url'] video_item.quality = "%s b/s" % stream_dict['bandwidth'] video_item.bandwidth = int(stream_dict['bandwidth']) if 'resolution' in stream_dict: video_item.quality = stream_dict['resolution'].split( 'x')[1] + "p" # TODO remove workaround of embedding # quality in title in addons video_item.name = name = item.name quality = video_item.quality if quality and quality not in name: if "[???]" in name: video_item.name = name.replace( "[???]", "[%s]" % (quality)) else: video_item.name = "[%s] %s" % (i.quality, i.name) tmp_list.append(video_item) tmp_list.sort(key=operator.attrgetter('bandwidth'), reverse=True) if tmp_list: log.info("%s __resolve_video_items: found %d streams" % (self, len(tmp_list))) item_list.remove(item) item_list.extend(tmp_list) return result def get_result(res, item): if isinstance(res, failure.Failure): log.error("%s _resolve_video_items: %s - %s" % (self, item.url, res.value)) else: log.debug("%s _resolve_video_items: %s - %dB" % (self, item.url, len(res))) return res, item item_list, __, __ = result video_list = [ i for i in item_list if isinstance(i, PVideoResolved) and is_hls_url(i.url) ] log.debug("%s _resolve_video_items: found %d resolvable video items" % (self, len(video_list))) d_list = [] for item in video_list: d = url_get_data_async(toString(item.url), headers=item.settings["extra-headers"], timeout=5) d.addBoth(get_result, item) d_list.append(d) return defer.DeferredList(d_list, consumeErrors=True).addCallback(all_done)
def showList(self): try: log.debug('showing list') self["menu"].show() except: log.logError("Action [showList] failed.\n%s" % traceback.format_exc()) pass
def get_localized_string(self, string_id): if string_id in self.current_language: return self.current_language[string_id] else: log.debug( "%s cannot find language id %s in %s language, returning id of language", self, string_id, self.current_language_id) return str(string_id)
def hideList(self): try: log.debug('hiding list') self["menu"].hide() except: log.logError("Action [hideList] failed.\n%s" % traceback.format_exc()) pass
def showList(self): try: log.debug("<%s>: showList" % (self.__class__.__name__)) self.__listboxRenderer.show() except: log.logError("Action [showList] failed.\n%s" % traceback.format_exc()) pass
def get_download_position(self): if self.video_length_total is None or self.download.length == 0: return None download_pts = long(float(self.download.getCurrentLength()) / float(self.download.length) * self.video_length_total) log.debug('download_time: %dh:%02dm:%02ds' , self.pts_to_hms(download_pts)) self.video_length = download_pts return download_pts
def _do_eof_internal(self, playing): log.debug('stopping timers_eof') if self.check_timer_running and hasattr(self, "check_timer"): self.check_timer.stop() if self.buffering_timer_running and hasattr(self, "buffering_timer"): self.buffering_timer.stop() log.debug('do_eof_internal') self.video_player._doEofInternal(playing)
def _prebuffer(self): if self.prebuffering: self.prebufferred_seconds += 1 self.prebuffered_percent = int( float(self.download_percent) / float(self.prebuffer_percent) * 100) log.debug("Prebuffered seconds : %ds, Prebuffered percent %d%%", self.prebufferred_second, self.prebuffered_percent)
def get_result(res, item): if isinstance(res, failure.Failure): log.error("%s _resolve_video_items: %s - %s" % (self, item.url, res.value)) else: log.debug("%s _resolve_video_items: %s - %dB" % (self, item.url, len(res))) return res, item
def get_result(res, item): if isinstance(res, failure.Failure): log.error("%s _resolve_video_items: %s - %s"%( self, item.url, res.value)) else: log.debug("%s _resolve_video_items: %s - %dB"%( self, item.url, len(res))) return res, item
def create_video_it(name, url, subs=None, image=None, infoLabels={}, menuItems={}, filename=None, live=False, stream=None, settings=None): it = PVideoResolved() it.name = toUnicode(name) it.url = toUnicode(url) if subs is not None and subs != "": it.subs = toUnicode(subs) it.image = toUnicode(image) infolabel_uni = {} for key, value in infoLabels.iteritems(): infolabel_uni[key] = toUnicode(value) if not 'Title' in infolabel_uni: infolabel_uni["Title"] = it.name it.info = infolabel_uni for key, value in menuItems.iteritems(): item_name = decode_string(key) thumb = None if isinstance(value, dict): params = value thumb = None if isinstance(value, list): thumb = value[0] params = value[1] it.add_context_menu_item(item_name, thumb=thumb, params=params) if filename is not None: it.filename = toUnicode(filename) it.live = live if stream is not None and isinstance(Stream): it.add_stream(stream) if settings is not None: if not isinstance(settings, dict): log.error("Cannot load settings %s class, it has to be dict class", settings.__class__.__name__) else: if 'user-agent' not in settings: settings['user-agent'] = "" if 'extra-headers' not in settings: settings['extra-headers'] = {} log.debug("Settings: %s", settings) it.settings = settings it.resolved = True return it
def start(self): if self.__started: log.debug("[%s] cannot start, provider is already started", self) return self.__started = True self.__paused = False for f in self.on_start: f() log.debug("[%s] started", self)
def remove_item(self, item): xml_items = self.xml_root_element.find('items') xml_item = self.find_item_by_id(item.id) if xml_item is None: log.debug('{0} remove_item - {1} not found'.format(self, toString(item))) else: xml_items.remove(xml_item) log.debug('{0} remove_item - {1} successfully removed'.format(self, toString(item))) item.id = None
def get_info(self, info): try: atr = getattr(self.info, '%s' % info) except Exception: print traceback.print_exc() log.debug("get_info cannot retrieve info") return None else: return atr
def remove_item(self, item): xml_items = self.xml_root_element.find('items') xml_item = self.find_item_by_id(item.id) if xml_item is None: log.debug('{0} remove_item - {1} not found'.format(self, item)) else: xml_items.remove(xml_item) log.debug('{0} remove_item - {1} successfully removed'.format(self, item)) item.id = None
def set_language(self, language_id): if self.has_language(language_id): if self.languages[language_id] is None: self.load_language(language_id) log.debug("setting current language %s to %s", self.current_language_id, language_id) self.current_language_id = language_id self.current_language = self.languages[language_id] else: log.debug("%s cannot set language %s, language is not available", self, language_id)
def update_addons(self, addons): """update addons in repository, according to their state""" log.debug('updating addons') update_success = [] for addon in addons: if addon.need_update(): if addon.update(): update_success.append(update_success) return update_success
def stop(self): if not self.__started: log.debug("[%s] cannot stop, provider is already stopped", self) return self.__started = False self.__paused = False for f in self.on_stop: f() log.debug("[%s] stopped", self)
def save(self): """saves current screen to stack""" log.debug("saving current screen to stack") self.old_stack_len = len(self.stack) self.stack.append({'lst_items':self.lst_items, 'parent_it':copy.copy(self.parent_it), 'refresh':self.refresh, 'index':self["menu"].index})
def __ev_updated_download_status(self): if self.istreamed is None: return info = getBufferInfo(self.istreamed) self.download_speed = info['avg_in_rate'] self.download_percent = info['download_percent'] self.buffered_percent = info['percentage'] self.buffer_size = info['size'] log.debug('download_percent: %d, buffer_size %lu', self.download_percent, self.buffer_size) self._update()
def get_setting(self, setting_id): try: setting = getattr(self.main, '%s' % setting_id) except (ValueError, KeyError): log.debug('%s cannot retrieve setting %s, Invalid setting id', self, setting_id) return "" else: if isinstance(setting, ConfigIP): return setting.getText() return setting.getValue()
def set_setting(self, setting_id, value): try: setting = getattr(self.main, '%s' % setting_id) except ValueError: log.debug('%s cannot retrieve setting %s, Invalid setting id', self, setting_id) return False else: setting.setValue(value) setting.save() return True
def resolveCommand(self, command, arg): print arg log.debug("resolving %s command " , str(command)) if command is None: pass elif command == 'refreshnow': self.refreshList() else: log.debug("unknown command %s" , command)
def toggleCancelLoading(self): if Task.getInstance() is not None and not Task.getInstance().isCancelling(): self["status_label"].setText("Canceling...") Task.getInstance().setCancel() elif Task.getInstance() is not None and Task.getInstance().isCancelling(): self["status_label"].setText("Loading...") Task.getInstance().setResume() else: log.debug("Task is not running")
def _exit_video_player(self): log.debug('stopping timers_exit') if self.check_timer_running: self.check_timer.stop() if self.buffering_timer_running: self.buffering_timer.stop() del self.check_timer del self.buffering_timer log.debug('exiting service') self.video_player._exitVideoPlayer()