kodi beim Start programmieren

0.00245474902034 - CleanLibrary
1.86549916029    - CleanLibrary finsihed


1.86640293587    - UpdateLibrary
1.87585681408    - UpdateLibrary finsihed


1.87618554457    - RunAddon
1.87646327051    - RunAddon finsihed   (sollte eigentlich 10 Sek. schlafen)


1.87680599614    - exportlibrary
2.32635659638    - exportlibrary finsihed


2.326792312      - finsihed

import xbmc
import time
import os


# -----------------------------------------------------------------------------
# Settings area


artwork_log = xbmc.translatePath('special://userdata/addon_data/script.artwork.downloader/downloadreport.txt')
maximum_wait_time = 30 # in seconds
sleep_time = 5 # in seconds


# -----------------------------------------------------------------------------
# main


if os.path.isfile(artwork_log):
    os.remove(artwork_log)


current_wait_time = 0 # in seconds
maximum_wait_time_reached = False


xbmc.executebuiltin('CleanLibrary(video)', True)
xbmc.executebuiltin('UpdateLibrary(video)', True)
xbmc.executebuiltin('RunAddon(script.artwork.downloader)')


while not (os.path.isfile(artwork_log) or maximum_wait_time_reached):
    time.sleep(sleep_time)
    current_wait_time += sleep_time
    maximum_wait_time_reached = True if current_wait_time >= maximum_wait_time else False


if not maximum_wait_time_reached:
    xbmc.executebuiltin('exportlibrary(video,true,thumbs=true,overwrite=false,actorthumbs=false)', True)

import xbmc
import time
import os


class _MONITOR(xbmc.Monitor):


    artwork_log = xbmc.translatePath('special://userdata/addon_data/script.artwork.downloader/downloadreport.txt')


    def __init__(self, _maximum_wait_time=60, _sleep_time=10):
        super(_MONITOR, self).__init__()
        self.maximum_wait_time = _maximum_wait_time
        self.sleep_time = _sleep_time


        self.action_finished = False
        # remove old download report file if exists
        if os.path.isfile(self.artwork_log):
            os.remove(self.artwork_log)


        self.start()


    def onCleanFinished(self, library):
        # let's start update library
        xbmc.executebuiltin('UpdateLibrary(music)', True)


    def onScanFinished(self, library):
        # now it is time for run addon
        self.run_addon()


    def run_addon(self):
        maximum_wait_time_reached = False
        current_wait_time = 0
        xbmc.executebuiltin('RunAddon(script.artwork.downloader)')


        while not (os.path.isfile(self.artwork_log) or maximum_wait_time_reached):
            time.sleep(self.sleep_time)
            current_wait_time += self.sleep_time
            maximum_wait_time_reached = True if current_wait_time >= self.maximum_wait_time else False


        if not maximum_wait_time_reached:
            xbmc.executebuiltin('exportlibrary(video,true,thumbs=true,overwrite=false,actorthumbs=false)', True)
        self.action_finished = True


    def start(self):
        # clean library starts
        xbmc.executebuiltin('CleanLibrary(video)', False)


# -----------------------------------------------------------------------------
# main


_monitor = _MONITOR(30,5)  # <<--- 1st value maximum_wait_time, 2nd value sleep_time
while not (_monitor.abortRequested() or _monitor.action_finished):
    _monitor.waitForAbort(1)


del _monitor

import xbmc
import xbmcgui
import xbmcvfs
import time
import os


USER_ADDON_DIRECTORY = xbmc.translatePath('special://userdata/addon_data')
LOG_DIRECTORY = os.path.join(USER_ADDON_DIRECTORY, __xbmcaddonid__)
LOG_FILE = 'kodi_user.[definition='1','0']log[/definition]'
FULL_LOG_FILE_PATH = os.path.join(LOG_DIRECTORY, LOG_FILE)


# settings - modify to your needs
MAXIMUM_WAIT_TIME = 60 # used for RunAddon calls
SLEEP_TIME = 5         # -"-
DIALOG_AUTO_CLOSE_TIME = 10


# -----------------------------------------------------------------------------
# logging function


