def _doesThemeExist(self,
directory,
checkParent=False,
incAudioThemes=True,
incVideoThemes=True):
log("doesThemeExist: Checking directory: %s" % directory)
# Check for custom theme directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(directory, Settings.getThemeDirectory())
# Check if this directory exists
if not dir_exists(themeDir):
workingPath = directory
# If the path currently ends in the directory separator
# then we need to clear an extra one
if (workingPath[-1] == os.sep) or (workingPath[-1]
== os.altsep):
workingPath = workingPath[:-1]
# If not check to see if we have a DVD VOB
if (os_path_split(workingPath)[1]
== 'VIDEO_TS') or (os_path_split(workingPath)[1]
== 'BDMV'):
# Check the parent of the DVD Dir
themeDir = os_path_split(workingPath)[0]
themeDir = os_path_join(themeDir,
Settings.getThemeDirectory())
directory = themeDir
# Check to see if we need to check the parent directory
if checkParent:
directory = os_path_split(directory)[0]
# check if the directory exists before searching
if dir_exists(directory):
# Generate the regex
audioOnly = False
videoOnly = False
if not incAudioThemes:
videoOnly = True
if not incVideoThemes:
audioOnly = True
themeFileRegEx = Settings.getThemeFileRegEx(audioOnly=audioOnly,
videoOnly=videoOnly)
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeFileRegEx, aFile, re.IGNORECASE)
if m:
log("doesThemeExist: Found match: " + aFile)
return True
# Check if an NFO file exists
nfoFileName = os_path_join(directory, "tvtunes.nfo")
if xbmcvfs.exists(nfoFileName):
log("doesThemeExist: Found match: " + nfoFileName)
return True
return False
def _doesThemeExist(self, directory, checkParent=False, incAudioThemes=True, incVideoThemes=True):
log("doesThemeExist: Checking directory: %s" % directory)
# Check for custom theme directory
if Settings.isThemeDirEnabled():
themeDir = os_path_join(directory, Settings.getThemeDirectory())
# Check if this directory exists
if not dir_exists(themeDir):
workingPath = directory
# If the path currently ends in the directory separator
# then we need to clear an extra one
if (workingPath[-1] == os.sep) or (workingPath[-1] == os.altsep):
workingPath = workingPath[:-1]
# If not check to see if we have a DVD VOB
if (os_path_split(workingPath)[1] == 'VIDEO_TS') or (os_path_split(workingPath)[1] == 'BDMV'):
# Check the parent of the DVD Dir
themeDir = os_path_split(workingPath)[0]
themeDir = os_path_join(themeDir, Settings.getThemeDirectory())
directory = themeDir
# Check to see if we need to check the parent directory
if checkParent:
directory = os_path_split(directory)[0]
# check if the directory exists before searching
if dir_exists(directory):
# Generate the regex
audioOnly = False
videoOnly = False
if not incAudioThemes:
videoOnly = True
if not incVideoThemes:
audioOnly = True
themeFileRegEx = Settings.getThemeFileRegEx(audioOnly=audioOnly, videoOnly=videoOnly)
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeFileRegEx, aFile, re.IGNORECASE)
if m:
log("doesThemeExist: Found match: " + aFile)
return True
# Check if an NFO file exists
nfoFileName = os_path_join(directory, "tvtunes.nfo")
if xbmcvfs.exists(nfoFileName):
log("doesThemeExist: Found match: " + nfoFileName)
return True
return False
def _moveToThemeFolder(self, directory):
log("moveToThemeFolder: path = %s" % directory)
# Handle the case where we have a disk image
if (os_path_split(directory)[1]
== 'VIDEO_TS') or (os_path_split(directory)[1] == 'BDMV'):
directory = os_path_split(directory)[0]
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(Settings.getThemeFileRegEx(directory), aFile,
re.IGNORECASE)
if m:
srcpath = os_path_join(directory, aFile)
log("fetchAllMissingThemes: Found match: %s" % srcpath)
targetpath = os_path_join(directory,
Settings.getThemeDirectory())
# Make sure the theme directory exists
if not dir_exists(targetpath):
try:
xbmcvfs.mkdir(targetpath)
except:
log(
"fetchAllMissingThemes: Failed to create directory: %s"
% targetpath, True, LOGERROR)
break
else:
log("moveToThemeFolder: directory already exists %s" %
targetpath)
# Add the filename to the path
targetpath = os_path_join(targetpath, aFile)
if not xbmcvfs.rename(srcpath, targetpath):
log("moveToThemeFolder: Failed to move file from %s to %s"
% (srcpath, targetpath))
def hasVideoExtras(self, target, dbid, file, title=None):
# If the service is on, then we can just check to see if the overlay image exists
if Settings.isServiceEnabled():
# Get the path where the file exists
rootPath = os_path_join(PROFILE_DIR, target)
if not dir_exists(rootPath):
# Directory does not exist yet, so can't have extras
return False
# Generate the name of the file that the overlay will be copied to
targetFile = os_path_join(rootPath, ("%d.png" % dbid))
if xbmcvfs.exists(targetFile):
return True
# Otherwise, need to do the lookup the old fashioned way of looking for the
# extras files on the file system (This is much slower)
else:
videoExtras = VideoExtrasBase(file, target, title)
# We are only checking for existence of extras, no need for fanart
firstExtraFile = videoExtras.findExtras(True)
del videoExtras
if firstExtraFile:
log("MenuNavigator: Extras found for (%d) %s" % (dbid, file))
return True
return False
def _moveToThemeFolder(self, directory):
log("moveToThemeFolder: path = %s" % directory)
# Handle the case where we have a disk image
if (os_path_split(directory)[1] == 'VIDEO_TS') or (os_path_split(directory)[1] == 'BDMV'):
directory = os_path_split(directory)[0]
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(Settings.getThemeFileRegEx(directory), aFile, re.IGNORECASE)
if m:
srcpath = os_path_join(directory, aFile)
log("fetchAllMissingThemes: Found match: %s" % srcpath)
targetpath = os_path_join(directory, Settings.getThemeDirectory())
# Make sure the theme directory exists
if not dir_exists(targetpath):
try:
xbmcvfs.mkdir(targetpath)
except:
log("fetchAllMissingThemes: Failed to create directory: %s" % targetpath, True, xbmc.LOGERROR)
break
else:
log("moveToThemeFolder: directory already exists %s" % targetpath)
# Add the filename to the path
targetpath = os_path_join(targetpath, aFile)
if not xbmcvfs.rename(srcpath, targetpath):
log("moveToThemeFolder: Failed to move file from %s to %s" % (srcpath, targetpath))
def hasVideoExtras(self, target, dbid, file, title=None):
# If the service is on, then we can just check to see if the overlay image exists
if Settings.isServiceEnabled():
# Get the path where the file exists
rootPath = os_path_join(PROFILE_DIR, target)
if not dir_exists(rootPath):
# Directory does not exist yet, so can't have extras
return False
# Generate the name of the file that the overlay will be copied to
targetFile = os_path_join(rootPath, ("%d.png" % dbid))
if xbmcvfs.exists(targetFile):
return True
# Otherwise, need to do the lookup the old fashioned way of looking for the
# extras files on the file system (This is much slower)
else:
videoExtras = VideoExtrasBase(file, target, title)
# We are only checking for existence of extras, no need for fanart
firstExtraFile = videoExtras.findExtras(True)
del videoExtras
if firstExtraFile:
log("MenuNavigator: Extras found for (%d) %s" % (dbid, file))
return True
return False
def _createTargetPath(self, target, dbid, postfix=''):
# Get the path where the file exists
rootPath = os_path_join(PROFILE_DIR, target)
if not dir_exists(rootPath):
# Directory does not exist yet, create one
xbmcvfs.mkdirs(rootPath)
# Generate the name of the file that the overlay will be copied to
targetFile = os_path_join(rootPath, ("%d%s.png" % (dbid, postfix)))
return targetFile
def _createTargetPath(self, target, dbid, postfix=''):
# Get the path where the file exists
rootPath = os_path_join(PROFILE_DIR, target)
if not dir_exists(rootPath):
# Directory does not exist yet, create one
xbmcvfs.mkdirs(rootPath)
# Generate the name of the file that the overlay will be copied to
targetFile = os_path_join(rootPath, ("%d%s.png" % (dbid, postfix)))
return targetFile
def _getThemeFiles(self, directory, extensionOnly=False):
# First read from the NFO file if it exists
nfoRead = NfoReader(directory, self.debug_logging_enabled)
themeFiles = nfoRead.getThemeFiles()
# Get the theme directories that are referenced and process the data in them
for nfoDir in nfoRead.getThemeDirs():
# Do not want the theme keyword if looking at an entire directory
themeFiles = themeFiles + self._getThemeFiles(nfoDir, True)
del nfoRead
themeRegex = Settings.getThemeFileRegEx(directory, extensionOnly, self.audioOnly)
log("ThemeFiles: Searching %s for %s" % (directory, themeRegex), self.debug_logging_enabled)
# Make sure that the path does not point to a plugin, as we are checking the
# file-system for themes, not plugins. This can be the case with Emby
if "plugin://" in directory:
log("ThemeFiles: Plugin paths do not support theme files: %s" % directory, self.debug_logging_enabled)
else:
# check if the directory exists before searching
if dir_exists(directory):
dirs, files = list_dir(directory)
for aFile in files:
m = re.search(themeRegex, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found match: %s" % path, self.debug_logging_enabled)
# Add the theme file to the list
themeFiles.append(path)
# Check to see if any themes were found, and if not see if we should try
# and use a trailer file instead
if (len(themeFiles) < 1) and (not self.audioOnly) and (not extensionOnly) and Settings.useTrailers():
trailerRegEx = Settings.getTrailerFileRegEx()
for aFile in files:
m = re.search(trailerRegEx, aFile, re.IGNORECASE)
if m:
path = os_path_join(directory, aFile)
log("ThemeFiles: Found trailer match: %s" % path, self.debug_logging_enabled)
# Add the trailer file to the list
themeFiles.append(path)
return themeFiles
def _getPlaylist(self):
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
# Note: The playlist clear option seems to impact all playlist settings,
# so will remove the repeat settings on a playlist that is currently playing,
# not just this instance - a bit nasty, but not much we can do about it
playlist.clear()
# Check to see if we should be using a video from the schedule
scheduleEntry = self.scheduler.getScheduleEntry()
if scheduleEntry != -1:
# There is an item scheduled, so check to see if the item has actually changed
if scheduleEntry == self.currentScheduleItem:
return None
# Set the entry we are about to play
self.currentScheduleItem = scheduleEntry
# Get the actual video file that should be played
scheduledVideo = self.scheduler.getScheduleVideo(scheduleEntry)
# Do a quick check to see if the video exists
if xbmcvfs.exists(scheduledVideo):
log("Screensaver video for scheduled item %d is: %s" % (scheduleEntry, scheduledVideo))
playlist.add(scheduledVideo)
# Check if we are showing all the videos in a given folder
elif Settings.isFolderSelection():
videosFolder = Settings.getScreensaverFolder()
# Check if we are dealing with a Folder of videos
if videosFolder not in [None, ""]:
if dir_exists(videosFolder):
self.currentScheduleItem = -1
files = self._getAllFilesInDirectory(videosFolder)
# Check if we are limiting to a single folder per session
if Settings.isLimitSessionToSingleCollection():
# Select just one file at random
singleVideo = random.choice(files)
# Check if this file is part of a collection
justFilename = (os_path_split(singleVideo))[-1]
collectionCtrl = CollectSets()
collectionVideos = collectionCtrl.getFilesInSameCollection(justFilename)
del collectionCtrl
# If it is part of a collection, then limit to only files in
# this collection
if len(collectionVideos) > 0:
log("Screensaver restricting to collection containing %s" % singleVideo)
# Check each of the videos to see which are in the collection
collectionFileList = []
for aFile in files:
# Get just the filename
aFilename = (os_path_split(aFile))[-1]
if aFilename in collectionVideos:
log("Screensaver including collection video %s" % aFile)
collectionFileList.append(aFile)
else:
log("Screensaver excluding non collection video %s" % aFile)
else:
log("Screensaver restricting to directory containing %s" % singleVideo)
# Not in a collection, so just gather the files in the same directory
# Get the directory that file was part of
parentPath = (os_path_split(singleVideo))[0]
# Now only select videos from that directory
files = self._getAllFilesInDirectory(parentPath, False)
# Now shuffle the playlist to ensure that if there are more
# than one video a different one starts each time
random.shuffle(files)
for vidFile in files:
log("Screensaver video in directory is: %s" % vidFile)
playlist.add(vidFile)
else:
# Must be dealing with a single file
videoFile = Settings.getScreensaverVideo()
# Check to make sure the screensaver video file exists
if videoFile not in [None, ""]:
if xbmcvfs.exists(videoFile):
self.currentScheduleItem = -1
log("Screensaver video is: %s" % videoFile)
playlist.add(videoFile)
# If there are no videos in the playlist yet, then display an error
if playlist.size() < 1:
errorLocation = Settings.getScreensaverVideo()
if Settings.isFolderSelection():
errorLocation = Settings.getScreensaverFolder()
log("No Screensaver file set or not valid %s" % errorLocation)
cmd = 'Notification("{0}", "{1}", 3000, "{2}")'.format(ADDON.getLocalizedString(32300).encode('utf-8'), errorLocation, ADDON.getAddonInfo('icon'))
xbmc.executebuiltin(cmd)
return None
return playlist
def _getPlaylist(self):
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
# Note: The playlist clear option seems to impact all playlist settings,
# so will remove the repeat settings on a playlist that is currently playing,
# not just this instance - a bit nasty, but not much we can do about it
playlist.clear()
# Check to see if we should be using a video from the schedule
scheduleEntry = self.scheduler.getScheduleEntry()
if scheduleEntry != -1:
# There is an item scheduled, so check to see if the item has actually changed
if scheduleEntry == self.currentScheduleItem:
return None
# Set the entry we are about to play
self.currentScheduleItem = scheduleEntry
# Get the actual video file that should be played
scheduledVideo = self.scheduler.getScheduleVideo(scheduleEntry)
# Do a quick check to see if the video exists
if xbmcvfs.exists(scheduledVideo):
log("Screensaver video for scheduled item %d is: %s" %
(scheduleEntry, scheduledVideo))
playlist.add(scheduledVideo)
# Check if we are showing all the videos in a given folder
elif Settings.isFolderSelection():
videosFolder = Settings.getScreensaverFolder()
# Check if we are dealing with a Folder of videos
if videosFolder not in [None, ""]:
if dir_exists(videosFolder):
self.currentScheduleItem = -1
files = self._getAllFilesInDirectory(videosFolder)
# Check if we are limiting to a single folder per session
if Settings.isLimitSessionToSingleCollection():
# Select just one file at random
singleVideo = random.choice(files)
# Check if this file is part of a collection
justFilename = (os_path_split(singleVideo))[-1]
collectionCtrl = CollectSets()
collectionVideos = collectionCtrl.getFilesInSameCollection(
justFilename)
del collectionCtrl
# If it is part of a collection, then limit to only files in
# this collection
if len(collectionVideos) > 0:
log("Screensaver restricting to collection containing %s"
% singleVideo)
# Check each of the videos to see which are in the collection
collectionFileList = []
for aFile in files:
# Get just the filename
aFilename = (os_path_split(aFile))[-1]
if aFilename in collectionVideos:
log("Screensaver including collection video %s"
% aFile)
collectionFileList.append(aFile)
else:
log("Screensaver excluding non collection video %s"
% aFile)
else:
log("Screensaver restricting to directory containing %s"
% singleVideo)
# Not in a collection, so just gather the files in the same directory
# Get the directory that file was part of
parentPath = (os_path_split(singleVideo))[0]
# Now only select videos from that directory
files = self._getAllFilesInDirectory(
parentPath, False)
# Now shuffle the playlist to ensure that if there are more
# than one video a different one starts each time
random.shuffle(files)
for vidFile in files:
log("Screensaver video in directory is: %s" % vidFile)
playlist.add(vidFile)
else:
# Must be dealing with a single file
videoFile = Settings.getScreensaverVideo()
# Check to make sure the screensaver video file exists
if videoFile not in [None, ""]:
if xbmcvfs.exists(videoFile):
self.currentScheduleItem = -1
log("Screensaver video is: %s" % videoFile)
playlist.add(videoFile)
# If there are no videos in the playlist yet, then display an error
if playlist.size() < 1:
errorLocation = Settings.getScreensaverVideo()
if Settings.isFolderSelection():
errorLocation = Settings.getScreensaverFolder()
log("No Screensaver file set or not valid %s" % errorLocation)
cmd = 'Notification("{0}", "{1}", 3000, "{2}")'.format(
ADDON.getLocalizedString(32300).encode('utf-8'), errorLocation,
ADDON.getAddonInfo('icon'))
xbmc.executebuiltin(cmd)
return None
return playlist
from resources.lib.settings import log
from resources.lib.settings import dir_exists
from resources.lib.settings import os_path_join
ADDON = xbmcaddon.Addon(id='script.audiobooks')
#########################
# Main
#########################
if __name__ == '__main__':
log("AudioBookCoverCleanup: Cover cache cleanup called (version %s)" %
ADDON.getAddonInfo('version'))
coverCache = Settings.getCoverCacheLocation()
if dir_exists(coverCache):
try:
log("AudioBookCoverCleanup: Checking cache files %s" % coverCache)
# Remove the jpg and png files in the directory first
dirs, files = xbmcvfs.listdir(coverCache)
for aFile in files:
log("AudioBookCoverCleanup: Removing file %s" % aFile)
if aFile.endswith('.jpg') or aFile.endswith(
'.jpeg') or aFile.endswith('.png'):
coverFile = os_path_join(coverCache, aFile)
xbmcvfs.delete(coverFile)
# Now remove the actual directory
xbmcvfs.rmdir(coverCache)
except:
def _loadNfoInfo(self, directory):
# Find out the name of the NFO file
nfoFileName = os_path_join(directory, "tvtunes.nfo")
# If this is a plugin path, then don't try and get the NFO file
if "plugin://" in nfoFileName:
log("NfoReader: Plugin paths do not support NFO files: %s" % nfoFileName, self.debug_logging_enabled)
return
log("NfoReader: Searching for NFO file: %s" % nfoFileName, self.debug_logging_enabled)
# Return False if file does not exist
if not xbmcvfs.exists(nfoFileName):
log("NfoReader: No NFO file found: %s" % nfoFileName, self.debug_logging_enabled)
return False
returnValue = False
checkThemeExists = False
try:
# Need to first load the contents of the NFO file into
# a string, this is because the XML File Parse option will
# not handle formats like smb://
nfoFile = xbmcvfs.File(nfoFileName, 'r')
nfoFileStr = nfoFile.read()
nfoFile.close()
# Create an XML parser
nfoXml = ET.ElementTree(ET.fromstring(nfoFileStr))
rootElement = nfoXml.getroot()
log("NfoReader: Root element is = %s" % rootElement.tag, self.debug_logging_enabled)
# Check which format if being used
if rootElement.tag == "tvtunes":
log("NfoReader: TvTunes format NFO detected", self.debug_logging_enabled)
# <tvtunes>
# <file>theme.mp3</file>
# <directory>c:\my\themes</directory>
# <playlistfile>playlist.m3u</playlistfile>
# <excludeFromScreensaver/>
# </tvtunes>
# There could be multiple file entries, so loop through all of them
for fileElem in nfoXml.findall('file'):
file = None
if fileElem is not None:
file = fileElem.text
if (file is not None) and (file != ""):
if file.startswith('..') or (("/" not in file) and ("\\" not in file)):
# Make it a full path if it is not already
file = os_path_join(directory, file)
log("NfoReader: file = %s" % file, self.debug_logging_enabled)
self.themeFiles.append(file)
# There could be multiple directory entries, so loop through all of them
for dirElem in nfoXml.findall('directory'):
dir = None
if dirElem is not None:
dir = dirElem.text
if (dir is not None) and (dir != ""):
if dir.startswith('..') or (("/" not in dir) and ("\\" not in dir)):
# Make it a full path if it is not already
dir = os_path_join(directory, dir)
log("NfoReader: directory = %s" % dir, self.debug_logging_enabled)
self.themeDirs.append(dir)
# Check for the playlist files
for playlistFileElem in nfoXml.findall('playlistfile'):
playlistFile = None
if playlistFileElem is not None:
playlistFile = playlistFileElem.text
self._addFilesFromPlaylist(playlistFile, directory)
# Check if this directory should be excluded from the screensaver
for playlistFileElem in nfoXml.findall('excludeFromScreensaver'):
self.excludeFromScreensaver = True
# Check if there may be theme paths that do not exist and we should
# check each theme to see if they they can be accessed
for playlistFileElem in nfoXml.findall('checkThemeExists'):
checkThemeExists = True
returnValue = True
else:
self.displayName = None
self.orderKey = None
log("NfoReader: Unknown NFO format", self.debug_logging_enabled)
del nfoXml
except:
log("NfoReader: Failed to process NFO: %s" % nfoFileName, True, LOGERROR)
log("NfoReader: %s" % traceback.format_exc(), True, LOGERROR)
returnValue = False
# Not that the entire NFO file has been read, see if we need to verify
# that each of the themes exists
if checkThemeExists:
# Check the theme files to make sure they all exist
existingThemeFiles = []
for nfoThemeFile in self.themeFiles:
if xbmcvfs.exists(nfoThemeFile):
existingThemeFiles.append(nfoThemeFile)
else:
log("NfoReader: File does not exists, removing %s" % nfoThemeFile, self.debug_logging_enabled)
self.themeFiles = existingThemeFiles
# Check the theme directories to make sure they all exist
existingThemeDir = []
for nfoThemeDir in self.themeDirs:
if dir_exists(nfoThemeDir):
existingThemeDir.append(nfoThemeDir)
else:
log("NfoReader: Directory does not exists, removing %s" % nfoThemeDir, self.debug_logging_enabled)
self.themeDirs = existingThemeDir
return returnValue
log("AudioBookService: Detected library path as %s" % libPath)
Settings.setFFmpegLibraryLocation(libPath)
# If the libraries are there, enable them as the default
defaultFFmpegSetting = Settings.FFMPEG_LIB
# Now check to see if we have one of the FFmpeg bundles installed
if xbmc.getCondVisibility('System.HasAddon(script.module.ffmpeg)') != 1:
log("AudioBookService: No script.module.ffmpeg bundle detected")
else:
log("AudioBookService: script.module.ffmpeg bundle detected")
ffmpegModule = xbmcaddon.Addon(id='script.module.ffmpeg')
modulePath = ffmpegModule.getAddonInfo('path')
log("AudioBookService: FFmpeg addon path is: %s" % modulePath)
# Make sure the addon path exists
if not dir_exists(modulePath):
log("AudioBookService: FFmpeg addon path does not exist: %s" % modulePath)
else:
# Check if there is library path available
libPath = os_path_join(modulePath, "libs")
if not dir_exists(libPath):
log("AudioBookService: No libraries included in FFmpeg bundle")
else:
log("AudioBookService: Setting library path to: %s" % libPath)
Settings.setFFmpegLibraryLocation(libPath)
# If the libraries are there, enable them as the default
defaultFFmpegSetting = Settings.FFMPEG_LIB
# Check if there is an executable available
execPath = os_path_join(modulePath, "exec")
if not dir_exists(execPath):
from resources.lib.settings import log
from resources.lib.settings import dir_exists
from resources.lib.settings import os_path_join
ADDON = xbmcaddon.Addon(id='script.audiobooks')
#########################
# Main
#########################
if __name__ == '__main__':
log("AudioBookCoverCleanup: Cover cache cleanup called (version %s)" % ADDON.getAddonInfo('version'))
coverCache = Settings.getCoverCacheLocation()
if dir_exists(coverCache):
try:
log("AudioBookCoverCleanup: Checking cache files %s" % coverCache)
# Remove the jpg and png files in the directory first
dirs, files = xbmcvfs.listdir(coverCache)
for aFile in files:
log("AudioBookCoverCleanup: Removing file %s" % aFile)
if aFile.endswith('.jpg') or aFile.endswith('.jpeg') or aFile.endswith('.png'):
coverFile = os_path_join(coverCache, aFile)
xbmcvfs.delete(coverFile)
# Now remove the actual directory
xbmcvfs.rmdir(coverCache)
except:
log("AudioBookCoverCleanup: %s" % traceback.format_exc(), xbmc.LOGERROR)