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 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 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 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 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 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 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 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 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 _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 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 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 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 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 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 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 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 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 _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)