def logger(msg, file=FULL_LOG_FILE_PATH):
    with open(file, 'a') as f:
        f.write('{} - {}\n'.format(time.ctime(), msg))




# -----------------------------------------------------------------------------
# subclass yesno dialog because we want True in case of autoclose


class _Dialog(xbmcgui.Dialog):


    def __init__(self):
        super(_Dialog,self).__init__()


    def yesno(self, heading='', line1='', line2='', line3='', autoclose=0):
        start = time.time()
        result = super(_Dialog, self).yesno(heading, line1, line2, line3, nolabel='abort', yeslabel='ok', autoclose=autoclose*1000)
        duration = (time.time() - start)
        return True if autoclose > 0 and duration >= autoclose else result


# -----------------------------------------------------------------------------
# some predefined exceptions


class BackupError(Exception):
    def __init__(self, _message):
        self.message = _message
    def __str__(self):
        return repr(self.message)


class PrerequisiteError(Exception):
    def __init__(self, _message):
        self.message = _message
    def __str__(self):
        return repr(self.message)


class TimeOutError(Exception):
    def __init__(self, _message):
        self.message = "{} didn't finish on time".format(_message)
    def __str__(self):
        return repr(self.message)
# -----------------------------------------------------------------------------
# subclass xbmc.Monitor in order to get callbacks executed


class _MONITOR(xbmc.Monitor):


    task_is_still_running = False
    task_event_waiting_for = ''
    rollback_needed = False
    error_is_set = False
    exception_object = None


    def __init__(self, _maximum_wait_time, _sleep_time):
        super(_MONITOR, self).__init__()
        self.maximum_wait_time = _maximum_wait_time*1000
        self.sleep_time = _sleep_time*1000




# -----------------------------------------------------------------------------
# callback
# it is needed to use either waitForAbort or xmbc.sleep in the
# main loop function of the class otherwise they won't get called ! ????


    def onNotification(self, sender, method, data):
        if (sender=='xbmc') and (self.task_event_waiting_for==method):
            self.task_is_still_running = False




# -----------------------------------------------------------------------------
# decorator used to init some variables, get the method which indicates finished
# and does logging for every task starting


    def mark_running(event_waiting_for=''):
        def wrapper(func):
            def function_call(self):
                self.task_is_still_running = True
                self.error_handler(reset=True)
                self.task_event_waiting_for = event_waiting_for
                logger('%s is running' % func.__name__)
                return func(self)
            return function_call
        return wrapper




# -----------------------------------------------------------------------------
# instead of try...except block errors should uses error_handler function
# to give the choice to continue if user decides


    def error_handler(self, _exception_object=None ,reset=False):
        self.error_is_set = False if reset else True
        self.exception_object = None if reset else _exception_object




# -----------------------------------------------------------------------------
# start of the batch tasks
# mark_running decorator does not get a finishing method means
# the function needs to handle task_is_still_running itself.


    @mark_running()
    def check_prerequisite(self):
        # simulate doing stuff
        # this could be things like checking if network is available, nas is on ...
        if _Dialog().yesno('Checking prerequisite','Please wait... Press abort to simulate error', autoclose=5):
            logger('check_prerequisite is ok')
        else:
            self.error_handler(PrerequisiteError('No network'))
        self.task_is_still_running = False




# -----------------------------------------------------------------------------


    @mark_running()
    def backup_library(self):
        # simulate doing stuff
        # in reality this isn't easy to solve as
        # a) there is no method/property which returns the database files in use and
        # b) KODI holds the databases open at runtime and in order
        #    to make a proper backup the database files needs to be closed
        # While using an KODI addon the only solution might be to do a sql dump
        if _Dialog().yesno('Backup database','Please wait... Press abort to simulate error', autoclose=3):
            logger('backup is ok')
        else:
            self.error_handler(BackupError('No space left on device'))
        self.task_is_still_running = False




