def initialize_entry(self, setting, entry): # fix dotted id entry['id'] = entry['id'].replace('.', '_') if entry['type'] == 'bool': setattr(setting, entry['id'], ConfigYesNo(default=(entry['default'] == 'true'))) entry['setting_id'] = getattr(setting, entry['id']) elif entry['type'] == 'text': if entry['option'] == 'true': setattr(setting, entry['id'], ConfigPassword(default=entry['default'], fixed_size=False)) else: setattr(setting, entry['id'], ConfigText(default=entry['default'], fixed_size=False)) entry['setting_id'] = getattr(setting, entry['id']) elif entry['type'] == 'enum': choicelist = [(str(idx), self._get_label(e).encode('utf-8')) for idx, e in enumerate(entry['lvalues'].split("|"))] setattr(setting, entry['id'], ConfigSelection(default=entry['default'], choices=choicelist)) entry['setting_id'] = getattr(setting, entry['id']) elif entry['type'] == 'labelenum': choicelist = [(self._get_label(e).encode('utf-8'), self._get_label(e).encode('utf-8')) for e in entry['values'].split("|")] setattr(setting, entry['id'], ConfigSelection(default=entry['default'], choices=choicelist)) entry['setting_id'] = getattr(setting, entry['id']) elif entry['type'] == 'ipaddress': setattr(setting, entry['id'], ConfigIP(default=map(int, entry['default'].split('.')), auto_jump=True)) entry['setting_id'] = getattr(setting, entry['id']) elif entry['type'] == 'number': setattr(setting, entry['id'], ConfigNumber(default=int(entry['default']))) entry['setting_id'] = getattr(setting, entry['id']) else: log.error('%s cannot initialize unknown entry %s', self, entry['type'])
def close_archive_screen(self): if not config.plugins.archivCZSK.preload.getValue(): self.__addons.clear() self.__repositories.clear() ArchivCZSK.__loaded = False self.__console = None # We dont need worker thread anymore so we stop it Task.stopWorkerThread() # finally save all cfg changes - edit by shamman configfile.save() # clear tmp content by shamman filelist = [ f for f in os.listdir("/tmp") if f.endswith(".url") ] for f in filelist: try: os.remove(os.path.join('/tmp', f)) except OSError: continue filelist = [ f for f in os.listdir("/tmp") if f.endswith(".png") ] for f in filelist: try: os.remove(os.path.join('/tmp', f)) except OSError: continue shutil.rmtree("/tmp/archivCZSK", True) if config.plugins.archivCZSK.clearMemory.getValue(): try: with open("/proc/sys/vm/drop_caches", "w") as f: f.write("1") except IOError as e: log.error('cannot drop caches : %s' % str(e))
def check_commit_download(self, data, retval, extra_args): if retval == 0 and os.path.exists(os.path.join(os.path.dirname(__file__), 'commit')): self.check_addon_updates() else: log.error("commit not downloaded") log.logError("Download addons commit return failed.") self.open_archive_screen()
def play(self, session, item, mode, player_callback=None): #debug props #try: # props = "" # for property, value in vars(item).iteritems(): # props = props + ("%s : %s\n"%(property,value)) # log.logDebug(props) #except: # log.logError("iter items failed.\n%s"%traceback.format_exc()) # pass self.player = Player(session, player_callback, self) if mode in self.capabilities: if mode == 'play': try: self.player.play_item(item) except: traceback.print_exc() elif mode == 'play_and_download': try: self.play_and_download(session, item, "auto", player_callback) except: traceback.print_exc() else: log.error('Invalid playing mode - %s', str(mode))
def __setitem__(self, key, val): if key == 'path': log.error('you cannot replace AddonSysPath!') elif key == 'stdout': pass else: dict.__setitem__(self, key, val)
def setPlayItem(self, it): if not isinstance(it, PVideo): log.error("""[Player] playItem: incompatible play item %s""", str(it)) return setting.resetSettings() self.play_it = it self.playSettings = it.settings
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.error('cannot download %s update xml', self.repository.name) raise UpdateXMLVersionError()
def check_commit_download(self, data, retval, extra_args): if retval == 0: self.check_addon_updates() else: log.error("commit not downloaded") log.logError("Download addons commit return failed.") self.open_archive_screen()
def __init__(self, info_file): log.info("AddonInfo(%s) initializing.." , '/'.join(info_file.split('/')[-3:])) 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 = config.plugins.archivCZSK.tmpPath.value 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.error('%s c[C]angleog.txt cannot be decoded', self) self.changelog = u'' pass else: log.error('%s c[C]hangelog.txt file is missing', self) self.changelog = u''
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_localized_string(self, string_id): if string_id in self.current_language: return self.current_language[string_id] else: log.error( "%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 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 __init__(self, info_file): log.info("AddonInfo(%s) initializing.." , '/'.join(info_file.split('/')[-3:])) 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 = config.plugins.archivCZSK.tmpPath.value 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 except Exception: log.error('%s c[C]angleog.txt cannot be decoded', self) self.changelog = u'' pass else: log.error('%s c[C]hangelog.txt file is missing', self) self.changelog = u''
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.info("%s setting current language %s to %s", self, self.current_language_id, language_id) self.current_language_id = language_id self.current_language = self.languages[language_id] else: log.error("%s cannot set language %s, language is not available", self, language_id)
def get_info(self, info): try: atr = getattr(self.info, '%s' % info) except Exception as e: #traceback.print_exc() log.error("%s get_info cannot retrieve info - %s" % (self, str(e))) return None else: return atr
def _remove_oldest_poster_file(self): _, path = self.poster_files.pop(0) log.debug( "PosterProcessing._remove_oldest_poster_file: {0}".format(path)) try: os.unlink(path) except Exception as e: log.error( "PosterProcessing._remove_oldest_poster_file: {0}".format( str(e)))
def set_setting(self, setting_id, value): try: setting = getattr(self.main, '%s' % setting_id) except ValueError: log.error('%s cannot retrieve setting %s, Invalid setting id', self, setting_id) return False else: setting.setValue(value) setting.save() return True
def get_setting(self, setting_id): try: setting = getattr(self.main, '%s' % setting_id) except (ValueError, KeyError): log.error('%s cannot retrieve setting %s, Invalid setting id', self, setting_id) return "" else: if isinstance(setting, ConfigIP): return setting.getText() return setting.getValue()
def check_repository(repository): try: to_update = repository.check_updates() with lock: self.to_update_addons += to_update except UpdateXMLVersionError: log.error('cannot retrieve update xml for repository %s', repository) except Exception: traceback.print_exc() log.error('error when checking updates for repository %s', repository)
def _got_picture_data(self, picInfo=None): picPtr = self.picload.getData() if picPtr is not None: log.debug("PosterImageHandler._got_picture_data, success") self.poster_widget.instance.setPixmap(picPtr) self.last_decoded_url = self._decoding_url else: log.error("PosterImageHandler._got_picture_data, failed") self.last_decoded_url = None self._decoding_url = None
def parse_file(self): if not os.path.exists(self.path): return False try: self.xml_tree = ElementTree() self.xml_tree.parse(self.path) self.xml_root_element = self.xml_tree.getroot() except Exception as e: log.error("%s invalid xml file - %s, creating backup..."%(str(self), str(e))) shutil.copy2(self.path, self.path + ".bak") return False return True
def check_repository(repository): try: to_update = repository.check_updates() with lock: self.to_update_addons += to_update except UpdateXMLVersionError: log.logError('cannot retrieve update xml for repository %s'%repository) log.error('cannot retrieve update xml for repository %s', repository) except Exception: traceback.print_exc() log.logError('error when checking updates for repository %s.\n%s' %(repository, traceback.format_exc())) log.error('error when checking updates for repository %s', repository)
def createDownload(self, name, url, destination, filename=None, live=False, startCB=None, finishCB=None, stream=None, quiet=False, playDownload=False, headers=None, mode=""): log.info("Downloader.createDownload(url=%s,mode=%s"%(toString(url), mode)) #log.logDebug("Creating download\name=%s\nurl=%s\ndestination=%s\nfilename=%s\nheaders=%s\nmode=%s" % (name, url, destination, filename, headers, mode)) d = None if headers is None: headers = {} try: headers = headers.copy() except: log.logError("Copy headers for download failed, continute download.\n%s"%traceback.format_exc()) headers = {} pass from Plugins.Extensions.archivCZSK.settings import USER_AGENT headers.setdefault('User-Agent', USER_AGENT) filename, length = getFilenameAndLength(url, headers, filename) log.info("Downloader.createDownload() filename=%s, length=%s", toString(filename), length) if (((url[0:4] == 'rtmp' and mode in ('auto', 'gstreamer')) or (url[0:4] == 'http' and mode in ('auto', 'gstreamer') and isHLSUrl(url)) or (url[0:4] == 'http' and mode in ('auto', 'gstreamer') and playDownload) or (url[0:4] == 'http' and mode in ('gstreamer',))) and GST_LAUNCH is not None): d = GstDownload(url = url, name = name, destDir = destination, filename=filename, headers=headers) elif url[0:4] == 'rtmp' and mode in ('auto', 'rtmpdump'): urlList = url.split() rtmp_url = [] for url in urlList[1:]: rtmp = url.split('=', 1) rtmp_url.append(' --' + rtmp[0]) rtmp_url.append("'%s'" % rtmp[1]) url = "'%s'" % urlList[0] + ' '.join(rtmp_url) if not live: realtime = True else: realtime = False d = RTMPDownloadE2(url=url, name=name, destDir=destination, filename=filename, live=live, quiet=quiet, realtime=realtime) elif url[0:4] == 'http': if isHLSUrl(url): raise NotSupportedProtocolError('HLS') d = HTTPDownloadE2(name=name, url=url, filename=filename, destDir=destination, quiet=quiet, headers=headers) else: protocol = url.split('://')[0].upper() log.error('Downloader.createDownload() - not supported protocol %s' % toString(protocol)) raise NotSupportedProtocolError(protocol) if startCB is not None: d.onStartCB.append(startCB) if finishCB is not None: d.onFinishCB.append(finishCB) d.status = DownloadStatus(d) d.length = length or 0 return d
def open_item(self, item, *args, **kwargs): if self.is_exit(item): self.exit_item() elif self.is_root(item): self.root_item(item) else: handler = self._get_handler(item) if handler is not None: handler.open_item(item, *args, **kwargs) else: log.error("cannot open item %s, cannot found its handler" % item) self.content_screen.stopLoading() self.content_screen.showList() self.content_screen.workingFinished()
def _init_poster_dir(self): if not os.path.isdir(self.poster_dir): try: os.makedirs(self.poster_dir) except Exception: pass for filename in os.listdir(self.poster_dir): file_path = os.path.join(self.poster_dir, filename) try: if os.path.isfile(file_path) or os.path.islink(file_path): os.unlink(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path) except Exception as e: log.error('Failed to delete %s. Reason: %s' % (file_path, e))
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 load_language(self, language_id): language_dir_path = os.path.join(self._languages_dir, self.get_language_name(language_id)) language_file_path = os.path.join(language_dir_path, self._language_filename) try: el = util.load_xml(language_file_path) except Exception: log.error("%s skipping language %s"%(self, language_id)) else: language = {} strings = el.getroot() for string in strings.findall('string'): string_id = int(string.attrib.get('id')) text = string.text language[string_id] = text self.languages[language_id] = language log.debug("%s language %s was successfully loaded", (self, language_id))
def play(self, session, item, mode, player_callback=None): self.player = Player(session, player_callback, self) if mode in self.capabilities: if mode == 'play': self.handle_substitles_and_play(item) #try: # self.player.play_item(item) #except: # traceback.print_exc() elif mode == 'play_and_download': try: self.play_and_download(session, item, "auto", player_callback) except: traceback.print_exc() else: log.error('Invalid playing mode - %s', str(mode))
def resolve_dependencies(self): from Plugins.Extensions.archivCZSK.archivczsk import ArchivCZSK log.info("trying to resolve dependencies for %s", self.video_addon) for dependency in self.video_addon.requires: addon_id, version, optional = dependency['addon'], dependency[ 'version'], dependency['optional'] # checking if archivCZSK version is compatible with this plugin if addon_id == 'enigma2.archivczsk': if not util.check_version(aczsk.version, version): log.debug("archivCZSK version %s>=%s", aczsk.version, version) else: log.debug("archivCZSK version %s<=%s", aczsk.version, version) raise AddonError( _("You need to update archivCZSK at least to") + " " + version + " " + _("version")) log.info("%s requires %s addon, version %s", self.video_addon, addon_id, version) if ArchivCZSK.has_addon(addon_id): tools_addon = ArchivCZSK.get_addon(addon_id) log.info("required %s founded", tools_addon) if not util.check_version(tools_addon.version, version): log.debug("version %s>=%s", tools_addon.version, version) self._dependencies.append(tools_addon) else: log.debug("version %s<=%s", tools_addon.version, version) if not optional: log.error("cannot execute %s ", self.video_addon) raise AddonError( "Cannot execute addon %s, dependency %s version %s needs to be at least version %s" % (self.video_addon, tools_addon.id, tools_addon.version, version)) else: log.debug("skipping") continue else: log.info("required %s addon not founded", addon_id) if not optional: log.info("cannot execute %s addon", self.video_addon) raise Exception( "Cannot execute %s, missing dependency %s" % (self.video_addon, addon_id)) else: log.debug("skipping")
def load_repositories(): from engine.repository import Repository log.debug('looking for repositories in %s', settings.REPOSITORY_PATH) for repo in os.listdir(settings.REPOSITORY_PATH): repo_path = os.path.join(settings.REPOSITORY_PATH, repo) if os.path.isfile(repo_path): continue log.debug('found repository %s', repo) repo_xml = os.path.join(repo_path, 'addon.xml') try: repository = Repository(repo_xml) except Exception: traceback.print_exc() log.error('cannot load repository %s, skipping..', repo) continue else: ArchivCZSK.add_repository(repository) ArchivCZSK.__loaded = True
def remove_addon_callback(remove): if (remove): log.info("removing addon: %s" % addon.id) try: shutil.rmtree(addon.path) except Exception as e: log.error("cannot remove addon: %s" % str(e)) message = ("Unable to remove addon") self.session.open(MessageBox, message, type=MessageBox.TYPE_WARNING) log.info("addon was removed: %s" % addon.id) from Plugins.Extensions.archivCZSK.archivczsk import ArchivCZSK ArchivCZSK.remove_addon(addon) self.content_screen.workingStarted() self.content_screen.refreshList() self.content_screen.workingFinished()
def setMediaItem(self, it, seekable=True, pausable=True, idx=0): if not isinstance(it, Player.items): log.error("""[Player] setMediaItem: incompatible media item %s""", str(it)) return self.it = it if isinstance(it, PPlaylist): self.play_it = it.playlist[idx] self.playlist = it.playlist elif isinstance(it, PVideo): self.play_it = it self.playlist = [it] self.playlistName = it.name self.playSettings = self.play_it.settings self.seekable = seekable self.pausable = pausable stream = self.play_it.stream if stream: self.playDelay = int(stream.playDelay) self.playerBuffer = int(stream.playerBuffer)
def load_repositories(): from engine.repository import Repository log.debug('looking for repositories in %s', settings.REPOSITORY_PATH) for repo in os.listdir(settings.REPOSITORY_PATH): repo_path = os.path.join(settings.REPOSITORY_PATH, repo) if os.path.isfile(repo_path): continue log.debug('found repository %s', repo) repo_xml = os.path.join(repo_path, 'addon.xml') try: repository = Repository(repo_xml) except Exception: traceback.print_exc() log.error('cannot load repository %s, skipping..', repo) log.logError('Load repository %s failed, skipping...' % repo) continue else: ArchivCZSK.add_repository(repository) ArchivCZSK.__loaded = True
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.error('cannot download %s update xml', self.repository.name) raise UpdateXMLVersionError()
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 resolve_dependencies(self): from Plugins.Extensions.archivCZSK.archivczsk import ArchivCZSK log.info("trying to resolve dependencies for %s" , self.video_addon) for dependency in self.video_addon.requires: addon_id, version, optional = dependency['addon'], dependency['version'], dependency['optional'] # checking if archivCZSK version is compatible with this plugin if addon_id == 'enigma2.archivczsk': if not util.check_version(aczsk.version, version): log.debug("archivCZSK version %s>=%s" , aczsk.version, version) else: log.debug("archivCZSK version %s<=%s" , aczsk.version, version) raise AddonError(_("You need to update archivCZSK at least to") + " " + version + " " + _("version")) log.info("%s requires %s addon, version %s" , self.video_addon, addon_id, version) if ArchivCZSK.has_addon(addon_id): tools_addon = ArchivCZSK.get_addon(addon_id) log.info("required %s founded" , tools_addon) if not util.check_version(tools_addon.version, version): log.debug("version %s>=%s" , tools_addon.version, version) self._dependencies.append(tools_addon) else: log.debug("version %s<=%s" , tools_addon.version, version) if not optional: log.error("cannot execute %s " , self.video_addon) raise AddonError("Cannot execute addon %s, dependency %s version %s needs to be at least version %s" % (self.video_addon, tools_addon.id, tools_addon.version, version)) else: log.debug("skipping") continue else: log.info("required %s addon not founded" , addon_id) if not optional: log.info("cannot execute %s addon" , self.video_addon) raise Exception("Cannot execute %s, missing dependency %s" % (self.video_addon, addon_id)) else: log.debug("skipping")
elif width == 1920: RATIO = 1.5 except: pass def resize(t): return int(t*RATIO) try: fonts = json.load(settings.CUSTOM_FONTS_PATH) REGULAR_FONT = fonts['regular'] BOLD_FONT = fonts['bold'] ITALIC_FONT = fonts['italic'] except Exception as e: log.error("cannot load custom fonts - %s"%str(e)) REGULAR_FONT = "Regular"#"Ubuntu-R.ttf" BOLD_FONT = "Regular"#"Ubuntu-B.ttf" ITALIC_FONT = "Regular" #"Ubuntu-I.ttf" try: colors = json.load(settings.CUSTOM_COLORS_PATH) class Color: RED = colors['red'] GREEN = colors['green'] BLUE = colors['blue'] YELLOW = colors['yellow'] YELLOW_MILD = colors['yellow_mild'] WHITE = colors['white'] BLACK = colors['black'] GREY = colors['grey']
def createDownload(self, name, url, destination, filename=None, live=False, startCB=None, finishCB=None, stream=None, quiet=False, playDownload=False, headers=None, mode=""): log.info("Downloader.createDownload(url=%s,mode=%s" % (toString(url), mode)) #log.logDebug("Creating download\name=%s\nurl=%s\ndestination=%s\nfilename=%s\nheaders=%s\nmode=%s" % (name, url, destination, filename, headers, mode)) d = None if headers is None: headers = {} try: headers = headers.copy() except: log.logError( "Copy headers for download failed, continute download.\n%s" % traceback.format_exc()) headers = {} pass from Plugins.Extensions.archivCZSK.settings import USER_AGENT headers.setdefault('User-Agent', USER_AGENT) filename, length = getFilenameAndLength(url, headers, filename) log.info("Downloader.createDownload() filename=%s, length=%s", toString(filename), length) if (((url[0:4] == 'rtmp' and mode in ('auto', 'gstreamer')) or (url[0:4] == 'http' and mode in ('auto', 'gstreamer') and isHLSUrl(url)) or (url[0:4] == 'http' and mode in ('auto', 'gstreamer') and playDownload) or (url[0:4] == 'http' and mode in ('gstreamer', ))) and GST_LAUNCH is not None): d = GstDownload(url=url, name=name, destDir=destination, filename=filename, headers=headers) elif url[0:4] == 'rtmp' and mode in ('auto', 'rtmpdump'): urlList = url.split() rtmp_url = [] for url in urlList[1:]: rtmp = url.split('=', 1) rtmp_url.append(' --' + rtmp[0]) rtmp_url.append("'%s'" % rtmp[1]) url = "'%s'" % urlList[0] + ' '.join(rtmp_url) if not live: realtime = True else: realtime = False d = RTMPDownloadE2(url=url, name=name, destDir=destination, filename=filename, live=live, quiet=quiet, realtime=realtime) elif url[0:4] == 'http': if isHLSUrl(url): raise NotSupportedProtocolError('HLS') d = HTTPDownloadE2(name=name, url=url, filename=filename, destDir=destination, quiet=quiet, headers=headers) else: protocol = url.split('://')[0].upper() log.error( 'Downloader.createDownload() - not supported protocol %s' % toString(protocol)) raise NotSupportedProtocolError(protocol) if startCB is not None: d.onStartCB.append(startCB) if finishCB is not None: d.onFinishCB.append(finishCB) d.status = DownloadStatus(d) d.length = length or 0 return d
def get_localized_string(self, string_id): if string_id in self.current_language: return self.current_language[string_id] else: log.error("%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 __init__(self, config_file): log.debug("initializing repository from %s", config_file) pars = parser.XBMCAddonXMLParser(config_file) repo_dict = pars.parse() self.id = repo_dict['id'] self.name = repo_dict['name'] self.author = repo_dict['author'] self.version = repo_dict['version'] self.description = repo_dict['description'] # every repository should have its update xml, to check versions and update/download addons self.update_xml_url = repo_dict['repo_addons_url'] self.update_datadir_url = repo_dict['repo_datadir_url'] self.path = os.path.dirname(config_file) self.addons_path = self.path #os.path.join(self.path, "addons") # addon.xml which describes addon self.addon_xml_relpath = 'addon.xml' # icon for addon size 256x256 self.addon_icon_relpath = 'icon.png' self.addon_resources_relpath = 'resources' # default language,settings and libraries path of addon self.addon_languages_relpath = self.addon_resources_relpath + '/language' self.addon_settings_relpath = self.addon_resources_relpath + '/settings.xml' self.addon_libraries_relpath = self.addon_resources_relpath + '/lib' self._addons = {} #create updater for repository self._updater = updater.Updater( self, os.path.join(config.plugins.archivCZSK.tmpPath.value, self.id)) # load installed addons in repository for addon_dir in os.listdir(self.addons_path): addon_path = os.path.join(self.addons_path, addon_dir) if os.path.isfile(addon_path): continue addon_info = AddonInfo( os.path.join(addon_path, self.addon_xml_relpath)) if addon_info.type not in Repository.SUPPORTED_ADDONS: raise Exception( "%s '%s' addon not in supported type of addons %s " % (self, addon_info.type, Repository.SUPPORTED_ADDONS)) if addon_info.type == 'video': try: tmp = os.path.join(addon_path, addon_info.script) if not os.path.isfile(tmp): raise Exception( "Invalid addon %s. Script file missing %s" % (addon_info.name, tmp)) addon = VideoAddon(addon_info, self) except Exception: traceback.print_exc() log.logError( "Load video addon %s failed, skipping...\n%s" % (addon_dir, traceback.format_exc())) #log.error("%s cannot load video addon %s, skipping.." , self, addon_dir) continue else: archivczsk.ArchivCZSK.add_addon(addon) self.add_addon(addon) elif addon_info.type == 'tools': # load tools addons try: tools = ToolsAddon(addon_info, self) except Exception: traceback.print_exc() log.error("%s cannot load tools addon %s, skipping..", self, addon_dir) continue else: archivczsk.ArchivCZSK.add_addon(tools) self.add_addon(tools) log.debug("%s successfully loaded", self)
def __setitem__(self, key, val): if key == 'path': log.error('you cannot replace AddonSysPath!') else: dict.__setitem__(self, key, val)