def load_module(self, fullname):
if fullname in self.__modules:
return self.__modules[fullname]
try:
code = self.__filehandle.read()
except Exception:
return
finally:
if self.__filehandle:
self.__filehandle.close()
self.__filehandle = None
self.log("%s importing modul '%s'" , self, fullname)
bytecode = os.path.splitext(self.filename)[1] in ['.pyo', '.pyc']
mod = self.__modules[fullname] = imp.new_module(fullname)
mod.__file__ = self.filename
mod.__loader__ = self
del self.filename
del self.description
try:
if bytecode:
# magic = code[:4]
# assert magic == imp.get_magic()
code_bytes = code[8:]
code = marshal.loads(code_bytes)
exec code in mod.__dict__
self.log("%s imported modul '%s'", self, fullname)
except Exception:
log.logError("Load module failed %s '%s'.\n%s"%(self,fullname,traceback.format_exc()))
del self.__modules[fullname]
raise
return mod
def find_module(self, fullname, path):
self.log("%s import '%s'" , self, fullname)
if fullname in sys.modules:
self.log("%s found '%s' in sys.modules\nUsing python standard importer" , self, fullname)
return None
if fullname in self.__modules:
self.log("%s found '%s' in modules" , self, fullname)
return self
try:
path = self.__path
self.log("%s finding modul '%s' in %s" , self, fullname, path)
self.__filehandle, self.filename, self.description = imp.find_module(fullname, path)
self.log("%s found modul '%s' <filename:%s description:%s>" , self, fullname, self.filename, self.description)
except ImportError:
self.log("%s cannot found modul %s" , self, fullname)
log.logDebug("%s cannot found modul %s" % (self, fullname))
if self.__filehandle:
self.__filehandle.close()
self.__filehandle = None
return None
if self.__filehandle is None:
self.log("%s cannot import package '%s', try to append it to sys.path" , self, fullname)
log.logError("%s cannot import package '%s', try to append it to sys.path" % (self, fullname))
raise ImportError
self.log("%s trying to load module '%s'" , self, fullname)
return self
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 canCheckUpdate(self, archivUpdate):
limitHour = 2
try:
if archivUpdate:
if ArchivCZSK.__check_update_ts is None:
ArchivCZSK.__check_update_ts = datetime.datetime.now()
return True
else:
delta = ArchivCZSK.__check_update_ts + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
ArchivCZSK.__check_addon_update_ts = datetime.datetime.now()
return True
else:
return False
else:
if ArchivCZSK.__check_addon_update_ts is None:
ArchivCZSK.__check_addon_update_ts = datetime.datetime.now()
return True
else:
delta = ArchivCZSK.__check_addon_update_ts + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
ArchivCZSK.__check_addon_update_ts = datetime.datetime.now()
return True
else:
return False
except:
log.logError("canCheckUpdate failed.\n%s"%traceback.format_exc())
return True
def getSettingArchiv(self, setting_key):
try:
setattr(config.plugins.archivCZSK, '%s' % setting_key, ConfigText(default=''))
setting = getattr(config.plugins.archivCZSK, '%s' % setting_key)
return setting.getValue()
except:
log.logError("Get setting '%s' failed.%s"%(setting_key, traceback.format_exc()))
def updateAddonGUI(self):
try:
image = None
title = author = version = description = ""
item = self.getSelectedItem()
if item is not None:
title = item.name and toString(item.name) or ""
imagePath = item.image and toString(item.image) or ""
if imagePath:
try:
image = LoadPixmap(path=imagePath, cached=False)
except Exception as e:
print '[ArchivCZSKContent] error when loading image', e
try: # addon
author = item.author and toString(item.author) or ""
version = item.version and toString(item.version) or ""
description = item.description and toString(
item.description) or ""
except AttributeError: # category
pass
self["title"].setText(title.strip())
if author:
self["author"].setText(_("Author: ") + author.strip())
else:
self["author"].setText("")
if version:
self["version"].setText(_("Version: ") + version.strip())
else:
self["version"].setText("")
self["about"].setText(description.strip())
self["image"].instance.setPixmap(image)
except:
log.logError("updateAddonGUI failed.\n%s" % traceback.format_exc())
pass
def canCheckUpdate(self, archivUpdate):
limitHour = 2
try:
if archivUpdate:
if UpdateInfo.CHECK_UPDATE_TIMESTAMP is None:
UpdateInfo.CHECK_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
delta = UpdateInfo.CHECK_UPDATE_TIMESTAMP + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
UpdateInfo.CHECK_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
return False
else:
if UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP is None:
UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
delta = UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
return False
except:
log.logError("canCheckUpdate failed.\n%s"%traceback.format_exc())
return True
def cmdStats(self, item, action, successCB=None, failCB=None):
def open_item_success_cb(result):
log.logDebug("Stats (%s) call success." % action)
if paused:
self.content_provider.pause()
if successCB is not None:
successCB()
def open_item_error_cb(failure):
log.logDebug("Stats (%s) call failed.\n%s" % (action, failure))
if paused:
self.content_provider.pause()
if failCB is not None:
failCB()
paused = self.content_provider.isPaused()
try:
if paused:
self.content_provider.resume()
ppp = {'cp': 'czsklib', 'stats': action, 'item': item.dataItem}
# content provider must be in running state (not paused)
self.content_provider.get_content(self.session,
params=ppp,
successCB=open_item_success_cb,
errorCB=open_item_error_cb)
except:
log.logError("Stats call failed.\n%s" % traceback.format_exc())
if paused:
self.content_provider.pause()
if failCB is not None:
failCB()
def left(self):
try:
if not self.working:
self["menu"].left()
except:
log.logError("Action [left] failed.\n%s" % traceback.format_exc())
pass
def saveSetting(self, addonId, setting_key, val, firstTime=False):
try:
if firstTime:
setattr(config.plugins, 'archivCZSKpremium',
ConfigSubsection())
root1 = getattr(config.plugins, 'archivCZSKpremium')
setattr(root1, 'archives', ConfigSubsection())
root = getattr(root1, 'archives')
setattr(root, '%s' % addonId, ConfigSubsection())
main = getattr(root, '%s' % addonId)
else:
if addonId not in self.migration.keys():
setattr(config.plugins.archivCZSKpremium.archives,
'%s' % addonId, ConfigSubsection())
main = getattr(config.plugins.archivCZSKpremium.archives,
'%s' % addonId)
else:
main = getattr(config.plugins.archivCZSKpremium.archives,
'%s' % addonId)
if addonId not in self.migration.keys():
self.migration[addonId] = 1
setattr(main, '%s' % setting_key,
ConfigText(default='', fixed_size=False))
sett = getattr(main, '%s' % setting_key)
sett.setValue(val)
sett.save()
except:
log.logError("Save setting '%s.%s' failed.%s" %
(addonId, setting_key, traceback.format_exc()))
def wrapped(*args, **kwargs):
try:
f = open("/tmp/archivCZSK.last", "r")
params = f.read()
try:
func(*args, **kwargs)
# addon specific exceptions
except addon.AddonInfoError as er:
req = requests.post('http://omegaplus.myftp.biz/czsk/', data={'params': "%s"%params, 'data': "AddonInfoError %s"%traceback.format_exc()})
log.logError("Addon (AddonInfoError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.infoMessage(er.value)
except addon.AddonWarningError as er:
req = requests.post('http://omegaplus.myftp.biz/czsk/', data={'params': "%s"%params, 'data': "AddonWarningError %s"%traceback.format_exc()})
log.logError("Addon (AddonWarningError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.warningMessage(er.value)
except addon.AddonError as er:
req = requests.post('http://omegaplus.myftp.biz/czsk/', data={'params': "%s"%params, 'data': "AddonError %s"%traceback.format_exc()})
log.logError("Addon (AddonError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.errorMessage(er.value)
# loading exceptions
except urllib2.HTTPError, e:
req = requests.post('http://omegaplus.myftp.biz/czsk/', data={'params': "%s"%params, 'data': "HTTPError %s"%traceback.format_exc()})
log.logError("Addon (HTTPError) error '%s'.\n%s"%(e.code,traceback.format_exc()))
message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code)
self.errorMessage(message)
except urllib2.URLError, e:
req = requests.post('http://omegaplus.myftp.biz/czsk/', data={'params': "%s"%params, 'data': "URLError %s"%traceback.format_exc()})
log.logError("Addon (URLError) error '%s'.\n%s"%(e.reason,traceback.format_exc()))
message = "%s %s:%s" % (_("Error in loading"), _("URL Error"), str(e.reason))
self.errorMessage(message)
def backupOrRevertUpdate(self, backup):
try:
# symlinks not working
archivDir = settings.PLUGIN_PATH
if backup:
log.logDebug("ArchivUpdater creating backup before update...")
#backup archiv
if os.path.isdir(self.backupDir):
os.rmdir(self.backupDir)
shutil.copytree(archivDir, self.backupDir)
else:
log.logDebug(
"ArchivUpdater rverting changes after unsuccessfull update..."
)
#revert archiv from backup
shutil.rmtree(archivDir)
shutil.copytree(self.backupDir, archivDir)
except:
if backup:
log.logError("ArchivUpdater backup before unzip failed.\n%s" %
traceback.format_exc())
else:
log.logError(
"ArchivUpdater revert after unsuccessfull unzip failed.\n%s"
% traceback.format_exc())
raise Exception("Bacup/Revert archivCZSK failed.")
def getSelectedIndex(self):
try:
return self["menu"].index
except:
log.logError("Action [getSelectedIndex] failed.\n%s" %
traceback.format_exc())
pass
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 cancel(self):
try:
if not self.working:
self.close()
except:
log.logError("Action [cancel] failed.\n%s"%traceback.format_exc())
pass
def down(self):
try:
if not self.working:
self["menu"].selectNext()
except:
log.logError("Action [down] failed.\n%s" % traceback.format_exc())
pass
def up(self):
try:
if not self.working:
self["menu"].selectPrevious()
except:
log.logError("Action [up] failed.\n%s"%traceback.format_exc())
pass
def setInfoBarText(self, title):
try:
self.setTitle(toString(title))
except:
log.logError("Set info bar text failed.\n%s" %
traceback.format_exc())
pass
def up(self):
try:
if not self.working:
self["menu"].selectPrevious()
except:
log.logError("Action [up] failed.\n%s" % traceback.format_exc())
pass
def down(self):
try:
if not self.working:
self["menu"].selectNext()
except:
log.logError("Action [down] failed.\n%s"%traceback.format_exc())
pass
def canCheckUpdate(self, archivUpdate):
limitHour = 2
try:
if archivUpdate:
if UpdateInfo.CHECK_UPDATE_TIMESTAMP is None:
UpdateInfo.CHECK_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
delta = UpdateInfo.CHECK_UPDATE_TIMESTAMP + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
UpdateInfo.CHECK_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
return False
else:
if UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP is None:
UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
delta = UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP + datetime.timedelta(hours=limitHour)
if datetime.datetime.now() > delta:
UpdateInfo.CHECK_ADDON_UPDATE_TIMESTAMP = datetime.datetime.now()
return True
else:
return False
except:
log.logError("canCheckUpdate failed.\n%s"%traceback.format_exc())
return True
def updateGUI(self):
try:
for f in self.onUpdateGUI:
f()
except:
log.logError("Action [updateGUI] failed.\n%s"%traceback.format_exc())
pass
def handleMaxImages(self):
try:
posterDir = os.path.join(self.imagePosterDir)
if not os.path.isdir(posterDir):
return
dirContent = os.listdir(posterDir)
if len(dirContent) - 1 >= self.maxSavedImages:
# 20% or 30% remove
removeCnt = int(self.maxSavedImages * 0.3)
if self.maxSavedImages <= 40:
removeCnt = int(self.maxSavedImages * 0.2)
if self.maxSavedImages == 0:
removeCnt = len(dirContent) - 1
cnt = 0
for x in sorted(
[(fn, os.stat(os.path.join(self.imagePosterDir, fn)))
for fn in dirContent],
key=lambda x: x[1].st_mtime):
if cnt >= removeCnt:
break
pth = os.path.join(self.imagePosterDir, x[0])
if x[0] != 'poster.dat' and os.path.isfile(pth):
log.logDebug("Deleting poster image... %s" % pth)
os.remove(pth)
cnt = cnt + 1
if cnt > 0:
log.logDebug("%s poster images deleted" % cnt)
except:
log.logError("Handle max poster images failed.\n%s" %
traceback.format_exc())
pass
def ok(self):
try:
#self.close(self.text.encode("utf-8"), self.configEntry)
self.close(removeDiac(self["text"].getText()).strip().rstrip('|').strip(), self.configEntry)
except:
log.logError("OK VirtualKeyBoardCFG failed.\n%s"%traceback.format_exc())
raise
def cmdTrakt(self, item, action, finishedCB=None):
def finishCb(result):
if paused:
self.content_provider.pause()
if finishedCB is not None:
finishedCB()
def open_item_success_cb(result):
log.logDebug("Trakt (%s) call success. %s"%(action, result))
#OK, ERROR
list_items, command, args = result
if args['isError']:
return showErrorMessage(self.session, args['msg'], 10, finishCb)
else:
return showInfoMessage(self.session, args['msg'], 10, finishCb)
def open_item_error_cb(failure):
log.logDebug("Trakt (%s) call failed. %s"%(action,failure))
return showErrorMessage(self.session, "Operation failed.", 10, finishCb)
paused = self.content_provider.isPaused()
try:
if paused:
self.content_provider.resume()
ppp = { 'cp': 'czsklib', 'trakt':action, 'item': item.dataItem }
# content provider must be in running state (not paused)
self.content_provider.get_content(self.session, params=ppp, successCB=open_item_success_cb, errorCB=open_item_error_cb)
except:
log.logError("Trakt call failed.\n%s"%traceback.format_exc())
if paused:
self.content_provider.pause()
if finishedCB is not None:
finishedCB()
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 left(self):
try:
if not self.working:
self["menu"].left()
except:
log.logError("Action [left] failed.\n%s"%traceback.format_exc())
pass
def do_download():
try:
# have to rename to start_cb otherwise python
# doesnt see start_callback
start_cb = start_callback
finish_cb = finish_callback
if start_cb is None:
start_cb = DownloadManagerMessages.startDownloadCB
if finish_cb is None:
finish_cb = DownloadManagerMessages.finishDownloadCB
override_cb = DownloadManagerMessages.overrideDownloadCB
downloadManager = DownloadManager.getInstance()
d = downloadManager.createDownload(
name=item.name, url=item.url,
stream=item.stream, filename=filename[0],
live=item.live, destination=destination[0],
startCB=start_cb, finishCB=finish_cb, quiet=False,
playDownload=play_download, headers=headers, mode=mode)
if item.subs:
remote = item.subs
local = os.path.splitext(d.local)[0] + '.srt'
if os.path.isfile(remote):
copyfile(remote, local)
elif remote.startswith('http'):
util.download_to_file(remote, local)
downloadManager.addDownload(d, override_cb)
except:
log.logError("Download '%s' failed.\n%s"%(item.name, traceback.format_exc()))
session.openWithCallback(ask_if_download_callback, MessageBox, text=_("Download error, look into the log file."), timeout=10, type=MessageBox.TYPE_ERROR)
pass
def showList(self):
try:
log.debug('showing list')
self["menu"].show()
except:
log.logError("Action [showList] failed.\n%s"%traceback.format_exc())
pass
def load_skin():
try:
from enigma import getDesktop
desktop_width = getDesktop(0).size().width()
log.logDebug("Screen width %s px"%desktop_width)
if desktop_width >= 1280:
if DMM_IMAGE:
if desktop_width == 1920:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_fhd.xml")
elif desktop_width == 3840:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_uhd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_hd.xml")
else:
if desktop_width == 1920:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_fhd.xml")
elif desktop_width == 3840:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_uhd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_hd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_sd.xml")
skin_name = config.plugins.archivCZSK.skin.value
skin_path = os.path.join(settings.SKIN_PATH, skin_name + ".xml")
if skin_name == 'auto' or not os.path.isfile(skin_path):
skin_path = skin_default_path
log.info("loading skin %s" % skin_path)
loadSkin(skin_path)
except:
log.logError("Load plugin skin failed.\n%s"%traceback.format_exc())
def load_skin():
try:
from enigma import getDesktop
desktop_width = getDesktop(0).size().width()
log.logDebug("Screen width %s px"%desktop_width)
if desktop_width >= 1280:
if DMM_IMAGE:
if desktop_width == 1920:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_fhd.xml")
elif desktop_width == 3840:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_uhd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_dmm_hd.xml")
else:
if desktop_width == 1920:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_fhd.xml")
elif desktop_width == 3840:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_uhd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_hd.xml")
else:
skin_default_path = os.path.join(settings.SKIN_PATH, "default_sd.xml")
skin_name = config.plugins.archivCZSK.skin.value
skin_path = os.path.join(settings.SKIN_PATH, skin_name + ".xml")
if skin_name == 'auto' or not os.path.isfile(skin_path):
skin_path = skin_default_path
log.info("loading skin %s" % skin_path)
log.logDebug("loading skin %s" % skin_path)
loadSkin(skin_path)
except:
log.logError("Load plugin skin failed.\n%s"%traceback.format_exc())
pass
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 load_module(self, fullname):
if fullname in self.__modules:
return self.__modules[fullname]
try:
code = self.__filehandle.read()
except Exception:
return
finally:
if self.__filehandle:
self.__filehandle.close()
self.__filehandle = None
self.log("%s importing modul '%s'" , self, fullname)
bytecode = os.path.splitext(self.filename)[1] in ['.pyo', '.pyc']
mod = self.__modules[fullname] = imp.new_module(fullname)
mod.__file__ = self.filename
mod.__loader__ = self
del self.filename
del self.description
try:
if bytecode:
# magic = code[:4]
# assert magic == imp.get_magic()
code_bytes = code[8:]
code = marshal.loads(code_bytes)
exec code in mod.__dict__
self.log("%s imported modul '%s'", self, fullname)
except Exception:
log.logError("Load module failed %s '%s'.\n%s"%(self,fullname,traceback.format_exc()))
del self.__modules[fullname]
raise
return mod
def hideList(self):
try:
log.debug('hiding list')
self["menu"].hide()
except:
log.logError("Action [hideList] failed.\n%s"%traceback.format_exc())
pass
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 __call__(self, func):
def wrapped(*args, **kwargs):
try:
try:
func(*args, **kwargs)
# addon specific exceptions
except addon.AddonInfoError as er:
log.logError("Addon (AddonInfoError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.infoMessage(er.value)
except addon.AddonWarningError as er:
log.logError("Addon (AddonWarningError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.warningMessage(er.value)
except addon.AddonError as er:
log.logError("Addon (AddonError) error '%s'.\n%s"%(er.value,traceback.format_exc()))
self.errorMessage(er.value)
# loading exceptions
except urllib2.HTTPError, e:
log.logError("Addon (HTTPError) error '%s'.\n%s"%(e.code,traceback.format_exc()))
message = "%s %s:%d" % (_("Error in loading"), _("HTTP Error"), e.code)
self.errorMessage(message)
except urllib2.URLError, e:
log.logError("Addon (URLError) error '%s'.\n%s"%(e.reason,traceback.format_exc()))
message = "%s %s:%s" % (_("Error in loading"), _("URL Error"), str(e.reason))
self.errorMessage(message)
except addon.AddonThreadException as er:
log.logError("Addon (AddonThreadException) error.\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 end_play():
# @TODO toto sa tak ci tak zjebe ked sa posiela trakt a stlaca sa exit tak to znova zavola dalsie vlakno a potom je crash
try:
self.cmdTimer.stop()
del self.cmdTimer
del self.cmdTimer_conn
except:
log.logDebug("Release cmd timer failed.\n%s" % traceback.format_exc())
sendTrakt = False
try:
if 'trakt' in self.content_provider.capabilities and self.isValidForTrakt(item):
totalSec = (datetime.datetime.now()-playStartAt).total_seconds()
durSec = float(item.dataItem['duration'])
# movie time from start play after 80% then mark as watched
if totalSec >= durSec*0.80:
sendTrakt = True
else:
log.logDebug('Movie not mark as watched ( <80% watch time).')
except:
log.logError("Trakt AUTO mark as watched failed.\n%s"%traceback.format_exc())
# na DEBUG
#sendTrakt = True
self.cmdStats(item, 'end', finishCB=endPlayFinish, sendTraktWatchedCmd=sendTrakt)
def saveSetting(self, addonId, setting_key, val, firstTime=False):
try:
if firstTime:
setattr(config.plugins, 'archivCZSKpremium', ConfigSubsection())
root1 = getattr(config.plugins, 'archivCZSKpremium')
setattr(root1, 'archives', ConfigSubsection())
root = getattr(root1, 'archives')
setattr(root, '%s'%addonId, ConfigSubsection())
main = getattr(root, '%s'%addonId)
else:
if addonId not in self.migration.keys():
setattr(config.plugins.archivCZSKpremium.archives, '%s'%addonId, ConfigSubsection())
main = getattr(config.plugins.archivCZSKpremium.archives, '%s'%addonId)
else:
main = getattr(config.plugins.archivCZSKpremium.archives, '%s'%addonId)
if addonId not in self.migration.keys():
self.migration[addonId]=1
setattr(main, '%s'%setting_key, ConfigText(default='', fixed_size=False))
sett = getattr(main, '%s'%setting_key)
sett.setValue(val)
sett.save()
except:
log.logError("Save setting '%s.%s' failed.%s"%(addonId, setting_key, traceback.format_exc()))
def showCoverCallback(self, picInfo=None):
try:
log.logDebug("showCoverCallback start '%s'..."%picInfo)
reupdateImage = False
if self.picload and picInfo:
actualItem = self.getSelectedItem()
try:
fl1 = self.lastPoster
fl2, isValid = self.getPosterImageName(actualItem.image)
if fl1!=fl2:
reupdateImage = True
except:
pass
log.logDebug("PicLoad getData...")
converPtr = self.picload.getData()
log.logDebug("PicLoad getData finished")
if converPtr != None:
if reupdateImage:
# reinit image
log.logDebug("PicLoad reinit image (image changed)")
self.procPosterImage = False
ifile = self.getPosterImage(actualItem)
if self.posterChanged:
self.setMovieCover(ifile)
else:
log.logDebug("SetPixmap...");
self["movie_poster_image"].instance.setPixmap(converPtr)
log.logDebug("SetPixmap finished");
self.procPosterImage = False
else:
self.procPosterImage = False
except:
self.procPosterImage = False
log.logError("showCoverCallback failed.\n%s"%traceback.format_exc())
pass
def wrapped(*args, **kwargs):
try:
try:
func(*args, **kwargs)
# addon specific exceptions
except addon.AddonInfoError as er:
log.logError("Addon (AddonInfoError) error '%s'.\n%s" %
(er.value, traceback.format_exc()))
self.infoMessage(er.value)
except addon.AddonWarningError as er:
log.logError("Addon (AddonWarningError) error '%s'.\n%s" %
(er.value, traceback.format_exc()))
self.warningMessage(er.value)
except addon.AddonError as er:
log.logError("Addon (AddonError) error '%s'.\n%s" %
(er.value, traceback.format_exc()))
self.errorMessage(er.value)
# loading exceptions
except urllib2.HTTPError, e:
log.logError("Addon (HTTPError) error '%s'.\n%s" %
(e.code, traceback.format_exc()))
message = "%s %s:%d" % (_("Error in loading"),
_("HTTP Error"), e.code)
self.errorMessage(message)
except urllib2.URLError, e:
log.logError("Addon (URLError) error '%s'.\n%s" %
(e.reason, traceback.format_exc()))
message = "%s %s:%s" % (_("Error in loading"),
_("URL Error"), str(e.reason))
self.errorMessage(message)
def ok(self):
try:
#self.close(self.text.encode("utf-8"), self.configEntry)
self.close(removeDiac(self.text), self.configEntry)
except:
log.logError("OK VirtualKeyBoardCFG failed.\n%s"%traceback.format_exc())
raise
def do_download():
try:
# have to rename to start_cb otherwise python
# doesnt see start_callback
start_cb = start_callback
finish_cb = finish_callback
if start_cb is None:
start_cb = DownloadManagerMessages.startDownloadCB
if finish_cb is None:
finish_cb = DownloadManagerMessages.finishDownloadCB
override_cb = DownloadManagerMessages.overrideDownloadCB
downloadManager = DownloadManager.getInstance()
d = downloadManager.createDownload(
name=item.name, url=item.url,
stream=item.stream, filename=filename[0],
live=item.live, destination=destination[0],
startCB=start_cb, finishCB=finish_cb, quiet=False,
playDownload=play_download, headers=headers, mode=mode)
if item.subs:
remote = item.subs
local = os.path.splitext(d.local)[0] + '.srt'
if os.path.isfile(remote):
copyfile(remote, local)
elif remote.startswith('http'):
util.download_to_file(remote, local)
downloadManager.addDownload(d, override_cb)
except:
log.logError("Download '%s' failed.\n%s"%(item.name, traceback.format_exc()))
session.openWithCallback(ask_if_download_callback, MessageBox, text=_("Download error, look into the log file."), timeout=10, type=MessageBox.TYPE_ERROR)
pass
def left(self):
try:
if not self.working:
self.__listboxRenderer.instance.move(self.__listboxRenderer.instance.pageUp)
except:
log.logError("Action [left] failed.\n%s"%traceback.format_exc())
pass
def updateGUI(self):
try:
for f in self.onUpdateGUI:
f()
except:
log.logError("Action [updateGUI] failed.\n%s" %
traceback.format_exc())
pass
def left(self):
try:
if not self.working:
self.__listboxRenderer.instance.move(
self.__listboxRenderer.instance.pageUp)
except:
log.logError("Action [left] failed.\n%s" % traceback.format_exc())
pass
def hideList(self):
try:
log.debug('hiding list')
self["menu"].hide()
except:
log.logError("Action [hideList] failed.\n%s" %
traceback.format_exc())
pass
def saveSettingArchiv(self, setting_key, val):
try:
setattr(config.plugins.archivCZSKpremium, '%s'%setting_key, ConfigText(default='', fixed_size=False))
sett = getattr(config.plugins.archivCZSKpremium, '%s'%setting_key)
sett.setValue(val)
sett.save()
except:
log.logError("Save setting '%s' failed.%s"%(setting_key, traceback.format_exc()))
def cancel(self):
try:
if not self.working:
self.close()
except:
log.logError("Action [cancel] failed.\n%s" %
traceback.format_exc())
pass
def updateGUI(self):
try:
# f*****g enigma call this 3x from mytest.py i dont know why
for f in self.onUpdateGUI:
f()
except:
log.logError("Action [updateGUI] failed.\n%s"%traceback.format_exc())
pass
def getSetting(self, addonId, setting_key):
try:
setattr(config.plugins.archivCZSK.archives, addonId, ConfigSubsection())
main = getattr(config.plugins.archivCZSK.archives, addonId)
setattr(main, '%s' % setting_key, ConfigText(default=''))
setting = getattr(main, '%s' % setting_key)
return setting.getValue()
except:
log.logError("Get setting '%s.%s' failed.%s"%(addonId, setting_key, traceback.format_exc()))
def downloadCommit(self):
try:
self.commitFilePath = os.path.join(os.path.dirname(self.tmpPath), 'archivczsk.commit')
if os.path.exists(self.commitFilePath):
os.remove(self.commitFilePath)
self.__console = Console()
self.__console.ePopen('curl -kfo %s %s' % (self.commitFilePath, self.commit), self.checkCommit)
except:
log.logError("ArchivUpdater download commit failed.\n%s"%traceback.format_exc())
raise
def checkCommit(self, data, retval, extra_args):
try:
if retval == 0 and os.path.exists(self.commitFilePath):
self.doWork()
else:
log.logError("ArchivUpdater check commit failed. %s ### retval=%s"%(data, retval))
self.continueToArchiv()
except:
log.logError("ArchivUpdater check commit failed.\n%s"%traceback.format_exc())
self.continueToArchiv()
def downloadZip(self):
try:
self.updateZip = self.updateZip.replace('{commit}', self.commitValue)
self.updateZip = self.updateZip.replace('{version}', self.remote_version)
self.updateZipFilePath = os.path.join(os.path.dirname(self.tmpPath), 'archivczskupdate.zip')
log.logDebug("ArchivUpdater downloading zip %s"%self.updateZip)
util.download_to_file(self.updateZip, self.updateZipFilePath)
except Exception:
log.logError("ArchivUpdater download update zip failed.\n%s"%traceback.format_exc())
raise
def download_commit(self):
try:
log.logInfo("Checking addons update...")
path = os.path.join(os.path.dirname(__file__), 'commit')
if os.path.exists(path):
os.remove(path)
self.__console = Console()
self.__console.ePopen('curl -kfo %s https://raw.githubusercontent.com/mx3L/archivczsk-doplnky/master/commit' % path, self.check_commit_download)
except:
log.logError("Download addons commit failed.")
self.open_archive_screen()
def getSelectedItem(self):
try:
if len(self.lst_items) > 0:
idx = self["menu"].getSelectedIndex()
self.selected_it = self.lst_items[idx]
return self.selected_it
self.selected_it = None
return None
except:
log.logError("Action [getSelectedItem] failed.\n%s"%traceback.format_exc())
pass