# -----------------------------------------------------------------------------
# decorator gets the method means, onNotification checks if this method is
# called and sets task_is_still_running=False


    @mark_running('VideoLibrary.OnCleanFinished')
    def clean_library(self):
        xbmc.executebuiltin('CleanLibrary(video)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------


    @mark_running('VideoLibrary.OnScanFinished')
    def update_library(self):
        xbmc.executebuiltin('UpdateLibrary(video)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------


    @mark_running()
    def run_artwork_downloader(self):
        artwork_log = xbmc.translatePath('special://userdata/addon_data/script.artwork.downloader/downloadreport.txt')
        # remove old download report file if exists
        if xbmcvfs.exists(artwork_log):
            xbmcvfs.delete(artwork_log)


        maximum_wait_time_reached = False
        current_wait_time = 0
        xbmc.executebuiltin('RunAddon(script.artwork.downloader)')


        # now check if the file has been recreated, which indicates artwork downloader has finished its task.
        while not (xbmcvfs.exists(artwork_log) or maximum_wait_time_reached):
            xbmc.sleep(self.sleep_time)
            current_wait_time += self.sleep_time
            maximum_wait_time_reached = True if current_wait_time >= self.maximum_wait_time else False


        if maximum_wait_time_reached:
            self.error_handler(TimeOutError("RunAddon(script.artwork.downloader)"))


        self.task_is_still_running = False




# -----------------------------------------------------------------------------


    @mark_running('VideoLibrary.OnExport')
    def export_library(self):
        xbmc.executebuiltin('exportlibrary(video,true,thumbs=true,overwrite=false,actorthumbs=false)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------
# call each tasks in a generator function
# the yield does the magic, once executed it returns control back to
# the calling process which needs to call __next__ to get the next function executed.


    def batch_processing(self):
        self.check_prerequisite(); yield
        self.backup_library(); yield
        self.clean_library(); yield
        self.update_library(); yield
        self.run_artwork_downloader(); yield
        self.export_library(); yield




# -----------------------------------------------------------------------------
# revert changes
# in reality here goes the code to revert things changed


    def rollback(self):
        logger('start rolling back')




# -----------------------------------------------------------------------------
# entry point to start batch processing
# this should be the only place within the class which does try...except
# in order to provide some kind of continue functionality


    def start(self):
        logger('start batch processing')


        try:
            # this for loop is basically calling __next__ under the hood
            for _ in self.batch_processing():
                # looping until the flag is reset
                while self.task_is_still_running:
                    # to avoid gui freezes
                    self.waitForAbort(1)


                if self.error_is_set:
                    # decide if batch processing should be continued,
                    # will be auto answered to False after autoclose timeout
                    if not xbmcgui.Dialog().yesno("Would you continue anyway?",
                                                  line1=self.exception_object.message,
                                                  autoclose=DIALOG_AUTO_CLOSE_TIME*1000):


                        # do not continue - raise the exception and
                        # jump to the needed except block
                        raise self.exception_object


                logger('  {}'.format('and finished' if not self.error_is_set else self.exception_object.message))


        except PrerequisiteError as e:
            logger('PrerequisiteError::{}'.format(e.message))


        except BackupError as e:
            logger('BackupError::{}'.format(e.message))


        # uncomment self.rollback_needed = True if rollback is needed
        except TimeOutError as e:
            logger('TimeOutError::{}'.format(e.message))
            # self.rollback_needed = True


        except Exception as e:
            # inform user about problem - allow to ignore rollback
            if xbmcgui.Dialog().yesno("Unhandled exception occurred: Rollback needed?",
                                      line1=e.message,
                                      autoclose=DIALOG_AUTO_CLOSE_TIME*1000):


                logger('Unhandled exception:{}'.format(e.message))
                self.rollback_needed = True
        finally:
            # if rollback flag is set call the rollback function
            if self.rollback_needed:
                self.rollback()
            logger('batch processing finished')




# -----------------------------------------------------------------------------
# main


def main():
    logger('*'*30)
    logger('start main')
    if not xbmcvfs.exists(LOG_DIRECTORY):
        xbmcvfs.mkdirs(LOG_DIRECTORY) # create the directory if it doesn't exist


    batch_processor = _MONITOR(MAXIMUM_WAIT_TIME,SLEEP_TIME)
    batch_processor.start()


    try:
        del batch_processor
    except:
        pass
    logger('main finished')


main()